# mypy: allow-redefinition-new, local-partial-types

"""Python parser that directly constructs a native AST (when compiled).

Use a Rust extension to generate a serialized AST, and deserialize the AST directly

to a mypy AST.

NOTE: This is work in progress. To use this, you need to manually build the

ast_serialize Rust extension. See the README at https://github.com/mypyc/ast_serialize.

Expected benefits over mypy.fastparse:

* No intermediate non-mypyc Python-level AST created, to improve performance

* Parsing doesn't need GIL => use multithreading to construct serialized ASTs in parallel

* Produce import dependencies without having to build an AST => helps parallel type checking

* Support all Python syntax even if mypy is running on an older Python version

* Generate an AST even if there are syntax errors

* Potential to support incremental parsing (quickly process modified sections in a file)

* Stripping function bodies in third-party code can happen earlier, for extra performance

"""

from __future__ import annotations

import os

from typing import Any, Final, cast

import ast_serialize # type: ignore[import-untyped, import-not-found, unused-ignore]

from librt.internal import (

read_float as read_float_bare,

read_int as read_int_bare,

read_str as read_str_bare,

)

from mypy import message_registry, nodes, types

from mypy.cache import (

DICT_STR_GEN,

END_TAG,

LIST_GEN,

LIST_INT,

LITERAL_FLOAT,

LITERAL_NONE,

LITERAL_STR,

LOCATION,

ReadBuffer,

Tag,

read_bool,

read_int,

read_str,

read_str_opt,

read_tag,

)

from mypy.nodes import (

ARG_KINDS,

ARG_POS,

IMPORT_METADATA,

IMPORTALL_METADATA,

IMPORTFROM_METADATA,

MISSING_FALLBACK,

Argument,

AssertStmt,

AssignmentExpr,

AssignmentStmt,

AwaitExpr,

Block,

BreakStmt,

BytesExpr,

CallExpr,

ClassDef,

ComparisonExpr,

ComplexExpr,

ConditionalExpr,

Context,

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,

NonlocalDecl,

OperatorAssignmentStmt,

OpExpr,

OverloadedFuncDef,

OverloadPart,

PassStmt,

RaiseStmt,

RefExpr,

ReturnStmt,

SetComprehension,

SetExpr,

SliceExpr,

StarExpr,

Statement,

StrExpr,

SuperExpr,

TempNode,

TryStmt,

TupleExpr,

TypeAliasStmt,

TypeParam,

UnaryExpr,

Var,

WhileStmt,

WithStmt,

YieldExpr,

YieldFromExpr,

)

from mypy.options import Options

from mypy.patterns import (

AsPattern,

ClassPattern,

MappingPattern,

OrPattern,

Pattern,

SequencePattern,

SingletonPattern,

StarredPattern,

ValuePattern,

)

from mypy.reachability import infer_reachability_of_if_statement

from mypy.sharedparse import special_function_elide_names

from mypy.types import (

AnyType,

CallableArgument,

CallableType,

EllipsisType,

Instance,

ProperType,

RawExpressionType,

TupleType,

Type,

TypedDictType,

TypeList,

TypeOfAny,

UnboundType,

UnionType,

UnpackType,

)

from mypy.util import unnamed_function

TypeIgnores = list[tuple[int, list[str]]]

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

# they must be patched later.

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

class State:

def __init__(self, options: Options) -> None:

self.options = options

self.errors: list[dict[str, Any]] = []

self.num_funcs = 0

def add_error(

self,

message: str,

line: int,

column: int,

*,

blocker: bool = False,

code: str | None = None,

) -> None:

"""Report an error at a specific location.

Args:

message: Error message to display

line: Line number where error occurred

column: Column number where error occurred

blocker: If True, this error blocks further analysis

code: Error code for categorization

"""

self.errors.append(

{"line": line, "column": column, "message": message, "blocker": blocker, "code": code}

)

def native_parse(

filename: str, options: Options, skip_function_bodies: bool = False

) -> tuple[MypyFile, list[dict[str, Any]], TypeIgnores]:

"""Parse a Python file using the native Rust-based parser.

Uses the ast_serialize Rust extension to parse Python code and deserialize

the resulting AST directly into mypy's native AST representation.

Args:

filename: Path to the Python source file to parse

options: Mypy options affecting parsing behavior (e.g., Python version)

skip_function_bodies: If True, many function and method bodies are omitted from

the AST, useful for parsing stubs or extracting signatures without full

implementation details

Returns:

A tuple containing:

- MypyFile: The parsed AST as a mypy AST node

- list[dict[str, Any]]: List of parse errors and deserialization errors

- TypeIgnores: List of (line_number, ignored_codes) tuples for type: ignore comments

"""

