feat: include expected type for invalid type error message (tact-lang#1738)

Author: Gusarich

dev-docs/CHANGELOG.md

@@ -48,6 +48,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Don't generate `lazy_deployment_completed` by default: PR [#1717](https://github.com/tact-lang/tact/pull/1717)
 - Optimized `emptyCell()` and `emptySlice()` functions: PR [#1696](https://github.com/tact-lang/tact/pull/1696)
 - Rearrange parameters of some asm methods in order described in `AsmShuffle`: PR [#1702](https://github.com/tact-lang/tact/pull/1702)
+- Error message for invalid type for function argument now shows expected type: PR [#1738](https://github.com/tact-lang/tact/pull/1738)
 
 ### Fixed
 

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

@@ -100,7 +100,7 @@ exports[`resolveStatements should fail statements for contract-getter-with-metho
 `;
 
 exports[`resolveStatements should fail statements for contract-initof-wrong-arg 1`] = `
-"<unknown>:26:25: Invalid type "String" for argument "owner"
+"<unknown>:26:25: Cannot pass an expression of type "String" to the parameter "owner" of type "Int"
   25 |     get fun newInit(): StateInit {
 > 26 |         return initOf A("hello");
                                ^~~~~~~
@@ -385,7 +385,7 @@ exports[`resolveStatements should fail statements for expr-field-does-not-exist-
 `;
 
 exports[`resolveStatements should fail statements for expr-internal-fun-call-bool-param.tact 1`] = `
-"<unknown>:20:27: Invalid type "Bool" for argument "b"
+"<unknown>:20:27: Cannot pass an expression of type "Bool" to the parameter "b" of type "Int"
   19 |     fun f2(a: Int): Int {
 > 20 |         return self.f1(a, true);
                                  ^~~~
@@ -448,7 +448,7 @@ exports[`resolveStatements should fail statements for expr-method-does-not-exist
 `;
 
 exports[`resolveStatements should fail statements for expr-module-fun-call-bool-param 1`] = `
-"<unknown>:13:18: Invalid type "Bool" for argument "b"
+"<unknown>:13:18: Cannot pass an expression of type "Bool" to the parameter "b" of type "Int"
   12 | fun f2(a: Int): Int {
 > 13 |     return f1(a, true);
                         ^~~~

src/types/resolveExpression.ts

@@ -15,7 +15,12 @@ import {
     hasStaticConstant,
     hasStaticFunction,
 } from "./resolveDescriptors";
-import { printTypeRef, TypeRef, typeRefEquals } from "./types";
+import {
+    FunctionParameter,
+    printTypeRef,
+    TypeRef,
+    typeRefEquals,
+} from "./types";
 import { StatementContext } from "./resolveStatements";
 import { MapFunctions } from "../abi/map";
 import { GlobalFunctions } from "../abi/global";
@@ -526,6 +531,20 @@ function resolveFieldAccess(
     }
 }
 
+function checkParameterType(
+    expression: A.AstExpression,
+    parameter: FunctionParameter,
+    ctx: CompilerContext,
+) {
+    const t = getExpType(ctx, expression);
+    if (!isAssignable(t, parameter.type)) {
+        throwCompilationError(
+            `Cannot pass an expression of type "${printTypeRef(t)}" to the parameter ${idTextErr(parameter.name)} of type "${printTypeRef(parameter.type)}"`,
+            expression.loc,
+        );
+    }
+}
+
 function resolveStaticCall(
     exp: A.AstStaticCall,
     sctx: StatementContext,
@@ -587,14 +606,7 @@ function resolveStaticCall(
         );
     }
     for (const [i, a] of f.params.entries()) {
-        const e = exp.args[i]!;
-        const t = getExpType(ctx, e);
-        if (!isAssignable(t, a.type)) {
-            throwCompilationError(
-                `Invalid type "${printTypeRef(t)}" for argument ${idTextErr(a.name)}`,
-                e.loc,
-            );
-        }
+        checkParameterType(exp.args[i]!, a, ctx);
     }
 
     // Resolve return type
@@ -654,14 +666,7 @@ function resolveCall(
                 );
             }
             for (const [i, a] of f.params.entries()) {
-                const e = exp.args[i]!;
-                const t = getExpType(ctx, e);
-                if (!isAssignable(t, a.type)) {
-                    throwCompilationError(
-                        `Invalid type "${printTypeRef(t)}" for argument ${idTextErr(a.name)}`,
-                        e.loc,
-                    );
-                }
+                checkParameterType(exp.args[i]!, a, ctx);
             }
 
             return registerExpType(ctx, exp, f.returns);
@@ -779,14 +784,7 @@ function resolveInitOf(
         );
     }
     for (const [i, a] of type.init.params.entries()) {
-        const e = ast.args[i]!;
-        const t = getExpType(ctx, e);
-        if (!isAssignable(t, a.type)) {
-            throwCompilationError(
-                `Invalid type "${printTypeRef(t)}" for argument ${idTextErr(a.name)}`,
-                e.loc,
-            );
-        }
+        checkParameterType(ast.args[i]!, a, ctx);
     }
 
     // Register return type