jaclang 0.7.5__py3-none-any.whl → 0.7.6__py3-none-any.whl

jaclang/compiler/absyntree.py

@@ -3,24 +3,38 @@
 from __future__ import annotations
 
 import ast as ast3
+import builtins
 import os
 from hashlib import md5
 from types import EllipsisType
-from typing import Any, Callable, Generic, Optional, Sequence, Type, TypeVar
+from typing import (
+    Any,
+    Callable,
+    Generic,
+    Optional,
+    Sequence,
+    TYPE_CHECKING,
+    Type,
+    TypeVar,
+)
+
 
 from jaclang.compiler import TOKEN_MAP
 from jaclang.compiler.codeloc import CodeGenTarget, CodeLocInfo
-from jaclang.compiler.constant import Constants as Con, EdgeDir
-from jaclang.compiler.constant import DELIM_MAP, Tokens as Tok
-from jaclang.compiler.semtable import SemRegistry
-from jaclang.compiler.symtable import (
-    Symbol,
-    SymbolAccess,
-    SymbolTable,
+from jaclang.compiler.constant import (
+    Constants as Con,
+    EdgeDir,
+    JacSemTokenModifier as SemTokMod,
+    JacSemTokenType as SemTokType,
     SymbolType,
 )
+from jaclang.compiler.constant import DELIM_MAP, SymbolAccess, Tokens as Tok
+from jaclang.compiler.semtable import SemRegistry
 from jaclang.utils.treeprinter import dotgen_ast_tree, print_ast_tree
 
+if TYPE_CHECKING:
+    from jaclang.compiler.symtable import Symbol, SymbolTable
+
 
 class AstNode:
     """Abstract syntax tree node for Jac."""
@@ -29,12 +43,35 @@ class AstNode:
         """Initialize ast."""
         self.parent: Optional[AstNode] = None
         self.kid: list[AstNode] = [x.set_parent(self) for x in kid]
-        self.sym_tab: Optional[SymbolTable] = None
+        self._sym_tab: Optional[SymbolTable] = None
         self._sub_node_tab: dict[type, list[AstNode]] = {}
+        self._in_mod_nodes: list[AstNode] = []
         self.gen: CodeGenTarget = CodeGenTarget()
         self.meta: dict[str, str] = {}
         self.loc: CodeLocInfo = CodeLocInfo(*self.resolve_tok_range())
 
+    @property
+    def sym_tab(self) -> SymbolTable:
+        """Get symbol table."""
+        # sym_tab should never be accessed without being set in codebase
+        if not self._sym_tab:
+            import traceback
+
+            if self.parent:
+                print(f"Parent: {self.parent.pp()}")
+            print("Node: ", self.pp())
+            stack_trace = traceback.format_stack()
+            print("".join(stack_trace))
+            raise ValueError(
+                f"Symbol table not set for {type(self).__name__}. Impossible."
+            )
+        return self._sym_tab
+
+    @sym_tab.setter
+    def sym_tab(self, sym_tab: SymbolTable) -> None:
+        """Set symbol table."""
+        self._sym_tab = sym_tab
+
     def add_kids_left(
         self, nodes: Sequence[AstNode], pos_update: bool = True
     ) -> AstNode:
@@ -352,6 +389,17 @@ class AstImplOnlyNode(CodeBlockStmt, ElementStmt, AstSymbolNode):
             sym_category=SymbolType.IMPL,
         )
 
