jaclang 0.8.4__py3-none-any.whl → 0.8.6__py3-none-any.whl

jaclang/compiler/type_system/types.py

@@ -0,0 +1,240 @@
+"""Representation of types used during type analysis."""
+
+from __future__ import annotations
+
+# Pyright Reference: packages\pyright-internal\src\analyzer\types.ts
+from abc import ABC
+from enum import IntEnum, auto
+from pathlib import Path
+from typing import ClassVar, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from jaclang.compiler.unitree import Symbol, UniScopeNode as SymbolTable
+
+
+class TypeCategory(IntEnum):
+    """Enumeration of type categories."""
+
+    Unbound = auto()  # Name is not bound to a value of any type
+    Unknown = auto()  # Implicit Any type
+    Never = auto()  # The bottom type, equivalent to an empty union
+    Any = auto()  # Type can be anything
+    Module = auto()  # Module instance
+    Class = auto()  # Class definition
+    Function = auto()  # Callable type
+    Union = auto()  # Union of two or more other types
+
+
+class TypeFlags(IntEnum):
+    """Flags to set on a type.
+
+    foo = 42  # <-- Here type of foo is `int` class, Instance type.
+    foo = int # <-- Here type of foo is `type[int]`, Instantiable is set.
+    foo: int = 42
+         ^^^------- Here the type of the expression `int` is `type[int]`
+                    That is same as the prefetched int_class that has the
+                    flag Instantiable set.
+
+                    calling convertToInstance() will return the same type
+                    with Instance flag set.
+    """
+
+    Null = 0  # Pyright use None but python can't
+
+    # This type refers to something that can be instantiated.
+    Instantiable = 1 << 0
+
+    # This type refers to something that has been instantiated.
+    Instance = 1 << 1
+
+    # This type is inferred within a py.typed source file and could be
+    # inferred differently by other type checkers.
+    Ambiguous = 1 << 2
+
+
+class ParameterCategory(IntEnum):
+    """Enumeration of parameter categories."""
+
+    Positional = auto()
+    ArgsList = auto()
+    KwargsDict = auto()
+
+
+class TypeBase(ABC):
+    """Maps to pyright's TypeBase<T> in the types.ts file.
+
+    This is the base class for all type instance of the jaclang that holds
+    information about the type's category and any additional metadata and
+    utilities to analyze type information and provide type checking.
+    """
+
+    # Each subclass should provide a class-level CATEGORY constant indicating its type category.
+    CATEGORY: ClassVar[TypeCategory]
+
+    def __init__(self, flags: TypeFlags = TypeFlags.Null) -> None:
+        """Initialize obviously."""
+        self.flags: TypeFlags = flags
+
+    @property
+    def category(self) -> TypeCategory:
+        """Returns the category of the type."""
+        return self.CATEGORY
+
+    @staticmethod
+    def unknown() -> "UnknownType":
+        """Return an instance of an unknown type."""
+        return UnknownType()
+
+    def is_instantiable(self) -> bool:
+        """Return whether the type is instantiable."""
+        return bool(self.flags & TypeFlags.Instantiable)
+
+    def is_instance(self) -> bool:
+        """Return whether the type is an instance."""
+        return bool(self.flags & TypeFlags.Instance)
+
+    def is_instantiable_class(self) -> bool:
+        """Return whether the class can be instantiated."""
+        return (self.category == TypeCategory.Class) and self.is_instantiable()
+
+    def is_class_instance(self) -> bool:
+        """Return whether the class is an instance."""
+        return (self.category == TypeCategory.Class) and self.is_instance()
+
+
+class UnboundType(TypeBase):
+    """Represents a type that is not bound to a specific value or context."""
+
+    CATEGORY: ClassVar[TypeCategory] = TypeCategory.Unbound
+
+
+class UnknownType(TypeBase):
+    """Represents a type that is not known or cannot be determined."""
+
+    CATEGORY: ClassVar[TypeCategory] = TypeCategory.Unknown
+
+
+class NeverType(TypeBase):
+    """Represents a type that can never occur."""
+
+    CATEGORY: ClassVar[TypeCategory] = TypeCategory.Never
+
+
+class AnyType(TypeBase):
+    """Represents a type that can be anything."""
+
+    CATEGORY: ClassVar[TypeCategory] = TypeCategory.Any
+
+
+class ModuleType(TypeBase):
+    """Represents a module type."""
+
+    CATEGORY: ClassVar[TypeCategory] = TypeCategory.Module
+
+    def __init__(
+        self, mod_name: str, file_uri: Path, symbol_table: SymbolTable
+    ) -> None:
+        """Initialize the class."""
+        super().__init__()
+        self.mod_name = mod_name
+        self.file_uri = file_uri
+        self.symbol_table = symbol_table
+
+
+class ClassType(TypeBase):
+    """Represents a class type."""
+
+    CATEGORY: ClassVar[TypeCategory] = TypeCategory.Class
+
+    # Pyright has both ClassDetailsShared; and ClassDetailsPriv;
+    # however we're only using shared instance and the private details
+    # will be part of the class itself.
+
+    class ClassDetailsShared:
+        """Holds the shared details of class type.
+
+        The shared detail of classes will points to the same instance across multiple clones
+        of the same class. This is needed when we do `==` between two classes, if they have the
+        same shared object, that means they both are the same class (with different context).
+        """
+
+        def __init__(
+            self,
+            class_name: str,
+            symbol_table: SymbolTable,
+            base_classes: list[TypeBase] | None = None,
+        ) -> None:
+            """Initialize obviously."""
+            self.class_name = class_name
+            self.symbol_table = symbol_table
+            self.base_classes = base_classes or []
+
+    def __init__(
+        self,
+        shared: ClassType.ClassDetailsShared,
+        flags: TypeFlags = TypeFlags.Null,
+    ) -> None:
+        """Initialize the class type."""
+        super().__init__(flags=flags)
+        self.shared = shared
+
+    def clone_as_instance(self) -> "ClassType":
+        """Clone this class type as an instance type."""
+        if self.is_instance():
+            return self
+        new_instance = ClassType(self.shared)
+
+        # TODO: There is more to this but we're not over complicating this atm.
+        new_flag = self.flags
+        new_flag = TypeFlags(new_flag & ~TypeFlags.Instantiable)
+        new_flags = TypeFlags(new_flag | TypeFlags.Instance)
+        new_instance.flags = new_flags
+
+        return new_instance
+
+    def lookup_member_symbol(self, member: str) -> Symbol | None:
+        """Lookup a member in the class type."""
+        return self.shared.symbol_table.lookup(member, deep=True)
+
+
+class Parameter:
+    """Represents a function parameter."""
+
+    def __init__(
+        self, name: str, category: ParameterCategory, param_type: TypeBase | None
+    ) -> None:
+        """Initialize obviously."""
+        super().__init__()
+        self.name = name
+        self.category = category
+        self.param_type = param_type
+
+
+class FunctionType(TypeBase):
+    """Represents a function type."""
+
+    CATEGORY: ClassVar[TypeCategory] = TypeCategory.Function
+
+    def __init__(
+        self,
+        func_name: str,
+        return_type: TypeBase | None = None,
+        parameters: list[Parameter] | None = None,
+        flags: TypeFlags = TypeFlags.Null,
+    ) -> None:
+        """Initialize obviously."""
+        super().__init__(flags=flags)
+        self.func_name = func_name
+        self.return_type = return_type
+        self.parameters = parameters or []
+
+
+class UnionType(TypeBase):
+    """Represents a union type."""
+
+    CATEGORY: ClassVar[TypeCategory] = TypeCategory.Union
+
+    def __init__(self, types: list[TypeBase]) -> None:
+        """Initialize obviously."""
+        super().__init__()
+        self.types = types

