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

jaclang/compiler/passes/tool/tests/fixtures/genai/wikipedia.jac

@@ -1,5 +1,5 @@
 import:py wikipedia;
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");
 

jaclang/compiler/symtable.py

@@ -2,60 +2,14 @@
 
 from __future__ import annotations
 
-from enum import Enum
-from typing import Optional, TYPE_CHECKING
+import ast as ast3
+from typing import Optional, Sequence
 
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.constant import SymbolAccess, SymbolType
 from jaclang.utils.treeprinter import dotgen_symtab_tree, print_symtab_tree
 
 
-if TYPE_CHECKING:
-    import jaclang.compiler.absyntree as ast
-
-
-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 SymbolAccess(Enum):
-    """Symbol types."""
-
-    PRIVATE = "private"
-    PUBLIC = "public"
-    PROTECTED = "protected"
-
-    def __str__(self) -> str:
-        """Stringify."""
-        return self.value
-
-
 # Symbols can have mulitple definitions but resolves decl to be the
 # first such definition in a given scope.
 class Symbol:
@@ -93,13 +47,10 @@ class Symbol:
     def sym_dotted_name(self) -> str:
         """Return a full path of the symbol."""
         out = [self.defn[0].sym_name]
-        current_tab = self.parent_tab
+        current_tab: SymbolTable | None = self.parent_tab
         while current_tab is not None:
             out.append(current_tab.name)
-            if current_tab.has_parent():
-                current_tab = current_tab.parent
-            else:
-                break
+            current_tab = current_tab.parent
         out.reverse()
         return ".".join(out)
 
@@ -127,19 +78,13 @@ class SymbolTable:
         """Initialize."""
         self.name = name
         self.owner = owner
-        self.parent = parent if parent else self
+        self.parent = parent
         self.kid: list[SymbolTable] = []
         self.tab: dict[str, Symbol] = {}
         self.inherit: list[SymbolTable] = []
 
-    def has_parent(self) -> bool:
-        """Check if has parent."""
-        return self.parent != self
-
-    def get_parent(self) -> SymbolTable:
+    def get_parent(self) -> Optional[SymbolTable]:
         """Get parent."""
-        if self.parent == self:
-            raise Exception("No parent")
         return self.parent
 
     def lookup(self, name: str, deep: bool = True) -> Optional[Symbol]:
@@ -150,8 +95,8 @@ class SymbolTable:
             found = i.lookup(name, deep=False)
             if found:
                 return found