+    @property
+    def sym_tab(self) -> SymbolTable:
+        """Get symbol table."""
+        return super().sym_tab
+
+    @sym_tab.setter
+    def sym_tab(self, sym_tab: SymbolTable) -> None:
+        """Set symbol table."""
+        self._sym_tab = sym_tab
+        self.name_spec._sym_tab = sym_tab
+
     def create_impl_name_node(self) -> Name:
         """Create impl name."""
         ret = Name(
@@ -451,6 +499,41 @@ class NameAtom(AtomExpr, EnumBlockStmt):
         """Set type symbol table."""
         self._type_sym_tab = type_sym_tab
 
+    @property
+    def sem_token(self) -> Optional[tuple[SemTokType, SemTokMod]]:
+        """Resolve semantic token."""
+        if isinstance(self.name_of, BuiltinType):
+            return SemTokType.CLASS, SemTokMod.DECLARATION
+        name_of = (
+            self.sym.decl.name_of
+            if self.sym and not isinstance(self.sym.decl.name_of, Name)
+            else self.name_of
+        )
+        if isinstance(name_of, ModulePath):
+            return SemTokType.NAMESPACE, SemTokMod.DEFINITION
+        if isinstance(name_of, Architype):
+            return SemTokType.CLASS, SemTokMod.DECLARATION
+        if isinstance(name_of, Enum):
+            return SemTokType.ENUM, SemTokMod.DECLARATION
+        if isinstance(name_of, Ability) and name_of.is_method:
+            return SemTokType.METHOD, SemTokMod.DECLARATION
+        if isinstance(name_of, (Ability, Test)):
+            return SemTokType.FUNCTION, SemTokMod.DECLARATION
+        if isinstance(name_of, ParamVar):
+            return SemTokType.PARAMETER, SemTokMod.DECLARATION
+        if self.sym and self.sym_name.isupper():
+            return SemTokType.VARIABLE, SemTokMod.READONLY
+        if (
+            self.sym
+            and self.sym.decl.name_of == self.sym.decl
+            and self.sym_name in dir(builtins)
+            and callable(getattr(builtins, self.sym_name))
+        ):
+            return SemTokType.FUNCTION, SemTokMod.DEFINITION
+        if self.sym:
+            return SemTokType.PROPERTY, SemTokMod.DEFINITION
+        return None
+
 
 class ArchSpec(ElementStmt, CodeBlockStmt, AstSymbolNode, AstDocNode, AstSemStrNode):
     """ArchSpec node type for Jac Ast."""
@@ -558,7 +641,10 @@ class Module(AstDocNode):
     @property
     def annexable_by(self) -> Optional[str]:
         """Get annexable by."""
-        if not self.stub_only and self.loc.mod_path.endswith("impl.jac"):
+        if not self.stub_only and (
+            self.loc.mod_path.endswith("impl.jac")
+            or self.loc.mod_path.endswith("test.jac")
+        ):
             head_mod_name = self.name.split(".")[0]
             potential_path = os.path.join(
                 os.path.dirname(self.loc.mod_path),
@@ -566,7 +652,8 @@ class Module(AstDocNode):
             )
             if os.path.exists(potential_path):
                 return potential_path
-            if os.path.split(os.path.dirname(self.loc.mod_path))[-1].endswith(".impl"):
+            annex_dir = os.path.split(os.path.dirname(self.loc.mod_path))[-1]
+            if annex_dir.endswith(".impl") or annex_dir.endswith(".test"):
                 head_mod_name = os.path.split(os.path.dirname(self.loc.mod_path))[
                     -1
                 ].split(".")[0]
@@ -821,13 +908,12 @@ class ModulePath(AstSymbolNode):
         level: int,
         alias: Optional[Name],
         kid: Sequence[AstNode],
-        sub_module: Optional[Module] = None,
     ) -> None:
         """Initialize module path node."""
         self.path = path
         self.level = level
         self.alias = alias
-        self.sub_module = sub_module
+        self.sub_module: Optional[Module] = None
 
         name_spec = alias if alias else path[0] if path else None
         if not isinstance(name_spec, Name):
@@ -880,12 +966,11 @@ class ModuleItem(AstSymbolNode):
         name: Name,
         alias: Optional[Name],
         kid: Sequence[AstNode],
-        sub_module: Optional[Module] = None,
     ) -> None:
         """Initialize module item node."""
         self.name = name
         self.alias = alias
-        self.sub_module = sub_module
+        self.sub_module: Optional[Module] = None
         AstNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
             self,
@@ -894,6 +979,24 @@ class ModuleItem(AstSymbolNode):
             sym_category=SymbolType.MOD_VAR,
         )
 
+    @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)
+        ):
+            raise ValueError("Import parent not found. Not Possible.")
+        return self.parent.parent
+
+    @property
+    def from_mod_path(self) -> ModulePath:
+        """Get relevant module path."""
+        if not self.from_parent.from_loc:
+            raise ValueError("Module items should have module path. Not Possible.")
+        return self.from_parent.from_loc
+
     def normalize(self, deep: bool = False) -> bool:
         """Normalize module item node."""
         res = True
