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

jaclang/compiler/passes/main/tests/test_decl_def_match_pass.py

@@ -1,5 +1,6 @@
 """Test pass module."""
 
+import jaclang.compiler.absyntree as ast
 from jaclang.compiler.compile import jac_file_to_pass
 from jaclang.compiler.passes.main import DeclImplMatchPass
 from jaclang.utils.test import TestCase
@@ -17,15 +18,31 @@ class DeclImplMatchPassTests(TestCase):
         state = jac_file_to_pass(self.fixture_abs_path("base.jac"), DeclImplMatchPass)
         self.assertFalse(state.errors_had)
         self.assertIn("(o)Test.(c)say_hi", state.ir.sym_tab.tab)
-        self.assertIsNotNone(state.ir.sym_tab.tab["(o)Test.(c)say_hi"].decl.body)
+        self.assertIsNotNone(
+            state.ir.sym_tab.tab["(o)Test.(c)say_hi"].decl.name_of.body
+        )
         self.assertIn("(o)Test.(c)__init__", state.ir.sym_tab.tab)
-        self.assertIsNotNone(state.ir.sym_tab.tab["(o)Test.(c)__init__"].decl.body)
+        self.assertIsNotNone(
+            state.ir.sym_tab.tab["(o)Test.(c)__init__"].decl.name_of.body
+        )
 
     def test_ability_connected_to_decl_post(self) -> None:
         """Basic test for pass."""
         state = jac_file_to_pass(self.fixture_abs_path("base2.jac"), DeclImplMatchPass)
         self.assertFalse(state.errors_had)
         self.assertIn("(o)Test.(c)say_hi", state.ir.sym_tab.tab)
-        self.assertIsNotNone(state.ir.sym_tab.tab["(o)Test.(c)say_hi"].decl.body)
+        self.assertIsNotNone(
+            state.ir.sym_tab.tab["(o)Test.(c)say_hi"].decl.name_of.body
+        )
         self.assertIn("(o)Test.(c)__init__", state.ir.sym_tab.tab)
-        self.assertIsNotNone(state.ir.sym_tab.tab["(o)Test.(c)__init__"].decl.body)
+        self.assertIsNotNone(
+            state.ir.sym_tab.tab["(o)Test.(c)__init__"].decl.name_of.body
+        )
+
+    def test_arch_ref_has_sym(self) -> None:
+        """Basic test for pass."""
+        state = jac_file_to_pass(
+            self.fixture_abs_path("defs_and_uses.jac"), DeclImplMatchPass
+        )
+        for i in state.ir.get_all_sub_nodes(ast.ArchRef):
+            self.assertIsNotNone(i.sym)

jaclang/compiler/passes/main/tests/test_def_use_pass.py

@@ -18,13 +18,8 @@ class DefUsePassTests(TestCase):
             file_path=self.fixture_abs_path("defs_and_uses.jac"),
             target=DefUsePass,
         )
-        # for i in state.unlinked:
-        #     print(f"Unlinked {i.__class__.__name__} {i.sym_name} {i.loc}")
-        # for i in state.linked:
-        #     print(
-        #         f"Linked {i.__class__.__name__} {i.sym_name} {i.loc} "
-        #         f", {i.sym_link.decl.loc if i.sym_link else None}"
-        #     )
-        self.assertGreater(len(state.linked), 5)
-        self.assertLess(len(state.warnings_had), 50)
-        self.assertEqual(len(state.errors_had), 0)
+        uses = [i.uses for i in state.ir.sym_tab.kid[0].tab.values()]
+        self.assertEqual(len(uses[1]), 1)
+        self.assertEqual(len(uses[2]), 1)
+        self.assertIn("output", [uses[1][0].sym_name, uses[2][0].sym_name])
+        self.assertIn("message", [uses[1][0].sym_name, uses[2][0].sym_name])

jaclang/compiler/passes/main/type_check_pass.py

@@ -8,9 +8,9 @@ import os
 import pathlib
 import sys
 
-
 import jaclang.compiler.absyntree as ast
 import jaclang.compiler.passes.utils.mypy_ast_build as myab
+from jaclang.compiler.constant import Constants as Con
 from jaclang.compiler.passes import Pass
 
 
@@ -48,6 +48,7 @@ class JacTypeCheckPass(Pass):
         """Call mypy APIs to implement type checking in Jac."""
         # Creating mypy api objects
         options = myab.myb.Options()
+        options.cache_dir = Con.JAC_MYPY_CACHE
         errors = myab.Errors(self, options)
         fs_cache = myab.FileSystemCache()
         search_paths = myab.compute_search_paths([], options, str(self.__path))

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -484,7 +484,7 @@ class JacFormatPass(Pass):
 
         var: Token,
         """
-        self.emit(node, node.var.value)
+        self.emit(node, node.orig.value)
 
     def exit_ability_def(self, node: ast.AbilityDef) -> None:
         """Sub objects.