-        if deep and self.has_parent():
-            return self.get_parent().lookup(name, deep)
+        if deep and self.parent:
+            return self.parent.lookup(name, deep)
         return None
 
     def insert(
@@ -197,6 +142,114 @@ class SymbolTable:
         self.kid.append(SymbolTable(name, key_node, self))
         return self.kid[-1]
 
+    def inherit_sym_tab(self, target_sym_tab: SymbolTable) -> None:
+        """Inherit symbol table."""
+        for i in target_sym_tab.tab.values():
+            self.def_insert(i.decl, access_spec=i.access)
+
+    def def_insert(
+        self,
+        node: ast.AstSymbolNode,
+        access_spec: Optional[ast.AstAccessNode] | SymbolAccess = None,
+        single_decl: Optional[str] = None,
+    ) -> Optional[Symbol]:
+        """Insert into symbol table."""
+        if node.sym and self == node.sym.parent_tab:
+            return node.sym
+        self.insert(node=node, single=single_decl is not None, access_spec=access_spec)
+        self.update_py_ctx_for_def(node)
+        return node.sym
+
+    def chain_def_insert(self, node_list: list[ast.AstSymbolNode]) -> None:
+        """Link chain of containing names to symbol."""
+        if not node_list:
+            return
+        cur_sym_tab: SymbolTable | None = node_list[0].sym_tab
+        node_list[-1].name_spec.py_ctx_func = ast3.Store
+        if isinstance(node_list[-1].name_spec, ast.AstSymbolNode):
+            node_list[-1].name_spec.py_ctx_func = ast3.Store
+
+        node_list = node_list[:-1]  # Just performs lookup mappings of pre assign chain
+        for i in node_list:
+            cur_sym_tab = (
+                lookup.decl.sym_tab
+                if (
+                    lookup := self.use_lookup(
+                        i,
+                        sym_table=cur_sym_tab,
+                    )
+                )
+                else None
+            )
+
+    def use_lookup(
+        self,
+        node: ast.AstSymbolNode,
+        sym_table: Optional[SymbolTable] = None,
+    ) -> Optional[Symbol]:
+        """Link to symbol."""
+        if node.sym:
+            return node.sym
+        if not sym_table:
+            sym_table = node.sym_tab
+        if sym_table:
+            lookup = sym_table.lookup(name=node.sym_name, deep=True)
+            lookup.add_use(node.name_spec) if lookup else None
+        return node.sym
+
+    def chain_use_lookup(self, node_list: Sequence[ast.AstSymbolNode]) -> None:
+        """Link chain of containing names to symbol."""
+        if not node_list:
+            return
+        cur_sym_tab: SymbolTable | None = node_list[0].sym_tab
+        for i in node_list:
+            if cur_sym_tab is None:
+                break
+            cur_sym_tab = (
+                lookup.decl.sym_tab
+                if (
+                    lookup := self.use_lookup(
+                        i,
+                        sym_table=cur_sym_tab,
+                    )
+                )
+                else None
+            )
+
+    def update_py_ctx_for_def(self, node: ast.AstSymbolNode) -> None:
+        """Update python context for definition."""
+        node.name_spec.py_ctx_func = ast3.Store
+        if isinstance(node, (ast.TupleVal, ast.ListVal)) and node.values:
+            # Handling of UnaryExpr case for item is only necessary for
+            # the generation of Starred nodes in the AST for examples
+            # like `(a, *b) = (1, 2, 3, 4)`.
+            def fix(item: ast.TupleVal | ast.ListVal | ast.UnaryExpr) -> None:
+                if isinstance(item, ast.UnaryExpr):
+                    if isinstance(item.operand, ast.AstSymbolNode):
+                        item.operand.name_spec.py_ctx_func = ast3.Store
+                elif isinstance(item, (ast.TupleVal, ast.ListVal)):
+                    for i in item.values.items if item.values else []:
+                        if isinstance(i, ast.AstSymbolNode):
+                            i.name_spec.py_ctx_func = ast3.Store
+                        elif isinstance(i, ast.AtomTrailer):
+                            self.chain_def_insert(i.as_attr_list)
+                        if isinstance(i, (ast.TupleVal, ast.ListVal, ast.UnaryExpr)):
+                            fix(i)
+
+            fix(node)
+
+    def inherit_baseclasses_sym(self, node: ast.Architype | ast.Enum) -> None:
+        """Inherit base classes symbol tables."""
+        if node.base_classes:
+            for base_cls in node.base_classes.items:
+                if (
+                    isinstance(base_cls, ast.AstSymbolNode)
+                    and (found := self.use_lookup(base_cls))
+                    and found
+                ):
+                    self.inherit.append(found.decl.sym_tab)
+                    base_cls.name_spec.name_of = found.decl.name_of
+
     def pp(self, depth: Optional[int] = None) -> str:
         """Pretty print."""
         return print_symtab_tree(root=self, depth=depth)

jaclang/core/aott.py

@@ -18,14 +18,18 @@ except ImportError:
     Image = None
 
 from jaclang.compiler.semtable import SemInfo, SemRegistry, SemScope
-from jaclang.core.llms.base import BaseLLM
+
+try:
+    from mtllm.llms import BaseLLM
+except ImportError:
+    BaseLLM = None
 
 
 IMG_FORMATS = ["PngImageFile", "JpegImageFile"]
 
 
 def aott_raise(
-    model: BaseLLM,
+    model: BaseLLM,  # type: ignore
     information: str,
     inputs_information: str | list[dict],
     output_information: str,
@@ -298,7 +302,7 @@ def get_input_information(
         return inputs_information_dict_list
 
 
-def image_to_base64(image: Image) -> str:
+def image_to_base64(image: Image) -> str:  # type: ignore
     """Convert an image to base64 expected by OpenAI."""
     if not Image:
         log = logging.getLogger(__name__)

jaclang/core/importer.py

@@ -45,7 +45,7 @@ def jac_importer(
         if isinstance(mod_bundle, str)
         and mod_bundle in sys.modules
         and "__jac_mod_bundle__" in sys.modules[mod_bundle].__dict__
-        else mod_bundle
+        else None
     )
 
     caller_dir = get_caller_dir(target, base_path, dir_path)

jaclang/langserve/engine.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import logging
 from enum import IntEnum
-from hashlib import md5
 from typing import Optional
 
 
@@ -19,6 +18,8 @@ from jaclang.langserve.utils import (
     collect_symbols,
     create_range,
     find_deepest_symbol_node_at_pos,
+    get_item_path,
+    get_mod_path,
 )
 from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.server import LanguageServer
@@ -27,7 +28,7 @@ import lsprotocol.types as lspt
 
 
 class ALev(IntEnum):
-    """Analysis Level."""
+    """Analysis Level successfully completed."""
 
     QUICK = 1
     DEEP = 2
@@ -52,6 +53,7 @@ class ModuleInfo:
         self.alev = alev
         self.parent: Optional[ModuleInfo] = parent
         self.diagnostics = self.gen_diagnostics()
+        self.sem_tokens: list[int] = self.gen_sem_tokens()
 
     @property
     def uri(self) -> str:
@@ -63,13 +65,19 @@ class ModuleInfo:
         """Return if there are syntax errors."""
         return len(self.errors) > 0 and self.alev == ALev.QUICK
 
-    def update_with(self, new_info: ModuleInfo) -> None:
+    def update_with(self, new_info: ModuleInfo, refresh: bool = False) -> None:
         """Update module info."""
         self.ir = new_info.ir
-        self.errors += [i for i in new_info.errors if i not in self.errors]
-        self.warnings += [i for i in new_info.warnings if i not in self.warnings]
+        if refresh:
+            self.errors = new_info.errors
+            self.warnings = new_info.warnings
+        else:
+            self.errors += [i for i in new_info.errors if i not in self.errors]
+            self.warnings += [i for i in new_info.warnings if i not in self.warnings]
         self.alev = new_info.alev
         self.diagnostics = self.gen_diagnostics()
+        if self.alev == ALev.TYPE:
+            self.sem_tokens = self.gen_sem_tokens()
 
     def gen_diagnostics(self) -> list[lspt.Diagnostic]:
         """Return diagnostics."""
@@ -89,6 +97,27 @@ class ModuleInfo:
             for warning in self.warnings
         ]
 
+    def gen_sem_tokens(self) -> list[int]:
+        """Return semantic tokens."""
+        tokens = []
+        prev_line, prev_col = 0, 0
+        for node in self.ir._in_mod_nodes:
+            if isinstance(node, ast.NameAtom) and node.sem_token:
+                line, col_start, col_end = (
+                    node.loc.first_line - 1,
+                    node.loc.col_start - 1,
+                    node.loc.col_end - 1,
+                )
+                length = col_end - col_start
+                tokens += [
+                    line - prev_line,
+                    col_start if line != prev_line else col_start - prev_col,
+                    length,
+                    *node.sem_token,
+                ]
+                prev_line, prev_col = line, col_start
+        return tokens
+
 
 class JacLangServer(LanguageServer):
     """Class for managing workspace."""
@@ -98,19 +127,6 @@ class JacLangServer(LanguageServer):
         super().__init__("jac-lsp", "v0.1")
         self.modules: dict[str, ModuleInfo] = {}
 
-    def module_not_diff(self, uri: str, alev: ALev) -> bool:
-        """Check if module was changed."""
-        doc = self.workspace.get_text_document(uri)
-        return (
-            doc.uri in self.modules
-            and self.modules[doc.uri].ir.source.hash
-            == md5(doc.source.encode()).hexdigest()
-            and (
-                self.modules[doc.uri].alev >= alev
-                or self.modules[doc.uri].has_syntax_error
-            )
-        )
-
     def push_diagnostics(self, file_path: str) -> None:
         """Push diagnostics for a file."""
         if file_path in self.modules:
@@ -153,8 +169,8 @@ class JacLangServer(LanguageServer):
             ],
             alev=alev,
         )
