Continue work on new generics, a lot of stuff works

notes2.txt

@@ -55,3 +55,12 @@ x = Container(4) # ici on instancie Container avec un TypeVar donc on a `x: Cont
 				 # et on lit le corps de __init__ pour faire le reste de l'unification
 				 # self.x est de type A, via l'assignation on unifie A=C=int
 				 # donc x: Container[int] 
+
+
+---------------------------------------------------------------------------
+
+
+fonction : type concret qui a un type caché qui correspond à ce qui sera générique en gros
+pareil pour les classes
+donc on peut passer des types génériques puisqu'ils sont wrappés par un type concret
+

pyproject.toml

@@ -12,6 +12,7 @@ dependencies = [
   "pygments ~= 2.15.1",
   "colorful ~= 0.5.5",
   "pybind11 ~= 2.11.1",
+  "python-dotenv ~= 1.0.1",
 ]
 
 [project.optional-dependencies]

typon/trans/stdlib/__init__.py

 from typing import Self, Generic, Protocol, Optional
 
+assert 5
+
 class object:
     def __eq__(self, other: Self) -> bool: ...
     def __ne__(self, other: Self) -> bool: ...

typon/trans/tests/user_generics.py

 # coding: utf-8
 
-from dataclasses import dataclass
-
-
-
-@dataclass
-class Thing[T]:
-    x: T
-
-
-def f[T](x: T):
-    pass
-
-
-
-
-if __name__ == "__main__":
-    a = Thing[int](1)
-    b = Thing[str]("abc")
-    print(a)
-    print(b)
+# from dataclasses import dataclass
+#
+#
+#
+# @dataclass
+# class Thing[T]:
+#     x: T
+
+
+# def f[T](x: T):
+#     pass
+#
+#
+#
+#
+# if __name__ == "__main__":
+#     a = Thing[int](1)
+#     b = Thing[str]("abc")
+#     print(a)
+#     print(b)

typon/trans/transpiler/__init__.py

@@ -15,12 +15,11 @@ from transpiler.phases.desugar_op import DesugarOp
 
 colorama.init()
 
-from transpiler.phases.emit_cpp.consts import MAPPINGS
 from transpiler.exceptions import CompileError
 from transpiler.phases.desugar_with import DesugarWith
-from transpiler.phases.emit_cpp.file import FileVisitor
+#from transpiler.phases.emit_cpp.file import FileVisitor
 from transpiler.phases.if_main import IfMainVisitor
-from transpiler.phases.typing.block import ScoperBlockVisitor
+#from transpiler.phases.typing.block import ScoperBlockVisitor
 from transpiler.phases.typing.scope import Scope
 from transpiler.utils import highlight
 
@@ -179,12 +178,12 @@ else:
 def transpile(source, name: str, path=None):
     __TB__ = f"transpiling module {cf.white(name)}"
     res = ast.parse(source, type_comments=True)
-
+    exit()
     IfMainVisitor().visit(res)
     res = DesugarWith().visit(res)
     res = DesugarCompare().visit(res)
     res = DesugarOp().visit(res)
-    ScoperBlockVisitor().visit(res)
+    #ScoperBlockVisitor().visit(res)
 
     # print(res.scope)
 

typon/trans/transpiler/phases/typing/__init__.py

@@ -4,7 +4,7 @@ from logging import debug
 from transpiler.phases.typing.scope import VarKind, VarDecl, ScopeKind, Scope
 from transpiler.phases.typing.stdlib import PRELUDE, StdlibVisitor
 from transpiler.phases.typing.types import TY_TYPE, TY_INT, TY_STR, TY_BOOL, TY_COMPLEX, TY_NONE, ResolvedConcreteType, \
-    MemberDef
+    MemberDef, TY_FLOAT, TY_BUILTIN_FEATURE, TY_TUPLE, TY_DICT, TY_SET, TY_LIST, TY_BYTES, TY_OBJECT, TY_CPP_TYPE
 
 # PRELUDE.vars.update({
 #     "int": VarDecl(VarKind.LOCAL, TypeType(TY_INT)),
@@ -31,6 +31,24 @@ from transpiler.phases.typing.types import TY_TYPE, TY_INT, TY_STR, TY_BOOL, TY_
 #     "Optional": VarDecl(VarKind.LOCAL, TypeType(lambda x: UnionType(x, TY_NONE))),
 # })
 
+prelude_vars = {
+    "object": TY_OBJECT,
+    "bool": TY_BOOL,
+    "int": TY_INT,
+    "float": TY_FLOAT,
+    "str": TY_STR,
+    "bytes": TY_BYTES,
+    "complex": TY_COMPLEX,
+    "list": TY_LIST,
+    "set": TY_SET,
+    "dict": TY_DICT,
+    "tuple": TY_TUPLE,
+    "BuiltinFeature": TY_BUILTIN_FEATURE,
+    "CppType": TY_CPP_TYPE
+}
+
+PRELUDE.vars.update({name: VarDecl(VarKind.LOCAL, ty.type_type()) for name, ty in prelude_vars.items()})
+
 typon_std = Path(__file__).parent.parent.parent.parent / "stdlib"
 
 def make_module(name: str, scope: Scope) -> ResolvedConcreteType:

typon/trans/transpiler/phases/typing/annotations.py

@@ -4,7 +4,8 @@ from dataclasses import dataclass, field
 from typing import Optional, List
 
 from transpiler.phases.typing.scope import Scope
-from transpiler.phases.typing.types import BaseType, TY_NONE, TypeVariable, TY_TYPE, ResolvedConcreteType, TypeListType
+from transpiler.phases.typing.types import BaseType, TY_NONE, TypeVariable, TY_TYPE, ResolvedConcreteType, TypeListType, \
+    TY_BUILTIN_FEATURE, make_builtin_feature, TY_CPP_TYPE, make_cpp_type, GenericType, TY_UNION
 from transpiler.phases.utils import NodeVisitorSeq
 
 
@@ -33,11 +34,18 @@ class TypeAnnotationVisitor(NodeVisitorSeq):
         raise NotImplementedError
 
     def visit_Subscript(self, node: ast.Subscript) -> BaseType:
-        # ty_op = self.visit(node.value)
-        # args = list(node.slice.elts) if type(node.slice) == ast.Tuple else [node.slice]
-        # args = [self.visit(arg) for arg in args]
+        ty_op = self.visit(node.value)
+        args = list(node.slice.elts) if type(node.slice) == ast.Tuple else [node.slice]
+        args = [self.visit(arg) for arg in args]
+        if ty_op is TY_BUILTIN_FEATURE:
+            assert len(args) == 1
+            return make_builtin_feature(args[0])
+        elif ty_op is TY_CPP_TYPE:
+            assert len(args) == 1
+            return make_cpp_type(args[0])
         # return ty_op(*args)
-        raise NotImplementedError()
+        assert isinstance(ty_op, GenericType)
+        return ty_op.instantiate(args)
         # return TypeOperator([self.visit(node.value)], self.visit(node.slice.value))
 
     def visit_List(self, node: ast.List) -> BaseType:
@@ -51,6 +59,6 @@ class TypeAnnotationVisitor(NodeVisitorSeq):
         # return res.type_object
 
     def visit_BinOp(self, node: ast.BinOp) -> BaseType:
-        # if isinstance(node.op, ast.BitOr):
-        #     return UnionType(self.visit(node.left), self.visit(node.right))
+        if isinstance(node.op, ast.BitOr):
+            return TY_UNION.instantiate([self.visit(node.left), self.visit(node.right)])
         raise NotImplementedError(node.op)

typon/trans/transpiler/phases/typing/exceptions.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass
 
 from transpiler.utils import highlight
 from transpiler.exceptions import CompileError
-from transpiler.phases.typing.types import TypeVariable, BaseType, TypeOperator
+from transpiler.phases.typing.types import TypeVariable, BaseType
 
 
 @dataclass
@@ -85,8 +85,8 @@ class TypeMismatchError(CompileError):
 
 @dataclass
 class ArgumentCountMismatchError(CompileError):
-    func: TypeOperator
-    arguments: TypeOperator
+    func: "TypeOperator"
+    arguments: "TypeOperator"
 
     def __str__(self) -> str:
         fcount = str(len(self.func.args))
@@ -309,7 +309,7 @@ class InconsistentMroError(CompileError):
     bases: list[BaseType]
 
     def __str__(self) -> str:
