jaclang 0.5.16__py3-none-any.whl → 0.5.18__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

@@ -238,7 +238,7 @@ def debug(filename: str, main: bool = True, cache: bool = False) -> None:
 
 
 @cmd_registry.register
-def graph(
+def dot(
     filename: str,
     initial: str = "",
     depth: int = -1,

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."""
@@ -591,16 +595,16 @@ class Import(ElementStmt, CodeBlockStmt):
 
     def __init__(
         self,
-        lang: SubTag[Name],
-        paths: list[ModulePath],
-        items: Optional[SubNodeList[ModuleItem]],
+        hint: SubTag[Name],
+        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.lang = lang
-        self.paths = paths
+        self.hint = hint
+        self.from_loc = from_loc
         self.items = items
         self.is_absorb = is_absorb
         AstNode.__init__(self, kid=kid)
@@ -610,10 +614,9 @@ class Import(ElementStmt, CodeBlockStmt):
         """Normalize import node."""
         res = True
         if deep:
-            res = self.lang.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 = self.hint.normalize(deep)
+            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:
@@ -622,16 +625,12 @@ class Import(ElementStmt, CodeBlockStmt):
             new_kid.append(self.gen_token(Tok.KW_INCLUDE))
         else:
             new_kid.append(self.gen_token(Tok.KW_IMPORT))
-        new_kid.append(self.lang)
-        if self.items:
+        new_kid.append(self.hint)
+        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.gen_token(Tok.COMMA))
-        new_kid.pop()
-        if self.items:
+            new_kid.append(self.from_loc)
             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),