@@ -1149,6 +1252,7 @@ class Ability(
     ElementStmt,
     AstAsyncNode,
     ArchBlockStmt,
+    EnumBlockStmt,
     CodeBlockStmt,
     AstSemStrNode,
     AstImplNeedingNode,
@@ -1195,6 +1299,17 @@ class Ability(
         """Check if is func."""
         return self.signature.is_method
 
+    @property
+    def owner_method(self) -> Optional[Architype | Enum]:
+        """Check if is owner method."""
+        return (
+            self.parent.parent
+            if self.parent
+            and self.parent.parent
+            and isinstance(self.parent.parent, (Architype, Enum))
+            else None
+        )
+
     @property
     def is_genai_ability(self) -> bool:
         """Check if is genai_ability."""
@@ -3051,6 +3166,22 @@ class AtomTrailer(Expr):
         self.set_kids(nodes=new_kid)
         return res
 
+    @property
+    def as_attr_list(self) -> list[AstSymbolNode]:
+        """Unwind trailer into list of ast symbol nodes."""
+        left = self.right if isinstance(self.right, AtomTrailer) else self.target
+        right = self.target if isinstance(self.right, AtomTrailer) else self.right
+        trag_list: list[AstSymbolNode] = (
+            [right] if isinstance(right, AstSymbolNode) else []
+        )
+        while isinstance(left, AtomTrailer) and left.is_attr:
+            if isinstance(left.right, AstSymbolNode):
+                trag_list.insert(0, left.right)
+            left = left.target
+        if isinstance(left, AstSymbolNode):
+            trag_list.insert(0, left)
+        return trag_list
+
 
 class AtomUnit(Expr):
     """AtomUnit node type for Jac Ast."""
@@ -3869,7 +4000,9 @@ class Name(Token, NameAtom):
         )
 
     @staticmethod
-    def gen_stub_from_node(node: AstSymbolNode, name_str: str) -> Name:
+    def gen_stub_from_node(
+        node: AstSymbolNode, name_str: str, set_name_of: Optional[AstSymbolNode] = None
+    ) -> Name:
         """Generate name from node."""
         ret = Name(
             file_path=node.loc.mod_path,
@@ -3882,8 +4015,9 @@ class Name(Token, NameAtom):
             pos_start=node.loc.pos_start,
             pos_end=node.loc.pos_end,
         )
-        ret.name_of = node
-        ret.sym_tab = node.sym_tab
+        ret.name_of = set_name_of if set_name_of else ret
+        if node._sym_tab:
+            ret.sym_tab = node.sym_tab
         return ret
 
 
@@ -4121,6 +4255,7 @@ class CommentToken(Token):
         name: str,
         value: str,
         line: int,
+        end_line: int,
         col_start: int,
         col_end: int,
         pos_start: int,
@@ -4129,15 +4264,21 @@ class CommentToken(Token):
         is_inline: bool = False,
     ) -> None:
         """Initialize token."""
-        self.file_path = file_path
-        self.name = name
-        self.value = value
-        self.line_no = line
-        self.c_start = col_start
-        self.c_end = col_end
-        self.pos_start = pos_start
-        self.pos_end = pos_end
         self.is_inline = is_inline
+
+        Token.__init__(
+            self,
+            file_path=file_path,
+            name=name,
+            value=value,
+            line=line,
+            end_line=end_line,
+            col_start=col_start,
+            col_end=col_end,
+            pos_start=pos_start,
+            pos_end=pos_end,
+        )
+
         AstNode.__init__(self, kid=kid)
 
 

jaclang/compiler/constant.py

@@ -1,9 +1,93 @@
 """Constants across the project."""
 
-from enum import Enum
+from enum import Enum, IntEnum, IntFlag, StrEnum
 
 
-class Constants(str, Enum):
+class SymbolType(Enum):
+    """Symbol types."""
+
+    MODULE = "module"  # LSP: Module
+    MOD_VAR = "mod_var"  # LSP: Variable
+    VAR = "variable"  # LSP: Variable
+    IMM_VAR = "immutable"  # LSP: Constant
+    ABILITY = "ability"  # LSP: Function
+    OBJECT_ARCH = "object"  # LSP: Class
+    NODE_ARCH = "node"  # LSP: Class
+    EDGE_ARCH = "edge"  # LSP: Class
+    WALKER_ARCH = "walker"  # LSP: Class
+    ENUM_ARCH = "enum"  # LSP: Enum
+    TEST = "test"  # LSP: Function
+    TYPE = "type"  # LSP: TypeParameter
+    IMPL = "impl"  # LSP: Interface or Property
+    HAS_VAR = "field"  # LSP: Field
+    METHOD = "method"  # LSP: Method
+    CONSTRUCTOR = "constructor"  # LSP: Constructor
+    ENUM_MEMBER = "enum_member"  # LSP: EnumMember
+    NUMBER = "number"  # LSP: Number
+    STRING = "string"  # LSP: String
+    BOOL = "bool"  # LSP: Boolean
+    SEQUENCE = "sequence"  # LSP: Array
+    NULL = "null"  # LSP: Null
+    UNKNOWN = "unknown"  # LSP: Unknown
+
+    def __str__(self) -> str:
+        """Stringify."""
+        return self.value
+
+
+class JacSemTokenType(IntEnum):
+    """LSP Token types for Jac."""
+
+    NAMESPACE = 0
+    TYPE = 1
+    CLASS = 2
+    ENUM = 3
+    INTERFACE = 4
+    STRUCT = 5
+    TYPE_PARAMETER = 6
+    PARAMETER = 7
+    VARIABLE = 8
+    PROPERTY = 9
+    ENUM_MEMBER = 10
+    EVENT = 11
+    FUNCTION = 12
+    METHOD = 13
+    MACRO = 14
+    KEYWORD = 15
+    MODIFIER = 16
+    COMMENT = 17
+    STRING = 18
+    NUMBER = 19
+    REGEXP = 20
+    OPERATOR = 21
+
+    @staticmethod
+    def as_str_list() -> list[str]:
+        """Return the string representation of the token."""
+        return [i.name.lower() for i in JacSemTokenType]
+
+
+class JacSemTokenModifier(IntFlag):
+    """LSP Token modifiers for Jac."""
+
+    DECLARATION = 1 << 0
+    DEFINITION = 1 << 1
+    READONLY = 1 << 2
+    STATIC = 1 << 3
+    DEPRECATED = 1 << 4
+    ABSTRACT = 1 << 5
+    ASYNC = 1 << 6
+    MODIFICATION = 1 << 7
+    DOCUMENTATION = 1 << 8
+    DEFAULT_LIBRARY = 1 << 9
+
+    @staticmethod
+    def as_str_list() -> list[str]:
+        """Return the string representation of the token."""
+        return [i.name.lower() for i in JacSemTokenModifier if i.name]
+
+
+class Constants(StrEnum):
     """Token constants for Jac."""
 
     JAC_LANG_IMP = "jac"
