Add TypeParser (handling types list - specifiers etc.)

smnp/ast/node/atom.py

@@ -67,7 +67,7 @@ def BoolParser(input):
     return Parser.terminalParser(TokenType.BOOL, createNode=BoolLiteral.withValue)(input)
 
 
-def TypeParser(input):
+def TypeLiteralParser(input):
     return Parser.terminalParser(TokenType.TYPE, createNode=TypeLiteral.withValue)(input)
 
 
@@ -77,7 +77,7 @@ def LiteralParser(input):
         StringParser,
         NoteParser,
         BoolParser,
-        TypeParser,
+        TypeLiteralParser,
         name="literal"
     )(input)
 

smnp/ast/node/expression.py

@@ -21,7 +21,7 @@ def ExpressionParser(input):
 
     expr2 =  Parser.leftAssociativeOperatorParser(
         expr1,
-        [TokenType.RELATION],
+        [TokenType.RELATION, TokenType.OPEN_ANGLE, TokenType.CLOSE_ANGLE],
         expr1,
         lambda left, op, right: Expression.withValue(BinaryOperator.withValues(left, op, right))
     )

smnp/ast/node/type.py

@@ -5,7 +5,79 @@
 # from smnp.token.type import TokenType
 # from smnp.type.model import Type
 #
-#
+from smnp.ast.node.atom import TypeLiteralParser
+from smnp.ast.node.iterable import abstractIterableParser
+from smnp.ast.node.model import Node
+from smnp.ast.node.none import NoneNode
+from smnp.ast.parser import Parser
+from smnp.token.type import TokenType
+
+
+class Type(Node):
+    def __init__(self, pos):
+        super().__init__(pos)
+        self.children = [NoneNode(), NoneNode()]
+
+    @property
+    def type(self):
+        return self[0]
+
+    @type.setter
+    def type(self, value):
+        self[0] = value
+
+    @property
+    def specifiers(self):
+        return self[1]
+
+    @specifiers.setter
+    def specifiers(self, value):
+        self[1] = value
+
+    @classmethod
+    def withValues(cls, pos, type, specifiers=NoneNode()):
+        node = cls(pos)
+        node.type = type
+        node.specifiers = specifiers
+        return node
+
+
+class TypesList(Node):
+    pass
+
+
+def TypesListParser(input):
+    typeListItem = Parser.oneOf(
+        TypeParser
+    )
+
+    return abstractIterableParser(
+        TypesList,
+        TokenType.OPEN_ANGLE,
+        TokenType.CLOSE_ANGLE,
+        TypeParser
+    )(input)
+
+
+class TypeSpecifiers(Node):
+    pass
+
+
+def TypeParser(input):
+    typeWithSpecifier = Parser.allOf(
+        TypeLiteralParser,
+        Parser.many(TypesListParser, createNode=TypeSpecifiers.withChildren),
+        createNode=lambda type, specifiers: Type.withValues(type.pos, type, specifiers),
+        name="type with specifiers?"
+    )
+
+    return Parser.oneOf(
+        typeWithSpecifier,
+        TypesListParser,
+        name="mult. types or type with specifier"
+    )(input)
+
+
 # class TypeSpecifier(Node):
 #
 #     @classmethod