@@ -1871,6 +1871,32 @@ class JacFormatPass(Pass):
         if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)):
             self.emit_ln(node, "")
 
+    def exit_check_stmt(self, node: ast.CheckStmt) -> None:
+        """Sub objects.
+
+        target: ExprType,
+        """
+        start = True
+        for i in node.kid:
+            if isinstance(i, ast.CommentToken):
+                if i.is_inline:
+                    self.emit(node, f" {i.gen.jac}")
+                else:
+                    if not node.gen.jac.endswith("\n"):
+                        self.emit_ln(node, "")
+                    self.emit_ln(node, "")
+                    self.emit(node, i.gen.jac)
+            elif isinstance(i, ast.Semi):
+                self.emit(node, i.gen.jac)
+            else:
+                if start:
+                    self.emit(node, i.gen.jac)
+                    start = False
+                else:
+                    self.emit(node, f" {i.gen.jac}")
+        if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)):
+            self.emit_ln(node, "")
+
     def exit_ctrl_stmt(self, node: ast.CtrlStmt) -> None:
         """Sub objects.
 
@@ -2002,7 +2028,6 @@ class JacFormatPass(Pass):
         doc: Optional[Token],
         body: CodeBlock,
         """
-        start = True
         for i in node.kid:
             if isinstance(i, ast.CommentToken):
                 if i.is_inline:
@@ -2013,14 +2038,10 @@ class JacFormatPass(Pass):
             elif isinstance(i, ast.Semi):
                 self.emit(node, i.gen.jac)
             elif isinstance(i, ast.Name):
-                if not i.value.startswith("test_t"):
-                    self.emit(node, f" {i.value} ")
+                if not i.value.startswith("_jac_gen_"):
+                    self.emit(node, f" {i.value}")
             else:
-                if start:
-                    self.emit(node, i.gen.jac)
-                    start = False
-                else:
-                    self.emit(node, f" {i.gen.jac}")
+                self.emit(node, i.gen.jac)
         if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)):
             self.emit_ln(node, "")
 

jaclang/compiler/passes/tool/tests/fixtures/corelib.jac

@@ -478,3 +478,19 @@ obj JacPlugin {
 (walker_obj: Any, expr: Any) -> bool {
     return walker_obj._jac_.visit_node(expr);
 }
+
+glob expected_area = 78.53981633974483;
+
+test a1 {
+    check assertAlmostEqual(calculate_area(RAD), expected_area);
+}
+
+test a2 {
+    c = Circle(RAD);
+    check assertAlmostEqual(c.area(), expected_area);
+}
+
+test a3 {
+    c = Circle(RAD);
+    check assertEqual(c.shape_type, ShapeType.CIRCLE);
+}

jaclang/compiler/passes/tool/tests/fixtures/corelib_fmt.jac

@@ -478,3 +478,19 @@ obj JacPlugin {
 (walker_obj: Any, expr: Any) -> bool {
     return walker_obj._jac_.visit_node(expr);
 }
+
+glob expected_area = 78.53981633974483;
+
+test a1 {
+    check assertAlmostEqual(calculate_area(RAD), expected_area);
+}
+
+test a2 {
+    c = Circle(RAD);
+    check assertAlmostEqual(c.area(), expected_area);
+}
+
+test a3 {
+    c = Circle(RAD);
+    check assertEqual(c.shape_type, ShapeType.CIRCLE);
+}

jaclang/compiler/passes/transform.py

@@ -22,7 +22,7 @@ class Alert:
     def __str__(self) -> str:
         """Return string representation of alert."""
         return (
-            f"{self.loc.mod_path}, line {self.loc.first_line},"
+            f" {self.loc.mod_path}, line {self.loc.first_line},"
             f" col {self.loc.col_start}: {self.msg}"
         )
 
@@ -40,7 +40,7 @@ class Transform(ABC, Generic[T]):
         prior: Optional[Transform] = None,
     ) -> None:
         """Initialize pass."""
-        self.logger = logging.getLogger(self.__class__.__module__)
+        self.logger = logging.getLogger(self.__class__.__name__)
         self.errors_had: list[Alert] = [] if not prior else prior.errors_had
         self.warnings_had: list[Alert] = [] if not prior else prior.warnings_had
         self.cur_node: AstNode = input_ir  # tracks current node during traversal
@@ -59,7 +59,6 @@ class Transform(ABC, Generic[T]):
             self.__class__,
         )
         self.errors_had.append(alrt)
-        # print("Error:", str(alrt))
         self.logger.error(str(alrt))
 
     def log_warning(self, msg: str, node_override: Optional[AstNode] = None) -> None:
