from __future__ import annotations

import re

import sys

import warnings

from collections.abc import Callable, Sequence

from typing import Any, Final, Literal, TypeVar, cast, overload

from mypy import defaults, errorcodes as codes, message_registry

from mypy.errors import Errors

from mypy.message_registry import ErrorMessage

from mypy.nodes import (

ARG_NAMED,

ARG_NAMED_OPT,

ARG_OPT,

ARG_POS,

ARG_STAR,

ARG_STAR2,

MISSING_FALLBACK,

PARAM_SPEC_KIND,

TYPE_VAR_KIND,

TYPE_VAR_TUPLE_KIND,

ArgKind,

Argument,

AssertStmt,

AssignmentExpr,

AssignmentStmt,

AwaitExpr,

Block,

BreakStmt,

BytesExpr,

CallExpr,

ClassDef,

ComparisonExpr,

ComplexExpr,

ConditionalExpr,

ContinueStmt,

Decorator,

DelStmt,

DictExpr,

DictionaryComprehension,

EllipsisExpr,

Expression,

ExpressionStmt,

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,

TemplateStrExpr,

TempNode,

TryStmt,

TupleExpr,

TypeAliasStmt,

TypeParam,

UnaryExpr,

Var,

WhileStmt,

WithStmt,

YieldExpr,

YieldFromExpr,

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

TypedDictType,

TypeList,

TypeOfAny,

UnboundType,

UnionType,

UnpackType,

)

from mypy.util import bytes_to_human_readable_repr, unnamed_function

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

import ast as ast3

from ast import AST, Attribute, Call, FunctionType, Name, Starred, UAdd, UnaryOp, USub

def ast3_parse(

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

) -> AST:

# Ignore warnings that look like:

# <type_comment>:1: SyntaxWarning: invalid escape sequence '\.'

# because `source` could be anything, including literals like r'(re\.match)'

with warnings.catch_warnings():

warnings.simplefilter("ignore", SyntaxWarning)

return ast3.parse(

source,

filename,

mode,

type_comments=True, # This works the magic

feature_version=feature_version,

)

AstNode = ast3.expr | ast3.stmt | ast3.pattern | ast3.ExceptHandler

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

TryStar = ast3.TryStar

else:

TryStar = Any

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

ast_TypeAlias = ast3.TypeAlias

ast_ParamSpec = ast3.ParamSpec

ast_TypeVar = ast3.TypeVar

ast_TypeVarTuple = ast3.TypeVarTuple

else:

ast_TypeAlias = Any

ast_ParamSpec = Any

ast_TypeVar = Any

ast_TypeVarTuple = Any

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

ast_TemplateStr = ast3.TemplateStr

ast_Interpolation = ast3.Interpolation

else:

ast_TemplateStr = Any

ast_Interpolation = Any

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

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

# they must be patched later.

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

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

def parse(

source: str | bytes,

fnam: str,

module: str | None,

errors: Errors,

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 (

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)

if options is None:

options = Options()

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 for 'invalid escape sequence' (Python 3.11 and below)

# - syntax warnings for 'invalid escape sequence' (3.12+) and 'return in finally' (3.14+)

with warnings.catch_warnings():

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

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

ast = ast3_parse(source, fnam, "exec", feature_version=feature_version)

tree = ASTConverter(

options=options,

is_stub=is_stub_file,

errors=errors,

strip_function_bodies=strip_function_bodies,

path=fnam,

).visit(ast)

except RecursionError as e:

# For very complex expressions it is possible to hit recursion limit

# before reaching a leaf node.

# Should reject at top level instead at bottom, since bottom would already

# be at the threshold of the recursion limit, and may fail again later.

# E.G. x1+x2+x3+...+xn -> BinOp(left=BinOp(left=BinOp(left=...

try:

# But to prove that is the cause of this particular recursion error,

# try to walk the tree using builtin visitor

ast3.NodeVisitor().visit(ast)

except RecursionError:

errors.report(

-1, -1, "Source expression too complex to parse", blocker=False, code=codes.MISC

)

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

else:

# re-raise original recursion error if it *can* be unparsed,

# maybe this is some other issue that shouldn't be silenced/misdirected

raise e

except SyntaxError as e:

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,

re.sub(

r"^(\s*\w)", lambda m: m.group(1).upper(), message

), # Standardizing error message

blocker=True,

code=codes.SYNTAX,

)

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

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 [stripped_code for code in m.group(1).split(",") if (stripped_code := code.strip())]

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 = message_registry.TYPE_COMMENT_SYNTAX_ERROR_VALUE.format(stripped_type)

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

return None, None

else:

raise

else:

extra_ignore = TYPE_IGNORE_PATTERN.match(type_comment)

if extra_ignore:

tag: str | None = 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, message_registry.INVALID_TYPE_IGNORE.value, 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(f"({expr_string})", line=line, column=column, errors=None)

if isinstance(node, (UnboundType, UnionType)) 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.

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

def find_disallowed_expression_in_annotation_scope(expr: ast3.expr | None) -> ast3.expr | None:

if expr is None:

return None

for node in ast3.walk(expr):