-        if not refresh and file_path in self.modules:
-            self.modules[file_path].update_with(new_mod)
+        if file_path in self.modules:
+            self.modules[file_path].update_with(new_mod, refresh=refresh)
         else:
             self.modules[file_path] = new_mod
         for p in build.ir.mod_deps.keys():
@@ -173,10 +189,8 @@ class JacLangServer(LanguageServer):
                 self.modules[file_path] if file_path != uri else None
             )
 
-    def quick_check(self, file_path: str, force: bool = False) -> None:
+    def quick_check(self, file_path: str) -> bool:
         """Rebuild a file."""
-        if not force and self.module_not_diff(file_path, ALev.QUICK):
-            return
         try:
             document = self.workspace.get_text_document(file_path)
             build = jac_str_to_pass(
@@ -184,27 +198,27 @@ class JacLangServer(LanguageServer):
             )
         except Exception as e:
             self.log_error(f"Error during syntax check: {e}")
+            return False
         self.update_modules(file_path, build, ALev.QUICK, refresh=True)
+        return len(self.modules[file_path].errors) == 0
 
-    def deep_check(self, file_path: str, force: bool = False) -> None:
+    def deep_check(self, file_path: str) -> bool:
         """Rebuild a file and its dependencies."""
-        if file_path in self.modules:
-            self.quick_check(file_path, force=force)
-        if not force and self.module_not_diff(file_path, ALev.DEEP):
-            return
+        if file_path not in self.modules:
+            self.quick_check(file_path)
         try:
             file_path = self.unwind_to_parent(file_path)
             build = jac_ir_to_pass(ir=self.modules[file_path].ir)
         except Exception as e:
             self.log_error(f"Error during syntax check: {e}")
