feature_version: int = PY_MINOR_VERSION) -> AST:

return ast3.parse(source, filename, mode,

type_comments=True, # This works the magic

fnam: str,

module: Optional[str],

errors: Optional[Errors] = None,

options: Optional[Options] = None) -> MypyFile:

"""Parse a source file, without doing any semantic analysis.

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]

# Disable deprecation warnings about \u

with warnings.catch_warnings():

warnings.filterwarnings("ignore", category=DeprecationWarning)

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:

# alias to please mypyc

is_py38_or_earlier = sys.version_info < (3, 9)

if is_py38_or_earlier and e.filename == "<fstring>":

# In Python 3.8 and earlier, syntax errors in f-strings have lineno relative to the

# start of the f-string. This would be misleading, as mypy will report the error as the

# lineno within the file.

e.lineno = None

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

"""Parse optional "[code, ...]" tag after "# type: ignore".

if not tag or tag.strip() == '' or tag.strip().startswith('#'):

# No tag -- ignore all errors.

return []

m = re.match(r'\s*\[([^]#]*)\]\s*(#.*)?$', tag)

if m is None:

# Invalid "# type: ignore" comment.

return None

line: int,

column: int,

errors: Optional[Errors],

assume_str_is_unicode: bool = True,

) -> Tuple[Optional[List[str]], Optional[ProperType]]:

"""Parse type portion of a type comment (+ optional type ignore).

try:

typ = ast3_parse(type_comment, '<type_comment>', 'eval')

except SyntaxError:

if errors is not None:

stripped_type = type_comment.split("#", 2)[0].strip()

err_msg = "{} '{}'".format(TYPE_COMMENT_SYNTAX_ERROR, stripped_type)

errors.report(line, column, err_msg, blocker=True, code=codes.SYNTAX)

return None, None

else:

raise

else:

extra_ignore = TYPE_IGNORE_PATTERN.match(type_comment)

if extra_ignore:

# Typeshed has a non-optional return type for group!

tag = cast(Any, extra_ignore).group(1) # type: Optional[str]

ignored = parse_type_ignore_tag(tag) # type: Optional[List[str]]

if ignored is None:

if errors is not None:

errors.report(line, column, INVALID_TYPE_IGNORE, code=codes.SYNTAX)

else:

raise SyntaxError

else:

ignored = None

assert isinstance(typ, ast3_Expression)

converted = TypeConverter(errors,

line=line,

override_column=column,

assume_str_is_unicode=assume_str_is_unicode).visit(typ.body)

line: int, column: int, assume_str_is_unicode: bool = True) -> ProperType:

"""Parses a type that was originally present inside of an explicit string,

try:

_, node = parse_type_comment(expr_string.strip(), line=line, column=column, errors=None,

assume_str_is_unicode=assume_str_is_unicode)

if isinstance(node, UnboundType) and node.original_str_expr is None:

node.original_str_expr = expr_string

node.original_str_fallback = expr_fallback_name

return node

else:

return RawExpressionType(expr_string, expr_fallback_name, line, column)

except (SyntaxError, ValueError):

# Note: the parser will raise a `ValueError` instead of a SyntaxError if

# the string happens to contain things like \x00.

if isinstance(expr, Name):

return expr.id == 'no_type_check'

elif isinstance(expr, Attribute):

if isinstance(expr.value, Name):

return expr.value.id == 'typing' and expr.attr == 'no_type_check'

def __init__(self,

options: Options,

is_stub: bool,

errors: Errors) -> None:

# 'C' for class, 'F' for function

self.class_and_function_stack = [] # type: List[Literal['C', 'F']]

self.imports = [] # type: List[ImportBase]

self.options = options

self.is_stub = is_stub

self.errors = errors

self.type_ignores = {} # type: Dict[int, List[str]]

# Cache of visit_X methods keyed by type of visited object

self.visitor_cache = {} # type: Dict[type, Callable[[Optional[AST]], Any]]

def note(self, msg: str, line: int, column: int) -> None:

self.errors.report(line, column, msg, severity='note', code=codes.SYNTAX)

def fail(self,

msg: str,

line: int,

column: int,

blocker: bool = True) -> None:

if blocker or not self.options.ignore_errors:

self.errors.report(line, column, msg, blocker=blocker, code=codes.SYNTAX)

def visit(self, node: Optional[AST]) -> Any:

if node is None:

return None

typeobj = type(node)

visitor = self.visitor_cache.get(typeobj)

if visitor is None:

method = 'visit_' + node.__class__.__name__

visitor = getattr(self, method)

self.visitor_cache[typeobj] = visitor

return visitor(node)

def set_line(self, node: N, n: Union[ast3.expr, ast3.stmt, ast3.ExceptHandler]) -> N:

node.line = n.lineno

node.column = n.col_offset

node.end_line = getattr(n, "end_lineno", None) if isinstance(n, ast3.expr) else None

return node

def translate_opt_expr_list(self, l: Sequence[Optional[AST]]) -> List[Optional[Expression]]:

res = [] # type: List[Optional[Expression]]

for e in l:

exp = self.visit(e)

res.append(exp)

return res

def translate_expr_list(self, l: Sequence[AST]) -> List[Expression]:

return cast(List[Expression], self.translate_opt_expr_list(l))

def get_lineno(self, node: Union[ast3.expr, ast3.stmt]) -> int:

if (isinstance(node, (ast3.AsyncFunctionDef, ast3.ClassDef, ast3.FunctionDef))

and node.decorator_list):

return node.decorator_list[0].lineno

return node.lineno

def translate_stmt_list(self,

stmts: Sequence[ast3.stmt],

ismodule: bool = False) -> List[Statement]:

# A "# type: ignore" comment before the first statement of a module

# ignores the whole module:

if (ismodule and stmts and self.type_ignores

and min(self.type_ignores) < self.get_lineno(stmts[0])):

self.errors.used_ignored_lines[self.errors.file].add(min(self.type_ignores))

block = Block(self.fix_function_overloads(self.translate_stmt_list(stmts)))

mark_block_unreachable(block)

return [block]

res = [] # type: List[Statement]

for stmt in stmts:

node = self.visit(stmt)

res.append(node)

return res

def translate_type_comment(self,

n: Union[ast3.stmt, ast3.arg],

type_comment: Optional[str]) -> Optional[ProperType]:

if type_comment is None:

return None

else:

lineno = n.lineno

extra_ignore, typ = parse_type_comment(type_comment,

lineno,

n.col_offset,

self.errors)

if extra_ignore is not None:

self.type_ignores[lineno] = extra_ignore

return typ

op_map = {

ast3.Add: '+',

ast3.Sub: '-',

ast3.Mult: '*',

ast3.MatMult: '@',

ast3.Div: '/',

ast3.Mod: '%',

ast3.Pow: '**',

ast3.LShift: '<<',

ast3.RShift: '>>',

ast3.BitOr: '|',

ast3.BitXor: '^',

ast3.BitAnd: '&',

ast3.FloorDiv: '//'

} # type: Final[Dict[typing.Type[AST], str]]

def from_operator(self, op: ast3.operator) -> str:

op_name = ASTConverter.op_map.get(type(op))

if op_name is None:

raise RuntimeError('Unknown operator ' + str(type(op)))

else:

return op_name

comp_op_map = {

ast3.Gt: '>',

ast3.Lt: '<',

ast3.Eq: '==',

ast3.GtE: '>=',

ast3.LtE: '<=',

ast3.NotEq: '!=',

ast3.Is: 'is',

ast3.IsNot: 'is not',

ast3.In: 'in',

ast3.NotIn: 'not in'

} # type: Final[Dict[typing.Type[AST], str]]

def from_comp_operator(self, op: ast3.cmpop) -> str:

op_name = ASTConverter.comp_op_map.get(type(op))

if op_name is None:

raise RuntimeError('Unknown comparison operator ' + str(type(op)))

else:

return op_name

