from __future__ import annotations

import copy

import re

import sys

import warnings

from typing import Any, Callable, List, Optional, Sequence, TypeVar, Union, cast

from typing_extensions import Final, Literal, overload

from mypy import defaults, errorcodes as codes, message_registry

from mypy.errors import Errors

from mypy.nodes import (

ARG_NAMED,

ARG_NAMED_OPT,

ARG_OPT,

ARG_POS,

ARG_STAR,

ARG_STAR2,

ArgKind,

Argument,

AssertStmt,

AssignmentExpr,

AssignmentStmt,

AwaitExpr,

Block,

BreakStmt,

BytesExpr,

CallExpr,

ClassDef,

ComparisonExpr,

ComplexExpr,

ConditionalExpr,

ContinueStmt,

Decorator,

DelStmt,

DictExpr,

DictionaryComprehension,

EllipsisExpr,

Expression,

ExpressionStmt,

FakeInfo,

FloatExpr,

ForStmt,

FuncDef,

GeneratorExpr,

GlobalDecl,

IfStmt,

Import,

ImportAll,

ImportBase,

ImportFrom,

IndexExpr,

IntExpr,

LambdaExpr,

ListComprehension,

ListExpr,

MatchStmt,

MemberExpr,

MypyFile,

NameExpr,

Node,

NonlocalDecl,

OperatorAssignmentStmt,

OpExpr,

OverloadedFuncDef,

OverloadPart,

PassStmt,

RaiseStmt,

RefExpr,

ReturnStmt,

SetComprehension,

SetExpr,

SliceExpr,

StarExpr,

Statement,

StrExpr,

SuperExpr,

TempNode,

TryStmt,

TupleExpr,

UnaryExpr,

Var,

WhileStmt,

WithStmt,

YieldExpr,

YieldFromExpr,

check_arg_names,

)

from mypy.options import Options

from mypy.patterns import (

AsPattern,

ClassPattern,

MappingPattern,

OrPattern,

SequencePattern,

SingletonPattern,

StarredPattern,

ValuePattern,

)

from mypy.reachability import infer_reachability_of_if_statement, mark_block_unreachable

from mypy.sharedparse import argument_elide_name, special_function_elide_names

from mypy.traverser import TraverserVisitor

from mypy.types import (

AnyType,

CallableArgument,

CallableType,

EllipsisType,

Instance,

ProperType,

RawExpressionType,

TupleType,

Type,

TypeList,

TypeOfAny,

UnboundType,

UnionType,

)

from mypy.util import bytes_to_human_readable_repr, unnamed_function

try:

# pull this into a final variable to make mypyc be quiet about the

# the default argument warning

PY_MINOR_VERSION: Final = sys.version_info[1]

# Check if we can use the stdlib ast module instead of typed_ast.

if sys.version_info >= (3, 8):

import ast as ast3

assert (

"kind" in ast3.Constant._fields

), f"This 3.8.0 alpha ({sys.version.split()[0]}) is too old; 3.8.0a3 required"

# TODO: Num, Str, Bytes, NameConstant, Ellipsis are deprecated in 3.8.

# TODO: Index, ExtSlice are deprecated in 3.9.

from ast import (

AST,

Attribute,

Bytes,

Call,

Ellipsis as ast3_Ellipsis,

Expression as ast3_Expression,

FunctionType,

Index,

Name,

NameConstant,

Num,

Starred,

Str,

UnaryOp,

USub,

)

def ast3_parse(

source: str | bytes, filename: str, mode: str, feature_version: int = PY_MINOR_VERSION

) -> AST:

return ast3.parse(

source,

filename,

mode,

type_comments=True, # This works the magic

feature_version=feature_version,

)

NamedExpr = ast3.NamedExpr

Constant = ast3.Constant

else:

from typed_ast import ast3

from typed_ast.ast3 import (

AST,

Attribute,

Bytes,

Call,

Ellipsis as ast3_Ellipsis,

Expression as ast3_Expression,

FunctionType,

Index,

Name,

NameConstant,

Num,

Starred,

Str,

UnaryOp,

USub,

)

def ast3_parse(

source: str | bytes, filename: str, mode: str, feature_version: int = PY_MINOR_VERSION

) -> AST:

return ast3.parse(source, filename, mode, feature_version=feature_version)

# These don't exist before 3.8

NamedExpr = Any

Constant = Any

if sys.version_info >= (3, 10):

Match = ast3.Match

MatchValue = ast3.MatchValue

