jaclang 0.7.1__py3-none-any.whl → 0.7.7__py3-none-any.whl

jaclang/core/memory.py

@@ -1,8 +1,11 @@
-"""Memory abstraction for jaseci plugin."""
+"""Core constructs for Jac Language."""
 
+from __future__ import annotations
+
+import shelve
 from uuid import UUID
 
-from jaclang.core.construct import Architype
+from .architype import Architype
 
 
 class Memory:
@@ -46,3 +49,51 @@ class Memory:
     def close(self) -> None:
         """Close any connection, if applicable."""
         self.mem.clear()
+
+
+class ShelveStorage(Memory):
+    """Shelve storage for jaclang runtime object."""
+
+    storage: shelve.Shelf | None = None
+
+    def __init__(self, session: str = "") -> None:
+        """Init shelve storage."""
+        super().__init__()
+        if session:
+            self.connect(session)
+
+    def get_obj_from_store(self, obj_id: UUID) -> Architype | None:
+        """Get object from the underlying store."""
+        obj = super().get_obj_from_store(obj_id)
+        if obj is None and self.storage:
+            obj = self.storage.get(str(obj_id))
+            if obj is not None:
+                self.mem[obj_id] = obj
+
+        return obj
+
+    def has_obj_in_store(self, obj_id: UUID | str) -> bool:
+        """Check if the object exists in the underlying store."""
+        return obj_id in self.mem or (
+            str(obj_id) in self.storage if self.storage else False
+        )
+
+    def commit(self) -> None:
+        """Commit changes to persistent storage."""
+        if self.storage is not None:
+            for obj_id, obj in self.save_obj_list.items():
+                self.storage[str(obj_id)] = obj
+        self.save_obj_list.clear()
+
+    def connect(self, session: str) -> None:
+        """Connect to storage."""
+        self.session = session
+        self.storage = shelve.open(session)
+
+    def close(self) -> None:
+        """Close the storage."""
+        super().close()
+        self.commit()
+        if self.storage:
+            self.storage.close()
+        self.storage = None

jaclang/core/test.py

@@ -0,0 +1,90 @@
+"""Core constructs for Jac Language."""
+
+from __future__ import annotations
+
+import unittest
+from typing import Callable, Optional
+
+
+class JacTestResult(unittest.TextTestResult):
+    """Jac test result class."""
+
+    def __init__(
+        self,
+        stream,  # noqa
+        descriptions,  # noqa
+        verbosity: int,
+        max_failures: Optional[int] = None,
+    ) -> None:
+        """Initialize FailFastTestResult object."""
+        super().__init__(stream, descriptions, verbosity)  # noqa
+        self.failures_count = JacTestCheck.failcount
+        self.max_failures = max_failures
+
+    def addFailure(self, test, err) -> None:  # noqa
+        """Count failures and stop."""
+        super().addFailure(test, err)
+        self.failures_count += 1
+        if self.max_failures is not None and self.failures_count >= self.max_failures:
+            self.stop()
+
+    def stop(self) -> None:
+        """Stop the test execution."""
+        self.shouldStop = True
+
+
+class JacTextTestRunner(unittest.TextTestRunner):
+    """Jac test runner class."""
+
+    def __init__(self, max_failures: Optional[int] = None, **kwargs) -> None:  # noqa
+        """Initialize JacTextTestRunner object."""
+        self.max_failures = max_failures
+        super().__init__(**kwargs)
+
+    def _makeResult(self) -> JacTestResult:  # noqa
+        """Override the method to return an instance of JacTestResult."""
+        return JacTestResult(
+            self.stream,
+            self.descriptions,
+            self.verbosity,
+            max_failures=self.max_failures,
+        )
+
+
+class JacTestCheck:
+    """Jac Testing and Checking."""
+
+    test_case = unittest.TestCase()
+    test_suite = unittest.TestSuite()
+    breaker = False
+    failcount = 0
+
+    @staticmethod
+    def reset() -> None:
+        """Clear the test suite."""
+        JacTestCheck.test_case = unittest.TestCase()
+        JacTestCheck.test_suite = unittest.TestSuite()
+
+    @staticmethod
+    def run_test(xit: bool, maxfail: int | None, verbose: bool) -> None:
+        """Run the test suite."""
+        verb = 2 if verbose else 1
+        runner = JacTextTestRunner(max_failures=maxfail, failfast=xit, verbosity=verb)
+        result = runner.run(JacTestCheck.test_suite)
+        if result.wasSuccessful():
+            print("Passed successfully.")
+        else:
+            fails = len(result.failures)
+            JacTestCheck.failcount += fails
+            JacTestCheck.breaker = (
+                (JacTestCheck.failcount >= maxfail) if maxfail else True
+            )
+
+    @staticmethod
+    def add_test(test_fun: Callable) -> None:
+        """Create a new test."""
+        JacTestCheck.test_suite.addTest(unittest.FunctionTestCase(test_fun))
+
+    def __getattr__(self, name: str) -> object:
+        """Make convenient check.Equal(...) etc."""
+        return getattr(JacTestCheck.test_case, name)

