jaclang 0.8.7__py3-none-any.whl → 0.8.9__py3-none-any.whl

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:
@@ -2161,7 +2167,7 @@ class HasVar(AstSymbolNode, AstTypedVarNode):
         return res
 
 
-class TypedCtxBlock(CodeBlockStmt, UniScopeNode):
+class TypedCtxBlock(CodeBlockStmt, WalkerStmtOnlyNode, UniScopeNode):
     """TypedCtxBlock node type for Jac Ast."""
 
     def __init__(
@@ -2175,6 +2181,7 @@ class TypedCtxBlock(CodeBlockStmt, UniScopeNode):
         UniNode.__init__(self, kid=kid)
         UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
         CodeBlockStmt.__init__(self)
+        WalkerStmtOnlyNode.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
         res = True
@@ -2687,31 +2694,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."""
 
@@ -3248,13 +3230,21 @@ class FString(AtomExpr):
             for part in self.parts:
                 res = res and part.normalize(deep)
         new_kid: list[UniNode] = []
-        is_single_quote = (
-            isinstance(self.kid[0], Token) and self.kid[0].name == Tok.FSTR_SQ_START
-        )
-        if is_single_quote:
-            new_kid.append(self.gen_token(Tok.FSTR_SQ_START))
+        # Determine quote type from first token
+        start_token = self.kid[0] if isinstance(self.kid[0], Token) else None
+        if start_token:
+            if start_token.name == Tok.FSTR_SQ_TRIPLE_START:
+                start_tok, end_tok = Tok.FSTR_SQ_TRIPLE_START, Tok.FSTR_SQ_TRIPLE_END
+            elif start_token.name == Tok.FSTR_TRIPLE_START:
+                start_tok, end_tok = Tok.FSTR_TRIPLE_START, Tok.FSTR_TRIPLE_END
+            elif start_token.name == Tok.FSTR_SQ_START:
+                start_tok, end_tok = Tok.FSTR_SQ_START, Tok.FSTR_SQ_END
+            else:
+                start_tok, end_tok = Tok.FSTR_START, Tok.FSTR_END
         else:
-            new_kid.append(self.gen_token(Tok.FSTR_START))
+            start_tok, end_tok = Tok.FSTR_START, Tok.FSTR_END
+
+        new_kid.append(self.gen_token(start_tok))
         for i in self.parts:
             if isinstance(i, String):
                 i.value = (
@@ -3265,10 +3255,7 @@ class FString(AtomExpr):
                 new_kid.append(self.gen_token(Tok.LBRACE))
                 new_kid.append(i)
                 new_kid.append(self.gen_token(Tok.RBRACE))
-        if is_single_quote:
-            new_kid.append(self.gen_token(Tok.FSTR_SQ_END))
-        else:
-            new_kid.append(self.gen_token(Tok.FSTR_END))
+        new_kid.append(self.gen_token(end_tok))
         self.set_kids(nodes=new_kid)
         return res
 
@@ -3731,7 +3718,10 @@ class FuncCall(Expr):
             res = self.target.normalize(deep)
             for prm in self.params:
                 res = res and prm.normalize(deep)
-        new_kids = [self.target, self.gen_token(Tok.LPAREN, "(")]
+        new_kids: list[UniNode] = [self.target]
+        is_gencompr = len(self.params) == 1 and isinstance(self.params[0], GenCompr)
+        if not is_gencompr:
+            new_kids.append(self.gen_token(Tok.LPAREN))
         for i, prm in enumerate(self.params):
             new_kids.append(prm)
             if i < len(self.params) - 1:
@@ -3739,7 +3729,8 @@ class FuncCall(Expr):
         if self.genai_call:
             new_kids.append(self.gen_token(Tok.KW_BY))
             new_kids.append(self.genai_call)
-        new_kids.append(self.gen_token(Tok.RPAREN, ")"))
+        if not is_gencompr:
+            new_kids.append(self.gen_token(Tok.RPAREN, ")"))
         self.set_kids(nodes=new_kids)
         return res
 
@@ -3831,10 +3822,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 +3837,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)