@@ -70,5 +69,4 @@ class Transform(ABC, Generic[T]):
             self.__class__,
         )
         self.warnings_had.append(alrt)
-        # print("Warning:", str(alrt))
         self.logger.warning(str(alrt))

jaclang/{core/registry.py → compiler/semtable.py}

@@ -12,9 +12,7 @@ from typing import Optional
 class SemInfo:
     """Semantic information class."""
 
-    def __init__(
-        self, name: str, type: Optional[str] = None, semstr: Optional[str] = None
-    ) -> None:
+    def __init__(self, name: str, type: Optional[str] = None, semstr: str = "") -> None:
         """Initialize the class."""
         self.name = name
         self.type = type

jaclang/compiler/symtable.py

@@ -37,30 +37,13 @@ class SymbolType(Enum):
     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 SymbolInfo:
-    """Symbol Info."""
-
-    def __init__(
-        self, typ: str = "NoType", acc_tag: Optional[SymbolAccess] = None
-    ) -> None:  # noqa: ANN401
-        """Initialize."""
-        self.typ = typ
-        self.acc_tag: Optional[SymbolAccess] = acc_tag
-        self.typ_sym_table: Optional[SymbolTable] = None
-
-    @property
-    def clean_type(self) -> str:
-        """Get clean type."""
-        ret_type = self.typ.replace("builtins.", "").replace("NoType", "")
-        return ret_type
-
-
 class SymbolAccess(Enum):
     """Symbol types."""
 
@@ -80,20 +63,19 @@ class Symbol:
 
     def __init__(
         self,
-        defn: ast.AstSymbolNode,
+        defn: ast.NameAtom,
         access: SymbolAccess,
         parent_tab: SymbolTable,
-        typ: Optional[type] = None,
     ) -> None:
         """Initialize."""
-        self.typ = typ
-        self.defn: list[ast.AstSymbolNode] = [defn]
-        defn.sym_link = self
-        self.access = access
+        self.defn: list[ast.NameAtom] = [defn]
+        self.uses: list[ast.NameAtom] = []
+        defn.sym = self
+        self.access: SymbolAccess = access
         self.parent_tab = parent_tab
 
     @property
-    def decl(self) -> ast.AstSymbolNode:
+    def decl(self) -> ast.NameAtom:
         """Get decl."""
         return self.defn[0]
 
@@ -105,10 +87,10 @@ class Symbol:
     @property
     def sym_type(self) -> SymbolType:
         """Get sym_type."""
-        return self.decl.sym_type
+        return self.decl.sym_category
 
     @property
-    def sym_path_str(self) -> str:
+    def sym_dotted_name(self) -> str:
         """Return a full path of the symbol."""
         out = [self.defn[0].sym_name]
         current_tab = self.parent_tab
@@ -121,17 +103,19 @@ class Symbol:
         out.reverse()
         return ".".join(out)
 
-    def add_defn(self, node: ast.AstSymbolNode) -> None:
+    def add_defn(self, node: ast.NameAtom) -> None:
         """Add defn."""
         self.defn.append(node)
-        node.sym_link = self
+        node.sym = self
+
+    def add_use(self, node: ast.NameAtom) -> None:
+        """Add use."""
+        self.uses.append(node)
+        node.sym = self
 
     def __repr__(self) -> str:
         """Repr."""
-        return (
-            f"Symbol({self.sym_name}, {self.sym_type}, {self.access}, "
-            f"{self.typ}, {self.defn})"
-        )
+        return f"Symbol({self.sym_name}, {self.sym_type}, {self.access}, {self.defn})"
 
 
 class SymbolTable:
@@ -146,7 +130,7 @@ class SymbolTable:
         self.parent = parent if parent else self
         self.kid: list[SymbolTable] = []
         self.tab: dict[str, Symbol] = {}
-        self.uses: list[ast.AstSymbolNode] = []
+        self.inherit: list[SymbolTable] = []
 
     def has_parent(self) -> bool:
         """Check if has parent."""
@@ -162,6 +146,10 @@ class SymbolTable:
         """Lookup a variable in the symbol table."""
         if name in self.tab:
             return self.tab[name]
+        for i in self.inherit:
+            found = i.lookup(name, deep=False)
+            if found:
+                return found
         if deep and self.has_parent():
             return self.get_parent().lookup(name, deep)
         return None
