Function countSuperCalls

src/ast/ast_lint.cpp:225–333

        return false;
    }
    SuperCount countSuperCalls ( const ExpressionPtr & expr, const SuperChainMatch & chainCall ) {
        if ( !expr ) return SuperCount::onlyFall(0, 0);
        if ( expr->rtti_isCall() ) {
            auto call = static_cast<ExprCall*>(expr);
            if ( chainCall(call) ) {
                return SuperCount::onlyFall(1, 1);
            }
            // JIT-mode rewrite of try/recover: ast_infer_type_op.cpp:1015 emits
            // `builtin_try_recover(make_block(try), make_block(catch))` and the typer
            // appends `context` + `at` (final arity = 4). Match the resolved function on
            // its source module ($) to avoid colliding with any user shadow. Count super
            // in the try block only; the recover block is fatal-panic-with-diagnostics,
            // irrelevant to chain semantics (mirrors the direct ExprTryCatch handler below).
            if ( call->func && call->func->module && call->func->module->name == "$"
                && call->func->name == "builtin_try_recover"
                && call->arguments.size() >= 2
                && call->arguments[0]->rtti_isMakeBlock() ) {
                auto mb = static_cast<ExprMakeBlock*>(call->arguments[0]);
                return countSuperCalls(mb->block, chainCall);
            }
            return SuperCount::onlyFall(0, 0);
        }
        if ( expr->rtti_isReturn() ) {
            // Early-exit at this point with the prefix accumulated so far; no super
            // here, no fall-through. The caller (block walker) folds the prefix in.
            return SuperCount::onlyExit(0, 0);
        }
        if ( expr->rtti_isBreak() || expr->rtti_isContinue() || expr->rtti_isGoto() ) {
            // Don't escape the function — they stop block iteration (no fall-through) but
            // contribute no function-level exit path.
            return SuperCount::dead();
        }
        if ( expr->rtti_isBlock() ) {
            auto blk = static_cast<ExprBlock*>(expr);
            int prefix_lo = 0, prefix_hi = 0;
            SuperCount out = SuperCount::onlyFall(0, 0); // exits accumulated as we go
            out.hasExits = false;
            bool fallenThrough = true;
            for ( auto & be : blk->list ) {
                auto sub = countSuperCalls(be, chainCall);
                if ( sub.hasExits ) {
                    mergeExit(out, safeAdd(prefix_lo, sub.exitLo), safeAdd(prefix_hi, sub.exitHi));
                }
                if ( !sub.fallsThrough ) {
                    fallenThrough = false;
                    break;
                }
                prefix_lo = safeAdd(prefix_lo, sub.fallLo);
                prefix_hi = safeAdd(prefix_hi, sub.fallHi);
            }
            out.fallsThrough = fallenThrough;
            out.fallLo = prefix_lo;
            out.fallHi = prefix_hi;
            return out;
        }
        if ( expr->rtti_isIfThenElse() ) {
            auto ite = static_cast<ExprIfThenElse*>(expr);
            auto t = countSuperCalls(ite->if_true, chainCall);