if isinstance(node, (ast3.Yield, ast3.YieldFrom, ast3.NamedExpr, ast3.Await)):

return node

return None

class ASTConverter:

def __init__(

self,

options: Options,

is_stub: bool,

errors: Errors,

*,

strip_function_bodies: bool,

path: str,

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

self.path = path

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

self.uses_template_strings = False

# 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: ErrorMessage, line: int, column: int, blocker: bool) -> None:

if blocker or not self.options.ignore_errors:

# Make sure self.errors reflects any type ignores that we have parsed

self.errors.set_file_ignored_lines(

self.path, self.type_ignores, self.options.ignore_errors

)

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

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

self.fail(

message_registry.FAILED_TO_MERGE_OVERLOADS,

line=node.line,

column=node.column,

blocker=False,

)

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 = n.end_lineno

node.end_column = n.end_col_offset

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,

is_coroutine: 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 (first := min(self.type_ignores)) < self.get_lineno(stmts[0])

):

ignores = self.type_ignores.pop(first)

if ignores:

joined_ignores = ", ".join(ignores)

self.fail(

message_registry.TYPE_IGNORE_WITH_ERRCODE_ON_MODULE.format(joined_ignores),

line=first,

column=0,

blocker=False,

)

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

self.set_block_lines(block, stmts)

mark_block_unreachable(block)

return [block]

stack = self.class_and_function_stack

# Fast case for stripping function bodies

if (

can_strip

and self.strip_function_bodies

and len(stack) == 1

and stack[0] == "F"

and not is_coroutine

):

return []

res: list[Statement] = []

for stmt in stmts:

node = self.visit(stmt)

res.append(node)

# Slow case for stripping function bodies

if can_strip and self.strip_function_bodies:

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

if is_possible_trivial_body(res):

can_strip = False

else:

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

can_strip = False

break

if can_strip and stack[-1] == "F" and is_coroutine:

# Yields inside an async function affect the return type and should not

# be stripped.

yield_visitor = FindYield()

for s in res:

s.accept(yield_visitor)

if yield_visitor.found:

can_strip = False

break

if can_strip:

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", # codespell:ignore notin

}

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 set_block_lines(self, b: Block, stmts: Sequence[ast3.stmt]) -> None:

first, last = stmts[0], stmts[-1]

b.line = first.lineno

b.column = first.col_offset

b.end_line = last.end_lineno

b.end_column = last.end_col_offset

if not b.body:

return

new_first = b.body[0]

if isinstance(new_first, (Decorator, OverloadedFuncDef)):

# Decorated function lines are different between Python versions.

# copy the normalization we do for them to block first lines.

b.line = new_first.line

b.column = new_first.column

def as_block(self, stmts: list[ast3.stmt]) -> Block | None:

b = None

if stmts:

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

self.set_block_lines(b, stmts)

return b

def as_required_block(

self, stmts: list[ast3.stmt], *, can_strip: bool = False, is_coroutine: bool = False

) -> Block:

assert stmts # must be non-empty

b = Block(

self.fix_function_overloads(

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

)

)

self.set_block_lines(b, stmts)

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

last_unconditional_func_def: str | None = None

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

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

# This is, strictly speaking, wrong: there might be a decorated

# implementation. However, it only affects the error message we show:

# ideally it's "already defined", but "implementation must come last"

# is also reasonable.

# TODO: can we get rid of this completely and just always emit

# "implementation must come last" instead?

last_unconditional_func_def = stmt.name

elif (

current_overload_name is not None

and isinstance(stmt, IfStmt)

and if_overload_name == current_overload_name

and last_unconditional_func_def != 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(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

popped = ret.pop()

assert isinstance(popped, IfStmt)

skipped_if_stmts.append(popped)

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

last_unconditional_func_def = None

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(

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(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 = {}

self.uses_template_strings = False

for ti in mod.type_ignores:

parsed = parse_type_ignore_tag(ti.tag)

if parsed is not None:

self.type_ignores[ti.lineno] = parsed

else:

self.fail(message_registry.INVALID_TYPE_IGNORE, ti.lineno, -1, blocker=False)

body = self.fix_function_overloads(self.translate_stmt_list(mod.body, ismodule=True))

ret = MypyFile(body, self.imports, False, ignored_lines=self.type_ignores)

ret.is_stub = self.is_stub

ret.path = self.path

ret.uses_template_strings = self.uses_template_strings

return ret

# --- 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 self.options.pos_only_special_methods and 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]

# Type parameters, if using new syntax for generics (PEP 695)

explicit_type_params: list[TypeParam] | None = None

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

and func_type_ast.argtypes[0].value is Ellipsis

):

if n.returns:

# PEP 484 disallows both type annotations and type comments

self.fail(

message_registry.DUPLICATE_TYPE_SIGNATURES,

lineno,

n.col_offset,

blocker=False,

)

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,

blocker=False,

)

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[Type | None], 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 = message_registry.TYPE_COMMENT_SYNTAX_ERROR_VALUE.format(stripped_type)

self.fail(err_msg, lineno, n.col_offset, blocker=False)

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:

if sys.version_info >= (3, 12) and n.type_params:

explicit_type_params = self.translate_type_params(n.type_params)

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)