Extend type specifiers to cover maps

smnp/ast/node/model.py

@@ -59,6 +59,12 @@ class Node:
     def __str__(self):
         return self.__class__.__name__
 
+    @classmethod
+    def withChildren(cls, children, pos):
+        node = cls(pos)
+        node.children = children
+        return node
+
 
 class ParseResult():
     def __init__(self, result, node):

smnp/ast/node/type.py

@@ -20,6 +20,9 @@ class TypeSpecifier(Node):
             cls.parse
         )
 
+class TypeSpecifiers(Node):
+    pass
+
 
 class TypeNode(AccessNode):
     def __init__(self, pos):
@@ -34,24 +37,24 @@ class TypeNode(AccessNode):
         self[0] = value
 
     @property
-    def specifier(self):
+    def specifiers(self):
         return self[1]
 
-    @specifier.setter
-    def specifier(self, value):
+    @specifiers.setter
+    def specifiers(self, value):
         self[1] = value
 
     @classmethod
     def _parse(cls, input):
-        def createNode(type, specifier):
+        def createNode(type, specifiers):
             node = TypeNode(type.pos)
             node.type = Type[type.value.upper()]
-            node.specifier = specifier
+            node.specifiers = specifiers
             return node
 
         return Parser.allOf(
             cls._rawTypeParser(),
-            Parser.optional(TypeSpecifier.parse),
+            Parser.many(TypeSpecifier.parse, lambda specifiers, pos: TypeSpecifiers.withChildren(specifiers, pos)),
             createNode=createNode
         )(input)
 

smnp/ast/parser.py

@@ -151,3 +151,20 @@ class Parser:
             return ParseResult.OK(NoneNode())
 
         return parse
+
+    @staticmethod
+    def many(parser, createNode):
+        def parse(input):
+            results = []
+            snap = input.snapshot()
+            pos = input.currentPos()
+            while True:
+                result = parser(input)
+                if result.result:
+                    results.append(result.node)
+                    snap = input.snapshot()
+                else:
+                    input.reset(snap)
+                    return ParseResult.OK(createNode(results, pos) if len(results) > 0 else NoneNode())
+
+        return parse