jaclang/core/utils.py

@@ -8,10 +8,10 @@ from contextlib import contextmanager
 from typing import Callable, Iterator, TYPE_CHECKING
 
 import jaclang.compiler.absyntree as ast
-from jaclang.core.registry import SemScope
+from jaclang.compiler.semtable import SemScope
 
 if TYPE_CHECKING:
-    from jaclang.core.construct import NodeAnchor, NodeArchitype
+    from jaclang.core.constructs import NodeAnchor, NodeArchitype
 
 
 @contextmanager

jaclang/langserve/engine.py

@@ -2,9 +2,9 @@
 
 from __future__ import annotations
 
+import logging
 from enum import IntEnum
-from hashlib import md5
-from typing import Optional, Sequence
+from typing import Optional
 
 
 import jaclang.compiler.absyntree as ast
@@ -14,7 +14,13 @@ from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main.schedules import type_checker_sched
 from jaclang.compiler.passes.tool import FuseCommentsPass, JacFormatPass
 from jaclang.compiler.passes.transform import Alert
-from jaclang.langserve.utils import find_deepest_node_at_pos
+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
 
@@ -22,7 +28,7 @@ import lsprotocol.types as lspt
 
 
 class ALev(IntEnum):
-    """Analysis Level."""
+    """Analysis Level successfully completed."""
 
     QUICK = 1
     DEEP = 2
@@ -35,8 +41,8 @@ class ModuleInfo:
     def __init__(
         self,
         ir: ast.Module,
-        errors: Sequence[Alert],
-        warnings: Sequence[Alert],
+        errors: list[Alert],
+        warnings: list[Alert],
         alev: ALev,
         parent: Optional[ModuleInfo] = None,
     ) -> None:
@@ -47,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:
@@ -58,41 +65,59 @@ 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, refresh: bool = False) -> None:
+        """Update module info."""
+        self.ir = new_info.ir
+        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."""
         return [
             lspt.Diagnostic(
-                range=lspt.Range(
-                    start=lspt.Position(
-                        line=error.loc.first_line - 1, character=error.loc.col_start - 1
-                    ),
-                    end=lspt.Position(
-                        line=error.loc.last_line - 1,
-                        character=error.loc.col_end - 1,
-                    ),
-                ),
+                range=create_range(error.loc),
                 message=error.msg,
                 severity=lspt.DiagnosticSeverity.Error,
             )
             for error in self.errors
         ] + [
             lspt.Diagnostic(
-                range=lspt.Range(
-                    start=lspt.Position(
-                        line=warning.loc.first_line - 1,
-                        character=warning.loc.col_start - 1,
-                    ),
-                    end=lspt.Position(
-                        line=warning.loc.last_line - 1,
-                        character=warning.loc.col_end - 1,
-                    ),
-                ),
+                range=create_range(warning.loc),
                 message=warning.msg,
                 severity=lspt.DiagnosticSeverity.Warning,
             )
             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."""
@@ -102,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_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:
@@ -125,17 +137,25 @@ class JacLangServer(LanguageServer):
 
     def unwind_to_parent(self, file_path: str) -> str:
         """Unwind to parent."""
+        orig_file_path = file_path
         if file_path in self.modules:
             while cur := self.modules[file_path].parent:
                 file_path = cur.uri
+            if file_path == orig_file_path and (
+                discover := self.modules[file_path].ir.annexable_by
+            ):
+                file_path = uris.from_fs_path(discover)
+                self.quick_check(file_path)
         return file_path
 
-    def update_modules(self, file_path: str, build: Pass, alev: ALev) -> None:
+    def update_modules(
+        self, file_path: str, build: Pass, alev: ALev, refresh: bool = False
+    ) -> None:
         """Update modules."""
         if not isinstance(build.ir, ast.Module):
             self.log_error("Error with module build.")
             return
