jaclang 0.7.1__py3-none-any.whl → 0.7.7__py3-none-any.whl

jaclang/compiler/passes/main/type_check_pass.py

@@ -8,9 +8,9 @@ import os
 import pathlib
 import sys
 
-
 import jaclang.compiler.absyntree as ast
 import jaclang.compiler.passes.utils.mypy_ast_build as myab
+from jaclang.compiler.constant import Constants as Con
 from jaclang.compiler.passes import Pass
 
 
@@ -48,6 +48,7 @@ class JacTypeCheckPass(Pass):
         """Call mypy APIs to implement type checking in Jac."""
         # Creating mypy api objects
         options = myab.myb.Options()
+        options.cache_dir = Con.JAC_MYPY_CACHE
         errors = myab.Errors(self, options)
         fs_cache = myab.FileSystemCache()
         search_paths = myab.compute_search_paths([], options, str(self.__path))

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -421,7 +421,10 @@ class JacFormatPass(Pass):
                     self.emit_ln(node, "")
                     self.emit_ln(node, i.gen.jac)
             if isinstance(i, ast.Token) and i.name == Tok.KW_BY:
-                self.emit(node, f"{i.gen.jac} ")
+                if not node.params:
+                    self.emit(node, f"{i.gen.jac} ")
+                else:
+                    self.emit(node, f" {i.gen.jac} ")
             else:
                 if (
                     line_break_needed
@@ -481,7 +484,7 @@ class JacFormatPass(Pass):
 
         var: Token,
         """
-        self.emit(node, node.var.value)
+        self.emit(node, node.orig.value)
 
     def exit_ability_def(self, node: ast.AbilityDef) -> None:
         """Sub objects.
@@ -1868,6 +1871,32 @@ class JacFormatPass(Pass):
         if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)):
             self.emit_ln(node, "")
 
+    def exit_check_stmt(self, node: ast.CheckStmt) -> None:
+        """Sub objects.
+
+        target: ExprType,
+        """
+        start = True
+        for i in node.kid:
+            if isinstance(i, ast.CommentToken):
+                if i.is_inline:
+                    self.emit(node, f" {i.gen.jac}")
+                else:
+                    if not node.gen.jac.endswith("\n"):
+                        self.emit_ln(node, "")
+                    self.emit_ln(node, "")
+                    self.emit(node, i.gen.jac)
+            elif isinstance(i, ast.Semi):
+                self.emit(node, i.gen.jac)
+            else:
+                if start:
+                    self.emit(node, i.gen.jac)
+                    start = False
+                else:
+                    self.emit(node, f" {i.gen.jac}")
+        if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)):
+            self.emit_ln(node, "")
+
     def exit_ctrl_stmt(self, node: ast.CtrlStmt) -> None:
         """Sub objects.
 
@@ -1999,7 +2028,6 @@ class JacFormatPass(Pass):
         doc: Optional[Token],
         body: CodeBlock,
         """
-        start = True
         for i in node.kid:
             if isinstance(i, ast.CommentToken):
                 if i.is_inline:
@@ -2010,14 +2038,10 @@ class JacFormatPass(Pass):
             elif isinstance(i, ast.Semi):
                 self.emit(node, i.gen.jac)
             elif isinstance(i, ast.Name):
-                if not i.value.startswith("test_t"):
-                    self.emit(node, f" {i.value} ")
+                if not i.value.startswith("_jac_gen_"):
+                    self.emit(node, f" {i.value}")
             else:
-                if start:
-                    self.emit(node, i.gen.jac)
-                    start = False
-                else:
-                    self.emit(node, f" {i.gen.jac}")
+                self.emit(node, i.gen.jac)
         if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)):
             self.emit_ln(node, "")
 
@@ -2402,7 +2426,16 @@ class JacFormatPass(Pass):
             and isinstance(node.parent.parent, ast.FString)
         ):
             self.emit(node, node.value)