# If the path is a directory, return empty AST (matching fastparse behavior)

# This can happen for packages that only contain .pyc files without source

if os.path.isdir(filename):

node = MypyFile([], [])

node.path = filename

return node, [], []

b, errors, ignores, import_bytes, is_partial_package = parse_to_binary_ast(

filename, options, skip_function_bodies

)

data = ReadBuffer(b)

n = read_int(data)

state = State(options)

defs = read_statements(state, data, n)

imports = deserialize_imports(import_bytes)

node = MypyFile(defs, imports)

node.path = filename

node.is_partial_stub_package = is_partial_package

# Merge deserialization errors with parsing errors

all_errors = errors + state.errors

return node, all_errors, ignores

def expect_end_tag(data: ReadBuffer) -> None:

assert read_tag(data) == END_TAG

def expect_tag(data: ReadBuffer, tag: Tag) -> None:

assert read_tag(data) == tag

def read_statements(state: State, data: ReadBuffer, n: int) -> list[Statement]:

defs: list[Statement] = []

old_num_funcs = state.num_funcs

for _ in range(n):

stmt = read_statement(state, data)

defs.append(stmt)

if state.num_funcs > old_num_funcs + 1:

# There were at least two functions, so we may need to merge overloads.

defs = fix_function_overloads(state, defs)

return defs

def parse_to_binary_ast(

filename: str, options: Options, skip_function_bodies: bool = False

) -> tuple[bytes, list[dict[str, Any]], TypeIgnores, bytes, bool]:

ast_bytes, errors, ignores, import_bytes, is_partial_package = ast_serialize.parse(

filename, skip_function_bodies, python_version=options.python_version

)

return (

ast_bytes,

cast("list[dict[str, Any]]", errors),

ignores,

import_bytes,

is_partial_package,

)

def read_statement(state: State, data: ReadBuffer) -> Statement:

tag = read_tag(data)

stmt: Statement

if tag == nodes.FUNC_DEF_STMT:

return read_func_def(state, data)

elif tag == nodes.DECORATOR:

expect_tag(data, LIST_GEN)

n_decorators = read_int_bare(data)

decorators = [read_expression(state, data) for i in range(n_decorators)]

line = read_int(data)

column = read_int(data)

fdef = read_statement(state, data)

assert isinstance(fdef, FuncDef)

fdef.is_decorated = True

var = Var(fdef.name)

var.line = fdef.line

var.is_ready = False

stmt = Decorator(fdef, decorators, var)

stmt.line = line

stmt.column = column

stmt.end_line = fdef.end_line

stmt.end_column = fdef.end_column

# TODO: Adjust funcdef location to start after decorator?

expect_end_tag(data)

return stmt

elif tag == nodes.EXPR_STMT:

es = ExpressionStmt(read_expression(state, data))

set_line_column_range(es, es.expr)

expect_end_tag(data)

return es

elif tag == nodes.ASSIGNMENT_STMT:

lvalues = read_expression_list(state, data)

rvalue = read_expression(state, data)

has_type = read_bool(data)

if has_type:

type_annotation = read_type(state, data)

else:

type_annotation = None

new_syntax = read_bool(data)

a = AssignmentStmt(lvalues, rvalue, type=type_annotation, new_syntax=new_syntax)

read_loc(data, a)

# If rvalue is TempNode, copy location from AssignmentStmt

if isinstance(rvalue, TempNode):

set_line_column_range(rvalue, a)

expect_end_tag(data)

return a

elif tag == nodes.OPERATOR_ASSIGNMENT_STMT:

# Read operator string

op = read_str(data)

# Read lvalue (target)

lvalue = read_expression(state, data)

# Read rvalue (value)

rvalue = read_expression(state, data)

stmt = OperatorAssignmentStmt(op, lvalue, rvalue)

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.IF_STMT:

# Read the main if condition and body

expr = read_expression(state, data)

body = read_block(state, data)

# Read elif clauses

num_elif = read_int(data)

elif_exprs = []

elif_bodies = []

for i in range(num_elif):

elif_exprs.append(read_expression(state, data))

elif_bodies.append(read_block(state, data))

has_else = read_bool(data)

if has_else:

else_body = read_block(state, data)

else:

else_body = None

# Normalize elif into nested if/else statements

