jaclang 0.7.34__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypy/server/mergecheck.py

@@ -1,83 +0,0 @@
-"""Check for duplicate AST nodes after merge."""
-
-from __future__ import annotations
-
-from typing import Final
-
-from mypy.nodes import Decorator, FakeInfo, FuncDef, SymbolNode, Var
-from mypy.server.objgraph import get_path, get_reachable_graph
-
-# If True, print more verbose output on failure.
-DUMP_MISMATCH_NODES: Final = False
-
-
-def check_consistency(o: object) -> None:
-    """Fail if there are two AST nodes with the same fullname reachable from 'o'.
-
-    Raise AssertionError on failure and print some debugging output.
-    """
-    seen, parents = get_reachable_graph(o)
-    reachable = list(seen.values())
-    syms = [x for x in reachable if isinstance(x, SymbolNode)]
-
-    m: dict[str, SymbolNode] = {}
-    for sym in syms:
-        if isinstance(sym, FakeInfo):
-            continue
-
-        fn = sym.fullname
-        # Skip None names, since they are ambiguous.
-        # TODO: Everything should have a proper full name?
-        if fn is None:
-            continue
-        # Skip stuff that should be expected to have duplicate names
-        if isinstance(sym, (Var, Decorator)):
-            continue
-        if isinstance(sym, FuncDef) and sym.is_overload:
-            continue
-
-        if fn not in m:
-            m[sym.fullname] = sym
-            continue
-
-        # We have trouble and need to decide what to do about it.
-        sym1, sym2 = sym, m[fn]
-
-        # If the type changed, then it shouldn't have been merged.
-        if type(sym1) is not type(sym2):
-            continue
-
-        path1 = get_path(sym1, seen, parents)
-        path2 = get_path(sym2, seen, parents)
-
-        if fn in m:
-            print(f"\nDuplicate {type(sym).__name__!r} nodes with fullname {fn!r} found:")
-            print("[1] %d: %s" % (id(sym1), path_to_str(path1)))
-            print("[2] %d: %s" % (id(sym2), path_to_str(path2)))
-
-        if DUMP_MISMATCH_NODES and fn in m:
-            # Add verbose output with full AST node contents.
-            print("---")
-            print(id(sym1), sym1)
-            print("---")
-            print(id(sym2), sym2)
-
-        assert sym.fullname not in m
-
-
-def path_to_str(path: list[tuple[object, object]]) -> str:
-    result = "<root>"
-    for attr, obj in path:
-        t = type(obj).__name__
-        if t in ("dict", "tuple", "SymbolTable", "list"):
-            result += f"[{repr(attr)}]"
-        else:
-            if isinstance(obj, Var):
-                result += f".{attr}({t}:{obj.name})"
-            elif t in ("BuildManager", "FineGrainedBuildManager"):
-                # Omit class name for some classes that aren't part of a class
-                # hierarchy since there isn't much ambiguity.
-                result += f".{attr}"
-            else:
-                result += f".{attr}({t})"
-    return result

jaclang/vendor/mypy/server/objgraph.py

