from __future__ import annotations

import copy

import re

import sys

import warnings

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

from typing_extensions import Literal, 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,

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,

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

# TODO: Index, ExtSlice are deprecated in 3.9.

from ast import AST, Attribute, Call, FunctionType, Index, Name, Starred, UAdd, 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

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

ast_TypeAlias = ast3.TypeAlias

else:

ast_TypeAlias = 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

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

strip_function_bodies=strip_function_bodies,

path=fnam,

).visit(ast)

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, {})

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

return RawExpressionType(expr_string, expr_fallback_name, line, column, node=node)

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,

*,

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

# 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 = True) -> 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 = 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,

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

):

ignores = self.type_ignores[min(self.type_ignores)]

if ignores:

joined_ignores = ", ".join(ignores)

self.fail(

message_registry.TYPE_IGNORE_WITH_ERRCODE_ON_MODULE.format(joined_ignores),

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

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

}

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 = getattr(last, "end_lineno", None)

b.end_column = getattr(last, "end_col_offset", None)

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

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

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

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)

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

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

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

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

self.fail(

ErrorMessage("PEP 695 generics are not yet supported", code=codes.VALID_TYPE),

n.type_params[0].lineno,

n.type_params[0].col_offset,

blocker=False,

)

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(message_registry.ELLIPSIS_WITH_OTHER_TYPEARGS, lineno, n.col_offset)

elif len(arg_types) > len(arg_kinds):

self.fail(

message_registry.TYPE_SIGNATURE_TOO_MANY_ARGS,

lineno,

n.col_offset,

blocker=False,

)

elif len(arg_types) < len(arg_kinds):

self.fail(

message_registry.TYPE_SIGNATURE_TOO_FEW_ARGS,

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,

)

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

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

# End line and column span the whole function including its body.

# Determine end of the function definition itself.

# Fall back to the end of the function definition including its body.

def_end_line: int | None = n.lineno

def_end_column: int | None = n.col_offset

returns = n.returns

# Use the return type hint if defined.

if returns is not None:

def_end_line = returns.end_lineno

def_end_column = returns.end_col_offset

# Otherwise use the last argument in the function definition.

elif len(args) > 0:

last_arg = args[-1]

initializer = last_arg.initializer