MatchSingleton = ast3.MatchSingleton

MatchSequence = ast3.MatchSequence

MatchStar = ast3.MatchStar

MatchMapping = ast3.MatchMapping

MatchClass = ast3.MatchClass

MatchAs = ast3.MatchAs

MatchOr = ast3.MatchOr

AstNode = Union[ast3.expr, ast3.stmt, ast3.pattern, ast3.ExceptHandler]

else:

Match = Any

MatchValue = Any

MatchSingleton = Any

MatchSequence = Any

MatchStar = Any

MatchMapping = Any

MatchClass = Any

MatchAs = Any

MatchOr = Any

AstNode = Union[ast3.expr, ast3.stmt, ast3.ExceptHandler]

if sys.version_info >= (3, 11):

TryStar = ast3.TryStar

else:

TryStar = Any

except ImportError:

try:

from typed_ast import ast35 # type: ignore[attr-defined] # noqa: F401

except ImportError:

print(

"The typed_ast package is not installed.\n"

"You can install it with `python3 -m pip install typed-ast`.",

file=sys.stderr,

)

else:

print(

"You need a more recent version of the typed_ast package.\n"

"You can update to the latest version with "

"`python3 -m pip install -U typed-ast`.",

file=sys.stderr,

)

sys.exit(1)

N = TypeVar("N", bound=Node)

# There is no way to create reasonable fallbacks at this stage,

# they must be patched later.

MISSING_FALLBACK: Final = FakeInfo("fallback can't be filled out until semanal")

_dummy_fallback: Final = Instance(MISSING_FALLBACK, [], -1)

TYPE_COMMENT_SYNTAX_ERROR: Final = "syntax error in type comment"

INVALID_TYPE_IGNORE: Final = 'Invalid "type: ignore" comment'

TYPE_IGNORE_PATTERN: Final = re.compile(r"[^#]*#\s*type:\s*ignore\s*(.*)")

def parse(

source: str | bytes,

fnam: str,

module: str | None,

errors: Errors | None = None,

options: Options | None = 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.

"""

ignore_errors = (options is not None and options.ignore_errors) or (

errors is not None and fnam in errors.ignored_files

)

# If errors are ignored, we can drop many function bodies to speed up type checking.

strip_function_bodies = ignore_errors and (options is None or not options.preserve_asts)

raise_on_error = False

if options is None:

options = Options()

if errors is None:

errors = Errors(hide_error_codes=options.hide_error_codes)

raise_on_error = True

errors.set_file(fnam, module, options=options)

is_stub_file = fnam.endswith(".pyi")

if is_stub_file:

feature_version = defaults.PYTHON3_VERSION[1]

if options.python_version[0] == 3 and options.python_version[1] > feature_version:

feature_version = options.python_version[1]

else:

assert options.python_version[0] >= 3

feature_version = options.python_version[1]

try:

# 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,

ignore_errors=ignore_errors,

strip_function_bodies=strip_function_bodies,

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

message = e.msg

if feature_version > sys.version_info.minor and message.startswith("invalid syntax"):

python_version_str = f"{options.python_version[0]}.{options.python_version[1]}"

message += f"; you likely need to run mypy using Python {python_version_str} or newer"

errors.report(

e.lineno if e.lineno is not None else -1,

e.offset,

message,

blocker=True,

code=codes.SYNTAX,

)

tree = MypyFile([], [], False, {})

if raise_on_error and errors.is_errors():

errors.raise_error()

assert isinstance(tree, MypyFile)

return tree

def parse_type_ignore_tag(tag: str | None) -> list[str] | None:

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

Return:

* [] if no tag was found (ignore all errors)

* list of ignored error codes if a tag was found

* None if the tag was invalid.

"""

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

return [code.strip() for code in m.group(1).split(",")]

def parse_type_comment(

type_comment: str, line: int, column: int, errors: Errors | None

) -> tuple[list[str] | None, ProperType | None]:

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

Return (ignore info, parsed type).

"""

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 = f'{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: str | None = cast(Any, extra_ignore).group(1)

ignored: list[str] | None = parse_type_ignore_tag(tag)

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, is_evaluated=False

).visit(typ.body)

return ignored, converted

def parse_type_string(

expr_string: str, expr_fallback_name: str, line: int, column: int

) -> ProperType:

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

For example, suppose we have the type `Foo["blah"]`. We should parse the

string expression "blah" using this function.

"""

try:

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

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

elif isinstance(node, UnionType):

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.

return RawExpressionType(expr_string, expr_fallback_name, line, column)

def is_no_type_check_decorator(expr: ast3.expr) -> bool:

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"

return False

class ASTConverter:

def __init__(

self,

options: Options,

is_stub: bool,

errors: Errors,

*,

ignore_errors: bool,

strip_function_bodies: bool,

) -> None:

# 'C' for class, 'D' for function signature, 'F' for function, 'L' for lambda

self.class_and_function_stack: list[Literal["C", "D", "F", "L"]] = []

self.imports: list[ImportBase] = []

self.options = options

self.is_stub = is_stub

self.errors = errors

self.ignore_errors = ignore_errors

self.strip_function_bodies = strip_function_bodies

self.type_ignores: dict[int, list[str]] = {}

# Cache of visit_X methods keyed by type of visited object

self.visitor_cache: dict[type, Callable[[AST | None], 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,

code: codes.ErrorCode = codes.SYNTAX,

) -> None:

if blocker or not self.options.ignore_errors:

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

def fail_merge_overload(self, node: IfStmt) -> None:

self.fail(

"Condition can't be inferred, unable to merge overloads",

line=node.line,

column=node.column,

blocker=False,

code=codes.MISC,

)

def visit(self, node: AST | None) -> 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: AstNode) -> N:

node.line = n.lineno

node.column = n.col_offset

node.end_line = getattr(n, "end_lineno", None)

node.end_column = getattr(n, "end_col_offset", None)

return node

def translate_opt_expr_list(self, l: Sequence[AST | None]) -> list[Expression | None]:

res: list[Expression | None] = []

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: 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, can_strip: 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])

):