jaclang/compiler/unitree.py

@@ -30,6 +30,7 @@ from jaclang.compiler.constant import (
     SymbolType,
 )
 from jaclang.compiler.constant import DELIM_MAP, SymbolAccess, Tokens as Tok
+from jaclang.compiler.type_system.types import TypeBase
 from jaclang.utils import resolve_relative_path
 from jaclang.utils.treeprinter import (
     print_ast_tree,
@@ -209,7 +210,7 @@ class UniNode:
 
     def flatten(self) -> list[UniNode]:
         """Flatten ast."""
-        ret = [self]
+        ret: list[UniNode] = [self]
         for k in self.kid:
             ret += k.flatten()
         return ret
@@ -235,10 +236,12 @@ class Symbol:
         defn: NameAtom,
         access: SymbolAccess,
         parent_tab: UniScopeNode,
+        imported: bool = False,
     ) -> None:
         """Initialize."""
         self.defn: list[NameAtom] = [defn]
         self.uses: list[NameAtom] = []
+        self.imported: bool = imported
         defn.sym = self
         self.access: SymbolAccess = access
         self.parent_tab = parent_tab
@@ -271,7 +274,7 @@ class Symbol:
         return ".".join(out)
 
     @property
-    def fetch_sym_tab(self) -> Optional[UniScopeNode]:
+    def symbol_table(self) -> Optional[UniScopeNode]:
         """Get symbol table."""
         return self.parent_tab.find_scope(self.sym_name)
 
