jaclang 0.4.7__py3-none-any.whl → 0.5.0__py3-none-any.whl

jaclang/compiler/absyntree.py

@@ -1,4 +1,5 @@
 """Abstract class for IR Passes for Jac."""
+
 from __future__ import annotations
 
 import ast as ast3
@@ -99,6 +100,13 @@ class AstNode:
         """Print ast."""
         return dotgen_ast_tree(self)
 
+    def flatten(self) -> list[AstNode]:
+        """Flatten ast."""
+        ret = [self]
+        for k in self.kid:
+            ret += k.flatten()
+        return ret
+
 
 class AstSymbolNode(AstNode):
     """Nodes that have link to a symbol in symbol table."""
@@ -127,9 +135,11 @@ class AstAccessNode(AstNode):
         return (
             SymbolAccess.PRIVATE
             if self.access and self.access.tag.value == Tok.KW_PRIV
-            else SymbolAccess.PROTECTED
-            if self.access and self.access.tag.value == Tok.KW_PROT
-            else SymbolAccess.PUBLIC
+            else (
+                SymbolAccess.PROTECTED
+                if self.access and self.access.tag.value == Tok.KW_PROT
+                else SymbolAccess.PUBLIC
+            )
         )
 
 
@@ -387,19 +397,17 @@ class Import(ElementStmt, CodeBlockStmt):
     def __init__(
         self,
         lang: SubTag[Name],
-        path: ModulePath,
+        paths: list[ModulePath],
         items: Optional[SubNodeList[ModuleItem]],
         is_absorb: bool,  # For includes
         kid: Sequence[AstNode],
         doc: Optional[String] = None,
-        sub_module: Optional[Module] = None,
     ) -> None:
         """Initialize import node."""
         self.lang = lang
-        self.path = path
+        self.paths = paths
         self.items = items
         self.is_absorb = is_absorb
-        self.sub_module = sub_module
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
@@ -412,10 +420,12 @@ class ModulePath(AstSymbolNode):
         path: Sequence[Token],
         alias: Optional[Name],
         kid: Sequence[AstNode],
+        sub_module: Optional[Module] = None,
     ) -> None:
         """Initialize module path node."""
         self.path = path
         self.alias = alias
+        self.sub_module = sub_module
         self.path_str: str = "".join([p.value for p in path])
         AstNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
@@ -472,21 +482,39 @@ class Architype(ArchSpec, AstAccessNode, ArchBlockStmt):
             self,
             sym_name=name.value,
             sym_name_node=name,
-            sym_type=SymbolType.OBJECT_ARCH
-            if arch_type.name == Tok.KW_OBJECT
-            else SymbolType.NODE_ARCH
-            if arch_type.name == Tok.KW_NODE
-            else SymbolType.EDGE_ARCH
-            if arch_type.name == Tok.KW_EDGE
-            else SymbolType.WALKER_ARCH
-            if arch_type.name == Tok.KW_WALKER
-            else SymbolType.TYPE,
+            sym_type=(
+                SymbolType.OBJECT_ARCH
+                if arch_type.name == Tok.KW_OBJECT
+                else (
+                    SymbolType.NODE_ARCH
+                    if arch_type.name == Tok.KW_NODE
+                    else (
+                        SymbolType.EDGE_ARCH
+                        if arch_type.name == Tok.KW_EDGE
+                        else (
+                            SymbolType.WALKER_ARCH
+                            if arch_type.name == Tok.KW_WALKER
+                            else SymbolType.TYPE
+                        )
+                    )
+                )
+            ),
         )
         AstAccessNode.__init__(self, access=access)
         AstDocNode.__init__(self, doc=doc)
         AstSemStrNode.__init__(self, semstr=semstr)
         ArchSpec.__init__(self, decorators=decorators)
 
+    @property
+    def is_abstract(self) -> bool:
+        """Check if has an abstract method."""
+        body = (
+            self.body.items
+            if isinstance(self.body, SubNodeList)
+            else self.body.body.items if isinstance(self.body, ArchDef) else []
+        )
+        return any(isinstance(i, Ability) and i.is_abstract for i in body)
+
 
 class ArchDef(ArchSpec, AstImplOnlyNode):
     """ArchDef node type for Jac Ast."""
