Enable parsing negative integers

smnp/newast/node/expression.py

@@ -18,9 +18,9 @@ class ExpressionNode(Node):
 
 
     @classmethod
-    def withValue(cls, v, pos):
+    def withValue(cls, val, pos):
         node = cls(pos)
-        node.value = v
+        node.value = val
         return node
 
 

smnp/newast/node/integer.py

@@ -1,13 +1,31 @@
 from smnp.newast.node.access import AccessNode
-from smnp.newast.node.literal import LiteralNode
+from smnp.newast.parser import Parser
 from smnp.token.type import TokenType
 
 
-class IntegerLiteralNode(LiteralNode, AccessNode):
+class IntegerLiteralNode(AccessNode):
     def __init__(self, pos):
         super().__init__(pos)
         del self.children[1]
 
     @classmethod
-    def _getTokenType(cls):
-        return TokenType.INTEGER
+    def _literalParser(cls):
+        return Parser.oneOf(
+            cls._negativeIntegerParser(),
+            cls._positiveIntegerParser()
+        )
+
+    @classmethod
+    def _negativeIntegerParser(cls):
+        def createNode(minus, integer):
+            return IntegerLiteralNode.withValue(-integer.value, minus.pos)
+
+        return Parser.allOf(
+            Parser.terminalParser(TokenType.MINUS),
+            cls._positiveIntegerParser(),
+            createNode=createNode
+        )
+
+    @classmethod
+    def _positiveIntegerParser(cls):
+        return Parser.terminalParser(TokenType.INTEGER, lambda val, pos: IntegerLiteralNode.withValue(int(val), pos))

smnp/newast/node/iterable.py

@@ -91,7 +91,7 @@ def abstractIterableParser(iterableNodeType, openTokenType, closeTokenType, item
                 return node
 
             return Parser.allOf(
-                Parser.terminalParser(openTokenType, lambda v, pos: Node(pos)),
+                Parser.terminalParser(openTokenType, lambda val, pos: Node(pos)),
                 itemParser,
                 AbstractIterableTailNode.parse,
                 createNode=createNode

smnp/newast/node/literal.py

@@ -14,5 +14,5 @@ class LiteralNode(ExpressionNode):
 
     @classmethod
     def _literalParser(cls):
-        createNode = lambda v, pos: cls.withValue(cls._processValue(v), pos)
+        createNode = lambda val, pos: cls.withValue(cls._processValue(val), pos)
         return Parser.terminalParser(cls._getTokenType(), createNode)