Enhance error handling to support third-party tools

scripts/prepare.ts

@@ -15,74 +15,84 @@ import { __DANGER__disableVersionNumber } from "../src/pipeline/version";
 
     const logger = new Logger();
 
-    // Compile projects
-    if (!(await run({ configPath: __dirname + "/../tact.config.json" })).ok) {
-        console.error("Tact projects compilation failed");
-        process.exit(1);
-    }
-
-    // Verify projects
-    for (const pkgPath of glob.sync(
-        path.normalize(
-            path.resolve(__dirname, "..", "examples", "output", "*.pkg"),
-        ),
-    )) {
-        const res = await verify({ pkg: fs.readFileSync(pkgPath, "utf-8") });
-        if (!res.ok) {
-            console.error("Failed to verify " + pkgPath + ": " + res.error);
-            process.exit(1);
+    try {
+        // Compile projects
+        const compileResult = await run({
+            configPath: path.join(__dirname, "../tact.config.json"),
+        });
+        if (!compileResult.ok) {
+            throw new Error("Tact projects compilation failed");
         }
-    }
 
-    // Compile func files
-    for (const p of [{ path: __dirname + "/../func/" }]) {
-        const recs = fs.readdirSync(p.path);
-        for (const r of recs) {
-            if (!r.endsWith(".fc")) {
-                continue;
+        // Verify projects
+        for (const pkgPath of glob.sync(
+            path.normalize(
+                path.resolve(__dirname, "..", "examples", "output", "*.pkg"),
+            ),
+        )) {
+            const res = await verify({
+                pkg: fs.readFileSync(pkgPath, "utf-8"),
+            });
+            if (!res.ok) {
+                throw new Error(`Failed to verify ${pkgPath}: ${res.error}`);
             }
+        }
 
-            // Precompile
-            console.log("Processing " + p.path + r);
-            let c: FuncCompilationResult;
-            try {
-                const stdlibPath = path.resolve(
-                    __dirname,
-                    "..",
-                    "stdlib",
-                    "stdlib.fc",
-                );
-                const stdlib = fs.readFileSync(stdlibPath, "utf-8");
-                const code = fs.readFileSync(p.path + r, "utf-8");
-                c = await funcCompile({
-                    entries: [stdlibPath, p.path + r],
-                    sources: [
-                        {
-                            path: stdlibPath,
-                            content: stdlib,
-                        },
-                        {
-                            path: p.path + r,
-                            content: code,
-                        },
-                    ],
-                    logger: logger,
-                });
-                if (!c.ok) {
-                    logger.error(c.log);
-                    process.exit(1);
+        // Compile func files
+        for (const p of [{ path: path.join(__dirname, "/../func/") }]) {
+            const recs = fs.readdirSync(p.path);
+            for (const r of recs) {
+                if (!r.endsWith(".fc")) {
+                    continue;
                 }
-            } catch (e) {
-                logger.error(e as Error);
-                logger.error("Failed");
-                process.exit(1);
-            }
-            fs.writeFileSync(p.path + r + ".fift", c.fift!);
-            fs.writeFileSync(p.path + r + ".cell", c.output!);
 
-            // Cell -> Fift decompiler
-            const source = decompileAll({ src: c.output! });
-            fs.writeFileSync(p.path + r + ".rev.fift", source);
+                // Precompile
+                logger.info(`Processing ${path.join(p.path + r)}`);
+                let c: FuncCompilationResult;
+                try {
+                    const stdlibPath = path.resolve(
+                        __dirname,
+                        "..",
+                        "stdlib",
+                        "stdlib.fc",
+                    );
+                    const stdlib = fs.readFileSync(stdlibPath, "utf-8");
+                    const code = fs.readFileSync(p.path + r, "utf-8");
+                    c = await funcCompile({
+                        entries: [stdlibPath, p.path + r],
+                        sources: [
+                            {
+                                path: stdlibPath,
+                                content: stdlib,
+                            },
+                            {
+                                path: p.path + r,
+                                content: code,
+                            },
+                        ],
+                        logger: logger,
+                    });
+                    if (!c.ok) {
+                        logger.error(c.log);
+                        throw new Error(
+                            `FunC compilation failed for ${path.join(p.path, r)}`,
+                        );
+                    }
+                } catch (e) {
+                    logger.error(e as Error);
+                    logger.error(`Failed for ${path.join(p.path, r)}`);
+                    throw e;
+                }
+                fs.writeFileSync(p.path + r + ".fift", c.fift!);
+                fs.writeFileSync(p.path + r + ".cell", c.output!);
+
+                // Cell -> Fift decompiler
+                const source = decompileAll({ src: c.output! });
+                fs.writeFileSync(p.path + r + ".rev.fift", source);
+            }
         }
+    } catch (error) {
+        logger.error(error as Error);
+        process.exit(1);
     }
 })();

src/browser.ts

@@ -6,7 +6,7 @@ import { createVirtualFileSystem } from "./vfs/createVirtualFileSystem";
 export async function run(args: {
     config: Config;
     files: { [key: string]: string };
-    logger?: Logger | null | undefined;
+    logger?: Logger;
 }) {
     // Verify config
     const config = verifyConfig(args.config);

src/logger.ts

@@ -54,7 +54,7 @@ export class Logger {
         if (message instanceof Error) {
             message = message.stack || message.message;
         } else {
-            message = "" + message.toString();
+            message = message.toString();
         }
 
         if (level > this.level) return;

src/node.ts

@@ -69,7 +69,14 @@ export async function run(args: {
 }) {
     const configWithRootPath = await loadConfig(args.fileName, args.configPath);
     if (!configWithRootPath) {
-        return { ok: false, error: [new Error("Unable to load config")] };
+        return {
+            ok: false,
+            error: [
+                new Error(
+                    `Unable to load config from path: ${args.configPath}`,
+                ),
+            ],
+        };
     }
 
     const logger = new Logger(args.suppressLog ? LogLevel.NONE : LogLevel.INFO);

src/pipeline/build.ts

@@ -26,7 +26,7 @@ export async function build(args: {
     config: ConfigProject;
     project: VirtualFileSystem;
     stdlib: string | VirtualFileSystem;
-    logger?: Logger | null | undefined;
+    logger?: Logger;
 }): Promise<{ ok: boolean; error: TactErrorCollection[] }> {
     const { config, project } = args;
     const stdlib =
@@ -112,7 +112,7 @@ export async function build(args: {
         let codeEntrypoint: string;
 
         // Compiling contract to func
-        logger.info("   > " + contract + ": tact compiler");
+        logger.info(`   > ${contract}: tact compiler`);
         let abi: string;
         try {
             const res = await compile(
@@ -336,10 +336,10 @@ export async function build(args: {
                 bindingsServer,
             );
         } catch (e) {
-            const message = "Bindings compiler crashed";
-            logger.error(message);
-            logger.error(e as Error);
-            errorMessages.push(new Error(message));
+            const error = e as Error;
+            error.message = `Bindings compiler crashed, ${error.message}`;
+            logger.error(error);
+            errorMessages.push(error);
             return { ok: false, error: errorMessages };
         }
     }
@@ -356,10 +356,10 @@ export async function build(args: {
             );
             project.writeFile(pathBindings, report);
         } catch (e) {
-            const message = "Report generation crashed";
-            logger.error(message);
-            logger.error(e as Error);
-            errorMessages.push(new Error(message));
+            const error = e as Error;
+            error.message = `Report generation crashed, ${error.message}`;
+            logger.error(error);
+            errorMessages.push(error);
             return { ok: false, error: errorMessages };
         }
     }