def as_block(self, stmts: List[ast3.stmt], lineno: int) -> Optional[Block]:

b = None

if stmts:

b = Block(self.fix_function_overloads(self.translate_stmt_list(stmts)))

b.set_line(lineno)

return b

def as_required_block(self, stmts: List[ast3.stmt], lineno: int) -> Block:

assert stmts # must be non-empty

b = Block(self.fix_function_overloads(self.translate_stmt_list(stmts)))

b.set_line(lineno)

return b

def fix_function_overloads(self, stmts: List[Statement]) -> List[Statement]:

ret = [] # type: List[Statement]

current_overload = [] # type: List[OverloadPart]

current_overload_name = None # type: Optional[str]

for stmt in stmts:

if (current_overload_name is not None

and isinstance(stmt, (Decorator, FuncDef))

and stmt.name == current_overload_name):

current_overload.append(stmt)

else:

if len(current_overload) == 1:

ret.append(current_overload[0])

elif len(current_overload) > 1:

ret.append(OverloadedFuncDef(current_overload))

if isinstance(stmt, Decorator):

current_overload = [stmt]

current_overload_name = stmt.name

else:

current_overload = []

current_overload_name = None

ret.append(stmt)

if len(current_overload) == 1:

ret.append(current_overload[0])

elif len(current_overload) > 1:

ret.append(OverloadedFuncDef(current_overload))

return ret

def in_method_scope(self) -> bool:

return self.class_and_function_stack[-2:] == ['C', 'F']

def translate_module_id(self, id: str) -> str:

"""Return the actual, internal module id for a source text id.

if id == self.options.custom_typing_module:

return 'typing'

elif id == '__builtin__' and self.options.python_version[0] == 2:

# HACK: __builtin__ in Python 2 is aliases to builtins. However, the implementation

# is named __builtin__.py (there is another layer of translation elsewhere).

return 'builtins'

return id

def visit_Module(self, mod: ast3.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, ismodule=True))

return MypyFile(body,

self.imports,

False,

self.type_ignores,

)

# --- stmt ---

# FunctionDef(identifier name, arguments args,

# stmt* body, expr* decorator_list, expr? returns, string? type_comment)

# arguments = (arg* args, arg? vararg, arg* kwonlyargs, expr* kw_defaults,

# arg? kwarg, expr* defaults)

def visit_FunctionDef(self, n: ast3.FunctionDef) -> Union[FuncDef, Decorator]:

return self.do_func_def(n)

# AsyncFunctionDef(identifier name, arguments args,

# stmt* body, expr* decorator_list, expr? returns, string? type_comment)

def visit_AsyncFunctionDef(self, n: ast3.AsyncFunctionDef) -> Union[FuncDef, Decorator]:

return self.do_func_def(n, is_coroutine=True)

def do_func_def(self, n: Union[ast3.FunctionDef, ast3.AsyncFunctionDef],

is_coroutine: bool = False) -> Union[FuncDef, Decorator]:

"""Helper shared between visit_FunctionDef and visit_AsyncFunctionDef."""

self.class_and_function_stack.append('F')

no_type_check = bool(n.decorator_list and

any(is_no_type_check_decorator(d) for d in n.decorator_list))

lineno = n.lineno

args = self.transform_args(n.args, lineno, no_type_check=no_type_check)

posonlyargs = [arg.arg for arg in getattr(n.args, "posonlyargs", [])]

arg_kinds = [arg.kind for arg in args]

arg_names = [arg.variable.name for arg in args] # type: List[Optional[str]]

arg_names = [None if argument_elide_name(name) or name in posonlyargs else name

for name in arg_names]

if special_function_elide_names(n.name):

arg_names = [None] * len(arg_names)

arg_types = [] # type: List[Optional[Type]]

if no_type_check:

arg_types = [None] * len(args)

return_type = None

elif n.type_comment is not None:

try:

func_type_ast = ast3_parse(n.type_comment, '<func_type>', 'func_type')

assert isinstance(func_type_ast, FunctionType)

# for ellipsis arg

if (len(func_type_ast.argtypes) == 1 and

isinstance(func_type_ast.argtypes[0], ast3_Ellipsis)):

if n.returns:

# PEP 484 disallows both type annotations and type comments

self.fail(message_registry.DUPLICATE_TYPE_SIGNATURES, lineno, n.col_offset)

arg_types = [a.type_annotation

if a.type_annotation is not None

else AnyType(TypeOfAny.unannotated)

for a in args]

else:

# PEP 484 disallows both type annotations and type comments

if n.returns or any(a.type_annotation is not None for a in args):

self.fail(message_registry.DUPLICATE_TYPE_SIGNATURES, lineno, n.col_offset)

translated_args = (TypeConverter(self.errors,

line=lineno,

override_column=n.col_offset)

.translate_expr_list(func_type_ast.argtypes))

arg_types = [a if a is not None else AnyType(TypeOfAny.unannotated)

for a in translated_args]

return_type = TypeConverter(self.errors,

line=lineno).visit(func_type_ast.returns)

# add implicit self type

if self.in_method_scope() and len(arg_types) < len(args):

arg_types.insert(0, AnyType(TypeOfAny.special_form))

except SyntaxError:

stripped_type = n.type_comment.split("#", 2)[0].strip()

err_msg = "{} '{}'".format(TYPE_COMMENT_SYNTAX_ERROR, stripped_type)

self.fail(err_msg, lineno, n.col_offset)

if n.type_comment and n.type_comment[0] not in ["(", "#"]:

self.note('Suggestion: wrap argument types in parentheses',

lineno, n.col_offset)

arg_types = [AnyType(TypeOfAny.from_error)] * len(args)

return_type = AnyType(TypeOfAny.from_error)

else:

arg_types = [a.type_annotation for a in args]

return_type = TypeConverter(self.errors, line=n.returns.lineno

if n.returns else lineno).visit(n.returns)

for arg, arg_type in zip(args, arg_types):

self.set_type_optional(arg_type, arg.initializer)

func_type = None

if any(arg_types) or return_type:

if len(arg_types) != 1 and any(isinstance(t, EllipsisType)

for t in arg_types):

self.fail("Ellipses cannot accompany other argument types "

"in function type signature", lineno, n.col_offset)

elif len(arg_types) > len(arg_kinds):

self.fail('Type signature has too many arguments', lineno, n.col_offset,

blocker=False)

elif len(arg_types) < len(arg_kinds):

self.fail('Type signature has too few arguments', lineno, n.col_offset,

blocker=False)

else:

func_type = CallableType([a if a is not None else

AnyType(TypeOfAny.unannotated) for a in arg_types],

arg_kinds,

arg_names,

return_type if return_type is not None else

AnyType(TypeOfAny.unannotated),

_dummy_fallback)

func_def = FuncDef(n.name,

args,

self.as_required_block(n.body, lineno),

func_type)

if isinstance(func_def.type, CallableType):

# semanal.py does some in-place modifications we want to avoid

func_def.unanalyzed_type = func_def.type.copy_modified()

if is_coroutine:

func_def.is_coroutine = True

if func_type is not None:

func_type.definition = func_def

func_type.line = lineno

if n.decorator_list:

if sys.version_info < (3, 8):

# Before 3.8, [typed_]ast the line number points to the first decorator.

# In 3.8, it points to the 'def' line, where we want it.

lineno += len(n.decorator_list)

end_lineno = None # type: Optional[int]

else:

# Set end_lineno to the old pre-3.8 lineno, in order to keep

# existing "# type: ignore" comments working:

end_lineno = n.decorator_list[0].lineno + len(n.decorator_list)

var = Var(func_def.name)

var.is_ready = False

var.set_line(lineno)

func_def.is_decorated = True

func_def.set_line(lineno, n.col_offset, end_lineno)

func_def.body.set_line(lineno) # TODO: Why?

deco = Decorator(func_def, self.translate_expr_list(n.decorator_list), var)

first = n.decorator_list[0]

deco.set_line(first.lineno, first.col_offset)

retval = deco # type: Union[FuncDef, Decorator]

else:

# FuncDef overrides set_line -- can't use self.set_line

func_def.set_line(lineno, n.col_offset)

retval = func_def

self.class_and_function_stack.pop()

return retval

def set_type_optional(self, type: Optional[Type], initializer: Optional[Expression]) -> None:

if self.options.no_implicit_optional:

return

# Indicate that type should be wrapped in an Optional if arg is initialized to None.

optional = isinstance(initializer, NameExpr) and initializer.name == 'None'

if isinstance(type, UnboundType):

type.optional = optional

def transform_args(self,

args: ast3.arguments,

line: int,

no_type_check: bool = False,

) -> List[Argument]:

new_args = []

names = [] # type: List[ast3.arg]

args_args = getattr(args, "posonlyargs", []) + args.args

args_defaults = args.defaults

num_no_defaults = len(args_args) - len(args_defaults)

# positional arguments without defaults

for a in args_args[:num_no_defaults]:

new_args.append(self.make_argument(a, None, ARG_POS, no_type_check))

names.append(a)

# positional arguments with defaults

for a, d in zip(args_args[num_no_defaults:], args_defaults):

new_args.append(self.make_argument(a, d, ARG_OPT, no_type_check))

names.append(a)

# *arg

if args.vararg is not None:

new_args.append(self.make_argument(args.vararg, None, ARG_STAR, no_type_check))

names.append(args.vararg)

# keyword-only arguments with defaults

for a, d in zip(args.kwonlyargs, args.kw_defaults):

new_args.append(self.make_argument(

a,

d,

ARG_NAMED if d is None else ARG_NAMED_OPT,

no_type_check))

names.append(a)

# **kwarg

if args.kwarg is not None:

new_args.append(self.make_argument(args.kwarg, None, ARG_STAR2, no_type_check))

names.append(args.kwarg)

check_arg_names([arg.variable.name for arg in new_args], names, self.fail_arg)

return new_args

def make_argument(self, arg: ast3.arg, default: Optional[ast3.expr], kind: int,

no_type_check: bool) -> Argument:

if no_type_check:

arg_type = None

else:

annotation = arg.annotation

type_comment = arg.type_comment

if annotation is not None and type_comment is not None:

self.fail(message_registry.DUPLICATE_TYPE_SIGNATURES, arg.lineno, arg.col_offset)

arg_type = None

if annotation is not None:

arg_type = TypeConverter(self.errors, line=arg.lineno).visit(annotation)

else:

arg_type = self.translate_type_comment(arg, type_comment)

return Argument(Var(arg.arg), arg_type, self.visit(default), kind)

def fail_arg(self, msg: str, arg: ast3.arg) -> None:

self.fail(msg, arg.lineno, arg.col_offset)

# ClassDef(identifier name,

# expr* bases,

# keyword* keywords,

# stmt* body,

# expr* decorator_list)

def visit_ClassDef(self, n: ast3.ClassDef) -> ClassDef:

self.class_and_function_stack.append('C')

keywords = [(kw.arg, self.visit(kw.value))

for kw in n.keywords if kw.arg]

cdef = ClassDef(n.name,

self.as_required_block(n.body, n.lineno),

None,

self.translate_expr_list(n.bases),

metaclass=dict(keywords).get('metaclass'),

keywords=keywords)

cdef.decorators = self.translate_expr_list(n.decorator_list)

# Set end_lineno to the old mypy 0.700 lineno, in order to keep

# existing "# type: ignore" comments working:

if sys.version_info < (3, 8):

cdef.line = n.lineno + len(n.decorator_list)

cdef.end_line = n.lineno

else:

cdef.line = n.lineno

cdef.end_line = n.decorator_list[0].lineno if n.decorator_list else None

cdef.column = n.col_offset

self.class_and_function_stack.pop()

return cdef

# Return(expr? value)

def visit_Return(self, n: ast3.Return) -> ReturnStmt:

node = ReturnStmt(self.visit(n.value))

return self.set_line(node, n)

# Delete(expr* targets)

def visit_Delete(self, n: ast3.Delete) -> DelStmt:

if len(n.targets) > 1:

tup = TupleExpr(self.translate_expr_list(n.targets))

tup.set_line(n.lineno)

node = DelStmt(tup)

else:

node = DelStmt(self.visit(n.targets[0]))

return self.set_line(node, n)

# Assign(expr* targets, expr? value, string? type_comment, expr? annotation)

def visit_Assign(self, n: ast3.Assign) -> AssignmentStmt:

lvalues = self.translate_expr_list(n.targets)

rvalue = self.visit(n.value)

typ = self.translate_type_comment(n, n.type_comment)

s = AssignmentStmt(lvalues, rvalue, type=typ, new_syntax=False)

return self.set_line(s, n)

# AnnAssign(expr target, expr annotation, expr? value, int simple)

def visit_AnnAssign(self, n: ast3.AnnAssign) -> AssignmentStmt:

line = n.lineno

if n.value is None: # always allow 'x: int'

rvalue = TempNode(AnyType(TypeOfAny.special_form), no_rhs=True) # type: Expression

rvalue.line = line

rvalue.column = n.col_offset

else:

rvalue = self.visit(n.value)

typ = TypeConverter(self.errors, line=line).visit(n.annotation)

assert typ is not None

typ.column = n.annotation.col_offset

s = AssignmentStmt([self.visit(n.target)], rvalue, type=typ, new_syntax=True)

return self.set_line(s, n)

# AugAssign(expr target, operator op, expr value)

def visit_AugAssign(self, n: ast3.AugAssign) -> OperatorAssignmentStmt:

s = OperatorAssignmentStmt(self.from_operator(n.op),

self.visit(n.target),

self.visit(n.value))

return self.set_line(s, n)

# For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)

def visit_For(self, n: ast3.For) -> ForStmt:

target_type = self.translate_type_comment(n, n.type_comment)

node = ForStmt(self.visit(n.target),

self.visit(n.iter),

self.as_required_block(n.body, n.lineno),

self.as_block(n.orelse, n.lineno),

target_type)

return self.set_line(node, n)

# AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)

def visit_AsyncFor(self, n: ast3.AsyncFor) -> ForStmt:

target_type = self.translate_type_comment(n, n.type_comment)

node = ForStmt(self.visit(n.target),

self.visit(n.iter),

self.as_required_block(n.body, n.lineno),

self.as_block(n.orelse, n.lineno),

target_type)

node.is_async = True

return self.set_line(node, n)

# While(expr test, stmt* body, stmt* orelse)

def visit_While(self, n: ast3.While) -> WhileStmt:

node = WhileStmt(self.visit(n.test),

self.as_required_block(n.body, n.lineno),

self.as_block(n.orelse, n.lineno))

return self.set_line(node, n)

# If(expr test, stmt* body, stmt* orelse)

def visit_If(self, n: ast3.If) -> IfStmt:

lineno = n.lineno

node = IfStmt([self.visit(n.test)],

[self.as_required_block(n.body, lineno)],

self.as_block(n.orelse, lineno))

return self.set_line(node, n)

# With(withitem* items, stmt* body, string? type_comment)

def visit_With(self, n: ast3.With) -> WithStmt:

target_type = self.translate_type_comment(n, n.type_comment)

node = WithStmt([self.visit(i.context_expr) for i in n.items],

[self.visit(i.optional_vars) for i in n.items],

self.as_required_block(n.body, n.lineno),

target_type)

return self.set_line(node, n)

# AsyncWith(withitem* items, stmt* body, string? type_comment)

def visit_AsyncWith(self, n: ast3.AsyncWith) -> WithStmt:

target_type = self.translate_type_comment(n, n.type_comment)

s = WithStmt([self.visit(i.context_expr) for i in n.items],

[self.visit(i.optional_vars) for i in n.items],

self.as_required_block(n.body, n.lineno),

target_type)

s.is_async = True

return self.set_line(s, n)

# Raise(expr? exc, expr? cause)

def visit_Raise(self, n: ast3.Raise) -> RaiseStmt:

node = RaiseStmt(self.visit(n.exc), self.visit(n.cause))

return self.set_line(node, n)

# Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)

def visit_Try(self, n: ast3.Try) -> TryStmt:

vs = [

self.set_line(NameExpr(h.name), h) if h.name is not None else None for h in n.handlers

]

types = [self.visit(h.type) for h in n.handlers]

handlers = [self.as_required_block(h.body, h.lineno) for h in n.handlers]

node = TryStmt(self.as_required_block(n.body, n.lineno),

vs,

types,

handlers,

self.as_block(n.orelse, n.lineno),

self.as_block(n.finalbody, n.lineno))

return self.set_line(node, n)

# Assert(expr test, expr? msg)

def visit_Assert(self, n: ast3.Assert) -> AssertStmt:

node = AssertStmt(self.visit(n.test), self.visit(n.msg))

return self.set_line(node, n)

# Import(alias* names)

def visit_Import(self, n: ast3.Import) -> Import:

names = [] # type: List[Tuple[str, Optional[str]]]

for alias in n.names:

name = self.translate_module_id(alias.name)

asname = alias.asname

if asname is None and name != alias.name:

# if the module name has been translated (and it's not already

# an explicit import-as), make it an implicit import-as the

# original name

asname = alias.name

names.append((name, asname))

i = Import(names)

self.imports.append(i)

return self.set_line(i, n)

# ImportFrom(identifier? module, alias* names, int? level)

def visit_ImportFrom(self, n: ast3.ImportFrom) -> ImportBase:

assert n.level is not None

if len(n.names) == 1 and n.names[0].name == '*':

mod = n.module if n.module is not None else ''

i = ImportAll(mod, n.level) # type: ImportBase

else:

i = ImportFrom(self.translate_module_id(n.module) if n.module is not None else '',

n.level,

[(a.name, a.asname) for a in n.names])

self.imports.append(i)

return self.set_line(i, n)

# Global(identifier* names)

def visit_Global(self, n: ast3.Global) -> GlobalDecl:

g = GlobalDecl(n.names)

return self.set_line(g, n)

# Nonlocal(identifier* names)

def visit_Nonlocal(self, n: ast3.Nonlocal) -> NonlocalDecl:

d = NonlocalDecl(n.names)

return self.set_line(d, n)

# Expr(expr value)

def visit_Expr(self, n: ast3.Expr) -> ExpressionStmt:

value = self.visit(n.value)

node = ExpressionStmt(value)

return self.set_line(node, n)

# Pass

def visit_Pass(self, n: ast3.Pass) -> PassStmt:

s = PassStmt()

return self.set_line(s, n)

# Break

def visit_Break(self, n: ast3.Break) -> BreakStmt:

s = BreakStmt()

return self.set_line(s, n)

# Continue

def visit_Continue(self, n: ast3.Continue) -> ContinueStmt:

s = ContinueStmt()

return self.set_line(s, n)

# --- expr ---

def visit_NamedExpr(self, n: NamedExpr) -> AssignmentExpr:

s = AssignmentExpr(self.visit(n.target), self.visit(n.value))

return self.set_line(s, n)

# BoolOp(boolop op, expr* values)

def visit_BoolOp(self, n: ast3.BoolOp) -> OpExpr:

# mypy translates (1 and 2 and 3) as (1 and (2 and 3))

assert len(n.values) >= 2

op_node = n.op

if isinstance(op_node, ast3.And):

op = 'and'

elif isinstance(op_node, ast3.Or):

op = 'or'

else:

raise RuntimeError('unknown BoolOp ' + str(type(n)))

# potentially inefficient!

return self.group(op, self.translate_expr_list(n.values), n)

def group(self, op: str, vals: List[Expression], n: ast3.expr) -> OpExpr:

if len(vals) == 2:

e = OpExpr(op, vals[0], vals[1])

else:

e = OpExpr(op, vals[0], self.group(op, vals[1:], n))