@@ -333,6 +336,7 @@ class UniScopeNode(UniNode):
         access_spec: Optional[AstAccessNode] | SymbolAccess = None,
         single: bool = False,
         force_overwrite: bool = False,
+        imported: bool = False,
     ) -> Optional[UniNode]:
         """Set a variable in the symbol table.
 
@@ -353,6 +357,7 @@ class UniScopeNode(UniNode):
                     else access_spec.access_type if access_spec else SymbolAccess.PUBLIC
                 ),
                 parent_tab=self,
+                imported=imported,
             )
         else:
             self.names_in_scope[node.sym_name].add_defn(node.name_spec)
@@ -386,6 +391,7 @@ class UniScopeNode(UniNode):
         access_spec: Optional[AstAccessNode] | SymbolAccess = None,
         single_decl: Optional[str] = None,
         force_overwrite: bool = False,
+        imported: bool = False,
     ) -> Optional[Symbol]:
         """Insert into symbol table."""
         if node.sym and self == node.sym.parent_tab:
@@ -395,6 +401,7 @@ class UniScopeNode(UniNode):
             single=single_decl is not None,
             access_spec=access_spec,
             force_overwrite=force_overwrite,
+            imported=imported,
         )
         self.update_py_ctx_for_def(node)
         return node.sym
@@ -715,6 +722,14 @@ class Expr(UniNode):
         self._sym_type: str = "NoType"
         self._type_sym_tab: Optional[UniScopeNode] = None
 
+        # When the type of an expression is resolved, we'll be caching
+        # the type here.
+        #
+        # TODO:
+        # 1. Find a better name for this
+        # 2. Migrate this to expr_type property
+        self.type: TypeBase | None = None
+
     @property
     def expr_type(self) -> str:
         return self._sym_type
@@ -967,8 +982,10 @@ class Module(AstDocNode, UniScopeNode):
             prog=JacProgram(),
         ).ir_out.gen.jac
 
-    def unparse(self) -> str:
-        super().unparse()
+    def unparse(self, requires_format: bool = True) -> str:
+        unparsed = super().unparse()
+        if not requires_format:
+            return unparsed
         return self.format()
 
     @staticmethod
@@ -1363,7 +1380,7 @@ class ModuleItem(AstSymbolNode):
         AstSymbolNode.__init__(
             self,
             sym_name=alias.sym_name if alias else name.sym_name,
-            name_spec=alias if alias else name,
+            name_spec=alias or name,
             sym_category=SymbolType.MOD_VAR,
         )
         self.abs_path: Optional[str] = None
@@ -1371,13 +1388,9 @@ class ModuleItem(AstSymbolNode):
     @property
     def from_parent(self) -> Import:
         """Get import parent."""
-        if (
-            not self.parent
-            or not self.parent.parent
-            or not isinstance(self.parent.parent, Import)
-        ):
+        if not self.parent or not isinstance(self.parent, Import):
             raise ValueError("Import parent not found. Not Possible.")
-        return self.parent.parent
+        return self.parent
 
     @property
     def from_mod_path(self) -> ModulePath:
@@ -1516,7 +1529,8 @@ class Archetype(
                     new_kid.append(stmt)
                 new_kid.append(self.gen_token(Tok.RBRACE))
         else:
-            new_kid.append(self.gen_token(Tok.SEMI))
+            new_kid.append(self.gen_token(Tok.LBRACE))
+            new_kid.append(self.gen_token(Tok.RBRACE))
         self.set_kids(nodes=new_kid)
         return res
 
@@ -1529,7 +1543,7 @@ class ImplDef(CodeBlockStmt, ElementStmt, ArchBlockStmt, AstSymbolNode, UniScope
         decorators: Optional[Sequence[Expr]],
         target: Sequence[NameAtom],
         spec: Sequence[Expr] | FuncSignature | EventSignature | None,
-        body: Sequence[CodeBlockStmt] | Sequence[EnumBlockStmt] | FuncCall,
+        body: Sequence[CodeBlockStmt] | Sequence[EnumBlockStmt] | Expr,
         kid: Sequence[UniNode],
         doc: Optional[String] = None,
         decl_link: Optional[UniNode] = None,
@@ -1575,7 +1589,7 @@ class ImplDef(CodeBlockStmt, ElementStmt, ArchBlockStmt, AstSymbolNode, UniScope
                     res = res and sp.normalize(deep)
             else:
                 res = res and self.spec.normalize(deep) if self.spec else res
-            if isinstance(self.body, FuncCall):
+            if isinstance(self.body, Expr):
                 res = res and self.body.normalize(deep)
             else:
                 for stmt in self.body:
@@ -1608,7 +1622,7 @@ class ImplDef(CodeBlockStmt, ElementStmt, ArchBlockStmt, AstSymbolNode, UniScope
                 new_kid.append(self.gen_token(Tok.RPAREN))
             else:
                 new_kid.append(self.spec)
-        if isinstance(self.body, FuncCall):
+        if isinstance(self.body, Expr):
             new_kid.append(self.body)
         else:
             new_kid.append(self.gen_token(Tok.LBRACE))
@@ -1781,7 +1795,7 @@ class Ability(
         is_abstract: bool,
         access: Optional[SubTag[Token]],
         signature: FuncSignature | EventSignature | None,
-        body: Sequence[CodeBlockStmt] | ImplDef | FuncCall | None,
+        body: Sequence[CodeBlockStmt] | ImplDef | Expr | None,
         kid: Sequence[UniNode],
         doc: Optional[String] = None,
         decorators: Sequence[Expr] | None = None,
@@ -1832,7 +1846,7 @@ class Ability(
 
     @property
     def is_genai_ability(self) -> bool:
-        return isinstance(self.body, FuncCall)
+        return isinstance(self.body, Expr)
 
     def get_pos_argc_range(self) -> tuple[int, int]:
         """Get the range of positional arguments for this ability.
