jaclang 0.0.5__py3-none-any.whl → 0.0.8__py3-none-any.whl

jaclang/jac/symtable.py

@@ -0,0 +1,154 @@
+"""Jac Symbol Table."""
+from __future__ import annotations
+
+from enum import Enum
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import jaclang.jac.absyntree as ast
+
+
+class SymbolType(Enum):
+    """Symbol types."""
+
+    VAR = "var"
+    ABILITY = "ability"
+    ARCH = "arch"
+    IMPL = "impl"
+    HAS = "field"
+
+
+class SymbolHitType(Enum):
+    """Symbol types."""
+
+    DECL = "decl"
+    DEFN = "defn"
+    DECL_DEFN = "decl_defn"
+    USE = "use"
+
+
+class Symbol:
+    """Symbol."""
+
+    def __init__(
+        self,
+        name: str,
+        sym_type: SymbolType,
+        typ: Optional[type] = None,
+        decl: Optional[ast.AstNode] = None,
+        defn: Optional[list[ast.AstNode]] = None,
+        uses: Optional[list[ast.AstNode]] = None,
+    ) -> None:
+        """Initialize."""
+        self.name = name
+        self.sym_type = sym_type
+        self.typ = typ
+        self.decl = decl
+        self.defn: list[ast.AstNode] = defn if defn else []
+        self.uses: list[ast.AstNode] = uses if uses else []
+
+    def __repr__(self) -> str:
+        """Repr."""
+        return (
+            f"Symbol({self.name}, {self.sym_type}, {self.typ}, "
+            f"{self.decl}, {self.defn}, {self.uses})"
+        )
+
+
+class SymbolTable:
+    """Symbol Table."""
+
+    def __init__(
+        self, name: str, key_node: ast.AstNode, parent: Optional[SymbolTable] = None
+    ) -> None:
+        """Initialize."""
+        self.name = name
+        self.key_node = key_node
+        self.parent = parent if parent else self
+        self.kid: list[SymbolTable] = []
+        self.tab: dict[str, Symbol] = {}
+
+    def has_parent(self) -> bool:
+        """Check if has parent."""
+        return self.parent != self
+
+    def get_parent(self) -> SymbolTable:
+        """Get parent."""
+        if self.parent == self:
+            raise Exception("No parent")
+        return self.parent
+
+    def lookup(
+        self, name: str, sym_hit: Optional[SymbolHitType] = None, deep: bool = True
+    ) -> Optional[Symbol]:
+        """Lookup a variable in the symbol table."""
+        if name in self.tab and (
+            not sym_hit
+            or (sym_hit == SymbolHitType.DECL and self.tab[name].decl)
+            or (sym_hit == SymbolHitType.DEFN and len(self.tab[name].defn))
+            or (
+                sym_hit == SymbolHitType.DECL_DEFN
+                and (self.tab[name].decl or len(self.tab[name].defn))
+            )
+            or (sym_hit == SymbolHitType.USE and len(self.tab[name].uses))
+        ):
+            return self.tab[name]
+        if deep and self.has_parent():
+            return self.get_parent().lookup(name, sym_hit, deep)
+        return None
+
+    def insert(
+        self,
+        name: str,
+        sym_type: SymbolType,
+        sym_hit: SymbolHitType,
+        node: ast.AstNode,
+        single: bool = False,
+    ) -> Optional[ast.AstNode]:
+        """Set a variable in the symbol table.
+
+        Returns original symbol single check fails.
+        """
+        if single:
+            if (
+                sym_hit in [SymbolHitType.DECL, SymbolHitType.DECL_DEFN]
+                and name in self.tab
+                and self.tab[name].decl
+            ):
+                return self.tab[name].decl
+            elif (
+                sym_hit in [SymbolHitType.DEFN, SymbolHitType.DECL_DEFN]
+                and name in self.tab
+                and len(self.tab[name].defn)
+            ):
+                return self.tab[name].defn[-1]
+            elif (
+                sym_hit == SymbolHitType.USE
+                and name in self.tab
+                and len(self.tab[name].uses)
+            ):
+                return self.tab[name].uses[-1]
+        if name not in self.tab:
+            self.tab[name] = Symbol(name=name, sym_type=sym_type)
+        if sym_hit == SymbolHitType.DECL:
+            self.tab[name].decl = node
+        elif sym_hit == SymbolHitType.DEFN:
+            self.tab[name].defn.append(node)
+        elif sym_hit == SymbolHitType.DECL_DEFN:
+            self.tab[name].defn.append(node)
+            if not self.tab[name].decl:
+                self.tab[name].decl = node
+        elif sym_hit == SymbolHitType.USE:
+            self.tab[name].uses.append(node)
+
+    def push_scope(self, name: str, key_node: ast.AstNode) -> SymbolTable:
+        """Push a new scope onto the symbol table."""
+        self.kid.append(SymbolTable(name, key_node, self))
+        return self.kid[-1]
+
+    def __repr__(self) -> str:
+        """Repr."""
+        out = f"{self.name} {super().__repr__()}:\n"
+        for k, v in self.tab.items():
+            out += f"    {k}: {v}\n"
+        return out

