jaclang 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

jaclang/jac/tests/fixtures/fam.jac

@@ -0,0 +1,68 @@
+# This is a comment
+#*
+This is multi line comment
+Many styles!
+*#
+"""
+These are doc strings and can be used as comments
+Use them to document your code
+"""
+
+import:jac .stuff;
+import:py from .activity, Activity as Actvy;
+
+node location {
+    has x: int, y: int, name: str = True;
+    has activities: list[Activity];
+    has intro: str = "Welcome";
+    has visited: int = 0;
+
+
+    can record with tourist entry {
+        visited+=1;
+        for i in activities {
+            i.duration = visitor.duration;
+            if <h>.name not in visitor.passport {
+                if i.name == "Hiking" {
+                    for j=0 to j<3 by j+=1 {
+                        i.duration += 1;
+                    }
+                    i.duration += 1;
+                }
+                visitor.passport.append(<h>.name);
+               }
+        }
+    }
+}
+
+walker tourist {
+    has duration: float = .435e-2;
+    has budget: int;
+    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>;
+        report <h>.activities;
+    }
+
+    can do_something(app: int =Actvy) -> Actvy {
+        app.do_something();
+    }
+    can do_something(app: int = Actvy, other: float = Actvy) -> Actvy {
+        return app?.do_something(other);
+    }
+
+    can outside_func() -> None;
+}
+
+
+:walker:tourist:ability:outside_func {
+
+}

jaclang/jac/tests/fixtures/hello_world.jac

@@ -0,0 +1,5 @@
+""" Basic Hello World function """
+
+can hello() {
+    return "Hello World!";
+}

jaclang/jac/tests/fixtures/lexer_fam.jac

@@ -0,0 +1,61 @@
+# This is a comment
+
+"""
+These are doc strings and can be used as comments
+Use them to document your code
+"""
+
+import:jac .stuff;
+import:py from .activity, Activity as Actvy;
+
+node location {
+    has x: int, y: int, name: str;
+    has anchor activities: list[Activity];
+    has hidden intro: str = "Welcome";
+    has visited: int = 0;
+
+
+    can record with tourist entry {
+        visited+=1;
+        for i in activities {
+            i.duration = visitor.duration;
+            if <h>.name not in visitor.passport {
+                if i.name == "Hiking" {
+                    for j=0 to j<3 by j+=1 {
+                        i.duration += 1;
+                    }
+                    i.duration += 1;
+                }
+                visitor.passport.append(<h>.name);
+               }
+        }
+    }
+}
+
+walker tourist {
+    has duration: int;
+    has budget: int;
+    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)::;
+        :g:stuff:w:tourist::;
+        report <h>.activities;
+    }
+
+    can do_something(app: int =Actvy) -> Actvy {
+        app.do_something();
+    }
+    can do_something(app: int = Actvy, other: float = Actvy) -> Actvy {
+        return app?.do_something(other);
+    }
+
+    can outside_func() -> None;
+}
+
+
+:walker:tourist:ability:outside_func {
+
+}

jaclang/jac/tests/fixtures/stuff.jac

@@ -0,0 +1,6 @@
+global x = 54;
+
+edge path {
+    has distance: int = 0;
+    // has: int visited = 0;
+}

jaclang/jac/tests/test_importer.py

