jaclang 0.4.6__py3-none-any.whl → 0.5.0__py3-none-any.whl

jaclang/vendor/mypy/parse.py

@@ -9,8 +9,9 @@ def parse(
     source: str | bytes,
     fnam: str,
     module: str | None,
-    errors: Errors | None,
+    errors: Errors,
     options: Options,
+    raise_on_error: bool = False,
 ) -> MypyFile:
     """Parse a source file, without doing any semantic analysis.
 
@@ -23,6 +24,9 @@ def parse(
         source = options.transform_source(source)
     import mypy.fastparse
 
-    return mypy.fastparse.parse(
+    tree = mypy.fastparse.parse(
         source, fnam=fnam, module=module, errors=errors, options=options
     )
+    if raise_on_error and errors.is_errors():
+        errors.raise_error()
+    return tree

jaclang/vendor/mypy/patterns.py

@@ -60,7 +60,7 @@ class ValuePattern(Pattern):
 
     expr: Expression
 
-    def __init__(self, expr: Expression):
+    def __init__(self, expr: Expression) -> None:
         super().__init__()
         self.expr = expr
 
@@ -72,7 +72,7 @@ class SingletonPattern(Pattern):
     # This can be exactly True, False or None
     value: bool | None
 
-    def __init__(self, value: bool | None):
+    def __init__(self, value: bool | None) -> None:
         super().__init__()
         self.value = value
 
@@ -85,7 +85,7 @@ class SequencePattern(Pattern):
 
     patterns: list[Pattern]
 
-    def __init__(self, patterns: list[Pattern]):
+    def __init__(self, patterns: list[Pattern]) -> None:
         super().__init__()
         self.patterns = patterns
 
@@ -98,7 +98,7 @@ class StarredPattern(Pattern):
     # a name.
     capture: NameExpr | None
 
-    def __init__(self, capture: NameExpr | None):
+    def __init__(self, capture: NameExpr | None) -> None:
         super().__init__()
         self.capture = capture
 
@@ -113,7 +113,7 @@ class MappingPattern(Pattern):
 
     def __init__(
         self, keys: list[Expression], values: list[Pattern], rest: NameExpr | None
-    ):
+    ) -> None:
         super().__init__()
         assert len(keys) == len(values)
         self.keys = keys
@@ -138,7 +138,7 @@ class ClassPattern(Pattern):
         positionals: list[Pattern],
         keyword_keys: list[str],
         keyword_values: list[Pattern],
-    ):
+    ) -> None:
         super().__init__()
         assert len(keyword_keys) == len(keyword_values)
         self.class_ref = class_ref

jaclang/vendor/mypy/plugin.py

@@ -515,7 +515,9 @@ class AttributeContext(NamedTuple):
 # A context for a class hook that modifies the class definition.
 class ClassDefContext(NamedTuple):
     cls: ClassDef  # The class definition
-    reason: Expression  # The expression being applied (decorator, metaclass, base class)
+    reason: (
+        Expression  # The expression being applied (decorator, metaclass, base class)
+    )
     api: SemanticAnalyzerPluginInterface
 
 

jaclang/vendor/mypy/plugins/attrs.py

@@ -123,6 +123,7 @@ class Attribute:
     def __init__(
         self,
         name: str,
+        alias: str | None,
         info: TypeInfo,
         has_default: bool,
         init: bool,
@@ -132,6 +133,7 @@ class Attribute:
         init_type: Type | None,
     ) -> None:
         self.name = name
+        self.alias = alias
         self.info = info
         self.has_default = has_default
         self.init = init
@@ -192,21 +194,23 @@ class Attribute:
             arg_kind = ARG_OPT if self.has_default else ARG_POS
 
         # Attrs removes leading underscores when creating the __init__ arguments.
-        return Argument(
-            Var(self.name.lstrip("_"), init_type), init_type, None, arg_kind
-        )
+        name = self.alias or self.name.lstrip("_")
+        return Argument(Var(name, init_type), init_type, None, arg_kind)
 
     def serialize(self) -> JsonDict:
         """Serialize this object so it can be saved and restored."""
         return {
             "name": self.name,
+            "alias": self.alias,
             "has_default": self.has_default,
             "init": self.init,
             "kw_only": self.kw_only,
             "has_converter": self.converter is not None,
-            "converter_init_type": self.converter.init_type.serialize()
-            if self.converter and self.converter.init_type
-            else None,
+            "converter_init_type": (
+                self.converter.init_type.serialize()
+                if self.converter and self.converter.init_type
+                else None
+            ),
             "context_line": self.context.line,
             "context_column": self.context.column,
             "init_type": self.init_type.serialize() if self.init_type else None,
@@ -230,6 +234,7 @@ class Attribute:
 
         return Attribute(
             data["name"],
+            data["alias"],
             info,
             data["has_default"],
             data["init"],
@@ -332,6 +337,8 @@ def attr_class_maker_callback(
     it will add an __init__ or all the compare methods.
     For frozen=True it will turn the attrs into properties.
 
+    Hashability will be set according to https://www.attrs.org/en/stable/hashing.html.
+
     See https://www.attrs.org/en/stable/how-does-it-work.html for information on how attrs works.
 
     If this returns False, some required metadata was not ready yet and we need another
@@ -343,6 +350,9 @@ def attr_class_maker_callback(
     frozen = _get_frozen(ctx, frozen_default)
     order = _determine_eq_order(ctx)
     slots = _get_decorator_bool_argument(ctx, "slots", slots_default)
+    hashable = _get_decorator_bool_argument(
+        ctx, "hash", False
+    ) or _get_decorator_bool_argument(ctx, "unsafe_hash", False)
 
     auto_attribs = _get_decorator_optional_bool_argument(
         ctx, "auto_attribs", auto_attribs_default
@@ -385,10 +395,13 @@ def attr_class_maker_callback(
     adder = MethodAdder(ctx)
     # If  __init__ is not being generated, attrs still generates it as __attrs_init__ instead.
     _add_init(ctx, attributes, adder, "__init__" if init else ATTRS_INIT_NAME)
+
     if order:
         _add_order(ctx, adder)
     if frozen:
         _make_frozen(ctx, attributes)
+    elif not hashable:
+        _remove_hashability(ctx)
 
     return True
 
@@ -534,6 +547,7 @@ def _attributes_from_assignment(
     or if auto_attribs is enabled also like this:
         x: type
         x: type = default_value
+        x: type = attr.ib(...)
     """
     for lvalue in stmt.lvalues:
         lvalues, rvalues = _parse_assignments(lvalue, stmt)
@@ -604,7 +618,9 @@ def _attribute_from_auto_attrib(
     has_rhs = not isinstance(rvalue, TempNode)
     sym = ctx.cls.info.names.get(name)
     init_type = sym.type if sym else None
-    return Attribute(name, ctx.cls.info, has_rhs, True, kw_only, None, stmt, init_type)
+    return Attribute(
+        name, None, ctx.cls.info, has_rhs, True, kw_only, None, stmt, init_type
+    )
 
 
 def _attribute_from_attrib_maker(
@@ -670,9 +686,21 @@ def _attribute_from_attrib_maker(
         converter = convert
     converter_info = _parse_converter(ctx, converter)
 
+    # Custom alias might be defined:
+    alias = None
+    alias_expr = _get_argument(rvalue, "alias")
+    if alias_expr:
+        alias = ctx.api.parse_str_literal(alias_expr)
+        if alias is None:
+            ctx.api.fail(
+                '"alias" argument to attrs field must be a string literal',
+                rvalue,
+                code=LITERAL_REQ,
+            )
     name = unmangle(lhs.name)
     return Attribute(
         name,
+        alias,
         ctx.cls.info,
         attr_has_default,
         init,
@@ -989,6 +1017,18 @@ def _add_match_args(
         )
 
 
+def _remove_hashability(ctx: mypy.plugin.ClassDefContext) -> None:
+    """Remove hashability from a class."""
+    add_attribute_to_class(
+        ctx.api,
+        ctx.cls,
+        "__hash__",
+        NoneType(),
+        is_classvar=True,
+        overwrite_existing=True,
+    )
+
+
 class MethodAdder:
     """Helper to add methods to a TypeInfo.
 
@@ -1110,9 +1150,11 @@ def _meet_fields(types: list[Mapping[str, Type]]) -> Mapping[str, Type]:
             field_to_types[name].append(typ)
 
     return {
-        name: get_proper_type(reduce(meet_types, f_types))
-        if len(f_types) == len(types)
-        else UninhabitedType()
+        name: (
+            get_proper_type(reduce(meet_types, f_types))
+            if len(f_types) == len(types)
+            else UninhabitedType()
+        )
         for name, f_types in field_to_types.items()
     }
 

jaclang/vendor/mypy/plugins/common.py

@@ -417,6 +417,7 @@ def add_attribute_to_class(
     override_allow_incompatible: bool = False,
     fullname: str | None = None,
     is_classvar: bool = False,
+    overwrite_existing: bool = False,
 ) -> Var:
     """
     Adds a new attribute to a class definition.
@@ -426,7 +427,7 @@ def add_attribute_to_class(
 
     # NOTE: we would like the plugin generated node to dominate, but we still
     # need to keep any existing definitions so they get semantically analyzed.
-    if name in info.names:
+    if name in info.names and not overwrite_existing:
         # Get a nice unique name instead.
         r_name = get_unique_redefinition_name(name, info.names)
         info.names[r_name] = info.names[name]

jaclang/vendor/mypy/plugins/enums.py

@@ -10,6 +10,7 @@ Note that this file does *not* contain all special-cased logic related to enums:
 we actually bake some of it directly in to the semantic analysis layer (see
 semanal_enum.py).
 """
+
 from __future__ import annotations
 
 from typing import Final, Iterable, Sequence, TypeVar, cast
@@ -177,11 +178,11 @@ def enum_value_callback(ctx: mypy.plugin.AttributeContext) -> Type:
                 for n in stnodes
                 if n is None or not n.implicit
             )
-            proper_types = list(
+            proper_types = [
                 _infer_value_type_with_auto_fallback(ctx, t)
                 for t in node_types
                 if t is None or not isinstance(t, CallableType)
-            )
+            ]
             underlying_type = _first(proper_types)
             if underlying_type is None:
                 return ctx.default_attr_type

jaclang/vendor/mypy/plugins/functools.py

@@ -1,4 +1,5 @@
 """Plugin for supporting the functools standard library module."""
+
 from __future__ import annotations
 
 from typing import Final, NamedTuple

jaclang/vendor/mypy/renaming.py

@@ -270,7 +270,7 @@ class VariableRenameVisitor(TraverserVisitor):
         This will be called at the end of a scope.
         """
         is_func = self.scope_kinds[-1] == FUNCTION
-        for name, refs in self.refs[-1].items():
+        for refs in self.refs[-1].values():
             if len(refs) == 1:
                 # Only one definition -- no renaming needed.
                 continue

jaclang/vendor/mypy/report.py

@@ -31,18 +31,18 @@ try:
 except ImportError:
     LXML_INSTALLED = False
 
-type_of_any_name_map: Final[
-    collections.OrderedDict[int, str]
-] = collections.OrderedDict(
-    [
-        (TypeOfAny.unannotated, "Unannotated"),
-        (TypeOfAny.explicit, "Explicit"),
-        (TypeOfAny.from_unimported_type, "Unimported"),
-        (TypeOfAny.from_omitted_generics, "Omitted Generics"),
-        (TypeOfAny.from_error, "Error"),
-        (TypeOfAny.special_form, "Special Form"),
-        (TypeOfAny.implementation_artifact, "Implementation Artifact"),
-    ]
+type_of_any_name_map: Final[collections.OrderedDict[int, str]] = (
+    collections.OrderedDict(
+        [
+            (TypeOfAny.unannotated, "Unannotated"),
+            (TypeOfAny.explicit, "Explicit"),
+            (TypeOfAny.from_unimported_type, "Unimported"),
+            (TypeOfAny.from_omitted_generics, "Omitted Generics"),
+            (TypeOfAny.from_error, "Error"),
+            (TypeOfAny.special_form, "Special Form"),
+            (TypeOfAny.implementation_artifact, "Implementation Artifact"),
+        ]
+    )
 )
 
 ReporterClasses: _TypeAlias = Dict[
@@ -101,7 +101,7 @@ class AbstractReporter(metaclass=ABCMeta):
     def __init__(self, reports: Reports, output_dir: str) -> None:
         self.output_dir = output_dir
         if output_dir != "<memory>":
-            stats.ensure_dir_exists(output_dir)
+            os.makedirs(output_dir, exist_ok=True)
 
     @abstractmethod
     def on_file(
@@ -766,7 +766,7 @@ class XmlReporter(AbstractXmlReporter):
         if path.startswith(".."):
             return
         out_path = os.path.join(self.output_dir, "xml", path + ".xml")
-        stats.ensure_dir_exists(os.path.dirname(out_path))
+        os.makedirs(os.path.dirname(out_path), exist_ok=True)
         last_xml.write(out_path, encoding="utf-8")
 
     def on_finish(self) -> None:
@@ -811,7 +811,7 @@ class XsltHtmlReporter(AbstractXmlReporter):
         if path.startswith(".."):
             return
         out_path = os.path.join(self.output_dir, "html", path + ".html")
-        stats.ensure_dir_exists(os.path.dirname(out_path))
+        os.makedirs(os.path.dirname(out_path), exist_ok=True)
         transformed_html = bytes(self.xslt_html(last_xml, ext=self.param_html))
         with open(out_path, "wb") as out_file:
             out_file.write(transformed_html)

jaclang/vendor/mypy/semanal.py

@@ -234,9 +234,9 @@ from mypy.semanal_typeddict import TypedDictAnalyzer
 from mypy.tvar_scope import TypeVarLikeScope
 from mypy.typeanal import (
     SELF_TYPE_NAMES,
+    FindTypeVarVisitor,
     TypeAnalyser,
     TypeVarLikeList,
-    TypeVarLikeQuery,
     analyze_type_alias,
     check_for_explicit_any,
     detect_diverging_alias,
@@ -2147,6 +2147,11 @@ class SemanticAnalyzer(
             assert isinstance(sym.node, TypeVarExpr)
             return t.name, sym.node
 
+    def find_type_var_likes(self, t: Type) -> TypeVarLikeList:
+        visitor = FindTypeVarVisitor(self, self.tvar_scope)
+        t.accept(visitor)
+        return visitor.type_var_likes
+
     def get_all_bases_tvars(
         self, base_type_exprs: list[Expression], removed: list[int]
     ) -> TypeVarLikeList:
@@ -2159,7 +2164,7 @@ class SemanticAnalyzer(
                 except TypeTranslationError:
                     # This error will be caught later.
                     continue
-                base_tvars = base.accept(TypeVarLikeQuery(self, self.tvar_scope))
+                base_tvars = self.find_type_var_likes(base)
                 tvars.extend(base_tvars)
         return remove_dups(tvars)
 
@@ -2179,7 +2184,7 @@ class SemanticAnalyzer(
             except TypeTranslationError:
                 # This error will be caught later.
                 continue
-            base_tvars = base.accept(TypeVarLikeQuery(self, self.tvar_scope))
+            base_tvars = self.find_type_var_likes(base)
             tvars.extend(base_tvars)
         tvars = remove_dups(
             tvars
@@ -2281,8 +2286,16 @@ class SemanticAnalyzer(
             if (
                 isinstance(base_expr, RefExpr)
                 and base_expr.fullname in TYPED_NAMEDTUPLE_NAMES + TPDICT_NAMES
+            ) or (
+                isinstance(base_expr, CallExpr)
+                and isinstance(base_expr.callee, RefExpr)
+                and base_expr.callee.fullname in TPDICT_NAMES
             ):
                 # Ignore magic bases for now.
+                # For example:
+                #  class Foo(TypedDict): ...  # RefExpr
+                #  class Foo(NamedTuple): ...  # RefExpr
+                #  class Foo(TypedDict("Foo", {"a": int})): ...  # CallExpr
                 continue
 
             try:
@@ -3721,7 +3734,7 @@ class SemanticAnalyzer(
             )
             return None, [], set(), [], False
 
-        found_type_vars = typ.accept(TypeVarLikeQuery(self, self.tvar_scope))
+        found_type_vars = self.find_type_var_likes(typ)
         tvar_defs: list[TypeVarLikeType] = []
         namespace = self.qualified_name(name)
         with self.tvar_scope_frame(self.tvar_scope.class_frame(namespace)):
@@ -4437,7 +4450,7 @@ class SemanticAnalyzer(
         if len(call.args) < 1:
             self.fail(f"Too few arguments for {typevarlike_type}()", context)
             return False
-        if not isinstance(call.args[0], StrExpr) or not call.arg_kinds[0] == ARG_POS:
+        if not isinstance(call.args[0], StrExpr) or call.arg_kinds[0] != ARG_POS:
             self.fail(
                 f"{typevarlike_type}() expects a string literal as first argument",
                 context,
@@ -5306,9 +5319,7 @@ class SemanticAnalyzer(
         """Bind name expression to a symbol table node."""
         if isinstance(sym.node, TypeVarExpr) and self.tvar_scope.get_binding(sym):
             self.fail(
-                '"{}" is a type variable and only valid in type '
-                "context".format(expr.name),
-                expr,
+                f'"{expr.name}" is a type variable and only valid in type context', expr
             )
         elif isinstance(sym.node, PlaceholderNode):
             self.process_placeholder(expr.name, "name", expr)
@@ -6645,9 +6656,7 @@ class SemanticAnalyzer(
         line = (
             debug_context.line
             if debug_context
-            else self.statement.line
-            if self.statement
-            else -1
+            else self.statement.line if self.statement else -1
         )
         self.deferral_debug_context.append((self.cur_mod_id, line))
 
@@ -7273,13 +7282,13 @@ class SemanticAnalyzer(
     ) -> tuple[str, ...]:
         if not isinstance(arg, TupleExpr):
             self.fail('"field_specifiers" argument must be a tuple literal', arg)
-            return tuple()
+            return ()
 
         names = []
         for specifier in arg.items:
             if not isinstance(specifier, RefExpr):
                 self.fail('"field_specifiers" must only contain identifiers', specifier)
-                return tuple()
+                return ()
             names.append(specifier.fullname)
         return tuple(names)
 

jaclang/vendor/mypy/semanal_enum.py

@@ -148,7 +148,7 @@ class EnumCallAnalyzer:
         Return a tuple of fields, values, was there an error.
         """
         args = call.args
-        if not all([arg_kind in [ARG_POS, ARG_NAMED] for arg_kind in call.arg_kinds]):
+        if not all(arg_kind in [ARG_POS, ARG_NAMED] for arg_kind in call.arg_kinds):
             return self.fail_enum_call_arg(
                 f"Unexpected arguments to {class_name}()", call
             )

jaclang/vendor/mypy/semanal_namedtuple.py

@@ -85,8 +85,7 @@ NAMEDTUPLE_PROHIBITED_NAMES: Final = (
 )
 
 NAMEDTUP_CLASS_ERROR: Final = (
-    "Invalid statement in NamedTuple definition; "
-    'expected "field_name: field_type [= default]"'
+    'Invalid statement in NamedTuple definition; expected "field_name: field_type [= default]"'
 )
 
 SELF_TVAR_NAME: Final = "_NT"

jaclang/vendor/mypy/semanal_shared.py

@@ -318,8 +318,7 @@ def calculate_tuple_fallback(typ: TupleType) -> None:
 class _NamedTypeCallback(Protocol):
     def __call__(
         self, fully_qualified_name: str, args: list[Type] | None = None
-    ) -> Instance:
-        ...
+    ) -> Instance: ...
 
 
 def paramspec_args(
@@ -469,8 +468,7 @@ def require_bool_literal_argument(
     expression: Expression,
     name: str,
     default: Literal[True] | Literal[False],
-) -> bool:
-    ...
+) -> bool: ...
 
 
 @overload
@@ -479,8 +477,7 @@ def require_bool_literal_argument(
     expression: Expression,
     name: str,
     default: None = None,
-) -> bool | None:
-    ...
+) -> bool | None: ...
 
 
 def require_bool_literal_argument(

jaclang/vendor/mypy/semanal_typeddict.py

@@ -50,7 +50,7 @@ from mypy.types import (
 )
 
 TPDICT_CLASS_ERROR: Final = (
-    "Invalid statement in TypedDict definition; " 'expected "field_name: field_type"'
+    'Invalid statement in TypedDict definition; expected "field_name: field_type"'
 )
 
 
@@ -81,6 +81,8 @@ class TypedDictAnalyzer:
         """
         possible = False
         for base_expr in defn.base_type_exprs:
+            if isinstance(base_expr, CallExpr):
+                base_expr = base_expr.callee
             if isinstance(base_expr, IndexExpr):
                 base_expr = base_expr.base
             if isinstance(base_expr, RefExpr):
@@ -126,7 +128,13 @@ class TypedDictAnalyzer:
         typeddict_bases: list[Expression] = []
         typeddict_bases_set = set()
         for expr in defn.base_type_exprs:
-            if isinstance(expr, RefExpr) and expr.fullname in TPDICT_NAMES:
+            ok, maybe_type_info, _ = self.check_typeddict(expr, None, False)
+            if ok and maybe_type_info is not None:
+                # expr is a CallExpr
+                info = maybe_type_info
+                typeddict_bases_set.add(info.fullname)
+                typeddict_bases.append(expr)
+            elif isinstance(expr, RefExpr) and expr.fullname in TPDICT_NAMES:
                 if "TypedDict" not in typeddict_bases_set:
                     typeddict_bases_set.add("TypedDict")
                 else:
@@ -185,12 +193,11 @@ class TypedDictAnalyzer:
         required_keys: set[str],
         ctx: Context,
     ) -> None:
+        base_args: list[Type] = []
         if isinstance(base, RefExpr):
             assert isinstance(base.node, TypeInfo)
             info = base.node
-            base_args: list[Type] = []
-        else:
-            assert isinstance(base, IndexExpr)
+        elif isinstance(base, IndexExpr):
             assert isinstance(base.base, RefExpr)
             assert isinstance(base.base.node, TypeInfo)
             info = base.base.node
@@ -198,6 +205,10 @@ class TypedDictAnalyzer:
             if args is None:
                 return
             base_args = args
+        else:
+            assert isinstance(base, CallExpr)
+            assert isinstance(base.analyzed, TypedDictExpr)
+            info = base.analyzed.info
 
         assert info.typeddict_type is not None
         base_typed_dict = info.typeddict_type

jaclang/vendor/mypy/server/astdiff.py

@@ -261,9 +261,11 @@ def snapshot_definition(
             node.is_static,
             signature,
             is_trivial_body,
-            dataclass_transform_spec.serialize()
-            if dataclass_transform_spec is not None
-            else None,
+            (
+                dataclass_transform_spec.serialize()
+                if dataclass_transform_spec is not None
+                else None
+            ),
         )
     elif isinstance(node, Var):
         return ("Var", common, snapshot_optional_type(node.type), node.is_final)
@@ -309,9 +311,11 @@ def snapshot_definition(
             tuple(snapshot_type(tdef) for tdef in node.defn.type_vars),
             [snapshot_type(base) for base in node.bases],
             [snapshot_type(p) for p in node._promote],
-            dataclass_transform_spec.serialize()
-            if dataclass_transform_spec is not None
-            else None,
+            (
+                dataclass_transform_spec.serialize()
+                if dataclass_transform_spec is not None
+                else None
+            ),
         )
         prefix = node.fullname
         symbol_table = snapshot_symbol_table(prefix, node.names)
@@ -397,9 +401,11 @@ class SnapshotTypeVisitor(TypeVisitor[SnapshotItem]):
             "Instance",
             encode_optional_str(typ.type.fullname),
             snapshot_types(typ.args),
-            ("None",)
-            if typ.last_known_value is None
-            else snapshot_type(typ.last_known_value),
+            (
+                ("None",)
+                if typ.last_known_value is None
+                else snapshot_type(typ.last_known_value)
+            ),
         )
 
     def visit_type_var(self, typ: TypeVarType) -> SnapshotItem:

jaclang/vendor/mypy/server/astmerge.py

@@ -175,9 +175,9 @@ def replacement_map_from_symbol_table(
                     )
                     replacements.update(type_repl)
                     if node.node.special_alias and new_node.node.special_alias:
-                        replacements[
-                            new_node.node.special_alias
-                        ] = node.node.special_alias
+                        replacements[new_node.node.special_alias] = (
+                            node.node.special_alias
+                        )
     return replacements
 
 
@@ -398,7 +398,7 @@ class NodeReplaceVisitor(TraverserVisitor):
         # have bodies in the AST so we need to iterate over their symbol
         # tables separately, unlike normal classes.
         self.process_type_info(info)
-        for name, node in info.names.items():
+        for node in info.names.values():
             if node.node:
                 node.node.accept(self)
 
@@ -553,7 +553,7 @@ class TypeReplaceVisitor(SyntheticTypeVisitor[None]):
 def replace_nodes_in_symbol_table(
     symbols: SymbolTable, replacements: dict[SymbolNode, SymbolNode]
 ) -> None:
-    for name, node in symbols.items():
+    for node in symbols.values():
         if node.node:
             if node.node in replacements:
                 new = replacements[node.node]

jaclang/vendor/mypy/stats.py

@@ -495,11 +495,6 @@ def is_complex(t: Type) -> bool:
     return is_generic(t) or isinstance(t, (FunctionLike, TupleType, TypeVarType))
 
 
-def ensure_dir_exists(dir: str) -> None:
-    if not os.path.exists(dir):
-        os.makedirs(dir)
-
-
 def is_special_form_any(t: AnyType) -> bool:
     return get_original_any(t).type_of_any == TypeOfAny.special_form