Keep working on type checker

src/typechecker/typechecker.cpp

@@ -1,4 +1,6 @@
 #include "typechecker.hpp"
+#include "type.hpp"
+#include <stdexcept>
 
 namespace Solstice {
 
@@ -68,5 +70,71 @@ namespace Solstice {
         };
     }
 
+    void TypeChecker::checkLiteralNodeType(Node& node) {
+        auto literal = node.getLiteral();
+        if (!literal.has_value()) {
+            throw std::runtime_error("FIXME literal node does not contain literal");
+        }
+        switch (literal->type) {
+            case LiteralType::None:
+                node.ptype = {{BaseType::None}};
+                break;
+            case LiteralType::String:
+                node.ptype = {{BaseType::String}};
+                break;
+            case LiteralType::Int:
+                node.ptype = {{BaseType::Int}};
+                break;
+            case LiteralType::Double:
+                node.ptype = {{BaseType::Double}};
+                break;
+            case LiteralType::Bool:
+                node.ptype = {{BaseType::Bool}};
+                break;
+            case LiteralType::Char:
+                node.ptype = {{BaseType::Char}};
+                break;
+        }
+    }
+
+    void TypeChecker::checkIdentifierNodeType(Node& node) {
+        auto identifier = node.getIdentifier();
+        if (!identifier.has_value()) {
+            throw std::runtime_error("FIXME identifier node does not contain identifier");
+        }
+
+        if (variables.find(*identifier) == variables.end()) {
+            throw std::runtime_error("unknown variable " + *identifier);
+        }
+
+        node.ptype = variables[*identifier];        
+    }
+
+    void TypeChecker::checkTupleNodeType(Node& node) {}
+
+    void TypeChecker::checkNodeType(Node& node) {
+        switch (node.type) {
+            case NodeType::Root:
+                node.ptype = {{}}; // no possible types for root node
+                break;
+            case NodeType::Literal:
+                checkLiteralNodeType(node);
+                break;
+            case NodeType::Expression:
+                checkNodeType(node.children[0]);
+                break;
+            case NodeType::Identifier:
+                checkIdentifierNodeType(node);
+                break;
+            case NodeType::Tuple:
+                checkTupleNodeType(node);
+                break;
+        }
+    }
+
+    void TypeChecker::checkTypes() {
+        checkNodeType(input);
+    }
+
 
 }