@@ -0,0 +1,24 @@
+"""Tests for Jac Loader."""
+import sys
+
+from jaclang import jac_blue_import
+from jaclang.utils.test import TestCase
+
+
+class TestLoader(TestCase):
+    """Test Jac self.prse."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def test_import_basic_python(self) -> None:
+        """Test basic self loading."""
+        h = jac_blue_import("fixtures.hello_world")
+        self.assertEqual(h.hello(), "Hello World!")  # type: ignore
+
+    def test_modules_correct(self) -> None:
+        """Test basic self loading."""
+        jac_blue_import("fixtures.hello_world")
+        self.assertIn("module 'hello_world'", str(sys.modules))
+        self.assertIn("/tests/fixtures/hello_world.jac", str(sys.modules))

jaclang/jac/tests/test_lexer.py

@@ -0,0 +1,57 @@
+"""Tests for Jac lexer."""
+from typing import Generator
+
+from jaclang.jac.lexer import JacLexer, Tokens
+from jaclang.utils.test import TestCase
+
+
+class TestLexer(TestCase):
+    """Test Jac lexer."""
+
+    def test_lexer(self) -> None:
+        """Basic test for lexer."""
+        tokens = []
+        ir = JacLexer(mod_path="", input_ir=self.load_fixture("lexer_fam.jac")).ir
+        if not isinstance(ir, Generator):
+            raise ValueError("Lexer did not return generator.")
+        for t in ir:
+            tokens.append(t)
+        self.assertEqual(tokens[0].type, "DOC_STRING")
+        self.assertEqual(
+            [
+                tokens[10].type,
+                tokens[10].value,
+                tokens[10].lineno,
+                tokens[10].index,
+                tokens[10].end,
+            ],
+            ["KW_FROM", "from", 9, 140, 144],
+        )
+        self.assertEqual(
+            [
+                tokens[-1].type,
+                tokens[-1].value,
+                tokens[-1].lineno,
+            ],
+            ["RBRACE", "}", 61],
+        )
+
+    def test_col_idxs(self) -> None:
+        """Basic test for lexer."""
+        tokens = []
+        ir = JacLexer(mod_path="", input_ir=self.load_fixture("lexer_fam.jac")).ir
+        if not isinstance(ir, Generator):
+            raise ValueError("Lexer did not return generator.")
+        for t in ir:
+            tokens.append((t.value, t.lineno, t.index - t.lineidx, t.end - t.lineidx))
+        self.assertEqual(tokens[12], ("activity", 9, 16, 24))
+        self.assertEqual(tokens[-3], ("outside_func", 59, 24, 36))
+
+    def test_enum_matches_lexer_toks(self) -> None:
+        """Test that enum stays synced with lexer."""
+        for token in JacLexer.tokens:
+            self.assertIn(token, Tokens.__members__)
+        for token in Tokens:
+            self.assertIn(token.name, JacLexer.tokens)
+        for token in Tokens:
+            self.assertIn(token.value, JacLexer.tokens)

jaclang/jac/tests/test_parser.py

@@ -0,0 +1,50 @@
+"""Tests for Jac parser."""
+from jaclang.jac.absyntree import AstNode
+from jaclang.jac.lexer import JacLexer
+from jaclang.jac.parser import JacParser
+from jaclang.utils.test import TestCaseMicroSuite
+
+
+class TestParser(TestCaseMicroSuite):
+    """Test Jac self.prse."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def micro_suite_test(self, filename: str) -> None:
+        """Parse micro jac file."""
+        lex = JacLexer(mod_path=filename, input_ir=self.file_to_str(filename)).ir
+        prse = JacParser(mod_path=filename, input_ir=lex)
+        self.assertFalse(prse.errors_had)
+
+    def test_shift_reduce_conflict(self) -> None:
+        """Test for shift reduce conflict."""
+        self.assertEqual(len(JacParser._lrtable.sr_conflicts), 0)
+
+    def test_reduce_reduce_conflict(self) -> None:
+        """Test for reduce reduce conflict."""
+        self.assertEqual(len(JacParser._lrtable.rr_conflicts), 0)
+
+    def test_basci_parsing(self) -> None:
+        """Basic test for parsing."""
+        lex = JacLexer(mod_path="fam.jac", input_ir=self.load_fixture("fam.jac")).ir
+        prse = JacParser(mod_path="fam.jac", input_ir=lex)
+        output = prse.ir
+        self.assertFalse(prse.errors_had)
+        if isinstance(output, AstNode):
+            self.assertGreater(len(str(output.to_dict())), 1000)
+        else:
+            self.fail("Output is not an AstNode.")
+
+    def test_parsing_jac_cli(self) -> None:
+        """Basic test for parsing."""
+        lex = JacLexer(
+            mod_path="../../../cli/cli.jac",
+            input_ir=self.load_fixture("../../../cli/cli.jac"),
+        ).ir
+        prse = JacParser(mod_path="../../../cli/cli.jac", input_ir=lex)
+        self.assertFalse(prse.errors_had)
+
+
+TestParser.self_attach_micro_tests()

