jaclang 0.5.17__py3-none-any.whl → 0.6.0__py3-none-any.whl

jaclang/__init__.py

@@ -17,13 +17,9 @@ from jaclang.vendor import pluggy  # noqa: E402
 
 jac_import = JacFeature.jac_import
 
-__all__ = [
-    "jac_import",
-    "lark",
-    "mypy",
-    "pluggy",
-]
 pm.register(JacFeatureDefaults)
 pm.register(JacBuiltin)
 pm.register(JacCmdDefaults)
 pm.load_setuptools_entrypoints("jac")
+
+__all__ = ["jac_import", "lark", "mypy", "pluggy"]

jaclang/cli/cli.py

@@ -106,7 +106,7 @@ def build(filename: str) -> None:
 
 
 @cmd_registry.register
-def check(filename: str) -> None:
+def check(filename: str, print_errs: bool = True) -> None:
     """Run type checker for a specified .jac file.
 
     :param filename: The path to the .jac file.
@@ -119,7 +119,9 @@ def check(filename: str) -> None:
 
         errs = len(out.errors_had)
         warnings = len(out.warnings_had)
-
+        if print_errs:
+            for e in out.errors_had:
+                print("Error:", e)
         print(f"Errors: {errs}, Warnings: {warnings}")
     else:
         print("Not a .jac file.")

jaclang/compiler/__init__.py

@@ -86,17 +86,24 @@ TOKEN_MAP.update(
         "A_PIPE_FWD": ":>",
         "A_PIPE_BKWD": "<:",
         "DOT_FWD": ".>",
+        "STAR_POW": "**",
+        "STAR_MUL": "*",
+        "FLOOR_DIV": "//",
+        "DIV": "/",
+        "PYNLINE": "::py::",
+        "ADD_EQ": "+=",
+        "SUB_EQ": "-=",
         "STAR_POW_EQ": "**=",
         "MUL_EQ": "*=",
         "FLOOR_DIV_EQ": "//=",
         "DIV_EQ": "/=",
+        "MOD_EQ": "%=",
+        "BW_AND_EQ": "&=",
         "BW_OR_EQ": "|=",
         "BW_XOR_EQ": "^=",
-        "STAR_POW": "**",
-        "STAR_MUL": "*",
-        "FLOOR_DIV": "//",
-        "DIV": "/",
-        "PYNLINE": "::py::",
+        "BW_NOT_EQ": "~=",
+        "LSHIFT_EQ": "<<=",
+        "RSHIFT_EQ": ">>=",
     }
 )
 

jaclang/compiler/absyntree.py

@@ -110,11 +110,15 @@ class AstNode:
 
         return Pass.get_all_sub_nodes(node=self, typ=typ, brute_force=brute_force)
 
-    def has_parent_of_type(self, typ: Type[T]) -> Optional[T]:
+    def parent_of_type(self, typ: Type[T]) -> T:
         """Get parent of type."""
         from jaclang.compiler.passes import Pass
 
-        return Pass.has_parent_of_type(node=self, typ=typ)
+        ret = Pass.has_parent_of_type(node=self, typ=typ)
+        if isinstance(ret, typ):
+            return ret
+        else:
+            raise ValueError(f"Parent of type {typ} not found.")
 
     def format(self) -> str:
         """Get all sub nodes of type."""
@@ -190,10 +194,10 @@ class AstAccessNode(AstNode):
         """Get access spec."""
         return (
             SymbolAccess.PRIVATE
-            if self.access and self.access.tag.value == Tok.KW_PRIV
+            if self.access and self.access.tag.name == Tok.KW_PRIV
             else (
                 SymbolAccess.PROTECTED
-                if self.access and self.access.tag.value == Tok.KW_PROT
+                if self.access and self.access.tag.name == Tok.KW_PROT
                 else SymbolAccess.PUBLIC
             )
         )
@@ -592,15 +596,15 @@ class Import(ElementStmt, CodeBlockStmt):
     def __init__(
         self,
         hint: SubTag[Name],
-        paths: list[ModulePath],
-        items: Optional[SubNodeList[ModuleItem]],
+        from_loc: Optional[ModulePath],
+        items: SubNodeList[ModuleItem] | SubNodeList[ModulePath],
         is_absorb: bool,  # For includes
         kid: Sequence[AstNode],
         doc: Optional[String] = None,
     ) -> None:
         """Initialize import node."""
         self.hint = hint
-        self.paths = paths
+        self.from_loc = from_loc
         self.items = items
         self.is_absorb = is_absorb
         AstNode.__init__(self, kid=kid)
@@ -611,9 +615,8 @@ class Import(ElementStmt, CodeBlockStmt):
         res = True
         if deep:
             res = self.hint.normalize(deep)
-            for p in self.paths:
-                res = res and p.normalize(deep)
-            res = res and self.items.normalize(deep) if self.items else res
+            res = res and self.from_loc.normalize(deep) if self.from_loc else res
+            res = res and self.items.normalize(deep)
             res = res and self.doc.normalize(deep) if self.doc else res
         new_kid: list[AstNode] = []
         if self.doc:
@@ -623,15 +626,11 @@ class Import(ElementStmt, CodeBlockStmt):
         else:
             new_kid.append(self.gen_token(Tok.KW_IMPORT))
         new_kid.append(self.hint)
-        if self.items:
+        if self.from_loc:
             new_kid.append(self.gen_token(Tok.KW_FROM))
-        for p in self.paths:
-            new_kid.append(p)
+            new_kid.append(self.from_loc)
             new_kid.append(self.gen_token(Tok.COMMA))
-        new_kid.pop()
-        if self.items:
-            new_kid.append(self.gen_token(Tok.COMMA))
-            new_kid.append(self.items)
+        new_kid.append(self.items)
         new_kid.append(self.gen_token(Tok.SEMI))
         self.set_kids(nodes=new_kid)
         return res
@@ -2389,9 +2388,9 @@ class LambdaExpr(Expr):
 
     def __init__(
         self,
-        signature: FuncSignature,
         body: Expr,
         kid: Sequence[AstNode],
+        signature: Optional[FuncSignature] = None,
     ) -> None:
         """Initialize lambda expression node."""
         self.signature = signature
@@ -2402,11 +2401,12 @@ class LambdaExpr(Expr):
         """Normalize ast node."""
         res = True
         if deep:
-            res = self.signature.normalize(deep)
+            res = self.signature.normalize(deep) if self.signature else res
             res = res and self.body.normalize(deep)
-        new_kid: list[AstNode] = [
-            self.gen_token(Tok.KW_WITH),
-            self.signature,
+        new_kid: list[AstNode] = [self.gen_token(Tok.KW_WITH)]
+        if self.signature:
+            new_kid.append(self.signature)
+        new_kid += [
             self.gen_token(Tok.KW_CAN),
             self.body,
             self.gen_token(Tok.SEMI),
@@ -3716,7 +3716,7 @@ class MatchArch(MatchPattern):
 
     def __init__(
         self,
-        name: NameSpec,
+        name: AtomTrailer | NameSpec,
         arg_patterns: Optional[SubNodeList[MatchPattern]],
         kw_patterns: Optional[SubNodeList[MatchKVPair]],
         kid: Sequence[AstNode],