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

jaclang/vendor/mypyc/irbuild/targets.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-from mypyc.ir.ops import Register, Value
-from mypyc.ir.rtypes import RInstance, RType, object_rprimitive
-
-
-class AssignmentTarget:
-    """Abstract base class for assignment targets during IR building."""
-
-    type: RType = object_rprimitive
-
-
-class AssignmentTargetRegister(AssignmentTarget):
-    """Register as an assignment target.
-
-    This is used for local variables and some temporaries.
-    """
-
-    def __init__(self, register: Register) -> None:
-        self.register = register
-        self.type = register.type
-
-
-class AssignmentTargetIndex(AssignmentTarget):
-    """base[index] as assignment target"""
-
-    def __init__(self, base: Value, index: Value) -> None:
-        self.base = base
-        self.index = index
-        # TODO: object_rprimitive won't be right for user-defined classes. Store the
-        #       lvalue type in mypy and use a better type to avoid unneeded boxing.
-        self.type = object_rprimitive
-
-
-class AssignmentTargetAttr(AssignmentTarget):
-    """obj.attr as assignment target"""
-
-    def __init__(self, obj: Value, attr: str, can_borrow: bool = False) -> None:
-        self.obj = obj
-        self.attr = attr
-        self.can_borrow = can_borrow
-        if isinstance(obj.type, RInstance) and obj.type.class_ir.has_attr(attr):
-            # Native attribute reference
-            self.obj_type: RType = obj.type
-            self.type = obj.type.attr_type(attr)
-        else:
-            # Python attribute reference
-            self.obj_type = object_rprimitive
-            self.type = object_rprimitive
-
-
-class AssignmentTargetTuple(AssignmentTarget):
-    """x, ..., y as assignment target"""
-
-    def __init__(self, items: list[AssignmentTarget], star_idx: int | None = None) -> None:
-        self.items = items
-        self.star_idx = star_idx

jaclang/vendor/mypyc/irbuild/util.py

