def _buildInplaceAssignVariableNode(variable_ref, operator, expression, source_ref): assert variable_ref.isExpressionTargetVariableRef(), variable_ref inplace_node = ExpressionOperationBinaryInplace( operator = operator, left = ExpressionVariableRef( variable_name = variable_ref.getVariableName(), source_ref = source_ref ), right = expression, source_ref = source_ref ) inplace_node.markAsInplaceSuspect() result = ( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = variable_ref.getVariableName(), source_ref = source_ref ), source = inplace_node, source_ref = source_ref ), ) return result
def createPython3NamespacePath(package_name, module_relpath, source_ref): return StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__path__", source_ref = source_ref ), source = ExpressionCallNoKeywords( called = ExpressionImportName( module = ExpressionImportModule( module_name = "_frozen_importlib", import_list = (), level = 0, source_ref = source_ref ), import_name = "_NamespacePath", source_ref = source_ref ), args = ExpressionConstantRef( constant = ( package_name, [module_relpath], None ), source_ref = source_ref ), source_ref = source_ref ), source_ref = source_ref )
def createNamespacePackage(package_name, module_relpath): parts = package_name.split('.') source_ref = SourceCodeReference.fromFilenameAndLine( filename = module_relpath, line = 1, future_spec = FutureSpec(), ) source_ref = source_ref.atInternal() package_package_name = '.'.join(parts[:-1]) or None package = PythonPackage( name = parts[-1], package_name = package_package_name, source_ref = source_ref, ) package.setBody( makeStatementsSequenceFromStatement( statement = ( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__path__", source_ref = source_ref ), source = ExpressionCallNoKeywords( called = ExpressionImportName( module = ExpressionImportModule( module_name = "_frozen_importlib", import_list = (), level = 0, source_ref = source_ref ), import_name = "_NamespacePath", source_ref = source_ref ), args = ExpressionConstantRef( constant = ( package_name, [module_relpath], None ), source_ref = source_ref ), source_ref = source_ref ), source_ref = source_ref ) ) ) ) completeVariableClosures(package) return source_ref, package
def buildImportModulesNode(node, source_ref): # Import modules statement. As described in the developer manual, these # statements can be treated as several ones. import_names = [(import_desc.name, import_desc.asname) for import_desc in node.names] import_nodes = [] for import_desc in import_names: module_name, local_name = import_desc module_topname = module_name.split(".")[0] # Note: The "level" of import is influenced by the future absolute # imports. level = 0 if source_ref.getFutureSpec().isAbsoluteImport() else -1 if local_name: import_node = ExpressionImportModule(module_name=module_name, import_list=None, level=level, source_ref=source_ref) for import_name in module_name.split(".")[1:]: import_node = ExpressionImportName(module=import_node, import_name=import_name, source_ref=source_ref) else: import_node = ExpressionImportModule(module_name=module_name, import_list=None, level=level, source_ref=source_ref) # If a name was given, use the one provided, otherwise the import gives # the top level package name given for assignment of the imported # module. import_nodes.append( StatementAssignmentVariable( variable_ref=ExpressionTargetVariableRef( variable_name=local_name if local_name is not None else module_topname, source_ref=source_ref), source=import_node, source_ref=source_ref)) # Note: Each import is sequential. It will potentially succeed, and the # failure of a later one is not changing that one bit . We can therefore # have a sequence of imports that only import one thing therefore. return makeStatementsSequenceOrStatement(statements=import_nodes, source_ref=source_ref)
def createPathAssignment(source_ref): if Options.getFileReferenceMode() == "original": path_value = ExpressionConstantRef( constant = [ Utils.dirname(source_ref.getFilename()) ], source_ref = source_ref, user_provided = True ) else: path_value = ExpressionMakeList( elements = ( ExpressionCallNoKeywords( called = ExpressionAttributeLookup( source = ExpressionImportModuleHard( module_name = "os", import_name = "path", source_ref = source_ref ), attribute_name = "dirname", source_ref = source_ref ), args = ExpressionMakeTuple( elements = ( ExpressionModuleFileAttributeRef( source_ref = source_ref, ), ), source_ref = source_ref, ), source_ref = source_ref, ), ), source_ref = source_ref ) return StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__path__", source_ref = source_ref ), source = path_value, source_ref = source_ref )
def buildFunctionNode(provider, node, source_ref): assert getKind(node) == "FunctionDef" function_statements, function_doc = extractDocFromBody(node) function_body = ExpressionFunctionBody( provider = provider, name = node.name, doc = function_doc, parameters = buildParameterSpec(node.name, node, source_ref), source_ref = source_ref ) # Hack: function_body.parent = provider decorators = buildNodeList( provider = provider, nodes = reversed(node.decorator_list), source_ref = source_ref ) defaults = buildNodeList( provider = provider, nodes = node.args.defaults, source_ref = source_ref ) kw_defaults = buildParameterKwDefaults( provider, node, function_body, source_ref ) pushIndicatorVariable(Ellipsis) function_statements_body = buildStatementsNode( provider = function_body, nodes = function_statements, frame = True, source_ref = source_ref ) popIndicatorVariable() if function_body.isGenerator(): # TODO: raise generator exit? pass elif function_statements_body is None: function_statements_body = makeStatementsSequenceFromStatement( statement = StatementReturn( expression = ExpressionConstantRef( constant = None, source_ref = source_ref.atInternal() ), source_ref = source_ref.atInternal() ) ) elif not function_statements_body.isStatementAborting(): function_statements_body.setStatements( function_statements_body.getStatements() + ( StatementReturn( expression = ExpressionConstantRef( constant = None, source_ref = source_ref ), source_ref = source_ref.atInternal() ), ) ) function_body.setBody( function_statements_body ) annotations = buildParameterAnnotations(provider, node, source_ref) function_creation = ExpressionFunctionCreation( function_ref = ExpressionFunctionRef( function_body, source_ref = source_ref ), defaults = defaults, kw_defaults = kw_defaults, annotations = annotations, source_ref = source_ref ) # Add the staticmethod decorator to __new__ methods if not provided. # CPython made these optional, but applies them to every class __new__. We # add them early, so our optimization will see it. if node.name == "__new__" and not decorators and \ provider.isExpressionFunctionBody() and provider.isClassDictCreation(): decorators = ( ExpressionBuiltinRef( builtin_name = "staticmethod", source_ref = source_ref ), ) decorated_function = function_creation for decorator in decorators: decorated_function = ExpressionCallNoKeywords( called = decorator, args = ExpressionMakeTuple( elements = (decorated_function,), source_ref = source_ref ), source_ref = decorator.getSourceReference() ) result = StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = node.name, source_ref = source_ref ), source = decorated_function, source_ref = source_ref ) if Utils.python_version >= 340: function_body.qualname_setup = result.getTargetVariableRef() return result
def buildParseTree(provider, source_code, source_ref, is_module, is_main): # There are a bunch of branches here, mostly to deal with version # differences for module default variables. pylint: disable=R0912 # Workaround: ast.parse cannot cope with some situations where a file is not # terminated by a new line. if not source_code.endswith('\n'): source_code = source_code + '\n' try: body = ast.parse(source_code, source_ref.getFilename()) except SyntaxError as e: _makeSyntaxErrorCompatible(e) raise e assert getKind(body) == "Module" line_offset = source_ref.getLineNumber() - 1 if line_offset > 0: for created_node in ast.walk(body): if hasattr(created_node, "lineno"): created_node.lineno += line_offset body, doc = extractDocFromBody(body) result = buildStatementsNode( provider = provider, nodes = body, source_ref = source_ref ) checkFutureImportsOnlyAtStart(body) internal_source_ref = source_ref.atInternal() statements = [] if is_module: # Add import of "site" module of main programs visibly in the node tree, # so recursion and optimization can pick it up, checking its effects. if is_main and not sys.flags.no_site: statements.append( StatementExpressionOnly( expression = ExpressionImportModule( module_name = "site", import_list = (), level = 0, source_ref = source_ref, ), source_ref = source_ref ) ) statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__doc__", source_ref = internal_source_ref ), source = ExpressionConstantRef( constant = doc, source_ref = internal_source_ref, user_provided = True ), source_ref = internal_source_ref ) ) statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__file__", source_ref = internal_source_ref ), source = ExpressionModuleFileAttributeRef( source_ref = internal_source_ref, ), source_ref = internal_source_ref ) ) if provider.isPythonPackage(): # This assigns "__path__" value. statements.append( createPathAssignment(internal_source_ref) ) if Utils.python_version >= 300: statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__cached__", source_ref = internal_source_ref ), source = ExpressionConstantRef( constant = None, source_ref = internal_source_ref, user_provided = True ), source_ref = internal_source_ref ) ) if Utils.python_version >= 330: # For Python3.3, it's set for both packages and non-packages. statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__package__", source_ref = internal_source_ref ), source = ExpressionConstantRef( constant = provider.getFullName() if provider.isPythonPackage() else provider.getPackage(), source_ref = internal_source_ref, user_provided = True ), source_ref = internal_source_ref ) ) needs__initializing__ = not provider.isMainModule() and \ (Utils.python_version >= 330 and Utils.python_version < 340) if needs__initializing__: # Set "__initializing__" at the beginning to True statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__initializing__", source_ref = internal_source_ref ), source = ExpressionConstantRef( constant = True, source_ref = internal_source_ref, user_provided = True ), source_ref = internal_source_ref ) ) # Now the module body if there is any at all. if result is not None: statements.extend( result.getStatements() ) if needs__initializing__: # Set "__initializing__" at the end to False statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__initializing__", source_ref = internal_source_ref ), source = ExpressionConstantRef( constant = False, source_ref = internal_source_ref, user_provided = True ), source_ref = internal_source_ref ) ) if is_module: result = makeModuleFrame( module = provider, statements = statements, source_ref = source_ref ) applyLaterWrappers() return result else: assert False
def _buildClassNode3(provider, node, source_ref): # Many variables, due to the huge re-formulation that is going on here, # which just has the complexity, pylint: disable=R0914 # This function is the Python3 special case with special re-formulation as # according to developer manual. class_statements, class_doc = extractDocFromBody(node) # We need a scope for the temporary variables, and they might be closured. temp_scope = provider.allocateTempScope( name = "class_creation", allow_closure = True ) tmp_bases = provider.allocateTempVariable( temp_scope = temp_scope, name = "bases" ) tmp_class_decl_dict = provider.allocateTempVariable( temp_scope = temp_scope, name = "class_decl_dict" ) tmp_metaclass = provider.allocateTempVariable( temp_scope = temp_scope, name = "metaclass" ) tmp_prepared = provider.allocateTempVariable( temp_scope = temp_scope, name = "prepared" ) class_creation_function = ExpressionFunctionBody( provider = provider, is_class = True, parameters = make_class_parameters, name = node.name, doc = class_doc, source_ref = source_ref ) # Hack: This allows some APIs to work although this is not yet officially a # child yet. class_creation_function.parent = provider body = buildStatementsNode( provider = class_creation_function, nodes = class_statements, frame = True, source_ref = source_ref ) source_ref_orig = source_ref if body is not None: # The frame guard has nothing to tell its line number to. body.source_ref = source_ref module_variable = class_creation_function.getVariableForAssignment( "__module__" ) statements = [ StatementSetLocals( new_locals = ExpressionTempVariableRef( variable = tmp_prepared, source_ref = source_ref ), source_ref = source_ref ), StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__module__", variable = module_variable, source_ref = source_ref ), source = ExpressionConstantRef( constant = provider.getParentModule().getFullName(), source_ref = source_ref, user_provided = True ), source_ref = source_ref ) ] if class_doc is not None: doc_variable = class_creation_function.getVariableForAssignment( "__doc__" ) statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__doc__", variable = doc_variable, source_ref = source_ref ), source = ExpressionConstantRef( constant = class_doc, source_ref = source_ref, user_provided = True ), source_ref = source_ref ) ) # The "__qualname__" attribute is new in Python 3.3. if Utils.python_version >= 330: qualname = class_creation_function.getFunctionQualname() qualname_variable = class_creation_function.getVariableForAssignment( "__qualname__" ) if Utils.python_version < 340: qualname_ref = ExpressionConstantRef( constant = qualname, source_ref = source_ref, user_provided = True ) else: qualname_ref = ExpressionFunctionQualnameRef( function_body = class_creation_function, source_ref = source_ref, ) statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__qualname__", variable = qualname_variable, source_ref = source_ref ), source = qualname_ref, source_ref = source_ref ) ) if Utils.python_version >= 340: qualname_assign = statements[-1] if Utils.python_version >= 340 and False: # TODO: Temporarily reverted: tmp_class = class_creation_function.allocateTempVariable( temp_scope = None, name = "__class__" ) class_target_variable_ref = ExpressionTargetTempVariableRef( variable = tmp_class, source_ref = source_ref ) class_variable_ref = ExpressionTempVariableRef( variable = tmp_class, source_ref = source_ref ) else: class_variable = class_creation_function.getVariableForAssignment( "__class__" ) class_target_variable_ref = ExpressionTargetVariableRef( variable_name = "__class__", variable = class_variable, source_ref = source_ref ) class_variable_ref = ExpressionVariableRef( variable_name = "__class__", variable = class_variable, source_ref = source_ref ) statements += [ body, StatementAssignmentVariable( variable_ref = class_target_variable_ref, source = ExpressionCall( called = ExpressionTempVariableRef( variable = tmp_metaclass, source_ref = source_ref ), args = makeSequenceCreationOrConstant( sequence_kind = "tuple", elements = ( ExpressionConstantRef( constant = node.name, source_ref = source_ref, user_provided = True ), ExpressionTempVariableRef( variable = tmp_bases, source_ref = source_ref ), ExpressionBuiltinLocals( source_ref = source_ref ) ), source_ref = source_ref ), kw = ExpressionTempVariableRef( variable = tmp_class_decl_dict, source_ref = source_ref ), source_ref = source_ref ), source_ref = source_ref ), StatementReturn( expression = class_variable_ref, source_ref = source_ref ) ] body = makeStatementsSequence( statements = statements, allow_none = True, 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. class_creation_function.setBody(body) # The class body is basically a function that implicitly, at the end # returns its created class and cannot have other return statements # contained. decorated_body = ExpressionFunctionCall( function = ExpressionFunctionCreation( function_ref = ExpressionFunctionRef( function_body = class_creation_function, source_ref = source_ref ), defaults = (), kw_defaults = None, annotations = None, source_ref = source_ref ), values = (), source_ref = source_ref ) for decorator in buildNodeList( provider, reversed(node.decorator_list), source_ref ): decorated_body = ExpressionCallNoKeywords( called = decorator, args = ExpressionMakeTuple( elements = ( decorated_body, ), source_ref = source_ref ), source_ref = decorator.getSourceReference() ) statements = ( StatementAssignmentVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_bases, source_ref = source_ref ), source = makeSequenceCreationOrConstant( sequence_kind = "tuple", elements = buildNodeList( provider, node.bases, source_ref ), source_ref = source_ref ), source_ref = source_ref ), StatementAssignmentVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_class_decl_dict, source_ref = source_ref ), source = makeDictCreationOrConstant( keys = [ ExpressionConstantRef( constant = keyword.arg, source_ref = source_ref, user_provided = True ) for keyword in node.keywords ], values = [ buildNode(provider, keyword.value, source_ref) for keyword in node.keywords ], lazy_order = False, source_ref = source_ref ), source_ref = source_ref ), StatementAssignmentVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_metaclass, source_ref = source_ref ), source = ExpressionSelectMetaclass( metaclass = ExpressionConditional( condition = ExpressionComparison( comparator = "In", left = ExpressionConstantRef( constant = "metaclass", source_ref = source_ref, user_provided = True ), right = ExpressionTempVariableRef( variable = tmp_class_decl_dict, source_ref = source_ref ), source_ref = source_ref ), yes_expression = ExpressionDictOperationGet( dicte = ExpressionTempVariableRef( variable = tmp_class_decl_dict, source_ref = source_ref ), key = ExpressionConstantRef( constant = "metaclass", source_ref = source_ref, user_provided = True ), source_ref = source_ref ), no_expression = ExpressionConditional( condition = ExpressionTempVariableRef( variable = tmp_bases, source_ref = source_ref ), no_expression = ExpressionBuiltinRef( builtin_name = "type", source_ref = source_ref ), yes_expression = ExpressionBuiltinType1( value = ExpressionSubscriptLookup( subscribed = ExpressionTempVariableRef( variable = tmp_bases, source_ref = source_ref ), subscript = ExpressionConstantRef( constant = 0, source_ref = source_ref, user_provided = True ), source_ref = source_ref ), source_ref = source_ref ), source_ref = source_ref ), source_ref = source_ref ), bases = ExpressionTempVariableRef( variable = tmp_bases, source_ref = source_ref ), source_ref = source_ref ), source_ref = source_ref_orig ), StatementConditional( condition = ExpressionComparison( comparator = "In", left = ExpressionConstantRef( constant = "metaclass", source_ref = source_ref, user_provided = True ), right = ExpressionTempVariableRef( variable = tmp_class_decl_dict, source_ref = source_ref ), source_ref = source_ref ), no_branch = None, yes_branch = makeStatementsSequenceFromStatement( statement = StatementDictOperationRemove( dicte = ExpressionTempVariableRef( variable = tmp_class_decl_dict, source_ref = source_ref ), key = ExpressionConstantRef( constant = "metaclass", source_ref = source_ref, user_provided = True ), source_ref = source_ref ) ), source_ref = source_ref ), StatementAssignmentVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_prepared, source_ref = source_ref ), source = ExpressionConditional( condition = ExpressionBuiltinHasattr( object = ExpressionTempVariableRef( variable = tmp_metaclass, source_ref = source_ref ), name = ExpressionConstantRef( constant = "__prepare__", source_ref = source_ref, user_provided = True ), source_ref = source_ref ), no_expression = ExpressionConstantRef( constant = {}, source_ref = source_ref, user_provided = True ), yes_expression = ExpressionCall( called = ExpressionAttributeLookup( source = ExpressionTempVariableRef( variable = tmp_metaclass, source_ref = source_ref ), attribute_name = "__prepare__", source_ref = source_ref ), args = ExpressionMakeTuple( elements = ( ExpressionConstantRef( constant = node.name, source_ref = source_ref, user_provided = True ), ExpressionTempVariableRef( variable = tmp_bases, source_ref = source_ref ) ), source_ref = source_ref ), kw = ExpressionTempVariableRef( variable = tmp_class_decl_dict, source_ref = source_ref ), source_ref = source_ref ), source_ref = source_ref ), source_ref = source_ref ), StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = node.name, source_ref = source_ref ), source = decorated_body, source_ref = source_ref ), ) if Utils.python_version >= 340: class_assign = statements[-1] # assert False, class_creation_function class_creation_function.qualname_setup = class_assign, qualname_assign final = ( StatementDelVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_bases, source_ref = source_ref ), tolerant = True, source_ref = source_ref ), StatementDelVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_class_decl_dict, source_ref = source_ref ), tolerant = True, source_ref = source_ref ), StatementDelVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_metaclass, source_ref = source_ref ), tolerant = True, source_ref = source_ref ), StatementDelVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_prepared, source_ref = source_ref ), tolerant = True, source_ref = source_ref ) ) return makeTryFinallyStatement( tried = statements, final = final, source_ref = source_ref )
def _buildClassNode2(provider, node, source_ref): class_statements, class_doc = extractDocFromBody(node) # This function is the Python2 special case with special re-formulation as # according to developer manual. function_body = ExpressionFunctionBody( provider = provider, is_class = True, parameters = make_class_parameters, name = node.name, doc = class_doc, source_ref = source_ref ) body = buildStatementsNode( provider = function_body, nodes = class_statements, frame = True, 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() # 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 = [ StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__module__", source_ref = source_ref ), source = ExpressionConstantRef( constant = provider.getParentModule().getFullName(), source_ref = source_ref, user_provided = True ), source_ref = source_ref.atInternal() ) ] if class_doc is not None: statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__doc__", source_ref = source_ref ), source = ExpressionConstantRef( constant = class_doc, source_ref = source_ref, user_provided = True ), source_ref = source_ref.atInternal() ) ) statements += [ body, StatementReturn( expression = ExpressionBuiltinLocals( source_ref = source_ref ), source_ref = source_ref.atInternal() ) ] body = makeStatementsSequence( statements = statements, allow_none = True, 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") statements = [ StatementAssignmentVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_bases, source_ref = source_ref ), source = makeSequenceCreationOrConstant( sequence_kind = "tuple", elements = buildNodeList( provider, node.bases, source_ref ), source_ref = source_ref ), source_ref = source_ref ), StatementAssignmentVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_class_dict, source_ref = source_ref ), source = ExpressionFunctionCall( function = ExpressionFunctionCreation( function_ref = ExpressionFunctionRef( function_body = function_body, source_ref = source_ref ), defaults = (), kw_defaults = None, annotations = None, source_ref = source_ref ), values = (), source_ref = source_ref ), source_ref = source_ref ), StatementAssignmentVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_metaclass, source_ref = source_ref ), source = ExpressionConditional( condition = ExpressionComparison( comparator = "In", left = ExpressionConstantRef( constant = "__metaclass__", source_ref = source_ref, user_provided = True ), right = ExpressionTempVariableRef( variable = tmp_class_dict, source_ref = source_ref ), source_ref = source_ref ), yes_expression = ExpressionDictOperationGet( dicte = ExpressionTempVariableRef( variable = tmp_class_dict, source_ref = source_ref ), key = ExpressionConstantRef( constant = "__metaclass__", source_ref = source_ref, user_provided = True ), source_ref = source_ref ), no_expression = ExpressionSelectMetaclass( metaclass = None, bases = ExpressionTempVariableRef( variable = tmp_bases, source_ref = source_ref ), source_ref = source_ref ), source_ref = source_ref ), source_ref = source_ref ), StatementAssignmentVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_class, source_ref = source_ref ), source = ExpressionCallNoKeywords( called = ExpressionTempVariableRef( variable = tmp_metaclass, source_ref = source_ref ), args = ExpressionMakeTuple( elements = ( ExpressionConstantRef( 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 ), source_ref = source_ref ), source_ref = source_ref ), ] for decorator in buildNodeList( provider, reversed(node.decorator_list), source_ref ): statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_class, source_ref = source_ref ), source = ExpressionCallNoKeywords( called = decorator, args = ExpressionMakeTuple( elements = ( ExpressionTempVariableRef( variable = tmp_class, source_ref = source_ref ), ), source_ref = source_ref ), source_ref = decorator.getSourceReference() ), source_ref = decorator.getSourceReference() ) ) statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = node.name, source_ref = source_ref ), source = ExpressionTempVariableRef( variable = tmp_class, source_ref = source_ref ), source_ref = source_ref ) ) final = ( StatementDelVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_class, source_ref = source_ref ), tolerant = True, source_ref = source_ref ), StatementDelVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_bases, source_ref = source_ref ), tolerant = True, source_ref = source_ref ), StatementDelVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_class_dict, source_ref = source_ref ), tolerant = True, source_ref = source_ref ), StatementDelVariable( variable_ref = ExpressionTargetTempVariableRef( variable = tmp_metaclass, source_ref = source_ref ), tolerant = True, source_ref = source_ref ) ) return makeTryFinallyStatement( tried = statements, final = final, source_ref = source_ref )
def buildParseTree(provider, source_code, source_ref): # Workaround: ast.parse cannot cope with some situations where a file is not terminated # by a new line. if not source_code.endswith("\n"): source_code = source_code + "\n" body = ast.parse(source_code, source_ref.getFilename()) assert getKind(body) == "Module" line_offset = source_ref.getLineNumber() - 1 if line_offset > 0: for created_node in ast.walk(body): if hasattr(created_node, "lineno"): created_node.lineno += line_offset body, doc = extractDocFromBody(body) result = buildStatementsNode(provider=provider, nodes=body, source_ref=source_ref, frame=True) # Check if a __future__ imports really were at the beginning of the file. for node in body: if node in _future_import_nodes: _future_import_nodes.remove(node) else: if _future_import_nodes: SyntaxErrors.raiseSyntaxError( reason= "from __future__ imports must occur at the beginning of the file", col_offset=1 if Utils.python_version >= 300 or not Options.isFullCompat() else None, source_ref=_future_import_nodes[0].source_ref) internal_source_ref = source_ref.atInternal() statements = [] statements.append( StatementAssignmentVariable(variable_ref=ExpressionTargetVariableRef( variable_name="__doc__", source_ref=internal_source_ref), source=ExpressionConstantRef( constant=doc, source_ref=internal_source_ref), source_ref=internal_source_ref)) statements.append( StatementAssignmentVariable(variable_ref=ExpressionTargetVariableRef( variable_name="__file__", source_ref=internal_source_ref), source=ExpressionConstantRef( constant=source_ref.getFilename(), source_ref=internal_source_ref), source_ref=internal_source_ref)) if provider.isPythonPackage(): # TODO: __package__ is not set here, but automatically, which makes it invisible # though statements.append( StatementAssignmentVariable( variable_ref=ExpressionTargetVariableRef( variable_name="__path__", source_ref=internal_source_ref), source=ExpressionConstantRef( constant=[Utils.dirname(source_ref.getFilename())], source_ref=internal_source_ref), source_ref=internal_source_ref)) if Utils.python_version >= 300: statements.append( StatementAssignmentVariable( variable_ref=ExpressionTargetVariableRef( variable_name="__cached__", source_ref=internal_source_ref), source=ExpressionConstantRef(constant=None, source_ref=internal_source_ref), source_ref=internal_source_ref)) if Utils.python_version >= 330: # For Python3.3, it's set for both packages and non-packages. statements.append( StatementAssignmentVariable( variable_ref=ExpressionTargetVariableRef( variable_name="__package__", source_ref=internal_source_ref), source=ExpressionConstantRef(constant=provider.getPackage(), source_ref=internal_source_ref), source_ref=internal_source_ref)) if Utils.python_version >= 330: # Set initialzing at the beginning to True statements.append( StatementAssignmentVariable( variable_ref=ExpressionTargetVariableRef( variable_name="__initializing__", source_ref=internal_source_ref), source=ExpressionConstantRef(constant=True, source_ref=internal_source_ref), source_ref=internal_source_ref)) # Now the module body if there is any at all. if result is not None: statements.extend(result.getStatements()) if Utils.python_version >= 330: # Set initialzing at the beginning to True statements.append( StatementAssignmentVariable( variable_ref=ExpressionTargetVariableRef( variable_name="__initializing__", source_ref=internal_source_ref), source=ExpressionConstantRef(constant=False, source_ref=internal_source_ref), source_ref=internal_source_ref)) if result is None: result = makeStatementsSequence(statements=statements, source_ref=internal_source_ref, allow_none=False) else: result.setStatements(statements) provider.setBody(result) return result
def buildImportFromNode(provider, node, source_ref): # "from .. import .." statements. This may trigger a star import, or multiple names # being looked up from the given module variable name. module_name = node.module if node.module is not None else "" level = node.level # Importing from "__future__" module may enable flags. if module_name == "__future__": assert provider.isPythonModule() or source_ref.isExecReference() for import_desc in node.names: object_name, _local_name = import_desc.name, import_desc.asname enableFutureFeature(object_name=object_name, future_spec=source_ref.getFutureSpec(), source_ref=source_ref) # Remember it for checks to be applied once module is complete. node.source_ref = source_ref _future_import_nodes.append(node) target_names = [] import_names = [] for import_desc in node.names: object_name, local_name = import_desc.name, import_desc.asname if object_name == "*": target_names.append(None) else: target_names.append( local_name if local_name is not None else object_name) import_names.append(object_name) if None in target_names: # More than "*" is a syntax error in Python, need not care about this at # all, it's only allowed value for import list in this case. assert target_names == [None] # Python3 made this a syntax error unfortunately. if not provider.isPythonModule() and Utils.python_version >= 300: SyntaxErrors.raiseSyntaxError( "import * only allowed at module level", provider.getSourceReference()) if provider.isExpressionFunctionBody(): provider.markAsStarImportContaining() return StatementImportStar(module_import=ExpressionImportModule( module_name=module_name, import_list=("*", ), level=level, source_ref=source_ref), source_ref=source_ref) else: import_nodes = [] for target_name, import_name in zip(target_names, import_names): import_nodes.append( StatementAssignmentVariable( variable_ref=ExpressionTargetVariableRef( variable_name=target_name, source_ref=source_ref), source=ExpressionImportName(module=ExpressionImportModule( module_name=module_name, import_list=import_names, level=level, source_ref=source_ref), import_name=import_name, source_ref=source_ref), source_ref=source_ref)) # Note: Each import is sequential. It can succeed, and the failure of a later one is # not changing one. We can therefore have a sequence of imports that only import one # thing therefore. return StatementsSequence(statements=import_nodes, source_ref=source_ref)
def _buildClassNode3(provider, node, source_ref): # Many variables, due to the huge re-formulation that is going on here, which just has # the complexity, pylint: disable=R0914 # This function is the Python3 special case with special re-formulation as according # to developer manual. class_statements, class_doc = extractDocFromBody(node) # The result will be a temp block that holds the temporary variables. result = StatementTempBlock(source_ref=source_ref) tmp_bases = result.getTempVariable("bases") tmp_class_decl_dict = result.getTempVariable("class_decl_dict") tmp_metaclass = result.getTempVariable("metaclass") tmp_prepared = result.getTempVariable("prepared") class_creation_function = ExpressionFunctionBody( provider=provider, is_class=True, parameters=make_class_parameters, name=node.name, doc=class_doc, source_ref=source_ref) # Hack: class_creation_function.parent = provider body = buildStatementsNode(provider=class_creation_function, nodes=class_statements, frame=True, 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() statements = [ StatementSetLocals(new_locals=ExpressionTempVariableRef( variable=tmp_prepared.makeReference(result), source_ref=source_ref), source_ref=source_ref.atInternal()), StatementAssignmentVariable( variable_ref=ExpressionTargetVariableRef( variable_name="__module__", source_ref=source_ref), source=ExpressionConstantRef( constant=provider.getParentModule().getName(), source_ref=source_ref), source_ref=source_ref.atInternal()) ] if class_doc is not None: statements.append( StatementAssignmentVariable( variable_ref=ExpressionTargetVariableRef( variable_name="__doc__", source_ref=source_ref), source=ExpressionConstantRef(constant=class_doc, source_ref=source_ref), source_ref=source_ref.atInternal())) if Utils.python_version >= 330: if provider.isExpressionFunctionBody(): qualname = provider.getName() + ".<locals>." + node.name else: qualname = node.name statements.append( StatementAssignmentVariable( variable_ref=ExpressionTargetVariableRef( variable_name="__qualname__", source_ref=source_ref), source=ExpressionConstantRef(constant=qualname, source_ref=source_ref), source_ref=source_ref.atInternal())) statements += [ body, StatementAssignmentVariable( variable_ref=ExpressionTargetVariableRef(variable_name="__class__", source_ref=source_ref), source=ExpressionCall( called=ExpressionTempVariableRef( variable=tmp_metaclass.makeReference(result), source_ref=source_ref), args=ExpressionMakeTuple( elements=(ExpressionConstantRef(constant=node.name, source_ref=source_ref), ExpressionTempVariableRef( variable=tmp_bases.makeReference(result), source_ref=source_ref), ExpressionBuiltinLocals(source_ref=source_ref)), source_ref=source_ref), kw=ExpressionTempVariableRef( variable=tmp_class_decl_dict.makeReference(result), source_ref=source_ref), source_ref=source_ref), source_ref=source_ref.atInternal()), StatementReturn(expression=ExpressionVariableRef( variable_name="__class__", source_ref=source_ref), source_ref=source_ref.atInternal()) ] body = makeStatementsSequence(statements=statements, allow_none=True, source_ref=source_ref) # The class body is basically a function that implicitely, at the end returns its # locals and cannot have other return statements contained. class_creation_function.setBody(body) # The class body is basically a function that implicitely, at the end returns its # created class and cannot have other return statements contained. decorated_body = ExpressionFunctionCall( function=ExpressionFunctionCreation(function_ref=ExpressionFunctionRef( function_body=class_creation_function, source_ref=source_ref), defaults=(), kw_defaults=None, annotations=None, source_ref=source_ref), values=(), source_ref=source_ref) for decorator in buildNodeList(provider, reversed(node.decorator_list), source_ref): decorated_body = ExpressionCallNoKeywords( called=decorator, args=ExpressionMakeTuple(elements=(decorated_body, ), source_ref=source_ref), source_ref=decorator.getSourceReference()) statements = [ StatementAssignmentVariable( variable_ref=ExpressionTargetTempVariableRef( variable=tmp_bases.makeReference(result), source_ref=source_ref), source=ExpressionMakeTuple(elements=buildNodeList( provider, node.bases, source_ref), source_ref=source_ref), source_ref=source_ref), StatementAssignmentVariable( variable_ref=ExpressionTargetTempVariableRef( variable=tmp_class_decl_dict.makeReference(result), source_ref=source_ref), source=ExpressionMakeDict(pairs=[ ExpressionKeyValuePair( key=ExpressionConstantRef(constant=keyword.arg, source_ref=source_ref), value=buildNode(provider, keyword.value, source_ref), source_ref=source_ref) for keyword in node.keywords ], source_ref=source_ref), source_ref=source_ref), StatementAssignmentVariable( variable_ref=ExpressionTargetTempVariableRef( variable=tmp_metaclass.makeReference(result), source_ref=source_ref), source=ExpressionSelectMetaclass( metaclass=ExpressionConditional( condition=ExpressionComparison( comparator="In", left=ExpressionConstantRef(constant="metaclass", source_ref=source_ref), right=ExpressionTempVariableRef( variable=tmp_class_decl_dict.makeReference(result), source_ref=source_ref), source_ref=source_ref), yes_expression=ExpressionDictOperationGet( dicte=ExpressionTempVariableRef( variable=tmp_class_decl_dict.makeReference(result), source_ref=source_ref), key=ExpressionConstantRef(constant="metaclass", source_ref=source_ref), source_ref=source_ref), no_expression=ExpressionConditional( condition=ExpressionTempVariableRef( variable=tmp_bases.makeReference(result), source_ref=source_ref), no_expression=ExpressionBuiltinRef( builtin_name="type", source_ref=source_ref), yes_expression=ExpressionBuiltinType1( value=ExpressionSubscriptLookup( expression=ExpressionTempVariableRef( variable=tmp_bases.makeReference(result), source_ref=source_ref), subscript=ExpressionConstantRef( constant=0, source_ref=source_ref), source_ref=source_ref), source_ref=source_ref), source_ref=source_ref), source_ref=source_ref), bases=ExpressionTempVariableRef( variable=tmp_bases.makeReference(result), source_ref=source_ref), source_ref=source_ref), source_ref=source_ref), StatementConditional( condition=ExpressionComparison( comparator="In", left=ExpressionConstantRef(constant="metaclass", source_ref=source_ref), right=ExpressionTempVariableRef( variable=tmp_class_decl_dict.makeReference(result), source_ref=source_ref), source_ref=source_ref), no_branch=None, yes_branch=makeStatementsSequenceFromStatement( statement=StatementDictOperationRemove( dicte=ExpressionTempVariableRef( variable=tmp_class_decl_dict.makeReference(result), source_ref=source_ref), key=ExpressionConstantRef(constant="metaclass", source_ref=source_ref), source_ref=source_ref)), source_ref=source_ref), StatementAssignmentVariable( variable_ref=ExpressionTargetTempVariableRef( variable=tmp_prepared.makeReference(result), source_ref=source_ref), source=ExpressionConditional( condition=ExpressionBuiltinHasattr( object=ExpressionTempVariableRef( variable=tmp_metaclass.makeReference(result), source_ref=source_ref), name=ExpressionConstantRef(constant="__prepare__", source_ref=source_ref), source_ref=source_ref), no_expression=ExpressionConstantRef(constant={}, source_ref=source_ref), yes_expression=ExpressionCall( called=ExpressionAttributeLookup( expression=ExpressionTempVariableRef( variable=tmp_metaclass.makeReference(result), source_ref=source_ref), attribute_name="__prepare__", source_ref=source_ref), args=ExpressionMakeTuple( elements=(ExpressionConstantRef(constant=node.name, source_ref=source_ref), ExpressionTempVariableRef( variable=tmp_bases.makeReference(result), source_ref=source_ref)), source_ref=source_ref), kw=ExpressionTempVariableRef( variable=tmp_class_decl_dict.makeReference(result), source_ref=source_ref), source_ref=source_ref), source_ref=source_ref), source_ref=source_ref), StatementAssignmentVariable(variable_ref=ExpressionTargetVariableRef( variable_name=node.name, source_ref=source_ref), source=decorated_body, source_ref=source_ref) ] result.setBody( StatementsSequence(statements=statements, source_ref=source_ref)) return result
def _buildClassNode2(provider, node, source_ref): class_statements, class_doc = extractDocFromBody(node) # This function is the Python3 special case with special re-formulation as according # to developer manual. # The result will be a temp block that holds the temporary variables. result = StatementTempBlock(source_ref=source_ref) tmp_bases = result.getTempVariable("bases") tmp_class_dict = result.getTempVariable("class_dict") tmp_metaclass = result.getTempVariable("metaclass") tmp_class = result.getTempVariable("class") class_creation_function = ExpressionFunctionBody( provider=provider, is_class=True, parameters=make_class_parameters, name=node.name, doc=class_doc, source_ref=source_ref) body = buildStatementsNode(provider=class_creation_function, nodes=class_statements, frame=True, 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() # The class body is basically a function that implicitely, 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 = [ StatementAssignmentVariable( variable_ref=ExpressionTargetVariableRef( variable_name="__module__", source_ref=source_ref), source=ExpressionConstantRef( constant=provider.getParentModule().getName(), source_ref=source_ref), source_ref=source_ref.atInternal()) ] if class_doc is not None: statements.append( StatementAssignmentVariable( variable_ref=ExpressionTargetVariableRef( variable_name="__doc__", source_ref=source_ref), source=ExpressionConstantRef(constant=class_doc, source_ref=source_ref), source_ref=source_ref.atInternal())) statements += [ body, StatementReturn( expression=ExpressionBuiltinLocals(source_ref=source_ref), source_ref=source_ref.atInternal()) ] body = makeStatementsSequence(statements=statements, allow_none=True, source_ref=source_ref) # The class body is basically a function that implicitely, at the end returns its # locals and cannot have other return statements contained. class_creation_function.setBody(body) statements = [ StatementAssignmentVariable( variable_ref=ExpressionTargetTempVariableRef( variable=tmp_bases.makeReference(result), source_ref=source_ref), source=ExpressionMakeTuple(elements=buildNodeList( provider, node.bases, source_ref), source_ref=source_ref), source_ref=source_ref), StatementAssignmentVariable( variable_ref=ExpressionTargetTempVariableRef( variable=tmp_class_dict.makeReference(result), source_ref=source_ref), source=ExpressionFunctionCall(function=ExpressionFunctionCreation( function_ref=ExpressionFunctionRef( function_body=class_creation_function, source_ref=source_ref), defaults=(), kw_defaults=None, annotations=None, source_ref=source_ref), values=(), source_ref=source_ref), source_ref=source_ref), StatementAssignmentVariable( variable_ref=ExpressionTargetTempVariableRef( variable=tmp_metaclass.makeReference(result), source_ref=source_ref), source=ExpressionConditional( condition=ExpressionComparison( comparator="In", left=ExpressionConstantRef(constant="__metaclass__", source_ref=source_ref), right=ExpressionTempVariableRef( variable=tmp_class_dict.makeReference(result), source_ref=source_ref), source_ref=source_ref), yes_expression=ExpressionDictOperationGet( dicte=ExpressionTempVariableRef( variable=tmp_class_dict.makeReference(result), source_ref=source_ref), key=ExpressionConstantRef(constant="__metaclass__", source_ref=source_ref), source_ref=source_ref), no_expression=ExpressionSelectMetaclass( metaclass=None, bases=ExpressionTempVariableRef( variable=tmp_bases.makeReference(result), source_ref=source_ref), source_ref=source_ref), source_ref=source_ref), source_ref=source_ref), StatementAssignmentVariable( variable_ref=ExpressionTargetTempVariableRef( variable=tmp_class.makeReference(result), source_ref=source_ref), source=ExpressionCallNoKeywords( called=ExpressionTempVariableRef( variable=tmp_metaclass.makeReference(result), source_ref=source_ref), args=ExpressionMakeTuple(elements=( ExpressionConstantRef(constant=node.name, source_ref=source_ref), ExpressionTempVariableRef( variable=tmp_bases.makeReference(result), source_ref=source_ref), ExpressionTempVariableRef( variable=tmp_class_dict.makeReference(result), source_ref=source_ref)), source_ref=source_ref), source_ref=source_ref), source_ref=source_ref) ] for decorator in buildNodeList(provider, reversed(node.decorator_list), source_ref): statements.append( StatementAssignmentVariable( variable_ref=ExpressionTargetTempVariableRef( variable=tmp_class.makeReference(result), source_ref=source_ref), source=ExpressionCallNoKeywords( called=decorator, args=ExpressionMakeTuple( elements=(ExpressionTempVariableRef( variable=tmp_class.makeReference(result), source_ref=source_ref), ), source_ref=source_ref), source_ref=decorator.getSourceReference()), source_ref=decorator.getSourceReference())) statements.append( StatementAssignmentVariable( variable_ref=ExpressionTargetVariableRef(variable_name=node.name, source_ref=source_ref), source=ExpressionTempVariableRef( variable=tmp_class.makeReference(result), source_ref=source_ref), source_ref=source_ref)) result.setBody( StatementsSequence(statements=statements, source_ref=source_ref)) return result
def decodeAssignTarget(provider, node, source_ref, allow_none = False): # Many cases to deal with, because of the different assign targets, # pylint: disable=R0911,R0912 if node is None and allow_none: return None if hasattr(node, "ctx"): assert getKind(node.ctx) in ("Store", "Del") kind = getKind(node) if type(node) is str: return "Name", ExpressionTargetVariableRef( variable_name = mangleName(node, provider), source_ref = source_ref ) elif kind == "Name": return kind, ExpressionTargetVariableRef( variable_name = mangleName(node.id, provider), source_ref = source_ref ) elif kind == "Attribute": return kind, ( buildNode(provider, node.value, source_ref), node.attr ) elif kind == "Subscript": slice_kind = getKind(node.slice) if slice_kind == "Index": return "Subscript", ( buildNode(provider, node.value, source_ref), buildNode(provider, node.slice.value, source_ref) ) elif slice_kind == "Slice": lower = buildNode(provider, node.slice.lower, source_ref, True) upper = buildNode(provider, node.slice.upper, source_ref, True) if node.slice.step is not None: step = buildNode(provider, node.slice.step, source_ref) return "Subscript", ( buildNode(provider, node.value, source_ref), ExpressionSliceObject( lower = lower, upper = upper, step = step, source_ref = source_ref ) ) else: return "Slice", ( buildNode(provider, node.value, source_ref), lower, upper ) elif slice_kind == "ExtSlice": return "Subscript", ( buildNode(provider, node.value, source_ref), buildExtSliceNode(provider, node, source_ref) ) elif slice_kind == "Ellipsis": return "Subscript", ( buildNode(provider, node.value, source_ref), ExpressionConstantRef( constant = Ellipsis, source_ref = source_ref ) ) else: assert False, slice_kind elif kind in ("Tuple", "List"): return "Tuple", tuple( decodeAssignTarget( provider = provider, node = sub_node, source_ref = source_ref, allow_none = False ) for sub_node in node.elts ) elif kind == "Starred": return "Starred", decodeAssignTarget( provider = provider, node = node.value, source_ref = source_ref, allow_none = False ) else: assert False, (source_ref, kind)
def buildParseTree( provider, source_code, source_ref, is_module, is_main ): # Workaround: ast.parse cannot cope with some situations where a file is not # terminated by a new line. if not source_code.endswith( "\n" ): source_code = source_code + "\n" body = ast.parse( source_code, source_ref.getFilename() ) assert getKind( body ) == "Module" line_offset = source_ref.getLineNumber() - 1 if line_offset > 0: for created_node in ast.walk( body ): if hasattr( created_node, "lineno" ): created_node.lineno += line_offset body, doc = extractDocFromBody( body ) result = buildStatementsNode( provider = provider, nodes = body, source_ref = source_ref ) # Check if a __future__ imports really were at the beginning of the file. for node in body: if node in _future_import_nodes: _future_import_nodes.remove( node ) else: if _future_import_nodes: SyntaxErrors.raiseSyntaxError( reason = """\ from __future__ imports must occur at the beginning of the file""", col_offset = 1 if Utils.python_version >= 300 or \ not Options.isFullCompat() else None, source_ref = _future_import_nodes[0].source_ref ) internal_source_ref = source_ref.atInternal() statements = [] if is_module: # Add import of "site" module of main programs visibly in the node tree, # so recursion and optimization can pick it up, checking its effects. if is_main and not sys.flags.no_site: statements.append( StatementExpressionOnly( expression = ExpressionImportModule( module_name = "site", import_list = (), level = 0, source_ref = source_ref, ), source_ref = source_ref ) ) statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__doc__", source_ref = internal_source_ref ), source = ExpressionConstantRef( constant = doc, source_ref = internal_source_ref, user_provided = True ), source_ref = internal_source_ref ) ) statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__file__", source_ref = internal_source_ref ), source = ExpressionConstantRef( constant = source_ref.getFilename(), source_ref = internal_source_ref, user_provided = True ), source_ref = internal_source_ref ) ) if provider.isPythonPackage(): # TODO: __package__ is not set here, but automatically, which makes # it invisible though statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__path__", source_ref = internal_source_ref ), source = ExpressionConstantRef( constant = [ Utils.dirname( source_ref.getFilename() ) ], source_ref = internal_source_ref, user_provided = True ), source_ref = internal_source_ref ) ) if Utils.python_version >= 300: statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__cached__", source_ref = internal_source_ref ), source = ExpressionConstantRef( constant = None, source_ref = internal_source_ref, user_provided = True ), source_ref = internal_source_ref ) ) if Utils.python_version >= 330: # For Python3.3, it's set for both packages and non-packages. statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__package__", source_ref = internal_source_ref ), source = ExpressionConstantRef( constant = provider.getFullName() if provider.isPythonPackage() else provider.getPackage(), source_ref = internal_source_ref, user_provided = True ), source_ref = internal_source_ref ) ) if Utils.python_version >= 330 and not provider.isMainModule(): # Set initialzing at the beginning to True statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__initializing__", source_ref = internal_source_ref ), source = ExpressionConstantRef( constant = True, source_ref = internal_source_ref, user_provided = True ), source_ref = internal_source_ref ) ) # Now the module body if there is any at all. if result is not None: statements.extend( result.getStatements() ) if Utils.python_version >= 330 and not provider.isMainModule(): # Set initialzing at the beginning to True statements.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = "__initializing__", source_ref = internal_source_ref ), source = ExpressionConstantRef( constant = False, source_ref = internal_source_ref, user_provided = True ), source_ref = internal_source_ref ) ) if is_module: return makeModuleFrame( module = provider, statements = statements, source_ref = source_ref ) else: assert False
def buildImportFromNode(provider, node, source_ref): # "from .. import .." statements. This may trigger a star import, or # multiple names being looked up from the given module variable name. module_name = node.module if node.module is not None else "" level = node.level # Importing from "__future__" module may enable flags to the parser, # that we need to know. if module_name == "__future__": # Future imports we see are all legal, and known to work. if not provider.isPythonModule(): SyntaxErrors.raiseSyntaxError( reason = """\ from __future__ imports must occur at the beginning of the file""", col_offset = 8 if Utils.python_version >= 300 or \ not Options.isFullCompat() else None, source_ref = source_ref ) for import_desc in node.names: object_name, _local_name = import_desc.name, import_desc.asname enableFutureFeature( object_name = object_name, future_spec = source_ref.getFutureSpec(), source_ref = source_ref ) # Remember it for checks to be applied once module is complete. node.source_ref = source_ref _future_import_nodes.append(node) target_names = [] import_names = [] for import_desc in node.names: object_name, local_name = import_desc.name, import_desc.asname if object_name == '*': target_names.append(None) else: target_names.append( local_name if local_name is not None else object_name ) import_names.append(object_name) if None in target_names: # More than "*" is a syntax error in Python, need not care about this at # all, it's only allowed value for import list in this case. assert target_names == [None] # Python3 made this a syntax error unfortunately. if not provider.isPythonModule() and Utils.python_version >= 300: SyntaxErrors.raiseSyntaxError( "import * only allowed at module level", provider.getSourceReference() ) if provider.isExpressionFunctionBody(): provider.markAsStarImportContaining() return StatementImportStar( module_import = ExpressionImportModule( module_name = module_name, import_list = ('*',), level = level, source_ref = source_ref ), source_ref = source_ref ) else: # Make __future__ imports "hard" immediately, they cannot be any other # way. def makeImportName(import_name): if module_name == "__future__": return ExpressionImportModuleHard( module_name = "__future__", import_name = import_name, source_ref = source_ref ) else: # TODO: This ought to use a temporary variable for multiple # names, instead of importing multiple times. return ExpressionImportName( module = ExpressionImportModule( module_name = module_name, import_list = tuple(import_names), level = level, source_ref = source_ref ), import_name = import_name, source_ref = source_ref ) import_nodes = [] for target_name, import_name in zip(target_names, import_names): import_nodes.append( StatementAssignmentVariable( variable_ref = ExpressionTargetVariableRef( variable_name = mangleName(target_name, provider), source_ref = source_ref ), source = makeImportName( import_name = import_name, ), source_ref = source_ref ) ) # Note: Each import is sequential. It can succeed, and the failure of a # later one is not changing one. We can therefore have a sequence of # imports that only import one thing therefore. return StatementsSequence( statements = import_nodes, source_ref = source_ref )