-        self.modules[file_path] = ModuleInfo(
+        new_mod = ModuleInfo(
             ir=build.ir,
             errors=[
                 i
@@ -149,47 +169,56 @@ class JacLangServer(LanguageServer):
             ],
             alev=alev,
         )
+        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():
             uri = uris.from_fs_path(p)
-            self.modules[uri] = ModuleInfo(
+            new_mod = ModuleInfo(
                 ir=build.ir.mod_deps[p],
                 errors=[i for i in build.errors_had if i.loc.mod_path == p],
                 warnings=[i for i in build.warnings_had if i.loc.mod_path == p],
                 alev=alev,
             )
+            if not refresh and uri in self.modules:
+                self.modules[uri].update_with(new_mod)
+            else:
+                self.modules[uri] = new_mod
+            self.modules[uri].parent = (
+                self.modules[file_path] if file_path != uri else None
+            )
 
-    def quick_check(self, file_path: str) -> None:
+    def quick_check(self, file_path: str) -> bool:
         """Rebuild a file."""
-        if self.module_not_diff(file_path, ALev.QUICK):
-            return
         try:
-            document = self.workspace.get_document(file_path)
+            document = self.workspace.get_text_document(file_path)
             build = jac_str_to_pass(
                 jac_str=document.source, file_path=document.path, schedule=[]
             )
         except Exception as e:
             self.log_error(f"Error during syntax check: {e}")
-        self.update_modules(file_path, build, ALev.QUICK)
+            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) -> None:
+    def deep_check(self, file_path: str) -> bool:
         """Rebuild a file and its dependencies."""
-        if file_path in self.modules:
+        if file_path not in self.modules:
             self.quick_check(file_path)
-        if self.module_not_diff(file_path, ALev.DEEP):
-            return
         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) -> 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)
-        if self.module_not_diff(file_path, ALev.TYPE):
-            return
         try:
             file_path = self.unwind_to_parent(file_path)
             build = jac_ir_to_pass(
@@ -197,14 +226,28 @@ 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
     ) -> lspt.CompletionList:
         """Return completion for a file."""
         items = []
-        document = self.workspace.get_document(file_path)
+        document = self.workspace.get_text_document(file_path)
         current_line = document.lines[position.line].strip()
         if current_line.endswith("hello."):
 
@@ -228,7 +271,7 @@ class JacLangServer(LanguageServer):
     def formatted_jac(self, file_path: str) -> list[lspt.TextEdit]:
         """Return formatted jac."""
         try:
-            document = self.workspace.get_document(file_path)
+            document = self.workspace.get_text_document(file_path)
             format = jac_str_to_pass(
                 jac_str=document.source,
                 file_path=document.path,
@@ -259,7 +302,7 @@ class JacLangServer(LanguageServer):
         self, file_path: str, position: lspt.Position
     ) -> Optional[lspt.Hover]:
         """Return hover information for a file."""
-        node_selected = find_deepest_node_at_pos(
+        node_selected = find_deepest_symbol_node_at_pos(
             self.modules[file_path].ir, position.line, position.character
         )
         value = self.get_node_info(node_selected) if node_selected else None
@@ -271,94 +314,108 @@ class JacLangServer(LanguageServer):
             )
         return None
 
-    def get_node_info(self, node: ast.AstNode) -> Optional[str]:
+    def get_node_info(self, node: ast.AstSymbolNode) -> Optional[str]:
         """Extract meaningful information from the AST node."""
         try:
-            if isinstance(node, ast.Token):
-                if isinstance(node, ast.AstSymbolNode):
-                    if isinstance(node, ast.String):
-                        return None
-                    if node.sym_link and node.sym_link.decl:
-                        decl_node = node.sym_link.decl
-                        if isinstance(decl_node, ast.Architype):
-                            if decl_node.doc:
-                                node_info = f"({decl_node.arch_type.value}) {node.value} \n{decl_node.doc.lit_value}"
-                            else:
-                                node_info = (
-                                    f"({decl_node.arch_type.value}) {node.value}"
-                                )
-                            if decl_node.semstr:
-                                node_info += f"\n{decl_node.semstr.lit_value}"
-                        elif isinstance(decl_node, ast.Ability):
-                            node_info = f"(ability) can {node.value}"
-                            if decl_node.signature:
-                                node_info += f" {decl_node.signature.unparse()}"
-                            if decl_node.doc:
-                                node_info += f"\n{decl_node.doc.lit_value}"
-                            if decl_node.semstr:
-                                node_info += f"\n{decl_node.semstr.lit_value}"
-                        elif isinstance(decl_node, ast.Name):
-                            if (
-                                decl_node.parent
-                                and isinstance(decl_node.parent, ast.SubNodeList)
-                                and decl_node.parent.parent
-                                and isinstance(decl_node.parent.parent, ast.Assignment)
-                                and decl_node.parent.parent.type_tag
-                            ):
-                                node_info = (
-                                    f"(variable) {decl_node.value}: "
-                                    f"{decl_node.parent.parent.type_tag.unparse()}"
-                                )
-                                if decl_node.parent.parent.semstr:
-                                    node_info += (
-                                        f"\n{decl_node.parent.parent.semstr.lit_value}"
-                                    )
-                            else:
-                                if decl_node.value in [
-                                    "str",
-                                    "int",
-                                    "float",
-                                    "bool",
-                                    "bytes",
-                                    "list",
-                                    "tuple",
-                                    "set",
-                                    "dict",
-                                    "type",
-                                ]:
-                                    node_info = f"({decl_node.value}) Built-in type"
-                                else:
-                                    node_info = f"(variable) {decl_node.value}: None"
-                        elif isinstance(decl_node, ast.HasVar):
-                            if decl_node.type_tag:
-                                node_info = f"(variable) {decl_node.name.value} {decl_node.type_tag.unparse()}"
-                            else:
-                                node_info = f"(variable) {decl_node.name.value}"
-                            if decl_node.semstr:
-                                node_info += f"\n{decl_node.semstr.lit_value}"
-                        elif isinstance(decl_node, ast.ParamVar):
-                            if decl_node.type_tag:
-                                node_info = f"(parameter) {decl_node.name.value} {decl_node.type_tag.unparse()}"
-                            else:
-                                node_info = f"(parameter) {decl_node.name.value}"
-                            if decl_node.semstr:
-                                node_info += f"\n{decl_node.semstr.lit_value}"
-                        elif isinstance(decl_node, ast.ModuleItem):
-                            node_info = (
-                                f"(ModuleItem) {node.value}"  # TODO: Add more info
-                            )
-                        else:
-                            node_info = f"{node.value}"
-                    else:
-                        node_info = f"{node.value}"  # non symbol node
-                else:
-                    return None
-            else:
-                return None
+            if isinstance(node, ast.NameAtom):
+                node = node.name_of
+            access = node.sym.access.value + " " if node.sym else None
+            node_info = (
+                f"({access if access else ''}{node.sym_category.value}) {node.sym_name}"
+            )
+            if node.name_spec.clean_type:
+                node_info += f": {node.name_spec.clean_type}"
+            if isinstance(node, ast.AstSemStrNode) and node.semstr:
+                node_info += f"\n{node.semstr.value}"
+            if isinstance(node, ast.AstDocNode) and node.doc:
+                node_info += f"\n{node.doc.value}"
+            if isinstance(node, ast.Ability) and node.signature:
+                node_info += f"\n{node.signature.unparse()}"
+            self.log_py(f"mypy_node: {node.gen.mypy_ast}")
         except AttributeError as e:
             self.log_warning(f"Attribute error when accessing node attributes: {e}")
         return node_info.strip()
 
+    def get_document_symbols(self, file_path: str) -> list[lspt.DocumentSymbol]:
+        """Return document symbols for a file."""
+        if root_node := self.modules[file_path].ir._sym_tab:
+            return collect_symbols(root_node)
+        return []
+
+    def get_definition(
+        self, file_path: str, position: lspt.Position
+    ) -> Optional[lspt.Location]:
+        """Return definition location for a file."""
+        node_selected: Optional[ast.AstSymbolNode] = find_deepest_symbol_node_at_pos(
+            self.modules[file_path].ir, position.line, position.character
+        )
+        if node_selected:
+            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
+                if node_selected.parent
+                and isinstance(node_selected.parent, ast.AstImplNeedingNode)
+                and isinstance(node_selected.parent.body, ast.AstImplOnlyNode)
+                else (
+                    node_selected.sym.decl
+                    if (node_selected.sym and node_selected.sym.decl)
+                    else node_selected
+                )
+            )
+            self.log_py(f"{node_selected}, {decl_node}")
+            decl_uri = uris.from_fs_path(decl_node.loc.mod_path)
+            try:
+                decl_range = create_range(decl_node.loc)
+            except ValueError:  # 'print' name has decl in 0,0,0,0
+                return None
+            decl_location = lspt.Location(
+                uri=decl_uri,
+                range=decl_range,
+            )
+
+            return decl_location
+        else:
+            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)
@@ -373,3 +430,7 @@ class JacLangServer(LanguageServer):
         """Log an info message."""
         self.show_message_log(message, lspt.MessageType.Info)
         self.show_message(message, lspt.MessageType.Info)
+
+    def log_py(self, message: str) -> None:
+        """Log a message."""
+        logging.info(message)