def parse(source: Union[str, bytes],
fnam: str = None,
errors: Errors = None,
pyversion: Tuple[int, int] = defaults.PYTHON3_VERSION,
custom_typing_module: str = None,
implicit_any: bool = False) -> MypyFile:
"""Parse a source file, without doing any semantic analysis.
Return the parse tree. If errors is not provided, raise ParseError
on failure. Otherwise, use the errors object to report parse errors.
The pyversion (major, minor) argument determines the Python syntax variant.
"""
is_stub_file = bool(fnam) and fnam.endswith('.pyi')
try:
ast = typed_ast.parse(source, fnam, 'exec')
except SyntaxError as e:
if errors:
errors.set_file('<input>' if fnam is None else fnam)
errors.report(e.lineno, e.msg) # type: ignore
else:
raise
else:
tree = ASTConverter().visit(ast)
tree.path = fnam
tree.is_stub = is_stub_file
return tree
return MypyFile([], [], False, set(), weak_opts=set())
def parse(source: Union[str, bytes],
fnam: str = None,
errors: Errors = None,
pyversion: Tuple[int, int] = defaults.PYTHON3_VERSION,
custom_typing_module: str = None) -> MypyFile:
"""Parse a source file, without doing any semantic analysis.
Return the parse tree. If errors is not provided, raise ParseError
on failure. Otherwise, use the errors object to report parse errors.
The pyversion (major, minor) argument determines the Python syntax variant.
"""
is_stub_file = bool(fnam) and fnam.endswith('.pyi')
try:
assert pyversion[0] < 3 and not is_stub_file
ast = ast27.parse(source, fnam, 'exec')
tree = ASTConverter(
pyversion=pyversion,
is_stub=is_stub_file,
custom_typing_module=custom_typing_module,
).visit(ast)
assert isinstance(tree, MypyFile)
tree.path = fnam
tree.is_stub = is_stub_file
return tree
except (SyntaxError, TypeCommentParseError) as e:
if errors:
errors.set_file('<input>' if fnam is None else fnam)
errors.report(e.lineno, e.offset, e.msg)
else:
raise
return MypyFile([], [], False, set())
def parse(
source: Union[str, bytes],
fnam: Optional[str] = None,
errors: Optional[Errors] = None,
options: Options = Options()) -> MypyFile:
"""Parse a source file, without doing any semantic analysis.
Return the parse tree. If errors is not provided, raise ParseError
on failure. Otherwise, use the errors object to report parse errors.
"""
raise_on_error = False
if errors is None:
errors = Errors()
raise_on_error = True
errors.set_file('<input>' if fnam is None else fnam, None)
is_stub_file = bool(fnam) and fnam.endswith('.pyi')
try:
assert options.python_version[0] < 3 and not is_stub_file
ast = ast27.parse(source, fnam, 'exec')
tree = ASTConverter(
options=options,
is_stub=is_stub_file,
errors=errors,
).visit(ast)
assert isinstance(tree, MypyFile)
tree.path = fnam
tree.is_stub = is_stub_file
except SyntaxError as e:
errors.report(e.lineno, e.offset, e.msg)
tree = MypyFile([], [], False, set())
if raise_on_error and errors.is_errors():
errors.raise_error()
return tree
def visit_Module(self, mod: ast35.Module) -> Node:
body = self.fix_function_overloads(self.visit_list(mod.body))
return MypyFile(body,
self.imports,
False,
{ti.lineno for ti in mod.type_ignores},
weak_opts=set())
def visit_Module(self, mod: ast27.Module) -> MypyFile:
body = self.fix_function_overloads(self.translate_stmt_list(mod.body))
return MypyFile(body,
self.imports,
False,
{ti.lineno for ti in mod.type_ignores},
)
def visit_mypy_file(self, node: MypyFile) -> Node:
# NOTE: The 'names' and 'imports' instance variables will be empty!
new = MypyFile(self.nodes(node.defs), [], node.is_bom)
new._name = node._name
new._fullname = node._fullname
new.path = node.path
new.names = SymbolTable()
return new
def visit_mypy_file(self, node: MypyFile) -> MypyFile:
# NOTE: The 'names' and 'imports' instance variables will be empty!
new = MypyFile(self.statements(node.defs), [], node.is_bom,
ignored_lines=set(node.ignored_lines))
new._name = node._name
new._fullname = node._fullname
new.path = node.path
new.names = SymbolTable()
return new
def visit_Module(self, mod: ast27.Module) -> MypyFile:
body = self.fix_function_overloads(self.translate_stmt_list(mod.body))
ignores = [ti.lineno for ti in mod.type_ignores]
ignores.extend(self.extra_type_ignores)
return MypyFile(body,
self.imports,
False,
set(ignores),
)
def visit_Module(self, mod: ast27.Module) -> MypyFile:
self.type_ignores = {ti.lineno: parse_type_ignore_tag(ti.tag) # type: ignore
for ti in mod.type_ignores}
body = self.fix_function_overloads(self.translate_stmt_list(mod.body))
return MypyFile(body,
self.imports,
False,
self.type_ignores,
)
def visit_mypy_file(self, node: MypyFile) -> MypyFile:
# NOTE: The 'names' and 'imports' instance variables will be empty!
ignored_lines = {line: codes[:]
for line, codes in node.ignored_lines.items()}
new = MypyFile(self.statements(node.defs), [], node.is_bom,
ignored_lines=ignored_lines)
new._fullname = node._fullname
new.path = node.path
new.names = SymbolTable()
return new
def visit_Module(self, mod: ast27.Module) -> MypyFile:
self.type_ignores = {}
for ti in mod.type_ignores:
parsed = parse_type_ignore_tag(ti.tag) # type: ignore[attr-defined]
if parsed is not None:
self.type_ignores[ti.lineno] = parsed
else:
self.fail(INVALID_TYPE_IGNORE, ti.lineno, -1)
body = self.fix_function_overloads(self.translate_stmt_list(mod.body, module=True))
return MypyFile(body,
self.imports,
False,
self.type_ignores,
)
def parse(source: Union[str, bytes],
fnam: str,
module: Optional[str],
errors: Optional[Errors] = None,
options: Optional[Options] = None) -> MypyFile:
"""Parse a source file, without doing any semantic analysis.
Return the parse tree. If errors is not provided, raise ParseError
on failure. Otherwise, use the errors object to report parse errors.
"""
raise_on_error = False
if errors is None:
errors = Errors()
raise_on_error = True
if options is None:
options = Options()
errors.set_file(fnam, module)
is_stub_file = fnam.endswith('.pyi')
try:
if is_stub_file:
feature_version = defaults.PYTHON3_VERSION[1]
else:
assert options.python_version[0] >= 3
feature_version = options.python_version[1]
ast = ast3.parse(source, fnam, 'exec', feature_version=feature_version)
tree = ASTConverter(
options=options,
is_stub=is_stub_file,
errors=errors,
).visit(ast)
tree.path = fnam
tree.is_stub = is_stub_file
except SyntaxError as e:
errors.reportErrorCode(errorcode.SYNTAX_ERROR(e.msg),
e.lineno,
e.offset,
blocker=True)
tree = MypyFile([], [], False, set())
if raise_on_error and errors.is_errors():
errors.raise_error()
return tree
def parse(source: Union[str, bytes],
fnam: str,
module: Optional[str],
errors: Optional[Errors] = None,
options: Optional[Options] = None) -> MypyFile:
"""Parse a source file, without doing any semantic analysis.
Return the parse tree. If errors is not provided, raise ParseError
on failure. Otherwise, use the errors object to report parse errors.
"""
raise_on_error = False
if errors is None:
errors = Errors()
raise_on_error = True
if options is None:
options = Options()
errors.set_file(fnam, module)
is_stub_file = fnam.endswith('.pyi')
try:
assert options.python_version[0] < 3 and not is_stub_file
# Disable deprecation warnings about <>.
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=DeprecationWarning)
ast = ast27.parse(source, fnam, 'exec')
tree = ASTConverter(
options=options,
errors=errors,
).visit(ast)
assert isinstance(tree, MypyFile)
tree.path = fnam
tree.is_stub = is_stub_file
except SyntaxError as e:
errors.report(e.lineno if e.lineno is not None else -1,
e.offset,
e.msg,
blocker=True,
code=codes.SYNTAX)
tree = MypyFile([], [], False, {})
if raise_on_error and errors.is_errors():
errors.raise_error()
return tree
def parse(source: Union[str, bytes],
fnam: str = None,
errors: Errors = None,
pyversion: Tuple[int, int] = defaults.PYTHON3_VERSION,
custom_typing_module: str = None) -> MypyFile:
"""Parse a source file, without doing any semantic analysis.
Return the parse tree. If errors is not provided, raise ParseError
on failure. Otherwise, use the errors object to report parse errors.
The pyversion (major, minor) argument determines the Python syntax variant.
"""
raise_on_error = False
if errors is None:
errors = Errors()
raise_on_error = True
errors.set_file('<input>' if fnam is None else fnam)
is_stub_file = bool(fnam) and fnam.endswith('.pyi')
try:
assert pyversion[0] >= 3 or is_stub_file
feature_version = pyversion[
1] if not is_stub_file else defaults.PYTHON3_VERSION[1]
ast = ast3.parse(source, fnam, 'exec', feature_version=feature_version)
tree = ASTConverter(
pyversion=pyversion,
is_stub=is_stub_file,
errors=errors,
custom_typing_module=custom_typing_module,
).visit(ast)
tree.path = fnam
tree.is_stub = is_stub_file
except SyntaxError as e:
errors.report(e.lineno, e.offset, e.msg)
tree = MypyFile([], [], False, set())
if raise_on_error and errors.is_errors():
errors.raise_error()
return tree