jaclang/jac/tests/test_utils.py

@@ -0,0 +1,12 @@
+"""Tests for Jac utils."""
+from jaclang.jac.utils import load_ast_and_print_pass_template
+from jaclang.utils.test import TestCase
+
+
+class TestLexer(TestCase):
+    """Test Jac utils."""
+
+    def test_ast_template_loader(self) -> None:
+        """Basic test for ast template loader."""
+        output = load_ast_and_print_pass_template()
+        self.assertGreater(len(output), 1000)

jaclang/jac/transform.py

@@ -0,0 +1,63 @@
+"""Standardized transformation process and error interface."""
+from __future__ import annotations
+
+import os
+from abc import ABC, ABCMeta, abstractmethod
+from typing import Optional
+
+
+from jaclang.jac.absyntree import AstNode
+from jaclang.utils.log import logging
+from jaclang.utils.sly.lex import LexerMeta
+from jaclang.utils.sly.yacc import ParserMeta
+
+
+class Transform(ABC):
+    """Abstract class for IR passes."""
+
+    def __init__(
+        self,
+        mod_path: str,
+        input_ir: AstNode,
+        base_path: str = "",
+        prior: Optional[Transform] = None,
+    ) -> 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.cur_line = 0
+        self.mod_path = mod_path
+        self.rel_mod_path = (
+            mod_path.replace(base_path, "") if base_path else mod_path.split(os.sep)[-1]
+        )
+        self.ir = self.transform(ir=input_ir)
+
+    @abstractmethod
+    def transform(self, ir: AstNode) -> AstNode:
+        """Transform interface."""
+        pass
+
+    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)
+
+    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)
+
+
+class ABCLexerMeta(ABCMeta, LexerMeta):
+    """Metaclass for Jac Lexer."""
+
+    pass
+
+
+class ABCParserMeta(ABCMeta, ParserMeta):
+    """Metaclass for Jac Lexer."""
+
+    pass

jaclang/jac/transpiler.py

@@ -0,0 +1,69 @@
+"""Transpilation functions."""
+from typing import Type, TypeVar
+
+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
+
+
+T = TypeVar("T", bound=Pass)
+
+
+def jac_file_to_parse_tree(file_path: str, base_dir: str) -> Transform:
+    """Convert a Jac file to an AST."""
+    with open(file_path) as file:
+        lex = JacLexer(mod_path=file_path, input_ir=file.read(), base_path=base_dir)
+        prse = JacParser(
+            mod_path=file_path, input_ir=lex.ir, base_path=base_dir, prior=lex
+        )
+        return prse
+
+
+def transpile_jac_blue(file_path: str, base_dir: str) -> str:
+    """Transpiler Jac file and return python code as string."""
+    code = jac_file_to_pass(
+        file_path=file_path, base_dir=base_dir, target=BluePygenPass
+    )
+    if isinstance(code.ir, ast.Module):
+        return code.ir.meta["py_code"]
+    else:
+        raise ValueError("Transpilation of Jac file failed.")
+
+
+def transpile_jac_purple(file_path: str, base_dir: str) -> str:
+    """Transpiler Jac file and return python code as string."""
+    from jaclang.jac.passes.purple import pass_schedule, PurplePygenPass
+
+    code = jac_file_to_pass(
+        file_path=file_path,
+        base_dir=base_dir,
+        target=PurplePygenPass,
+        schedule=pass_schedule,
+    )
+    if isinstance(code.ir, ast.Module):
+        return code.ir.meta["py_code"]
+    else:
+        raise ValueError("Transpilation of Jac file failed.")
+
+
+def jac_file_to_pass(
+    file_path: str,
+    base_dir: str = "",
+    target: Type[T] = BluePygenPass,
+    schedule: list[Type[T]] = pass_schedule,
+) -> T:
+    """Convert a Jac file to an AST."""
+    ast_ret = jac_file_to_parse_tree(file_path, base_dir)
+    for i in schedule:
+        if i == target:
+            break
+        ast_ret = i(
+            mod_path=file_path, input_ir=ast_ret.ir, base_path=base_dir, prior=ast_ret
+        )
+    ast_ret = target(
+        mod_path=file_path, input_ir=ast_ret.ir, base_path=base_dir, prior=ast_ret
+    )
+    return ast_ret