@@ -1,189 +0,0 @@
-"""Various utilities that don't depend on other modules in mypyc.irbuild."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from mypy.nodes import (
-    ARG_NAMED,
-    ARG_NAMED_OPT,
-    ARG_OPT,
-    ARG_POS,
-    GDEF,
-    ArgKind,
-    BytesExpr,
-    CallExpr,
-    ClassDef,
-    Decorator,
-    Expression,
-    FloatExpr,
-    FuncDef,
-    IntExpr,
-    NameExpr,
-    OverloadedFuncDef,
-    RefExpr,
-    StrExpr,
-    TupleExpr,
-    UnaryExpr,
-    Var,
-)
-
-DATACLASS_DECORATORS = {"dataclasses.dataclass", "attr.s", "attr.attrs"}
-
-
-def is_trait_decorator(d: Expression) -> bool:
-    return isinstance(d, RefExpr) and d.fullname == "mypy_extensions.trait"
-
-
-def is_trait(cdef: ClassDef) -> bool:
-    return any(is_trait_decorator(d) for d in cdef.decorators) or cdef.info.is_protocol
-
-
-def dataclass_decorator_type(d: Expression) -> str | None:
-    if isinstance(d, RefExpr) and d.fullname in DATACLASS_DECORATORS:
-        return d.fullname.split(".")[0]
-    elif (
-        isinstance(d, CallExpr)
-        and isinstance(d.callee, RefExpr)
-        and d.callee.fullname in DATACLASS_DECORATORS
-    ):
-        name = d.callee.fullname.split(".")[0]
-        if name == "attr" and "auto_attribs" in d.arg_names:
-            # Note: the mypy attrs plugin checks that the value of auto_attribs is
-            # not computed at runtime, so we don't need to perform that check here
-            auto = d.args[d.arg_names.index("auto_attribs")]
-            if isinstance(auto, NameExpr) and auto.name == "True":
-                return "attr-auto"
-        return name
-    else:
-        return None
-
-
-def is_dataclass_decorator(d: Expression) -> bool:
-    return dataclass_decorator_type(d) is not None
-
-
-def is_dataclass(cdef: ClassDef) -> bool:
-    return any(is_dataclass_decorator(d) for d in cdef.decorators)
-
-
-def dataclass_type(cdef: ClassDef) -> str | None:
-    for d in cdef.decorators:
-        typ = dataclass_decorator_type(d)
-        if typ is not None:
-            return typ
-    return None
-
-
-def get_mypyc_attr_literal(e: Expression) -> Any:
-    """Convert an expression from a mypyc_attr decorator to a value.
-
-    Supports a pretty limited range."""
-    if isinstance(e, (StrExpr, IntExpr, FloatExpr)):
-        return e.value
-    elif isinstance(e, RefExpr) and e.fullname == "builtins.True":
-        return True
-    elif isinstance(e, RefExpr) and e.fullname == "builtins.False":
-        return False
-    elif isinstance(e, RefExpr) and e.fullname == "builtins.None":
-        return None
-    return NotImplemented
-
-
-def get_mypyc_attr_call(d: Expression) -> CallExpr | None:
-    """Check if an expression is a call to mypyc_attr and return it if so."""
-    if (
-        isinstance(d, CallExpr)
-        and isinstance(d.callee, RefExpr)
-        and d.callee.fullname == "mypy_extensions.mypyc_attr"
-    ):
-        return d
-    return None
-
-
-def get_mypyc_attrs(stmt: ClassDef | Decorator) -> dict[str, Any]:
-    """Collect all the mypyc_attr attributes on a class definition or a function."""
-    attrs: dict[str, Any] = {}
-    for dec in stmt.decorators:
-        d = get_mypyc_attr_call(dec)
-        if d:
-            for name, arg in zip(d.arg_names, d.args):
-                if name is None:
-                    if isinstance(arg, StrExpr):
-                        attrs[arg.value] = True
-                else:
-                    attrs[name] = get_mypyc_attr_literal(arg)
-
-    return attrs
-
-
-def is_extension_class(cdef: ClassDef) -> bool:
-    if any(
-        not is_trait_decorator(d) and not is_dataclass_decorator(d) and not get_mypyc_attr_call(d)
-        for d in cdef.decorators
-    ):
-        return False
-    if cdef.info.typeddict_type:
-        return False
-    if cdef.info.is_named_tuple:
-        return False
-    if cdef.info.metaclass_type and cdef.info.metaclass_type.type.fullname not in (
-        "abc.ABCMeta",
-        "typing.TypingMeta",
-        "typing.GenericMeta",
-    ):
-        return False
-    return True
-
-
-def get_func_def(op: FuncDef | Decorator | OverloadedFuncDef) -> FuncDef:
-    if isinstance(op, OverloadedFuncDef):
-        assert op.impl
-        op = op.impl
-    if isinstance(op, Decorator):
-        op = op.func
-    return op
-
-
-def concrete_arg_kind(kind: ArgKind) -> ArgKind:
-    """Find the concrete version of an arg kind that is being passed."""
-    if kind == ARG_OPT:
-        return ARG_POS
-    elif kind == ARG_NAMED_OPT:
-        return ARG_NAMED
-    else:
-        return kind
-
-
-def is_constant(e: Expression) -> bool:
-    """Check whether we allow an expression to appear as a default value.
-
-    We don't currently properly support storing the evaluated
-    values for default arguments and default attribute values, so
-    we restrict what expressions we allow.  We allow literals of
-    primitives types, None, and references to Final global
-    variables.
-    """
-    return (
-        isinstance(e, (StrExpr, BytesExpr, IntExpr, FloatExpr))
-        or (isinstance(e, UnaryExpr) and e.op == "-" and isinstance(e.expr, (IntExpr, FloatExpr)))
-        or (isinstance(e, TupleExpr) and all(is_constant(e) for e in e.items))
-        or (
-            isinstance(e, RefExpr)
-            and e.kind == GDEF
-            and (
-                e.fullname in ("builtins.True", "builtins.False", "builtins.None")
-                or (isinstance(e.node, Var) and e.node.is_final)
-            )
-        )
-    )
-
-
-def bytes_from_str(value: str) -> bytes:
-    """Convert a string representing bytes into actual bytes.
-
-    This is needed because the literal characters of BytesExpr (the
-    characters inside b'') are stored in BytesExpr.value, whose type is
-    'str' not 'bytes'.
-    """
-    return bytes(value, "utf8").decode("unicode-escape").encode("raw-unicode-escape")

jaclang/vendor/mypyc/irbuild/visitor.py

@@ -1,401 +0,0 @@
-"""Dispatcher used when transforming a mypy AST to the IR form.
-
-mypyc.irbuild.builder and mypyc.irbuild.main are closely related.
-"""
-
-from __future__ import annotations
-
-from typing import NoReturn
-
-from mypy.nodes import (
-    AssertStmt,
-    AssertTypeExpr,
-    AssignmentExpr,
-    AssignmentStmt,
-    AwaitExpr,
-    Block,
-    BreakStmt,
-    BytesExpr,
-    CallExpr,
-    CastExpr,
-    ClassDef,
-    ComparisonExpr,
-    ComplexExpr,
-    ConditionalExpr,
-    ContinueStmt,
-    Decorator,
-    DelStmt,
-    DictExpr,
-    DictionaryComprehension,
-    EllipsisExpr,
-    EnumCallExpr,
-    ExpressionStmt,
-    FloatExpr,
-    ForStmt,
-    FuncDef,
-    GeneratorExpr,
-    GlobalDecl,
-    IfStmt,
-    Import,
-    ImportAll,
-    ImportFrom,
-    IndexExpr,
-    IntExpr,
-    LambdaExpr,
-    ListComprehension,
-    ListExpr,
-    MatchStmt,
-    MemberExpr,
-    MypyFile,
-    NamedTupleExpr,
-    NameExpr,
-    NewTypeExpr,
-    NonlocalDecl,
-    OperatorAssignmentStmt,
-    OpExpr,
-    OverloadedFuncDef,
-    ParamSpecExpr,
-    PassStmt,
-    PromoteExpr,
-    RaiseStmt,
-    ReturnStmt,
-    RevealExpr,
-    SetComprehension,
-    SetExpr,
-    SliceExpr,
-    StarExpr,
-    StrExpr,
-    SuperExpr,
-    TempNode,
-    TryStmt,
-    TupleExpr,
-    TypeAliasExpr,
-    TypeApplication,
-    TypedDictExpr,
-    TypeVarExpr,
-    TypeVarTupleExpr,
-    UnaryExpr,
-    Var,
-    WhileStmt,
-    WithStmt,
-    YieldExpr,
-    YieldFromExpr,
-)
-from mypyc.ir.ops import Value
-from mypyc.irbuild.builder import IRBuilder, IRVisitor, UnsupportedException
-from mypyc.irbuild.classdef import transform_class_def
-from mypyc.irbuild.expression import (
-    transform_assignment_expr,
-    transform_bytes_expr,
-    transform_call_expr,
-    transform_comparison_expr,
-    transform_complex_expr,
-    transform_conditional_expr,
-    transform_dict_expr,
-    transform_dictionary_comprehension,
-    transform_ellipsis,
-    transform_float_expr,
-    transform_generator_expr,
-    transform_index_expr,
-    transform_int_expr,
-    transform_list_comprehension,
-    transform_list_expr,
-    transform_member_expr,
-    transform_name_expr,
-    transform_op_expr,
-    transform_set_comprehension,
-    transform_set_expr,
-    transform_slice_expr,
-    transform_str_expr,
-    transform_super_expr,
-    transform_tuple_expr,
-    transform_unary_expr,
-)
-from mypyc.irbuild.function import (
-    transform_decorator,
-    transform_func_def,
-    transform_lambda_expr,
-    transform_overloaded_func_def,
-)
-from mypyc.irbuild.statement import (
-    transform_assert_stmt,
-    transform_assignment_stmt,
-    transform_await_expr,
-    transform_block,
-    transform_break_stmt,
-    transform_continue_stmt,
-    transform_del_stmt,
-    transform_expression_stmt,
-    transform_for_stmt,
-    transform_if_stmt,
-    transform_import,
-    transform_import_all,
-    transform_import_from,
-    transform_match_stmt,
-    transform_operator_assignment_stmt,
-    transform_raise_stmt,
-    transform_return_stmt,
-    transform_try_stmt,
-    transform_while_stmt,
-    transform_with_stmt,
-    transform_yield_expr,
-    transform_yield_from_expr,
-)
-
-
-class IRBuilderVisitor(IRVisitor):
-    """Mypy node visitor that dispatches to node transform implementations.
-
-    This class should have no non-trivial logic.
-
-    This visitor is separated from the rest of code to improve modularity and
-    to avoid import cycles.
-
-    This is based on the visitor pattern
-    (https://en.wikipedia.org/wiki/Visitor_pattern).
-    """
-
-    # This gets passed to all the implementations and contains all the
-    # state and many helpers. The attribute is initialized outside
-    # this class since this class and IRBuilder form a reference loop.
-    builder: IRBuilder
-
-    def visit_mypy_file(self, mypyfile: MypyFile) -> None:
-        assert False, "use transform_mypy_file instead"
-
-    def visit_class_def(self, cdef: ClassDef) -> None:
-        transform_class_def(self.builder, cdef)
-
-    def visit_import(self, node: Import) -> None:
-        transform_import(self.builder, node)
-
-    def visit_import_from(self, node: ImportFrom) -> None:
-        transform_import_from(self.builder, node)
-
-    def visit_import_all(self, node: ImportAll) -> None:
-        transform_import_all(self.builder, node)
-
-    def visit_func_def(self, fdef: FuncDef) -> None:
-        transform_func_def(self.builder, fdef)
-
-    def visit_overloaded_func_def(self, o: OverloadedFuncDef) -> None:
-        transform_overloaded_func_def(self.builder, o)
-
-    def visit_decorator(self, dec: Decorator) -> None:
-        transform_decorator(self.builder, dec)
-
-    def visit_block(self, block: Block) -> None:
-        transform_block(self.builder, block)
-
-    # Statements
-
-    def visit_expression_stmt(self, stmt: ExpressionStmt) -> None:
-        transform_expression_stmt(self.builder, stmt)
-
-    def visit_return_stmt(self, stmt: ReturnStmt) -> None:
-        transform_return_stmt(self.builder, stmt)
-        self.builder.mark_block_unreachable()
-
-    def visit_assignment_stmt(self, stmt: AssignmentStmt) -> None:
-        transform_assignment_stmt(self.builder, stmt)
-
-    def visit_operator_assignment_stmt(self, stmt: OperatorAssignmentStmt) -> None:
-        transform_operator_assignment_stmt(self.builder, stmt)
-
-    def visit_if_stmt(self, stmt: IfStmt) -> None:
-        transform_if_stmt(self.builder, stmt)
-
-    def visit_while_stmt(self, stmt: WhileStmt) -> None:
-        transform_while_stmt(self.builder, stmt)
-
-    def visit_for_stmt(self, stmt: ForStmt) -> None:
-        transform_for_stmt(self.builder, stmt)
-
-    def visit_break_stmt(self, stmt: BreakStmt) -> None:
-        transform_break_stmt(self.builder, stmt)
-        self.builder.mark_block_unreachable()
-
-    def visit_continue_stmt(self, stmt: ContinueStmt) -> None:
-        transform_continue_stmt(self.builder, stmt)
-        self.builder.mark_block_unreachable()
-
-    def visit_raise_stmt(self, stmt: RaiseStmt) -> None:
-        transform_raise_stmt(self.builder, stmt)
-        self.builder.mark_block_unreachable()
-
-    def visit_try_stmt(self, stmt: TryStmt) -> None:
-        transform_try_stmt(self.builder, stmt)
-
-    def visit_with_stmt(self, stmt: WithStmt) -> None:
-        transform_with_stmt(self.builder, stmt)
-
-    def visit_pass_stmt(self, stmt: PassStmt) -> None:
-        pass
-
-    def visit_assert_stmt(self, stmt: AssertStmt) -> None:
-        transform_assert_stmt(self.builder, stmt)
-
-    def visit_del_stmt(self, stmt: DelStmt) -> None:
-        transform_del_stmt(self.builder, stmt)
-
-    def visit_global_decl(self, stmt: GlobalDecl) -> None:
-        # Pure declaration -- no runtime effect
-        pass
-
-    def visit_nonlocal_decl(self, stmt: NonlocalDecl) -> None:
-        # Pure declaration -- no runtime effect
-        pass
-
-    def visit_match_stmt(self, stmt: MatchStmt) -> None:
-        transform_match_stmt(self.builder, stmt)
-
-    # Expressions
-
-    def visit_name_expr(self, expr: NameExpr) -> Value:
-        return transform_name_expr(self.builder, expr)
-
-    def visit_member_expr(self, expr: MemberExpr) -> Value:
-        return transform_member_expr(self.builder, expr)
-
-    def visit_super_expr(self, expr: SuperExpr) -> Value:
-        return transform_super_expr(self.builder, expr)
-
-    def visit_call_expr(self, expr: CallExpr) -> Value:
-        return transform_call_expr(self.builder, expr)
-
-    def visit_unary_expr(self, expr: UnaryExpr) -> Value:
-        return transform_unary_expr(self.builder, expr)
-
-    def visit_op_expr(self, expr: OpExpr) -> Value:
-        return transform_op_expr(self.builder, expr)
-
-    def visit_index_expr(self, expr: IndexExpr) -> Value:
-        return transform_index_expr(self.builder, expr)
-
-    def visit_conditional_expr(self, expr: ConditionalExpr) -> Value:
-        return transform_conditional_expr(self.builder, expr)
-
-    def visit_comparison_expr(self, expr: ComparisonExpr) -> Value:
-        return transform_comparison_expr(self.builder, expr)
-
-    def visit_int_expr(self, expr: IntExpr) -> Value:
-        return transform_int_expr(self.builder, expr)
-
-    def visit_float_expr(self, expr: FloatExpr) -> Value:
-        return transform_float_expr(self.builder, expr)
-
-    def visit_complex_expr(self, expr: ComplexExpr) -> Value:
-        return transform_complex_expr(self.builder, expr)
-
-    def visit_str_expr(self, expr: StrExpr) -> Value:
-        return transform_str_expr(self.builder, expr)
-
-    def visit_bytes_expr(self, expr: BytesExpr) -> Value:
-        return transform_bytes_expr(self.builder, expr)
-
-    def visit_ellipsis(self, expr: EllipsisExpr) -> Value:
-        return transform_ellipsis(self.builder, expr)
-
-    def visit_list_expr(self, expr: ListExpr) -> Value:
-        return transform_list_expr(self.builder, expr)
-
-    def visit_tuple_expr(self, expr: TupleExpr) -> Value:
-        return transform_tuple_expr(self.builder, expr)
-
-    def visit_dict_expr(self, expr: DictExpr) -> Value:
-        return transform_dict_expr(self.builder, expr)
-
-    def visit_set_expr(self, expr: SetExpr) -> Value:
-        return transform_set_expr(self.builder, expr)
-
-    def visit_list_comprehension(self, expr: ListComprehension) -> Value:
-        return transform_list_comprehension(self.builder, expr)
-
-    def visit_set_comprehension(self, expr: SetComprehension) -> Value:
-        return transform_set_comprehension(self.builder, expr)
-
-    def visit_dictionary_comprehension(self, expr: DictionaryComprehension) -> Value:
-        return transform_dictionary_comprehension(self.builder, expr)
-
-    def visit_slice_expr(self, expr: SliceExpr) -> Value:
-        return transform_slice_expr(self.builder, expr)
-
-    def visit_generator_expr(self, expr: GeneratorExpr) -> Value:
-        return transform_generator_expr(self.builder, expr)
-
-    def visit_lambda_expr(self, expr: LambdaExpr) -> Value:
-        return transform_lambda_expr(self.builder, expr)
-
-    def visit_yield_expr(self, expr: YieldExpr) -> Value:
-        return transform_yield_expr(self.builder, expr)
-
-    def visit_yield_from_expr(self, o: YieldFromExpr) -> Value:
-        return transform_yield_from_expr(self.builder, o)
-
-    def visit_await_expr(self, o: AwaitExpr) -> Value:
-        return transform_await_expr(self.builder, o)
-
-    def visit_assignment_expr(self, o: AssignmentExpr) -> Value:
-        return transform_assignment_expr(self.builder, o)
-
-    # Constructs that shouldn't ever show up
-
-    def visit_enum_call_expr(self, o: EnumCallExpr) -> Value:
-        assert False, "can't compile analysis-only expressions"
-
-    def visit__promote_expr(self, o: PromoteExpr) -> Value:
-        assert False, "can't compile analysis-only expressions"
-
-    def visit_namedtuple_expr(self, o: NamedTupleExpr) -> Value:
-        assert False, "can't compile analysis-only expressions"
-
-    def visit_newtype_expr(self, o: NewTypeExpr) -> Value:
-        assert False, "can't compile analysis-only expressions"
-
-    def visit_temp_node(self, o: TempNode) -> Value:
-        assert False, "can't compile analysis-only expressions"
-
-    def visit_type_alias_expr(self, o: TypeAliasExpr) -> Value:
-        assert False, "can't compile analysis-only expressions"
-
-    def visit_type_application(self, o: TypeApplication) -> Value:
-        assert False, "can't compile analysis-only expressions"
-
-    def visit_type_var_expr(self, o: TypeVarExpr) -> Value:
-        assert False, "can't compile analysis-only expressions"
-
-    def visit_paramspec_expr(self, o: ParamSpecExpr) -> Value:
-        assert False, "can't compile analysis-only expressions"
-
-    def visit_type_var_tuple_expr(self, o: TypeVarTupleExpr) -> Value:
-        assert False, "can't compile analysis-only expressions"
-
-    def visit_typeddict_expr(self, o: TypedDictExpr) -> Value:
-        assert False, "can't compile analysis-only expressions"
-
-    def visit_reveal_expr(self, o: RevealExpr) -> Value:
-        assert False, "can't compile analysis-only expressions"
-
-    def visit_var(self, o: Var) -> None:
-        assert False, "can't compile Var; should have been handled already?"
-
-    def visit_cast_expr(self, o: CastExpr) -> Value:
-        assert False, "CastExpr should have been handled in CallExpr"
-
-    def visit_assert_type_expr(self, o: AssertTypeExpr) -> Value:
-        assert False, "AssertTypeExpr should have been handled in CallExpr"
-
-    def visit_star_expr(self, o: StarExpr) -> Value:
-        assert False, "should have been handled in Tuple/List/Set/DictExpr or CallExpr"
-
-    # Helpers
-
-    def bail(self, msg: str, line: int) -> NoReturn:
-        """Reports an error and aborts compilation up until the last accept() call
-
-        (accept() catches the UnsupportedException and keeps on
-        processing. This allows errors to be non-blocking without always
-        needing to write handling for them.
-        """
-        self.builder.error(msg, line)
-        raise UnsupportedException()