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

jaclang/compiler/type_system/type_utils.py

@@ -3,6 +3,11 @@
 PyrightReference: packages/pyright-internal/src/analyzer/typeUtils.ts
 """
 
+from dataclasses import dataclass
+from enum import Enum
+
+import jaclang.compiler.unitree as uni
+from jaclang.compiler.constant import Tokens as Tok
 from jaclang.compiler.unitree import Symbol
 
 from . import types
@@ -39,3 +44,244 @@ class ClassMember:
         # True if member lookup skipped an undeclared (inferred) type
         # in a subclass before finding a declared type in a base class
         self.skipped_undeclared_type = False
+
+
+def compute_mro_linearization(cls: types.ClassType) -> None:
+    """Compute the method resolution order (MRO) for a class type.
+
+    This uses the C3 linearization algorithm to compute the MRO.
+    See https://www.python.org/download/releases/2.3/mro/
+    """
+    if cls.shared.mro:
+        return
+
+    # FIXME: This is an ad-hoc implementation to make the MRO works
+    # and it'll cover the 90% or more of the user cases.
+
+    # Computer MRO for base classes first
+    cls.shared.mro.append(cls)
+    for base in cls.shared.base_classes:
+        if isinstance(base, types.ClassType):
+            compute_mro_linearization(base)
+
+    # Then add base classes and their MROs
+    for base in cls.shared.base_classes:
+        if isinstance(base, types.ClassType):
+            for mro_cls in base.shared.mro:
+                if mro_cls not in cls.shared.mro:
+                    cls.shared.mro.append(mro_cls)
+
+
+# In pyright, this class lives in the parameterUtils.ts however we're
+# putting it here for now and if the scale of the code grows we can
+# split it into a separate file.
+class ParamAssignmentTracker:
+    """Tracks parameter assignments for function calls.
+
+    This class helps in tracking which parameters have been matched
+    with arguments in a function call. It supports positional, named,
+    *args, and **kwargs arguments.
+    """
+
+    def __init__(self, params: list[types.Parameter]) -> None:
+        """Initialize obviously."""
+        self.params = params
+        self.curr_param_idx = 0
+        self.matched_params: set[types.Parameter] = set()
+
+        # Quick access to vararg and kwarg parameters
+        self.varargs: types.Parameter | None = None
+        self.kwargs: types.Parameter | None = None
+
+        # "Cache" vararg and kwarg parameters for quick access
+        for param in self.params:
+            if param.param_kind == types.ParamKind.VARARG:
+                self.varargs = param
+            elif param.param_kind == types.ParamKind.KWARG:
+                self.kwargs = param
+
+    def lookup_named_parameter(self, param_name: str) -> types.Parameter | None:
+        """Lookup a named parameter by name and if any match is found we mark it as such."""
+        for param in self.params:
+            # User try to pass a positional only parameter with a name, should be an error.
+            if (param.param_kind == types.ParamKind.POSONLY) and (
+                param_name == param.name
+            ):
+                self.matched_params.add(param)
+                raise Exception(
+                    f"Positional only parameter '{param.name}' cannot be matched with a named argument"
+                )
+            if param.param_kind not in (types.ParamKind.NORMAL, types.ParamKind.KWONLY):
+                continue
+            if param.name == param_name:
+                if param in self.matched_params:
+                    raise Exception(f"Parameter '{param.name}' already matched")
+                self.matched_params.add(param)
+                return param
+        # If we reached here, there is no named parameter to match with
+        # however if we have **kwargs, we can match it with that, if that
+        # also None, it'll return None indicating no match.
+        return self.kwargs
+
+    def _mark_all_named_params_as_matched(self) -> None:
+        """Mark all named parameters as matched."""
+        for param in self.params:
+            if param.param_kind in (
+                types.ParamKind.NORMAL,
+                types.ParamKind.KWONLY,
+                types.ParamKind.KWARG,
+            ):
+                self.matched_params.add(param)
+
+    def _mark_all_positional_params_as_matched(self) -> None:
+        """Mark all positional parameters as matched."""
+        for param in self.params:
+            if param.param_kind in (
+                types.ParamKind.POSONLY,
+                types.ParamKind.NORMAL,
+                types.ParamKind.VARARG,
+            ):
+                self.matched_params.add(param)
+        self.curr_param_idx = -1
+
+    def match_named_argument(self, arg: uni.KWPair) -> types.Parameter | None:
+        """Match a named argument to a parameter."""
+        if arg.key is None:
+            # **{} <- This can be matched with any named parameter
+            # in the current parameter list.
+            self._mark_all_named_params_as_matched()
+            return None
+        else:
+            if param := self.lookup_named_parameter(arg.key.sym_name):
+                return param
+            raise Exception(
+                f"Named argument '{arg.key.sym_name}' does not match any parameter"
+            )
+
+    def match_positional_argument(self, arg: uni.Expr) -> types.Parameter | None:
+        """Match a positional argument to a parameter."""
+        # NOTE: The curr_param_idx can be -1 only when a unpack (*expr) is passed
+        # at that point there is no reliable way to match the remaining positional
+        # arguments after the unpack, so we either match with *args or not match with
+        # anything.
+        if self.curr_param_idx == -1:
+            return self.varargs
+
+        if isinstance(arg, uni.UnaryExpr) and arg.op.value == Tok.STAR_MUL:
+            self._mark_all_positional_params_as_matched()
+            return None
+        else:
+            if self.curr_param_idx < len(self.params):
+                param = self.params[self.curr_param_idx]
+                if param.param_kind == types.ParamKind.VARARG:
+                    self.matched_params.add(param)
+                    return param
+                if param.param_kind in (
+                    types.ParamKind.NORMAL,
+                    types.ParamKind.POSONLY,
+                ):
+                    self.curr_param_idx += 1
+                    self.matched_params.add(param)
+                    return param
+
+            # If we reached here, there is no parameter to match with
+            raise Exception("Too many positional arguments")
+
+    def get_unmatched_required_params(self) -> list[types.Parameter]:
+        """Check if there are any unmatched required parameters."""
+        ret: list[types.Parameter] = []
+        for param in self.params:
+            if (
+                param not in self.matched_params
+                and param.default_value is None
+                and param.param_kind
+                not in (types.ParamKind.VARARG, types.ParamKind.KWARG)
+            ):
+                ret.append(param)
+        return ret
+
+
+# -----------------------------------------------------------------------------
+# Completion item utils
+# -----------------------------------------------------------------------------
+
+
+@dataclass
+class CompletionItem:
+    """A completion item."""
+
+    label: str
+    kind: int
+    detail: str | None = None
+
+
+class CompletionItemKind(int, Enum):
+    """The kind of a completion entry."""
+
+    Text = 1
+    Method = 2
+    Function = 3
+    Constructor = 4
+    Field = 5
+    Variable = 6
+    Class = 7
+    Interface = 8
+    Module = 9
+    Property = 10
+    Unit = 11
+    Value = 12
+    Enum = 13
+    Keyword = 14
+    Snippet = 15
+    Color = 16
+    File = 17
+    Reference = 18
+    Folder = 19
+    EnumMember = 20
+    Constant = 21
+    Struct = 22
+    Event = 23
+    Operator = 24
+    TypeParameter = 25
+
+
+def completion_kind_from_sym(sym: Symbol) -> int:
+    """Get the completion item kind from a symbol."""
+    match sym.decl.name_of:
+        case uni.ModulePath():
+            return CompletionItemKind.Module
+        case uni.Ability():
+            return CompletionItemKind.Function
+        case uni.Archetype():
+            return CompletionItemKind.Class
+        case uni.Enum():
+            return CompletionItemKind.Enum
+        case uni.HasVar():
+            return CompletionItemKind.Variable
+    return CompletionItemKind.Text
+
+
+def get_completion_items(ty: types.TypeBase | uni.UniScopeNode) -> list[CompletionItem]:
+    """Return a list of completion items for the type."""
+    ret = []
+
+    if isinstance(ty, uni.UniScopeNode):
+        scope = ty
+        while scope:
+            for name, sym in scope.names_in_scope.items():
+                kind = completion_kind_from_sym(sym)
+                ret.append(CompletionItem(label=name, kind=kind))
+            scope = scope.parent_scope
+
+    elif isinstance(ty, types.ClassType):
+        for cls in ty.shared.mro:
+            for name, sym in cls.shared.symbol_table.names_in_scope.items():
+                kind = completion_kind_from_sym(sym)
+                ret.append(CompletionItem(label=name, kind=kind))
+
+    elif isinstance(ty, types.ModuleType):
+        for name, sym in ty.symbol_table.names_in_scope.items():
+            kind = completion_kind_from_sym(sym)
+            ret.append(CompletionItem(label=name, kind=kind))
+
+    return ret

jaclang/compiler/type_system/types.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from typing import ClassVar, TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from jaclang.compiler.unitree import Symbol, UniScopeNode as SymbolTable
+    from jaclang.compiler.unitree import Expr, Symbol, UniScopeNode as SymbolTable
 
 
 class TypeCategory(IntEnum):
@@ -163,11 +163,25 @@ class ClassType(TypeBase):
             class_name: str,
             symbol_table: SymbolTable,
             base_classes: list[TypeBase] | None = None,
+            is_builtin_class: bool = False,
         ) -> None:
             """Initialize obviously."""
             self.class_name = class_name
             self.symbol_table = symbol_table
             self.base_classes = base_classes or []
+            self.mro: list[ClassType] = []
+
+            # In pyright classes have ClassTypeFlags to indicate if it's builtin
+            # along with other information, I'm adding only the builtin flag for now.
+            # add the other flags if needed in the future with a bitmask enum.
+            #
+            # export const enum ClassTypeFlags {
+            #   ...
+            #   // Class is defined in the "builtins" or "typing" file.
+            #   BuiltIn = 1 << 0,
+            #   ...
+            #
+            self.is_builtin_class = is_builtin_class
 
     def __init__(
         self,
@@ -178,6 +192,10 @@ class ClassType(TypeBase):
         super().__init__(flags=flags)
         self.shared = shared
 
+    def __str__(self) -> str:
+        """Return a string representation of the class type."""
+        return f"<class {self.shared.class_name}>"
+
     def clone_as_instance(self) -> "ClassType":
         """Clone this class type as an instance type."""
         if self.is_instance():
@@ -196,19 +214,57 @@ class ClassType(TypeBase):
         """Lookup a member in the class type."""
         return self.shared.symbol_table.lookup(member, deep=True)
 
+    def is_builtin(self, class_name: str | None = None) -> bool:
+        """
+        Return true if this class is a builtin class.
+
+        If class_name is provided, also check if the class name matches.
+        """
+        if not self.shared.is_builtin_class:
+            return False
+        if class_name is not None:
+            return self.shared.class_name == class_name
+        return True
+
+
+class ParamKind(IntEnum):
+    """Enumeration of parameter kinds."""
+
+    POSONLY = 0
+    NORMAL = 1
+    VARARG = 2
+    KWONLY = 3
+    KWARG = 4
+
 
 class Parameter:
     """Represents a function parameter."""
 
     def __init__(
-        self, name: str, category: ParameterCategory, param_type: TypeBase | None
+        self,
+        name: str,
+        category: ParameterCategory,
+        param_type: TypeBase | None,
+        default_value: Expr | None = None,
+        is_self: bool = False,
+        param_kind: ParamKind = ParamKind.NORMAL,
     ) -> None:
         """Initialize obviously."""
         super().__init__()
         self.name = name
         self.category = category
+        self.default_value = default_value
         self.param_type = param_type
 
+        # This will set to true if the parameter is `self`. In jaclang self
+        # in the context of obj, node, edge, walker methods is not required to
+        # be explicitly defined. However, in the `class` methods it should be
+        # explicitly defined.
+        self.is_self = is_self
+
+        # Kind is wheather it's normal, posonly, vararg, kwonly, kwarg.
+        self.param_kind: ParamKind = param_kind
+
 
 class FunctionType(TypeBase):
     """Represents a function type."""

jaclang/compiler/unitree.py

@@ -7,6 +7,7 @@ import builtins
 import os
 from copy import copy
 from dataclasses import dataclass
+from enum import IntEnum
 from hashlib import md5
 from types import EllipsisType
 from typing import (
@@ -306,7 +307,6 @@ class UniScopeNode(UniNode):
         self.parent_scope = parent_scope
         self.kid_scope: list[UniScopeNode] = []
         self.names_in_scope: dict[str, Symbol] = {}
-        self.inherited_scope: list[InheritedSymbolTable] = []
 
     def get_type(self) -> SymbolType:
         """Get type."""
@@ -322,10 +322,6 @@ class UniScopeNode(UniNode):
         """Lookup a variable in the symbol table."""
         if name in self.names_in_scope:
             return self.names_in_scope[name]
-        for i in self.inherited_scope:
-            found = i.lookup(name, deep=False)
-            if found:
-                return found
         if deep and self.parent_scope:
             return self.parent_scope.lookup(name, deep)
         return None
@@ -369,9 +365,6 @@ class UniScopeNode(UniNode):
         for k in self.kid_scope:
             if k.scope_name == name:
                 return k
-        for k2 in self.inherited_scope:
-            if k2.base_symbol_table.scope_name == name:
-                return k2.base_symbol_table
         return None
 
     def link_kid_scope(self, key_node: UniScopeNode) -> UniScopeNode:
@@ -489,22 +482,6 @@ class UniScopeNode(UniNode):
 
             fix(node)
 
-    def inherit_baseclasses_sym(self, node: Archetype | Enum) -> None:
-        """Inherit base classes symbol tables."""
-        if node.base_classes:
-            for base_cls in node.base_classes:
-                if (
-                    isinstance(base_cls, AstSymbolNode)
-                    and (found := self.use_lookup(base_cls))
-                    and found
-                ):
-                    found_tab = found.decl.sym_tab
-                    inher_sym_tab = InheritedSymbolTable(
-                        base_symbol_table=found_tab, load_all_symbols=True, symbols=[]
-                    )
-                    self.inherited_scope.append(inher_sym_tab)
-                    base_cls.name_spec.name_of = found.decl.name_of
-
     def sym_pp(self, depth: Optional[int] = None) -> str:
         """Pretty print."""
         return print_symtab_tree(root=self, depth=depth)
@@ -521,31 +498,6 @@ class UniScopeNode(UniNode):
         return out
 
 
-class InheritedSymbolTable:
-    """Inherited symbol table."""
-
-    def __init__(
-        self,
-        base_symbol_table: UniScopeNode,
-        load_all_symbols: bool = False,  # This is needed for python imports
-        symbols: Optional[list[str]] = None,
-    ) -> None:
-        """Initialize."""
-        self.base_symbol_table: UniScopeNode = base_symbol_table
-        self.load_all_symbols: bool = load_all_symbols
-        self.symbols: list[str] = symbols if symbols else []
-
-    def lookup(self, name: str, deep: bool = False) -> Optional[Symbol]:
-        """Lookup a variable in the symbol table."""
-        if self.load_all_symbols:
-            return self.base_symbol_table.lookup(name, deep)
-        else:
-            if name in self.symbols:
-                return self.base_symbol_table.lookup(name, deep)
-            else:
-                return None
-
-
 class AstSymbolNode(UniNode):
     """Nodes that have link to a symbol in symbol table."""
 
@@ -922,6 +874,12 @@ class Module(AstDocNode, UniScopeNode):
         self.src_terminals: list[Token] = terminals
         self.is_raised_from_py: bool = False
 
+        # We continue to parse a module even if there are syntax errors
+        # so that we can report more errors in a single pass and support
+        # features like code completion, lsp, format etc. This flag
+        # indicates if there were syntax errors during parsing.
+        self.has_syntax_errors: bool = False
+
         UniNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
         UniScopeNode.__init__(self, name=self.name)
@@ -1441,23 +1399,12 @@ class Archetype(
             self,
             sym_name=name.value,
             name_spec=name,
-            sym_category=(
-                SymbolType.OBJECT_ARCH
-                if arch_type.name == Tok.KW_OBJECT
-                else (
-                    SymbolType.NODE_ARCH
-                    if arch_type.name == Tok.KW_NODE
-                    else (
-                        SymbolType.EDGE_ARCH
-                        if arch_type.name == Tok.KW_EDGE
-                        else (
-                            SymbolType.WALKER_ARCH
-                            if arch_type.name == Tok.KW_WALKER
-                            else SymbolType.TYPE
-                        )
-                    )
-                )
-            ),
+            sym_category={
+                Tok.KW_OBJECT.value: SymbolType.OBJECT_ARCH,
+                Tok.KW_NODE.value: SymbolType.NODE_ARCH,
+                Tok.KW_EDGE.value: SymbolType.EDGE_ARCH,
+                Tok.KW_WALKER.value: SymbolType.WALKER_ARCH,
+            }.get(arch_type.name, SymbolType.TYPE),
         )
         AstImplNeedingNode.__init__(self, body=body)
         AstAccessNode.__init__(self, access=access)
@@ -1941,11 +1888,19 @@ class FuncSignature(UniNode):
 
     def __init__(
         self,
+        posonly_params: Sequence[ParamVar],
         params: Sequence[ParamVar] | None,
+        varargs: Optional[ParamVar],
+        kwonlyargs: Sequence[ParamVar],
+        kwargs: Optional[ParamVar],
         return_type: Optional[Expr],
         kid: Sequence[UniNode],
     ) -> None:
+        self.posonly_params: list[ParamVar] = list(posonly_params)
         self.params: list[ParamVar] = list(params) if params else []
+        self.varargs = varargs
+        self.kwonlyargs: list[ParamVar] = list(kwonlyargs)
+        self.kwargs = kwargs
         self.return_type = return_type
         UniNode.__init__(self, kid=kid)
 
@@ -1953,14 +1908,36 @@ class FuncSignature(UniNode):
         res = True
         is_lambda = self.parent and isinstance(self.parent, LambdaExpr)
         if deep:
+            for prm in self.posonly_params:
+                res = res and prm.normalize(deep)
             for prm in self.params:
                 res = res and prm.normalize(deep)
             res = res and self.return_type.normalize(deep) if self.return_type else res
         new_kid: list[UniNode] = [self.gen_token(Tok.LPAREN)] if not is_lambda else []
-        for idx, prm in enumerate(self.params):
-            new_kid.append(prm)
-            if idx < len(self.params) - 1:
+        if self.posonly_params:
+            for prm in self.posonly_params:
+                new_kid.append(prm)
                 new_kid.append(self.gen_token(Tok.COMMA))
+            new_kid.append(self.gen_token(Tok.DIV))
+            new_kid.append(self.gen_token(Tok.COMMA))
+        if self.params:
+            for prm in self.params:
+                new_kid.append(prm)
+                new_kid.append(self.gen_token(Tok.COMMA))
+        if self.varargs:
+            new_kid.append(self.varargs)
+            new_kid.append(self.gen_token(Tok.COMMA))
+        elif self.kwonlyargs:
+            new_kid.append(self.gen_token(Tok.STAR_MUL))
+            new_kid.append(self.gen_token(Tok.COMMA))
+        for prm in self.kwonlyargs:
+            new_kid.append(prm)
+            new_kid.append(self.gen_token(Tok.COMMA))
+        if self.kwargs:
+            new_kid.append(self.kwargs)
+            new_kid.append(self.gen_token(Tok.COMMA))
+        if new_kid and isinstance(new_kid[-1], Token) and new_kid[-1].name == Tok.COMMA:
+            new_kid = new_kid[:-1]
         if not is_lambda:
             new_kid.append(self.gen_token(Tok.RPAREN))
         if self.return_type:
@@ -1969,6 +1946,16 @@ class FuncSignature(UniNode):
         self.set_kids(nodes=new_kid)
         return res
 
+    def get_parameters(self) -> list[ParamVar]:
+        """Return all parameters in the declared order."""
+        params = self.posonly_params + self.params
+        if self.varargs:
+            params.append(self.varargs)
+        params += self.kwonlyargs
+        if self.kwargs:
+            params.append(self.kwargs)
+        return params
+
     @property
     def is_static(self) -> bool:
         return (isinstance(self.parent, Ability) and self.parent.is_static) or (
@@ -2025,6 +2012,16 @@ class EventSignature(WalkerStmtOnlyNode):
         return res
 
 
+class ParamKind(IntEnum):
+    """Parameter kinds."""
+
+    POSONLY = 0
+    NORMAL = 1
+    VARARG = 2
+    KWONLY = 3
+    KWARG = 4
+
+
 class ParamVar(AstSymbolNode, AstTypedVarNode):
     """ParamVar node type for Jac Ast."""
 
@@ -2038,6 +2035,7 @@ class ParamVar(AstSymbolNode, AstTypedVarNode):
     ) -> None:
         self.name = name
         self.unpack = unpack
+        self.param_kind = ParamKind.NORMAL
         self.value = value
         UniNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
@@ -2048,6 +2046,14 @@ class ParamVar(AstSymbolNode, AstTypedVarNode):
         )
         AstTypedVarNode.__init__(self, type_tag=type_tag)
 
+    @property
+    def is_vararg(self) -> bool:
+        return bool((self.unpack) and (self.unpack.name == Tok.STAR_MUL.name))
+
+    @property
+    def is_kwargs(self) -> bool:
+        return bool((self.unpack) and (self.unpack.name == Tok.STAR_POW.name))
+
     def normalize(self, deep: bool = True) -> bool:
         res = True
         if deep:
@@ -2687,31 +2693,6 @@ class AssertStmt(CodeBlockStmt):
         return res
 
 
-class CheckStmt(CodeBlockStmt):
-    """CheckStmt node type for Jac Ast."""
-
-    def __init__(
-        self,
-        target: Expr,
-        kid: Sequence[UniNode],
-    ) -> None:
-        self.target = target
-        UniNode.__init__(self, kid=kid)
-        CodeBlockStmt.__init__(self)
-
-    def normalize(self, deep: bool = False) -> bool:
-        res = True
-        if deep:
-            res = self.target.normalize(deep)
-        new_kid: list[UniNode] = [
-            self.gen_token(Tok.KW_CHECK),
-            self.target,
-            self.gen_token(Tok.SEMI),
-        ]
-        self.set_kids(nodes=new_kid)
-        return res
-
-
 class CtrlStmt(CodeBlockStmt):
     """CtrlStmt node type for Jac Ast."""
 
@@ -3831,10 +3812,12 @@ class EdgeRefTrailer(Expr):
         self,
         chain: list[Expr | FilterCompr],
         edges_only: bool,
+        is_async: bool,
         kid: Sequence[UniNode],
     ) -> None:
         self.chain = chain
         self.edges_only = edges_only
+        self.is_async = is_async
         UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
 
@@ -3844,6 +3827,8 @@ class EdgeRefTrailer(Expr):
             res = res and expr.normalize(deep)
         new_kid: list[UniNode] = []
         new_kid.append(self.gen_token(Tok.LSQUARE))
+        if self.is_async:
+            new_kid.append(self.gen_token(Tok.KW_ASYNC))
         if self.edges_only:
             new_kid.append(self.gen_token(Tok.KW_EDGE))
         new_kid.extend(self.chain)