jaclang/jac/tests/fixtures/__jac_gen__/hello_world.py

@@ -0,0 +1,16 @@
+""" Basic Hello World function """  # 0 1
+from __future__ import annotations
+import traceback as __jac_traceback__  # -1 0
+from jaclang import handle_jac_error as __jac_error__  # -1 0
+def hello():  # 0 3
+    try:      # 0 3
+        return "Hello World!"  # 0 4
+    except Exception as e:      # 0 3
+        tb = __jac_traceback__.extract_tb(e.__traceback__)          # 0 3
+        __jac_tmp__ = __jac_error__(_jac_pycodestring_, e, tb)          # 0 3
+        e.args = (f'{e.args[0]}\n' + __jac_tmp__,) + e.args[1:] if 'Jac error originates from...' not in str(e) else e.args          # 0 3
+        raise e          # 0 3
+
+r""" JAC DEBUG INFO
+/home/ninja/jaclang/jaclang/jac/tests/fixtures/hello_world.jac
+JAC DEBUG INFO """

jaclang/jac/tests/fixtures/fam.jac

@@ -41,14 +41,13 @@ walker tourist {
     has passport: list[str];
 
     can make_visit with location|other exit {
-        b=:g:stuff:w:tourist;
-        a = spawn :g:stuff:w:tourist;
-        a = spawn :w:tourist;
-        a = <-[:g:edget:e:myedge:a==1,b==2]-;
-        a = b +[:g:edget:e:myedge:a=1]+> c;
-        a = b <+[:g:edget:e:myedge:a=1]+ c;
-        a = <here> +[:g:edget:e:myedge:a=1]+> spawn :g:stuff:n:tourist;
-        :g:stuff:w:tourist |> <here>;
+        b=tourist;
+        a = spawn tourist;
+        a = <-[myedge:a==1,b==2]-;
+        a = b +[myedge:a=1]+> c;
+        a = b <+[myedge:a=1]+ c;
+        a = <here> +[myedge:a=1]+> spawn tourist;
+        tourist |> <here>;
         report <h>.activities;
     }
 

jaclang/jac/tests/fixtures/mod_doc_test.jac

@@ -0,0 +1 @@
+with entry { print("hello"); }

jaclang/jac/tests/test_parser.py

@@ -45,6 +45,14 @@ class TestParser(TestCaseMicroSuite):
         self.assertFalse(prse.errors_had)
         self.assertIn("'name': 'KWESC_NAME', 'value': 'walker'", str(output.to_dict()))
 
+    def test_no_mod_doc(self) -> None:
+        """Basic test for parsing."""
+        lex = JacLexer(
+            mod_path="mod_doc_test.jac", input_ir=self.load_fixture("mod_doc_test.jac")
+        ).ir
+        prse = JacParser(mod_path="mod_doc_test.jac", input_ir=lex)
+        self.assertFalse(prse.errors_had)
+
     def test_parsing_jac_cli(self) -> None:
         """Basic test for parsing."""
         lex = JacLexer(

jaclang/jac/transform.py

@@ -5,28 +5,55 @@ import os
 from abc import ABC, ABCMeta, abstractmethod
 from typing import Optional
 
-
 from jaclang.jac.absyntree import AstNode
+from jaclang.jac.constant import Constants as Con, Values as Val
+from jaclang.utils.helpers import add_line_numbers, clip_code_section
 from jaclang.utils.log import logging
-from jaclang.utils.sly.lex import LexerMeta
-from jaclang.utils.sly.yacc import ParserMeta
+from jaclang.vendor.sly.lex import LexerMeta
+from jaclang.vendor.sly.yacc import ParserMeta
+
+
+class Alert:
+    """Alert interface."""
+
+    def __init__(self, msg: str, mod: str, line: int) -> None:
+        """Initialize alert."""
+        self.msg = msg
+        self.mod = mod
+        self.line = line
+
+    def __str__(self) -> str:
+        """Return string representation of alert."""
+        mod_path = os.path.relpath(self.mod, start=os.getcwd())
+        return f"{mod_path}, line {self.line}: {self.msg}"
 
 
 class TransformError(Exception):
     """Error during transformation."""
 
-    def __init__(self, message: str, errors: list[str], warnings: list[str]) -> None:
+    def __init__(
+        self, message: str, errors: list[Alert], warnings: list[Alert]
+    ) -> None:
         """Initialize error."""
         self.errors = errors
         self.warnings = warnings
         if len(errors):
             message += "\nErrors:"
             for i in self.errors:
-                message += "\n" + i
+                message += "\n" + str(i)
         if len(warnings):
             message += "\nWarnings:"
             for i in self.warnings:
-                message += "\n" + i
+                message += "\n" + str(i)
+        if len(errors) or len(warnings):
+            jac_err_line = errors[0].line if len(errors) else warnings[0].line
+            with open(errors[0].mod, "r") as file:
+                jac_code_string = file.read()
+            message += f"\n{Con.JAC_ERROR_PREAMBLE}\n" + clip_code_section(
+                add_line_numbers(jac_code_string),
+                jac_err_line,
+                Val.JAC_ERROR_LINE_RANGE,
+            )
         super().__init__(message)
 
 
@@ -42,8 +69,8 @@ class Transform(ABC):
     ) -> None:
         """Initialize pass."""
         self.logger = logging.getLogger(self.__class__.__module__)
-        self.errors_had = [] if not prior else prior.errors_had
-        self.warnings_had = [] if not prior else prior.warnings_had
+        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_line = 0
         self.mod_path = mod_path
         self.rel_mod_path = (
@@ -58,15 +85,15 @@ class Transform(ABC):
 
     def log_error(self, msg: str) -> None:
         """Pass Error."""
-        msg = f"Mod {self.rel_mod_path}: Line {self.cur_line}, " + msg
-        self.errors_had.append(msg)
-        self.logger.error(msg)
+        alrt = Alert(msg, self.mod_path, self.cur_line)
+        self.errors_had.append(alrt)
+        self.logger.error(str(alrt))
 
     def log_warning(self, msg: str) -> None:
         """Pass Error."""
-        msg = f"Mod {self.rel_mod_path}: Line {self.cur_line}, " + msg
-        self.warnings_had.append(msg)
-        self.logger.warning(msg)
+        alrt = Alert(msg, self.mod_path, self.cur_line)
+        self.warnings_had.append(alrt)
+        self.logger.warning(str(alrt))
 
     def gen_exception(
         self, msg: str = "Error in code transform, see above for details."

jaclang/jac/transpiler.py

@@ -5,8 +5,8 @@ import jaclang.jac.absyntree as ast
 from jaclang.jac.parser import JacLexer
 from jaclang.jac.parser import JacParser
 from jaclang.jac.passes import Pass
-from jaclang.jac.passes.blue import BluePygenPass, pass_schedule
-from jaclang.jac.transform import Transform
+from jaclang.jac.passes.blue import BluePygenPass, PyOutPass, pass_schedule
+from jaclang.jac.transform import Alert, Transform
 
 
 T = TypeVar("T", bound=Pass)
@@ -22,18 +22,24 @@ def jac_file_to_parse_tree(file_path: str, base_dir: str) -> Transform:
         return prse
 
 
-def transpile_jac_blue(file_path: str, base_dir: str) -> str:
+def transpile_jac_blue(file_path: str, base_dir: str) -> list[Alert]:
     """Transpiler Jac file and return python code as string."""
     code = jac_file_to_pass(
-        file_path=file_path, base_dir=base_dir, target=BluePygenPass
+        file_path=file_path,
+        base_dir=base_dir,
+        target=BluePygenPass,
+        schedule=pass_schedule,
     )
     if isinstance(code.ir, ast.Module):
-        return code.ir.meta["py_code"]
+        print_pass = PyOutPass(
+            mod_path=file_path, input_ir=code.ir, base_path=base_dir, prior=code
+        )
     else:
-        raise code.gen_exception("Transpilation of Jac file failed.")
+        return code.errors_had
+    return print_pass.errors_had
 
 
-def transpile_jac_purple(file_path: str, base_dir: str) -> str:
+def transpile_jac_purple(file_path: str, base_dir: str) -> list[Alert]:
     """Transpiler Jac file and return python code as string."""
     from jaclang.jac.passes.purple import pass_schedule, PurplePygenPass
 
@@ -44,9 +50,12 @@ def transpile_jac_purple(file_path: str, base_dir: str) -> str:
         schedule=pass_schedule,
     )
     if isinstance(code.ir, ast.Module):
-        return code.ir.meta["py_code"]
+        print_pass = PyOutPass(
+            mod_path=file_path, input_ir=code.ir, base_path=base_dir, prior=code
+        )
     else:
-        raise code.gen_exception("Transpilation of Jac file failed.")
+        return code.errors_had
+    return print_pass.errors_had
 
 
 def jac_file_to_pass(

jaclang/utils/fstring_parser.py

@@ -1,7 +1,7 @@
 # type: ignore
 """Python Like F-String Parser."""
-from jaclang.utils.sly.lex import Lexer
-from jaclang.utils.sly.yacc import Parser, YaccProduction
+from jaclang.vendor.sly.lex import Lexer
+from jaclang.vendor.sly.yacc import Parser, YaccProduction
 
 _ = None  # For flake8 linting and sly compatibility
 

jaclang/utils/helpers.py

@@ -1,7 +1,9 @@
 """Utility functions and classes for Jac compilation toolchain."""
 import re
+import traceback
 
 import jaclang.jac.absyntree as ast
+from jaclang.jac.constant import Constants as Con, Values as Val
 
 
 def pascal_to_snake(pascal_string: str) -> str:
@@ -31,6 +33,45 @@ def clip_code_section(s: str, target_line: int, line_range: int) -> str:
     return "\n".join(result)
 
 
+def dedent_code_block(code: str) -> str:
+    """Dedent a code block."""
+    lines = code.splitlines()
+    min_indent = min(len(line) - len(line.lstrip()) for line in lines if line.strip())
+    dedented_lines = [line[min_indent:] for line in lines]
+    dedented_code = "\n".join(dedented_lines)
+    return dedented_code
+
+
+def handle_jac_error(code_string: str, e: Exception, tb: traceback.StackSummary) -> str:
+    """Handle Jac Error."""
+    except_line = e.end_lineno if isinstance(e, SyntaxError) else list(tb)[-1].lineno
+    if not isinstance(except_line, int) or except_line == 0:
+        return ""
+    py_error_region = clip_code_section(
+        add_line_numbers(code_string), except_line, Val.JAC_ERROR_LINE_RANGE
+    )
+    try:
+        jac_err_line = int(code_string.splitlines()[except_line - 1].split()[-1])
+        mod_index = int(code_string.splitlines()[except_line - 1].split()[-2])
+        mod_paths = code_string.split(Con.JAC_DEBUG_SPLITTER)[1].strip().splitlines()
+        target_mod = mod_paths[mod_index]
+        with open(target_mod, "r") as file:
+            jac_code_string = file.read()
+        jac_error_region = clip_code_section(
+            add_line_numbers(jac_code_string), jac_err_line, Val.JAC_ERROR_LINE_RANGE
+        )
+    except Exception as e:
+        jac_error_region = str(e)
+        target_mod = ""
+    snippet = (
+        f"{Con.JAC_ERROR_PREAMBLE}\n"
+        f"{target_mod}\n"
+        f"JacCode Snippet:\n{jac_error_region}\n"
+        f"PyCode Snippet:\n{py_error_region}\n"
+    )
+    return snippet
+
+
 def get_ast_nodes_as_snake_case() -> list[str]:
     """Get all AST nodes as snake case."""
     import inspect

jaclang/utils/lang_tools.py

@@ -38,7 +38,14 @@ class AstNodeInfo:
         self.init_sig = inspect.signature(cls.__init__)
         self.kids: list[AstKidInfo] = []
         for param_name, param in self.init_sig.parameters.items():
-            if param_name not in ["self", "parent", "kid", "line", "mod_link"]:
+            if param_name not in [
+                "self",
+                "parent",
+                "kid",
+                "line",
+                "mod_link",
+                "sym_tab",
+            ]:
                 param_type = (
                     param.annotation
                     if param.annotation != inspect.Parameter.empty
@@ -59,7 +66,10 @@ class AstTool:
         source_code = inspect.getsource(module)
         classes = inspect.getmembers(module, inspect.isclass)
         ast_node_classes = [
-            AstNodeInfo(cls) for _, cls in classes if issubclass(cls, ast.AstNode)
+            AstNodeInfo(cls)
+            for _, cls in classes
+            if issubclass(cls, ast.AstNode)
+            and cls.__name__ not in ["AstNode", "OOPAccessNode", "WalkerStmtOnlyNode"]
         ]
         self.ast_classes = sorted(
             ast_node_classes,

jaclang/utils/test.py

@@ -5,6 +5,8 @@ import os
 from abc import ABC, abstractmethod
 from unittest import TestCase as _TestCase
 
+from jaclang.utils.helpers import get_ast_nodes_as_snake_case as ast_snakes
+
 
 class TestCase(_TestCase):
     """Base test case for Jaseci."""
@@ -65,6 +67,17 @@ class TestCaseMicroSuite(ABC, TestCase):
                     cls, method_name, lambda self, f=file_path: self.micro_suite_test(f)
                 )
 
+        directory = os.path.dirname(__file__) + "/../../examples/manual_code"
+        for filename in os.listdir(directory):
+            if os.path.isfile(os.path.join(directory, filename)) and filename.endswith(
+                ".jac"
+            ):
+                method_name = f"test_micro_{filename.replace('.jac', '')}"
+                file_path = os.path.join(directory, filename)
+                setattr(
+                    cls, method_name, lambda self, f=file_path: self.micro_suite_test(f)
+                )
+
         directory = os.path.dirname(__file__) + "/../../examples/guess_game"
         for filename in os.listdir(directory):
             if os.path.isfile(os.path.join(directory, filename)) and filename.endswith(
@@ -90,3 +103,31 @@ class TestCaseMicroSuite(ABC, TestCase):
     def micro_suite_test(self, filename: str) -> None:
         """Test micro jac file."""
         pass
+
+
+class AstSyncTestMixin:
+    """Mixin for testing AST sync."""
+
+    TargetPass = None
+
+    def test_pass_ast_complete(self) -> None:
+        """Test for enter/exit name diffs with parser."""
+        ast_func_names = [
+            x
+            for x in ast_snakes()
+            if x not in ["ast_node", "o_o_p_access_node", "walker_stmt_only_node"]
+        ]
+        pygen_func_names = []
+        for name, value in inspect.getmembers(self.TargetPass):
+            if (
+                (name.startswith("enter_") or name.startswith("exit_"))
+                and inspect.isfunction(value)
+                and not getattr(self.TargetPass.__base__, value.__name__, False)  # type: ignore
+                and value.__qualname__.split(".")[0]
+                == self.TargetPass.__name__.replace("enter_", "").replace("exit_", "")  # type: ignore
+            ):
+                pygen_func_names.append(name.replace("enter_", "").replace("exit_", ""))
+        for name in pygen_func_names:
+            self.assertIn(name, ast_func_names)  # type: ignore
+        for name in ast_func_names:
+            self.assertIn(name, pygen_func_names)  # type: ignore

jaclang/vendor/__init__.py

@@ -0,0 +1 @@
+"""Vendor packages for JACLang."""

jaclang/vendor/pygls/__init__.py

@@ -0,0 +1,25 @@
+############################################################################
+# Original work Copyright 2018 Palantir Technologies, Inc.                 #
+# Original work licensed under the MIT License.                            #
+# See ThirdPartyNotices.txt in the project root for license information.   #
+# All modifications Copyright (c) Open Law Library. All rights reserved.   #
+#                                                                          #
+# Licensed under the Apache License, Version 2.0 (the "License")           #
+# you may not use this file except in compliance with the License.         #
+# You may obtain a copy of the License at                                  #
+#                                                                          #
+#     http: // www.apache.org/licenses/LICENSE-2.0                         #
+#                                                                          #
+# Unless required by applicable law or agreed to in writing, software      #
+# distributed under the License is distributed on an "AS IS" BASIS,        #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and      #
+# limitations under the License.                                           #
+############################################################################
+import os
+import sys
+
+IS_WIN = os.name == "nt"
+IS_PYODIDE = "pyodide" in sys.modules
+
+pygls = "pygls"