Merge pull request #31 from MarcellPerger1/start-ast

Refactor CST nodes

Author: MarcellPerger1

main.py

@@ -4,7 +4,7 @@
 from util import readfile
 from parser.cst.treegen import TreeGen
 from parser.lexer import Tokenizer, print_tokens
-from parser.cst.tree_print import tprint
+from parser.trees.tree_print import tprint
 
 
 def make_tree(src: str):

parser/cst/nodes.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
 
-from .named_node import (NamedLeafCls, NamedNodeCls, NamedSizedNodeCls,
-                         register_corresponding_token)
+from typing import cast
+
+from util import checked_cast
+from ..trees.named_node import (NamedLeafCls, NamedNodeCls, NamedSizedNodeCls,
+                                register_corresponding_token)
 
 __all__ = [
     "NumberNode", "StringNode", "AnyNameLeaf", "IdentNode", "AttrNameNode",
@@ -16,6 +19,10 @@
 class ProgramNode(NamedNodeCls):
     name = 'program'  # Varargs
 
+    @property
+    def statements(self):
+        return self.children
+
 
 # region ---- Expressions ----
 @register_corresponding_token
@@ -45,30 +52,66 @@ class AttrNameNode(AnyNameLeaf):
 class AutocatNode(NamedNodeCls):
     name = 'autocat'  # Note: this is varargs, unlike regular concat
 
+    @property
+    def parts(self) -> list[StringNode]:
+        return cast(list[StringNode], self.children)
+
 
 class GetattrNode(NamedSizedNodeCls):
     name = 'getattr'
     size = 2
 
+    @property
+    def target(self):
+        return self.children[0]
+
+    @property
+    def attr(self):
+        return self.children[1]
+
 
 class GetitemNode(NamedSizedNodeCls):
     name = 'getitem'
     size = 2
 
+    @property
+    def target(self):
+        return self.children[0]
+
+    @property
+    def item(self):
+        return checked_cast(AttrNameNode, self.children[1])
+
 
 class ParenNode(NamedSizedNodeCls):
     name = 'paren'
     size = 1
 
+    @property
+    def contents(self):
+        return self.children[0]
+
 
 class CallNode(NamedSizedNodeCls):
     name = 'call'
     size = 2
 
+    @property
+    def target(self):
+        return self.children[0]
+
+    @property
+    def arglist(self) -> CallArgs:
+        return checked_cast(CallArgs, self.children[1])
+
 
 class CallArgs(NamedNodeCls):
     name = 'call_args'  # Varargs
 
+    @property
+    def args(self):
+        return self.children
+
 
 class OperatorNode(NamedNodeCls):
     pass
@@ -77,6 +120,10 @@ class OperatorNode(NamedNodeCls):
 class UnaryOpNode(NamedSizedNodeCls, OperatorNode):
     size = 1
 
+    @property
+    def operand(self):
+        return self.children[0]
+
 
 @register_corresponding_token('+', arity=1)
 @register_corresponding_token()
@@ -98,6 +145,14 @@ class NotNode(UnaryOpNode):
 class BinOpNode(NamedSizedNodeCls, OperatorNode):
     size = 2
 
+    @property
+    def left(self):
+        return self.children[0]
+
+    @property
+    def right(self):
+        return self.children[1]
+
 
 @register_corresponding_token
 class AddNode(BinOpNode):
@@ -188,25 +243,61 @@ class NopNode(NamedLeafCls):
 class BlockNode(NamedNodeCls):
     name = 'block'  # Varargs
 
+    @property
+    def statements(self):
+        return self.children
+
 
 class ConditionalBlock(NamedNodeCls):  # Varargs: if, *elseif, else
     name = 'conditional'
 
+    @property
+    def if_block(self):
+        return checked_cast(IfBlock, self.children[0])
+
+    @property
+    def elseif_blocks(self):
+        return cast(list[ElseIfBlock], self.children[1:-1])
+
+    @property
+    def else_block(self) -> ElseBlock | NullElseBlock:
+        return checked_cast(ElseBlock | NullElseBlock, self.children[-1])
+
 
 class IfBlock(NamedSizedNodeCls):
     name = 'if'
     size = 2  # condition, block
 
+    @property
+    def cond(self):
+        return self.children[0]
+
+    @property
+    def block(self):
+        return checked_cast(BlockNode, self.children[1])
+
 
 class ElseIfBlock(NamedSizedNodeCls):
     name = 'elseif'
     size = 2
 
+    @property
+    def cond(self):
+        return self.children[0]
+
+    @property
+    def block(self):
+        return checked_cast(BlockNode, self.children[1])
+
 
 class ElseBlock(NamedSizedNodeCls):
     name = 'else'
     size = 1  # just the BlockNode
 
+    @property
+    def block(self):
+        return checked_cast(BlockNode, self.children[0])
+
 
 class NullElseBlock(NamedLeafCls):
     name = 'else_null'
@@ -217,42 +308,106 @@ class WhileBlock(NamedSizedNodeCls):
     name = 'while'
     size = 2
 
+    @property
+    def cond(self):
+        return self.children[0]
+
+    @property
+    def block(self):
+        return checked_cast(BlockNode, self.children[1])
+
 
 class RepeatBlock(NamedSizedNodeCls):
     name = 'repeat'
     size = 2
 
+    @property
+    def count(self):
+        return self.children[0]
+
+    @property
+    def block(self):
+        return checked_cast(BlockNode, self.children[1])
+
 
 class DefineNode(NamedSizedNodeCls):
     name = 'def'
     size = 3  # name, args_decl, block
 
+    @property
+    def ident(self):
+        return checked_cast(IdentNode, self.children[0])
+
+    @property
+    def args_decl(self):
+        return checked_cast(ArgsDeclNode, self.children[1])
+
+    @property
+    def block(self):
+        return checked_cast(BlockNode, self.children[1])
+
 
 class ArgsDeclNode(NamedNodeCls):
     name = 'args_decl'  # Varargs
 
+    @property
+    def decls(self):
+        return cast(list[ArgDeclNode], self.children)
+
 
 class ArgDeclNode(NamedSizedNodeCls):
     name = 'arg_decl'
     size = 2  # type and name
 
+    @property
+    def type(self):
+        return checked_cast(IdentNode, self.children[0])
+
+    @property
+    def ident(self):
+        return checked_cast(IdentNode, self.children[1])
+# endregion
+
 
 class DeclItemNode(NamedNodeCls):
     name = 'decl_item'  # 1 or 2 (name and optional value)
-# endregion
+
+    @property
+    def ident(self):
+        return checked_cast(IdentNode, self.children[0])
+
+    @property
+    def value(self):
+        if len(self.children) <= 1:
+            return None
+        return self.children[1]
 
 
 class LetNode(NamedNodeCls):
     name = 'let_decl'  # Varargs
 
+    @property
+    def decls(self):
+        return cast(list[DeclItemNode], self.children)
+
 
 class GlobalNode(NamedNodeCls):
     name = 'global_decl'  # Varargs
 
+    @property
+    def decls(self):
+        return cast(list[DeclItemNode], self.children)
+
 
 # region ---- Assignment-ops ----
 class AssignOpNode(BinOpNode):
-    pass
+    @property
+    def target(self):
+        return self.children[0]
+
+    @property
+    def source(self):
+        return self.children[1]
 
 
 @register_corresponding_token

parser/cst/treegen.py

@@ -4,13 +4,13 @@
 
 from .nodes import *
 from .token_matcher import OpM, KwdM, Matcher, PatternT
-from .named_node import AnyNamedNode, node_from_token, node_cls_from_name
-from .base_node import AnyNode, Node
 from ..error import BaseParseError, BaseLocatedError
 from ..lexer import Tokenizer
 from ..operators import UNARY_OPS, COMPARISONS, ASSIGN_OPS
 from ..str_region import StrRegion
 from ..tokens import *
+from ..trees.base_node import AnyNode, Node
+from ..trees.named_node import AnyNamedNode, node_from_token, node_cls_from_name
 
 DT = TypeVar('DT')
 

parser/trees/__init__.py

@@ -4,10 +4,10 @@
 from typing import TYPE_CHECKING, overload, Sequence, cast, Literal
 
 from .base_node import Leaf, AnyNode, Node
-from ..str_region import StrRegion
+from parser.str_region import StrRegion
 
 if TYPE_CHECKING:
-    from ..tokens import Token
+    from parser.tokens import Token
 
 
 # NOTE: these classes only follow the Liskov substitution principle on

parser/cst/base_node.py parser/trees/base_node.pyparser/cst/base_node.py renamed to parser/trees/base_node.py

@@ -5,7 +5,7 @@
 from typing import IO, Sequence
 
 from .base_node import Leaf, AnyNode, Node
-from ..str_region import StrRegion
+from parser.str_region import StrRegion
 
 __all__ = [
     'TreePrinter', 'tree_print', 'tree_format', 'tprint', 'tformat'

parser/cst/named_node.py parser/trees/named_node.pyparser/cst/named_node.py renamed to parser/trees/named_node.py

@@ -5,8 +5,8 @@
 from enum import IntFlag, Enum
 from typing import Sequence, TypeVar
 
-from parser.cst.base_node import Leaf, AnyNode, Node
-from parser.cst.tree_print import tformat
+from parser.trees.base_node import Leaf, AnyNode, Node
+from parser.trees.tree_print import tformat
 from parser.cst.treegen import TreeGen, CstParseError
 from parser.error import BaseParseError
 from parser.lexer import Tokenizer

parser/cst/tree_print.py parser/trees/tree_print.pyparser/cst/tree_print.py renamed to parser/trees/tree_print.py

@@ -2,7 +2,7 @@
 
 from parser.str_region import StrRegion
 from parser.tokens import NumberToken, IdentNameToken
-from parser.cst.named_node import node_from_token
+from parser.trees.named_node import node_from_token
 from parser.cst.nodes import NumberNode, IdentNode
 
 

test/common.py

@@ -1,13 +1,28 @@
 from __future__ import annotations
 
 from os import PathLike
+from typing import TypeVar, Any, overload
 
 from .simple_process_pool import *
 from .timeouts import *
 
+T = TypeVar('T')
+U = TypeVar('U')
+
 
 def readfile(path: int | str | bytes | PathLike[str] | PathLike[bytes],
              encoding='utf-8', errors: str | None = None,
              newline: str | None = None):
     with open(path, encoding=encoding, errors=errors, newline=newline, ) as f:
         return f.read()
+
+
+@overload
+def checked_cast(typ: type[T], val: Any) -> T: ...
+@overload
+def checked_cast(typ: type[T | U], val: Any) -> T | U: ...
+
+
+def checked_cast(typ: type[T], val: Any) -> T:
+    assert isinstance(val, typ)
+    return val