feat(all): Replace throw Error with throwInternalCompilerError

tact-lang · Aug 8, 2024 · c9475cf · c9475cf
1 parent 671b471
commit c9475cf
Show file tree

Hide file tree

Showing 11 changed files with 104 additions and 46 deletions.
diff --git a/src/grammar/clone.ts b/src/grammar/clone.ts
@@ -1,4 +1,5 @@
 import { AstNode, cloneAstNode } from "./ast";
+import { throwInternalCompilerError } from "../errors";
 
 export function cloneNode<T extends AstNode>(src: T): T {
     if (src.kind === "boolean") {
@@ -174,5 +175,5 @@ export function cloneNode<T extends AstNode>(src: T): T {
         });
     }
 
-    throw Error("Not implemented for " + src.kind);
+    throwInternalCompilerError(`Not implemented for ${src.kind}`);
 }
diff --git a/src/grammar/grammar.ts b/src/grammar/grammar.ts
@@ -7,6 +7,7 @@ import {
     Grammar,
 } from "ohm-js";
 import tactGrammar from "./grammar.ohm-bundle";
+import { throwInternalCompilerError } from "../errors";
 import {
     AstAugmentedAssignOperation,
     AstConstantAttribute,
@@ -675,8 +676,8 @@ semantics.addOperation<AstNode>("astOfStatement", {
                     op = "^";
                     break;
                 default:
-                    throw Error(
-                        "Internal compiler error: unreachable augmented assignment operator. Please report at https://github.com/tact-lang/tact/issues",
+                    throwInternalCompilerError(
+                        "Unreachable augmented assignment operator.",
                     );
             }
             return createAstNode({

diff --git a/src/grammar/store.ts b/src/grammar/store.ts
@@ -5,6 +5,7 @@ import {
     AstNativeFunctionDecl,
     AstTypeDecl,
 } from "./ast";
+import { throwInternalCompilerError } from "../errors";
 import { CompilerContext, createContextStore } from "../context";
 import { ItemOrigin, parse } from "./grammar";
 
@@ -40,7 +41,7 @@ const store = createContextStore<AstStore>();
 export function getRawAST(ctx: CompilerContext): AstStore {
     const r = store.get(ctx, "types");
     if (!r) {
-        throw Error("No AST found in context");
+        throwInternalCompilerError("No AST found in context");
     }
     return r;
 }

diff --git a/src/storage/allocator.ts b/src/storage/allocator.ts
@@ -119,7 +119,9 @@ export function getAllocationOperationFromField(
                         optional: src.optional ? src.optional : false,
                     };
                 } else if (src.format !== null && src.format !== undefined) {
-                    throw Error("Unsupported int format " + src.format);
+                    throwInternalCompilerError(
+                        `Unsupported int format: ${src.format}`,
+                    );
                 }
                 return {
                     kind: "int",
@@ -170,7 +172,9 @@ export function getAllocationOperationFromField(
                         optional: src.optional ? src.optional : false,
                     };
                 } else if (src.format !== null && src.format !== undefined) {
-                    throw Error("Unsupported int format " + src.format);
+                    throwInternalCompilerError(
+                        `Unsupported int format: ${src.format}`,
+                    );
                 }
                 return {
                     kind: "uint",
@@ -180,7 +184,9 @@ export function getAllocationOperationFromField(
             }
             if (src.type === "bool") {
                 if (src.format !== null && src.format !== undefined) {
-                    throw Error("Unsupported bool format " + src.format);
+                    throwInternalCompilerError(
+                        `Unsupported bool format: ${src.format}`,
+                    );
                 }
                 return {
                     kind: "boolean",
@@ -195,7 +201,9 @@ export function getAllocationOperationFromField(
                         format: "remainder",
                     };
                 } else if (src.format !== null && src.format !== undefined) {
-                    throw Error("Unsupported cell format " + src.format);
+                    throwInternalCompilerError(
+                        `Unsupported cell format: ${src.format}`,
+                    );
                 }
                 return {
                     kind: "cell",
@@ -211,7 +219,9 @@ export function getAllocationOperationFromField(
                         format: "remainder",
                     };
                 } else if (src.format !== null && src.format !== undefined) {
-                    throw Error("Unsupported slice format " + src.format);
+                    throwInternalCompilerError(
+                        `Unsupported slice format: ${src.format}`,
+                    );
                 }
                 return {
                     kind: "slice",
@@ -227,7 +237,9 @@ export function getAllocationOperationFromField(
                         format: "remainder",
                     };
                 } else if (src.format !== null && src.format !== undefined) {
-                    throw Error("Unsupported slice format " + src.format);
+                    throwInternalCompilerError(
+                        `Unsupported slice format: ${src.format}`,
+                    );
                 }
                 return {
                     kind: "builder",
@@ -249,12 +261,16 @@ export function getAllocationOperationFromField(
                         optional: src.optional ? src.optional : false,
                     };
                 } else {
-                    throw Error("Unsupported fixed-bytes format " + src.format);
+                    throwInternalCompilerError(
+                        `Unsupported fixed-bytes format: ${src.format}`,
+                    );
                 }
             }
             if (src.type === "string") {
                 if (src.format !== null && src.format !== undefined) {
-                    throw Error("Unsupported string format " + src.format);
+                    throwInternalCompilerError(
+                        `Unsupported string format: ${src.format}`,
+                    );
                 }
                 return {
                     kind: "string",
@@ -273,7 +289,9 @@ export function getAllocationOperationFromField(
                     size,
                 };
             } else if (src.format !== undefined && src.format !== null) {
-                throw Error("Unsupported struct format " + src.format);
+                throwInternalCompilerError(
+                    `Unsupported struct format: ${src.format}`,
+                );
             } else {
                 return {
                     kind: "struct",
@@ -286,7 +304,9 @@ export function getAllocationOperationFromField(
         }
         case "dict": {
             if (src.format !== null && src.format !== undefined) {
-                throw Error("Unsupported map format " + src.format);
+                throwInternalCompilerError(
+                    `Unsupported map format: ${src.format}`,
+                );
             }
             return { kind: "map" };
         }

diff --git a/src/storage/resolveAllocation.ts b/src/storage/resolveAllocation.ts
@@ -7,14 +7,15 @@ import { AllocationOperation } from "./operation";
 import { allocate, getAllocationOperationFromField } from "./allocator";
 import { createABITypeRefFromTypeRef } from "../types/resolveABITypeRef";
 import { funcInitIdOf } from "../generator/writers/id";
+import { throwInternalCompilerError } from "../errors";
 import { idText } from "../grammar/ast";
 
 const store = createContextStore<StorageAllocation>();
 
 export function getAllocation(ctx: CompilerContext, name: string) {
     const t = store.get(ctx, name);
     if (!t) {
-        throw Error("Allocation for " + name + " not found");
+        throwInternalCompilerError(`Allocation for ${name} not found`);
     }
     return t;
 }

diff --git a/src/types/resolveABITypeRef.ts b/src/types/resolveABITypeRef.ts
@@ -408,7 +408,7 @@ export function createABITypeRefFromTypeRef(
             return { kind: "simple", type: "string", optional: src.optional };
         }
         if (src.name === "StringBuilder") {
-            throw Error(`Unsupported type "${src.name}"`);
+            throwInternalCompilerError(`Unsupported type "${src.name}"`);
         }
 
         // Structs
@@ -444,7 +444,7 @@ export function createABITypeRefFromTypeRef(
                 );
             }
         } else {
-            throw Error(`Unsupported map key type "${src.key}"`);
+            throwInternalCompilerError(`Unsupported map key type "${src.key}"`);
         }
 
         // Resolve value type
@@ -479,7 +479,9 @@ export function createABITypeRefFromTypeRef(
                 );
             }
         } else if (src.value === "Slice") {
-            throw Error(`Unsupported map value type "${src.value}"`);
+            throwInternalCompilerError(
+                `Unsupported map value type "${src.value}"`,
+            );
         } else if (src.value === "Address") {
             value = "address";
             if (src.valueAs) {
@@ -489,9 +491,13 @@ export function createABITypeRefFromTypeRef(
                 );
             }
         } else if (src.value === "String") {
-            throw Error(`Unsupported map value type "${src.value}"`);
+            throwInternalCompilerError(
+                `Unsupported map value type "${src.value}"`,
+            );
         } else if (src.value === "StringBuilder" || src.value === "Builder") {
-            throw Error(`Unsupported map value type "${src.value}"`);
+            throwInternalCompilerError(
+                `Unsupported map value type "${src.value}"`,
+            );
         } else {
             value = src.value;
             valueFormat = "ref";
@@ -507,8 +513,8 @@ export function createABITypeRefFromTypeRef(
     }
 
     if (src.kind === "ref_bounced") {
-        throw Error("Unexpected bounced reference");
+        throwInternalCompilerError("Unexpected bounced reference");
     }
 
-    throw Error(`Unsupported type`);
+    throwInternalCompilerError(`Unsupported type`);
 }
diff --git a/src/types/resolveDescriptors.ts b/src/types/resolveDescriptors.ts
@@ -906,7 +906,9 @@ export function resolveDescriptors(ctx: CompilerContext) {
                 if (d.kind === "function_def" || d.kind === "function_decl") {
                     const f = resolveFunctionDescriptor(s.name, d, s.origin);
                     if (f.self !== s.name) {
-                        throw Error("Function self must be " + s.name); // Impossible
+                        throwInternalCompilerError(
+                            `Function self must be ${s.name}`,
+                        ); // Impossible
                     }
                     if (s.functions.has(f.name)) {
                         throwCompilationError(
@@ -1818,7 +1820,7 @@ export function getType(
     const name = typeof ident === "string" ? ident : idText(ident);
     const r = store.get(ctx, name);
     if (!r) {
-        throw Error("Type " + name + " not found");
+        throwInternalCompilerError(`Type ${name} not found`);
     }
     return r;
 }
@@ -1839,7 +1841,7 @@ export function getStaticFunction(
 ): FunctionDescription {
     const r = staticFunctionsStore.get(ctx, name);
     if (!r) {
-        throw Error("Static function " + name + " not found");
+        throwInternalCompilerError(`Static function ${name} not found`);
     }
     return r;
 }
@@ -1854,7 +1856,7 @@ export function getStaticConstant(
 ): ConstantDescription {
     const r = staticConstantsStore.get(ctx, name);
     if (!r) {
-        throw Error("Static constant " + name + " not found");
+        throwInternalCompilerError(`Static constant ${name} not found`);
     }
     return r;
 }

diff --git a/src/types/resolveExpression.ts b/src/types/resolveExpression.ts
@@ -35,6 +35,7 @@ import { StatementContext } from "./resolveStatements";
 import { MapFunctions } from "../abi/map";
 import { GlobalFunctions } from "../abi/global";
 import { isAssignable, moreGeneralType } from "./subtyping";
+import { throwInternalCompilerError } from "../errors";
 import { StructFunctions } from "../abi/struct";
 
 const store = createContextStore<{
@@ -45,7 +46,7 @@ const store = createContextStore<{
 export function getExpType(ctx: CompilerContext, exp: AstExpression) {
     const t = store.get(ctx, exp.id);
     if (!t) {
-        throw Error("Expression " + exp.id + " not found");
+        throwInternalCompilerError(`Expression ${exp.id} not found`);
     }
     return t.description;
 }
@@ -60,7 +61,7 @@ function registerExpType(
         if (typeRefEquals(ex.description, description)) {
             return ctx;
         }
-        throw Error("Expression " + exp.id + " already has a type");
+        throwInternalCompilerError(`Expression ${exp.id} already has a type`);
     }
     return store.set(ctx, exp.id, { ast: exp, description });
 }