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))
