unbreak tests with typechecker enabled

Author: o-

compiler.cpp

@@ -236,7 +236,7 @@ class Compiler : public Visitor {
     void optimizeModule(ExecutionEngine * ee) {
         auto *pm = new legacy::FunctionPassManager(m);
         m->setDataLayout(*ee->getDataLayout());
-        //pm->add(new TypeChecker());
+        pm->add(new TypeChecker());
         pm->add(new TypeAnalysis());
         pm->add(new Unboxing());
         pm->add(new BoxingRemoval());

type_checker.cpp

@@ -16,13 +16,13 @@ bool TypeChecker::runOnFunction(llvm::Function & f) {
                 if (CallInst * ci = dyn_cast<CallInst>(&i)) {
                     StringRef s = ci->getCalledFunction()->getName();
                     if (s == "doubleVectorLiteral") {
-                        state.upddate(ci, Type::D);
+                        state.update(ci, Type::D);
                     } else if (s == "fromDoubleVector") {
-                        state.upddate(ci, Type::D);
+                        state.update(ci, Type::D);
                     } else if (s == "characterVectorLiteral") {
-                        state.upddate(ci, Type::C);
+                        state.update(ci, Type::C);
                     } else if (s == "fromCharacterVector") {
-                        state.upddate(ci, Type::C);
+                        state.update(ci, Type::C);
                     } else if (s == "genericSub") {
                         Type t1 = state.get(ci->getOperand(0));
                         Type t2 = state.get(ci->getOperand(1));
@@ -32,14 +32,45 @@ bool TypeChecker::runOnFunction(llvm::Function & f) {
                                 switch (t2) {
                                     case Type::D:
                                     case Type::T:
-                                        state.upddate(ci, Type::D);
+                                        state.update(ci, Type::D);
                                         break;
                                     default:
-                                        throw "Invalid types for binary subtraction";
+                                        throw "TypeErr: Invalid types for binary subtraction";
                                 }
                                 break;
                             default:
-                                throw "Invalid types for binary subtraction";
+                                throw "TypeErr: Invalid types for binary subtraction";
+                        }
+                    } else if (s == "fromFunction") {
+                        state.update(ci, Type::F);
+                    } else if (s == "genericGetElement") {
+                        Type vector_t = state.get(ci->getOperand(0));
+                        Type index_t  = state.get(ci->getOperand(1));
+                        if (vector_t == Type::F) {
+                            throw "TypeErr: Cannot index functions";
+                        }
+                        switch (index_t) {
+                            case Type::C:
+                                throw "TypeErr: character is not a valid index";
+                            case Type::F:
+                                throw "TypeErr: A function is not a valid index";
+                            case Type::T:
+                            case Type::D:
+                                state.update(ci, vector_t);
+                                break;
+                            default:
+                                assert(false);
+                        }
+
+                    //Complete me
+
+                    } else {
+                        // If we still don't know nothing about the instruction
+                        // set it to T, since it could be anything. If we handle
+                        // all cases above this case should not be reached
+                        // anymore.
+                        if (state.get(ci) == Type::B) {
+                            state.update(ci, Type::T);
                         }
                     }
                 }

type_checker.h

@@ -39,7 +39,7 @@ class TypeChecker : public llvm::FunctionPass {
                 return Type::B;
         }
 
-        void upddate(llvm::Value * v, Type t) {
+        void update(llvm::Value * v, Type t) {
             Type prev = get(v);
             if (prev < t) {
                 type[v] = t;