def process(self) -> None: """Parse the file, store global names and advance to the next state.""" if self.id in self.manager.semantic_analyzer.modules: self.fail(self.path, 1, "Duplicate module named '{}'".format(self.id)) return tree = self.parse(self.program_text, self.path) # Store the parsed module in the shared module symbol table. self.manager.semantic_analyzer.modules[self.id] = tree if '.' in self.id: # Include module in the symbol table of the enclosing package. c = self.id.split('.') p = '.'.join(c[:-1]) sem_anal = self.manager.semantic_analyzer if p in sem_anal.modules: sem_anal.modules[p].names[c[-1]] = SymbolTableNode( MODULE_REF, tree, p) if self.id != 'builtins': # The builtins module is imported implicitly in every program (it # contains definitions of int, print etc.). self.manager.trace('import builtins') if not self.import_module('builtins'): self.fail(self.path, 1, 'Could not find builtins') # Do the first pass of semantic analysis: add top-level definitions in # the file to the symbol table. We must do this before processing imports, # since this may mark some import statements as unreachable. first = FirstPass(self.semantic_analyzer()) first.analyze(tree, self.path, self.id) # Add all directly imported modules to be processed (however they are # not processed yet, just waiting to be processed). for id, line in self.manager.all_imported_modules_in_file(tree): self.errors().push_import_context(self.path, line) try: res = self.import_module(id) finally: self.errors().pop_import_context() if not res: if id == '': # Must be from a relative import. self.fail(self.path, line, "No parent module -- cannot perform relative import".format(id), blocker=True) else: if (line not in tree.ignored_lines and 'import' not in tree.weak_opts and not self.silent): self.module_not_found(self.path, line, id) self.manager.missing_modules.add(id) # Initialize module symbol table, which was populated by the semantic # analyzer. tree.names = self.semantic_analyzer().globals # Replace this state object with a parsed state in BuildManager. self.switch_state(ParsedFile(self.info(), tree))
def process(self) -> None: """Parse the file, store global names and advance to the next state.""" tree = self.parse(self.program_text, self.path) # Store the parsed module in the shared module symbol table. assert self.id not in self.manager.semantic_analyzer.modules, ( 'Module %s processed twice' % self.id) self.manager.semantic_analyzer.modules[self.id] = tree if '.' in self.id: # Include module in the symbol table of the enclosing package. c = self.id.split('.') p = '.'.join(c[:-1]) sem_anal = self.manager.semantic_analyzer sem_anal.modules[p].names[c[-1]] = SymbolTableNode( MODULE_REF, tree, p) if self.id != 'builtins': # The builtins module is imported implicitly in every program (it # contains definitions of int, print etc.). trace('import builtins') if not self.import_module('builtins'): self.fail(self.path, 1, 'Could not find builtins') # Do the first pass of semantic analysis: add top-level definitions in # the file to the symbol table. We must do this before processing imports, # since this may mark some import statements as unreachable. first = FirstPass(self.semantic_analyzer()) first.analyze(tree, self.path, self.id) # Add all directly imported modules to be processed (however they are # not processed yet, just waiting to be processed). for id, line in self.manager.all_imported_modules_in_file(tree): self.errors().push_import_context(self.path, line) try: res = self.import_module(id) finally: self.errors().pop_import_context() if not res: if id == '': # Must be from a relative import. self.fail( self.path, line, "No parent module -- cannot perform relative import". format(id), blocker=True) else: if (line not in tree.ignored_lines and 'import' not in tree.weak_opts): self.module_not_found(self.path, line, id) self.manager.missing_modules.add(id) # Initialize module symbol table, which was populated by the semantic # analyzer. tree.names = self.semantic_analyzer().globals # Replace this state object with a parsed state in BuildManager. self.switch_state(ParsedFile(self.info(), tree))
def process(self) -> None: """Parse the file, store global names and advance to the next state.""" tree = self.parse(self.program_text, self.path) # Store the parsed module in the shared module symbol table. self.manager.semantic_analyzer.modules[self.id] = tree if '.' in self.id: # Include module in the symbol table of the enclosing package. c = self.id.split('.') p = '.'.join(c[:-1]) sem_anal = self.manager.semantic_analyzer sem_anal.modules[p].names[c[-1]] = SymbolTableNode( MODULE_REF, tree, p) if self.id != 'builtins': # The builtins module is imported implicitly in every program (it # contains definitions of int, print etc.). trace('import builtins') if not self.import_module('builtins'): self.fail(self.path, 1, 'Could not find builtins') # Add all directly imported modules to be processed (however they are # not processed yet, just waiting to be processed). for id, line in self.manager.all_imported_modules_in_file(tree): self.errors().push_import_context(self.path, line) try: res = self.import_module(id) finally: self.errors().pop_import_context() if not res: self.fail(self.path, line, "No module named '{}'".format(id), blocker=False) self.manager.missing_modules.add(id) # Do the first pass of semantic analysis: add top-level definitions in # the file to the symbol table. first = FirstPass(self.semantic_analyzer()) first.analyze(tree, self.path, self.id) # Initialize module symbol table, which was populated by the semantic # analyzer. tree.names = self.semantic_analyzer().globals # Replace this state object with a parsed state in BuildManager. self.switch_state(ParsedFile(self.info(), tree))
def process(self) -> None: """Parse the file, store global names and advance to the next state.""" tree = self.parse(self.program_text, self.path) # Store the parsed module in the shared module symbol table. self.manager.semantic_analyzer.modules[self.id] = tree if '.' in self.id: # Include module in the symbol table of the enclosing package. c = self.id.split('.') p = '.'.join(c[:-1]) sem_anal = self.manager.semantic_analyzer sem_anal.modules[p].names[c[-1]] = SymbolTableNode( MODULE_REF, tree, p) if self.id != 'builtins': # The builtins module is imported implicitly in every program (it # contains definitions of int, print etc.). trace('import builtins') if not self.import_module('builtins'): self.fail(self.path, 1, 'Could not find builtins') # Add all directly imported modules to be processed (however they are # not processed yet, just waiting to be processed). for id, line in self.manager.all_imported_modules_in_file(tree): self.errors().push_import_context(self.path, line) try: res = self.import_module(id) finally: self.errors().pop_import_context() if not res: self.fail(self.path, line, "No module named '{}'".format(id)) # Do the first pass of semantic analysis: add top-level definitions in # the file to the symbol table. first = FirstPass(self.semantic_analyzer()) first.analyze(tree, self.path, self.id) # Initialize module symbol table, which was populated by the semantic # analyzer. tree.names = self.semantic_analyzer().globals # Replace this state object with a parsed state in BuildManager. self.switch_state(ParsedFile(self.info(), tree))