-        self.emit(node, node.value)
+        if "\n" in node.value:
+            string_type = node.value[0:3]
+            pure_string = node.value[3:-3]
+            lines = pure_string.split("\n")
+            self.emit(node, string_type)
+            for line in lines[:-1]:
+                self.emit_ln(node, line)
+            self.emit_ln(node, f"{lines[-1]}{string_type}")
+        else:
+            self.emit(node, node.value)
 
     def enter_bool(self, node: ast.Bool) -> None:
         """Sub objects.

jaclang/compiler/passes/tool/tests/fixtures/corelib.jac

@@ -478,3 +478,19 @@ obj JacPlugin {
 (walker_obj: Any, expr: Any) -> bool {
     return walker_obj._jac_.visit_node(expr);
 }
+
+glob expected_area = 78.53981633974483;
+
+test a1 {
+    check assertAlmostEqual(calculate_area(RAD), expected_area);
+}
+
+test a2 {
+    c = Circle(RAD);
+    check assertAlmostEqual(c.area(), expected_area);
+}
+
+test a3 {
+    c = Circle(RAD);
+    check assertEqual(c.shape_type, ShapeType.CIRCLE);
+}

jaclang/compiler/passes/tool/tests/fixtures/corelib_fmt.jac

@@ -478,3 +478,19 @@ obj JacPlugin {
 (walker_obj: Any, expr: Any) -> bool {
     return walker_obj._jac_.visit_node(expr);
 }
+
+glob expected_area = 78.53981633974483;
+
+test a1 {
+    check assertAlmostEqual(calculate_area(RAD), expected_area);
+}
+
+test a2 {
+    c = Circle(RAD);
+    check assertAlmostEqual(c.area(), expected_area);
+}
+
+test a3 {
+    c = Circle(RAD);
+    check assertEqual(c.shape_type, ShapeType.CIRCLE);
+}

jaclang/compiler/passes/tool/tests/fixtures/doc_string.jac

@@ -0,0 +1,15 @@
+class foo {
+    """
+    doc string
+    """
+    can print_here() {
+        print("i'm here");
+    }
+
+    """this is a
+    multiline docstring
+    to test"""
+    can also_print() {
+        print("I'm in also");
+    }
+}

jaclang/compiler/passes/tool/tests/fixtures/genai/essay_review.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");
 

jaclang/compiler/passes/tool/tests/fixtures/genai/expert_answer.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");
 

jaclang/compiler/passes/tool/tests/fixtures/genai/joke_gen.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");
 

jaclang/compiler/passes/tool/tests/fixtures/genai/odd_word_out.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");
 

jaclang/compiler/passes/tool/tests/fixtures/genai/personality_finder.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");
 

jaclang/compiler/passes/tool/tests/fixtures/genai/text_to_type.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");
 

jaclang/compiler/passes/tool/tests/fixtures/genai/translator.jac

@@ -1,4 +1,4 @@
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");
 

jaclang/compiler/passes/tool/tests/fixtures/genai/wikipedia.jac

@@ -1,5 +1,5 @@
 import:py wikipedia;
-import:py from jaclang.core.llms, Anthropic;
+import:py from mtllm.llms, Anthropic;
 
 glob llm = Anthropic(model_name="claude-3-sonnet-20240229");
 

jaclang/compiler/passes/tool/tests/test_jac_format_pass.py

@@ -44,8 +44,8 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
 
             if diff:
                 print(f"Differences found in comparison:\n{diff}")
-                # raise AssertionError("Files differ after formatting.")
-                self.skipTest("Test failed, but skipping instead of failing.")
+                raise AssertionError("Files differ after formatting.")
+
         except FileNotFoundError:
             print(f"File not found: {original_file} or {formatted_file}")
             raise
@@ -76,6 +76,9 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
         self.compare_files(
             os.path.join(self.fixture_abs_path(""), "corelib_fmt.jac"),
         )
+        self.compare_files(
+            os.path.join(self.fixture_abs_path(""), "doc_string.jac"),
+        )
 
     def test_compare_myca_fixtures(self) -> None:
         """Tests if files in the myca fixtures directory do not change after being formatted."""
@@ -135,14 +138,13 @@ class JacFormatPassTests(TestCaseMicroSuite, AstSyncTestMixin):
             diff = "\n".join(unified_diff(before.splitlines(), after.splitlines()))
             self.assertFalse(diff, "AST structures differ after formatting.")
 
-        except Exception:
+        except Exception as e:
             print(add_line_numbers(code_gen_pure.ir.source.code))
             print("\n+++++++++++++++++++++++++++++++++++++++\n")
             print(add_line_numbers(code_gen_format.ir.gen.jac))
             print("\n+++++++++++++++++++++++++++++++++++++++\n")
             print("\n".join(unified_diff(before.splitlines(), after.splitlines())))
-            self.skipTest("Test failed, but skipping instead of failing.")
-            # raise e
+            raise e
 
 
 JacFormatPassTests.self_attach_micro_tests()

jaclang/compiler/passes/tool/tests/test_unparse_validate.py

@@ -30,7 +30,7 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
             self.assertEqual(x, y)
         except Exception as e:
             print("\n".join(unified_diff(x.splitlines(), y.splitlines())))
-            self.skipTest(f"Test failed, but skipping instead of failing: {e}")
+            raise e
 
     def micro_suite_test(self, filename: str) -> None:
         """Parse micro jac file."""
@@ -75,7 +75,6 @@ class JacUnparseTests(TestCaseMicroSuite, AstSyncTestMixin):
 
         except Exception as e:
             raise e
-            # self.skipTest(f"Test failed, but skipping instead of failing: {e}")
 
 
 JacUnparseTests.self_attach_micro_tests()

jaclang/compiler/passes/transform.py

@@ -22,7 +22,7 @@ class Alert:
     def __str__(self) -> str:
         """Return string representation of alert."""
         return (
-            f"{self.loc.mod_path}, line {self.loc.first_line},"
+            f" {self.loc.mod_path}, line {self.loc.first_line},"
             f" col {self.loc.col_start}: {self.msg}"
         )
 
@@ -40,7 +40,7 @@ class Transform(ABC, Generic[T]):
         prior: Optional[Transform] = None,
     ) -> None:
         """Initialize pass."""
-        self.logger = logging.getLogger(self.__class__.__module__)
+        self.logger = logging.getLogger(self.__class__.__name__)
         self.errors_had: list[Alert] = [] if not prior else prior.errors_had
         self.warnings_had: list[Alert] = [] if not prior else prior.warnings_had
         self.cur_node: AstNode = input_ir  # tracks current node during traversal
@@ -59,7 +59,6 @@ class Transform(ABC, Generic[T]):
             self.__class__,
         )
         self.errors_had.append(alrt)
-        # print("Error:", str(alrt))
         self.logger.error(str(alrt))
 
     def log_warning(self, msg: str, node_override: Optional[AstNode] = None) -> None:
@@ -70,5 +69,4 @@ class Transform(ABC, Generic[T]):
             self.__class__,
         )
         self.warnings_had.append(alrt)
-        # print("Warning:", str(alrt))
         self.logger.warning(str(alrt))

jaclang/{core/registry.py → compiler/semtable.py}

@@ -12,9 +12,7 @@ from typing import Optional
 class SemInfo:
     """Semantic information class."""
 
-    def __init__(
-        self, name: str, type: Optional[str] = None, semstr: Optional[str] = None
-    ) -> None:
+    def __init__(self, name: str, type: Optional[str] = None, semstr: str = "") -> None:
         """Initialize the class."""
         self.name = name
         self.type = type

jaclang/compiler/symtable.py

@@ -2,71 +2,14 @@
 
 from __future__ import annotations
 
-from enum import Enum
-from typing import Optional, TYPE_CHECKING
+import ast as ast3
+from typing import Optional, Sequence
 
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.constant import SymbolAccess, SymbolType
 from jaclang.utils.treeprinter import dotgen_symtab_tree, print_symtab_tree
 
 
-if TYPE_CHECKING:
-    import jaclang.compiler.absyntree as ast
-
-
-class SymbolType(Enum):
-    """Symbol types."""
-
-    MODULE = "module"  # LSP: Module
-    MOD_VAR = "mod_var"  # LSP: Variable
-    VAR = "var"  # LSP: Variable
-    IMM_VAR = "immutable"  # LSP: Constant
-    ABILITY = "ability"  # LSP: Function
-    OBJECT_ARCH = "object"  # LSP: Class
-    NODE_ARCH = "node"  # LSP: Class
-    EDGE_ARCH = "edge"  # LSP: Class
-    WALKER_ARCH = "walker"  # LSP: Class
-    ENUM_ARCH = "enum"  # LSP: Enum
-    TEST = "test"  # LSP: Function
-    TYPE = "type"  # LSP: TypeParameter
-    IMPL = "impl"  # LSP: Interface or Property
-    HAS_VAR = "field"  # LSP: Field
-    METHOD = "method"  # LSP: Method
-    CONSTRUCTOR = "constructor"  # LSP: Constructor
-    ENUM_MEMBER = "enum_member"  # LSP: EnumMember
-    NUMBER = "number"  # LSP: Number
-    STRING = "string"  # LSP: String
-    BOOL = "bool"  # LSP: Boolean
-    SEQUENCE = "sequence"  # LSP: Array
-    NULL = "null"  # LSP: Null
-
-    def __str__(self) -> str:
-        """Stringify."""
-        return self.value
-
-
-class SymbolInfo:
-    """Symbol Info."""
-
-    def __init__(
-        self, typ: str = "NoType", acc_tag: Optional[SymbolAccess] = None
-    ) -> None:  # noqa: ANN401
-        """Initialize."""
-        self.typ = typ
-        self.acc_tag: Optional[SymbolAccess] = acc_tag
-        self.typ_sym_table: Optional[SymbolTable] = None
-
-
-class SymbolAccess(Enum):
-    """Symbol types."""
-
-    PRIVATE = "private"
-    PUBLIC = "public"
-    PROTECTED = "protected"
-
-    def __str__(self) -> str:
-        """Stringify."""
-        return self.value
-
-
 # Symbols can have mulitple definitions but resolves decl to be the
 # first such definition in a given scope.
 class Symbol:
@@ -74,20 +17,19 @@ class Symbol:
 
     def __init__(
         self,
-        defn: ast.AstSymbolNode,
+        defn: ast.NameAtom,
         access: SymbolAccess,
         parent_tab: SymbolTable,
-        typ: Optional[type] = None,
     ) -> None:
         """Initialize."""
-        self.typ = typ
-        self.defn: list[ast.AstSymbolNode] = [defn]
-        defn.sym_link = self
-        self.access = access
+        self.defn: list[ast.NameAtom] = [defn]
+        self.uses: list[ast.NameAtom] = []
+        defn.sym = self
+        self.access: SymbolAccess = access
         self.parent_tab = parent_tab
 
     @property
-    def decl(self) -> ast.AstSymbolNode:
+    def decl(self) -> ast.NameAtom:
         """Get decl."""
         return self.defn[0]
 
@@ -99,19 +41,32 @@ class Symbol:
     @property
     def sym_type(self) -> SymbolType:
         """Get sym_type."""
-        return self.decl.sym_type
+        return self.decl.sym_category
 
-    def add_defn(self, node: ast.AstSymbolNode) -> None:
+    @property
+    def sym_dotted_name(self) -> str:
+        """Return a full path of the symbol."""
+        out = [self.defn[0].sym_name]
+        current_tab: SymbolTable | None = self.parent_tab
+        while current_tab is not None:
+            out.append(current_tab.name)
+            current_tab = current_tab.parent
+        out.reverse()
+        return ".".join(out)
+
+    def add_defn(self, node: ast.NameAtom) -> None:
         """Add defn."""
         self.defn.append(node)
-        node.sym_link = self
+        node.sym = self
+
+    def add_use(self, node: ast.NameAtom) -> None:
+        """Add use."""
+        self.uses.append(node)
+        node.sym = self
 
     def __repr__(self) -> str:
         """Repr."""
-        return (
-            f"Symbol({self.sym_name}, {self.sym_type}, {self.access}, "
-            f"{self.typ}, {self.defn})"
-        )
+        return f"Symbol({self.sym_name}, {self.sym_type}, {self.access}, {self.defn})"
 
 
 class SymbolTable:
@@ -123,27 +78,25 @@ class SymbolTable:
         """Initialize."""
         self.name = name
         self.owner = owner
-        self.parent = parent if parent else self
+        self.parent = parent
         self.kid: list[SymbolTable] = []
         self.tab: dict[str, Symbol] = {}
-        self.uses: list[ast.AstSymbolNode] = []
+        self.inherit: list[SymbolTable] = []
 
-    def has_parent(self) -> bool:
-        """Check if has parent."""
-        return self.parent != self
-
-    def get_parent(self) -> SymbolTable:
+    def get_parent(self) -> Optional[SymbolTable]:
         """Get parent."""
-        if self.parent == self:
-            raise Exception("No parent")
         return self.parent
 
     def lookup(self, name: str, deep: bool = True) -> Optional[Symbol]:
         """Lookup a variable in the symbol table."""
         if name in self.tab:
             return self.tab[name]
-        if deep and self.has_parent():
-            return self.get_parent().lookup(name, deep)
+        for i in self.inherit:
+            found = i.lookup(name, deep=False)
+            if found:
+                return found
+        if deep and self.parent:
+            return self.parent.lookup(name, deep)
         return None
 
     def insert(
@@ -164,7 +117,7 @@ class SymbolTable:
         )
         if node.sym_name not in self.tab:
             self.tab[node.sym_name] = Symbol(
-                defn=node,
+                defn=node.name_spec,
                 access=(
                     access_spec
                     if isinstance(access_spec, SymbolAccess)
@@ -173,8 +126,8 @@ class SymbolTable:
                 parent_tab=self,
             )
         else:
-            self.tab[node.sym_name].add_defn(node)
-        node.sym_link = self.tab[node.sym_name]
+            self.tab[node.sym_name].add_defn(node.name_spec)
+        node.name_spec.sym = self.tab[node.sym_name]
         return collision
 
     def find_scope(self, name: str) -> Optional[SymbolTable]:
@@ -189,6 +142,114 @@ class SymbolTable:
         self.kid.append(SymbolTable(name, key_node, self))
         return self.kid[-1]
 
+    def inherit_sym_tab(self, target_sym_tab: SymbolTable) -> None:
+        """Inherit symbol table."""
+        for i in target_sym_tab.tab.values():
+            self.def_insert(i.decl, access_spec=i.access)
+
+    def def_insert(
+        self,
+        node: ast.AstSymbolNode,
+        access_spec: Optional[ast.AstAccessNode] | SymbolAccess = None,
+        single_decl: Optional[str] = None,
+    ) -> Optional[Symbol]:
+        """Insert into symbol table."""
+        if node.sym and self == node.sym.parent_tab:
+            return node.sym
+        self.insert(node=node, single=single_decl is not None, access_spec=access_spec)
+        self.update_py_ctx_for_def(node)
+        return node.sym
+
+    def chain_def_insert(self, node_list: list[ast.AstSymbolNode]) -> None:
+        """Link chain of containing names to symbol."""
+        if not node_list:
+            return
+        cur_sym_tab: SymbolTable | None = node_list[0].sym_tab
+        node_list[-1].name_spec.py_ctx_func = ast3.Store
+        if isinstance(node_list[-1].name_spec, ast.AstSymbolNode):
+            node_list[-1].name_spec.py_ctx_func = ast3.Store
+
+        node_list = node_list[:-1]  # Just performs lookup mappings of pre assign chain
+        for i in node_list:
+            cur_sym_tab = (
+                lookup.decl.sym_tab
+                if (
+                    lookup := self.use_lookup(
+                        i,
+                        sym_table=cur_sym_tab,
+                    )
+                )
+                else None
+            )
+
+    def use_lookup(
+        self,
+        node: ast.AstSymbolNode,
+        sym_table: Optional[SymbolTable] = None,
+    ) -> Optional[Symbol]:
+        """Link to symbol."""
+        if node.sym:
+            return node.sym
+        if not sym_table:
+            sym_table = node.sym_tab
+        if sym_table:
+            lookup = sym_table.lookup(name=node.sym_name, deep=True)
+            lookup.add_use(node.name_spec) if lookup else None
+        return node.sym
+
+    def chain_use_lookup(self, node_list: Sequence[ast.AstSymbolNode]) -> None:
+        """Link chain of containing names to symbol."""
+        if not node_list:
+            return
+        cur_sym_tab: SymbolTable | None = node_list[0].sym_tab
+        for i in node_list:
+            if cur_sym_tab is None:
+                break
+            cur_sym_tab = (
+                lookup.decl.sym_tab
+                if (
+                    lookup := self.use_lookup(
+                        i,
+                        sym_table=cur_sym_tab,
+                    )
+                )
+                else None
+            )
+
+    def update_py_ctx_for_def(self, node: ast.AstSymbolNode) -> None:
+        """Update python context for definition."""
+        node.name_spec.py_ctx_func = ast3.Store
+        if isinstance(node, (ast.TupleVal, ast.ListVal)) and node.values:
+            # Handling of UnaryExpr case for item is only necessary for
+            # the generation of Starred nodes in the AST for examples
+            # like `(a, *b) = (1, 2, 3, 4)`.
+            def fix(item: ast.TupleVal | ast.ListVal | ast.UnaryExpr) -> None:
+                if isinstance(item, ast.UnaryExpr):
+                    if isinstance(item.operand, ast.AstSymbolNode):
+                        item.operand.name_spec.py_ctx_func = ast3.Store
+                elif isinstance(item, (ast.TupleVal, ast.ListVal)):
+                    for i in item.values.items if item.values else []:
+                        if isinstance(i, ast.AstSymbolNode):
+                            i.name_spec.py_ctx_func = ast3.Store
+                        elif isinstance(i, ast.AtomTrailer):
+                            self.chain_def_insert(i.as_attr_list)
+                        if isinstance(i, (ast.TupleVal, ast.ListVal, ast.UnaryExpr)):
+                            fix(i)
+
+            fix(node)
+
+    def inherit_baseclasses_sym(self, node: ast.Architype | ast.Enum) -> None:
+        """Inherit base classes symbol tables."""
+        if node.base_classes:
+            for base_cls in node.base_classes.items:
+                if (
+                    isinstance(base_cls, ast.AstSymbolNode)
+                    and (found := self.use_lookup(base_cls))
+                    and found
+                ):
+                    self.inherit.append(found.decl.sym_tab)
+                    base_cls.name_spec.name_of = found.decl.name_of
+
     def pp(self, depth: Optional[int] = None) -> str:
         """Pretty print."""
         return print_symtab_tree(root=self, depth=depth)

jaclang/compiler/tests/test_parser.py

@@ -102,9 +102,9 @@ class TestLarkParser(TestCaseMicroSuite):
             "JacSource",
             "EmptyToken",
             "AstSymbolNode",
+            "AstSymbolStubNode",
             "AstImplNeedingNode",
             "AstAccessNode",
-            "TokenSymbol",
             "Literal",
             "AstDocNode",
             "AstSemStrNode",
@@ -119,7 +119,7 @@ class TestLarkParser(TestCaseMicroSuite):
             "ArchBlockStmt",
             "EnumBlockStmt",
             "CodeBlockStmt",
-            "NameSpec",
+            "NameAtom",
             "ArchSpec",
             "MatchPattern",
         ]