@@ -1,101 +0,0 @@
-"""Find all objects reachable from a root object."""
-
-from __future__ import annotations
-
-import types
-import weakref
-from collections.abc import Iterable
-from typing import Final, Iterator, Mapping
-
-method_descriptor_type: Final = type(object.__dir__)
-method_wrapper_type: Final = type(object().__ne__)
-wrapper_descriptor_type: Final = type(object.__ne__)
-
-FUNCTION_TYPES: Final = (
-    types.BuiltinFunctionType,
-    types.FunctionType,
-    types.MethodType,
-    method_descriptor_type,
-    wrapper_descriptor_type,
-    method_wrapper_type,
-)
-
-ATTR_BLACKLIST: Final = {"__doc__", "__name__", "__class__", "__dict__"}
-
-# Instances of these types can't have references to other objects
-ATOMIC_TYPE_BLACKLIST: Final = {bool, int, float, str, type(None), object}
-
-# Don't look at most attributes of these types
-COLLECTION_TYPE_BLACKLIST: Final = {list, set, dict, tuple}
-
-# Don't return these objects
-TYPE_BLACKLIST: Final = {weakref.ReferenceType}
-
-
-def isproperty(o: object, attr: str) -> bool:
-    return isinstance(getattr(type(o), attr, None), property)
-
-
-def get_edge_candidates(o: object) -> Iterator[tuple[object, object]]:
-    # use getattr because mypyc expects dict, not mappingproxy
-    if "__getattribute__" in getattr(type(o), "__dict__"):  # noqa: B009
-        return
-    if type(o) not in COLLECTION_TYPE_BLACKLIST:
-        for attr in dir(o):
-            try:
-                if attr not in ATTR_BLACKLIST and hasattr(o, attr) and not isproperty(o, attr):
-                    e = getattr(o, attr)
-                    if type(e) not in ATOMIC_TYPE_BLACKLIST:
-                        yield attr, e
-            except AssertionError:
-                pass
-    if isinstance(o, Mapping):
-        yield from o.items()
-    elif isinstance(o, Iterable) and not isinstance(o, str):
-        for i, e in enumerate(o):
-            yield i, e
-
-
-def get_edges(o: object) -> Iterator[tuple[object, object]]:
-    for s, e in get_edge_candidates(o):
-        if isinstance(e, FUNCTION_TYPES):
-            # We don't want to collect methods, but do want to collect values
-            # in closures and self pointers to other objects
-
-            if hasattr(e, "__closure__"):
-                yield (s, "__closure__"), e.__closure__
-            if hasattr(e, "__self__"):
-                se = e.__self__
-                if se is not o and se is not type(o) and hasattr(s, "__self__"):
-                    yield s.__self__, se
-        else:
-            if type(e) not in TYPE_BLACKLIST:
-                yield s, e
-
-
-def get_reachable_graph(root: object) -> tuple[dict[int, object], dict[int, tuple[int, object]]]:
-    parents = {}
-    seen = {id(root): root}
-    worklist = [root]
-    while worklist:
-        o = worklist.pop()
-        for s, e in get_edges(o):
-            if id(e) in seen:
-                continue
-            parents[id(e)] = (id(o), s)
-            seen[id(e)] = e
-            worklist.append(e)
-
-    return seen, parents
-
-
-def get_path(
-    o: object, seen: dict[int, object], parents: dict[int, tuple[int, object]]
-) -> list[tuple[object, object]]:
-    path = []
-    while id(o) in parents:
-        pid, attr = parents[id(o)]
-        o = seen[pid]
-        path.append((attr, o))
-    path.reverse()
-    return path

jaclang/vendor/mypy/server/subexpr.py