@@ -2285,8 +2299,7 @@ class ExprStmt(CodeBlockStmt):
         CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = True) -> bool:
-        if deep:
-            res = self.expr.normalize(deep)
+        res = self.expr.normalize(deep) if deep else False
         new_kid: list[UniNode] = []
         if self.in_fstring:
             new_kid.append(self.expr)
@@ -3488,7 +3501,7 @@ class InnerCompr(AstAsyncNode, UniScopeNode):
         return res
 
 
-class ListCompr(AtomExpr):
+class ListCompr(AtomExpr, UniScopeNode):
     """ListCompr node type for Jac Ast."""
 
     def __init__(
@@ -3502,6 +3515,7 @@ class ListCompr(AtomExpr):
         UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
         AstSymbolStubNode.__init__(self, sym_type=SymbolType.SEQUENCE)
+        UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
 
     def normalize(self, deep: bool = False) -> bool:
         res = True
@@ -3702,14 +3716,12 @@ class FuncCall(Expr):
         self,
         target: Expr,
         params: Sequence[Expr | KWPair] | None,
-        genai_call: Optional[FuncCall],
+        genai_call: Optional[Expr],
         kid: Sequence[UniNode],
-        body_genai_call: Optional[FuncCall] = None,
     ) -> None:
         self.target = target
         self.params = list(params) if params else []
         self.genai_call = genai_call
-        self.body_genai_call = body_genai_call
         UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
 
@@ -4649,7 +4661,7 @@ class String(Literal):
 
     def unparse(self) -> str:
         super().unparse()
-        return repr(self.value)
+        return self.value
 
 
 class Bool(Literal):