+            return False
         self.update_modules(file_path, build, ALev.DEEP)
+        return len(self.modules[file_path].errors) == 0
 
-    def type_check(self, file_path: str, force: bool = False) -> None:
+    def type_check(self, file_path: str) -> bool:
         """Rebuild a file and its dependencies."""
         if file_path not in self.modules:
-            self.deep_check(file_path, force=force)
-        if not force and self.module_not_diff(file_path, ALev.TYPE):
-            return
+            self.deep_check(file_path)
         try:
             file_path = self.unwind_to_parent(file_path)
             build = jac_ir_to_pass(
@@ -212,7 +226,21 @@ class JacLangServer(LanguageServer):
             )
         except Exception as e:
             self.log_error(f"Error during type check: {e}")
+            return False
         self.update_modules(file_path, build, ALev.TYPE)
+        return len(self.modules[file_path].errors) == 0
+
+    def analyze_and_publish(self, uri: str, level: int = 2) -> None:
+        """Analyze and publish diagnostics."""
+        self.log_py(f"Analyzing {uri}...")
+        success = self.quick_check(uri)
+        self.push_diagnostics(uri)
+        if success and level > 0:
+            success = self.deep_check(uri)
+            self.push_diagnostics(uri)
+            if level > 1:
+                self.type_check(uri)
+                self.push_diagnostics(uri)
 
     def get_completion(
         self, file_path: str, position: lspt.Position
@@ -310,8 +338,7 @@ class JacLangServer(LanguageServer):
 
     def get_document_symbols(self, file_path: str) -> list[lspt.DocumentSymbol]:
         """Return document symbols for a file."""
-        root_node = self.modules[file_path].ir.sym_tab
-        if root_node:
+        if root_node := self.modules[file_path].ir._sym_tab:
             return collect_symbols(root_node)
         return []
 
@@ -323,7 +350,39 @@ class JacLangServer(LanguageServer):
             self.modules[file_path].ir, position.line, position.character
         )
         if node_selected:
-            if isinstance(node_selected, (ast.ElementStmt, ast.BuiltinType)):
+            if (
+                isinstance(node_selected, ast.Name)
+                and node_selected.parent
+                and isinstance(node_selected.parent, ast.ModulePath)
+            ):
+                spec = get_mod_path(node_selected.parent, node_selected)
+                if spec:
+                    return lspt.Location(
+                        uri=uris.from_fs_path(spec),
+                        range=lspt.Range(
+                            start=lspt.Position(line=0, character=0),
+                            end=lspt.Position(line=0, character=0),
+                        ),
+                    )
+                else:
+                    return None
+            elif node_selected.parent and isinstance(
+                node_selected.parent, ast.ModuleItem
+            ):
+                path_range = get_item_path(node_selected.parent)
+                if path_range:
+                    path, range = path_range
+                    if path and range:
+                        return lspt.Location(
+                            uri=uris.from_fs_path(path),
+                            range=lspt.Range(
+                                start=lspt.Position(line=range[0], character=0),
+                                end=lspt.Position(line=range[1], character=5),
+                            ),
+                        )
+                else:
+                    return None
+            elif isinstance(node_selected, (ast.ElementStmt, ast.BuiltinType)):
                 return None
             decl_node = (
                 node_selected.parent.body.target
@@ -349,9 +408,14 @@ class JacLangServer(LanguageServer):
 
             return decl_location
         else:
-            self.log_info("No declaration found for the selected node.")
             return None
 
+    def get_semantic_tokens(self, file_path: str) -> lspt.SemanticTokens:
+        """Return semantic tokens for a file."""
+        if file_path not in self.modules:
+            return lspt.SemanticTokens(data=[])
+        return lspt.SemanticTokens(data=self.modules[file_path].sem_tokens)
+
     def log_error(self, message: str) -> None:
         """Log an error message."""
         self.show_message_log(message, lspt.MessageType.Error)