jaclang/jac/utils.py

@@ -0,0 +1,120 @@
+"""Utility functions and classes for Jac compilation toolchain."""
+import re
+
+import jaclang.jac.absyntree as ast
+from jaclang.jac.parser import JacLexer
+
+
+def get_all_jac_keywords() -> str:
+    """Get all Jac keywords as an or string."""
+    ret = ""
+    for k in JacLexer._remapping["NAME"].keys():
+        ret += f"{k}|"
+    return ret[:-1]
+
+
+def pascal_to_snake(pascal_string: str) -> str:
+    """Convert pascal case to snake case."""
+    snake_string = re.sub(r"(?<!^)(?=[A-Z])", "_", pascal_string).lower()
+    return snake_string
+
+
+def add_line_numbers(s: str) -> str:
+    """Add line numbers to a string."""
+    lines = s.split("\n")
+    return "\n".join(f"{i+1}: \t{line}" for i, line in enumerate(lines))
+
+
+def clip_code_section(s: str, target_line: int, line_range: int) -> str:
+    """Clip a section of code and highlight target line."""
+    lines = s.split("\n")
+    start = max(0, target_line - line_range - 1)
+    end = min(target_line + line_range, len(lines))
+
+    result = []
+    for i in range(start, end):
+        line = lines[i]
+        if i == target_line - 1:
+            line = "*" + line
+        result.append(line)
+    return "\n".join(result)
+
+
+def get_ast_nodes_as_snake_case() -> list[str]:
+    """Get all AST nodes as snake case."""
+    import inspect
+    import sys
+
+    module_name = ast.__name__
+    module = sys.modules[module_name]
+
+    # Retrieve the source code of the module
+    source_code = inspect.getsource(module)
+
+    classes = inspect.getmembers(module, inspect.isclass)
+    ast_node_classes = [cls for _, cls in classes if issubclass(cls, ast.AstNode)]
+
+    ordered_classes = sorted(
+        ast_node_classes, key=lambda cls: source_code.find(f"class {cls.__name__}")
+    )
+    snake_names = []
+    for cls in ordered_classes:
+        class_name = cls.__name__
+        snake_names.append(pascal_to_snake(class_name))
+    return snake_names
+
+
+def load_ast_and_print_pass_template() -> str:
+    """Load and print classes."""
+    import inspect
+    import sys
+
+    module_name = ast.__name__
+    module = sys.modules[module_name]
+
+    # Retrieve the source code of the module
+    source_code = inspect.getsource(module)
+
+    classes = inspect.getmembers(module, inspect.isclass)
+    ast_node_classes = [cls for _, cls in classes if issubclass(cls, ast.AstNode)]
+
+    ordered_classes = sorted(
+        ast_node_classes, key=lambda cls: source_code.find(f"class {cls.__name__}")
+    )
+    output = ""
+    for cls in ordered_classes:
+        class_name = cls.__name__
+        snake_case_name = pascal_to_snake(class_name)
+
+        output += f"def exit_{snake_case_name}(self, node: ast.{class_name}) -> None:\n"
+        output += '    """Sub objects.\n\n'
+
+        init_func = cls.__init__
+        init_signature = inspect.signature(init_func)
+
+        for param_name, param in init_signature.parameters.items():
+            if param_name not in ["self", "parent", "kid", "line"]:
+                param_type = (
+                    param.annotation
+                    if param.annotation != inspect.Parameter.empty
+                    else "Any"
+                )
+                param_default = (
+                    param.default if param.default != inspect.Parameter.empty else None
+                )
+                output += f"    {param_name}: {param_type}{' ='+param_default if param_default else ''},\n"
+
+        output += '    """\n\n'
+    output = output.replace("jaclang.jac.absyntree.", "")
+    output = output.replace("typing.", "")
+    output = output.replace("<enum '", "")
+    output = output.replace("'>", "")
+    output = output.replace("<class '", "")
+    output = output.replace("ForwardRef('", "")
+    output = output.replace("')", "")
+    return output
+
+
+if __name__ == "__main__":
+    print(get_all_jac_keywords())
+    print(load_ast_and_print_pass_template())