# Build from the bottom up, starting with the final else body

current_else = else_body

# Process elif clauses in reverse order

for i in range(len(elif_exprs) - 1, -1, -1):

elif_stmt = IfStmt([elif_exprs[i]], [elif_bodies[i]], current_else)

# Set location from the elif expression

elif_stmt.line = elif_exprs[i].line

elif_stmt.column = elif_exprs[i].column

# Set end location based on what follows

if current_else is not None:

elif_stmt.end_line = current_else.end_line

elif_stmt.end_column = current_else.end_column

else:

elif_stmt.end_line = elif_bodies[i].end_line

elif_stmt.end_column = elif_bodies[i].end_column

# Wrap in a Block to become the else clause for the outer if

current_else = Block([elif_stmt])

set_line_column_range(current_else, elif_stmt)

if_stmt = IfStmt([expr], [body], current_else)

read_loc(data, if_stmt)

expect_end_tag(data)

return if_stmt

elif tag == nodes.RETURN_STMT:

has_value = read_bool(data)

if has_value:

value = read_expression(state, data)

else:

value = None

stmt = ReturnStmt(value)

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.RAISE_STMT:

has_exc = read_bool(data)

if has_exc:

exc = read_expression(state, data)

else:

exc = None

has_from = read_bool(data)

if has_from:

from_expr = read_expression(state, data)

else:

from_expr = None

stmt = RaiseStmt(exc, from_expr)

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.ASSERT_STMT:

test = read_expression(state, data)

has_msg = read_bool(data)

if has_msg:

msg = read_expression(state, data)

else:

msg = None

stmt = AssertStmt(test, msg)

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.WHILE_STMT:

expr = read_expression(state, data)

body = read_block(state, data)

else_body = read_optional_block(state, data)

stmt = WhileStmt(expr, body, else_body)

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.FOR_STMT:

index = read_expression(state, data)

expr = read_expression(state, data)

body = read_block(state, data)

else_body = read_optional_block(state, data)

is_async = read_bool(data)

stmt = ForStmt(index, expr, body, else_body)

stmt.is_async = is_async

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.WITH_STMT:

n = read_int(data)

expr_list = []

target_list: list[Expression | None] = []

for _ in range(n):

context_expr = read_expression(state, data)

expr_list.append(context_expr)

has_target = read_bool(data)

if has_target:

target = read_expression(state, data)

target_list.append(target)

else:

target_list.append(None)

body = read_block(state, data)

is_async = read_bool(data)

stmt = WithStmt(expr_list, target_list, body)

stmt.is_async = is_async

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.PASS_STMT:

stmt = PassStmt()

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.BREAK_STMT:

stmt = BreakStmt()

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.CONTINUE_STMT:

stmt = ContinueStmt()

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.IMPORT:

n = read_int(data)

ids = []

for _ in range(n):

name = read_str(data)

has_asname = read_bool(data)

if has_asname:

asname = read_str(data)

else:

asname = None

ids.append((name, asname))

stmt = Import(ids)

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.IMPORT_FROM:

relative = read_int(data)

module_id = read_str(data) # Empty string for "from . import x"

n = read_int(data)

names = []

for _ in range(n):

name = read_str(data)

has_asname = read_bool(data)

if has_asname:

asname = read_str(data)

else:

asname = None

names.append((name, asname))

stmt = ImportFrom(module_id, relative, names)

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.IMPORT_ALL:

module_id = read_str(data) # Empty string for "from . import *"

relative = read_int(data)

stmt = ImportAll(module_id, relative)

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.CLASS_DEF:

return read_class_def(state, data)

elif tag == nodes.TYPE_ALIAS_STMT:

return read_type_alias_stmt(state, data)

elif tag == nodes.TRY_STMT:

return read_try_stmt(state, data)

elif tag == nodes.DEL_STMT:

expr = read_expression(state, data)

stmt = DelStmt(expr)

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.GLOBAL_DECL:

n = read_int(data)

decl_names = []

for _ in range(n):

decl_names.append(read_str(data))

stmt = GlobalDecl(decl_names)

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.NONLOCAL_DECL:

n = read_int(data)

decl_names = []

for _ in range(n):

decl_names.append(read_str(data))

stmt = NonlocalDecl(decl_names)

read_loc(data, stmt)

expect_end_tag(data)

return stmt

elif tag == nodes.MATCH_STMT:

subject = read_expression(state, data)

n_cases = read_int(data)

patterns = []

guards: list[Expression | None] = []

bodies = []