-        return f"Cannot create a cnossitent method resolution order (MRO) for bases {'\n'.join(map(highlight, self.bases))}"
+        return f"Cannot create a consistent method resolution order (MRO) for bases {'\n'.join(map(highlight, self.bases))}"
 
     def detail(self, last_node: ast.AST = None) -> str:
         return f"""

typon/trans/transpiler/phases/typing/scope.py

 import ast
 from dataclasses import field, dataclass
 from enum import Enum
-from typing import Optional, Dict, List, Any
+from typing import Optional, Dict, List, Any, Self
 
 from transpiler.phases.typing.types import BaseType, RuntimeValue
 
@@ -67,7 +67,7 @@ class Scope:
             return self.parent.is_in_loop()
         return None
 
-    def child(self, kind: ScopeKind):
+    def child(self, kind: ScopeKind) -> Self:
         res = Scope(self, kind, self.function, self.global_scope)
         if kind == ScopeKind.GLOBAL:
             res.global_scope = res

typon/trans/transpiler/phases/typing/stdlib.py

@@ -4,13 +4,15 @@ from abc import ABCMeta
 from dataclasses import dataclass, field
 from typing import Optional, List, Dict, Callable
 from logging import debug
+
+from transpiler.utils import highlight
 from transpiler.phases.typing.annotations import TypeAnnotationVisitor
 from transpiler.phases.typing.common import PRELUDE, is_builtin
 from transpiler.phases.typing.expr import ScoperExprVisitor
 from transpiler.phases.typing.scope import Scope, VarDecl, VarKind, ScopeKind
 from transpiler.phases.typing.types import BaseType, BuiltinGenericType, BuiltinType, create_builtin_generic_type, \
     create_builtin_type, ConcreteType, GenericInstanceType, TypeListType, TypeTupleType, GenericParameter, \
-    GenericParameterKind, TypeVariable
+    GenericParameterKind, TypeVariable, ResolvedConcreteType, MemberDef, ClassTypeType, CallableInstanceType
 from transpiler.phases.utils import NodeVisitorSeq
 
 def visit_generic_item(
@@ -18,8 +20,9 @@ def visit_generic_item(
         node,
         output_type: BuiltinGenericType,
         scope: Scope,
-        instance_type = None):
-    if node.type_params:
+        instance_type = None,
+        force_generic = False):
+    if force_generic or node.type_params:
         output_type.parameters = []
         for param in node.type_params:
             match param:
@@ -47,19 +50,21 @@ def visit_generic_item(
                     op_val = TypeVariable()
                 match param:
                     case ast.TypeVar(name, bound):
-                        new_scope.declare_local(name, op_val)
+                        new_scope.declare_local(name, op_val.type_type())
                         if bound is not None:
                             constraints.append((op_val, anno.visit(bound)))
                     case ast.ParamSpec(name):
                         assert isinstance(op_val, TypeListType)
-                        new_scope.declare_local(name, op_val)
+                        new_scope.declare_local(name, op_val.type_type())
                     case ast.TypeVarTuple(name):
-                        new_scope.declare_local(name, TypeTupleType(list(args_iter)))
-            for a, b in constraints:
-                raise NotImplementedError()
+                        new_scope.declare_local(name, TypeTupleType(list(args_iter)).type_type())
+            # for a, b in constraints:
+            #     raise NotImplementedError()
+            # todo
             new_output_type = instance_type()
             visit_nongeneric(new_scope, new_output_type)
             return new_output_type
+        output_type.constraints_ = []
         output_type.instantiate_ = instantiate
     else:
         visit_nongeneric(scope, output_type)
@@ -68,7 +73,7 @@ def visit_generic_item(
 @dataclass
 class StdlibVisitor(NodeVisitorSeq):
     scope: Scope = field(default_factory=lambda: PRELUDE)
-    cur_class: Optional[BaseType] = None
+    cur_class: Optional[ResolvedConcreteType] = None
     typevars: Dict[str, BaseType] = field(default_factory=dict)
 
     def expr(self) -> ScoperExprVisitor:
@@ -84,8 +89,8 @@ class StdlibVisitor(NodeVisitorSeq):
     def visit_AnnAssign(self, node: ast.AnnAssign):
         ty = self.anno().visit(node.annotation)
         if self.cur_class:
-            assert isinstance(self.cur_class, TypeType)
-            self.cur_class.type_object.fields[node.target.id] = MemberDef(ty.gen_sub(self.cur_class.type_object, self.typevars))
+            assert isinstance(self.cur_class, ResolvedConcreteType)
+            self.cur_class.fields[node.target.id] = MemberDef(ty)
         self.scope.vars[node.target.id] = VarDecl(VarKind.LOCAL, ty)
 
     def visit_ImportFrom(self, node: ast.ImportFrom):
@@ -96,14 +101,16 @@ class StdlibVisitor(NodeVisitorSeq):
 
     def visit_ClassDef(self, node: ast.ClassDef):
         if existing := self.scope.get(node.name):
-            NewType = existing.type
+            assert isinstance(existing.type, ClassTypeType)
+            NewType = existing.type.inner_type
         else:
             base_class = create_builtin_generic_type if node.type_params else create_builtin_type
             NewType = base_class(node.name)
             self.scope.vars[node.name] = VarDecl(VarKind.LOCAL, NewType.type_type())
 
-        def visit_nongeneric(scope, output: ConcreteType):
+        def visit_nongeneric(scope: Scope, output: ConcreteType):
             cl_scope = scope.child(ScopeKind.CLASS)
+            cl_scope.declare_local("Self", output.type_type())
             visitor = StdlibVisitor(cl_scope, output)
             for stmt in node.body:
                 visitor.visit(stmt)
@@ -114,17 +121,74 @@ class StdlibVisitor(NodeVisitorSeq):
         pass
 
     def visit_FunctionDef(self, node: ast.FunctionDef):
-        def visit_nongeneric(scope, output: ConcreteType):
-            cl_scope = scope.child(ScopeKind.CLASS)
-            visitor = StdlibVisitor(cl_scope, output)
-            for stmt in node.body:
-                visitor.visit(stmt)
+        def visit_nongeneric(scope, output: CallableInstanceType):
+            scope = scope.child(ScopeKind.FUNCTION)
+            arg_visitor = TypeAnnotationVisitor(scope)
+            output.parameters = [arg_visitor.visit(arg.annotation) for arg in node.args.args]
+            output.return_type = arg_visitor.visit(node.returns)
+
+        @dataclass(eq=False, init=False)
+        class InstanceType(CallableInstanceType):
+            def __init__(self):
+                super().__init__([], None)
+
+            def __str__(self):
+                return f"{node.name}({", ".join(map(str, self.parameters))}) -> {self.return_type}"
+
 
         '''
         class arguments(__ast.AST):
     """ arguments(arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs, expr* kw_defaults, arg? kwarg, expr* defaults) """'''
 
-        visit_generic_item(visit_nongeneric, node, NewType, self.scope)
+        args = node.args
+        assert args.posonlyargs == []
+        #assert args.vararg is None TODO
+        assert args.kwonlyargs == []
+        assert args.kw_defaults == []
+        assert args.kwarg is None
+        #assert args.defaults == [] TODO
+
+        for i, arg in enumerate(args.args):
+            arg: ast.arg
+            """ arg(identifier arg, expr? annotation, string? type_comment) """
+            if arg.annotation is None:
+                if i == 0 and self.cur_class is not None:
+                    arg_name = "Self"
+                else:
+                    arg_name = f"AutoVar${hash(arg.arg)}"
+                    node.type_params.append(ast.TypeVar(arg_name, None)) # todo: bounds
+                arg.annotation = ast.Name(arg_name, ast.Load())
+            else:
+                if isinstance(arg.annotation, ast.Name) and (
+                    arg.annotation.id == "Self" or
+                        any(k.name == arg.annotation.id for k in node.type_params)
+                ):
+                    # annotation is type variable so we keep it
+                    pass
+                else:
+                    arg_name = f"AutoBoundedVar${hash(arg.arg)}"
+                    node.type_params.append(ast.TypeVar(arg_name, arg.annotation))
+                    arg.annotation = ast.Name(arg_name, ast.Load())
+
+        # if self.cur_class is not None:
+        #     node.type_params.append(ast.TypeVar("Self", None))
+
+        if True or node.type_params:
+            class FuncType(BuiltinGenericType):
+                def name(self):
+                    return f"FuncTypeGen${node.name}"
+        else:
+            class FuncType(InstanceType):
+                pass
+        base_class = FuncType
+        NewType = base_class()
+        FuncType.__name__ = NewType.name()
+
+        self.scope.vars[node.name] = VarDecl(VarKind.LOCAL, NewType)
+        if self.cur_class is not None:
+            self.cur_class.fields[node.name] = MemberDef(NewType, node)
+
+        visit_generic_item(visit_nongeneric, node, NewType, self.scope, InstanceType, True)
 
 
         # tc = node.type_comment # todo : lire les commetnaries de type pour les fonctions génériques sinon trouver autre chose
@@ -155,18 +219,10 @@ class StdlibVisitor(NodeVisitorSeq):
             else:
                 raise AssertionError(f"Assertion should fail, got {res} for {ast.unparse(oper)}")
         else:
-            debug(f"Type of {ast.unparse(node.test)} := {self.expr().visit(node.test)}")
-
-    def visit_Call(self, node: ast.Call) -> BaseType:
-        ty_op = self.visit(node.func)
-        if is_builtin(ty_op, "TypeVar"):
-            return TypeType(TypeVariable(*[ast.literal_eval(arg) for arg in node.args]))
-        if isinstance(ty_op, TypeType):
-            return TypeType(ty_op.type_object(*[ast.literal_eval(arg) for arg in node.args]))
-        raise NotImplementedError(ast.unparse(node))
+            debug(f"Type of {highlight(ast.unparse(node.test))} := {highlight(self.expr().visit(node.test))}")
 
     def anno(self) -> "TypeAnnotationVisitor":
-        return TypeAnnotationVisitor(self.scope, self.cur_class)
+        return TypeAnnotationVisitor(self.scope)
 
     def visit_str(self, node: str) -> BaseType:
         if existing := self.scope.get(node):
@@ -175,6 +231,4 @@ class StdlibVisitor(NodeVisitorSeq):
         raise UnknownNameError(node)
 
     def visit_Name(self, node: ast.Name) -> BaseType:
-        if node.id == "TypeVar":
-            return BuiltinFeature("TypeVar")
         return self.visit_str(node.id)
\ No newline at end of file

typon/trans/transpiler/phases/typing2/__init__.py

-import ast
-from pathlib import Path
-from logging import debug
-from transpiler.phases.typing.scope import VarKind, VarDecl, ScopeKind, Scope
-from transpiler.phases.typing.stdlib import PRELUDE, StdlibVisitor
-from transpiler.phases.typing.types import TY_TYPE, TY_INT, TY_STR, TY_BOOL, TY_COMPLEX, TY_NONE, FunctionType, \
-    TypeVariable, CppType, PyList, TypeType, Forked, Task, Future, PyIterator, TupleType, TypeOperator, BaseType, \
-    ModuleType, TY_BYTES, TY_FLOAT, PyDict, TY_SLICE, TY_OBJECT, BuiltinFeature, UnionType, MemberDef
-
-PRELUDE.vars.update({
-    # "int": VarDecl(VarKind.LOCAL, TY_TYPE, TY_INT),
-    # "str": VarDecl(VarKind.LOCAL, TY_TYPE, TY_STR),
-    # "bool": VarDecl(VarKind.LOCAL, TY_TYPE, TY_BOOL),
-    # "complex": VarDecl(VarKind.LOCAL, TY_TYPE, TY_COMPLEX),
-    # "None": VarDecl(VarKind.LOCAL, TY_NONE, None),
-    # "Callable": VarDecl(VarKind.LOCAL, TY_TYPE, FunctionType),
-    # "TypeVar": VarDecl(VarKind.LOCAL, TY_TYPE, TypeVariable),
-    # "CppType": VarDecl(VarKind.LOCAL, TY_TYPE, CppType),
-    # "list": VarDecl(VarKind.LOCAL, TY_TYPE, PyList),
-    "int": VarDecl(VarKind.LOCAL, TypeType(TY_INT)),
-    "float": VarDecl(VarKind.LOCAL, TypeType(TY_FLOAT)),
-    "str": VarDecl(VarKind.LOCAL, TypeType(TY_STR)),
-    "bytes": VarDecl(VarKind.LOCAL, TypeType(TY_BYTES)),
-    "bool": VarDecl(VarKind.LOCAL, TypeType(TY_BOOL)),
-    "complex": VarDecl(VarKind.LOCAL, TypeType(TY_COMPLEX)),
-    "None": VarDecl(VarKind.LOCAL, TypeType(TY_NONE)),
-    "Callable": VarDecl(VarKind.LOCAL, TypeType(FunctionType)),
-    #"TypeVar": VarDecl(VarKind.LOCAL, TypeType(TypeVariable)),
-    "CppType": VarDecl(VarKind.LOCAL, TypeType(CppType)),
-    "list": VarDecl(VarKind.LOCAL, TypeType(PyList)),
-    "dict": VarDecl(VarKind.LOCAL, TypeType(PyDict)),
-    "Forked": VarDecl(VarKind.LOCAL, TypeType(Forked)),
-    "Task": VarDecl(VarKind.LOCAL, TypeType(Task)),
-    "Future": VarDecl(VarKind.LOCAL, TypeType(Future)),
-    "Iterator": VarDecl(VarKind.LOCAL, TypeType(PyIterator)),
-    "tuple": VarDecl(VarKind.LOCAL, TypeType(TupleType)),
-    "slice": VarDecl(VarKind.LOCAL, TypeType(TY_SLICE)),
-    "object": VarDecl(VarKind.LOCAL, TypeType(TY_OBJECT)),
-    "BuiltinFeature": VarDecl(VarKind.LOCAL, TypeType(BuiltinFeature)),
-    "Any": VarDecl(VarKind.LOCAL, TypeType(TY_OBJECT)),
-    "Optional": VarDecl(VarKind.LOCAL, TypeType(lambda x: UnionType(x, TY_NONE))),
-})
-
-typon_std = Path(__file__).parent.parent.parent.parent / "stdlib"
-
-def make_module(name: str, scope: Scope) -> BaseType:
-    ty = ModuleType([], f"{name}")
-    for n, v in scope.vars.items():
-        ty.fields[n] = MemberDef(v.type, v.val, False)
-    return ty
-
-
-def discover_module(path: Path, scope):
-    for child in sorted(path.iterdir()):
-        if child.is_dir():
-            mod_scope = PRELUDE.child(ScopeKind.GLOBAL)
-            discover_module(child, mod_scope)
-            scope.vars[child.name] = make_mod_decl(child.name, mod_scope)
-        elif child.name == "__init__.py":
-            StdlibVisitor(scope).visit(ast.parse(child.read_text()))
-            debug(f"Visited {child}")
-        elif child.suffix == ".py":
-            mod_scope = PRELUDE.child(ScopeKind.GLOBAL)
-            StdlibVisitor(mod_scope).visit(ast.parse(child.read_text()))
-            if child.stem[-1] == "_":
-                child = child.with_name(child.stem[:-1])
-            scope.vars[child.stem] = make_mod_decl(child.name, mod_scope)
-            debug(f"Visited {child}")
-
-
-def make_mod_decl(child, mod_scope):
-    return VarDecl(VarKind.MODULE, make_module(child, mod_scope), {k: v.type for k, v in mod_scope.vars.items()})
-
-
-discover_module(typon_std, PRELUDE)
-
-debug("Stdlib visited!")
-#exit()
\ No newline at end of file

typon/trans/transpiler/phases/typing2/annotations.py

-import abc
-import ast
-from dataclasses import dataclass, field
-from typing import Optional, List
-
-from transpiler.phases.typing.scope import Scope
-from transpiler.phases.typing.types import BaseType, TY_NONE, TypeVariable, TY_TYPE, ResolvedConcreteType, TypeListType
-from transpiler.phases.utils import NodeVisitorSeq
-
-
-@dataclass
-class TypeAnnotationVisitor(NodeVisitorSeq):
-    scope: Scope
-
-    def visit_str(self, node: str) -> BaseType:
-        if existing := self.scope.get(node):
-            ty = existing.type
-            assert isinstance(ty, ResolvedConcreteType)
-            assert ty.inherits(TY_TYPE)
-            return ty.inner_type
-
-        from transpiler.phases.typing.exceptions import UnknownNameError
-        raise UnknownNameError(node)
-
-    def visit_Name(self, node: ast.Name) -> BaseType:
-        return self.visit_str(node.id)
-
-    def visit_Constant(self, node: ast.Constant) -> BaseType:
-        if node.value is None:
-            return TY_NONE
-        if type(node.value) == str:
-            return node.value
-        raise NotImplementedError
-
-    def visit_Subscript(self, node: ast.Subscript) -> BaseType:
-        # ty_op = self.visit(node.value)
-        # args = list(node.slice.elts) if type(node.slice) == ast.Tuple else [node.slice]
-        # args = [self.visit(arg) for arg in args]
-        # return ty_op(*args)
-        raise NotImplementedError()
-        # return TypeOperator([self.visit(node.value)], self.visit(node.slice.value))
-
-    def visit_List(self, node: ast.List) -> BaseType:
-        return TypeListType([self.visit(elt) for elt in node.elts])
-
-    def visit_Attribute(self, node: ast.Attribute) -> BaseType:
-        raise NotImplementedError()
-        # left = self.visit(node.value)
-        # res = left.fields[node.attr].type
-        # assert isinstance(res, TypeType)
-        # return res.type_object
-
-    def visit_BinOp(self, node: ast.BinOp) -> BaseType:
-        # if isinstance(node.op, ast.BitOr):
-        #     return UnionType(self.visit(node.left), self.visit(node.right))
-        raise NotImplementedError(node.op)

typon/trans/transpiler/phases/typing2/class_.py

-# coding: utf-8
-import ast
-from dataclasses import dataclass, field
-
-from transpiler.phases.typing import FunctionType, ScopeKind, VarDecl, VarKind, TY_NONE
-from transpiler.phases.typing.common import ScoperVisitor
-from transpiler.phases.typing.types import PromiseKind, Promise, BaseType, MemberDef
-
-
-@dataclass
-class ScoperClassVisitor(ScoperVisitor):
-    fdecls: list[(ast.FunctionDef, BaseType)] = field(default_factory=list)
-
-    def visit_AnnAssign(self, node: ast.AnnAssign):
-        assert node.value is None, "Class field should not have a value"
-        assert node.simple == 1, "Class field should be simple (identifier, not parenthesized)"
-        assert isinstance(node.target, ast.Name)
-        self.scope.obj_type.fields[node.target.id] = MemberDef(self.visit_annotation(node.annotation))
-
-    def visit_Assign(self, node: ast.Assign):
-        assert len(node.targets) == 1, "Can't use destructuring in class static member"
-        assert isinstance(node.targets[0], ast.Name)
-        node.is_declare = True
-        valtype = self.expr().visit(node.value)
-        node.targets[0].type = valtype
-        self.scope.obj_type.fields[node.targets[0].id] = MemberDef(valtype, node.value)
-
-    def visit_FunctionDef(self, node: ast.FunctionDef):
-        ftype = self.parse_function(node)
-        ftype.parameters[0].unify(self.scope.obj_type)
-        inner = ftype.return_type
-        if node.name != "__init__":
-            ftype.return_type = Promise(ftype.return_type, PromiseKind.TASK)
-        ftype.is_method = True
-        self.scope.obj_type.fields[node.name] = MemberDef(ftype, node)
-        return (node, inner)

typon/trans/transpiler/phases/typing2/common.py

-import ast
-from dataclasses import dataclass, field
-from typing import Dict, Optional
-
-from transpiler.utils import highlight
-from transpiler.phases.typing.annotations import TypeAnnotationVisitor
-from transpiler.phases.typing.scope import Scope, ScopeKind, VarDecl, VarKind
-from transpiler.phases.typing.types import BaseType, TypeVariable, TY_NONE, TypeType, BuiltinFeature, FunctionType, \
-    Promise, PromiseKind
-from transpiler.phases.utils import NodeVisitorSeq, AnnotationName
-
-PRELUDE = Scope.make_global()
-
-@dataclass
-class ScoperVisitor(NodeVisitorSeq):
-    scope: Scope = field(default_factory=lambda: PRELUDE.child(ScopeKind.GLOBAL))
-    root_decls: Dict[str, VarDecl] = field(default_factory=dict)
-    cur_class: Optional[TypeType] = None
-
-    def expr(self) -> "ScoperExprVisitor":
-        from transpiler.phases.typing.expr import ScoperExprVisitor
-        return ScoperExprVisitor(self.scope, self.root_decls)
-
-    def anno(self) -> "TypeAnnotationVisitor":
-        return TypeAnnotationVisitor(self.scope, self.cur_class)
-
-    def visit_annotation(self, expr: Optional[ast.expr]) -> BaseType:
-        res = self.anno().visit(expr) if expr else TypeVariable()
-        assert not isinstance(res, TypeType)
-        return res
-
-    def annotate_arg(self, arg: ast.arg) -> BaseType:
-        if arg.annotation is None or isinstance(arg.annotation, AnnotationName):
-            res = TypeVariable()
-            arg.annotation = AnnotationName(res)
-            return res
-        else:
-            return self.visit_annotation(arg.annotation)
-
-    def parse_function(self, node: ast.FunctionDef):
-        argtypes = [self.annotate_arg(arg) for arg in node.args.args]
-        rtype = self.visit_annotation(node.returns)
-        ftype = FunctionType(argtypes, rtype)
-        scope = self.scope.child(ScopeKind.FUNCTION)
-        scope.obj_type = ftype
-        scope.function = scope
-        node.inner_scope = scope
-        node.type = ftype
-        ftype.optional_at = len(node.args.args) - len(node.args.defaults)
-        for ty, default in zip(argtypes[ftype.optional_at:], node.args.defaults):
-            self.expr().visit(default).unify(ty)
-        for arg, ty in zip(node.args.args, argtypes):
-            scope.vars[arg.arg] = VarDecl(VarKind.LOCAL, ty)
-        self.fdecls.append((node, rtype))
-        return ftype
-
-    def visit_block(self, block: list[ast.AST]):
-        if not block:
-            return
-        __TB__ = f"running type analysis on block starting with {highlight(block[0])}"
-        self.fdecls = []
-        for b in block:
-            self.visit(b)
-        if self.fdecls:
-            old_list = self.fdecls
-            exc = None
-            while True:
-                new_list = []
-                for node, rtype in old_list:
-                    from transpiler.exceptions import CompileError
-                    try:
-                        self.visit_function_definition(node, rtype)
-                    except CompileError as e:
-                        new_list.append((node, rtype))
-                        if not exc or getattr(node, "is_main", False):
-                            exc = e
-                if len(new_list) == len(old_list):
-                    raise exc
-                if not new_list:
-                    break
-                old_list = new_list
-                exc = None
-
-    def visit_function_definition(self, node, rtype):
-        __TB__ = f"running type analysis on the body of {highlight(node)}"
-        __TB_NODE__ = node
-        from transpiler.phases.typing.block import ScoperBlockVisitor
-        for b in node.body:
-            decls = {}
-            visitor = ScoperBlockVisitor(node.inner_scope, decls)
-            visitor.fdecls = []
-            visitor.visit(b)
-            if len(visitor.fdecls) > 1:
-                raise NotImplementedError("?")
-            elif len(visitor.fdecls) == 1:
-                fnode, frtype = visitor.fdecls[0]
-                self.visit_function_definition(fnode, frtype)
-                #del node.inner_scope.vars[fnode.name]
-                visitor.visit_assign_target(ast.Name(fnode.name), fnode.type)
-            b.decls = decls
-        if not node.inner_scope.diverges and not (isinstance(node.type.return_type, Promise) and node.type.return_type.kind == PromiseKind.GENERATOR):
-            from transpiler.phases.typing.exceptions import TypeMismatchError
-            try:
-                rtype.unify(TY_NONE)
-            except TypeMismatchError as e:
-                from transpiler.phases.typing.exceptions import MissingReturnError
-                raise MissingReturnError(node) from e
-
-def get_iter(seq_type):
-    try:
-        iter_type = seq_type.fields["__iter__"].type.return_type
-    except:
-        from transpiler.phases.typing.exceptions import NotIterableError
-        raise NotIterableError(seq_type)
-    return iter_type
-
-def get_next(iter_type):
-    try:
-        next_type = iter_type.fields["__next__"].type.return_type
-    except:
-        from transpiler.phases.typing.exceptions import NotIteratorError
-        raise NotIteratorError(iter_type)
-    return next_type
-
-def is_builtin(x, feature):
-    return isinstance(x, BuiltinFeature) and x.val == feature
\ No newline at end of file

typon/trans/transpiler/phases/typing2/scope.py

-import ast
-from dataclasses import field, dataclass
-from enum import Enum
-from typing import Optional, Dict, List, Any
-
-from transpiler.phases.typing.types import BaseType, RuntimeValue
-
-
-class VarKind(Enum):
-    """Kind of variable."""
-    LOCAL = 1
-    """`xxx = ...`"""
-    GLOBAL = 2
-    """`global xxx"""
-    NONLOCAL = 3
-    """`nonlocal xxx`"""
-    SELF = 4
-    OUTER_DECL = 5
-    MODULE = 6
-
-
-class VarType:
-    pass
-
-
-@dataclass
-class VarDecl:
-    kind: VarKind
-    type: BaseType
-    val: Any = RuntimeValue()
-
-
-class ScopeKind(Enum):
-    GLOBAL = 1
-    """Global (module) scope"""
-    FUNCTION = 2
-    """Function scope"""
-    FUNCTION_INNER = 3
-    """Block (if, for, ...) scope inside a function"""
-    CLASS = 4
-    """Class scope"""
-
-
-@dataclass
-class Scope:
-    parent: Optional["Scope"] = None
-    kind: ScopeKind = ScopeKind.GLOBAL
-    function: Optional["Scope"] = None
-    global_scope: Optional["Scope"] = None
-    vars: Dict[str, VarDecl] = field(default_factory=dict)
-    children: List["Scope"] = field(default_factory=list)
-    obj_type: Optional[BaseType] = None
-    diverges: bool = False
-    class_: Optional["Scope"] = None
-    is_loop: Optional[ast.For | ast.While] = None
-
-    @staticmethod
-    def make_global():
-        res = Scope()
-        res.global_scope = res
-        return res
-
-    def is_in_loop(self) -> Optional[ast.For | ast.While]:
-        if self.is_loop:
-            return self.is_loop
-        if self.parent is not None and self.kind != ScopeKind.FUNCTION:
-            return self.parent.is_in_loop()
-        return None
-
-    def child(self, kind: ScopeKind):
-        res = Scope(self, kind, self.function, self.global_scope)
-        if kind == ScopeKind.GLOBAL:
-            res.global_scope = res
-        self.children.append(res)
-        return res
-
-    def declare_local(self, name: str, type: BaseType):
-        """Declares a local variable"""
-        self.vars[name] = VarDecl(VarKind.LOCAL, type)
-
-    def get(self, name: str, kind: VarKind | set[VarKind] = VarKind.LOCAL, restrict_function: bool = False) -> Optional[VarDecl]:
-        """
-        Gets the variable declaration of a variable in the current scope or any parent scope.
-        """
-        if type(kind) is VarKind:
-            kind = {kind}
-        if (res := self.vars.get(name)) and res.kind in kind:
-            if res.kind == VarKind.GLOBAL:
-                return self.global_scope.get(name, kind)
-            elif res.kind == VarKind.NONLOCAL:
-                return self.function.parent.get(name, VarKind.LOCAL, True)
-            return res
-        if self.parent is not None and not (self.kind == ScopeKind.FUNCTION and restrict_function):
-            return self.parent.get(name, kind, restrict_function)
-        return None

typon/trans/transpiler/phases/typing2/stdlib.py

-import ast
-import dataclasses
-from abc import ABCMeta
-from dataclasses import dataclass, field
-from typing import Optional, List, Dict
-from logging import debug
-from transpiler.phases.typing.annotations import TypeAnnotationVisitor
-from transpiler.phases.typing.common import PRELUDE, is_builtin
-from transpiler.phases.typing.expr import ScoperExprVisitor
-from transpiler.phases.typing.scope import Scope, VarDecl, VarKind, ScopeKind
-from transpiler.phases.typing.types import BaseType, TypeOperator, FunctionType, TY_VARARG, TypeType, TypeVariable, \
-    MemberDef, BuiltinFeature
-from transpiler.phases.utils import NodeVisitorSeq
-
-
-
-@dataclass
-class StdlibVisitor(NodeVisitorSeq):
-    scope: Scope = field(default_factory=lambda: PRELUDE)
-    cur_class: Optional[BaseType] = None
-    typevars: Dict[str, BaseType] = field(default_factory=dict)
-
-    def expr(self) -> ScoperExprVisitor:
-        return ScoperExprVisitor(self.scope)
-
-    def visit_Module(self, node: ast.Module):
-        for stmt in node.body:
-            self.visit(stmt)
-
-    def visit_Assign(self, node: ast.Assign):
-        self.scope.vars[node.targets[0].id] = VarDecl(VarKind.LOCAL, self.visit(node.value))
-
-    def visit_AnnAssign(self, node: ast.AnnAssign):
-        ty = self.anno().visit(node.annotation)
-        if self.cur_class:
-            assert isinstance(self.cur_class, TypeType)
-            if isinstance(self.cur_class.type_object, ABCMeta):
-                raise NotImplementedError
-            else:
-                self.cur_class.type_object.fields[node.target.id] = MemberDef(ty.gen_sub(self.cur_class.type_object, self.typevars))
-        self.scope.vars[node.target.id] = VarDecl(VarKind.LOCAL, ty)
-
-    def visit_ImportFrom(self, node: ast.ImportFrom):
-        pass
-
-    def visit_Import(self, node: ast.Import):
-        pass
-
-    def visit_ClassDef(self, node: ast.ClassDef):
-        if existing := self.scope.get(node.name):
-            ty = existing.type
-        else:
-            class BuiltinClassType(TypeOperator):
-                def __init__(self, *args):
-                    super().__init__(args, node.name, is_reference=True)
-            ty = TypeType(BuiltinClassType)
-            self.scope.vars[node.name] = VarDecl(VarKind.LOCAL, ty)
-        typevars = []
-        for b in node.bases:
-            if isinstance(b, ast.Subscript):
-                if isinstance(b.slice, ast.Name):
-                    sliceval = [b.slice.id]
-                elif isinstance(b.slice, ast.Tuple):
-                    sliceval = [n.id for n in b.slice.elts]
-                if isinstance(b.value, ast.Name) and b.value.id == "Generic":
-                    typevars = sliceval
-                elif isinstance(b.value, ast.Name) and b.value.id == "Protocol":
-                    typevars = sliceval
-                    ty.type_object.is_protocol_gen = True
-                else:
-                    idxs = [typevars.index(v) for v in sliceval]
-                    parent = self.visit(b.value)
-                    assert isinstance(parent, TypeType)
-                    assert isinstance(ty.type_object, ABCMeta)
-                    ty.type_object.gen_parents.append(lambda selfvars: parent.type_object(*[selfvars[i] for i in idxs]))
-            else:
-                if isinstance(b, ast.Name) and b.id == "Protocol":
-                    ty.type_object.is_protocol_gen = True
-                else:
-                    parent = self.visit(b)
-                    assert isinstance(parent, TypeType)
-                    if isinstance(ty.type_object, ABCMeta):
-                        ty.type_object.gen_parents.append(parent.type_object)
-                    else:
-                        ty.type_object.parents.append(parent.type_object)
-        if not typevars and not existing:
-            ty.type_object = ty.type_object()
-        cl_scope = self.scope.child(ScopeKind.CLASS)
-        visitor = StdlibVisitor(cl_scope, ty)
-        for var in typevars:
-            visitor.typevars[var] = TypeType(TypeVariable(var))
-        for stmt in node.body:
-            visitor.visit(stmt)
-
-    def visit_Pass(self, node: ast.Pass):
-        pass
-
-    def visit_FunctionDef(self, node: ast.FunctionDef):
-        tc = node.type_comment # todo : lire les commetnaries de type pour les fonctions génériques sinon trouver autre chose
-        arg_visitor = TypeAnnotationVisitor(self.scope.child(ScopeKind.FUNCTION), self.cur_class)
-        arg_types = [arg_visitor.visit(arg.annotation or arg.arg) for arg in node.args.args]
-        ret_type = arg_visitor.visit(node.returns)
-        ty = FunctionType(arg_types, ret_type)
-        ty.typevars = arg_visitor.typevars
-        if node.args.vararg:
-            ty.variadic = True
-        ty.optional_at = 1 + len(node.args.args) - len(node.args.defaults)
-        if self.cur_class:
-            ty.is_method = True
-            assert isinstance(self.cur_class, TypeType)
-            if isinstance(self.cur_class.type_object, ABCMeta):
-                self.cur_class.type_object.gen_methods[node.name] = lambda t: ty.gen_sub(t, self.typevars)
-            else:
-                self.cur_class.type_object.fields[node.name] = MemberDef(ty.gen_sub(self.cur_class.type_object, self.typevars), ())
-        self.scope.vars[node.name] = VarDecl(VarKind.LOCAL, ty)
-
-    def visit_Assert(self, node: ast.Assert):
-        if isinstance(node.test, ast.UnaryOp) and isinstance(node.test.op, ast.Not):
-            oper = node.test.operand
-            try:
-                res = self.expr().visit(oper)
-            except:
-                debug(f"Type of {ast.unparse(oper)} := INVALID")
-            else:
-                raise AssertionError(f"Assertion should fail, got {res} for {ast.unparse(oper)}")
-        else:
-            debug(f"Type of {ast.unparse(node.test)} := {self.expr().visit(node.test)}")
-
-    def visit_Call(self, node: ast.Call) -> BaseType:
-        ty_op = self.visit(node.func)
-        if is_builtin(ty_op, "TypeVar"):
-            return TypeType(TypeVariable(*[ast.literal_eval(arg) for arg in node.args]))
-        if isinstance(ty_op, TypeType):
-            return TypeType(ty_op.type_object(*[ast.literal_eval(arg) for arg in node.args]))
-        raise NotImplementedError(ast.unparse(node))
-
-    def anno(self) -> "TypeAnnotationVisitor":
-        return TypeAnnotationVisitor(self.scope, self.cur_class)
-
-    def visit_str(self, node: str) -> BaseType:
-        if existing := self.scope.get(node):
-            return existing.type
-        from transpiler.phases.typing.exceptions import UnknownNameError
-        raise UnknownNameError(node)
-
-    def visit_Name(self, node: ast.Name) -> BaseType:
-        if node.id == "TypeVar":
-            return BuiltinFeature("TypeVar")
-        return self.visit_str(node.id)
\ No newline at end of file

typon/trans/transpiler/phases/typing2/types.py

-import typing
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from typing import Dict, Optional, Callable
-
-
-def get_default_parents():
-    if obj := globals().get("TY_OBJECT"):
-        return [obj]
-    return []
-
-
-class RuntimeValue:
-    pass
-
-
-@dataclass
-class MemberDef:
-    type: "BaseType"
-    val: typing.Any = RuntimeValue()
-    in_class_def: bool = True
-
-
-@dataclass(eq=False)
-class BaseType(ABC):
-    def resolve(self) -> "BaseType":
-        return self
-
-
-cur_var = 0
-
-
-def next_var_id():
-    global cur_var
-    cur_var += 1
-    return cur_var
-
-@dataclass(eq=False)
-class ConcreteType(BaseType):
-    """
-    A concrete type is the type of a concrete value.
-
-    It has fields and a list of parent concrete types.
-
-    Examples: int, str, list[int]
-    """
-
-
-@dataclass(eq=False)
-class TypeVariable(ConcreteType):
-    name: str = field(default_factory=lambda: next_var_id())
-    resolved: Optional[ConcreteType] = None
-
-    def resolve(self) -> ConcreteType:
-        if self.resolved is None:
-            return self
-        return self.resolved.resolve()
-
-    def __str__(self):
-        if self.resolved is None:
-            # return f"TypeVar[\"{self.name}\"]"
-            return f"_{self.name}"
-        return str(self.resolved)
-
-    def __eq__(self, other):
-        if not isinstance(other, BaseType):
-            return False
-        if self.resolved is None:
-            return self == other
-        return self.resolved == other.resolve()
-
-
-@dataclass(eq=False)
-class ResolvedConcreteType(ConcreteType):
-    """
-    A concrete type is the type of a concrete value.
-
-    It has fields and a list of parent concrete types.
-
-    Examples: int, str, list[int]
-    """
-
-    fields: Dict[str, "MemberDef"] = field(default_factory=dict, init=False)
-    parents: list["ResolvedConcreteType"] = field(default_factory=lambda: [TY_OBJECT], init=False)
-
-    def get_mro(self):
-        """
-        Performs linearization according to the MRO spec.
-
-        https://www.python.org/download/releases/2.3/mro/
-        """
-
-        def merge(*lists):
-            lists = [l for l in lists if len(l) > 0]
-            for i, l in enumerate(lists):
-                first = l[0]
-                for j, l2 in enumerate(lists):
-                    if j == i:
-                        continue
-                    if first in l2:
-                        break
-                else:
-                    return [first] + merge(*[x[1:] for x in lists if x[0] != first])
-            # unable to find a next element
-            from transpiler.phases.typing.exceptions import InconsistentMroError
-            raise InconsistentMroError(self.parents)
-
-        return [self] + merge(*[p.get_mro() for p in self.parents], self.parents)
-
-    def inherits(self, parent: BaseType):
-        return self == parent or any(p.inherits(parent) for p in self.parents)
-
-
-@dataclass(eq=False, init=False)
-class GenericInstanceType(ResolvedConcreteType):
-    """
-    An instance of a generic type.
-
-    Examples: list[int], dict[str, object], Callable[[int, int], int]
-    """
-    generic_parent: "GenericType"
-    generic_args: list[ConcreteType]
-
-    def __init__(self):
-        super().__init__()
-
-    def inherits(self, parent: BaseType):
-        return self.generic_parent == parent or super().inherits(parent)
-
-    def __eq__(self, other):
-        if isinstance(other, GenericInstanceType):
-            return self.generic_parent == other.generic_parent and self.generic_args == other.generic_args
-        return False
-
-    def __str__(self):
-        return f"{self.generic_parent}[{', '.join(map(str, self.generic_args))}]"
-
-
-@dataclass
-class GenericConstraint:
-    left: ResolvedConcreteType
-    right: ResolvedConcreteType
-
-
-@dataclass(eq=False, init=False)
-class GenericType(BaseType):
-    parameters: list[str]
-
-    def constraints(self, args: list[ConcreteType]) -> list[GenericConstraint]:
-        return []
-
-    @abstractmethod
-    def _instantiate(self, args: list[ConcreteType]) -> GenericInstanceType:
-        raise NotImplementedError()
-
-    def instantiate(self, args: list[ConcreteType]) -> GenericInstanceType:
-        res = self._instantiate(args)
-        res.generic_args = args
-        res.generic_parent = self
-        return res
-
-
-@dataclass(eq=False, init=False)
-class BuiltinGenericType(GenericType):
-    constraints_: Callable[[list[ConcreteType]], list[GenericConstraint]]
-    instantiate_: Callable[[list[ConcreteType]], GenericInstanceType]
-
-    def constraints(self, args: list[ConcreteType]) -> list[GenericConstraint]:
-        return self.constraints_(args)
-
-    def _instantiate(self, args: list[ConcreteType]) -> GenericInstanceType:
-        return self.instantiate_(args)
-
-
-def create_builtin_type(name: str):
-    class CreatedType(BuiltinGenericType):
-        def __str__(self):
-            return name
-
-    res = CreatedType()
-    return res
-
-
-TY_OBJECT = None
-TY_OBJECT = create_builtin_type("object")
-TY_OBJECT.parents = []
-TY_BOOL = create_builtin_type("bool")
-TY_INT = create_builtin_type("int")
-TY_FLOAT = create_builtin_type("float")
-TY_STR = create_builtin_type("str")
-TY_BYTES = create_builtin_type("bytes")
-TY_COMPLEX = create_builtin_type("complex")
-TY_NONE = create_builtin_type("NoneType")
-
-
-def unimpl(*args, **kwargs):
-    raise NotImplementedError()
-
-
-def create_builtin_generic_type(name: str):
-    class CreatedType(BuiltinGenericType):
-        def __str__(self):
-            return name
-
-    res = CreatedType()
-    return res
-
-
-TY_LIST = create_builtin_generic_type("list")
-TY_SET = create_builtin_generic_type("set")
-TY_DICT = create_builtin_generic_type("dict")
-TY_TUPLE = create_builtin_generic_type("tuple")
-
-@dataclass(unsafe_hash=False)
-class TypeListType(ConcreteType):
-    """
-    Special type used to represent a list of types.
-
-    Used in function types: Callable[[int, int], int]
-    """
-    contents: list[ConcreteType]
-
-    def __str__(self):
-        return f"[{', '.join(map(str, self.contents))}]"
-
-@dataclass(eq=False)
-class CallableInstanceType(GenericInstanceType):
-    parameters: list[ConcreteType]
-    return_type: ConcreteType
-
-
-class CallableType(GenericType):
-    def __str__(self):
-        return "Callable"
-
-    def _instantiate(self, args: list[ConcreteType]) -> GenericInstanceType:
-        match args:
-            case [TypeListType([*args]), ret]:
-                return CallableInstanceType(args, ret)
-            case _:
-                raise ValueError
-
-
-TY_CALLABLE = CallableType()
-
-@dataclass(eq=False)
-class ClassTypeType(GenericInstanceType):
-    inner_type: BaseType
-
-class ClassType(GenericType):
-    def __str__(self):
-        return "Type"
-
-    def _instantiate(self, args: list[ConcreteType]) -> GenericInstanceType:
-        return ClassTypeType(*args)
-
-TY_TYPE = ClassType()