jaclang/utils/__init__.py

@@ -0,0 +1 @@
+"""Jaseci utility functions and libraries."""

jaclang/utils/fstring_parser.py

@@ -0,0 +1,73 @@
+# type: ignore
+"""Python Like F-String Parser."""
+from jaclang.utils.sly.lex import Lexer
+from jaclang.utils.sly.yacc import Parser, YaccProduction
+
+_ = None  # For flake8 linting and sly compatibility
+
+
+class FStringLexer(Lexer):
+    """Python Like F-String Lexer."""
+
+    tokens = {
+        "STRING_START",
+        "STRING_END",
+        "EXPR_START",
+        "EXPR_END",
+        "PIECE",
+    }
+    # ignore = " \t"
+
+    # Tokens
+
+    STRING_START = r"f\""
+    STRING_END = r"\""
+    PIECE = r"[^\{\}\"]+|\{\{|\}\}"
+    EXPR_START = r"(?<!\{)\{(?!\{)"
+    EXPR_END = r"(?<!\})\}(?!\})"
+
+
+class FStringParser(Parser):
+    """Python Like F-String Parser."""
+
+    tokens = FStringLexer.tokens
+    start = "fstring"
+
+    @_("STRING_START fstr_parts STRING_END")
+    def fstring(self, p: YaccProduction) -> YaccProduction:
+        """Start rule for fstring."""
+        return p
+
+    @_(
+        "fstr_parts fstr_expr",
+        "fstr_parts PIECE",
+        "PIECE",
+        "fstr_expr",
+        "fstring",
+    )
+    def fstr_parts(self, p: YaccProduction) -> YaccProduction:
+        """Parts of the string both in string and in expression."""
+        return p
+
+    @_("EXPR_START fstr_parts EXPR_END")
+    def fstr_expr(self, p: YaccProduction) -> YaccProduction:
+        """Expressions rule."""
+        return p
+
+
+if __name__ == "__main__":
+    """Run the parser for live testing."""
+    lexer = FStringLexer()
+    parser = FStringParser()
+    while True:
+        try:
+            text = input("fstring > ")
+        except EOFError:
+            break
+        if text:
+            tokens = lexer.tokenize(text)
+            for i in tokens:
+                print(i, end=", ")
+            tokens = lexer.tokenize(text)
+            result = parser.parse(tokens)
+            print(result)

jaclang/utils/log.py

@@ -0,0 +1,9 @@
+"""Basic Logging Module for Jac Compiler."""
+
+import logging
+
+logging.basicConfig(
+    # level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    level=logging.INFO,
+    format="%(levelname)s - %(message)s",
+)

jaclang/utils/sly/__init__.py

@@ -0,0 +1,6 @@
+# flake8: noqa
+from .lex import *
+from .yacc import *
+
+__version__ = "0.5"
+__all__ = [*lex.__all__, *yacc.__all__]