@@ -49,6 +133,18 @@ class Values(int, Enum):
     JAC_ERROR_LINE_RANGE = 3
 
 
+class SymbolAccess(Enum):
+    """Symbol types."""
+
+    PRIVATE = "private"
+    PUBLIC = "public"
+    PROTECTED = "protected"
+
+    def __str__(self) -> str:
+        """Stringify."""
+        return self.value
+
+
 # Done like this for type checker
 # validated synced with test
 class Tokens(str, Enum):

jaclang/compiler/jac.lark

@@ -68,6 +68,8 @@ enum_stmt: NAME (COLON STRING)? EQ expression
          | NAME (COLON STRING)?
          | py_code_block
          | free_code
+         | abstract_ability
+         | ability
 
 // Abilities
 ability: decorators? KW_ASYNC? ability_decl

jaclang/compiler/parser.py

@@ -24,6 +24,7 @@ class JacParser(Pass):
         """Initialize parser."""
         self.source = input_ir
         self.mod_path = input_ir.loc.mod_path
+        self.node_list: list[ast.AstNode] = []
         if JacParser.dev_mode:
             JacParser.make_dev()
         Pass.__init__(self, input_ir=input_ir, prior=None)
@@ -67,6 +68,7 @@ class JacParser(Pass):
             name=token.type,
             value=token.value,
             line=token.line if token.line is not None else 0,
+            end_line=token.end_line if token.end_line is not None else 0,
             col_start=token.column if token.column is not None else 0,
             col_end=token.end_column if token.end_column is not None else 0,
             pos_start=token.start_pos if token.start_pos is not None else 0,
@@ -129,6 +131,7 @@ class JacParser(Pass):
         def nu(self, node: ast.T) -> ast.T:
             """Update node."""
             self.parse_ref.cur_node = node
+            self.parse_ref.node_list.append(node)
             return node
 
         def start(self, kid: list[ast.Module]) -> ast.Module:
@@ -136,6 +139,7 @@ class JacParser(Pass):
 
             start: module
             """
+            kid[0]._in_mod_nodes = self.parse_ref.node_list
             return self.nu(kid[0])
 
         def module(

jaclang/compiler/passes/main/access_modifier_pass.py

@@ -7,11 +7,13 @@ import os
 from typing import Optional
 
 import jaclang.compiler.absyntree as ast
-from jaclang.compiler.passes.main.sym_tab_build_pass import SymTabPass, SymbolAccess
+from jaclang.compiler.constant import SymbolAccess
+from jaclang.compiler.passes import Pass
+from jaclang.compiler.symtable import SymbolTable
 from jaclang.settings import settings
 
 
-class AccessCheckPass(SymTabPass):
+class AccessCheckPass(Pass):
     """Jac Ast Access Check pass."""
 
     def after_pass(self) -> None:
@@ -28,7 +30,7 @@ class AccessCheckPass(SymTabPass):
         """Access check."""
         node_info = (
             node.sym_tab.lookup(node.sym_name)
-            if isinstance(node.sym_tab, ast.SymbolTable)
+            if isinstance(node.sym_tab, SymbolTable)
             else None
         )
 

jaclang/compiler/passes/main/def_impl_match_pass.py

@@ -52,7 +52,9 @@ class DeclImplMatchPass(Pass):
                 if lookup and not isinstance(
                     lookup.decl.name_of, ast.AstImplNeedingNode
                 ):
-                    lookup = sym_tab.parent.lookup(arch_refs[0])
+                    lookup = (
+                        sym_tab.parent.lookup(arch_refs[0]) if sym_tab.parent else None
+                    )
                 decl_node = (
                     self.defn_lookup(lookup)
                     if len(arch_refs) == 1 and lookup