From 43061717157f80b733d1c6cebe36953385f41dbe Mon Sep 17 00:00:00 2001
From: Alex <dovzhanyn.alex@gmail.com>
Date: Mon, 2 Sep 2024 22:52:18 -0400
Subject: [PATCH] fix: fix typechecking for variadics vs function defs. also
 fixes all tests

---
 src/compiler/TypeChecker.cpp | 30 ++++++++++++++++++++++--------
 test/TypeCheckerTest.cpp     | 28 ++++++++++++++++------------
 2 files changed, 38 insertions(+), 20 deletions(-)

diff --git a/src/compiler/TypeChecker.cpp b/src/compiler/TypeChecker.cpp
index d0e86da..9961162 100644
--- a/src/compiler/TypeChecker.cpp
+++ b/src/compiler/TypeChecker.cpp
@@ -137,7 +137,7 @@ namespace Theta {
 
     bool TypeChecker::checkAssignmentNode(shared_ptr<AssignmentNode> node) {
         bool typesMatch = isSameType(node->getLeft()->getValue(), node->getRight()->getResolvedType());
-        
+
         shared_ptr<IdentifierNode> ident = dynamic_pointer_cast<IdentifierNode>(node->getLeft());
 
         if (!typesMatch) {
@@ -485,8 +485,10 @@ namespace Theta {
         
         shared_ptr<TypeDeclarationNode> type = make_shared<TypeDeclarationNode>(DataTypes::TUPLE, node);
 
-        type->setLeft(node->getLeft()->getResolvedType());
-        type->setRight(node->getRight()->getResolvedType());
+        type->setElements({
+            node->getLeft()->getResolvedType(),
+            node->getRight()->getResolvedType()
+        });
 
         node->setResolvedType(type);
 
@@ -769,15 +771,27 @@ namespace Theta {
                 if (!containsType) return false;
             }
         } else if (t1->hasMany() && t2->hasMany()) {
-            for (int i = 0; i < t2->getElements().size(); i++) {
-                bool containsType = false;
+            if (t1->getType() == DataTypes::VARIADIC) {
+                // In Variadic types, it makes sense that the types on the right can be any of the values defined
+                // on the left, in any order 
+                for (int i = 0; i < t2->getElements().size(); i++) {
+                    bool containsType = false;
+
+                    for (int j = 0; j < t1->getElements().size(); j++) {
+                        if (isSameType(t2->getElements().at(i), t1->getElements().at(j))) containsType = true;
+                    }
 
-                for (int j = 0; j < t1->getElements().size(); j++) {
-                    if (isSameType(t2->getElements().at(i), t1->getElements().at(j))) containsType = true;
+                    if (!containsType) return false;
                 }
+            } else {
+                // In every other case, though, order matters. The left and right types must be exactly the same
+                if (t1->getElements().size() != t2->getElements().size()) return false;
 
-                if (!containsType) return false;
+                for (int i = 0; i < t1->getElements().size(); i++) {
+                    if (!isSameType(t1->getElements().at(i), t2->getElements().at(i))) return false;
+                }
             }
+
         }
 
         return t1->getType() == t2->getType();
diff --git a/test/TypeCheckerTest.cpp b/test/TypeCheckerTest.cpp
index 571c0b3..7d289cb 100644
--- a/test/TypeCheckerTest.cpp
+++ b/test/TypeCheckerTest.cpp
@@ -223,7 +223,7 @@ TEST_CASE_METHOD(TypeCheckerTest, "TypeChecker") {
     SECTION("Can typecheck function assignents with parameters correctly") {
         shared_ptr<ASTNode> ast = setup(R"(
             capsule Test {
-                x<Function<String>> = (a<String>) -> a
+                x<Function<String, String>> = (a<String>) -> a
             }
         )");
 
@@ -246,6 +246,10 @@ TEST_CASE_METHOD(TypeCheckerTest, "TypeChecker") {
 
         bool isValid = typeChecker.checkAST(ast);
         
+        for (auto ex : Compiler::getInstance().getEncounteredExceptions()) {
+            ex->display();
+        }
+
         REQUIRE(isValid);
         REQUIRE(Compiler::getInstance().getEncounteredExceptions().size() == 0);
     }
@@ -270,7 +274,7 @@ TEST_CASE_METHOD(TypeCheckerTest, "TypeChecker") {
     SECTION("Can typecheck curried functions correctly") {
         shared_ptr<ASTNode> ast = setup(R"(
             capsule Test {
-                x<Function<Function<Number>>> = (a<Number>) -> (b<Number>) -> a + b
+                x<Function<Number, Function<Number, Number>>> = (a<Number>) -> (b<Number>) -> a + b
             }
         )");
 
@@ -289,7 +293,7 @@ TEST_CASE_METHOD(TypeCheckerTest, "TypeChecker") {
                     :HIGH
                 }
 
-                severityIdent<Function<Severity>> = (sev<Severity>) -> {
+                severityIdent<Function<Severity, Severity>> = (sev<Severity>) -> {
                     sev
                 }
             }
@@ -304,7 +308,7 @@ TEST_CASE_METHOD(TypeCheckerTest, "TypeChecker") {
     SECTION("Can typecheck control flow correctly") {
         shared_ptr<ASTNode> ast = setup(R"(
             capsule Test {
-                isEven<Function<Boolean>> = (num<Number>) -> {
+                isEven<Function<Number, Boolean>> = (num<Number>) -> {
                     if (num % 2 == 0) {
                         return true
                     } else if (num % 3 == 0) {
@@ -325,7 +329,7 @@ TEST_CASE_METHOD(TypeCheckerTest, "TypeChecker") {
     SECTION("Throws if control flow condition is not a boolean") {
         shared_ptr<ASTNode> ast = setup(R"(
             capsule Test {
-                isLongString<Function<Boolean>> = (str<String>) -> {
+                isLongString<Function<String, Boolean>> = (str<String>) -> {
                     if (str) {
                         return true
                     }
@@ -342,7 +346,7 @@ TEST_CASE_METHOD(TypeCheckerTest, "TypeChecker") {
     SECTION("Can typecheck recursive functions correctly") {
         shared_ptr<ASTNode> ast = setup(R"(
             capsule Test {
-                addUntilTen<Function<Number>> = (sum<Number>) -> {
+                addUntilTen<Function<Number, Number>> = (sum<Number>) -> {
                     if (sum == 10) {
                         return sum
                     }
@@ -406,9 +410,9 @@ TEST_CASE_METHOD(TypeCheckerTest, "TypeChecker") {
     SECTION("Can typecheck function overloads correctly") {
         shared_ptr<ASTNode> ast = setup(R"(
             capsule Test {
-                add<Function<Number>> = (x<Number>) -> x
-                add<Function<Number>> = (x<Number>, y<Number>) -> x + y
-                add<Function<Number>> = (x<Number>, y<String>) -> x
+                add<Function<Number, Number>> = (x<Number>) -> x
+                add<Function<Number, Number, Number>> = (x<Number>, y<Number>) -> x + y
+                add<Function<Number, String, Number>> = (x<Number>, y<String>) -> x
 
                 doTheThing<Function<Number>> = () -> {
                     add(1)
@@ -501,7 +505,7 @@ TEST_CASE_METHOD(TypeCheckerTest, "TypeChecker") {
                     y<Number>
                 }
 
-                addPoints<Function<Point>> = (p1<Point>, p2<Point>) -> {
+                addPoints<Function<Point, Point, Point>> = (p1<Point>, p2<Point>) -> {
                     @Point {
                         x: 4,
                         y: 2
@@ -524,7 +528,7 @@ TEST_CASE_METHOD(TypeCheckerTest, "TypeChecker") {
                     y<Number>
                 }
 
-                addPoints<Function<Point>> = (p1<Point>, p2<Point>) -> {
+                addPoints<Function<Point, Point, Point>> = (p1<Point>, p2<Point>) -> {
                     @Point {
                         x: 4
                     }
@@ -608,7 +612,7 @@ TEST_CASE_METHOD(TypeCheckerTest, "TypeChecker") {
             capsule Test {
                 z<Number> = 5
 
-                add<Function<Function<Number>>> = (x<Number>) -> (y<Number>) -> x + y + z
+                add<Function<Number, Function<Number, Number>>> = (x<Number>) -> (y<Number>) -> x + y + z
             }
         )");