jaclang 0.7.14__py3-none-any.whl → 0.7.16__py3-none-any.whl

jaclang/compiler/passes/tool/tests/fixtures/general_format_checks/long_names.jac

@@ -0,0 +1,19 @@
+with entry {
+    long_variable_name_1 = another_long_variable_name_2
+        = yet_another_long_variable_name_3
+        = still_another_long_variable_name_4
+        = yet_still_another_long_variable_name_5
+        = one_more_long_variable_name_6
+        = and_another_long_variable_name_7
+        = final_long_variable_name_8
+        =1.5;
+    result = long_variable_name_1
+        + another_long_variable_name_2
+        * yet_another_long_variable_name_3
+        - still_another_long_variable_name_4
+        / yet_still_another_long_variable_name_5
+        + one_more_long_variable_name_6
+        * and_another_long_variable_name_7
+        - final_long_variable_name_8;
+    print("The result of the ugly calculation is:", result);
+}

jaclang/compiler/passes/tool/tests/fixtures/general_format_checks/triple_quoted_string.jac

@@ -0,0 +1,6 @@
+with entry {
+    triple_quoted_string = """This is a triple quoted string.
+    It can span multiple lines.
+    It can contain any number of quotes or apostrophes.
+    """;
+}

jaclang/compiler/passes/tool/tests/test_jac_format_pass.py

@@ -102,6 +102,17 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
                 file_path = os.path.join(fixtures_dir, file_name)
                 self.compare_files(file_path)
 