@@ -589,6 +617,7 @@ class Ability(
         name_ref: NameSpec,
         is_func: bool,
         is_async: bool,
+        is_override: bool,
         is_static: bool,
         is_abstract: bool,
         access: Optional[SubTag[Token]],
@@ -602,6 +631,7 @@ class Ability(
         """Initialize func arch node."""
         self.name_ref = name_ref
         self.is_func = is_func
+        self.is_override = is_override
         self.is_static = is_static
         self.is_abstract = is_abstract
         self.decorators = decorators
@@ -755,7 +785,11 @@ class ArchRefChain(AstNode):
         """Resolve name."""
 
         def get_tag(x: ArchRef) -> str:
-            return x.arch.value[1] if x.arch.value != "enum" else "en"
+            return (
+                "en"
+                if x.arch.value == "enum"
+                else "cls" if x.arch.value == "class" else x.arch.value[1]
+            )
 
         return ".".join([f"({get_tag(x)}){x.py_resolve_name()}" for x in self.archs])
 
@@ -1449,7 +1483,7 @@ class KVPair(AstNode):
 
     def __init__(
         self,
-        key: Expr,
+        key: Optional[Expr],  # is **key if blank
         value: Expr,
         kid: Sequence[AstNode],
     ) -> None:
@@ -1464,7 +1498,7 @@ class KWPair(AstNode):
 
     def __init__(
         self,
-        key: NameSpec,
+        key: Optional[NameSpec],  # is **value if blank
         value: Expr,
         kid: Sequence[AstNode],
     ) -> None:

jaclang/compiler/codeloc.py

@@ -1,4 +1,5 @@
 """Code location info for AST nodes."""
+
 from __future__ import annotations
 
 import ast as ast3
@@ -17,8 +18,9 @@ class CodeGenTarget:
 
     py: str = ""
     jac: str = ""
-    py_ast: Optional[ast3.AST | list[ast3.AST]] = None
+    py_ast: list[ast3.AST] = field(default_factory=lambda: [])
     mypy_ast: list[MypyNode] = field(default_factory=lambda: [])
+    py_bytecode: Optional[bytes] = None
 
 
 class CodeLocInfo:

jaclang/compiler/{transpiler.py → compile.py}

@@ -1,4 +1,5 @@
 """Transpilation functions."""
+
 from typing import Optional, Type
 
 import jaclang.compiler.absyntree as ast
@@ -10,8 +11,8 @@ from jaclang.compiler.passes.tool.schedules import format_pass
 from jaclang.compiler.passes.transform import Alert
 
 
-def transpile_jac(file_path: str) -> list[Alert]:
-    """Transpiler Jac file and return python code as string."""
+def compile_jac(file_path: str) -> list[Alert]:
+    """Start Compile for Jac file and return python code as string."""
     code = jac_file_to_pass(
         file_path=file_path,
         schedule=pass_schedule,

jaclang/compiler/constant.py

@@ -1,4 +1,5 @@
 """Constants across the project."""
+
 from enum import Enum
 
 
@@ -78,6 +79,7 @@ class Tokens(str, Enum):
     KW_LET = "KW_LET"
     KW_ABSTRACT = "KW_ABSTRACT"
     KW_OBJECT = "KW_OBJECT"
+    KW_CLASS = "KW_CLASS"
     KW_ENUM = "KW_ENUM"
     KW_NODE = "KW_NODE"
     KW_IGNORE = "KW_IGNORE"
@@ -162,6 +164,7 @@ class Tokens(str, Enum):
     COMMA = "COMMA"
     KW_CAN = "KW_CAN"
     KW_STATIC = "KW_STATIC"
+    KW_OVERRIDE = "KW_OVERRIDE"
     KW_MATCH = "KW_MATCH"
     KW_CASE = "KW_CASE"
     PLUS = "PLUS"
@@ -205,6 +208,7 @@ class Tokens(str, Enum):
     WALKER_OP = "WALKER_OP"
     NODE_OP = "NODE_OP"
     EDGE_OP = "EDGE_OP"
+    CLASS_OP = "CLASS_OP"
     OBJECT_OP = "OBJECT_OP"
     TYPE_OP = "TYPE_OP"
     ENUM_OP = "ENUM_OP"