for _ in range(n_cases):

pattern = read_pattern(state, data)

patterns.append(pattern)

has_guard = read_bool(data)

if has_guard:

guard = read_expression(state, data)

guards.append(guard)

else:

guards.append(None)

body = read_block(state, data)

bodies.append(body)

stmt = MatchStmt(subject, patterns, guards, bodies)

read_loc(data, stmt)

expect_end_tag(data)

return stmt

else:

assert False, tag

def read_parameters(state: State, data: ReadBuffer) -> tuple[list[Argument], bool]:

"""Read function/lambda parameters from the buffer.

Returns:

A tuple of (arguments list, has_annotations flag)

"""

expect_tag(data, LIST_GEN)

n_args = read_int_bare(data)

arguments = []

has_ann = False

for _ in range(n_args):

arg_name = read_str(data)

arg_kind_int = read_int(data)

arg_kind = ARG_KINDS[arg_kind_int]

has_type = read_bool(data)

if has_type:

ann = read_type(state, data)

has_ann = True

else:

ann = None

has_default = read_bool(data)

if has_default:

default = read_expression(state, data)

else:

default = None

pos_only = read_bool(data)

# Apply implicit_optional if enabled and default is None

if state.options.implicit_optional and ann is not None:

optional = isinstance(default, NameExpr) and default.name == "None"

if isinstance(ann, UnboundType):

ann.optional = optional

var = Var(arg_name, ann)

var.is_inferred = False

var.is_argument = True

arg = Argument(var, ann, default, arg_kind, pos_only)

read_loc(data, arg)

set_line_column_range(var, arg)

arguments.append(arg)

return arguments, has_ann

def read_type_params(state: State, data: ReadBuffer) -> list[TypeParam]:

"""Read type parameters (PEP 695 generics)."""

type_params: list[TypeParam] = []

n = read_int_bare(data)

for _ in range(n):

kind = read_int(data)

name = read_str(data)

has_bound = read_bool(data)

if has_bound:

upper_bound = read_type(state, data)

else:

upper_bound = None

expect_tag(data, LIST_GEN)

n_values = read_int_bare(data)

values = [read_type(state, data) for _ in range(n_values)]

has_default = read_bool(data)

if has_default:

default = read_type(state, data)

else:

default = None

type_params.append(TypeParam(name, kind, upper_bound, values, default))

return type_params

def read_func_def(state: State, data: ReadBuffer) -> FuncDef:

state.num_funcs += 1

name = read_str(data)

arguments, has_ann = read_parameters(state, data)

if special_function_elide_names(name):

for arg in arguments:

arg.pos_only = True

body = read_block(state, data)

is_async = read_bool(data)

# Type parameters (PEP 695)

has_type_params = read_bool(data)

if has_type_params:

type_params = read_type_params(state, data)

else:

type_params = None

has_return_type = read_bool(data)

if has_return_type:

return_type = read_type(state, data)

has_ann = True

else:

return_type = None

if has_ann:

typ = CallableType(

[

arg.type_annotation if arg.type_annotation else AnyType(TypeOfAny.unannotated)

for arg in arguments

],

[arg.kind for arg in arguments],

[None if arg.pos_only else arg.variable.name for arg in arguments],

return_type if return_type else AnyType(TypeOfAny.unannotated),

_dummy_fallback,

)

else:

typ = None

func_def = FuncDef(name, arguments, body, typ=typ, type_args=type_params)

if is_async:

func_def.is_coroutine = True

read_loc(data, func_def)

if typ:

typ.line = func_def.line

typ.column = func_def.column

typ.definition = func_def

# TODO: This seems wasteful, can we avoid it?

func_def.unanalyzed_type = typ.copy_modified()

expect_end_tag(data)

return func_def

def read_class_def(state: State, data: ReadBuffer) -> ClassDef:

name = read_str(data)

body = read_block(state, data)

base_type_exprs = read_expression_list(state, data)

expect_tag(data, LIST_GEN)

n_decorators = read_int_bare(data)

decorators = [read_expression(state, data) for _ in range(n_decorators)]

# Type parameters (PEP 695)

has_type_params = read_bool(data)

if has_type_params:

type_params = read_type_params(state, data)

else:

type_params = None

# Keywords (all keyword arguments including metaclass)

expect_tag(data, DICT_STR_GEN)

n_keywords = read_int_bare(data)

keywords = []

for _ in range(n_keywords):

key = read_str(data)

value = read_expression(state, data)

keywords.append((key, value))

