jaclang 0.7.21__py3-none-any.whl → 0.7.23__py3-none-any.whl

jaclang/__init__.py

@@ -1,17 +1,12 @@
 """The Jac Programming Language."""
 
-from jaclang.plugin.default import (  # noqa: E402
-    JacBuiltin,
-    JacCmdDefaults,
-    JacFeatureDefaults,
-)
-from jaclang.plugin.feature import JacFeature, pm  # noqa: E402
+from jaclang.plugin.default import JacFeatureImpl
+from jaclang.plugin.feature import JacFeature, plugin_manager
 
 jac_import = JacFeature.jac_import
 
-pm.register(JacFeatureDefaults)
-pm.register(JacBuiltin)
-pm.register(JacCmdDefaults)
-pm.load_setuptools_entrypoints("jac")
+
+plugin_manager.register(JacFeatureImpl)
+plugin_manager.load_setuptools_entrypoints("jac")
 
 __all__ = ["jac_import"]

jaclang/cli/cli.py

@@ -28,6 +28,7 @@ from jaclang.utils.lang_tools import AstTool
 
 
 Cmd.create_cmd()
+Jac.setup()
 
 
 @cmd_registry.register
@@ -283,7 +284,9 @@ def enter(
 
             jctx.set_entry_node(node)
 
-            if isinstance(architype, WalkerArchitype) and jctx.validate_access():
+            if isinstance(architype, WalkerArchitype) and Jac.check_read_access(
+                jctx.entry_node
+            ):
                 Jac.spawn_call(jctx.entry_node.architype, architype)
 
     jctx.close()

jaclang/compiler/absyntree.py

@@ -2873,13 +2873,24 @@ class FString(AtomExpr):
         if deep:
             res = self.parts.normalize(deep) if self.parts else res
         new_kid: list[AstNode] = []
+        is_single_quote = (
+            isinstance(self.kid[0], Token) and self.kid[0].name == Tok.FSTR_SQ_START
+        )
         if self.parts:
+            if is_single_quote:
+                new_kid.append(self.gen_token(Tok.FSTR_SQ_START))
+            else:
+                new_kid.append(self.gen_token(Tok.FSTR_START))
             for i in self.parts.items:
                 if isinstance(i, String):
                     i.value = (
                         "{{" if i.value == "{" else "}}" if i.value == "}" else i.value
                     )
             new_kid.append(self.parts)
+            if is_single_quote:
+                new_kid.append(self.gen_token(Tok.FSTR_SQ_END))
+            else:
+                new_kid.append(self.gen_token(Tok.FSTR_END))
         self.set_kids(nodes=new_kid)
         return res
 
@@ -4257,7 +4268,6 @@ class String(Literal):
         """Return literal value in its python type."""
         if isinstance(self.value, bytes):
             return self.value
-        prefix_len = 3 if self.value.startswith(("'''", '"""')) else 1
         if any(
             self.value.startswith(prefix)
             and self.value[len(prefix) :].startswith(("'", '"'))
@@ -4266,8 +4276,23 @@ class String(Literal):
             return eval(self.value)
 
         elif self.value.startswith(("'", '"')):
-            ret_str = self.value[prefix_len:-prefix_len]
-            return ret_str.encode().decode("unicode_escape", errors="backslashreplace")
+            repr_str = self.value.encode().decode("unicode_escape")
+            if (
+                self.value.startswith('"""')
+                and self.value.endswith('"""')
+                and not self.find_parent_of_type(FString)
+            ):
+                return repr_str[3:-3]
+            if (not self.find_parent_of_type(FString)) or (
+                not (
+                    self.parent
+                    and isinstance(self.parent, SubNodeList)
+                    and self.parent.parent
+                    and isinstance(self.parent.parent, FString)
+                )
+            ):
+                return repr_str[1:-1]
+            return repr_str
         else:
             return self.value
 

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -1148,14 +1148,16 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             else:
                 token_type = f"{value_type.__name__.upper()}"
 
+            if value_type == str:
+                raw_repr = repr(node.value)
+                quote = "'" if raw_repr.startswith("'") else '"'
+                value = f"{quote}{raw_repr[1:-1]}{quote}"
+            else:
+                value = str(node.value)
             return type_mapping[value_type](
                 file_path=self.mod_path,
                 name=token_type,
-                value=(
-                    f'"{repr(node.value)[1:-1]}"'
-                    if value_type == str
-                    else str(node.value)
-                ),
+                value=value,
                 line=node.lineno,
                 end_line=node.end_lineno if node.end_lineno else node.lineno,
                 col_start=node.col_offset,
@@ -2625,7 +2627,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
 
     def convert_to_doc(self, string: ast.String) -> None:
         """Convert a string to a docstring."""
-        string.value = f'""{string.value}""'
+        string.value = f'"""{string.value[1:-1]}"""'
 
     def aug_op_map(self, tok_dict: dict, op: ast.Token) -> str:
         """aug_mapper."""

jaclang/compiler/passes/main/tests/fixtures/fstrings.jac

@@ -1,4 +1,47 @@
 """Small test for fstrings."""
 
+glob apple = 2;
+glob a=f"hello {40 + 2}   wor{apple}ld  ";
 
-glob a=f"hello {40 + 2}   wor{apple}ld  ";
+with entry {
+    a = 9;
+    s_2 = "'''hello'''";
+    s_3 = "'''hello  '''";
+    s_4 = "''' hello'''";
+    s_5 = '""" hello"""';
+    s_6 = '"""hello"""';
+    s_7 = '"""hello"" "';
+    s_8 = '"""hello""" ';
+    print(
+        len(s_2),
+        len(s_3),
+        len(s_4),
+        len(s_5),
+        len(s_6),
+        len(s_7),
+        len(s_8)
+    ) ;
+    b1 = f"{"'''hello''' "}";
+    b_2 = f"{'"""hello""" '}";
+    f_1 = f"{'hello '}{a}{'"""hello"""'}";
+    f_2 = f"{'hello '}{a}{"'''hello'''"}";
+    print(len(b1),len(b_2), b_2,len(f_1), len(f_2)) ;
+    f_3 = f"{'"""again"""'}";
+    f_4 = f"{'"""again""" '}";
+    f_5 = f"{"'''again'''"}";
+    f_6 = f"{"'''again''' "}";
+    f_7 = f"{'"""again"""'}";
+    f_s1 = f"{'hello '}{a}{'"""hello"""'}";
+    f_s2 = f"{'hello '}{a}{"'''hello'''"}{'kklkl'}";
+    print(
+        len(f_3),
+        len(f_4),
+        len(f_5),
+        len(f_6),
+        len(f_7),
+        len(f_s1), len(f_s2)
+    ) ;
+    """sdfsdf\nsdfsdfsdfsd dffgdfgd.""" ;
+}
+can func() {;
+}

jaclang/compiler/passes/main/type_check_pass.py

@@ -50,12 +50,6 @@ class JacTypeCheckPass(Pass):
         options = myab.myb.Options()
         options.ignore_missing_imports = True
         options.cache_dir = Con.JAC_MYPY_CACHE
-        options.mypy_path = [
-            # str( # TODO: Remove me, this was the wrong way to point to stubs
-            #     pathlib.Path(os.path.dirname(__file__)).parent.parent.parent.parent
-            #     / "stubs"
-            # )
-        ]
         if top_module_path != "":
             options.mypy_path.append(top_module_path)
 
@@ -116,6 +110,14 @@ class JacTypeCheckPass(Pass):
             old_graph=mypy_graph,
             new_modules=new_modules,  # To parse the dependancies of modules
         )
+        mypy_graph = {
+            k: v
+            for k, v in mypy_graph.items()
+            if (
+                k.startswith("jaclang.plugin")
+                or not (k.startswith("jaclang.") or k.startswith("mypy."))
+            )
+        }
         for i in mypy_graph:
             self.ir.py_mod_dep_map[i] = mypy_graph[i].xpath
             for j in mypy_graph[i].dependencies:

jaclang/plugin/builtin.py

@@ -19,9 +19,9 @@ def dotgen(
     dot_file: Optional[str] = None,
 ) -> str:
     """Print the dot graph."""
-    from jaclang.plugin.feature import pm
+    from jaclang.plugin.feature import JacFeature as Jac
 
-    root = pm.hook.get_root()
+    root = Jac.get_root()
     node = node if node is not None else root
     depth = depth if depth is not None else -1
     traverse = traverse if traverse is not None else False
@@ -29,7 +29,7 @@ def dotgen(
     edge_limit = edge_limit if edge_limit is not None else 512
     node_limit = node_limit if node_limit is not None else 512
 
-    return pm.hook.dotgen(
+    return Jac.dotgen(
         edge_type=edge_type,
         node=node,
         depth=depth,