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

jaclang/vendor/mypy/semanal_classprop.py

@@ -1,187 +0,0 @@
-"""Calculate some properties of classes.
-
-These happen after semantic analysis and before type checking.
-"""
-
-from __future__ import annotations
-
-from typing import Final
-
-from mypy.errors import Errors
-from mypy.nodes import (
-    IMPLICITLY_ABSTRACT,
-    IS_ABSTRACT,
-    CallExpr,
-    Decorator,
-    FuncDef,
-    Node,
-    OverloadedFuncDef,
-    PromoteExpr,
-    SymbolTable,
-    TypeInfo,
-    Var,
-)
-from mypy.options import Options
-from mypy.types import MYPYC_NATIVE_INT_NAMES, Instance, ProperType
-
-# Hard coded type promotions (shared between all Python versions).
-# These add extra ad-hoc edges to the subtyping relation. For example,
-# int is considered a subtype of float, even though there is no
-# subclass relationship.
-# Note that the bytearray -> bytes promotion is a little unsafe
-# as some functions only accept bytes objects. Here convenience
-# trumps safety.
-TYPE_PROMOTIONS: Final = {
-    "builtins.int": "float",
-    "builtins.float": "complex",
-    "builtins.bytearray": "bytes",
-    "builtins.memoryview": "bytes",
-}
-
-
-def calculate_class_abstract_status(typ: TypeInfo, is_stub_file: bool, errors: Errors) -> None:
-    """Calculate abstract status of a class.
-
-    Set is_abstract of the type to True if the type has an unimplemented
-    abstract attribute.  Also compute a list of abstract attributes.
-    Report error is required ABCMeta metaclass is missing.
-    """
-    typ.is_abstract = False
-    typ.abstract_attributes = []
-    if typ.typeddict_type:
-        return  # TypedDict can't be abstract
-    concrete: set[str] = set()
-    # List of abstract attributes together with their abstract status
-    abstract: list[tuple[str, int]] = []
-    abstract_in_this_class: list[str] = []
-    if typ.is_newtype:
-        # Special case: NewTypes are considered as always non-abstract, so they can be used as:
-        #     Config = NewType('Config', Mapping[str, str])
-        #     default = Config({'cannot': 'modify'})  # OK
-        return
-    for base in typ.mro:
-        for name, symnode in base.names.items():
-            node = symnode.node
-            if isinstance(node, OverloadedFuncDef):
-                # Unwrap an overloaded function definition. We can just
-                # check arbitrarily the first overload item. If the
-                # different items have a different abstract status, there
-                # should be an error reported elsewhere.
-                if node.items:  # can be empty for invalid overloads
-                    func: Node | None = node.items[0]
-                else:
-                    func = None
-            else:
-                func = node
-            if isinstance(func, Decorator):
-                func = func.func
-            if isinstance(func, FuncDef):
-                if (
-                    func.abstract_status in (IS_ABSTRACT, IMPLICITLY_ABSTRACT)
-                    and name not in concrete
-                ):
-                    typ.is_abstract = True
-                    abstract.append((name, func.abstract_status))
-                    if base is typ:
-                        abstract_in_this_class.append(name)
-            elif isinstance(node, Var):
-                if node.is_abstract_var and name not in concrete:
-                    typ.is_abstract = True
-                    abstract.append((name, IS_ABSTRACT))
-                    if base is typ:
-                        abstract_in_this_class.append(name)
-            concrete.add(name)
-    # In stubs, abstract classes need to be explicitly marked because it is too
-    # easy to accidentally leave a concrete class abstract by forgetting to
-    # implement some methods.
-    typ.abstract_attributes = sorted(abstract)
-    if is_stub_file:
-        if typ.declared_metaclass and typ.declared_metaclass.type.has_base("abc.ABCMeta"):
-            return
-        if typ.is_protocol:
-            return
-        if abstract and not abstract_in_this_class:
-
-            def report(message: str, severity: str) -> None:
-                errors.report(typ.line, typ.column, message, severity=severity)
-
-            attrs = ", ".join(f'"{attr}"' for attr, _ in sorted(abstract))
-            report(f"Class {typ.fullname} has abstract attributes {attrs}", "error")
-            report(
-                "If it is meant to be abstract, add 'abc.ABCMeta' as an explicit metaclass", "note"
-            )
-    if typ.is_final and abstract:
-        attrs = ", ".join(f'"{attr}"' for attr, _ in sorted(abstract))
-        errors.report(
-            typ.line, typ.column, f"Final class {typ.fullname} has abstract attributes {attrs}"
-        )
-
-
-def check_protocol_status(info: TypeInfo, errors: Errors) -> None:
-    """Check that all classes in MRO of a protocol are protocols"""
-    if info.is_protocol:
-        for type in info.bases:
-            if not type.type.is_protocol and type.type.fullname != "builtins.object":
-
-                def report(message: str, severity: str) -> None:
-                    errors.report(info.line, info.column, message, severity=severity)
-
-                report("All bases of a protocol must be protocols", "error")
-
-
-def calculate_class_vars(info: TypeInfo) -> None:
-    """Try to infer additional class variables.
-
-    Subclass attribute assignments with no type annotation are assumed
-    to be classvar if overriding a declared classvar from the base
-    class.
-
-    This must happen after the main semantic analysis pass, since
-    this depends on base class bodies having been fully analyzed.
-    """
-    for name, sym in info.names.items():
-        node = sym.node
-        if isinstance(node, Var) and node.info and node.is_inferred and not node.is_classvar:
-            for base in info.mro[1:]:
-                member = base.names.get(name)
-                if member is not None and isinstance(member.node, Var) and member.node.is_classvar:
-                    node.is_classvar = True
-
-
-def add_type_promotion(
-    info: TypeInfo, module_names: SymbolTable, options: Options, builtin_names: SymbolTable
-) -> None:
-    """Setup extra, ad-hoc subtyping relationships between classes (promotion).
-
-    This includes things like 'int' being compatible with 'float'.
-    """
-    defn = info.defn
-    promote_targets: list[ProperType] = []
-    for decorator in defn.decorators:
-        if isinstance(decorator, CallExpr):
-            analyzed = decorator.analyzed
-            if isinstance(analyzed, PromoteExpr):
-                # _promote class decorator (undocumented feature).
-                promote_targets.append(analyzed.type)
-    if not promote_targets:
-        if defn.fullname in TYPE_PROMOTIONS:
-            target_sym = module_names.get(TYPE_PROMOTIONS[defn.fullname])
-            if defn.fullname == "builtins.bytearray" and options.disable_bytearray_promotion:
-                target_sym = None
-            elif defn.fullname == "builtins.memoryview" and options.disable_memoryview_promotion:
-                target_sym = None
-            # With test stubs, the target may not exist.
-            if target_sym:
-                target_info = target_sym.node
-                assert isinstance(target_info, TypeInfo)
-                promote_targets.append(Instance(target_info, []))
-    # Special case the promotions between 'int' and native integer types.
-    # These have promotions going both ways, such as from 'int' to 'i64'
-    # and 'i64' to 'int', for convenience.
-    if defn.fullname in MYPYC_NATIVE_INT_NAMES:
-        int_sym = builtin_names["int"]
-        assert isinstance(int_sym.node, TypeInfo)
-        int_sym.node._promote.append(Instance(defn.info, []))
-        defn.info.alt_promote = Instance(int_sym.node, [])
-    if promote_targets:
-        defn.info._promote.extend(promote_targets)