# Extract metaclass from keywords if present

metaclass = dict(keywords).get("metaclass") if keywords else None

# Remove metaclass from keywords since it's passed as a separate field

filtered_keywords = [(k, v) for k, v in keywords if k != "metaclass"] if keywords else None

class_def = ClassDef(

name,

body,

base_type_exprs=base_type_exprs if base_type_exprs else None,

metaclass=metaclass,

keywords=filtered_keywords,

type_args=type_params,

)

class_def.decorators = decorators

read_loc(data, class_def)

expect_end_tag(data)

return class_def

def read_type_alias_stmt(state: State, data: ReadBuffer) -> TypeAliasStmt:

"""Read PEP 695 type alias statement."""

name = read_expression(state, data)

assert isinstance(name, NameExpr), f"Expected NameExpr for type alias name, got {type(name)}"

n_type_params = read_int_bare(data)

if n_type_params > 0:

type_params = []

for _ in range(n_type_params):

kind = read_int(data)

param_name = read_str(data)

has_bound = read_bool(data)

if has_bound:

upper_bound = read_type(state, data)

else:

upper_bound = None

# Read values (for constrained TypeVar)

expect_tag(data, LIST_GEN)

n_values = read_int_bare(data)

values = [read_type(state, data) for _ in range(n_values)]

has_default = read_bool(data)

if has_default:

default = read_type(state, data)

else:

default = None

type_params.append(TypeParam(param_name, kind, upper_bound, values, default))

else:

type_params = []

value_expr = read_expression(state, data)

# Wrap the value expression in a LambdaExpr as expected by TypeAliasStmt

# The LambdaExpr body is a Block with a single ReturnStmt

return_stmt = ReturnStmt(value_expr)

set_line_column_range(return_stmt, value_expr)

block = Block([return_stmt])

block.line = -1 # Synthetic block

block.column = 0

block.end_line = -1

block.end_column = 0

lambda_expr = LambdaExpr([], block)

set_line_column_range(lambda_expr, value_expr)

stmt = TypeAliasStmt(name, type_params, lambda_expr)

read_loc(data, stmt)

expect_end_tag(data)

return stmt

def read_try_stmt(state: State, data: ReadBuffer) -> TryStmt:

body = read_block(state, data)

num_handlers = read_int(data)

types_list: list[Expression | None] = []

for _ in range(num_handlers):

has_type = read_bool(data)

if has_type:

exc_type = read_expression(state, data)

types_list.append(exc_type)

else:

types_list.append(None)

vars_list: list[NameExpr | None] = []

for _ in range(num_handlers):

has_name = read_bool(data)

if has_name:

var_name = read_str(data)

var_expr = NameExpr(var_name)

vars_list.append(var_expr)

else:

vars_list.append(None)

handlers = []

for _ in range(num_handlers):

handler_body = read_block(state, data)

handlers.append(handler_body)

has_else = read_bool(data)

if has_else:

else_body = read_block(state, data)

else:

else_body = None

has_finally = read_bool(data)

if has_finally:

finally_body = read_block(state, data)

else:

finally_body = None

# Read is_star flag (for except* in Python 3.11+)

is_star = read_bool(data)

stmt = TryStmt(body, vars_list, types_list, handlers, else_body, finally_body)

stmt.is_star = is_star

read_loc(data, stmt)

expect_end_tag(data)

return stmt

def read_type(state: State, data: ReadBuffer) -> Type:

tag = read_tag(data)

if tag == types.UNBOUND_TYPE:

name = read_str(data)

expect_tag(data, LIST_GEN)

n = read_int_bare(data)

args = tuple(read_type(state, data) for i in range(n))

empty_tuple_index = read_bool(data)

# Read optional original_str_expr

t = read_tag(data)

if t == LITERAL_NONE:

original_str_expr = None

elif t == LITERAL_STR:

original_str_expr = read_str_bare(data)

else:

assert False, f"Unexpected tag for original_str_expr: {t}"

# Read optional original_str_fallback

t = read_tag(data)

if t == LITERAL_NONE:

original_str_fallback = None

elif t == LITERAL_STR:

original_str_fallback = read_str_bare(data)

else:

assert False, f"Unexpected tag for original_str_fallback: {t}"

unbound = UnboundType(

name,

args,

empty_tuple_index=empty_tuple_index,

original_str_expr=original_str_expr,

original_str_fallback=original_str_fallback,

)

read_loc(data, unbound)

expect_end_tag(data)

return unbound

elif tag == types.UNION_TYPE:

# Read items list

expect_tag(data, LIST_GEN)

n = read_int_bare(data)

items = [read_type(state, data) for i in range(n)]

# Read uses_pep604_syntax flag

uses_pep604_syntax = read_bool(data)

# Read optional original_str_expr

t = read_tag(data)

if t == LITERAL_NONE:

original_str_expr = None

elif t == LITERAL_STR:

original_str_expr = read_str_bare(data)

else:

assert False, f"Unexpected tag for original_str_expr: {t}"

# Read optional original_str_fallback

t = read_tag(data)

if t == LITERAL_NONE:

original_str_fallback = None

elif t == LITERAL_STR:

original_str_fallback = read_str_bare(data)

else:

assert False, f"Unexpected tag for original_str_fallback: {t}"

union = UnionType(items, uses_pep604_syntax=uses_pep604_syntax)

union.original_str_expr = original_str_expr

union.original_str_fallback = original_str_fallback

union.is_evaluated = read_bool(data)

read_loc(data, union)

expect_end_tag(data)

return union

elif tag == types.LIST_TYPE:

# Read items list

expect_tag(data, LIST_GEN)

n = read_int_bare(data)

items = [read_type(state, data) for i in range(n)]

type_list = TypeList(items)

read_loc(data, type_list)

expect_end_tag(data)

return type_list

elif tag == types.TUPLE_TYPE:

# Read items list

expect_tag(data, LIST_GEN)

n = read_int_bare(data)

items = [read_type(state, data) for i in range(n)]

implicit = read_bool(data)

tuple_type = TupleType(items, _dummy_fallback, implicit=implicit)

read_loc(data, tuple_type)

expect_end_tag(data)

return tuple_type

elif tag == types.TYPED_DICT_TYPE:

expect_tag(data, LIST_GEN)

n = read_int_bare(data)

keys = [read_str_opt(data) for i in range(n)]

expect_tag(data, LIST_GEN)

n = read_int_bare(data)

values = [read_type(state, data) for i in range(n)]

td_items = {}

extra_items_from = []

for key, val in zip(keys, values):

if key is None:

assert isinstance(val, ProperType)

extra_items_from.append(val)

else:

td_items[key] = val

typeddict_type = TypedDictType(td_items, set(), set(), _dummy_fallback)

typeddict_type.extra_items_from = extra_items_from

read_loc(data, typeddict_type)

expect_end_tag(data)

return typeddict_type

elif tag == types.ELLIPSIS_TYPE:

# EllipsisType has no attributes

ellipsis_type = EllipsisType()

read_loc(data, ellipsis_type)

expect_end_tag(data)

return ellipsis_type

elif tag == types.RAW_EXPRESSION_TYPE:

type_name = read_str(data)

value: types.LiteralValue | str | None

if type_name == "builtins.bool":

value = read_bool(data)

elif type_name == "builtins.int":

value = read_int(data)

elif type_name == "builtins.str":

value = read_str(data)

elif type_name == "builtins.bytes":

# Bytes literals are serialized as escaped strings

value = read_str(data)

elif type_name == "typing.Any":

# Invalid type - read None value

tag = read_tag(data)

assert tag == LITERAL_NONE, f"Expected LITERAL_NONE for invalid type, got {tag}"

value = None

else:

assert False, f"Unsupported RawExpressionType: {type_name}"

raw_type = RawExpressionType(value, type_name)

read_loc(data, raw_type)

expect_end_tag(data)

return raw_type

elif tag == types.UNPACK_TYPE:

inner_type = read_type(state, data)

from_star_syntax = read_bool(data)

unpack = UnpackType(inner_type, from_star_syntax=from_star_syntax)

read_loc(data, unpack)

expect_end_tag(data)

return unpack

elif tag == types.CALL_TYPE:

return read_call_type(state, data)

else:

assert False, tag

def stringify_type_name(typ: Type) -> str | None:

"""Extract qualified name from a type (for Arg constructor detection)."""

if isinstance(typ, UnboundType):

return typ.name

return None

def extract_arg_name(typ: Type) -> str | None:

"""Extract argument name from a type (for Arg name parameter)."""

if isinstance(typ, RawExpressionType) and typ.base_type_name == "builtins.str":

return typ.literal_value # type: ignore[return-value]

elif isinstance(typ, UnboundType):

# String literals in type context are parsed as UnboundType (forward references)

# For Arg names, these are typically simple names without dots

if typ.name == "None":

return None

# Return the name as-is (it's the argument name)