Enable support for specifying types by angle braces

smnp/ast/node/type.py

@@ -1,13 +1,66 @@
 from smnp.ast.node.access import AccessNode
-from smnp.ast.node.literal import LiteralNode
+from smnp.ast.node.iterable import abstractIterableParser
+from smnp.ast.node.model import Node
+from smnp.ast.parser import Parser
 from smnp.token.type import TokenType
 
 
-class TypeNode(LiteralNode, AccessNode):
+class TypeSpecifier(Node):
-    def __init__(self, pos):
-        super().__init__(pos)
-        del self.children[1]
 
     @classmethod
-    def _getTokenType(cls):
+    def _parse(cls, input):
-        return TokenType.TYPE
+        return abstractIterableParser(TypeSpecifier, TokenType.OPEN_ANGLE, TokenType.CLOSE_ANGLE,
+                                      Parser.doAssert(cls._specifierItem(), "type"))(input)
+
+    @classmethod
+    def _specifierItem(cls):
+        return Parser.oneOf(
+            TypeNode.parse,
+            cls.parse
+        )
+
+
+class TypeNode(AccessNode):
+    def __init__(self, pos):
+        super().__init__(pos)
+
+    @property
+    def type(self):
+        return self[0]
+
+    @type.setter
+    def type(self, value):
+        self[0] = value
+
+    @property
+    def specifier(self):
+        return self[1]
+
+    @specifier.setter
+    def specifier(self, value):
+        self[1] = value
+
+    @classmethod
+    def _parse(cls, input):
+        return Parser.oneOf(
+            cls._specifiedTypeParser(),
+            cls._rawTypeParser()
+        )(input)
+
+    @classmethod
+    def _specifiedTypeParser(cls):
+        def createNode(type, specifier):
+            node = TypeNode(type.pos)
+            node.type = type.value
+            node.specifier = specifier
+            return node
+
+        return Parser.allOf(
+            cls._rawTypeParser(),
+            TypeSpecifier.parse,
+            createNode=createNode
+        )
+
+    @classmethod
+    def _rawTypeParser(cls):
+        return Parser.terminalParser(TokenType.TYPE, lambda val, pos: TypeNode.withValue(val, pos))

smnp/ast/node/variable.py

@@ -3,7 +3,7 @@ from smnp.ast.node.identifier import IdentifierNode
 from smnp.ast.node.none import NoneNode
 from smnp.ast.node.type import TypeNode
 from smnp.ast.parser import Parser
-from smnp.token.type import TokenType
+
 
 class TypedVariableNode(ExpressionNode):
     def __init__(self, pos):
@@ -35,7 +35,7 @@ class TypedVariableNode(ExpressionNode):
             return node
 
         return Parser.allOf(
-            Parser.terminalParser(TokenType.TYPE, lambda val, pos: TypeNode.withValue(val, pos)),
+            TypeNode.parse,
             Parser.doAssert(IdentifierNode.identifierParser(), "variable name"),
             createNode=createNode
         )