Add support for 'extend' statement

smnp/ast/node/extend.py

@@ -1,70 +1,68 @@
-# from smnp.ast.node.block import BlockNode
+from smnp.ast.node.block import Block
-# from smnp.ast.node.function import FunctionDefinitionNode
+from smnp.ast.node.function import FunctionDefinitionParser
-# from smnp.ast.node.identifier import IdentifierNode
+from smnp.ast.node.identifier import IdentifierLiteralParser
-# from smnp.ast.node.none import NoneNode
+from smnp.ast.node.model import Node
-# from smnp.ast.node.statement import StatementNode
+from smnp.ast.node.none import NoneNode
-# from smnp.ast.node.type import TypeNode
+from smnp.ast.node.type import TypeParser
-# from smnp.ast.parser import Parser
+from smnp.ast.parser import Parser
-# from smnp.token.type import TokenType
+from smnp.token.type import TokenType
-#
+
-#
+
-# class ExtendNode(StatementNode):
+class Extend(Node):
-#     def __init__(self, pos):
+    def __init__(self, pos):
-#         super().__init__(pos)
+        super().__init__(pos)
-#         self.children = [NoneNode(), NoneNode(), NoneNode()]
+        self.children = [NoneNode(), NoneNode(), NoneNode()]
-#
+
-#     @property
+    @property
-#     def type(self):
+    def type(self):
-#         return self[0]
+        return self[0]
-#
+
-#     @type.setter
+    @type.setter
-#     def type(self, value):
+    def type(self, value):
-#         self[0] = value
+        self[0] = value
-#
+
-#     @property
+    @property
-#     def variable(self):
+    def variable(self):
-#         return self[1]
+        return self[1]
-#
+
-#     @variable.setter
+    @variable.setter
-#     def variable(self, value):
+    def variable(self, value):
-#         self[1] = value
+        self[1] = value
-#
+
-#     @property
+    @property
-#     def methods(self):
+    def methods(self):
-#         return self[2]
+        return self[2]
-#
+
-#     @methods.setter
+    @methods.setter
-#     def methods(self, value):
+    def methods(self, value):
-#         self[2] = value
+        self[2] = value
-#
+
-#     @classmethod
+    @classmethod
-#     def _parse(cls, input):
+    def withValues(cls, pos, type, variable, methods):
-#         def createNode(extend, type, asKeyword, variable, methods):
+        node = cls(pos)
-#             node = ExtendNode(extend.pos)
+        node.type = type
-#             node.type = type
+        node.variable = variable
-#             node.variable = variable
+        node.methods = methods
-#             node.methods = methods
+        return node
-#             return node
+
-#
+def ExtendParser(input):
-#         return Parser.allOf(
+    return Parser.allOf(
-#             Parser.terminalParser(TokenType.EXTEND),
+        Parser.terminal(TokenType.EXTEND),
-#             Parser.doAssert(TypeNode.parse, "type being extended"),
+        TypeParser,
-#             Parser.terminalParser(TokenType.AS, doAssert=True),
+        Parser.terminal(TokenType.AS),
-#             Parser.doAssert(IdentifierNode.identifierParser(), "variable name"),
+        IdentifierLiteralParser,
-#             Parser.doAssert(cls._methodsDeclarationsParser(), "methods declarations"),
+        MethodsDeclarationParser,
-#             createNode=createNode
+        createNode=lambda extend, type, _, variable, methods: Extend.withValues(extend.pos, type, variable, methods),
-#         )(input)
+        name="extend"
-#
+    )(input)
-#     @classmethod
+
-#     def _methodsDeclarationsParser(cls):
+
-#         def createNode(openBracket, items, closeBracket):
+def MethodsDeclarationParser(input):
-#             node = BlockNode(openBracket.pos)
+    return Parser.loop(
-#             node.children = items
+        Parser.terminal(TokenType.OPEN_CURLY),
-#             return node
+        FunctionDefinitionParser,
-#
+        Parser.terminal(TokenType.CLOSE_CURLY),
-#         return Parser.loop(
+        createNode=lambda open, methods, close: Block.withChildren(methods, open.pos),
-#             Parser.terminalParser(TokenType.OPEN_CURLY),
+        name="methods block"
-#             Parser.doAssert(FunctionDefinitionNode.parse, f"method declaration or '{TokenType.CLOSE_CURLY.key}'"),
+    )(input)
-#             Parser.terminalParser(TokenType.CLOSE_CURLY),
+
-#             createNode=createNode
-#         )

smnp/ast/node/function.py

@@ -123,5 +123,6 @@ def FunctionDefinitionParser(input):
         IdentifierLiteralParser,
         ArgumentsDeclarationParser,
         BlockParser,
-        createNode=lambda _, name, args, body: FunctionDefinition.withValues(name, args, body)
+        createNode=lambda _, name, args, body: FunctionDefinition.withValues(name, args, body),
+        name="function definition"
     )(input)

smnp/ast/node/program.py

@@ -1,3 +1,4 @@
+from smnp.ast.node.extend import ExtendParser
 from smnp.ast.node.function import FunctionDefinitionParser
 from smnp.ast.node.imports import ImportParser
 from smnp.ast.node.model import Node, ParseResult
@@ -17,6 +18,7 @@ def ProgramParser(input):
                 # Start Symbol
                 ImportParser,
                 FunctionDefinitionParser,
+                ExtendParser,
                 StatementParser,
                 exception=RuntimeError("Nie znam tego wyrazenia")
             )(input)