+    def test_general_format_fixtures(self) -> None:
+        """Tests if files in the general fixtures directory do not change after being formatted."""
+        fixtures_dir = os.path.join(self.fixture_abs_path(""), "general_format_checks")
+        fixture_files = os.listdir(fixtures_dir)
+        for file_name in fixture_files:
+            if file_name == "__jac_gen__":
+                continue
+            with self.subTest(file=file_name):
+                file_path = os.path.join(fixtures_dir, file_name)
+                self.compare_files(file_path)
+
     def micro_suite_test(self, filename: str) -> None:
         """Parse micro jac file."""
         code_gen_pure = jac_file_to_pass(

jaclang/compiler/passes/tool/tests/test_unparse_validate.py

@@ -33,47 +33,41 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
 
     def micro_suite_test(self, filename: str) -> None:
         """Parse micro jac file."""
-        try:
-            code_gen_pure = jac_file_to_pass(
-                self.fixture_abs_path(filename),
-                target=PyastGenPass,
-                schedule=without_format,
+        code_gen_pure = jac_file_to_pass(
+            self.fixture_abs_path(filename),
+            target=PyastGenPass,
+            schedule=without_format,
+        )
+        before = ast3.dump(code_gen_pure.ir.gen.py_ast[0], indent=2)
+        x = code_gen_pure.ir.unparse()
+        # print(x)
+        # print(f"Testing {code_gen_pure.ir.name}")
+        # print(code_gen_pure.ir.pp())
+        code_gen_jac = jac_str_to_pass(
+            jac_str=x,
+            file_path=filename,
+            target=PyastGenPass,
+            schedule=without_format,
+        )
+        after = ast3.dump(code_gen_jac.ir.gen.py_ast[0], indent=2)
+        if "circle_clean_tests.jac" in filename:
+            self.assertEqual(
+                len(
+                    [
+                        i
+                        for i in unified_diff(
+                            before.splitlines(), after.splitlines(), n=0
+                        )
+                        if "test" not in i
+                    ]
+                ),
+                5,
             )
-            before = ast3.dump(code_gen_pure.ir.gen.py_ast[0], indent=2)
-            x = code_gen_pure.ir.unparse()
-            # print(x)
-            # print(f"Testing {code_gen_pure.ir.name}")
-            # print(code_gen_pure.ir.pp())
-            code_gen_jac = jac_str_to_pass(
-                jac_str=x,
-                file_path=filename,
-                target=PyastGenPass,
-                schedule=without_format,
+        else:
+            self.assertEqual(
+                len("\n".join(unified_diff(before.splitlines(), after.splitlines()))),
+                0,
             )
-            after = ast3.dump(code_gen_jac.ir.gen.py_ast[0], indent=2)
-            if "circle_clean_tests.jac" in filename:
-                self.assertEqual(
-                    len(
-                        [
-                            i
-                            for i in unified_diff(
-                                before.splitlines(), after.splitlines(), n=0
-                            )
-                            if "test" not in i
-                        ]
-                    ),
-                    5,
-                )
-            else:
-                self.assertEqual(
-                    len(
-                        "\n".join(unified_diff(before.splitlines(), after.splitlines()))
-                    ),
-                    0,
-                )
-
-        except Exception as e:
-            raise e
 
 
 JacUnparseTests.self_attach_micro_tests()

jaclang/compiler/passes/transform.py

@@ -70,3 +70,7 @@ class Transform(ABC, Generic[T]):
         )
         self.warnings_had.append(alrt)
         self.logger.warning(str(alrt))
+
+    def log_info(self, msg: str) -> None:
+        """Log info."""
+        self.logger.info(msg)

jaclang/compiler/semtable.py

@@ -6,14 +6,24 @@ semantic information.
 
 from __future__ import annotations
 
-from typing import Optional
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import jaclang.compiler.absyntree as ast
 
 
 class SemInfo:
     """Semantic information class."""
 
-    def __init__(self, name: str, type: Optional[str] = None, semstr: str = "") -> None:
+    def __init__(
+        self,
+        node: ast.AstNode,
+        name: str,
+        type: Optional[str] = None,
+        semstr: str = "",
+    ) -> None:
         """Initialize the class."""
+        self.node = node
         self.name = name
         self.type = type
         self.semstr = semstr
@@ -22,6 +32,17 @@ class SemInfo:
         """Return the string representation of the class."""
         return f"{self.semstr} ({self.type}) ({self.name})"
 
+    def get_children(
+        self, sem_registry: SemRegistry, filter: Optional[type[ast.AstNode]] = None
+    ) -> list[SemInfo]:
+        """Get the children of the SemInfo."""
+        scope, _ = sem_registry.lookup(name=self.name)
+        self_scope = str(scope) + f".{self.name}({self.type})"
+        _, children = sem_registry.lookup(scope=SemScope.get_scope_from_str(self_scope))
+        if filter and children and isinstance(children, list):
+            return [i for i in children if isinstance(i.node, filter)]
+        return children if children and isinstance(children, list) else []
+
 
 class SemScope:
     """Scope class."""
@@ -38,7 +59,8 @@ class SemScope:
         """Return the string representation of the class."""
         if self.parent:
             return f"{self.parent}.{self.scope}({self.type})"
-        return f"{self.scope}({self.type})"
+        else:
+            return f"{self.scope}({self.type})"
 
     def __repr__(self) -> str:
         """Return the string representation of the class."""
@@ -57,7 +79,7 @@ class SemScope:
 
     @property
     def as_type_str(self) -> Optional[str]:
-        """Return the type string representation of the SemsScope."""
+        """Return the type string representation of the SemScope."""
         if self.type not in ["class", "node", "obj"]:
             return None
         type_str = self.scope
@@ -127,9 +149,11 @@ class SemRegistry:
                 break
         return i
 
-    def pp(self) -> None:
+    def pp(self) -> str:
         """Pretty print the registry."""
+        ret_str = ""
         for k, v in self.registry.items():
-            print(k)
+            ret_str += f"{k}\n"
             for i in v:
-                print(f"  {i.name} {i.type} {i.semstr}")
+                ret_str += f"  {i.name} {i.type} {i.semstr}\n"
+        return ret_str

jaclang/compiler/tests/test_importer.py

@@ -5,6 +5,7 @@ import sys
 
 from jaclang import jac_import
 from jaclang.cli import cli
+from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.utils.test import TestCase
 
 
@@ -17,13 +18,15 @@ class TestLoader(TestCase):
 
     def test_import_basic_python(self) -> None:
         """Test basic self loading."""
+        Jac.context().init_memory(base_path=self.fixture_abs_path(__file__))
         (h,) = jac_import("fixtures.hello_world", base_path=__file__)
         self.assertEqual(h.hello(), "Hello World!")  # type: ignore
 
     def test_modules_correct(self) -> None:
         """Test basic self loading."""
+        Jac.context().init_memory(base_path=self.fixture_abs_path(__file__))
         jac_import("fixtures.hello_world", base_path=__file__)
-        self.assertIn("module 'hello_world'", str(sys.modules))
+        self.assertIn("module 'fixtures.hello_world'", str(sys.modules))
         self.assertIn("/tests/fixtures/hello_world.jac", str(sys.modules))
 
     def test_jac_py_import(self) -> None:
@@ -39,11 +42,15 @@ class TestLoader(TestCase):
             stdout_value,
         )
 
-    def test_package_import(self) -> None:
-        """Test package import."""
+    def test_jac_py_import_auto(self) -> None:
+        """Basic test for pass."""
         captured_output = io.StringIO()
         sys.stdout = captured_output
-        cli.run(self.fixture_abs_path("../../../tests/fixtures/package_import.jac"))
+        cli.run(self.fixture_abs_path("../../../tests/fixtures/jp_importer_auto.jac"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
-        self.assertEqual("package is imported successfully!\n", stdout_value)
+        self.assertIn("Hello World!", stdout_value)
+        self.assertIn(
+            "{SomeObj(a=10): 'check'} [MyObj(apple=5, banana=7), MyObj(apple=5, banana=7)]",
+            stdout_value,
+        )

jaclang/langserve/engine.py

@@ -4,25 +4,26 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import time
 from concurrent.futures import ThreadPoolExecutor
 from typing import Callable, Optional
 
-
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.compile import jac_str_to_pass
 from jaclang.compiler.parser import JacParser
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.compiler.passes.tool import FuseCommentsPass, JacFormatPass
+from jaclang.langserve.sem_manager import SemTokManager
 from jaclang.langserve.utils import (
     collect_all_symbols_in_scope,
-    collect_symbols,
     create_range,
     find_deepest_symbol_node_at_pos,
+    find_index,
     gen_diagnostics,
     get_item_path,
     get_mod_path,
-    locate_affected_token,
+    get_symbols_for_outline,
     parse_symbol_path,
     resolve_completion_symbol_table,
 )
@@ -43,104 +44,13 @@ class ModuleInfo:
         """Initialize module info."""
         self.ir = ir
         self.impl_parent: Optional[ModuleInfo] = impl_parent
-        self.sem_tokens: list[int] = self.gen_sem_tokens()
+        self.sem_manager = SemTokManager(ir=ir)
 
     @property
     def uri(self) -> str:
         """Return uri."""
         return uris.from_fs_path(self.ir.loc.mod_path)
 
-    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
-
-    def update_sem_tokens(
-        self, content_changes: lspt.DidChangeTextDocumentParams
-    ) -> list[int]:
-        """Update semantic tokens on change."""
-        for change in [
-            x
-            for x in content_changes.content_changes
-            if isinstance(x, lspt.TextDocumentContentChangeEvent_Type1)
-        ]:
-            change_start_line = change.range.start.line
-            change_start_char = change.range.start.character
-            change_end_line = change.range.end.line
-            change_end_char = change.range.end.character
-
-            line_delta = change.text.count("\n") - (change_end_line - change_start_line)
-            if line_delta == 0:
-                char_delta = len(change.text) - (change_end_char - change_start_char)
-            else:
-                last_newline_index = change.text.rfind("\n")
-                char_delta = (
-                    len(change.text)
-                    - last_newline_index
-                    - 1
-                    - change_end_char
-                    + change_start_char
-                )
-
-            changed_token_index = locate_affected_token(
-                self.sem_tokens,
-                change_start_line,
-                change_start_char,
-                change_end_line,
-                change_end_char,
-            )
-            if changed_token_index:
-                self.sem_tokens[changed_token_index + 2] = max(
-                    1, self.sem_tokens[changed_token_index + 2] + char_delta
-                )
-                if (
-                    len(self.sem_tokens) > changed_token_index + 5
-                    and self.sem_tokens[changed_token_index + 5] == 0
-                ):
-                    next_token_index = changed_token_index + 5
-                    self.sem_tokens[next_token_index + 1] = max(
-                        0, self.sem_tokens[next_token_index + 1] + char_delta
-                    )
-                    return self.sem_tokens
-
-            current_token_index = 0
-            line_offset = 0
-            while current_token_index < len(self.sem_tokens):
-                token_line_number = self.sem_tokens[current_token_index] + line_offset
-                token_start_pos = self.sem_tokens[current_token_index + 1]
-
-                if token_line_number > change_start_line or (
-                    token_line_number == change_start_line
-                    and token_start_pos >= change_start_char
-                ):
-                    self.sem_tokens[current_token_index] += line_delta
-                    if token_line_number == change_start_line:
-                        self.sem_tokens[current_token_index + 1] += char_delta
-                    if token_line_number > change_end_line or (
-                        token_line_number == change_end_line
-                        and token_start_pos >= change_end_char
-                    ):
-                        break
-                line_offset += self.sem_tokens[current_token_index]
-                current_token_index += 5
-        return self.sem_tokens
-
 
 class JacLangServer(LanguageServer):
     """Class for managing workspace."""
@@ -190,6 +100,7 @@ class JacLangServer(LanguageServer):
     def deep_check(self, file_path: str, annex_view: Optional[str] = None) -> bool:
         """Rebuild a file and its dependencies."""
         try:
+            start_time = time.time()
             document = self.workspace.get_text_document(file_path)
             if file_path in self.modules and (
                 parent := self.modules[file_path].impl_parent
@@ -209,13 +120,14 @@ class JacLangServer(LanguageServer):
                 )
 
             self.publish_diagnostics(
-                file_path,
+                annex_view if annex_view else file_path,
                 gen_diagnostics(
                     annex_view if annex_view else file_path,
                     build.errors_had,
                     build.warnings_had,
                 ),
             )
+            self.log_py(f"PROFILE: Deep check took {time.time() - start_time} seconds.")
             return len(build.errors_had) == 0
         except Exception as e:
             self.log_error(f"Error during deep check: {e}")
@@ -256,12 +168,12 @@ class JacLangServer(LanguageServer):
         current_line = document.lines[position.line]
         current_pos = position.character
         current_symbol_path = parse_symbol_path(current_line, current_pos)
+
         node_selected = find_deepest_symbol_node_at_pos(
             self.modules[file_path].ir,
             position.line,
             position.character - 2,
         )
-
         mod_tab = (
             self.modules[file_path].ir.sym_tab
             if not node_selected
@@ -269,15 +181,30 @@ class JacLangServer(LanguageServer):
         )
         current_tab = self.modules[file_path].ir._sym_tab
         current_symbol_table = mod_tab
+
         if completion_trigger == ".":
-            completion_items = resolve_completion_symbol_table(
-                mod_tab, current_symbol_path, current_tab
-            )
+            if current_symbol_path:
+                completion_items = resolve_completion_symbol_table(
+                    mod_tab, current_symbol_path, current_tab
+                )
+            else:
+                completion_items = []
         else:
-            try:  # noqa SIM105
-                completion_items = collect_all_symbols_in_scope(current_symbol_table)
-            except AttributeError:
-                pass
+            if node_selected and (
+                node_selected.find_parent_of_type(ast.Architype)
+                or node_selected.find_parent_of_type(ast.AbilityDef)
+            ):
+                self_symbol = [
+                    lspt.CompletionItem(
+                        label="self", kind=lspt.CompletionItemKind.Variable
+                    )
+                ]
+            else:
+                self_symbol = []
+
+            completion_items = (
+                collect_all_symbols_in_scope(current_symbol_table) + self_symbol
+            )
         return lspt.CompletionList(is_incomplete=False, items=completion_items)
 
     def rename_module(self, old_path: str, new_path: str) -> None:
@@ -327,9 +254,16 @@ class JacLangServer(LanguageServer):
         """Return hover information for a file."""
         if file_path not in self.modules:
             return None
-        node_selected = find_deepest_symbol_node_at_pos(
-            self.modules[file_path].ir, position.line, position.character
+        token_index = find_index(
+            self.modules[file_path].sem_manager.sem_tokens,
+            position.line,
+            position.character,
         )
+        if token_index is None:
+            return None
+        node_selected = self.modules[file_path].sem_manager.static_sem_tokens[
+            token_index
+        ][3]
         value = self.get_node_info(node_selected) if node_selected else None
         if value:
             return lspt.Hover(
@@ -361,12 +295,12 @@ class JacLangServer(LanguageServer):
             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]:
+    def get_outline(self, file_path: str) -> list[lspt.DocumentSymbol]:
         """Return document symbols for a file."""
         if file_path in self.modules and (
             root_node := self.modules[file_path].ir._sym_tab
         ):
-            return collect_symbols(root_node)
+            return get_symbols_for_outline(root_node)
         return []
 
     def get_definition(
@@ -375,9 +309,16 @@ class JacLangServer(LanguageServer):
         """Return definition location for a file."""
         if file_path not in self.modules:
             return None
-        node_selected: Optional[ast.AstSymbolNode] = find_deepest_symbol_node_at_pos(
-            self.modules[file_path].ir, position.line, position.character
+        token_index = find_index(
+            self.modules[file_path].sem_manager.sem_tokens,
+            position.line,
+            position.character,
         )
+        if token_index is None:
+            return None
+        node_selected = self.modules[file_path].sem_manager.static_sem_tokens[
+            token_index
+        ][3]
         if node_selected:
             if (
                 isinstance(node_selected, ast.Name)
@@ -400,13 +341,13 @@ class JacLangServer(LanguageServer):
             ):
                 path_range = get_item_path(node_selected.parent)
                 if path_range:
-                    path, range = path_range
-                    if path and range:
+                    path, loc_range = path_range
+                    if path and loc_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),
+                                start=lspt.Position(line=loc_range[0], character=0),
+                                end=lspt.Position(line=loc_range[1], character=5),
                             ),
                         )
                 else:
@@ -424,7 +365,6 @@ class JacLangServer(LanguageServer):
                     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)
@@ -443,9 +383,16 @@ class JacLangServer(LanguageServer):
         self, file_path: str, position: lspt.Position
     ) -> list[lspt.Location]:
         """Return references for a file."""
-        node_selected = find_deepest_symbol_node_at_pos(
-            self.modules[file_path].ir, position.line, position.character
+        if file_path not in self.modules:
+            return []
+        index1 = find_index(
+            self.modules[file_path].sem_manager.sem_tokens,
+            position.line,
+            position.character,
         )
+        if index1 is None:
+            return []
+        node_selected = self.modules[file_path].sem_manager.static_sem_tokens[index1][3]
         if node_selected and node_selected.sym:
             list_of_references: list[lspt.Location] = [
                 lspt.Location(
@@ -461,7 +408,7 @@ class JacLangServer(LanguageServer):
         """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)
+        return lspt.SemanticTokens(data=self.modules[file_path].sem_manager.sem_tokens)
 
     def log_error(self, message: str) -> None:
         """Log an error message."""