if self.type_ignores[min(self.type_ignores)]:

self.fail(

(

"type ignore with error code is not supported for modules; "

"use `# mypy: disable-error-code=...`"

),

line=min(self.type_ignores),

column=0,

blocker=False,

)

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

codes.FILE.code

)

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

mark_block_unreachable(block)

return [block]

stack = self.class_and_function_stack

if self.strip_function_bodies and len(stack) == 1 and stack[0] == "F":

return []

res: list[Statement] = []

for stmt in stmts:

node = self.visit(stmt)

res.append(node)

if (

self.strip_function_bodies

and can_strip

and stack[-2:] == ["C", "F"]

and not is_possible_trivial_body(res)

):

# We only strip method bodies if they don't assign to an attribute, as

# this may define an attribute which has an externally visible effect.

visitor = FindAttributeAssign()

for s in res:

s.accept(visitor)

if visitor.found:

break

else:

return []

return res

def translate_type_comment(

self, n: ast3.stmt | ast3.arg, type_comment: str | None

) -> ProperType | None:

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: Final[dict[type[AST], str]] = {

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: "//",

}

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: Final[dict[type[AST], str]] = {

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",

}

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) -> Block | None:

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, *, can_strip: bool = False

) -> Block:

assert stmts # must be non-empty

b = Block(

self.fix_function_overloads(self.translate_stmt_list(stmts, can_strip=can_strip))

)

# TODO: in most call sites line is wrong (includes first line of enclosing statement)

# TODO: also we need to set the column, and the end position here.

b.set_line(lineno)

return b

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

ret: list[Statement] = []

current_overload: list[OverloadPart] = []

current_overload_name: str | None = None

seen_unconditional_func_def = False

last_if_stmt: IfStmt | None = None

last_if_overload: Decorator | FuncDef | OverloadedFuncDef | None = None

last_if_stmt_overload_name: str | None = None

last_if_unknown_truth_value: IfStmt | None = None

skipped_if_stmts: list[IfStmt] = []

for stmt in stmts:

if_overload_name: str | None = None

if_block_with_overload: Block | None = None

if_unknown_truth_value: IfStmt | None = None

if isinstance(stmt, IfStmt) and seen_unconditional_func_def is False:

# Check IfStmt block to determine if function overloads can be merged

if_overload_name = self._check_ifstmt_for_overloads(stmt, current_overload_name)

if if_overload_name is not None:

(

if_block_with_overload,

if_unknown_truth_value,

) = self._get_executable_if_block_with_overloads(stmt)

if (

current_overload_name is not None

and isinstance(stmt, (Decorator, FuncDef))

and stmt.name == current_overload_name

):

if last_if_stmt is not None:

skipped_if_stmts.append(last_if_stmt)

if last_if_overload is not None:

# Last stmt was an IfStmt with same overload name

# Add overloads to current_overload

if isinstance(last_if_overload, OverloadedFuncDef):

