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

jaclang/jac/constant.py

@@ -7,6 +7,7 @@ class Constants(str, Enum):
 
     JAC_LANG_IMP = "jac"
     JAC_DEBUG_SPLITTER = "JAC DEBUG INFO"
+    JAC_ERROR_PREAMBLE = "Jac error originates from..."
     PATCH = "PATCH"
 
     JAC_TMP = "_jac_tmp"
@@ -27,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
@@ -54,6 +58,7 @@ class Tokens(str, Enum):
     FLOAT = "FLOAT"
     STRING = "STRING"
     DOC_STRING = "DOC_STRING"
+    PYNLINE = "PYNLINE"
     FSTRING = "FSTRING"
     BOOL = "BOOL"
     INT = "INT"
@@ -75,6 +80,7 @@ class Tokens(str, Enum):
     TYP_ANY = "TYP_ANY"
     TYP_TYPE = "TYP_TYPE"
     KW_FREEZE = "KW_FREEZE"
+    KW_ABSTRACT = "KW_ABSTRACT"
     KW_OBJECT = "KW_OBJECT"
     KW_ENUM = "KW_ENUM"
     KW_NODE = "KW_NODE"

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(
@@ -17,11 +17,10 @@ def import_jac_module(
     target: str,
     base_path: Optional[str] = None,
     cachable: bool = True,
+    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, ".")
 
@@ -35,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)
@@ -47,28 +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__ = module_name
+    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:
-        codeobj = compile(code_string, f"_jac_py_gen ({module.__file__})", "exec")
-        with open(py_file_path + "c", "wb") as f:
-            marshal.dump(codeobj, f)
-
     try:
         exec(codeobj, module.__dict__)
     except Exception as e:
@@ -90,41 +84,25 @@ 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()
-        with open(mod_paths[mod_index], "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)
-    snippet = (
-        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, cachable: bool = True
+    target: str,
+    base_path: Optional[str] = None,
+    cachable: bool = True,
+    override_name: Optional[str] = None,
 ) -> Optional[types.ModuleType]:
     """Jac Blue Imports."""
-    return import_jac_module(transpile_jac_blue, target, base_path, cachable)
+    return import_jac_module(
+        transpile_jac_blue, target, base_path, cachable, override_name
+    )
 
 
 def jac_purple_import(
-    target: str, base_path: Optional[str] = None, cachable: bool = True
+    target: str,
+    base_path: Optional[str] = None,
+    cachable: bool = True,
+    override_name: Optional[str] = None,
 ) -> Optional[types.ModuleType]:
     """Jac Purple Imports."""
-    return import_jac_module(transpile_jac_purple, target, base_path, cachable)
+    return import_jac_module(
+        transpile_jac_purple, target, base_path, cachable, override_name
+    )

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):
@@ -14,8 +14,10 @@ class JacLexer(Lexer, Transform, metaclass=ABCLexerMeta):
         input_ir: str,
         base_path: str = "",
         prior: Transform | None = None,
+        fstr_override: bool = False,
     ) -> None:
         """Initialize lexer."""
+        self.fstr_override = fstr_override
         Transform.__init__(self, mod_path, input_ir, base_path, prior)  # type: ignore
         self.ir: Generator = self.ir
 
@@ -23,6 +25,7 @@ class JacLexer(Lexer, Transform, metaclass=ABCLexerMeta):
         "FLOAT",
         "STRING",
         "DOC_STRING",
+        "PYNLINE",
         "FSTRING",
         "BOOL",
         "INT",
@@ -44,6 +47,7 @@ class JacLexer(Lexer, Transform, metaclass=ABCLexerMeta):
         "TYP_ANY",
         "TYP_TYPE",
         "KW_FREEZE",
+        "KW_ABSTRACT",
         "KW_OBJECT",
         "KW_ENUM",
         "KW_NODE",
@@ -186,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"
@@ -211,7 +216,8 @@ class JacLexer(Lexer, Transform, metaclass=ABCLexerMeta):
     NAME["bytes"] = "TYP_BYTES"  # type: ignore
     NAME["any"] = "TYP_ANY"  # type: ignore
     NAME["type"] = "TYP_TYPE"  # type: ignore
-    NAME["freeze"] = "KW_FREEZE"  # type: ignore
+    NAME["froz"] = "KW_FREEZE"  # type: ignore
+    NAME["abstract"] = "KW_ABSTRACT"  # type: ignore
     NAME["object"] = "KW_OBJECT"  # type: ignore
     NAME["enum"] = "KW_ENUM"  # type: ignore
     NAME["node"] = "KW_NODE"  # type: ignore
@@ -269,9 +275,9 @@ class JacLexer(Lexer, Transform, metaclass=ABCLexerMeta):
     ARROW_R = r"-->"
     ARROW_BI = r"<-->"
     ARROW_L_p1 = r"<-\["
+    ARROW_R_p2 = r"]->"
     ARROW_L_p2 = r"]-"
     ARROW_R_p1 = r"-\["
-    ARROW_R_p2 = r"]->"
     CARROW_L = r"<\+\+"
     CARROW_R = r"\+\+>"
     CARROW_L_p1 = r"<\+\["
@@ -368,12 +374,38 @@ 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:
         """Tokenize the input."""
         return self.tokenize(ir)
 
+    def tokenize(self, text: str) -> Generator:
+        """Tokenize override for no module level docstring."""
+        has_doc_string_start = False
+        for tok in super().tokenize(text):
+            if (
+                tok.type != "DOC_STRING"
+                and not has_doc_string_start
+                and not self.fstr_override
+            ):
+                dtok = Token()
+                dtok.type = "DOC_STRING"
+                dtok.value = '""""""'
+                dtok.lineno = 1
+                dtok.lineidx = 0
+                dtok.index = 0
+                dtok.end = 0
+                yield dtok
+            has_doc_string_start = True
+            yield tok
+
     def error(self, t: Token) -> None:
         """Raise an error for illegal characters."""
         self.cur_line = self.lineno