Add 'throw' statement

smnp/ast/node/statement.py

@@ -10,12 +10,14 @@ def StatementParser(input):
     from smnp.ast.node.block import BlockParser
     from smnp.ast.node.condition import IfElseStatementParser
     from smnp.ast.node.expression import ExpressionParser
-
     from smnp.ast.node.ret import ReturnParser
+    from smnp.ast.node.throw import ThrowParser
+
     return Parser.oneOf(
         IfElseStatementParser,
         ExpressionParser,
         BlockParser,
         ReturnParser,
+        ThrowParser,
         name="statement"
     )(input)

smnp/ast/node/throw.py

@@ -0,0 +1,17 @@
+from smnp.ast.node.expression import ExpressionParser
+from smnp.ast.node.valuable import Valuable
+from smnp.ast.parser import Parser
+from smnp.token.type import TokenType
+
+
+class Throw(Valuable):
+    pass
+
+
+def ThrowParser(input):
+    return Parser.allOf(
+        Parser.terminal(TokenType.THROW),
+        Parser.doAssert(ExpressionParser, "error message as string"),
+        createNode=lambda throw, message: Throw.withValue(message, throw.pos),
+        name="throw"
+    )(input)

smnp/error/custom.py

@@ -0,0 +1,9 @@
+from smnp.error.base import SmnpException
+
+
+class CustomException(SmnpException):
+    def __init__(self, message, pos):
+        super().__init__(message, pos)
+
+    def _title(self):
+        return "Execution Error"

smnp/runtime/evaluator.py

@@ -5,6 +5,7 @@ from smnp.ast.node.function import FunctionDefinition
 from smnp.ast.node.imports import Import
 from smnp.ast.node.program import Program
 from smnp.ast.node.ret import Return
+from smnp.ast.node.throw import Throw
 from smnp.error.runtime import RuntimeException
 from smnp.type.model import Type
 
@@ -69,7 +70,6 @@ class EvaluationResult():
 
 def evaluate(node, environment):
     from smnp.runtime.evaluators.program import ProgramEvaluator
-
     from smnp.runtime.evaluators.expression import expressionEvaluator
     from smnp.runtime.evaluators.condition import IfElseStatementEvaluator
     from smnp.runtime.evaluators.block import BlockEvaluator
@@ -77,6 +77,8 @@ def evaluate(node, environment):
     from smnp.runtime.evaluators.function import FunctionDefinitionEvaluator
     from smnp.runtime.evaluators.function import ReturnEvaluator
     from smnp.runtime.evaluators.extend import ExtendEvaluator
+    from smnp.runtime.evaluators.throw import ThrowEvaluator
+
     result = Evaluator.oneOf(
         Evaluator.forNodes(ProgramEvaluator.evaluate, Program),
         Evaluator.forNodes(IfElseStatementEvaluator.evaluate, IfElse),
@@ -85,6 +87,7 @@ def evaluate(node, environment):
         Evaluator.forNodes(FunctionDefinitionEvaluator.evaluate, FunctionDefinition),
         Evaluator.forNodes(ReturnEvaluator.evaluate, Return),
         Evaluator.forNodes(ExtendEvaluator.evaluate, Extend),
+        Evaluator.forNodes(ThrowEvaluator.evaluate, Throw),
         #Evaluator.forNodes(ImportEvaluator.evaluate, ImportNode),
         #Evaluator.forNodes(FunctionDefinitionEvaluator.evaluate, FunctionDefinitionNode),
         #Evaluator.forNodes(ExtendEvaluator.evaluate, ExtendNode),

smnp/runtime/evaluators/throw.py

@@ -0,0 +1,17 @@
+from smnp.error.custom import CustomException
+from smnp.error.runtime import RuntimeException
+from smnp.runtime.evaluator import Evaluator
+from smnp.runtime.evaluators.expression import expressionEvaluator
+from smnp.type.model import Type
+
+
+class ThrowEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        string = expressionEvaluator(doAssert=True)(node.value, environment).value
+
+        if string.type != Type.STRING:
+            raise RuntimeException(f"Only {Type.STRING.name.lower()} types can be thrown", node.value.pos)
+
+        raise CustomException(string.value, node.pos)

smnp/token/tokenizer.py

@@ -50,6 +50,7 @@ tokenizers = (
     separated(defaultTokenizer(TokenType.RETURN)),
     separated(defaultTokenizer(TokenType.EXTEND)),
     separated(defaultTokenizer(TokenType.IMPORT)),
+    separated(defaultTokenizer(TokenType.THROW)),
     separated(defaultTokenizer(TokenType.FROM)),
     separated(defaultTokenizer(TokenType.WITH)),
     separated(defaultTokenizer(TokenType.ELSE)),

smnp/token/type.py

@@ -35,6 +35,7 @@ class TokenType(Enum):
     RETURN = 'return'
     EXTEND = 'extend'
     IMPORT = 'import'
+    THROW = 'throw'
     FROM = 'from'
     WITH = 'with'
     ELSE = 'else'