def buildExtSliceNode(provider, node, source_ref): elements = [] for dim in node.slice.dims: dim_kind = getKind(dim) if dim_kind == "Slice": lower = buildNode(provider, dim.lower, source_ref, True) upper = buildNode(provider, dim.upper, source_ref, True) step = buildNode(provider, dim.step, source_ref, True) element = makeExpressionBuiltinSlice(start=lower, stop=upper, step=step, source_ref=source_ref) elif dim_kind == "Ellipsis": element = ExpressionConstantEllipsisRef(source_ref=source_ref) elif dim_kind == "Index": element = buildNode(provider=provider, node=dim.value, source_ref=source_ref) else: assert False, dim elements.append(element) return makeExpressionMakeTupleOrConstant(elements=elements, user_provided=True, source_ref=source_ref)
def createPython3NamespacePath(package, source_ref): return StatementAssignmentVariableName( provider=package, variable_name="__path__", source=ExpressionCallNoKeywords( called=ExpressionImportName( module=makeExpressionImportModuleFixed( module_name="_frozen_importlib" if python_version < 0x350 else "_frozen_importlib_external", source_ref=source_ref, ), import_name="_NamespacePath", level=0, source_ref=source_ref, ), args=makeExpressionMakeTupleOrConstant( elements=( makeConstantRefNode( constant=package.getFullName().asString(), user_provided=True, source_ref=source_ref, ), getNameSpacePathExpression(package=package, source_ref=source_ref), makeConstantRefNode(constant=None, source_ref=source_ref), ), user_provided=True, source_ref=source_ref, ), source_ref=source_ref, ), source_ref=source_ref, )
def _buildBasesTupleCreationNode(provider, elements, source_ref): """For use in Python3 classes for the bases.""" for element in elements: if getKind(element) == "Starred": return buildTupleUnpacking(provider=provider, elements=elements, source_ref=source_ref) return makeExpressionMakeTupleOrConstant( elements=buildNodeList(provider, elements, source_ref), user_provided=True, source_ref=source_ref, )
def _makeCall(module_name, import_name, attribute_name, source_ref, *args): return ExpressionCallNoKeywords( called=makeExpressionAttributeLookup( expression=makeExpressionImportModuleNameHard( module_name=module_name, import_name=import_name, source_ref=source_ref ), attribute_name=attribute_name, source_ref=source_ref, ), args=makeExpressionMakeTupleOrConstant( elements=args, user_provided=True, source_ref=source_ref ), source_ref=source_ref, )
def buildTupleCreationNode(provider, node, source_ref): if python_version >= 300: for element in node.elts: if getKind(element) == "Starred": if python_version < 350: _raiseStarredSyntaxError(element, source_ref) else: return buildTupleUnpacking(provider=provider, elements=node.elts, source_ref=source_ref) return makeExpressionMakeTupleOrConstant( elements=buildNodeList(provider, node.elts, source_ref), user_provided=True, source_ref=source_ref, )
def makeCallNode(called, *args, **kwargs): source_ref = args[-1] if len(args) > 1: args = makeExpressionMakeTupleOrConstant( elements=args[:-1], user_provided=True, source_ref=source_ref ) else: args = None if kwargs: kwargs = makeDictCreationOrConstant2( keys=tuple(kwargs.keys()), values=tuple(kwargs.values()), source_ref=source_ref, ) else: kwargs = None return makeExpressionCall( called=called, args=args, kw=kwargs, source_ref=source_ref )
def _buildSetUnpacking(provider, elements, source_ref): helper_args = [] for element in elements: # We could be a lot cleverer about the tuples for non-starred # arguments, but lets get this to work first. And then rely on # future optimization to inline the list unpacking helper in a # way that has the same effect. if getKind(element) == "Starred": helper_args.append(buildNode(provider, element.value, source_ref)) else: helper_args.append( makeExpressionMakeTupleOrConstant( elements=(buildNode(provider, element, source_ref), ), user_provided=True, source_ref=source_ref, )) result = ExpressionFunctionCall( function=ExpressionFunctionCreation( function_ref=ExpressionFunctionRef( function_body=getSetUnpackingHelper(), source_ref=source_ref), defaults=(), kw_defaults=None, annotations=None, source_ref=source_ref, ), values=(makeExpressionMakeTuple(helper_args, source_ref), ), source_ref=source_ref, ) result.setCompatibleSourceReference( helper_args[-1].getCompatibleSourceReference()) return result
def _makeCallNode( called, positional_args, keys, values, list_star_arg, dict_star_arg, source_ref ): # Many variables, but only to cover the many complex call cases. if list_star_arg is None and dict_star_arg is None: result = makeExpressionCall( called=called, args=makeExpressionMakeTupleOrConstant( elements=positional_args, user_provided=True, source_ref=source_ref, ), kw=makeExpressionMakeDictOrConstant( makeExpressionPairs(keys=keys, values=values), user_provided=True, source_ref=source_ref, ), source_ref=source_ref, ) # Bug compatible line numbers before Python 3.8 if python_version < 0x380: if values: result.setCompatibleSourceReference( source_ref=values[-1].getCompatibleSourceReference() ) elif positional_args: result.setCompatibleSourceReference( source_ref=positional_args[-1].getCompatibleSourceReference() ) return result else: # Dispatch to complex helper function for each case. These do # re-formulation of complex calls according to developer manual. key = ( bool(positional_args), bool(keys), list_star_arg is not None, dict_star_arg is not None, ) table = { (True, True, True, False): getFunctionCallHelperPosKeywordsStarList, (True, False, True, False): getFunctionCallHelperPosStarList, (False, True, True, False): getFunctionCallHelperKeywordsStarList, (False, False, True, False): getFunctionCallHelperStarList, (True, True, False, True): getFunctionCallHelperPosKeywordsStarDict, (True, False, False, True): getFunctionCallHelperPosStarDict, (False, True, False, True): getFunctionCallHelperKeywordsStarDict, (False, False, False, True): getFunctionCallHelperStarDict, (True, True, True, True): getFunctionCallHelperPosKeywordsStarListStarDict, (True, False, True, True): getFunctionCallHelperPosStarListStarDict, (False, True, True, True): getFunctionCallHelperKeywordsStarListStarDict, (False, False, True, True): getFunctionCallHelperStarListStarDict, } get_helper = table[key] helper_args = [called] if positional_args: helper_args.append( makeExpressionMakeTupleOrConstant( elements=positional_args, user_provided=True, source_ref=source_ref, ) ) # Order of evaluation changed in Python3.5. if python_version >= 0x350 and list_star_arg is not None: helper_args.append(list_star_arg) if keys: helper_args.append( makeExpressionMakeDictOrConstant( pairs=makeExpressionPairs(keys=keys, values=values), user_provided=True, source_ref=source_ref, ) ) # Order of evaluation changed in Python3.5. if python_version < 0x350 and list_star_arg is not None: helper_args.append(list_star_arg) if dict_star_arg is not None: helper_args.append(dict_star_arg) result = ExpressionFunctionCall( function=ExpressionFunctionCreation( function_ref=ExpressionFunctionRef( function_body=get_helper(), source_ref=source_ref ), defaults=(), kw_defaults=None, annotations=None, source_ref=source_ref, ), values=helper_args, source_ref=source_ref, ) # Bug compatible line numbers before Python 3.8 if python_version < 0x380: result.setCompatibleSourceReference( source_ref=helper_args[-1].getCompatibleSourceReference() ) return result
def buildClassNode2(provider, node, source_ref): # This function is the Python2 special case with special re-formulation as # according to developer manual, and it's very detailed, pylint: disable=too-many-locals class_statement_nodes, class_doc = extractDocFromBody(node) function_body = ExpressionClassBody(provider=provider, name=node.name, doc=class_doc, source_ref=source_ref) parent_module = provider.getParentModule() code_object = CodeObjectSpec( co_name=node.name, co_kind="Class", co_varnames=(), co_freevars=(), co_argcount=0, co_posonlyargcount=0, co_kwonlyargcount=0, co_has_starlist=False, co_has_stardict=False, co_filename=parent_module.getRunTimeFilename(), co_lineno=source_ref.getLineNumber(), future_spec=parent_module.getFutureSpec(), ) body = buildFrameNode( provider=function_body, nodes=class_statement_nodes, code_object=code_object, source_ref=source_ref, ) if body is not None: # The frame guard has nothing to tell its line number to. body.source_ref = source_ref.atInternal() locals_scope = function_body.getLocalsScope() # The class body is basically a function that implicitly, at the end # returns its locals and cannot have other return statements contained, and # starts out with a variables "__module__" and potentially "__doc__" set. statements = [ StatementSetLocalsDictionary(locals_scope=locals_scope, source_ref=source_ref), StatementAssignmentVariableName( provider=function_body, variable_name="__module__", source=ExpressionModuleAttributeNameRef( variable=provider.getParentModule().getVariableForReference( "__name__"), source_ref=source_ref, ), source_ref=source_ref.atInternal(), ), ] if class_doc is not None: statements.append( StatementAssignmentVariableName( provider=function_body, variable_name="__doc__", source=makeConstantRefNode(constant=class_doc, source_ref=source_ref, user_provided=True), source_ref=source_ref.atInternal(), )) statements += ( body, StatementReturn( expression=ExpressionBuiltinLocalsRef(locals_scope=locals_scope, source_ref=source_ref), source_ref=source_ref, ), ) body = makeStatementsSequenceFromStatement( statement=makeTryFinallyStatement( provider=function_body, tried=mergeStatements(statements, True), final=StatementReleaseLocals(locals_scope=locals_scope, source_ref=source_ref), source_ref=source_ref, )) # The class body is basically a function that implicitly, at the end # returns its locals and cannot have other return statements contained. function_body.setBody(body) temp_scope = provider.allocateTempScope("class_creation") tmp_bases = provider.allocateTempVariable(temp_scope, "bases") tmp_class_dict = provider.allocateTempVariable(temp_scope, "class_dict") tmp_metaclass = provider.allocateTempVariable(temp_scope, "metaclass") tmp_class = provider.allocateTempVariable(temp_scope, "class") select_metaclass = ExpressionOutlineBody(provider=provider, name="select_metaclass", body=None, source_ref=source_ref) if node.bases: tmp_base = select_metaclass.allocateTempVariable(temp_scope=None, name="base") statements = ( StatementAssignmentVariable( variable=tmp_base, source=ExpressionSubscriptLookup( expression=ExpressionTempVariableRef( variable=tmp_bases, source_ref=source_ref), subscript=makeConstantRefNode(constant=0, source_ref=source_ref, user_provided=True), source_ref=source_ref, ), source_ref=source_ref, ), makeTryFinallyStatement( provider, tried=StatementTry( tried=makeStatementsSequenceFromStatement( statement=StatementReturn( expression=ExpressionAttributeLookup( expression=ExpressionTempVariableRef( variable=tmp_base, source_ref=source_ref), attribute_name="__class__", source_ref=source_ref, ), source_ref=source_ref, )), except_handler=makeStatementsSequenceFromStatement( statement=StatementReturn( expression=ExpressionBuiltinType1( value=ExpressionTempVariableRef( variable=tmp_base, source_ref=source_ref), source_ref=source_ref, ), source_ref=source_ref, )), break_handler=None, continue_handler=None, return_handler=None, source_ref=source_ref, ), final=StatementReleaseVariable(variable=tmp_base, source_ref=source_ref), source_ref=source_ref, public_exc=False, ), ) else: statements = ( StatementTry( tried=makeStatementsSequenceFromStatement( statement=StatementReturn( # TODO: Should avoid checking __builtins__ for this. expression=ExpressionVariableNameRef( variable_name="__metaclass__", provider=parent_module, source_ref=source_ref, ), source_ref=source_ref, )), except_handler=makeStatementsSequenceFromStatement( statement=StatementReturn( expression=ExpressionBuiltinAnonymousRef( builtin_name="classobj", source_ref=source_ref), source_ref=source_ref, )), break_handler=None, continue_handler=None, return_handler=None, source_ref=source_ref, ), ) select_metaclass.setBody( makeStatementsSequence(statements=statements, allow_none=False, source_ref=source_ref)) statements = [ StatementAssignmentVariable( variable=tmp_bases, source=makeExpressionMakeTupleOrConstant( elements=buildNodeList(provider=provider, nodes=node.bases, source_ref=source_ref), user_provided=True, source_ref=source_ref, ), source_ref=source_ref, ), StatementAssignmentVariable(variable=tmp_class_dict, source=function_body, source_ref=source_ref), StatementAssignmentVariable( variable=tmp_metaclass, source=ExpressionConditional( condition=ExpressionDictOperationIn( key=makeConstantRefNode( constant="__metaclass__", source_ref=source_ref, user_provided=True, ), dict_arg=ExpressionTempVariableRef(variable=tmp_class_dict, source_ref=source_ref), source_ref=source_ref, ), expression_yes=ExpressionDictOperationGet( dict_arg=ExpressionTempVariableRef(variable=tmp_class_dict, source_ref=source_ref), key=makeConstantRefNode( constant="__metaclass__", source_ref=source_ref, user_provided=True, ), source_ref=source_ref, ), expression_no=select_metaclass, source_ref=source_ref, ), source_ref=source_ref, ), StatementAssignmentVariable( variable=tmp_class, source=makeExpressionCall( called=ExpressionTempVariableRef(variable=tmp_metaclass, source_ref=source_ref), args=makeExpressionMakeTuple( elements=( makeConstantRefNode( constant=node.name, source_ref=source_ref, user_provided=True, ), ExpressionTempVariableRef(variable=tmp_bases, source_ref=source_ref), ExpressionTempVariableRef(variable=tmp_class_dict, source_ref=source_ref), ), source_ref=source_ref, ), kw=None, source_ref=source_ref, ), source_ref=source_ref, ), ] for decorator in buildNodeList(provider, reversed(node.decorator_list), source_ref): statements.append( StatementAssignmentVariable( variable=tmp_class, source=makeExpressionCall( called=decorator, args=makeExpressionMakeTuple( elements=(ExpressionTempVariableRef( variable=tmp_class, source_ref=source_ref), ), source_ref=source_ref, ), kw=None, source_ref=decorator.getSourceReference(), ), source_ref=decorator.getSourceReference(), )) statements.append( StatementAssignmentVariableName( provider=provider, variable_name=mangleName(node.name, provider), source=ExpressionTempVariableRef(variable=tmp_class, source_ref=source_ref), source_ref=source_ref, )) final = ( StatementReleaseVariable(variable=tmp_class, source_ref=source_ref), StatementReleaseVariable(variable=tmp_bases, source_ref=source_ref), StatementReleaseVariable(variable=tmp_class_dict, source_ref=source_ref), StatementReleaseVariable(variable=tmp_metaclass, source_ref=source_ref), ) return makeTryFinallyStatement(provider=function_body, tried=statements, final=final, source_ref=source_ref)