Perform cleaning code

smnp/ast/node/expression.py

@@ -19,14 +19,13 @@ def ExpressionParser(input):
         lambda left, op, right: Expression.withValue(BinaryOperator.withValues(left, op, right))
     )
 
-    expr2 =  Parser.leftAssociativeOperatorParser(
+    expr2 = Parser.leftAssociativeOperatorParser(
         expr1,
         [TokenType.RELATION, TokenType.OPEN_ANGLE, TokenType.CLOSE_ANGLE],
         expr1,
         lambda left, op, right: Expression.withValue(BinaryOperator.withValues(left, op, right))
     )
 
-
     expr3 = Parser.leftAssociativeOperatorParser(
         expr2,
         [TokenType.AND],
@@ -34,7 +33,6 @@ def ExpressionParser(input):
         lambda left, op, right: Expression.withValue(BinaryOperator.withValues(left, op, right))
     )
 
-
     expr4 = Parser.leftAssociativeOperatorParser(
         expr3,
         [TokenType.OR],

smnp/ast/node/identifier.py

@@ -54,8 +54,6 @@ def IdentifierLiteralParser(input):
 
 
 def IdentifierParser(input):
-
-
     functionCallParser = Parser.allOf(
         IdentifierLiteralParser,
         abstractIterableParser(ArgumentsList, TokenType.OPEN_PAREN, TokenType.CLOSE_PAREN, ExpressionParser),

smnp/ast/node/imports.py

@@ -1,11 +1,3 @@
-# from smnp.ast.node.identifier import Identifier
-# from smnp.ast.node.model import Node
-# from smnp.ast.node.none import NoneNode
-# from smnp.ast.node.string import StringLiteralNode
-# from smnp.ast.node.type import TypeNode
-# from smnp.ast.parser import Parser
-# from smnp.token.type import TokenType
-#
 from smnp.ast.node.atom import StringParser
 from smnp.ast.node.model import Node
 from smnp.ast.parser import Parser

smnp/ast/node/model.py

@@ -28,21 +28,6 @@ class Node:
     def pop(self, index):
         return self.children.pop(index)
 
-    @classmethod
-    def _parse(cls, input):
-        pass
-
-    @classmethod
-    def parse(cls, input):
-        result = cls._parse(input)
-        if result is None:
-            return ParseResult.FAIL()
-
-        if not isinstance(result, ParseResult):
-            raise RuntimeError(f"_parse() method of '{cls.__name__}' class haven't returned ParseResult object")
-
-        return result
-
     def print(self):
         self._print(first=True)
 

smnp/ast/node/program.py

@@ -4,6 +4,7 @@ from smnp.ast.node.imports import ImportParser
 from smnp.ast.node.model import Node, ParseResult
 from smnp.ast.node.statement import StatementParser
 from smnp.ast.parser import Parser
+from smnp.error.syntax import SyntaxException
 
 
 class Program(Node):
@@ -13,15 +14,19 @@ class Program(Node):
 def ProgramParser(input):
     def parse(input):
         root = Program()
+
+        # Start Symbol
+        startSymbolParser = Parser.oneOf(
+            ImportParser,
+            FunctionDefinitionParser,
+            ExtendParser,
+            StatementParser,
+            exception=lambda inp: SyntaxException(f"Invalid statement: {inp.currentToEndOfLine()}", inp.current().pos),
+            name="start symbol"
+        )
+
         while input.hasCurrent():
-            result = Parser.oneOf(
-                # Start Symbol
-                ImportParser,
-                FunctionDefinitionParser,
-                ExtendParser,
-                StatementParser,
-                exception=RuntimeError("Nie znam tego wyrazenia")
-            )(input)
+            result = startSymbolParser(input)
 
             if result.result:
                 root.append(result.node)
@@ -29,21 +34,3 @@ def ProgramParser(input):
         return ParseResult.OK(root)
 
     return Parser(parse, name="program")(input)
-    # @classmethod
-    # def _parse(cls, input):
-    #     def parseToken(input):
-    #         return Parser.oneOf(
-    #             FunctionDefinitionNode.parse,
-    #             ExtendNode.parse,
-    #             ExpressionNode.parse,
-    #             ImportNode.parse,
-    #             StatementNode.parse,
-    #             exception = SyntaxException(f"Invalid statement: {input.currentToEndOfLine()}", input.current().pos)
-    #         )(input)
-    #
-    #     root = Program()
-    #     while input.hasCurrent():
-    #         result = parseToken(input)
-    #         if result.result:
-    #             root.append(result.node)
-    #     return ParseResult.OK(root)

smnp/ast/node/statement.py

@@ -18,17 +18,3 @@ def StatementParser(input):
     )
 
     return Parser(parser, "statement", parser)(input)
-
-# class StatementNode(Node):
-#
-#     @classmethod
-#     def _parse(cls, input):
-#         from smnp.ast.node.block import BlockNode
-#         from smnp.ast.node.expression import ExpressionNode
-#         from smnp.ast.node.ret import ReturnNode
-#
-#         return Parser.oneOf(
-#             ExpressionNode.parse,
-#             BlockNode.parse,
-#             ReturnNode.parse,
-#         )(input)

smnp/ast/node/type.py

@@ -1,10 +1,3 @@
-# from smnp.ast.node.iterable import abstractIterableParser
-# from smnp.ast.node.model import Node
-# from smnp.ast.node.operator import LeftAssociativeOperatorNode
-# from smnp.ast.parser import Parser
-# 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
@@ -47,10 +40,6 @@ class TypesList(Node):
 
 
 def TypesListParser(input):
-    typeListItem = Parser.oneOf(
-        TypeParser
-    )
-
     return abstractIterableParser(
         TypesList,
         TokenType.OPEN_ANGLE,
@@ -76,60 +65,3 @@ def TypeParser(input):
         TypesListParser,
         name="mult. types or type with specifier"
     )(input)
-
-
-# class TypeSpecifier(Node):
-#
-#     @classmethod
-#     def _parse(cls, input):
-#         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 TypeSpecifiers(Node):
-#     pass
-#
-#
-# class TypeNode(LeftAssociativeOperatorNode):
-#     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 specifiers(self):
-#         return self[1]
-#
-#     @specifiers.setter
-#     def specifiers(self, value):
-#         self[1] = value
-#
-#     @classmethod
-#     def _parse(cls, input):
-#         def createNode(type, specifiers):
-#             node = TypeNode(type.pos)
-#             node.type = Type[type.value.upper()]
-#             node.specifiers = specifiers
-#             return node
-#
-#         return Parser.allOf(
-#             cls._rawTypeParser(),
-#             Parser.many(TypeSpecifier.parse, lambda specifiers, pos: TypeSpecifiers.withChildren(specifiers, pos)),
-#             createNode=createNode
-#         )(input)
-#
-#     @classmethod
-#     def _rawTypeParser(cls):
-#         return Parser.terminalParser(TokenType.TYPE, lambda val, pos: TypeNode.withValue(val, pos))