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

jaclang/jac/absyntree.py

@@ -14,7 +14,7 @@ class AstNode:
 
     def __init__(
         self,
-        parent: Optional["AstNode"],
+        parent: Optional[AstNode],
         mod_link: Optional[Module],
         kid: list,
         line: int,
@@ -180,7 +180,7 @@ class Test(AstNode):
                 sym_tab=name.sym_tab,
             )
         )
-        kid[1] = self.name
+        kid[0] = self.name  # Index is 0 since Doc string is inserted after init
         self.body = body
         super().__init__(
             parent=parent, mod_link=mod_link, kid=kid, line=line, sym_tab=sym_tab
@@ -210,6 +210,22 @@ class ModuleCode(AstNode):
         )
 
 
+class PyInlineCode(AstNode):
+    """Inline Python code node type for Jac Ast."""
+
+    def __init__(
+        self,
+        code: Token,
+        parent: Optional[AstNode],
+        mod_link: Optional[Module],
+        kid: list[AstNode],
+        line: int,
+    ) -> None:
+        """Initialize inline python code node."""
+        self.code = code
+        super().__init__(parent=parent, mod_link=mod_link, kid=kid, line=line)
+
+
 class Import(AstNode):
     """Import node type for Jac Ast."""
 
@@ -343,8 +359,7 @@ class ArchDef(AstNode):
     def __init__(
         self,
         doc: Optional[Token],
-        mod: Optional[DottedNameList],
-        arch: ArchRef,
+        target: ArchRefChain,
         body: ArchBlock,
         parent: Optional[AstNode],
         mod_link: Optional[Module],
@@ -354,8 +369,7 @@ class ArchDef(AstNode):
     ) -> None:
         """Initialize arch def node."""
         self.doc = doc
