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

jaclang/vendor/mypy/memprofile.py

@@ -1,121 +0,0 @@
-"""Utility for dumping memory usage stats.
-
-This is tailored to mypy and knows (a little) about which list objects are
-owned by particular AST nodes, etc.
-"""
-
-from __future__ import annotations
-
-import gc
-import sys
-from collections import defaultdict
-from typing import Dict, Iterable, cast
-
-from mypy.nodes import FakeInfo, Node
-from mypy.types import Type
-from mypy.util import get_class_descriptors
-
-
-def collect_memory_stats() -> tuple[dict[str, int], dict[str, int]]:
-    """Return stats about memory use.
-
-    Return a tuple with these items:
-      - Dict from object kind to number of instances of that kind
-      - Dict from object kind to total bytes used by all instances of that kind
-    """
-    objs = gc.get_objects()
-    find_recursive_objects(objs)
-
-    inferred = {}
-    for obj in objs:
-        if type(obj) is FakeInfo:
-            # Processing these would cause a crash.
-            continue
-        n = type(obj).__name__
-        if hasattr(obj, "__dict__"):
-            # Keep track of which class a particular __dict__ is associated with.
-            inferred[id(obj.__dict__)] = f"{n} (__dict__)"
-        if isinstance(obj, (Node, Type)):  # type: ignore[misc]
-            if hasattr(obj, "__dict__"):
-                for x in obj.__dict__.values():
-                    if isinstance(x, list):
-                        # Keep track of which node a list is associated with.
-                        inferred[id(x)] = f"{n} (list)"
-                    if isinstance(x, tuple):
-                        # Keep track of which node a list is associated with.
-                        inferred[id(x)] = f"{n} (tuple)"
-
-            for k in get_class_descriptors(type(obj)):
-                x = getattr(obj, k, None)
-                if isinstance(x, list):
-                    inferred[id(x)] = f"{n} (list)"
-                if isinstance(x, tuple):
-                    inferred[id(x)] = f"{n} (tuple)"
-
-    freqs: dict[str, int] = {}
-    memuse: dict[str, int] = {}
-    for obj in objs:
-        if id(obj) in inferred:
-            name = inferred[id(obj)]
-        else:
-            name = type(obj).__name__
-        freqs[name] = freqs.get(name, 0) + 1
-        memuse[name] = memuse.get(name, 0) + sys.getsizeof(obj)
-
-    return freqs, memuse
-
-
-def print_memory_profile(run_gc: bool = True) -> None:
-    if not sys.platform.startswith("win"):
-        import resource
-
-        system_memuse = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
-    else:
-        system_memuse = -1  # TODO: Support this on Windows
-    if run_gc:
-        gc.collect()
-    freqs, memuse = collect_memory_stats()
-    print("%7s  %7s  %7s  %s" % ("Freq", "Size(k)", "AvgSize", "Type"))
-    print("-------------------------------------------")
-    totalmem = 0
-    i = 0
-    for n, mem in sorted(memuse.items(), key=lambda x: -x[1]):
-        f = freqs[n]
-        if i < 50:
-            print("%7d  %7d  %7.0f  %s" % (f, mem // 1024, mem / f, n))
-        i += 1
-        totalmem += mem
-    print()
-    print("Mem usage RSS   ", system_memuse // 1024)
-    print("Total reachable ", totalmem // 1024)
-
-
-def find_recursive_objects(objs: list[object]) -> None:
-    """Find additional objects referenced by objs and append them to objs.
-
-    We use this since gc.get_objects() does not return objects without pointers
-    in them such as strings.
-    """
-    seen = {id(o) for o in objs}
-
-    def visit(o: object) -> None:
-        if id(o) not in seen:
-            objs.append(o)
-            seen.add(id(o))
-
-    for obj in objs.copy():
-        if type(obj) is FakeInfo:
-            # Processing these would cause a crash.
-            continue
-        if type(obj) in (dict, defaultdict):
-            for key, val in cast(Dict[object, object], obj).items():
-                visit(key)
-                visit(val)
-        if type(obj) in (list, tuple, set):
-            for x in cast(Iterable[object], obj):
-                visit(x)
-        if hasattr(obj, "__slots__"):
-            for base in type.mro(type(obj)):
-                for slot in getattr(base, "__slots__", ()):
-                    if hasattr(obj, slot):
-                        visit(getattr(obj, slot))

jaclang/vendor/mypy/message_registry.py

@@ -1,329 +0,0 @@
-"""Message constants for generating error messages during type checking.
-
-Literal messages should be defined as constants in this module so they won't get out of sync
-if used in more than one place, and so that they can be easily introspected. These messages are
-ultimately consumed by messages.MessageBuilder.fail(). For more non-trivial message generation,
-add a method to MessageBuilder and call this instead.
-"""
-
-from __future__ import annotations
-
-from typing import Final, NamedTuple
-
-from mypy import errorcodes as codes
-
-
-class ErrorMessage(NamedTuple):
-    value: str
-    code: codes.ErrorCode | None = None
-
-    def format(self, *args: object, **kwargs: object) -> ErrorMessage:
-        return ErrorMessage(self.value.format(*args, **kwargs), code=self.code)
-
-    def with_additional_msg(self, info: str) -> ErrorMessage:
-        return ErrorMessage(self.value + info, code=self.code)
-
-
-# Invalid types
-INVALID_TYPE_RAW_ENUM_VALUE: Final = ErrorMessage(
-    "Invalid type: try using Literal[{}.{}] instead?", codes.VALID_TYPE
-)
-
-# Type checker error message constants
-NO_RETURN_VALUE_EXPECTED: Final = ErrorMessage("No return value expected", codes.RETURN_VALUE)
-MISSING_RETURN_STATEMENT: Final = ErrorMessage("Missing return statement", codes.RETURN)
-EMPTY_BODY_ABSTRACT: Final = ErrorMessage(
-    "If the method is meant to be abstract, use @abc.abstractmethod", codes.EMPTY_BODY
-)
-INVALID_IMPLICIT_RETURN: Final = ErrorMessage("Implicit return in function which does not return")
-INCOMPATIBLE_RETURN_VALUE_TYPE: Final = ErrorMessage(
-    "Incompatible return value type", codes.RETURN_VALUE
-)
-RETURN_VALUE_EXPECTED: Final = ErrorMessage("Return value expected", codes.RETURN_VALUE)
-NO_RETURN_EXPECTED: Final = ErrorMessage("Return statement in function which does not return")
-INVALID_EXCEPTION: Final = ErrorMessage("Exception must be derived from BaseException")
-INVALID_EXCEPTION_TYPE: Final = ErrorMessage(
-    "Exception type must be derived from BaseException (or be a tuple of exception classes)"
-)
-INVALID_EXCEPTION_GROUP: Final = ErrorMessage(
-    "Exception type in except* cannot derive from BaseExceptionGroup"
-)
-RETURN_IN_ASYNC_GENERATOR: Final = ErrorMessage(
-    '"return" with value in async generator is not allowed'
-)
-INVALID_RETURN_TYPE_FOR_GENERATOR: Final = ErrorMessage(
-    'The return type of a generator function should be "Generator" or one of its supertypes'
-)
-INVALID_RETURN_TYPE_FOR_ASYNC_GENERATOR: Final = ErrorMessage(
-    'The return type of an async generator function should be "AsyncGenerator" or one of its '
-    "supertypes"
-)
-YIELD_VALUE_EXPECTED: Final = ErrorMessage("Yield value expected")
-INCOMPATIBLE_TYPES: Final = ErrorMessage("Incompatible types")
-INCOMPATIBLE_TYPES_IN_ASSIGNMENT: Final = ErrorMessage(
-    "Incompatible types in assignment", code=codes.ASSIGNMENT
-)
-COVARIANT_OVERRIDE_OF_MUTABLE_ATTRIBUTE: Final = ErrorMessage(
-    "Covariant override of a mutable attribute", code=codes.MUTABLE_OVERRIDE
-)
-INCOMPATIBLE_TYPES_IN_AWAIT: Final = ErrorMessage('Incompatible types in "await"')
-INCOMPATIBLE_REDEFINITION: Final = ErrorMessage("Incompatible redefinition")
-INCOMPATIBLE_TYPES_IN_ASYNC_WITH_AENTER: Final = (
-    'Incompatible types in "async with" for "__aenter__"'
-)
-INCOMPATIBLE_TYPES_IN_ASYNC_WITH_AEXIT: Final = (
-    'Incompatible types in "async with" for "__aexit__"'
-)
-INCOMPATIBLE_TYPES_IN_ASYNC_FOR: Final = 'Incompatible types in "async for"'
-INVALID_TYPE_FOR_SLOTS: Final = 'Invalid type for "__slots__"'
-
-ASYNC_FOR_OUTSIDE_COROUTINE: Final = '"async for" outside async function'
-ASYNC_WITH_OUTSIDE_COROUTINE: Final = '"async with" outside async function'
-
-INCOMPATIBLE_TYPES_IN_YIELD: Final = ErrorMessage('Incompatible types in "yield"')
-INCOMPATIBLE_TYPES_IN_YIELD_FROM: Final = ErrorMessage('Incompatible types in "yield from"')
-INCOMPATIBLE_TYPES_IN_STR_INTERPOLATION: Final = "Incompatible types in string interpolation"
-INCOMPATIBLE_TYPES_IN_CAPTURE: Final = ErrorMessage("Incompatible types in capture pattern")
-MUST_HAVE_NONE_RETURN_TYPE: Final = ErrorMessage('The return type of "{}" must be None')
-TUPLE_INDEX_OUT_OF_RANGE: Final = ErrorMessage("Tuple index out of range")
-AMBIGUOUS_SLICE_OF_VARIADIC_TUPLE: Final = ErrorMessage("Ambiguous slice of a variadic tuple")
-TOO_MANY_TARGETS_FOR_VARIADIC_UNPACK: Final = ErrorMessage(
-    "Too many assignment targets for variadic unpack"
-)
-INVALID_SLICE_INDEX: Final = ErrorMessage("Slice index must be an integer, SupportsIndex or None")
-CANNOT_INFER_LAMBDA_TYPE: Final = ErrorMessage("Cannot infer type of lambda")
-CANNOT_ACCESS_INIT: Final = (
-    'Accessing "__init__" on an instance is unsound, since instance.__init__ could be from'
-    " an incompatible subclass"
-)
-NON_INSTANCE_NEW_TYPE: Final = ErrorMessage('"__new__" must return a class instance (got {})')
-INVALID_NEW_TYPE: Final = ErrorMessage('Incompatible return type for "__new__"')
-BAD_CONSTRUCTOR_TYPE: Final = ErrorMessage("Unsupported decorated constructor type")
-CANNOT_ASSIGN_TO_METHOD: Final = "Cannot assign to a method"
-CANNOT_ASSIGN_TO_TYPE: Final = "Cannot assign to a type"
-INCONSISTENT_ABSTRACT_OVERLOAD: Final = ErrorMessage(
-    "Overloaded method has both abstract and non-abstract variants"
-)
-MULTIPLE_OVERLOADS_REQUIRED: Final = ErrorMessage("Single overload definition, multiple required")
-READ_ONLY_PROPERTY_OVERRIDES_READ_WRITE: Final = ErrorMessage(
-    "Read-only property cannot override read-write property"
-)
-FORMAT_REQUIRES_MAPPING: Final = "Format requires a mapping"
-RETURN_TYPE_CANNOT_BE_CONTRAVARIANT: Final = ErrorMessage(
-    "Cannot use a contravariant type variable as return type"
-)
-FUNCTION_PARAMETER_CANNOT_BE_COVARIANT: Final = ErrorMessage(
-    "Cannot use a covariant type variable as a parameter"
-)
-INCOMPATIBLE_IMPORT_OF: Final = ErrorMessage('Incompatible import of "{}"', code=codes.ASSIGNMENT)
-FUNCTION_TYPE_EXPECTED: Final = ErrorMessage(
-    "Function is missing a type annotation", codes.NO_UNTYPED_DEF
-)
-ONLY_CLASS_APPLICATION: Final = ErrorMessage(
-    "Type application is only supported for generic classes"
-)
-RETURN_TYPE_EXPECTED: Final = ErrorMessage(
-    "Function is missing a return type annotation", codes.NO_UNTYPED_DEF
-)
-ARGUMENT_TYPE_EXPECTED: Final = ErrorMessage(
-    "Function is missing a type annotation for one or more arguments", codes.NO_UNTYPED_DEF
-)
-KEYWORD_ARGUMENT_REQUIRES_STR_KEY_TYPE: Final = ErrorMessage(
-    'Keyword argument only valid with "str" key type in call to "dict"'
-)
-ALL_MUST_BE_SEQ_STR: Final = ErrorMessage("Type of __all__ must be {}, not {}")
-INVALID_TYPEDDICT_ARGS: Final = ErrorMessage(
-    "Expected keyword arguments, {...}, or dict(...) in TypedDict constructor"
-)
-TYPEDDICT_KEY_MUST_BE_STRING_LITERAL: Final = ErrorMessage(
-    "Expected TypedDict key to be string literal"
-)
-MALFORMED_ASSERT: Final = ErrorMessage("Assertion is always true, perhaps remove parentheses?")
-DUPLICATE_TYPE_SIGNATURES: Final = ErrorMessage("Function has duplicate type signatures")
-DESCRIPTOR_SET_NOT_CALLABLE: Final = ErrorMessage("{}.__set__ is not callable")
-DESCRIPTOR_GET_NOT_CALLABLE: Final = "{}.__get__ is not callable"
-MODULE_LEVEL_GETATTRIBUTE: Final = ErrorMessage(
-    "__getattribute__ is not valid at the module level"
-)
-CLASS_VAR_CONFLICTS_SLOTS: Final = '"{}" in __slots__ conflicts with class variable access'
-NAME_NOT_IN_SLOTS: Final = ErrorMessage(
-    'Trying to assign name "{}" that is not in "__slots__" of type "{}"'
-)
-TYPE_ALWAYS_TRUE: Final = ErrorMessage(
-    "{} which does not implement __bool__ or __len__ "
-    "so it could always be true in boolean context",
-    code=codes.TRUTHY_BOOL,
-)
-TYPE_ALWAYS_TRUE_UNIONTYPE: Final = ErrorMessage(
-    "{} of which no members implement __bool__ or __len__ "
-    "so it could always be true in boolean context",
-    code=codes.TRUTHY_BOOL,
-)
-FUNCTION_ALWAYS_TRUE: Final = ErrorMessage(
-    "Function {} could always be true in boolean context", code=codes.TRUTHY_FUNCTION
-)
-ITERABLE_ALWAYS_TRUE: Final = ErrorMessage(
-    "{} which can always be true in boolean context. Consider using {} instead.",
-    code=codes.TRUTHY_ITERABLE,
-)
-NOT_CALLABLE: Final = "{} not callable"
-TYPE_MUST_BE_USED: Final = "Value of type {} must be used"
-
-# Generic
-GENERIC_INSTANCE_VAR_CLASS_ACCESS: Final = (
-    "Access to generic instance variables via class is ambiguous"
-)
-GENERIC_CLASS_VAR_ACCESS: Final = "Access to generic class variables is ambiguous"
-BARE_GENERIC: Final = "Missing type parameters for generic type {}"
-IMPLICIT_GENERIC_ANY_BUILTIN: Final = (
-    'Implicit generic "Any". Use "{}" and specify generic parameters'
-)
-INVALID_UNPACK: Final = "{} cannot be unpacked (must be tuple or TypeVarTuple)"
-INVALID_UNPACK_POSITION: Final = "Unpack is only valid in a variadic position"
-
-# TypeVar
-INCOMPATIBLE_TYPEVAR_VALUE: Final = 'Value of type variable "{}" of {} cannot be {}'
-CANNOT_USE_TYPEVAR_AS_EXPRESSION: Final = 'Type variable "{}.{}" cannot be used as an expression'
-INVALID_TYPEVAR_AS_TYPEARG: Final = 'Type variable "{}" not valid as type argument value for "{}"'
-INVALID_TYPEVAR_ARG_BOUND: Final = 'Type argument {} of "{}" must be a subtype of {}'
-INVALID_TYPEVAR_ARG_VALUE: Final = 'Invalid type argument value for "{}"'
-TYPEVAR_VARIANCE_DEF: Final = 'TypeVar "{}" may only be a literal bool'
-TYPEVAR_ARG_MUST_BE_TYPE: Final = '{} "{}" must be a type'
-TYPEVAR_UNEXPECTED_ARGUMENT: Final = 'Unexpected argument to "TypeVar()"'
-UNBOUND_TYPEVAR: Final = (
-    "A function returning TypeVar should receive at least "
-    "one argument containing the same TypeVar"
-)
-
-# Super
-TOO_MANY_ARGS_FOR_SUPER: Final = ErrorMessage('Too many arguments for "super"')
-SUPER_WITH_SINGLE_ARG_NOT_SUPPORTED: Final = ErrorMessage(
-    '"super" with a single argument not supported'
-)
-UNSUPPORTED_ARG_1_FOR_SUPER: Final = ErrorMessage('Unsupported argument 1 for "super"')
-UNSUPPORTED_ARG_2_FOR_SUPER: Final = ErrorMessage('Unsupported argument 2 for "super"')
-SUPER_VARARGS_NOT_SUPPORTED: Final = ErrorMessage('Varargs not supported with "super"')
-SUPER_POSITIONAL_ARGS_REQUIRED: Final = ErrorMessage('"super" only accepts positional arguments')
-SUPER_ARG_2_NOT_INSTANCE_OF_ARG_1: Final = ErrorMessage(
-    'Argument 2 for "super" not an instance of argument 1'
-)
-TARGET_CLASS_HAS_NO_BASE_CLASS: Final = ErrorMessage("Target class has no base class")
-SUPER_OUTSIDE_OF_METHOD_NOT_SUPPORTED: Final = ErrorMessage(
-    '"super()" outside of a method is not supported'
-)
-SUPER_ENCLOSING_POSITIONAL_ARGS_REQUIRED: Final = ErrorMessage(
-    '"super()" requires one or two positional arguments in enclosing function'
-)
-
-# Self-type
-MISSING_OR_INVALID_SELF_TYPE: Final = ErrorMessage(
-    "Self argument missing for a non-static method (or an invalid type for self)"
-)
-ERASED_SELF_TYPE_NOT_SUPERTYPE: Final = ErrorMessage(
-    'The erased type of self "{}" is not a supertype of its class "{}"'
-)
-
-# Final
-CANNOT_INHERIT_FROM_FINAL: Final = ErrorMessage('Cannot inherit from final class "{}"')
-DEPENDENT_FINAL_IN_CLASS_BODY: Final = ErrorMessage(
-    "Final name declared in class body cannot depend on type variables"
-)
-CANNOT_ACCESS_FINAL_INSTANCE_ATTR: Final = (
-    'Cannot access final instance attribute "{}" on class object'
-)
-CANNOT_MAKE_DELETABLE_FINAL: Final = ErrorMessage("Deletable attribute cannot be final")
-
-# Enum
-ENUM_MEMBERS_ATTR_WILL_BE_OVERRIDEN: Final = ErrorMessage(
-    'Assigned "__members__" will be overridden by "Enum" internally'
-)
-
-# ClassVar
-CANNOT_OVERRIDE_INSTANCE_VAR: Final = ErrorMessage(
-    'Cannot override instance variable (previously declared on base class "{}") with class '
-    "variable"
-)
-CANNOT_OVERRIDE_CLASS_VAR: Final = ErrorMessage(
-    'Cannot override class variable (previously declared on base class "{}") with instance '
-    "variable"
-)
-CLASS_VAR_WITH_TYPEVARS: Final = "ClassVar cannot contain type variables"
-CLASS_VAR_WITH_GENERIC_SELF: Final = "ClassVar cannot contain Self type in generic classes"
-CLASS_VAR_OUTSIDE_OF_CLASS: Final = "ClassVar can only be used for assignments in class body"
-
-# Protocol
-RUNTIME_PROTOCOL_EXPECTED: Final = ErrorMessage(
-    "Only @runtime_checkable protocols can be used with instance and class checks"
-)
-CANNOT_INSTANTIATE_PROTOCOL: Final = ErrorMessage('Cannot instantiate protocol class "{}"')
-TOO_MANY_UNION_COMBINATIONS: Final = ErrorMessage(
-    "Not all union combinations were tried because there are too many unions"
-)
-
-CONTIGUOUS_ITERABLE_EXPECTED: Final = ErrorMessage("Contiguous iterable with same type expected")
-ITERABLE_TYPE_EXPECTED: Final = ErrorMessage("Invalid type '{}' for *expr (iterable expected)")
-TYPE_GUARD_POS_ARG_REQUIRED: Final = ErrorMessage("Type {} requires positional argument")
-
-# Match Statement
-MISSING_MATCH_ARGS: Final = 'Class "{}" doesn\'t define "__match_args__"'
-OR_PATTERN_ALTERNATIVE_NAMES: Final = "Alternative patterns bind different names"
-CLASS_PATTERN_GENERIC_TYPE_ALIAS: Final = (
-    "Class pattern class must not be a type alias with type parameters"
-)
-CLASS_PATTERN_TYPE_REQUIRED: Final = 'Expected type in class pattern; found "{}"'
-CLASS_PATTERN_TOO_MANY_POSITIONAL_ARGS: Final = "Too many positional patterns for class pattern"
-CLASS_PATTERN_KEYWORD_MATCHES_POSITIONAL: Final = (
-    'Keyword "{}" already matches a positional pattern'
-)
-CLASS_PATTERN_DUPLICATE_KEYWORD_PATTERN: Final = 'Duplicate keyword pattern "{}"'
-CLASS_PATTERN_UNKNOWN_KEYWORD: Final = 'Class "{}" has no attribute "{}"'
-CLASS_PATTERN_CLASS_OR_STATIC_METHOD: Final = "Cannot have both classmethod and staticmethod"
-MULTIPLE_ASSIGNMENTS_IN_PATTERN: Final = 'Multiple assignments to name "{}" in pattern'
-CANNOT_MODIFY_MATCH_ARGS: Final = 'Cannot assign to "__match_args__"'
-
-DATACLASS_FIELD_ALIAS_MUST_BE_LITERAL: Final = (
-    '"alias" argument to dataclass field must be a string literal'
-)
-DATACLASS_POST_INIT_MUST_BE_A_FUNCTION: Final = '"__post_init__" method must be an instance method'
-
-# fastparse
-FAILED_TO_MERGE_OVERLOADS: Final = ErrorMessage(
-    "Condition can't be inferred, unable to merge overloads"
-)
-TYPE_IGNORE_WITH_ERRCODE_ON_MODULE: Final = ErrorMessage(
-    "type ignore with error code is not supported for modules; "
-    'use `# mypy: disable-error-code="{}"`',
-    codes.SYNTAX,
-)
-INVALID_TYPE_IGNORE: Final = ErrorMessage('Invalid "type: ignore" comment', codes.SYNTAX)
-TYPE_COMMENT_SYNTAX_ERROR_VALUE: Final = ErrorMessage(
-    'Syntax error in type comment "{}"', codes.SYNTAX
-)
-ELLIPSIS_WITH_OTHER_TYPEARGS: Final = ErrorMessage(
-    "Ellipses cannot accompany other argument types in function type signature", codes.SYNTAX
-)
-TYPE_SIGNATURE_TOO_MANY_ARGS: Final = ErrorMessage(
-    "Type signature has too many arguments", codes.SYNTAX
-)
-TYPE_SIGNATURE_TOO_FEW_ARGS: Final = ErrorMessage(
-    "Type signature has too few arguments", codes.SYNTAX
-)
-ARG_CONSTRUCTOR_NAME_EXPECTED: Final = ErrorMessage("Expected arg constructor name", codes.SYNTAX)
-ARG_CONSTRUCTOR_TOO_MANY_ARGS: Final = ErrorMessage(
-    "Too many arguments for argument constructor", codes.SYNTAX
-)
-MULTIPLE_VALUES_FOR_NAME_KWARG: Final = ErrorMessage(
-    '"{}" gets multiple values for keyword argument "name"', codes.SYNTAX
-)
-MULTIPLE_VALUES_FOR_TYPE_KWARG: Final = ErrorMessage(
-    '"{}" gets multiple values for keyword argument "type"', codes.SYNTAX
-)
-ARG_CONSTRUCTOR_UNEXPECTED_ARG: Final = ErrorMessage(
-    'Unexpected argument "{}" for argument constructor', codes.SYNTAX
-)
-ARG_NAME_EXPECTED_STRING_LITERAL: Final = ErrorMessage(
-    "Expected string literal for argument name, got {}", codes.SYNTAX
-)
-NARROWED_TYPE_NOT_SUBTYPE: Final = ErrorMessage(
-    "Narrowed type {} is not a subtype of input type {}", codes.NARROWED_TYPE_NOT_SUBTYPE
-)