This problem occurs because the interpreter is called when the writer is called. In turn, the writer is called only when there is a declared contract in the Tact file (see the for-statement at line 100 in file build.ts). In other words, if the Tact file does not have a declared contract, the code generation into FunC is not triggered.

I understand that a FunC file describes the behavior of a contract (it is basically a list of receiver functions together with auxiliary functions). Therefore, if there is no declared contract in a Tact file, there is no FunC program to generate.

But then, in a file like this,

fun blowup(v: Int) {
    1 / v;
}

fun test() {
    blowup(0);
}

what is point of running the typechecker if it is not going to be compiled into FunC anyway? Probably because there are Tact files that are essentially collections of functions that can be used in other Tact files?

In that case, I think that the interpreter should be called not when the writer is called, but immediately after the typechecker finishes. In other words, there must be a pass to simplify expressions before the FunC code generation phase.

What do you think of this?

I think that the interpreter should be called not when the writer is called, but immediately after the typechecker finishes

yes, this makes sense. btw, when you implement this, please add a CLI option to output the resulting simplified Tact contract (will be really useful for debugging)

@anton-trunov, I think I should already create the "optimization phase" in build.ts. Like this:

// Precompile
    try {
        ctx = precompile(ctx, project, stdlib, config.path);
    } catch (e) {
        logger.error(
            config.mode === "checkOnly" || config.mode === "funcOnly"
                ? "Syntax and type checking failed"
                : "Tact compilation failed",
        );
        logger.error(e as Error);
        return { ok: false, error: [e as Error] };
    }

    if (config.mode === "checkOnly") {
        logger.info("✔️ Syntax and type checking succeeded.");
        return { ok: true, error: [] };
    }

/*************************** ADD IT RIGHT HERE *************
   // Tact optimization phase
 ctx = optimize_tact_code(ctx, ..............)


    // Compile contracts
    let ok = true;
....... rest of the FunC code generation and compilation phase

Inside optimize_tact_code will be the expression simplification pass, and also the constant propagation analyzer, and we can add later further passes.

Note that this is only the high level optimization pass. Optimization phases for lower level code will need to be added after the FunC generation.

@jeshecdom sounds good

also, let's add the ability to opt-out of optimizations, for instance, in case there is a bug in the optimizer