224 lines
8.5 KiB
C++
224 lines
8.5 KiB
C++
#include "typechecker.hpp"
|
|
#include "type.hpp"
|
|
#include <stdexcept>
|
|
#include <iostream>
|
|
|
|
namespace Solstice {
|
|
|
|
void TypeChecker::initOverloads() {
|
|
addOverloads = {
|
|
{{BaseType::Int, BaseType::Int}, BaseType::Int},
|
|
{{BaseType::Double, BaseType::Double}, BaseType::Double},
|
|
{{BaseType::Int, BaseType::Double}, BaseType::Double},
|
|
{{BaseType::Double, BaseType::Int}, BaseType::Double},
|
|
{{BaseType::String, BaseType::String}, BaseType::String},
|
|
{{BaseType::String, BaseType::Char}, BaseType::String},
|
|
{{BaseType::Char, BaseType::String}, BaseType::String},
|
|
{{BaseType::Char, BaseType::Char}, BaseType::Char}
|
|
};
|
|
subtractOverloads = {
|
|
{{BaseType::Int, BaseType::Int}, BaseType::Int},
|
|
{{BaseType::Double, BaseType::Double}, BaseType::Double},
|
|
{{BaseType::Int, BaseType::Double}, BaseType::Double},
|
|
{{BaseType::Double, BaseType::Int}, BaseType::Double},
|
|
{{BaseType::Char, BaseType::Char}, BaseType::Char}
|
|
};
|
|
multiplyOverloads = {
|
|
{{BaseType::Int, BaseType::Int}, BaseType::Int},
|
|
{{BaseType::Double, BaseType::Double}, BaseType::Double},
|
|
{{BaseType::Int, BaseType::Double}, BaseType::Double},
|
|
{{BaseType::Double, BaseType::Int}, BaseType::Double},
|
|
{{BaseType::Char, BaseType::Char}, BaseType::Char}
|
|
};
|
|
divideOverloads = {
|
|
{{BaseType::Int, BaseType::Int}, BaseType::Double},
|
|
{{BaseType::Double, BaseType::Double}, BaseType::Double},
|
|
{{BaseType::Int, BaseType::Double}, BaseType::Double},
|
|
{{BaseType::Double, BaseType::Int}, BaseType::Double},
|
|
{{BaseType::Char, BaseType::Char}, BaseType::Char}
|
|
};
|
|
equalOverloads = {
|
|
{{BaseType::Int, BaseType::Int}, BaseType::Bool},
|
|
{{BaseType::Double, BaseType::Double}, BaseType::Bool},
|
|
{{BaseType::Int, BaseType::Double}, BaseType::Bool},
|
|
{{BaseType::Double, BaseType::Int}, BaseType::Bool},
|
|
{{BaseType::String, BaseType::String}, BaseType::Bool},
|
|
{{BaseType::Char, BaseType::Char}, BaseType::Bool},
|
|
{{BaseType::Bool, BaseType::Bool}, BaseType::Bool},
|
|
};
|
|
notEqualOverloads = {
|
|
{{BaseType::Int, BaseType::Int}, BaseType::Bool},
|
|
{{BaseType::Double, BaseType::Double}, BaseType::Bool},
|
|
{{BaseType::Int, BaseType::Double}, BaseType::Bool},
|
|
{{BaseType::Double, BaseType::Int}, BaseType::Bool},
|
|
{{BaseType::String, BaseType::String}, BaseType::Bool},
|
|
{{BaseType::Char, BaseType::Char}, BaseType::Bool},
|
|
{{BaseType::Bool, BaseType::Bool}, BaseType::Bool},
|
|
};
|
|
greaterThanOverloads = {
|
|
{{BaseType::Int, BaseType::Int}, BaseType::Bool},
|
|
{{BaseType::Double, BaseType::Double}, BaseType::Bool},
|
|
{{BaseType::Int, BaseType::Double}, BaseType::Bool},
|
|
{{BaseType::Double, BaseType::Int}, BaseType::Bool},
|
|
{{BaseType::Char, BaseType::Char}, BaseType::Bool},
|
|
};
|
|
lesserThanOverloads = {
|
|
{{BaseType::Int, BaseType::Int}, BaseType::Bool},
|
|
{{BaseType::Double, BaseType::Double}, BaseType::Bool},
|
|
{{BaseType::Int, BaseType::Double}, BaseType::Bool},
|
|
{{BaseType::Double, BaseType::Int}, BaseType::Bool},
|
|
{{BaseType::Char, BaseType::Char}, BaseType::Bool},
|
|
};
|
|
}
|
|
|
|
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) {
|
|
for (auto& child : node.children) {
|
|
checkNodeType(child);
|
|
}
|
|
// TODO implemnt tuple type checking
|
|
}
|
|
|
|
void TypeChecker::checkBindNodeType(Node& node) {
|
|
auto id = node.children[0].getIdentifier();
|
|
if (!id.has_value()) {
|
|
throw std::runtime_error("FIXME identifier node does not contain identifier");
|
|
}
|
|
if (variables.find(*id) != variables.end()) {
|
|
throw std::runtime_error("Cannot overwrite existing bind/variable/function with new bind");
|
|
}
|
|
|
|
checkNodeType(node.children[1]);
|
|
auto nodeType = node.children[1].ptype.getOnlyType();
|
|
if (!nodeType.has_value()) {
|
|
throw std::runtime_error("cannot assign ambiguous type to name");
|
|
}
|
|
variables[*id] = *nodeType;
|
|
variables[*id].isConstant = true;
|
|
}
|
|
|
|
void TypeChecker::checkFunctionBindNodeType(Node& node) {
|
|
auto id = node.children[0].getIdentifier();
|
|
if (!id.has_value()) {
|
|
throw std::runtime_error("FIXME identifier node does not contain identifier");
|
|
}
|
|
if (variables.find(*id) != variables.end()) {
|
|
throw std::runtime_error("Cannot overwrite existing bind/variable/function with new function");
|
|
}
|
|
|
|
checkNodeType(node.children[1]);
|
|
auto nodeType = node.children[1].ptype.getOnlyType();
|
|
if (!nodeType.has_value()) {
|
|
throw std::runtime_error("cannot assign ambiguous type to name");
|
|
}
|
|
variables[*id] = *nodeType;
|
|
variables[*id].isConstant = true;
|
|
}
|
|
|
|
void TypeChecker::checkSetNodeType(Node& node) {
|
|
auto id = node.children[0].getIdentifier();
|
|
if (!id.has_value()) {
|
|
throw std::runtime_error("FIXME identifier node does not contain identifier");
|
|
}
|
|
if (variables.find(*id) != variables.end()) {
|
|
if (variables[*id].isConstant) {
|
|
throw std::runtime_error("cannot reassign existing bind");
|
|
}
|
|
}
|
|
if (!inFunction) {
|
|
throw std::runtime_error("mutable variables may only be used in functions");
|
|
}
|
|
|
|
checkNodeType(node.children[1]);
|
|
auto nodeType = node.children[1].ptype.getOnlyType();
|
|
if (!nodeType.has_value()) {
|
|
throw std::runtime_error("cannot assign ambiguous type to name");
|
|
}
|
|
variables[*id] = *nodeType;
|
|
}
|
|
|
|
void TypeChecker::checkCodeBlockType(Node& node) {}
|
|
|
|
|
|
void TypeChecker::checkNodeType(Node& node) {
|
|
switch (node.type) {
|
|
case NodeType::Root:
|
|
node.ptype = {{}}; // no possible types for root node
|
|
for (auto& child : node.children) {
|
|
checkNodeType(child);
|
|
}
|
|
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;
|
|
case NodeType::Bind:
|
|
checkBindNodeType(node);
|
|
break;
|
|
case NodeType::FunctionBind:
|
|
checkFunctionBindNodeType(node);
|
|
break;
|
|
case NodeType::Set:
|
|
checkSetNodeType(node);
|
|
break;
|
|
case NodeType::CodeBlock:
|
|
checkCodeBlockType(node);
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
void TypeChecker::checkTypes() {
|
|
checkNodeType(input);
|
|
}
|
|
|
|
|
|
}
|