@@ -1,198 +0,0 @@
-"""Find all subexpressions of an AST node."""
-
-from __future__ import annotations
-
-from mypy.nodes import (
-    AssertTypeExpr,
-    AssignmentExpr,
-    AwaitExpr,
-    CallExpr,
-    CastExpr,
-    ComparisonExpr,
-    ConditionalExpr,
-    DictExpr,
-    DictionaryComprehension,
-    Expression,
-    GeneratorExpr,
-    IndexExpr,
-    LambdaExpr,
-    ListComprehension,
-    ListExpr,
-    MemberExpr,
-    Node,
-    OpExpr,
-    RevealExpr,
-    SetComprehension,
-    SetExpr,
-    SliceExpr,
-    StarExpr,
-    TupleExpr,
-    TypeApplication,
-    UnaryExpr,
-    YieldExpr,
-    YieldFromExpr,
-)
-from mypy.traverser import TraverserVisitor
-
-
-def get_subexpressions(node: Node) -> list[Expression]:
-    visitor = SubexpressionFinder()
-    node.accept(visitor)
-    return visitor.expressions
-
-
-class SubexpressionFinder(TraverserVisitor):
-    def __init__(self) -> None:
-        self.expressions: list[Expression] = []
-
-    def visit_int_expr(self, o: Expression) -> None:
-        self.add(o)
-
-    def visit_name_expr(self, o: Expression) -> None:
-        self.add(o)
-
-    def visit_float_expr(self, o: Expression) -> None:
-        self.add(o)
-
-    def visit_str_expr(self, o: Expression) -> None:
-        self.add(o)
-
-    def visit_bytes_expr(self, o: Expression) -> None:
-        self.add(o)
-
-    def visit_unicode_expr(self, o: Expression) -> None:
-        self.add(o)
-
-    def visit_complex_expr(self, o: Expression) -> None:
-        self.add(o)
-
-    def visit_ellipsis(self, o: Expression) -> None:
-        self.add(o)
-
-    def visit_super_expr(self, o: Expression) -> None:
-        self.add(o)
-
-    def visit_type_var_expr(self, o: Expression) -> None:
-        self.add(o)
-
-    def visit_type_alias_expr(self, o: Expression) -> None:
-        self.add(o)
-
-    def visit_namedtuple_expr(self, o: Expression) -> None:
-        self.add(o)
-
-    def visit_typeddict_expr(self, o: Expression) -> None:
-        self.add(o)
-
-    def visit__promote_expr(self, o: Expression) -> None:
-        self.add(o)
-
-    def visit_newtype_expr(self, o: Expression) -> None:
-        self.add(o)
-
-    def visit_member_expr(self, e: MemberExpr) -> None:
-        self.add(e)
-        super().visit_member_expr(e)
-
-    def visit_yield_from_expr(self, e: YieldFromExpr) -> None:
-        self.add(e)
-        super().visit_yield_from_expr(e)
-
-    def visit_yield_expr(self, e: YieldExpr) -> None:
-        self.add(e)
-        super().visit_yield_expr(e)
-
-    def visit_call_expr(self, e: CallExpr) -> None:
-        self.add(e)
-        super().visit_call_expr(e)
-
-    def visit_op_expr(self, e: OpExpr) -> None:
-        self.add(e)
-        super().visit_op_expr(e)
-
-    def visit_comparison_expr(self, e: ComparisonExpr) -> None:
-        self.add(e)
-        super().visit_comparison_expr(e)
-
-    def visit_slice_expr(self, e: SliceExpr) -> None:
-        self.add(e)
-        super().visit_slice_expr(e)
-
-    def visit_cast_expr(self, e: CastExpr) -> None:
-        self.add(e)
-        super().visit_cast_expr(e)
-
-    def visit_assert_type_expr(self, e: AssertTypeExpr) -> None:
-        self.add(e)
-        super().visit_assert_type_expr(e)
-
-    def visit_reveal_expr(self, e: RevealExpr) -> None:
-        self.add(e)
-        super().visit_reveal_expr(e)
-
-    def visit_assignment_expr(self, e: AssignmentExpr) -> None:
-        self.add(e)
-        super().visit_assignment_expr(e)
-
-    def visit_unary_expr(self, e: UnaryExpr) -> None:
-        self.add(e)
-        super().visit_unary_expr(e)
-
-    def visit_list_expr(self, e: ListExpr) -> None:
-        self.add(e)
-        super().visit_list_expr(e)
-
-    def visit_tuple_expr(self, e: TupleExpr) -> None:
-        self.add(e)
-        super().visit_tuple_expr(e)
-
-    def visit_dict_expr(self, e: DictExpr) -> None:
-        self.add(e)
-        super().visit_dict_expr(e)
-
-    def visit_set_expr(self, e: SetExpr) -> None:
-        self.add(e)
-        super().visit_set_expr(e)
-
-    def visit_index_expr(self, e: IndexExpr) -> None:
-        self.add(e)
-        super().visit_index_expr(e)
-
-    def visit_generator_expr(self, e: GeneratorExpr) -> None:
-        self.add(e)
-        super().visit_generator_expr(e)
-
-    def visit_dictionary_comprehension(self, e: DictionaryComprehension) -> None:
-        self.add(e)
-        super().visit_dictionary_comprehension(e)
-
-    def visit_list_comprehension(self, e: ListComprehension) -> None:
-        self.add(e)
-        super().visit_list_comprehension(e)
-
-    def visit_set_comprehension(self, e: SetComprehension) -> None:
-        self.add(e)
-        super().visit_set_comprehension(e)
-
-    def visit_conditional_expr(self, e: ConditionalExpr) -> None:
-        self.add(e)
-        super().visit_conditional_expr(e)
-
-    def visit_type_application(self, e: TypeApplication) -> None:
-        self.add(e)
-        super().visit_type_application(e)
-
-    def visit_lambda_expr(self, e: LambdaExpr) -> None:
-        self.add(e)
-        super().visit_lambda_expr(e)
-
-    def visit_star_expr(self, e: StarExpr) -> None:
-        self.add(e)
-        super().visit_star_expr(e)
-
-    def visit_await_expr(self, e: AwaitExpr) -> None:
-        self.add(e)
-        super().visit_await_expr(e)
-
-    def add(self, e: Expression) -> None:
-        self.expressions.append(e)

jaclang/vendor/mypy/server/target.py

@@ -1,11 +0,0 @@
-from __future__ import annotations
-
-
-def trigger_to_target(s: str) -> str:
-    assert s[0] == "<"
-    # Strip off the angle brackets
-    s = s[1:-1]
-    # If there is a [wildcard] or similar, strip that off too
-    if s[-1] == "]":
-        s = s.split("[")[0]
-    return s

jaclang/vendor/mypy/server/trigger.py

@@ -1,26 +0,0 @@
-"""AST triggers that are used for fine-grained dependency handling."""
-
-from __future__ import annotations
-
-from typing import Final
-
-# Used as a suffix for triggers to handle "from m import *" dependencies (see also
-# make_wildcard_trigger)
-
-WILDCARD_TAG: Final = "[wildcard]"
-
-
-def make_trigger(name: str) -> str:
-    return f"<{name}>"
-
-
-def make_wildcard_trigger(module: str) -> str:
-    """Special trigger fired when any top-level name is changed in a module.
-
-    Note that this is different from a module trigger, as module triggers are only
-    fired if the module is created, deleted, or replaced with a non-module, whereas
-    a wildcard trigger is triggered for namespace changes.
-
-    This is used for "from m import *" dependencies.
-    """
-    return f"<{module}{WILDCARD_TAG}>"