-        self.mod = mod
-        self.arch = arch
+        self.target = target
         self.body = body
         super().__init__(
             parent=parent, mod_link=mod_link, kid=kid, line=line, sym_tab=sym_tab
@@ -405,7 +419,7 @@ class Ability(OOPAccessNode):
 
     def __init__(
         self,
-        name_ref: Name | SpecialVarRef | ArchRef,
+        name_ref: Name | SpecialVarRef,
         is_func: bool,
         is_async: bool,
         is_static: bool,
@@ -452,14 +466,6 @@ class Ability(OOPAccessNode):
         else:
             raise NotImplementedError
 
-    def resolve_ability_symtab_name(self) -> str:
-        """Resolve ability name in symbol table."""
-        return (
-            f"{self.arch_attached.parent.name.value}.{self.py_resolve_name()}"
-            if self.arch_attached and isinstance(self.arch_attached.parent, Architype)
-            else self.py_resolve_name()
-        )
-
 
 class AbilityDef(AstNode):
     """AbilityDef node type for Jac Ast."""
@@ -467,8 +473,7 @@ class AbilityDef(AstNode):
     def __init__(
         self,
         doc: Optional[Token],
-        target: Optional[DottedNameList],
-        ability: ArchRef,
+        target: ArchRefChain,
         signature: FuncSignature | EventSignature,
         body: CodeBlock,
         parent: Optional[AstNode],
@@ -480,26 +485,12 @@ class AbilityDef(AstNode):
         """Initialize ability def node."""
         self.doc = doc
         self.target = target
-        self.ability = ability
         self.signature = signature
         self.body = body
         super().__init__(
             parent=parent, mod_link=mod_link, kid=kid, line=line, sym_tab=sym_tab
         )
 
-    def py_resolve_name(self) -> str:
-        """Resolve name."""
-        ability_name = self.ability.py_resolve_name()
-        if self.target:
-            owner = self.target.names[-1]
-            if isinstance(owner, ArchRef):
-                owner = owner.py_resolve_name()
-                ability_name = f"{owner}.{ability_name}"
-                return ability_name
-            raise Exception("Invalid AST: Expected reference to Architype!")
-        else:
-            return ability_name
-
 
 class EventSignature(AstNode):
     """EventSignature node type for Jac Ast."""
@@ -529,7 +520,7 @@ class DottedNameList(AstNode):
 
     def __init__(
         self,
-        names: list[Token | SpecialVarRef | ArchRef | Name],
+        names: list[Token | SpecialVarRef | Name],
         parent: Optional[AstNode],
         mod_link: Optional[Module],
         kid: list[AstNode],
@@ -543,6 +534,31 @@ class DottedNameList(AstNode):
         )
 
 
+class ArchRefChain(AstNode):
+    """Arch ref list node type for Jac Ast."""
+
+    def __init__(
+        self,
+        archs: list[ArchRef],
+        parent: Optional[AstNode],
+        mod_link: Optional[Module],
+        kid: list[AstNode],
+        line: int,
+        sym_tab: Optional[SymbolTable] = None,
+    ) -> None:
+        """Initialize name list ."""
+        self.archs = archs
+        super().__init__(
+            parent=parent, mod_link=mod_link, kid=kid, line=line, sym_tab=sym_tab
+        )
+
+    def py_resolve_name(self) -> str:
+        """Resolve name."""
+        return ".".join(
+            [f"({x.arch.value[1]}){x.py_resolve_name()}" for x in self.archs]
+        )
+
+
 class FuncSignature(AstNode):
     """FuncSignature node type for Jac Ast."""
 
@@ -615,7 +631,7 @@ class Enum(OOPAccessNode):
         self,
         name: Name,
         doc: Optional[Token],
-        decorators: Optional["Decorators"],
+        decorators: Optional[Decorators],
         access: Optional[Token],
         base_classes: "BaseClasses",
         body: Optional["EnumBlock"],
@@ -647,8 +663,7 @@ class EnumDef(AstNode):
     def __init__(
         self,
         doc: Optional[Token],
-        enum: ArchRef,
-        mod: Optional[DottedNameList],
+        target: ArchRefChain,
         body: EnumBlock,
         parent: Optional[AstNode],
         mod_link: Optional[Module],
@@ -657,9 +672,8 @@ class EnumDef(AstNode):
         sym_tab: Optional[SymbolTable] = None,
     ) -> None:
         """Initialize arch def node."""
-        self.enum = enum
         self.doc = doc
-        self.mod = mod
+        self.target = target
         self.body = body
         super().__init__(
             parent=parent, mod_link=mod_link, kid=kid, line=line, sym_tab=sym_tab
@@ -690,7 +704,7 @@ class ArchBlock(AstNode):
 
     def __init__(
         self,
-        members: list["ArchHas | Ability"],
+        members: list[ArchHas | Ability],
         parent: Optional[AstNode],
         mod_link: Optional[Module],
         kid: list[AstNode],
@@ -1714,8 +1728,8 @@ class AtomTrailer(AstNode):
 
     def __init__(
         self,
-        target: "AtomType",
-        right: "IndexSlice | ArchRef | Token",
+        target: AtomType,
+        right: IndexSlice | ArchRef | Token,
         null_ok: bool,
         parent: Optional[AstNode],
         mod_link: Optional[Module],
@@ -1996,6 +2010,10 @@ class Parse(AstNode):
             parent=parent, mod_link=mod_link, kid=kid, line=line, sym_tab=sym_tab
         )
 
+    def __repr__(self) -> str:
+        """Return string representation of parse node."""
+        return super().__repr__() + f" ({self.name})" + " line: " + str(self.line)
+
 
 class Token(AstNode):
     """Token node type for Jac Ast."""
@@ -2153,9 +2171,14 @@ def replace_node(node: AstNode, new_node: Optional[AstNode]) -> AstNode | None:
     return new_node
 
 
-def append_node(node: AstNode, new_node: Optional[AstNode]) -> AstNode | None:
+def append_node(
+    node: AstNode, new_node: Optional[AstNode], front: bool = False
+) -> AstNode | None:
     """Replace node with new_node."""
-    node.kid.append(new_node)
+    if front:
+        node.kid.insert(0, new_node)
+    else:
+        node.kid.append(new_node)
     if new_node:
         new_node.parent = node
     return new_node

jaclang/jac/constant.py

@@ -28,6 +28,9 @@ class Constants(str, Enum):
     WITH_DIR = "_jac_apply_dir_"
     EDGE_DIR = "_jac_Edge_Dir_"
 
+    PYNLINE = "::py::"
+    JAC_GEN_DIR = "__jac_gen__"
+
     def __str__(self) -> str:
         """Return the string representation of the token."""
         return self.value
@@ -55,6 +58,7 @@ class Tokens(str, Enum):
     FLOAT = "FLOAT"
     STRING = "STRING"
     DOC_STRING = "DOC_STRING"
+    PYNLINE = "PYNLINE"
     FSTRING = "FSTRING"
     BOOL = "BOOL"
     INT = "INT"

jaclang/jac/importer.py

@@ -4,12 +4,12 @@ import marshal
 import sys
 import traceback
 import types
-from os import makedirs, path
+from os import path
 from typing import Callable, Optional
 
-from jaclang.jac.constant import Constants as Con, Values as Val
+from jaclang.jac.constant import Constants as Con
 from jaclang.jac.transpiler import transpile_jac_blue, transpile_jac_purple
-from jaclang.utils.helpers import add_line_numbers, clip_code_section
+from jaclang.utils.helpers import handle_jac_error
 
 
 def import_jac_module(
@@ -20,9 +20,7 @@ def import_jac_module(
     override_name: Optional[str] = None,
 ) -> Optional[types.ModuleType]:
     """Core Import Process."""
-    target = path.join(*(target.split("."))) + ".jac"
-
-    dir_path, file_name = path.split(target)
+    dir_path, file_name = path.split(path.join(*(target.split("."))) + ".jac")
     module_name = path.splitext(file_name)[0]
     package_path = dir_path.replace(path.sep, ".")
 
@@ -36,11 +34,13 @@ def import_jac_module(
     else:
         frame = inspect.stack()[2]
         caller_dir = path.dirname(path.abspath(frame[0].f_code.co_filename))
-    full_target = path.normpath(path.join(caller_dir, target))
+    caller_dir = path.join(caller_dir, dir_path)
+
+    gen_dir = path.join(caller_dir, Con.JAC_GEN_DIR)
+    full_target = path.normpath(path.join(caller_dir, file_name))
 
-    dev_dir = path.join(caller_dir, "__jac_gen__")
-    makedirs(dev_dir, exist_ok=True)
-    py_file_path = path.join(dev_dir, module_name + ".py")
+    py_file_path = path.join(gen_dir, module_name + ".py")
+    pyc_file_path = path.join(gen_dir, module_name + ".pyc")
     if (
         cachable
         and path.exists(py_file_path)
@@ -48,33 +48,21 @@ def import_jac_module(
     ):
         with open(py_file_path, "r") as f:
             code_string = f.read()
+        with open(pyc_file_path, "rb") as f:
+            codeobj = marshal.load(f)
     else:
-        code_string = transpiler_func(file_path=full_target, base_dir=caller_dir)
-        with open(py_file_path, "w") as f:
-            f.write(code_string)
+        if transpiler_func(file_path=full_target, base_dir=caller_dir):
+            return None
+        with open(py_file_path, "r") as f:
+            code_string = f.read()
+        with open(pyc_file_path, "rb") as f:
+            codeobj = marshal.load(f)
 
     module = types.ModuleType(module_name)
     module.__file__ = full_target
     module.__name__ = override_name if override_name else module_name
     module.__dict__["_jac_pycodestring_"] = code_string
 
-    if (
-        cachable
-        and path.exists(py_file_path + "c")
-        and path.getmtime(py_file_path + "c") > path.getmtime(full_target)
-    ):
-        with open(py_file_path + "c", "rb") as f:
-            codeobj = marshal.load(f)
-    else:
-        try:
-            codeobj = compile(code_string, f"_jac_py_gen ({module.__file__})", "exec")
-        except Exception as e:
-            tb = traceback.extract_tb(e.__traceback__)
-            err = handle_jac_error(code_string, e, tb)
-            raise type(e)(str(e) + "\n" + err)
-        with open(py_file_path + "c", "wb") as f:
-            marshal.dump(codeobj, f)
-
     try:
         exec(codeobj, module.__dict__)
     except Exception as e:
@@ -96,36 +84,6 @@ def import_jac_module(
     return module
 
 
-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 jac_blue_import(
     target: str,
     base_path: Optional[str] = None,

jaclang/jac/langserve.py

@@ -0,0 +1,26 @@
+"""Example language server for JAC."""
+
+from jaclang.vendor.pygls.lsprotocol.types import (
+    CompletionItem,
+    CompletionList,
+    CompletionParams,
+    TEXT_DOCUMENT_COMPLETION,
+)
+from jaclang.vendor.pygls.server import LanguageServer
+
+
+server = LanguageServer("example-server", "v0.1")
+
+
+@server.feature(TEXT_DOCUMENT_COMPLETION)
+def completions(params: CompletionParams) -> CompletionList:
+    """Provide completions for the current line."""
+    items = []
+    document = server.workspace.get_document(params.text_document.uri)
+    current_line = document.lines[params.position.line].strip()
+    if current_line.endswith("hello."):
+        items = [
+            CompletionItem(label="world"),
+            CompletionItem(label="friend"),
+        ]
+    return CompletionList(is_incomplete=False, items=items)

jaclang/jac/lexer.py

@@ -2,7 +2,7 @@
 from typing import Generator
 
 from jaclang.jac.transform import ABCLexerMeta, Transform
-from jaclang.utils.sly.lex import Lexer, Token
+from jaclang.vendor.sly.lex import Lexer, Token
 
 
 class JacLexer(Lexer, Transform, metaclass=ABCLexerMeta):
@@ -25,6 +25,7 @@ class JacLexer(Lexer, Transform, metaclass=ABCLexerMeta):
         "FLOAT",
         "STRING",
         "DOC_STRING",
+        "PYNLINE",
         "FSTRING",
         "BOOL",
         "INT",
@@ -189,6 +190,7 @@ class JacLexer(Lexer, Transform, metaclass=ABCLexerMeta):
     # Regular expression rules for tokens
     FLOAT = r"(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?"
     DOC_STRING = r'"""(.|\n|\r)*?"""|\'\'\'(.|\n|\r)*?\'\'\''  # type: ignore
+    PYNLINE = r"::py::(.|\n|\r)*?::py::"  # type: ignore
     FSTRING = r'f"[^"\r\n]*"|f\'[^\'\r\n]*\''
     STRING = r'"[^"\r\n]*"|\'[^\'\r\n]*\''
     BOOL = r"True|False"
@@ -372,6 +374,12 @@ class JacLexer(Lexer, Transform, metaclass=ABCLexerMeta):
         self.lineno += t.value.count("\r")
         return t
 
+    def PYNLINE(self, t: Token) -> Token:  # noqa
+        """Add docstring to lexer."""
+        self.lineno += t.value.count("\n")
+        self.lineno += t.value.count("\r")
+        return t
+
     # Transform Implementations
     # -------------------------
     def transform(self, ir: str) -> Generator: