Move left associativity of accessing properties to AccessNode class

smnp/newast/node/access.py

@@ -1,5 +1,7 @@
 from smnp.newast.node.expression import ExpressionNode
 from smnp.newast.node.ignore import IgnoredNode
+from smnp.newast.parser import Parser
+from smnp.token.type import TokenType
 
 
 class AccessNode(ExpressionNode):
@@ -8,9 +10,42 @@ class AccessNode(ExpressionNode):
         self.children.append(IgnoredNode(pos))
 
     @property
-    def next(self):
+    def left(self):
+        return self[0]
+
+    @left.setter
+    def left(self, value):
+        self[0] = value
+
+    @property
+    def right(self):
         return self[1]
 
-    @next.setter
-    def next(self, value):
+    @right.setter
+    def right(self, value):
         self[1] = value
+
+    @classmethod
+    def _parse(cls, input):
+        def createNode(left, right):
+            node = AccessNode(right.pos)
+            node.left = left
+            node.right = right
+            return node
+
+        return Parser.leftAssociativeOperatorParser(
+            cls._literalParser(),
+            TokenType.DOT,
+            cls._parseAccessingProperty(),
+            createNode=createNode
+        )(input)
+
+    @classmethod
+    def _literalParser(cls):
+        pass
+
+    @staticmethod
+    def _parseAccessingProperty():
+        from smnp.newast.node.integer import IntegerLiteralNode
+        # TODO: Just for example. It is supposed to be functionCall (and identifier there)
+        return IntegerLiteralNode._literalParser()

smnp/newast/node/integer.py

@@ -1,33 +1,15 @@
 from smnp.newast.node.access import AccessNode
-from smnp.newast.node.expression import ExpressionNode
 from smnp.newast.parser import Parser
 from smnp.token.type import TokenType
 
 
-class IntegerLiteralNode(ExpressionNode):
+class IntegerLiteralNode(AccessNode):
+    def __init__(self, pos):
+        super().__init__(pos)
+        del self.children[1]
+
 
     @classmethod
-    def _parse(cls, input):
-        def createNode(left, right):
-            node = AccessNode(right.pos)
-            node.value = left
-            node.next = right
-            return node
-
-        return Parser.leftAssociativeOperatorParser(
-            IntegerLiteralNode._parseInteger(),
-            TokenType.DOT,
-            IntegerLiteralNode._parseAccessingProperty(),
-            createNode=createNode
-        )(input)
-
-
-    @staticmethod
-    def _parseInteger():
+    def _literalParser(cls):
         createNode = lambda v, pos: IntegerLiteralNode.withValue(v, pos)
-        return Parser.terminalParser(TokenType.INTEGER, createNode)
-
-    @staticmethod
-    def _parseAccessingProperty():
-        # TODO: Just for example. It is supposed to be functionCall (and identifier there)
-        return IntegerLiteralNode._parseInteger()
+        return Parser.terminalParser(TokenType.INTEGER, createNode)