current_overload.extend(last_if_overload.items)

else:

current_overload.append(last_if_overload)

last_if_stmt, last_if_overload = None, None

if last_if_unknown_truth_value:

self.fail_merge_overload(last_if_unknown_truth_value)

last_if_unknown_truth_value = None

current_overload.append(stmt)

if isinstance(stmt, FuncDef):

seen_unconditional_func_def = True

elif (

current_overload_name is not None

and isinstance(stmt, IfStmt)

and if_overload_name == current_overload_name

):

# IfStmt only contains stmts relevant to current_overload.

# Check if stmts are reachable and add them to current_overload,

# otherwise skip IfStmt to allow subsequent overload

# or function definitions.

skipped_if_stmts.append(stmt)

if if_block_with_overload is None:

if if_unknown_truth_value is not None:

self.fail_merge_overload(if_unknown_truth_value)

continue

if last_if_overload is not None:

# Last stmt was an IfStmt with same overload name

# Add overloads to current_overload

if isinstance(last_if_overload, OverloadedFuncDef):

current_overload.extend(last_if_overload.items)

else:

current_overload.append(last_if_overload)

last_if_stmt, last_if_overload = None, None

if isinstance(if_block_with_overload.body[-1], OverloadedFuncDef):

skipped_if_stmts.extend(cast(List[IfStmt], if_block_with_overload.body[:-1]))

current_overload.extend(if_block_with_overload.body[-1].items)

else:

current_overload.append(

cast(Union[Decorator, FuncDef], if_block_with_overload.body[0])

)

else:

if last_if_stmt is not None:

ret.append(last_if_stmt)

last_if_stmt_overload_name = current_overload_name

last_if_stmt, last_if_overload = None, None

last_if_unknown_truth_value = None

if current_overload and current_overload_name == last_if_stmt_overload_name:

# Remove last stmt (IfStmt) from ret if the overload names matched

# Only happens if no executable block had been found in IfStmt

skipped_if_stmts.append(cast(IfStmt, ret.pop()))

if current_overload and skipped_if_stmts:

# Add bare IfStmt (without overloads) to ret

# Required for mypy to be able to still check conditions

for if_stmt in skipped_if_stmts:

self._strip_contents_from_if_stmt(if_stmt)

ret.append(if_stmt)

skipped_if_stmts = []

if len(current_overload) == 1:

ret.append(current_overload[0])

elif len(current_overload) > 1:

ret.append(OverloadedFuncDef(current_overload))

# If we have multiple decorated functions named "_" next to each, we want to treat

# them as a series of regular FuncDefs instead of one OverloadedFuncDef because

# most of mypy/mypyc assumes that all the functions in an OverloadedFuncDef are

# related, but multiple underscore functions next to each other aren't necessarily

# related

seen_unconditional_func_def = False

if isinstance(stmt, Decorator) and not unnamed_function(stmt.name):

current_overload = [stmt]

current_overload_name = stmt.name

elif isinstance(stmt, IfStmt) and if_overload_name is not None:

current_overload = []

current_overload_name = if_overload_name

last_if_stmt = stmt

last_if_stmt_overload_name = None

if if_block_with_overload is not None:

skipped_if_stmts.extend(

cast(List[IfStmt], if_block_with_overload.body[:-1])

)

last_if_overload = cast(

Union[Decorator, FuncDef, OverloadedFuncDef],

if_block_with_overload.body[-1],

)

last_if_unknown_truth_value = if_unknown_truth_value

else:

current_overload = []

current_overload_name = None

ret.append(stmt)

if current_overload and skipped_if_stmts:

# Add bare IfStmt (without overloads) to ret

# Required for mypy to be able to still check conditions

for if_stmt in skipped_if_stmts:

self._strip_contents_from_if_stmt(if_stmt)

ret.append(if_stmt)

if len(current_overload) == 1:

ret.append(current_overload[0])

elif len(current_overload) > 1:

ret.append(OverloadedFuncDef(current_overload))

elif last_if_overload is not None:

ret.append(last_if_overload)

elif last_if_stmt is not None:

ret.append(last_if_stmt)

return ret

def _check_ifstmt_for_overloads(

self, stmt: IfStmt, current_overload_name: str | None = None

) -> str | None:

"""Check if IfStmt contains only overloads with the same name.

Return overload_name if found, None otherwise.

"""

# Check that block only contains a single Decorator, FuncDef, or OverloadedFuncDef.

# Multiple overloads have already been merged as OverloadedFuncDef.

