Unary Operators

.env

@@ -0,0 +1 @@
+PYTHONPATH=bagel

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/**
+*.pyc
+.pytest_cache/**

.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: Module",
+            "type": "python",
+            "request": "launch",
+            "module": "bagel",
+            "justMyCode": true
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.linting.enabled": false
+}

.vscode/tasks.json

@@ -0,0 +1,15 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "bagel: REPL",
+            "type": "shell",
+            "command": "python -m bagel",
+            "problemMatcher": [],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        }
+    ]
+}

bagel/__init__.py

@@ -1 +1 @@
-__version__ = '0.1.0'
+__version__ = '0.1.5'

bagel/__main__.py

@@ -3,13 +3,14 @@
 import colorama
 from colorama import Fore
 
+from .codeanalysis.binding.binder import Binder
 from .codeanalysis.evaluator import Evaluator
-from .codeanalysis.syntaxnode import SyntaxNode
-from .codeanalysis.syntaxtoken import SyntaxToken
-from .codeanalysis.syntaxtree import SyntaxTree
+from .codeanalysis.syntax.syntaxnode import SyntaxNode
+from .codeanalysis.syntax.syntaxtoken import SyntaxToken
+from .codeanalysis.syntax.syntaxtree import SyntaxTree
 
 colorama.init(autoreset=True)
-show_tree = False
+SHOW_TREE = False
 
 
 def pretty_print(node: SyntaxNode, indent: str = "", is_last: bool = True):
@@ -40,49 +41,30 @@ def pretty_print(node: SyntaxNode, indent: str = "", is_last: bool = True):
 while True:
     line = input("» ")
 
-    # ideas
-    # a = input("» ")
-    # a = input("› ")
-    # a = input("¶ ")
-    # a = input("~ ")
-    # a = input("⇝ ")
-    # a = input("⇢ ")
-    # a = input("⇻ ")
-    # a = input("⇾ ")
-    # a = input("∢ ")
-    # a = input("∝ ")
-    # a = input("⊱ ")
-
-    # a = input("⊶ ")
-    # a = input("⊷ ")
-    # a = input("⊸ ")
-
-    # a = input("⋉ ")
-    # a = input("⋯ ")
-    # a = input("⨊ ")
-    # a = input("⨭ ")
-    # a = input("⫻ ")
-
     if line is None or line == "":
         break
 
     if line == "#showtree":
-        show_tree = not show_tree
-        print("Showing parser trees" if show_tree else "Not showing parser trees")
+        SHOW_TREE = not SHOW_TREE
+        print("Showing parser trees" if SHOW_TREE else "Not showing parser trees")
         continue
     elif line == "#cls":
         os.system('cls')
         continue
 
     syntax_tree = SyntaxTree.parse(line)
+    binder = Binder()
+    bound_expression = binder.bind_expression(syntax_tree.root)
+
+    diagnostics = syntax_tree.diagnostics + binder.diagnostics
 
-    if show_tree:
+    if SHOW_TREE:
         pretty_print(syntax_tree.root)
 
-    if not len(syntax_tree.diagnostics) > 0:
-        evaluator = Evaluator(syntax_tree.root)
+    if not any(syntax_tree.diagnostics):
+        evaluator = Evaluator(bound_expression)
         result = evaluator.evaluate()
-        print(str(result))
+        print(result)
     else:
         for _diagnostic in syntax_tree.diagnostics:
             print(Fore.RED + _diagnostic)

bagel/codeanalysis/binding/__init__.py

@@ -0,0 +1,9 @@
+from .boundnode import BoundNode
+from .boundnodekind import BoundNodeKind
+from .boundexpression import BoundExpression
+from .boundliteralexpression import BoundLiteralExpression
+from .boundunaryoperatorkind import BoundUnaryOperatorKind
+from .boundunaryexpression import BoundUnaryExpression
+from .boundbinaryoperatorkind import BoundBinaryOperatorKind
+from .boundbinaryexpression import BoundBinaryExpression
+from .binder import Binder

bagel/codeanalysis/binding/binder.py

@@ -0,0 +1,88 @@
+from typing import List
+
+from ..syntax.binary_expression_syntax import BinaryExpressionSyntax
+from ..syntax.expression_syntax import ExpressionSyntax
+from ..syntax.literal_expression_syntax import LiteralExpressionSyntax
+from ..syntax.syntaxkind import SyntaxKind
+from ..syntax.unary_expression_syntax import UnaryExpressionSyntax
+
+from .boundexpression import BoundExpression
+from .boundbinaryexpression import BoundBinaryExpression
+from .boundunaryexpression import BoundUnaryExpression
+from .boundliteralexpression import BoundLiteralExpression
+from .boundunaryoperatorkind import BoundUnaryOperatorKind
+from .boundbinaryoperatorkind import BoundBinaryOperatorKind
+
+
+class Binder:
+    _diagnostics: List[str]
+
+    def __init__(self):
+        self._diagnostics = []
+
+    @property
+    def diagnostics(self) -> List[str]:
+        return self._diagnostics
+
+    def bind_expression(self, syntax: ExpressionSyntax) -> BoundExpression:
+        match syntax.kind:
+            case SyntaxKind.LITERALEXPRESSION:
+                return self.bind_literal_expression(syntax)
+            case SyntaxKind.UNARYEXPRESSION:
+                return self.bind_unary_expression(syntax)
+            case SyntaxKind.BINARYEXPRESSION:
+                return self.bind_binary_expression(syntax)
+            case _:
+                raise Exception(f"Unexpected syntax {syntax.kind}")
+
+    def bind_literal_expression(self, syntax: LiteralExpressionSyntax) -> BoundLiteralExpression:
+        value = syntax.value if syntax.value != None else 0
+        return BoundLiteralExpression(value)
+
+    def bind_unary_expression(self, syntax: UnaryExpressionSyntax) -> BoundUnaryExpression:
+        bound_operand = self.bind_expression(syntax.operand)
+        bound_operator_kind = self.bind_unary_operator_kind(syntax.operator_token.kind, bound_operand.type)
+
+        if bound_operator_kind is None:
+            self._diagnostics.append(f"Unary operator {syntax.operator_token.text} is not defined for type {bound_operand.type}.")
+            return bound_operand
+
+        return BoundUnaryExpression(bound_operator_kind, bound_operand)
+
+    def bind_binary_expression(self, syntax: BinaryExpressionSyntax) -> BoundBinaryExpression:
+        bound_left = self.bind_expression(syntax.left)
+        bound_right = self.bind_expression(syntax.right)
+        bound_operator_kind = self.bind_binary_operator_kind(syntax.operator_token.kind, bound_left.type, bound_right.type)
+        if bound_operator_kind is None:
+            self._diagnostics.append(f"Binary operator {syntax.operator_token.text} is not defined for types {bound_left.type} and {bound_right.type}.")
+            return bound_left
+
+        return BoundBinaryExpression(bound_left, bound_operator_kind, bound_right)
+
+    def bind_unary_operator_kind(self, kind: SyntaxKind, operand_type: int) -> BoundUnaryOperatorKind | None:
+        if operand_type != int:
+            return
+
+        match kind:
+            case SyntaxKind.PLUSTOKEN:
+                return BoundUnaryOperatorKind.IDENTITY
+            case SyntaxKind.MINUSTOKEN:
+                return BoundUnaryOperatorKind.NEGATION
+            case _:
+                raise Exception(f"Unexpected unary operator kind {kind}")
+
+    def bind_binary_operator_kind(self, kind: SyntaxKind, left_type: int, right_type: int) -> BoundBinaryOperatorKind | None:
+        if left_type != int or right_type != int:
+            return
+
+        match kind:
+            case SyntaxKind.PLUSTOKEN:
+                return BoundBinaryOperatorKind.ADDITION
+            case SyntaxKind.MINUSTOKEN:
+                return BoundBinaryOperatorKind.SUBTRACTION
+            case SyntaxKind.STARTOKEN:
+                return BoundBinaryOperatorKind.MULTIPLICATION
+            case SyntaxKind.SLASHTOKEN:
+                return BoundBinaryOperatorKind.DIVISION
+            case _:
+                raise Exception(f"Unexpected binary operator kind {kind}")

bagel/codeanalysis/binding/boundbinaryexpression.py

@@ -0,0 +1,34 @@
+from .boundexpression import BoundExpression
+from .boundnodekind import BoundNodeKind
+from .boundunaryoperatorkind import BoundUnaryOperatorKind
+from .boundbinaryoperatorkind import BoundBinaryOperatorKind
+
+class BoundBinaryExpression(BoundExpression):
+    _left: BoundExpression
+    _operator_kind: BoundUnaryOperatorKind
+    _right: BoundExpression
+
+    def __init__(self, left: BoundExpression, operator_kind: BoundBinaryOperatorKind, right: BoundExpression):
+        self._left = left
+        self._operator_kind = operator_kind
+        self._right = right
+
+    @property
+    def kind(self) -> BoundNodeKind:
+        return BoundNodeKind.BINARYEXPRESSION
+
+    @property
+    def type(self):
+        return self._left.type
+
+    @property
+    def left(self) -> BoundExpression:
+        return self._left
+
+    @property
+    def operator_kind(self) -> BoundUnaryOperatorKind:
+        return self._operator_kind
+
+    @property
+    def right(self) -> BoundExpression:
+        return self._right

bagel/codeanalysis/binding/boundbinaryoperatorkind.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class BoundBinaryOperatorKind(Enum):
+    ADDITION = 0
+    SUBTRACTION = 1
+    MULTIPLICATION = 2
+    DIVISION = 3

bagel/codeanalysis/binding/boundexpression.py

@@ -0,0 +1,9 @@
+from .boundnode import BoundNode
+
+
+class BoundExpression(BoundNode):
+    _type: object
+
+    @property
+    def type(self):
+        return self._type

bagel/codeanalysis/binding/boundliteralexpression.py

@@ -0,0 +1,21 @@
+from .boundexpression import BoundExpression
+from .boundnodekind import BoundNodeKind
+
+
+class BoundLiteralExpression(BoundExpression):
+    _value: object
+
+    def __init__(self, value: object):
+        self._value = value
+
+    @property
+    def kind(self) -> BoundNodeKind:
+        return BoundNodeKind.LITERALEXPRESSION
+
+    @property
+    def type(self):
+        return type(self._value)
+
+    @property
+    def value(self):
+        return self._value

bagel/codeanalysis/binding/boundnode.py

@@ -0,0 +1,9 @@
+from .boundnodekind import BoundNodeKind
+
+
+class BoundNode:
+    _kind: BoundNodeKind
+
+    @property
+    def kind(self) -> BoundNodeKind:
+        return self._kind

bagel/codeanalysis/binding/boundnodekind.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class BoundNodeKind(Enum):
+    LITERALEXPRESSION = 0
+    UNARYEXPRESSION = 1
+    BINARYEXPRESSION = 2

bagel/codeanalysis/binding/boundunaryexpression.py

@@ -0,0 +1,27 @@
+from .boundnodekind import BoundNodeKind
+from .boundunaryoperatorkind import BoundUnaryOperatorKind
+from .boundexpression import BoundExpression
+
+class BoundUnaryExpression(BoundExpression):
+    _operator_kind: BoundUnaryOperatorKind
+    _operand: BoundExpression
+
+    def __init__(self, operator_kind: BoundUnaryOperatorKind, operand: BoundExpression):
+        self._operator_kind = operator_kind
+        self._operand = operand
+
+    @property
+    def kind(self) -> BoundNodeKind:
+        return BoundNodeKind.UNARYEXPRESSION
+
+    @property
+    def type(self):
+        return self._operand.type
+
+    @property
+    def operator_kind(self) -> BoundUnaryOperatorKind:
+        return self._operator_kind
+
+    @property
+    def operand(self) -> BoundExpression:
+        return self._operand

bagel/codeanalysis/binding/boundunaryoperatorkind.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class BoundUnaryOperatorKind(Enum):
+    IDENTITY = 0
+    NEGATION = 1