@@ -184,7 +172,7 @@ class SymbolTable:
         )
         if node.sym_name not in self.tab:
             self.tab[node.sym_name] = Symbol(
-                defn=node,
+                defn=node.name_spec,
                 access=(
                     access_spec
                     if isinstance(access_spec, SymbolAccess)
@@ -193,8 +181,8 @@ class SymbolTable:
                 parent_tab=self,
             )
         else:
-            self.tab[node.sym_name].add_defn(node)
-        node.sym_link = self.tab[node.sym_name]
+            self.tab[node.sym_name].add_defn(node.name_spec)
+        node.name_spec.sym = self.tab[node.sym_name]
         return collision
 
     def find_scope(self, name: str) -> Optional[SymbolTable]:

jaclang/compiler/tests/test_parser.py

@@ -102,9 +102,9 @@ class TestLarkParser(TestCaseMicroSuite):
             "JacSource",
             "EmptyToken",
             "AstSymbolNode",
+            "AstSymbolStubNode",
             "AstImplNeedingNode",
             "AstAccessNode",
-            "TokenSymbol",
             "Literal",
             "AstDocNode",
             "AstSemStrNode",
@@ -119,7 +119,7 @@ class TestLarkParser(TestCaseMicroSuite):
             "ArchBlockStmt",
             "EnumBlockStmt",
             "CodeBlockStmt",
-            "NameSpec",
+            "NameAtom",
             "ArchSpec",
             "MatchPattern",
         ]

jaclang/core/aott.py

@@ -17,8 +17,8 @@ try:
 except ImportError:
     Image = None
 
+from jaclang.compiler.semtable import SemInfo, SemRegistry, SemScope
 from jaclang.core.llms.base import BaseLLM
-from jaclang.core.registry import SemInfo, SemRegistry, SemScope
 
 
 IMG_FORMATS = ["PngImageFile", "JpegImageFile"]
@@ -108,7 +108,7 @@ def get_info_types(
                 else None
             )
             info_str.append(
-                f"{sem_info.semstr} ({sem_info.name}) ({sem_info.type}) = {get_object_string(incl[1])}"
+                f"{sem_info.semstr} ({sem_info.name}) ({sem_info.type}) = {get_object_string(incl[1])}".strip()
             )
     return ("\n".join(info_str), collected_types)
 
@@ -179,7 +179,7 @@ def get_type_explanation(
         if sem_info.type == "Enum" and isinstance(type_info, list):
             for enum_item in type_info:
                 type_info_str.append(
-                    f"{enum_item.semstr} ({enum_item.name}) (EnumItem)"
+                    f"{enum_item.semstr} ({enum_item.name}) (EnumItem)".strip()
                 )
             type_example[0] = type_example[0].replace("(", f".{enum_item.name}")
         elif sem_info.type in ["obj", "class", "node", "edge"] and isinstance(
@@ -189,7 +189,7 @@ def get_type_explanation(
                 if arch_item.type in ["obj", "class", "node", "edge"]:
                     continue
                 type_info_str.append(
-                    f"{arch_item.semstr} ({arch_item.name}) ({arch_item.type})"
+                    f"{arch_item.semstr} ({arch_item.name}) ({arch_item.type})".strip()
                 )
                 type_example.append(f"{arch_item.name}={arch_item.type}, ")
                 if arch_item.type and extract_non_primary_type(arch_item.type):
@@ -199,7 +199,7 @@ def get_type_explanation(
             else:
                 type_example.append(")")
         return (
-            f"{sem_info.semstr} ({sem_info.name}) ({sem_info.type}) eg:- {''.join(type_example)} -> {', '.join(type_info_str)}",  # noqa: E501
+            f"{sem_info.semstr} ({sem_info.name}) ({sem_info.type}) eg:- {''.join(type_example)} -> {', '.join(type_info_str)}".strip(),  # noqa: E501
             set(type_info_types),
         )
     return None, None
@@ -270,7 +270,7 @@ def get_input_information(
             typ_anno = get_type_annotation(i[3])
             type_collector.extend(extract_non_primary_type(typ_anno))
             inputs_information_list.append(
-                f"{i[0]} ({i[2]}) ({typ_anno}) = {get_object_string(i[3])}"
+                f"{i[0] if i[0] else ''} ({i[2]}) ({typ_anno}) = {get_object_string(i[3])}".strip()
             )
         return "\n".join(inputs_information_list)
     else:
@@ -281,7 +281,7 @@ def get_input_information(
                 image_repr: list[dict] = [
                     {
                         "type": "text",
-                        "text": f"{i[0]} ({i[2]}) (Image) = ",
+                        "text": f"{i[0] if i[0] else ''} ({i[2]}) (Image) = ".strip(),
                     },
                     {"type": "image_url", "image_url": {"url": img_base64}},
                 ]
@@ -292,7 +292,7 @@ def get_input_information(
             inputs_information_dict_list.append(
                 {
                     "type": "text",
-                    "text": f"{i[0]} ({i[2]}) ({typ_anno}) = {get_object_string(i[3])}",
+                    "text": f"{i[0] if i[0] else ''} ({i[2]}) ({typ_anno}) = {get_object_string(i[3])}".strip(),
                 }
             )
         return inputs_information_dict_list