fix: better type error messages for void type (#442)

CHANGELOG.md

@@ -38,6 +38,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `Int as coins` as a value type of a map in persistent storage does not throw compilation error anymore: PR [#413](https://github.com/tact-lang/tact/pull/413)
 - The semantics of the Tact arithmetic operations in the constant evaluator to perform rounding towards negative infinity: PR [#432](https://github.com/tact-lang/tact/pull/432)
 - Inferring `void` type in let statements is now forbidden: PR [#438](https://github.com/tact-lang/tact/pull/438)
+- Better error messages for the `void` type: PR [#442](https://github.com/tact-lang/tact/pull/442)
 
 ## [1.3.1] - 2024-06-08
 

src/types/__snapshots__/resolveStatements.spec.ts.snap

@@ -40,6 +40,26 @@ Line 5, col 12:
 "
 `;
 
+exports[`resolveStatements should fail statements for expr-cmp-void1 1`] = `
+"<unknown>:7:12: Expressions of "<void>" type cannot be used for (non)equality operator "=="
+Line 7, col 12:
+  6 | fun baz(): Bool {
+> 7 |     return foo() == bar()
+                 ^~~~~~~~~~~~~~
+  8 | }
+"
+`;
+
+exports[`resolveStatements should fail statements for expr-cmp-void2 1`] = `
+"<unknown>:7:12: Expressions of "<void>" type cannot be used for (non)equality operator "!="
+Line 7, col 12:
+  6 | fun baz(): Bool {
+> 7 |     return foo() != bar()
+                 ^~~~~~~~~~~~~~
+  8 | }
+"
+`;
+
 exports[`resolveStatements should fail statements for expr-conditional-branch-mismatch 1`] = `
 "<unknown>:5:43: Non-matching types "Bool" and "Int" for ternary branches
 Line 5, col 43:
@@ -110,6 +130,16 @@ Line 5, col 5:
 "
 `;
 
+exports[`resolveStatements should fail statements for expr-conditional-void-branches copy 1`] = `
+"<unknown>:6:19: Expressions of "<void>" type cannot be used for conditional expression
+Line 6, col 19:
+  5 | fun bar(): Int {
+> 6 |     let voidVar = true ? foo() : foo();
+                        ^~~~~~~~~~~~~~~~~~~~
+  7 |     return 42;
+"
+`;
+
 exports[`resolveStatements should fail statements for expr-internal-fun-call-bool-param.tact 1`] = `
 "<unknown>:20:27: Invalid type "Bool" for argument "b"
 Line 20, col 27:
@@ -430,6 +460,16 @@ Line 5, col 5:
 "
 `;
 
+exports[`resolveStatements should fail statements for stmt-conditional-expr-stmt-void1 1`] = `
+"<unknown>:5:5: Expressions of "<void>" type cannot be used for conditional expression
+Line 5, col 5:
+  4 | fun baz() {
+> 5 |     true ? foo() : bar();
+          ^~~~~~~~~~~~~~~~~~~~
+  6 | }
+"
+`;
+
 exports[`resolveStatements should fail statements for stmt-do-int 1`] = `
 "<unknown>:9:5: Type mismatch: "Int" is not assignable to "Bool"
 Line 9, col 5:
@@ -510,6 +550,46 @@ Line 8, col 9:
 "
 `;
 
+exports[`resolveStatements should fail statements for stmt-return-void1 1`] = `
+"<unknown>:4:5: 'return' statement can only be used with non-void types
+Line 4, col 5:
+  3 | fun bar() {
+> 4 |     return foo()
+          ^~~~~~~~~~~~
+  5 | }
+"
+`;
+
+exports[`resolveStatements should fail statements for stmt-return-void2 1`] = `
+"<unknown>:6:5: Type mismatch: "Int" is not assignable to "<void>"
+Line 6, col 5:
+  5 | fun bar() {
+> 6 |     return foo()
+          ^~~~~~~~~~~~
+  7 | }
+"
+`;
+
+exports[`resolveStatements should fail statements for stmt-return-void3 1`] = `
+"<unknown>:3:18: The function fails to return a result of type "Int"
+Line 3, col 18:
+  2 | 
+> 3 | fun bar(): Int { return }
+                       ^~~~~~
+  4 | 
+"
+`;
+
+exports[`resolveStatements should fail statements for stmt-unboxing-expr-stmt-void 1`] = `
+"<unknown>:4:5: Type "<void>" is not optional
+Line 4, col 5:
+  3 | fun bar() {
+> 4 |     foo()!!
+          ^~~~~~~
+  5 | }
+"
+`;
+
 exports[`resolveStatements should fail statements for stmt-while-int 1`] = `
 "<unknown>:9:5: Type mismatch: "Int" is not assignable to "Bool"
 Line 9, col 5:

src/types/resolveExpression.ts

@@ -253,6 +253,12 @@ function resolveBinaryOp(
                         exp.ref,
                     );
                 }
+                if (l.kind == "void" || r.kind == "void") {
+                    throwSyntaxError(
+                        `Expressions of "<void>" type cannot be used for (non)equality operator "${exp.op}"`,
+                        exp.ref,
+                    );
+                }
                 if (l.kind !== "ref" || r.kind !== "ref") {
                     throwSyntaxError(
                         `Incompatible types "${printTypeRef(le)}" and "${printTypeRef(re)}" for binary operator "${exp.op}"`,
@@ -670,6 +676,12 @@ export function resolveConditional(
 
     const resultType = moreGeneralType(thenType, elseType);
     if (resultType) {
+        if (resultType.kind == "void") {
+            throwSyntaxError(
+                `Expressions of "<void>" type cannot be used for conditional expression`,
+                ast.ref,
+            );
+        }
         return registerExpType(ctx, ast, resultType);
     }
 

src/types/resolveStatements.ts

@@ -300,6 +300,17 @@ function processStatements(
 
                 // Check type
                 const expressionType = getExpType(ctx, s.expression);
+
+                // Actually, we might relax the following restriction in the future
+                // Because `return foo()` means `foo(); return` for a void-returning function
+                // And `return foo()` looks nicer when the user needs early exit from a function
+                // right after executing `foo()`
+                if (expressionType.kind == "void") {
+                    throwSyntaxError(
+                        `'return' statement can only be used with non-void types`,
+                        s.ref,
+                    );
+                }
                 if (!isAssignable(expressionType, sctx.returns)) {
                     throwSyntaxError(
                         `Type mismatch: "${printTypeRef(expressionType)}" is not assignable to "${printTypeRef(sctx.returns)}"`,
@@ -309,7 +320,7 @@ function processStatements(
             } else {
                 if (sctx.returns.kind !== "void") {
                     throwSyntaxError(
-                        `Type mismatch: "void" is not assignable to "${printTypeRef(sctx.returns)}"`,
+                        `The function fails to return a result of type "${printTypeRef(sctx.returns)}"`,
                         s.ref,
                     );
                 }

src/types/stmts-failed/expr-cmp-void1.tact

@@ -0,0 +1,8 @@
+primitive Bool;
+
+fun foo() { return }
+fun bar() { return }
+
+fun baz(): Bool {
+    return foo() == bar()
+}

src/types/stmts-failed/expr-cmp-void2.tact

@@ -0,0 +1,8 @@
+primitive Bool;
+
+fun foo() { return }
+fun bar() { return }
+
+fun baz(): Bool {
+    return foo() != bar()
+}

src/types/stmts-failed/expr-conditional-void-branches copy.tact

@@ -0,0 +1,8 @@
+primitive Int;
+
+fun foo() { return }
+
+fun bar(): Int {
+    let voidVar = true ? foo() : foo();
+    return 42;
+}

src/types/stmts-failed/stmt-conditional-expr-stmt-void1.tact

@@ -0,0 +1,6 @@
+fun foo() { return }
+fun bar() { return }
+
+fun baz() {
+    true ? foo() : bar();
+}

src/types/stmts-failed/stmt-return-void1.tact

@@ -0,0 +1,5 @@
+fun foo() { return }
+
+fun bar() {
+    return foo()
+}

src/types/stmts-failed/stmt-return-void2.tact

@@ -0,0 +1,7 @@
+primitive Int;
+
+fun foo(): Int { return 42 }
+
+fun bar() {
+    return foo()
+}

src/types/stmts-failed/stmt-return-void3.tact

@@ -0,0 +1,3 @@
+primitive Int;
+
+fun bar(): Int { return }

src/types/stmts-failed/stmt-unboxing-expr-stmt-void.tact

@@ -0,0 +1,5 @@
+fun foo() { return }
+
+fun bar() {
+    foo()!!
+}

src/types/subtyping.ts

@@ -32,9 +32,8 @@ export function isAssignable(src: TypeRef, to: TypeRef): boolean {
         return true;
     }
 
-    // If either is void
-    if (src.kind === "void" || to.kind === "void") {
-        return false; // Void is not assignable
+    if (src.kind === "void" && to.kind === "void") {
+        return true;
     }
 
     // Check null