| """Conversion of parse tree nodes to strings.""" |
| |
| from __future__ import annotations |
| |
| import os |
| import re |
| from typing import TYPE_CHECKING, Any, Sequence |
| |
| import mypy.nodes |
| from mypy.options import Options |
| from mypy.util import IdMapper, short_type |
| from mypy.visitor import NodeVisitor |
| |
| if TYPE_CHECKING: |
| import mypy.patterns |
| import mypy.types |
| |
| |
| class StrConv(NodeVisitor[str]): |
| """Visitor for converting a node to a human-readable string. |
| |
| For example, an MypyFile node from program '1' is converted into |
| something like this: |
| |
| MypyFile:1( |
| fnam |
| ExpressionStmt:1( |
| IntExpr(1))) |
| """ |
| |
| __slots__ = ["options", "show_ids", "id_mapper"] |
| |
| def __init__(self, *, show_ids: bool = False, options: Options) -> None: |
| self.options = options |
| self.show_ids = show_ids |
| self.id_mapper: IdMapper | None = None |
| if show_ids: |
| self.id_mapper = IdMapper() |
| |
| def stringify_type(self, t: mypy.types.Type) -> str: |
| import mypy.types |
| |
| return t.accept(mypy.types.TypeStrVisitor(id_mapper=self.id_mapper, options=self.options)) |
| |
| def get_id(self, o: object) -> int | None: |
| if self.id_mapper: |
| return self.id_mapper.id(o) |
| return None |
| |
| def format_id(self, o: object) -> str: |
| if self.id_mapper: |
| return f"<{self.get_id(o)}>" |
| else: |
| return "" |
| |
| def dump(self, nodes: Sequence[object], obj: mypy.nodes.Context) -> str: |
| """Convert a list of items to a multiline pretty-printed string. |
| |
| The tag is produced from the type name of obj and its line |
| number. See mypy.util.dump_tagged for a description of the nodes |
| argument. |
| """ |
| tag = short_type(obj) + ":" + str(obj.line) |
| if self.show_ids: |
| assert self.id_mapper is not None |
| tag += f"<{self.get_id(obj)}>" |
| return dump_tagged(nodes, tag, self) |
| |
| def func_helper(self, o: mypy.nodes.FuncItem) -> list[object]: |
| """Return a list in a format suitable for dump() that represents the |
| arguments and the body of a function. The caller can then decorate the |
| array with information specific to methods, global functions or |
| anonymous functions. |
| """ |
| args: list[mypy.nodes.Var | tuple[str, list[mypy.nodes.Node]]] = [] |
| extra: list[tuple[str, list[mypy.nodes.Var]]] = [] |
| for arg in o.arguments: |
| kind: mypy.nodes.ArgKind = arg.kind |
| if kind.is_required(): |
| args.append(arg.variable) |
| elif kind.is_optional(): |
| assert arg.initializer is not None |
| args.append(("default", [arg.variable, arg.initializer])) |
| elif kind == mypy.nodes.ARG_STAR: |
| extra.append(("VarArg", [arg.variable])) |
| elif kind == mypy.nodes.ARG_STAR2: |
| extra.append(("DictVarArg", [arg.variable])) |
| a: list[Any] = [] |
| if args: |
| a.append(("Args", args)) |
| if o.type: |
| a.append(o.type) |
| if o.is_generator: |
| a.append("Generator") |
| a.extend(extra) |
| a.append(o.body) |
| return a |
| |
| # Top-level structures |
| |
| def visit_mypy_file(self, o: mypy.nodes.MypyFile) -> str: |
| # Skip implicit definitions. |
| a: list[Any] = [o.defs] |
| if o.is_bom: |
| a.insert(0, "BOM") |
| # Omit path to special file with name "main". This is used to simplify |
| # test case descriptions; the file "main" is used by default in many |
| # test cases. |
| if o.path != "main": |
| # Insert path. Normalize directory separators to / to unify test |
| # case# output in all platforms. |
| a.insert(0, o.path.replace(os.sep, "/")) |
| if o.ignored_lines: |
| a.append("IgnoredLines(%s)" % ", ".join(str(line) for line in sorted(o.ignored_lines))) |
| return self.dump(a, o) |
| |
| def visit_import(self, o: mypy.nodes.Import) -> str: |
| a = [] |
| for id, as_id in o.ids: |
| if as_id is not None: |
| a.append(f"{id} : {as_id}") |
| else: |
| a.append(id) |
| return f"Import:{o.line}({', '.join(a)})" |
| |
| def visit_import_from(self, o: mypy.nodes.ImportFrom) -> str: |
| a = [] |
| for name, as_name in o.names: |
| if as_name is not None: |
| a.append(f"{name} : {as_name}") |
| else: |
| a.append(name) |
| return f"ImportFrom:{o.line}({'.' * o.relative + o.id}, [{', '.join(a)}])" |
| |
| def visit_import_all(self, o: mypy.nodes.ImportAll) -> str: |
| return f"ImportAll:{o.line}({'.' * o.relative + o.id})" |
| |
| # Definitions |
| |
| def visit_func_def(self, o: mypy.nodes.FuncDef) -> str: |
| a = self.func_helper(o) |
| a.insert(0, o.name) |
| arg_kinds = {arg.kind for arg in o.arguments} |
| if len(arg_kinds & {mypy.nodes.ARG_NAMED, mypy.nodes.ARG_NAMED_OPT}) > 0: |
| a.insert(1, f"MaxPos({o.max_pos})") |
| if o.abstract_status in (mypy.nodes.IS_ABSTRACT, mypy.nodes.IMPLICITLY_ABSTRACT): |
| a.insert(-1, "Abstract") |
| if o.is_static: |
| a.insert(-1, "Static") |
| if o.is_class: |
| a.insert(-1, "Class") |
| if o.is_property: |
| a.insert(-1, "Property") |
| return self.dump(a, o) |
| |
| def visit_overloaded_func_def(self, o: mypy.nodes.OverloadedFuncDef) -> str: |
| a: Any = o.items.copy() |
| if o.type: |
| a.insert(0, o.type) |
| if o.impl: |
| a.insert(0, o.impl) |
| if o.is_static: |
| a.insert(-1, "Static") |
| if o.is_class: |
| a.insert(-1, "Class") |
| return self.dump(a, o) |
| |
| def visit_class_def(self, o: mypy.nodes.ClassDef) -> str: |
| a = [o.name, o.defs.body] |
| # Display base types unless they are implicitly just builtins.object |
| # (in this case base_type_exprs is empty). |
| if o.base_type_exprs: |
| if o.info and o.info.bases: |
| if len(o.info.bases) != 1 or o.info.bases[0].type.fullname != "builtins.object": |
| a.insert(1, ("BaseType", o.info.bases)) |
| else: |
| a.insert(1, ("BaseTypeExpr", o.base_type_exprs)) |
| if o.type_vars: |
| a.insert(1, ("TypeVars", o.type_vars)) |
| if o.metaclass: |
| a.insert(1, f"Metaclass({o.metaclass.accept(self)})") |
| if o.decorators: |
| a.insert(1, ("Decorators", o.decorators)) |
| if o.info and o.info._promote: |
| a.insert(1, f"Promote([{','.join(self.stringify_type(p) for p in o.info._promote)}])") |
| if o.info and o.info.tuple_type: |
| a.insert(1, ("TupleType", [o.info.tuple_type])) |
| if o.info and o.info.fallback_to_any: |
| a.insert(1, "FallbackToAny") |
| return self.dump(a, o) |
| |
| def visit_var(self, o: mypy.nodes.Var) -> str: |
| lst = "" |
| # Add :nil line number tag if no line number is specified to remain |
| # compatible with old test case descriptions that assume this. |
| if o.line < 0: |
| lst = ":nil" |
| return "Var" + lst + "(" + o.name + ")" |
| |
| def visit_global_decl(self, o: mypy.nodes.GlobalDecl) -> str: |
| return self.dump([o.names], o) |
| |
| def visit_nonlocal_decl(self, o: mypy.nodes.NonlocalDecl) -> str: |
| return self.dump([o.names], o) |
| |
| def visit_decorator(self, o: mypy.nodes.Decorator) -> str: |
| return self.dump([o.var, o.decorators, o.func], o) |
| |
| # Statements |
| |
| def visit_block(self, o: mypy.nodes.Block) -> str: |
| return self.dump(o.body, o) |
| |
| def visit_expression_stmt(self, o: mypy.nodes.ExpressionStmt) -> str: |
| return self.dump([o.expr], o) |
| |
| def visit_assignment_stmt(self, o: mypy.nodes.AssignmentStmt) -> str: |
| a: list[Any] = [] |
| if len(o.lvalues) > 1: |
| a = [("Lvalues", o.lvalues)] |
| else: |
| a = [o.lvalues[0]] |
| a.append(o.rvalue) |
| if o.type: |
| a.append(o.type) |
| return self.dump(a, o) |
| |
| def visit_operator_assignment_stmt(self, o: mypy.nodes.OperatorAssignmentStmt) -> str: |
| return self.dump([o.op, o.lvalue, o.rvalue], o) |
| |
| def visit_while_stmt(self, o: mypy.nodes.WhileStmt) -> str: |
| a: list[Any] = [o.expr, o.body] |
| if o.else_body: |
| a.append(("Else", o.else_body.body)) |
| return self.dump(a, o) |
| |
| def visit_for_stmt(self, o: mypy.nodes.ForStmt) -> str: |
| a: list[Any] = [] |
| if o.is_async: |
| a.append(("Async", "")) |
| a.append(o.index) |
| if o.index_type: |
| a.append(o.index_type) |
| a.extend([o.expr, o.body]) |
| if o.else_body: |
| a.append(("Else", o.else_body.body)) |
| return self.dump(a, o) |
| |
| def visit_return_stmt(self, o: mypy.nodes.ReturnStmt) -> str: |
| return self.dump([o.expr], o) |
| |
| def visit_if_stmt(self, o: mypy.nodes.IfStmt) -> str: |
| a: list[Any] = [] |
| for i in range(len(o.expr)): |
| a.append(("If", [o.expr[i]])) |
| a.append(("Then", o.body[i].body)) |
| |
| if not o.else_body: |
| return self.dump(a, o) |
| else: |
| return self.dump([a, ("Else", o.else_body.body)], o) |
| |
| def visit_break_stmt(self, o: mypy.nodes.BreakStmt) -> str: |
| return self.dump([], o) |
| |
| def visit_continue_stmt(self, o: mypy.nodes.ContinueStmt) -> str: |
| return self.dump([], o) |
| |
| def visit_pass_stmt(self, o: mypy.nodes.PassStmt) -> str: |
| return self.dump([], o) |
| |
| def visit_raise_stmt(self, o: mypy.nodes.RaiseStmt) -> str: |
| return self.dump([o.expr, o.from_expr], o) |
| |
| def visit_assert_stmt(self, o: mypy.nodes.AssertStmt) -> str: |
| if o.msg is not None: |
| return self.dump([o.expr, o.msg], o) |
| else: |
| return self.dump([o.expr], o) |
| |
| def visit_await_expr(self, o: mypy.nodes.AwaitExpr) -> str: |
| return self.dump([o.expr], o) |
| |
| def visit_del_stmt(self, o: mypy.nodes.DelStmt) -> str: |
| return self.dump([o.expr], o) |
| |
| def visit_try_stmt(self, o: mypy.nodes.TryStmt) -> str: |
| a: list[Any] = [o.body] |
| if o.is_star: |
| a.append("*") |
| |
| for i in range(len(o.vars)): |
| a.append(o.types[i]) |
| if o.vars[i]: |
| a.append(o.vars[i]) |
| a.append(o.handlers[i]) |
| |
| if o.else_body: |
| a.append(("Else", o.else_body.body)) |
| if o.finally_body: |
| a.append(("Finally", o.finally_body.body)) |
| |
| return self.dump(a, o) |
| |
| def visit_with_stmt(self, o: mypy.nodes.WithStmt) -> str: |
| a: list[Any] = [] |
| if o.is_async: |
| a.append(("Async", "")) |
| for i in range(len(o.expr)): |
| a.append(("Expr", [o.expr[i]])) |
| if o.target[i]: |
| a.append(("Target", [o.target[i]])) |
| if o.unanalyzed_type: |
| a.append(o.unanalyzed_type) |
| return self.dump(a + [o.body], o) |
| |
| def visit_match_stmt(self, o: mypy.nodes.MatchStmt) -> str: |
| a: list[Any] = [o.subject] |
| for i in range(len(o.patterns)): |
| a.append(("Pattern", [o.patterns[i]])) |
| if o.guards[i] is not None: |
| a.append(("Guard", [o.guards[i]])) |
| a.append(("Body", o.bodies[i].body)) |
| return self.dump(a, o) |
| |
| # Expressions |
| |
| # Simple expressions |
| |
| def visit_int_expr(self, o: mypy.nodes.IntExpr) -> str: |
| return f"IntExpr({o.value})" |
| |
| def visit_str_expr(self, o: mypy.nodes.StrExpr) -> str: |
| return f"StrExpr({self.str_repr(o.value)})" |
| |
| def visit_bytes_expr(self, o: mypy.nodes.BytesExpr) -> str: |
| return f"BytesExpr({self.str_repr(o.value)})" |
| |
| def str_repr(self, s: str) -> str: |
| s = re.sub(r"\\u[0-9a-fA-F]{4}", lambda m: "\\" + m.group(0), s) |
| return re.sub("[^\\x20-\\x7e]", lambda m: r"\u%.4x" % ord(m.group(0)), s) |
| |
| def visit_float_expr(self, o: mypy.nodes.FloatExpr) -> str: |
| return f"FloatExpr({o.value})" |
| |
| def visit_complex_expr(self, o: mypy.nodes.ComplexExpr) -> str: |
| return f"ComplexExpr({o.value})" |
| |
| def visit_ellipsis(self, o: mypy.nodes.EllipsisExpr) -> str: |
| return "Ellipsis" |
| |
| def visit_star_expr(self, o: mypy.nodes.StarExpr) -> str: |
| return self.dump([o.expr], o) |
| |
| def visit_name_expr(self, o: mypy.nodes.NameExpr) -> str: |
| pretty = self.pretty_name( |
| o.name, o.kind, o.fullname, o.is_inferred_def or o.is_special_form, o.node |
| ) |
| if isinstance(o.node, mypy.nodes.Var) and o.node.is_final: |
| pretty += f" = {o.node.final_value}" |
| return short_type(o) + "(" + pretty + ")" |
| |
| def pretty_name( |
| self, |
| name: str, |
| kind: int | None, |
| fullname: str | None, |
| is_inferred_def: bool, |
| target_node: mypy.nodes.Node | None = None, |
| ) -> str: |
| n = name |
| if is_inferred_def: |
| n += "*" |
| if target_node: |
| id = self.format_id(target_node) |
| else: |
| id = "" |
| if isinstance(target_node, mypy.nodes.MypyFile) and name == fullname: |
| n += id |
| elif kind == mypy.nodes.GDEF or (fullname != name and fullname): |
| # Append fully qualified name for global references. |
| n += f" [{fullname}{id}]" |
| elif kind == mypy.nodes.LDEF: |
| # Add tag to signify a local reference. |
| n += f" [l{id}]" |
| elif kind == mypy.nodes.MDEF: |
| # Add tag to signify a member reference. |
| n += f" [m{id}]" |
| else: |
| n += id |
| return n |
| |
| def visit_member_expr(self, o: mypy.nodes.MemberExpr) -> str: |
| pretty = self.pretty_name(o.name, o.kind, o.fullname, o.is_inferred_def, o.node) |
| return self.dump([o.expr, pretty], o) |
| |
| def visit_yield_expr(self, o: mypy.nodes.YieldExpr) -> str: |
| return self.dump([o.expr], o) |
| |
| def visit_yield_from_expr(self, o: mypy.nodes.YieldFromExpr) -> str: |
| if o.expr: |
| return self.dump([o.expr.accept(self)], o) |
| else: |
| return self.dump([], o) |
| |
| def visit_call_expr(self, o: mypy.nodes.CallExpr) -> str: |
| if o.analyzed: |
| return o.analyzed.accept(self) |
| args: list[mypy.nodes.Expression] = [] |
| extra: list[str | tuple[str, list[Any]]] = [] |
| for i, kind in enumerate(o.arg_kinds): |
| if kind in [mypy.nodes.ARG_POS, mypy.nodes.ARG_STAR]: |
| args.append(o.args[i]) |
| if kind == mypy.nodes.ARG_STAR: |
| extra.append("VarArg") |
| elif kind == mypy.nodes.ARG_NAMED: |
| extra.append(("KwArgs", [o.arg_names[i], o.args[i]])) |
| elif kind == mypy.nodes.ARG_STAR2: |
| extra.append(("DictVarArg", [o.args[i]])) |
| else: |
| raise RuntimeError(f"unknown kind {kind}") |
| a: list[Any] = [o.callee, ("Args", args)] |
| return self.dump(a + extra, o) |
| |
| def visit_op_expr(self, o: mypy.nodes.OpExpr) -> str: |
| if o.analyzed: |
| return o.analyzed.accept(self) |
| return self.dump([o.op, o.left, o.right], o) |
| |
| def visit_comparison_expr(self, o: mypy.nodes.ComparisonExpr) -> str: |
| return self.dump([o.operators, o.operands], o) |
| |
| def visit_cast_expr(self, o: mypy.nodes.CastExpr) -> str: |
| return self.dump([o.expr, o.type], o) |
| |
| def visit_assert_type_expr(self, o: mypy.nodes.AssertTypeExpr) -> str: |
| return self.dump([o.expr, o.type], o) |
| |
| def visit_reveal_expr(self, o: mypy.nodes.RevealExpr) -> str: |
| if o.kind == mypy.nodes.REVEAL_TYPE: |
| return self.dump([o.expr], o) |
| else: |
| # REVEAL_LOCALS |
| return self.dump([o.local_nodes], o) |
| |
| def visit_assignment_expr(self, o: mypy.nodes.AssignmentExpr) -> str: |
| return self.dump([o.target, o.value], o) |
| |
| def visit_unary_expr(self, o: mypy.nodes.UnaryExpr) -> str: |
| return self.dump([o.op, o.expr], o) |
| |
| def visit_list_expr(self, o: mypy.nodes.ListExpr) -> str: |
| return self.dump(o.items, o) |
| |
| def visit_dict_expr(self, o: mypy.nodes.DictExpr) -> str: |
| return self.dump([[k, v] for k, v in o.items], o) |
| |
| def visit_set_expr(self, o: mypy.nodes.SetExpr) -> str: |
| return self.dump(o.items, o) |
| |
| def visit_tuple_expr(self, o: mypy.nodes.TupleExpr) -> str: |
| return self.dump(o.items, o) |
| |
| def visit_index_expr(self, o: mypy.nodes.IndexExpr) -> str: |
| if o.analyzed: |
| return o.analyzed.accept(self) |
| return self.dump([o.base, o.index], o) |
| |
| def visit_super_expr(self, o: mypy.nodes.SuperExpr) -> str: |
| return self.dump([o.name, o.call], o) |
| |
| def visit_type_application(self, o: mypy.nodes.TypeApplication) -> str: |
| return self.dump([o.expr, ("Types", o.types)], o) |
| |
| def visit_type_var_expr(self, o: mypy.nodes.TypeVarExpr) -> str: |
| import mypy.types |
| |
| a: list[Any] = [] |
| if o.variance == mypy.nodes.COVARIANT: |
| a += ["Variance(COVARIANT)"] |
| if o.variance == mypy.nodes.CONTRAVARIANT: |
| a += ["Variance(CONTRAVARIANT)"] |
| if o.values: |
| a += [("Values", o.values)] |
| if not mypy.types.is_named_instance(o.upper_bound, "builtins.object"): |
| a += [f"UpperBound({self.stringify_type(o.upper_bound)})"] |
| return self.dump(a, o) |
| |
| def visit_paramspec_expr(self, o: mypy.nodes.ParamSpecExpr) -> str: |
| import mypy.types |
| |
| a: list[Any] = [] |
| if o.variance == mypy.nodes.COVARIANT: |
| a += ["Variance(COVARIANT)"] |
| if o.variance == mypy.nodes.CONTRAVARIANT: |
| a += ["Variance(CONTRAVARIANT)"] |
| if not mypy.types.is_named_instance(o.upper_bound, "builtins.object"): |
| a += [f"UpperBound({self.stringify_type(o.upper_bound)})"] |
| return self.dump(a, o) |
| |
| def visit_type_var_tuple_expr(self, o: mypy.nodes.TypeVarTupleExpr) -> str: |
| import mypy.types |
| |
| a: list[Any] = [] |
| if o.variance == mypy.nodes.COVARIANT: |
| a += ["Variance(COVARIANT)"] |
| if o.variance == mypy.nodes.CONTRAVARIANT: |
| a += ["Variance(CONTRAVARIANT)"] |
| if not mypy.types.is_named_instance(o.upper_bound, "builtins.object"): |
| a += [f"UpperBound({self.stringify_type(o.upper_bound)})"] |
| return self.dump(a, o) |
| |
| def visit_type_alias_expr(self, o: mypy.nodes.TypeAliasExpr) -> str: |
| return f"TypeAliasExpr({self.stringify_type(o.node.target)})" |
| |
| def visit_namedtuple_expr(self, o: mypy.nodes.NamedTupleExpr) -> str: |
| return f"NamedTupleExpr:{o.line}({o.info.name}, {self.stringify_type(o.info.tuple_type) if o.info.tuple_type is not None else None})" |
| |
| def visit_enum_call_expr(self, o: mypy.nodes.EnumCallExpr) -> str: |
| return f"EnumCallExpr:{o.line}({o.info.name}, {o.items})" |
| |
| def visit_typeddict_expr(self, o: mypy.nodes.TypedDictExpr) -> str: |
| return f"TypedDictExpr:{o.line}({o.info.name})" |
| |
| def visit__promote_expr(self, o: mypy.nodes.PromoteExpr) -> str: |
| return f"PromoteExpr:{o.line}({self.stringify_type(o.type)})" |
| |
| def visit_newtype_expr(self, o: mypy.nodes.NewTypeExpr) -> str: |
| return f"NewTypeExpr:{o.line}({o.name}, {self.dump([o.old_type], o)})" |
| |
| def visit_lambda_expr(self, o: mypy.nodes.LambdaExpr) -> str: |
| a = self.func_helper(o) |
| return self.dump(a, o) |
| |
| def visit_generator_expr(self, o: mypy.nodes.GeneratorExpr) -> str: |
| condlists = o.condlists if any(o.condlists) else None |
| return self.dump([o.left_expr, o.indices, o.sequences, condlists], o) |
| |
| def visit_list_comprehension(self, o: mypy.nodes.ListComprehension) -> str: |
| return self.dump([o.generator], o) |
| |
| def visit_set_comprehension(self, o: mypy.nodes.SetComprehension) -> str: |
| return self.dump([o.generator], o) |
| |
| def visit_dictionary_comprehension(self, o: mypy.nodes.DictionaryComprehension) -> str: |
| condlists = o.condlists if any(o.condlists) else None |
| return self.dump([o.key, o.value, o.indices, o.sequences, condlists], o) |
| |
| def visit_conditional_expr(self, o: mypy.nodes.ConditionalExpr) -> str: |
| return self.dump([("Condition", [o.cond]), o.if_expr, o.else_expr], o) |
| |
| def visit_slice_expr(self, o: mypy.nodes.SliceExpr) -> str: |
| a: list[Any] = [o.begin_index, o.end_index, o.stride] |
| if not a[0]: |
| a[0] = "<empty>" |
| if not a[1]: |
| a[1] = "<empty>" |
| return self.dump(a, o) |
| |
| def visit_temp_node(self, o: mypy.nodes.TempNode) -> str: |
| return self.dump([o.type], o) |
| |
| def visit_as_pattern(self, o: mypy.patterns.AsPattern) -> str: |
| return self.dump([o.pattern, o.name], o) |
| |
| def visit_or_pattern(self, o: mypy.patterns.OrPattern) -> str: |
| return self.dump(o.patterns, o) |
| |
| def visit_value_pattern(self, o: mypy.patterns.ValuePattern) -> str: |
| return self.dump([o.expr], o) |
| |
| def visit_singleton_pattern(self, o: mypy.patterns.SingletonPattern) -> str: |
| return self.dump([o.value], o) |
| |
| def visit_sequence_pattern(self, o: mypy.patterns.SequencePattern) -> str: |
| return self.dump(o.patterns, o) |
| |
| def visit_starred_pattern(self, o: mypy.patterns.StarredPattern) -> str: |
| return self.dump([o.capture], o) |
| |
| def visit_mapping_pattern(self, o: mypy.patterns.MappingPattern) -> str: |
| a: list[Any] = [] |
| for i in range(len(o.keys)): |
| a.append(("Key", [o.keys[i]])) |
| a.append(("Value", [o.values[i]])) |
| if o.rest is not None: |
| a.append(("Rest", [o.rest])) |
| return self.dump(a, o) |
| |
| def visit_class_pattern(self, o: mypy.patterns.ClassPattern) -> str: |
| a: list[Any] = [o.class_ref] |
| if len(o.positionals) > 0: |
| a.append(("Positionals", o.positionals)) |
| for i in range(len(o.keyword_keys)): |
| a.append(("Keyword", [o.keyword_keys[i], o.keyword_values[i]])) |
| |
| return self.dump(a, o) |
| |
| |
| def dump_tagged(nodes: Sequence[object], tag: str | None, str_conv: StrConv) -> str: |
| """Convert an array into a pretty-printed multiline string representation. |
| |
| The format is |
| tag( |
| item1.. |
| itemN) |
| Individual items are formatted like this: |
| - arrays are flattened |
| - pairs (str, array) are converted recursively, so that str is the tag |
| - other items are converted to strings and indented |
| """ |
| from mypy.types import Type, TypeStrVisitor |
| |
| a: list[str] = [] |
| if tag: |
| a.append(tag + "(") |
| for n in nodes: |
| if isinstance(n, list): |
| if n: |
| a.append(dump_tagged(n, None, str_conv)) |
| elif isinstance(n, tuple): |
| s = dump_tagged(n[1], n[0], str_conv) |
| a.append(indent(s, 2)) |
| elif isinstance(n, mypy.nodes.Node): |
| a.append(indent(n.accept(str_conv), 2)) |
| elif isinstance(n, Type): |
| a.append( |
| indent(n.accept(TypeStrVisitor(str_conv.id_mapper, options=str_conv.options)), 2) |
| ) |
| elif n is not None: |
| a.append(indent(str(n), 2)) |
| if tag: |
| a[-1] += ")" |
| return "\n".join(a) |
| |
| |
| def indent(s: str, n: int) -> str: |
| """Indent all the lines in s (separated by newlines) by n spaces.""" |
| s = " " * n + s |
| s = s.replace("\n", "\n" + " " * n) |
| return s |