if not (

len(stmt.body[0].body) == 1

and (

isinstance(stmt.body[0].body[0], (Decorator, OverloadedFuncDef))

or current_overload_name is not None

and isinstance(stmt.body[0].body[0], FuncDef)

)

or len(stmt.body[0].body) > 1

and isinstance(stmt.body[0].body[-1], OverloadedFuncDef)

and all(self._is_stripped_if_stmt(if_stmt) for if_stmt in stmt.body[0].body[:-1])

):

return None

overload_name = cast(

Union[Decorator, FuncDef, OverloadedFuncDef], stmt.body[0].body[-1]

).name

if stmt.else_body is None:

return overload_name

if len(stmt.else_body.body) == 1:

# For elif: else_body contains an IfStmt itself -> do a recursive check.

if (

isinstance(stmt.else_body.body[0], (Decorator, FuncDef, OverloadedFuncDef))

and stmt.else_body.body[0].name == overload_name

):

return overload_name

if (

isinstance(stmt.else_body.body[0], IfStmt)

and self._check_ifstmt_for_overloads(stmt.else_body.body[0], current_overload_name)

== overload_name

):

return overload_name

return None

def _get_executable_if_block_with_overloads(

self, stmt: IfStmt

) -> tuple[Block | None, IfStmt | None]:

"""Return block from IfStmt that will get executed.

Return

0 -> A block if sure that alternative blocks are unreachable.

1 -> An IfStmt if the reachability of it can't be inferred,

i.e. the truth value is unknown.

"""

infer_reachability_of_if_statement(stmt, self.options)

if stmt.else_body is None and stmt.body[0].is_unreachable is True:

# always False condition with no else

return None, None

if (

stmt.else_body is None

or stmt.body[0].is_unreachable is False

and stmt.else_body.is_unreachable is False

):

# The truth value is unknown, thus not conclusive

return None, stmt

if stmt.else_body.is_unreachable is True:

# else_body will be set unreachable if condition is always True

return stmt.body[0], None

if stmt.body[0].is_unreachable is True:

# body will be set unreachable if condition is always False

# else_body can contain an IfStmt itself (for elif) -> do a recursive check

if isinstance(stmt.else_body.body[0], IfStmt):

return self._get_executable_if_block_with_overloads(stmt.else_body.body[0])

return stmt.else_body, None

return None, stmt

def _strip_contents_from_if_stmt(self, stmt: IfStmt) -> None:

"""Remove contents from IfStmt.

Needed to still be able to check the conditions after the contents

have been merged with the surrounding function overloads.

"""

if len(stmt.body) == 1:

stmt.body[0].body = []

if stmt.else_body and len(stmt.else_body.body) == 1:

if isinstance(stmt.else_body.body[0], IfStmt):

self._strip_contents_from_if_stmt(stmt.else_body.body[0])

else:

stmt.else_body.body = []

def _is_stripped_if_stmt(self, stmt: Statement) -> bool:

"""Check stmt to make sure it is a stripped IfStmt.

See also: _strip_contents_from_if_stmt

"""

if not isinstance(stmt, IfStmt):

return False

if not (len(stmt.body) == 1 and len(stmt.body[0].body) == 0):

# Body not empty

return False

if not stmt.else_body or len(stmt.else_body.body) == 0:

# No or empty else_body

return True

# For elif, IfStmt are stored recursively in else_body

return self._is_stripped_if_stmt(stmt.else_body.body[0])

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"

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, blocker=False)

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) -> 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) -> FuncDef | Decorator:

return self.do_func_def(n, is_coroutine=True)

def do_func_def(

self, n: ast3.FunctionDef | ast3.AsyncFunctionDef, is_coroutine: bool = False

) -> FuncDef | Decorator:

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

self.class_and_function_stack.append("D")

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)

if special_function_elide_names(n.name):

for arg in args:

arg.pos_only = True

arg_kinds = [arg.kind for arg in args]

arg_names = [None if arg.pos_only else arg.variable.name for arg in args]

arg_types: list[Type | None] = []

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: list[Type] = TypeConverter(

self.errors, line=lineno, override_column=n.col_offset

).translate_expr_list(func_type_ast.argtypes)

# Use a cast to work around `list` invariance

arg_types = cast(List[Optional[Type]], translated_args)

return_type = TypeConverter(self.errors, line=lineno).visit(func_type_ast.returns)

# add implicit self type

in_method_scope = self.class_and_function_stack[-2:] == ["C", "D"]

if 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 = f'{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,