fix: better error message when two require() calls produce the same error code (#3286)

Author: i582

dev-docs/CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - [fix] Compiler now doesn't require explicit re-declaration for abstract methods and fields in traits: PR [#3272](https://github.com/tact-lang/tact/pull/3272)
 - Compiler now allows `toCell()` and `toSlice()` methods on contract types: PR [#3274](https://github.com/tact-lang/tact/pull/3274)
 - Compiler now generates message loading in place for better performance: PR [#2993](https://github.com/tact-lang/tact/pull/2993)
+- Compiler now shows a more informative error message if two `require()` calls have the same generated error code: PR [#3286](https://github.com/tact-lang/tact/pull/3286)
 
 ### Docs
 

src/storage/resolveErrors.spec.ts

@@ -49,4 +49,45 @@ contract Test {
         ctx = resolveStatements(ctx);
         expect(() => resolveErrors(ctx, ast)).toThrow(expectedErrors);
     });
+
+    it("should throw on duplicate error code", () => {
+        const src = `
+trait BaseTrait {}
+
+contract Test {
+    get fun foo(): Int {
+        require(false, "113");
+        return 0;
+    }
+
+    get fun bar(): Int {
+        require(false, "241");
+        return 0;
+    }
+}
+`;
+
+        const expectedErrors = `<unknown>:11:24: Error message "241" maps to error code 38048, which is already assigned to "113", change the message to resolve this conflict
+  10 |     get fun bar(): Int {
+> 11 |         require(false, "241");
+                              ^~~~~
+  12 |         return 0;
+`;
+
+        const ast = getAstFactory();
+        const sources: Source[] = [
+            { code: stdlib, path: primitivesPath, origin: "stdlib" },
+            { code: src, path: "<unknown>", origin: "user" },
+        ];
+        let ctx = openContext(
+            new CompilerContext(),
+            sources,
+            [],
+            parseModules(sources, getParser(ast)),
+        );
+        ctx = resolveDescriptors(ctx, ast);
+        ctx = resolveSignatures(ctx, ast);
+        ctx = resolveStatements(ctx);
+        expect(() => resolveErrors(ctx, ast)).toThrow(expectedErrors);
+    });
 });

src/types/resolveErrors.ts

@@ -40,21 +40,21 @@ function resolveStringsInAST(
 ) {
     traverse(ast, (node) => {
         if (node.kind === "static_call" && isRequire(node.function)) {
-            if (node.args.length !== 2) {
+            const [, messageArg] = node.args;
+            if (typeof messageArg === "undefined") {
                 return;
             }
             const resolved = ensureString(
-                evaluateRequireErrorString(node.args[1]!, ctx, util),
+                evaluateRequireErrorString(messageArg, ctx, util),
             ).value;
             if (!exceptions.get(ctx, resolved)) {
                 const id = exceptionId(resolved);
-                if (
-                    Array.from(exceptions.all(ctx).values()).find(
-                        (v) => v.id === id,
-                    )
-                ) {
-                    throwInternalCompilerError(
-                        `Duplicate error id: "${resolved}"`,
+                const exceptionsArray = [...exceptions.all(ctx).values()];
+                const prev = exceptionsArray.find((v) => v.id === id);
+                if (typeof prev !== "undefined") {
+                    throwCompilationError(
+                        `Error message "${resolved}" maps to error code ${id}, which is already assigned to "${prev.value}", change the message to resolve this conflict`,
+                        messageArg.loc,
                     );
                 }
                 ctx = exceptions.set(ctx, resolved, { value: resolved, id });