Add more tests for operator overloading and compound operators (#370)

spicelang · Nov 12, 2023 · 1704dd9 · 1704dd9
1 parent 2a6e290
commit 1704dd9
Show file tree

Hide file tree

Showing 12 changed files with 411 additions and 41 deletions.
diff --git a/.github/workflows/ci-cpp.yml b/.github/workflows/ci-cpp.yml
@@ -121,11 +121,4 @@ jobs:
           user: ${{ secrets.FTP_USERNAME }}
           password: ${{ secrets.FTP_PASSWORD }}
           localDir: ./bin/coverage
-          remoteDir: chillibits.com/spice/coverage
-
-      - name: Upload coverage report - Codecov
-        working-directory: ./bin
-        run: |
-          curl -Os https://uploader.codecov.io/latest/linux/codecov
-          chmod +x codecov
-          ./codecov -t ${{ secrets.CODECOV_TOKEN }}
+          remoteDir: chillibits.com/spice/coverage
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
@@ -364,7 +364,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          hub release download "${GITHUB_REF#refs/tags/}" -i '*windows_${{ matrix.config.arch }}*.zip'
+          gh release download "${GITHUB_REF#refs/tags/}" -p *windows_${{ matrix.config.arch }}*.zip
           printf "::set-output name=zip::%s\n" *.zip
           unzip -o *.zip && rm -v *.zip
           dir

diff --git a/src/ast/ASTBuilder.cpp b/src/ast/ASTBuilder.cpp
@@ -474,7 +474,7 @@ std::any ASTBuilder::visitSpecifier(SpiceParser::SpecifierContext *ctx) {
     else if (symbolType == SpiceParser::COMPOSE)
       specifierNode->type = SpecifierNode::TY_COMPOSITION;
     else
-      assert(false && "Unknown specifier type");
+      assert(false && "Unknown specifier type"); // GCOV_EXCL_LINE
   }
 
   return concludeNode(ctx, specifierNode);
@@ -1237,7 +1237,7 @@ std::any ASTBuilder::visitOverloadableOp(SpiceParser::OverloadableOpContext *ctx
     fctNameNode->overloadedOperator = FctNameNode::OP_MINUS_MINUS;
     fctNameNode->name = OP_FCT_POSTFIX_MINUS_MINUS;
   } else {
-    assert(false);
+    assert(false && "Unsupported overloadable operator"); // GCOV_EXCL_LINE
   }
   fctNameNode->fqName = fctNameNode->name;
   fctNameNode->nameFragments.push_back(fctNameNode->name);

diff --git a/test/test-files/irgenerator/operators/success-operator-overloading-binary/cout.out b/test/test-files/irgenerator/operators/success-operator-overloading-binary/cout.out
@@ -1,3 +1,12 @@
 Counter1 value: 2
 Counter2 value: 3
 Counter3 value: 5
+Counter4 value: 2
+Counter5 value: 6
+Counter6 value: 2
+Counter7 value: 16
+Counter8 value: 2
+Counter8 value: 5
+Counter8 value: 2
+Counter8 value: 6
+Counter8 value: 2
diff --git a/test/test-files/irgenerator/operators/success-operator-overloading-binary/ir-code.ll b/test/test-files/irgenerator/operators/success-operator-overloading-binary/ir-code.ll
@@ -8,6 +8,15 @@ target triple = "x86_64-w64-windows-gnu"
 @printf.str.0 = private unnamed_addr constant [20 x i8] c"Counter1 value: %d\0A\00", align 1
 @printf.str.1 = private unnamed_addr constant [20 x i8] c"Counter2 value: %d\0A\00", align 1
 @printf.str.2 = private unnamed_addr constant [20 x i8] c"Counter3 value: %d\0A\00", align 1
+@printf.str.3 = private unnamed_addr constant [20 x i8] c"Counter4 value: %d\0A\00", align 1
+@printf.str.4 = private unnamed_addr constant [20 x i8] c"Counter5 value: %d\0A\00", align 1
+@printf.str.5 = private unnamed_addr constant [20 x i8] c"Counter6 value: %d\0A\00", align 1
+@printf.str.6 = private unnamed_addr constant [20 x i8] c"Counter7 value: %d\0A\00", align 1
+@printf.str.7 = private unnamed_addr constant [20 x i8] c"Counter8 value: %d\0A\00", align 1
+@printf.str.8 = private unnamed_addr constant [20 x i8] c"Counter8 value: %d\0A\00", align 1
+@printf.str.9 = private unnamed_addr constant [20 x i8] c"Counter8 value: %d\0A\00", align 1
+@printf.str.10 = private unnamed_addr constant [20 x i8] c"Counter8 value: %d\0A\00", align 1
+@printf.str.11 = private unnamed_addr constant [20 x i8] c"Counter8 value: %d\0A\00", align 1
 
 define private void @_ZN7Counter4ctorEl(ptr noundef nonnull align 8 dereferenceable(8) %0, i64 %1) {
   %this = alloca ptr, align 8
@@ -51,12 +60,162 @@ define private %struct.Counter @_Z7op.plus7Counter7Counter(%struct.Counter %0, %
   ret %struct.Counter %7
 }
 
+define private %struct.Counter @_Z8op.minus7Counter7Counter(%struct.Counter %0, %struct.Counter %1) {
+  %result = alloca %struct.Counter, align 8
+  %c1 = alloca %struct.Counter, align 8
+  %c2 = alloca %struct.Counter, align 8
+  %3 = alloca %struct.Counter, align 8
+  store %struct.Counter %0, ptr %c1, align 8
+  store %struct.Counter %1, ptr %c2, align 8
+  %value_addr = getelementptr inbounds %struct.Counter, ptr %c1, i32 0, i32 0
+  %value_addr1 = getelementptr inbounds %struct.Counter, ptr %c2, i32 0, i32 0
+  %4 = load i64, ptr %value_addr1, align 8
+  %5 = load i64, ptr %value_addr, align 8
+  %6 = sub i64 %5, %4
+  call void @_ZN7Counter4ctorEl(ptr noundef nonnull align 8 dereferenceable(8) %3, i64 %6)
+  %7 = load %struct.Counter, ptr %3, align 8
+  ret %struct.Counter %7
+}
+
+define private %struct.Counter @_Z6op.mul7Counter7Counter(%struct.Counter %0, %struct.Counter %1) {
+  %result = alloca %struct.Counter, align 8
+  %c1 = alloca %struct.Counter, align 8
+  %c2 = alloca %struct.Counter, align 8
+  %3 = alloca %struct.Counter, align 8
+  store %struct.Counter %0, ptr %c1, align 8
+  store %struct.Counter %1, ptr %c2, align 8
+  %value_addr = getelementptr inbounds %struct.Counter, ptr %c1, i32 0, i32 0
+  %value_addr1 = getelementptr inbounds %struct.Counter, ptr %c2, i32 0, i32 0
+  %4 = load i64, ptr %value_addr1, align 8
+  %5 = load i64, ptr %value_addr, align 8
+  %6 = mul i64 %5, %4
+  call void @_ZN7Counter4ctorEl(ptr noundef nonnull align 8 dereferenceable(8) %3, i64 %6)
+  %7 = load %struct.Counter, ptr %3, align 8
+  ret %struct.Counter %7
+}
+
+define private %struct.Counter @_Z6op.div7Counter7Counter(%struct.Counter %0, %struct.Counter %1) {
+  %result = alloca %struct.Counter, align 8
+  %c1 = alloca %struct.Counter, align 8
+  %c2 = alloca %struct.Counter, align 8
+  %3 = alloca %struct.Counter, align 8
+  store %struct.Counter %0, ptr %c1, align 8
+  store %struct.Counter %1, ptr %c2, align 8
+  %value_addr = getelementptr inbounds %struct.Counter, ptr %c1, i32 0, i32 0
+  %value_addr1 = getelementptr inbounds %struct.Counter, ptr %c2, i32 0, i32 0
+  %4 = load i64, ptr %value_addr1, align 8
+  %5 = load i64, ptr %value_addr, align 8
+  %6 = sdiv i64 %5, %4
+  call void @_ZN7Counter4ctorEl(ptr noundef nonnull align 8 dereferenceable(8) %3, i64 %6)
+  %7 = load %struct.Counter, ptr %3, align 8
+  ret %struct.Counter %7
+}
+
+define private %struct.Counter @_Z6op.shl7Counter7Counter(%struct.Counter %0, %struct.Counter %1) {
+  %result = alloca %struct.Counter, align 8
+  %c1 = alloca %struct.Counter, align 8
+  %c2 = alloca %struct.Counter, align 8
+  %3 = alloca %struct.Counter, align 8
+  store %struct.Counter %0, ptr %c1, align 8
+  store %struct.Counter %1, ptr %c2, align 8
+  %value_addr = getelementptr inbounds %struct.Counter, ptr %c1, i32 0, i32 0
+  %value_addr1 = getelementptr inbounds %struct.Counter, ptr %c2, i32 0, i32 0
+  %4 = load i64, ptr %value_addr1, align 8
+  %5 = load i64, ptr %value_addr, align 8
+  %6 = shl i64 %5, %4
+  call void @_ZN7Counter4ctorEl(ptr noundef nonnull align 8 dereferenceable(8) %3, i64 %6)
+  %7 = load %struct.Counter, ptr %3, align 8
+  ret %struct.Counter %7
+}
+
+define private %struct.Counter @_Z6op.shr7Counter7Counter(%struct.Counter %0, %struct.Counter %1) {
+  %result = alloca %struct.Counter, align 8
+  %c1 = alloca %struct.Counter, align 8
+  %c2 = alloca %struct.Counter, align 8
+  %3 = alloca %struct.Counter, align 8
+  store %struct.Counter %0, ptr %c1, align 8
+  store %struct.Counter %1, ptr %c2, align 8
+  %value_addr = getelementptr inbounds %struct.Counter, ptr %c1, i32 0, i32 0
+  %value_addr1 = getelementptr inbounds %struct.Counter, ptr %c2, i32 0, i32 0
+  %4 = load i64, ptr %value_addr1, align 8
+  %5 = load i64, ptr %value_addr, align 8
+  %6 = lshr i64 %5, %4
+  call void @_ZN7Counter4ctorEl(ptr noundef nonnull align 8 dereferenceable(8) %3, i64 %6)
+  %7 = load %struct.Counter, ptr %3, align 8
+  ret %struct.Counter %7
+}
+
+define private void @_Z12op.plusequalR7Counter7Counter(ptr %0, %struct.Counter %1) {
+  %c1 = alloca ptr, align 8
+  %c2 = alloca %struct.Counter, align 8
+  store ptr %0, ptr %c1, align 8
+  store %struct.Counter %1, ptr %c2, align 8
+  %value_addr = getelementptr inbounds %struct.Counter, ptr %c2, i32 0, i32 0
+  %3 = load ptr, ptr %c1, align 8
+  %value_addr1 = getelementptr inbounds %struct.Counter, ptr %3, i32 0, i32 0
+  %4 = load i64, ptr %value_addr, align 8
+  %5 = load i64, ptr %value_addr1, align 8
+  %6 = add i64 %5, %4
+  store i64 %6, ptr %value_addr1, align 8
+  ret void
+}
+
+define private void @_Z13op.minusequalR7Counter7Counter(ptr %0, %struct.Counter %1) {
+  %c1 = alloca ptr, align 8
+  %c2 = alloca %struct.Counter, align 8
+  store ptr %0, ptr %c1, align 8
+  store %struct.Counter %1, ptr %c2, align 8
+  %value_addr = getelementptr inbounds %struct.Counter, ptr %c2, i32 0, i32 0
+  %3 = load ptr, ptr %c1, align 8
+  %value_addr1 = getelementptr inbounds %struct.Counter, ptr %3, i32 0, i32 0
+  %4 = load i64, ptr %value_addr, align 8
+  %5 = load i64, ptr %value_addr1, align 8
+  %6 = sub i64 %5, %4
+  store i64 %6, ptr %value_addr1, align 8
+  ret void
+}
+
+define private void @_Z11op.mulequalR7Counter7Counter(ptr %0, %struct.Counter %1) {
+  %c1 = alloca ptr, align 8
+  %c2 = alloca %struct.Counter, align 8
+  store ptr %0, ptr %c1, align 8
+  store %struct.Counter %1, ptr %c2, align 8
+  %value_addr = getelementptr inbounds %struct.Counter, ptr %c2, i32 0, i32 0
+  %3 = load ptr, ptr %c1, align 8
+  %value_addr1 = getelementptr inbounds %struct.Counter, ptr %3, i32 0, i32 0
+  %4 = load i64, ptr %value_addr, align 8
+  %5 = load i64, ptr %value_addr1, align 8
+  %6 = mul i64 %5, %4
+  store i64 %6, ptr %value_addr1, align 8
+  ret void
+}
+
+define private void @_Z11op.divequalR7Counter7Counter(ptr %0, %struct.Counter %1) {
+  %c1 = alloca ptr, align 8
+  %c2 = alloca %struct.Counter, align 8
+  store ptr %0, ptr %c1, align 8
+  store %struct.Counter %1, ptr %c2, align 8
+  %value_addr = getelementptr inbounds %struct.Counter, ptr %c2, i32 0, i32 0
+  %3 = load ptr, ptr %c1, align 8
+  %value_addr1 = getelementptr inbounds %struct.Counter, ptr %3, i32 0, i32 0
+  %4 = load i64, ptr %value_addr, align 8
+  %5 = load i64, ptr %value_addr1, align 8
+  %6 = sdiv i64 %5, %4
+  store i64 %6, ptr %value_addr1, align 8
+  ret void
+}
+
 ; Function Attrs: noinline nounwind optnone uwtable
 define dso_local i32 @main() #0 {
   %result = alloca i32, align 4
   %counter1 = alloca %struct.Counter, align 8
   %counter2 = alloca %struct.Counter, align 8
   %counter3 = alloca %struct.Counter, align 8
+  %counter4 = alloca %struct.Counter, align 8
+  %counter5 = alloca %struct.Counter, align 8
+  %counter6 = alloca %struct.Counter, align 8
+  %counter7 = alloca %struct.Counter, align 8
+  %counter8 = alloca %struct.Counter, align 8
   store i32 0, ptr %result, align 4
   call void @_ZN7Counter4ctorEl(ptr noundef nonnull align 8 dereferenceable(8) %counter1, i64 2)
   call void @_ZN7Counter4ctorEl(ptr noundef nonnull align 8 dereferenceable(8) %counter2, i64 3)
@@ -70,8 +229,54 @@ define dso_local i32 @main() #0 {
   store %struct.Counter %7, ptr %counter3, align 8
   %8 = call i64 @_ZN7Counter8getValueEv(ptr noundef nonnull align 8 dereferenceable(8) %counter3)
   %9 = call i32 (ptr, ...) @printf(ptr noundef @printf.str.2, i64 %8)
-  %10 = load i32, ptr %result, align 4
-  ret i32 %10
+  %10 = load %struct.Counter, ptr %counter3, align 8
+  %11 = load %struct.Counter, ptr %counter2, align 8
+  %12 = call %struct.Counter @_Z8op.minus7Counter7Counter(%struct.Counter %10, %struct.Counter %11)
+  store %struct.Counter %12, ptr %counter4, align 8
+  %13 = call i64 @_ZN7Counter8getValueEv(ptr noundef nonnull align 8 dereferenceable(8) %counter4)
+  %14 = call i32 (ptr, ...) @printf(ptr noundef @printf.str.3, i64 %13)
+  %15 = load %struct.Counter, ptr %counter4, align 8
+  %16 = load %struct.Counter, ptr %counter2, align 8
+  %17 = call %struct.Counter @_Z6op.mul7Counter7Counter(%struct.Counter %15, %struct.Counter %16)
+  store %struct.Counter %17, ptr %counter5, align 8
+  %18 = call i64 @_ZN7Counter8getValueEv(ptr noundef nonnull align 8 dereferenceable(8) %counter5)
+  %19 = call i32 (ptr, ...) @printf(ptr noundef @printf.str.4, i64 %18)
+  %20 = load %struct.Counter, ptr %counter5, align 8
+  %21 = load %struct.Counter, ptr %counter2, align 8
+  %22 = call %struct.Counter @_Z6op.div7Counter7Counter(%struct.Counter %20, %struct.Counter %21)
+  store %struct.Counter %22, ptr %counter6, align 8
+  %23 = call i64 @_ZN7Counter8getValueEv(ptr noundef nonnull align 8 dereferenceable(8) %counter6)
+  %24 = call i32 (ptr, ...) @printf(ptr noundef @printf.str.5, i64 %23)
+  %25 = load %struct.Counter, ptr %counter6, align 8
+  %26 = load %struct.Counter, ptr %counter2, align 8
+  %27 = call %struct.Counter @_Z6op.shl7Counter7Counter(%struct.Counter %25, %struct.Counter %26)
+  store %struct.Counter %27, ptr %counter7, align 8
+  %28 = call i64 @_ZN7Counter8getValueEv(ptr noundef nonnull align 8 dereferenceable(8) %counter7)
+  %29 = call i32 (ptr, ...) @printf(ptr noundef @printf.str.6, i64 %28)
+  %30 = load %struct.Counter, ptr %counter7, align 8
+  %31 = load %struct.Counter, ptr %counter2, align 8
+  %32 = call %struct.Counter @_Z6op.shr7Counter7Counter(%struct.Counter %30, %struct.Counter %31)
+  store %struct.Counter %32, ptr %counter8, align 8
+  %33 = call i64 @_ZN7Counter8getValueEv(ptr noundef nonnull align 8 dereferenceable(8) %counter8)
+  %34 = call i32 (ptr, ...) @printf(ptr noundef @printf.str.7, i64 %33)
+  %35 = load %struct.Counter, ptr %counter2, align 8
+  call void @_Z12op.plusequalR7Counter7Counter(ptr %counter8, %struct.Counter %35)
+  %36 = call i64 @_ZN7Counter8getValueEv(ptr noundef nonnull align 8 dereferenceable(8) %counter8)
+  %37 = call i32 (ptr, ...) @printf(ptr noundef @printf.str.8, i64 %36)
+  %38 = load %struct.Counter, ptr %counter2, align 8
+  call void @_Z13op.minusequalR7Counter7Counter(ptr %counter8, %struct.Counter %38)
+  %39 = call i64 @_ZN7Counter8getValueEv(ptr noundef nonnull align 8 dereferenceable(8) %counter8)
+  %40 = call i32 (ptr, ...) @printf(ptr noundef @printf.str.9, i64 %39)
+  %41 = load %struct.Counter, ptr %counter2, align 8
+  call void @_Z11op.mulequalR7Counter7Counter(ptr %counter8, %struct.Counter %41)
+  %42 = call i64 @_ZN7Counter8getValueEv(ptr noundef nonnull align 8 dereferenceable(8) %counter8)
+  %43 = call i32 (ptr, ...) @printf(ptr noundef @printf.str.10, i64 %42)
+  %44 = load %struct.Counter, ptr %counter2, align 8
+  call void @_Z11op.divequalR7Counter7Counter(ptr %counter8, %struct.Counter %44)
+  %45 = call i64 @_ZN7Counter8getValueEv(ptr noundef nonnull align 8 dereferenceable(8) %counter8)
+  %46 = call i32 (ptr, ...) @printf(ptr noundef @printf.str.11, i64 %45)
+  %47 = load i32, ptr %result, align 4
+  ret i32 %47
 }
 
 ; Function Attrs: nofree nounwind

diff --git a/test/test-files/irgenerator/operators/success-operator-overloading-binary/source.spice b/test/test-files/irgenerator/operators/success-operator-overloading-binary/source.spice
@@ -16,11 +16,65 @@ f<Counter> operator+(const Counter c1, const Counter c2) {
     return Counter(c1.value + c2.value);
 }
 
+f<Counter> operator-(const Counter c1, const Counter c2) {
+    return Counter(c1.value - c2.value);
+}
+
+f<Counter> operator*(const Counter c1, const Counter c2) {
+    return Counter(c1.value * c2.value);
+}
+
+f<Counter> operator/(const Counter c1, const Counter c2) {
+    return Counter(c1.value / c2.value);
+}
+
+f<Counter> operator<<(const Counter c1, const Counter c2) {
+    return Counter(c1.value << c2.value);
+}
+
+f<Counter> operator>>(const Counter c1, const Counter c2) {
+    return Counter(c1.value >> c2.value);
+}
+
+p operator+=(Counter& c1, const Counter c2) {
+    c1.value += c2.value;
+}
+
+p operator-=(Counter& c1, const Counter c2) {
+    c1.value -= c2.value;
+}
+
+p operator*=(Counter& c1, const Counter c2) {
+    c1.value *= c2.value;
+}
+
+p operator/=(Counter& c1, const Counter c2) {
+    c1.value /= c2.value;
+}
+
 f<int> main() {
     Counter counter1 = Counter(2l);
     Counter counter2 = Counter(3l);
     printf("Counter1 value: %d\n", counter1.getValue());
     printf("Counter2 value: %d\n", counter2.getValue());
     Counter counter3 = counter1 + counter2; // Here we call the overloaded operator
     printf("Counter3 value: %d\n", counter3.getValue());
+    Counter counter4 = counter3 - counter2; // Here we call the overloaded operator
+    printf("Counter4 value: %d\n", counter4.getValue());
+    Counter counter5 = counter4 * counter2; // Here we call the overloaded operator
+    printf("Counter5 value: %d\n", counter5.getValue());
+    Counter counter6 = counter5 / counter2; // Here we call the overloaded operator
+    printf("Counter6 value: %d\n", counter6.getValue());
+    Counter counter7 = counter6 << counter2; // Here we call the overloaded operator
+    printf("Counter7 value: %d\n", counter7.getValue());
+    Counter counter8 = counter7 >> counter2; // Here we call the overloaded operator
+    printf("Counter8 value: %d\n", counter8.getValue());
+    counter8 += counter2; // Here we call the overloaded operator
+    printf("Counter8 value: %d\n", counter8.getValue());
+    counter8 -= counter2; // Here we call the overloaded operator
+    printf("Counter8 value: %d\n", counter8.getValue());
+    counter8 *= counter2; // Here we call the overloaded operator
+    printf("Counter8 value: %d\n", counter8.getValue());
+    counter8 /= counter2; // Here we call the overloaded operator
+    printf("Counter8 value: %d\n", counter8.getValue());
 }
diff --git a/test/test-files/irgenerator/operators/success-operators/cout.out b/test/test-files/irgenerator/operators/success-operators/cout.out
@@ -1 +1 @@
-Value: 9
+All assertions passed!