jaclang/vendor/mypy/semanal_enum.py

@@ -1,253 +0,0 @@
-"""Semantic analysis of call-based Enum definitions.
-
-This is conceptually part of mypy.semanal (semantic analyzer pass 2).
-"""
-
-from __future__ import annotations
-
-from typing import Final, cast
-
-from mypy.nodes import (
-    ARG_NAMED,
-    ARG_POS,
-    MDEF,
-    AssignmentStmt,
-    CallExpr,
-    Context,
-    DictExpr,
-    EnumCallExpr,
-    Expression,
-    ListExpr,
-    MemberExpr,
-    NameExpr,
-    RefExpr,
-    StrExpr,
-    SymbolTableNode,
-    TupleExpr,
-    TypeInfo,
-    Var,
-    is_StrExpr_list,
-)
-from mypy.options import Options
-from mypy.semanal_shared import SemanticAnalyzerInterface
-from mypy.types import ENUM_REMOVED_PROPS, LiteralType, get_proper_type
-
-# Note: 'enum.EnumMeta' is deliberately excluded from this list. Classes that directly use
-# enum.EnumMeta do not necessarily automatically have the 'name' and 'value' attributes.
-ENUM_BASES: Final = frozenset(
-    ("enum.Enum", "enum.IntEnum", "enum.Flag", "enum.IntFlag", "enum.StrEnum")
-)
-ENUM_SPECIAL_PROPS: Final = frozenset(
-    (
-        "name",
-        "value",
-        "_name_",
-        "_value_",
-        *ENUM_REMOVED_PROPS,
-        # Also attributes from `object`:
-        "__module__",
-        "__annotations__",
-        "__doc__",
-        "__slots__",
-        "__dict__",
-    )
-)
-
-
-class EnumCallAnalyzer:
-    def __init__(self, options: Options, api: SemanticAnalyzerInterface) -> None:
-        self.options = options
-        self.api = api
-
-    def process_enum_call(self, s: AssignmentStmt, is_func_scope: bool) -> bool:
-        """Check if s defines an Enum; if yes, store the definition in symbol table.
-
-        Return True if this looks like an Enum definition (but maybe with errors),
-        otherwise return False.
-        """
-        if len(s.lvalues) != 1 or not isinstance(s.lvalues[0], (NameExpr, MemberExpr)):
-            return False
-        lvalue = s.lvalues[0]
-        name = lvalue.name
-        enum_call = self.check_enum_call(s.rvalue, name, is_func_scope)
-        if enum_call is None:
-            return False
-        if isinstance(lvalue, MemberExpr):
-            self.fail("Enum type as attribute is not supported", lvalue)
-            return False
-        # Yes, it's a valid Enum definition. Add it to the symbol table.
-        self.api.add_symbol(name, enum_call, s)
-        return True
-
-    def check_enum_call(
-        self, node: Expression, var_name: str, is_func_scope: bool
-    ) -> TypeInfo | None:
-        """Check if a call defines an Enum.
-
-        Example:
-
-          A = enum.Enum('A', 'foo bar')
-
-        is equivalent to:
-
-          class A(enum.Enum):
-              foo = 1
-              bar = 2
-        """
-        if not isinstance(node, CallExpr):
-            return None
-        call = node
-        callee = call.callee
-        if not isinstance(callee, RefExpr):
-            return None
-        fullname = callee.fullname
-        if fullname not in ENUM_BASES:
-            return None
-        items, values, ok = self.parse_enum_call_args(call, fullname.split(".")[-1])
-        if not ok:
-            # Error. Construct dummy return value.
-            name = var_name
-            if is_func_scope:
-                name += "@" + str(call.line)
-            info = self.build_enum_call_typeinfo(name, [], fullname, node.line)
-        else:
-            name = cast(StrExpr, call.args[0]).value
-            if name != var_name or is_func_scope:
-                # Give it a unique name derived from the line number.
-                name += "@" + str(call.line)
-            info = self.build_enum_call_typeinfo(name, items, fullname, call.line)
-        # Store generated TypeInfo under both names, see semanal_namedtuple for more details.
-        if name != var_name or is_func_scope:
-            self.api.add_symbol_skip_local(name, info)
-        call.analyzed = EnumCallExpr(info, items, values)
-        call.analyzed.set_line(call)
-        info.line = node.line
-        return info
-
-    def build_enum_call_typeinfo(
-        self, name: str, items: list[str], fullname: str, line: int
-    ) -> TypeInfo:
-        base = self.api.named_type_or_none(fullname)
-        assert base is not None
-        info = self.api.basic_new_typeinfo(name, base, line)
-        info.metaclass_type = info.calculate_metaclass_type()
-        info.is_enum = True
-        for item in items:
-            var = Var(item)
-            var.info = info
-            var.is_property = True
-            var._fullname = f"{info.fullname}.{item}"
-            info.names[item] = SymbolTableNode(MDEF, var)
-        return info
-
-    def parse_enum_call_args(
-        self, call: CallExpr, class_name: str
-    ) -> tuple[list[str], list[Expression | None], bool]:
-        """Parse arguments of an Enum call.
-
-        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):
-            return self.fail_enum_call_arg(f"Unexpected arguments to {class_name}()", call)
-        if len(args) < 2:
-            return self.fail_enum_call_arg(f"Too few arguments for {class_name}()", call)
-        if len(args) > 6:
-            return self.fail_enum_call_arg(f"Too many arguments for {class_name}()", call)
-        valid_name = [None, "value", "names", "module", "qualname", "type", "start"]
-        for arg_name in call.arg_names:
-            if arg_name not in valid_name:
-                self.fail_enum_call_arg(f'Unexpected keyword argument "{arg_name}"', call)
-        value, names = None, None
-        for arg_name, arg in zip(call.arg_names, args):
-            if arg_name == "value":
-                value = arg
-            if arg_name == "names":
-                names = arg
-        if value is None:
-            value = args[0]
-        if names is None:
-            names = args[1]
-        if not isinstance(value, StrExpr):
-            return self.fail_enum_call_arg(
-                f"{class_name}() expects a string literal as the first argument", call
-            )
-        items = []
-        values: list[Expression | None] = []
-        if isinstance(names, StrExpr):
-            fields = names.value
-            for field in fields.replace(",", " ").split():
-                items.append(field)
-        elif isinstance(names, (TupleExpr, ListExpr)):
-            seq_items = names.items
-            if is_StrExpr_list(seq_items):
-                items = [seq_item.value for seq_item in seq_items]
-            elif all(
-                isinstance(seq_item, (TupleExpr, ListExpr))
-                and len(seq_item.items) == 2
-                and isinstance(seq_item.items[0], StrExpr)
-                for seq_item in seq_items
-            ):
-                for seq_item in seq_items:
-                    assert isinstance(seq_item, (TupleExpr, ListExpr))
-                    name, value = seq_item.items
-                    assert isinstance(name, StrExpr)
-                    items.append(name.value)
-                    values.append(value)
-            else:
-                return self.fail_enum_call_arg(
-                    "%s() with tuple or list expects strings or (name, value) pairs" % class_name,
-                    call,
-                )
-        elif isinstance(names, DictExpr):
-            for key, value in names.items:
-                if not isinstance(key, StrExpr):
-                    return self.fail_enum_call_arg(
-                        f"{class_name}() with dict literal requires string literals", call
-                    )
-                items.append(key.value)
-                values.append(value)
-        elif isinstance(args[1], RefExpr) and isinstance(args[1].node, Var):
-            proper_type = get_proper_type(args[1].node.type)
-            if (
-                proper_type is not None
-                and isinstance(proper_type, LiteralType)
-                and isinstance(proper_type.value, str)
-            ):
-                fields = proper_type.value
-                for field in fields.replace(",", " ").split():
-                    items.append(field)
-            elif args[1].node.is_final and isinstance(args[1].node.final_value, str):
-                fields = args[1].node.final_value
-                for field in fields.replace(",", " ").split():
-                    items.append(field)
-            else:
-                return self.fail_enum_call_arg(
-                    "Second argument of %s() must be string, tuple, list or dict literal for mypy to determine Enum members"
-                    % class_name,
-                    call,
-                )
-        else:
-            # TODO: Allow dict(x=1, y=2) as a substitute for {'x': 1, 'y': 2}?
-            return self.fail_enum_call_arg(
-                "Second argument of %s() must be string, tuple, list or dict literal for mypy to determine Enum members"
-                % class_name,
-                call,
-            )
-        if not items:
-            return self.fail_enum_call_arg(f"{class_name}() needs at least one item", call)
-        if not values:
-            values = [None] * len(items)
-        assert len(items) == len(values)
-        return items, values, True
-
-    def fail_enum_call_arg(
-        self, message: str, context: Context
-    ) -> tuple[list[str], list[Expression | None], bool]:
-        self.fail(message, context)
-        return [], [], False
-
-    # Helpers
-
-    def fail(self, msg: str, ctx: Context) -> None:
-        self.api.fail(msg, ctx)

jaclang/vendor/mypy/semanal_infer.py

@@ -1,128 +0,0 @@
-"""Simple type inference for decorated functions during semantic analysis."""
-
-from __future__ import annotations
-
-from mypy.nodes import ARG_POS, CallExpr, Decorator, Expression, FuncDef, RefExpr, Var
-from mypy.semanal_shared import SemanticAnalyzerInterface
-from mypy.typeops import function_type
-from mypy.types import (
-    AnyType,
-    CallableType,
-    ProperType,
-    Type,
-    TypeOfAny,
-    TypeVarType,
-    get_proper_type,
-)
-from mypy.typevars import has_no_typevars
-
-
-def infer_decorator_signature_if_simple(
-    dec: Decorator, analyzer: SemanticAnalyzerInterface
-) -> None:
-    """Try to infer the type of the decorated function.
-
-    This lets us resolve additional references to decorated functions
-    during type checking. Otherwise the type might not be available
-    when we need it, since module top levels can't be deferred.
-
-    This basically uses a simple special-purpose type inference
-    engine just for decorators.
-    """
-    if dec.var.is_property:
-        # Decorators are expected to have a callable type (it's a little odd).
-        if dec.func.type is None:
-            dec.var.type = CallableType(
-                [AnyType(TypeOfAny.special_form)],
-                [ARG_POS],
-                [None],
-                AnyType(TypeOfAny.special_form),
-                analyzer.named_type("builtins.function"),
-                name=dec.var.name,
-            )
-        elif isinstance(dec.func.type, CallableType):
-            dec.var.type = dec.func.type
-        return
-    decorator_preserves_type = True
-    for expr in dec.decorators:
-        preserve_type = False
-        if isinstance(expr, RefExpr) and isinstance(expr.node, FuncDef):
-            if expr.node.type and is_identity_signature(expr.node.type):
-                preserve_type = True
-        if not preserve_type:
-            decorator_preserves_type = False
-            break
-    if decorator_preserves_type:
-        # No non-identity decorators left. We can trivially infer the type
-        # of the function here.
-        dec.var.type = function_type(dec.func, analyzer.named_type("builtins.function"))
-    if dec.decorators:
-        return_type = calculate_return_type(dec.decorators[0])
-        if return_type and isinstance(return_type, AnyType):
-            # The outermost decorator will return Any so we know the type of the
-            # decorated function.
-            dec.var.type = AnyType(TypeOfAny.from_another_any, source_any=return_type)
-        sig = find_fixed_callable_return(dec.decorators[0])
-        if sig:
-            # The outermost decorator always returns the same kind of function,
-            # so we know that this is the type of the decorated function.
-            orig_sig = function_type(dec.func, analyzer.named_type("builtins.function"))
-            sig.name = orig_sig.items[0].name
-            dec.var.type = sig
-
-
-def is_identity_signature(sig: Type) -> bool:
-    """Is type a callable of form T -> T (where T is a type variable)?"""
-    sig = get_proper_type(sig)
-    if isinstance(sig, CallableType) and sig.arg_kinds == [ARG_POS]:
-        if isinstance(sig.arg_types[0], TypeVarType) and isinstance(sig.ret_type, TypeVarType):
-            return sig.arg_types[0].id == sig.ret_type.id
-    return False
-
-
-def calculate_return_type(expr: Expression) -> ProperType | None:
-    """Return the return type if we can calculate it.
-
-    This only uses information available during semantic analysis so this
-    will sometimes return None because of insufficient information (as
-    type inference hasn't run yet).
-    """
-    if isinstance(expr, RefExpr):
-        if isinstance(expr.node, FuncDef):
-            typ = expr.node.type
-            if typ is None:
-                # No signature -> default to Any.
-                return AnyType(TypeOfAny.unannotated)
-            # Explicit Any return?
-            if isinstance(typ, CallableType):
-                return get_proper_type(typ.ret_type)
-            return None
-        elif isinstance(expr.node, Var):
-            return get_proper_type(expr.node.type)
-    elif isinstance(expr, CallExpr):
-        return calculate_return_type(expr.callee)
-    return None
-
-
-def find_fixed_callable_return(expr: Expression) -> CallableType | None:
-    """Return the return type, if expression refers to a callable that returns a callable.
-
-    But only do this if the return type has no type variables. Return None otherwise.
-    This approximates things a lot as this is supposed to be called before type checking
-    when full type information is not available yet.
-    """
-    if isinstance(expr, RefExpr):
-        if isinstance(expr.node, FuncDef):
-            typ = expr.node.type
-            if typ:
-                if isinstance(typ, CallableType) and has_no_typevars(typ.ret_type):
-                    ret_type = get_proper_type(typ.ret_type)
-                    if isinstance(ret_type, CallableType):
-                        return ret_type
-    elif isinstance(expr, CallExpr):
-        t = find_fixed_callable_return(expr.callee)
-        if t:
-            ret_type = get_proper_type(t.ret_type)
-            if isinstance(ret_type, CallableType):
-                return ret_type
-    return None