Function makeConstructor

src/ast/ast_generate.cpp:313–396

return [[t()]] -- or, for a class derived from a parent with a user ctor, emit the let-self / call Parent`Parent(self) / return self chain body.

    // return [[t()]] -- or, for a class derived from a parent with a user ctor,
    // emit the let-self / call Parent`Parent(self) / return self chain body.
    FunctionPtr makeConstructor ( Structure * str, bool isPrivate ) {
        auto fn = new Function();
        fn->generated = true;
        fn->privateFunction = isPrivate;
        fn->name = str->name;
        fn->at = fn->atDecl = str->at;
        fn->result = new TypeDecl(str);
        if ( str->isClass ) {
            fn->isClassMethod = true;
            fn->classParent = str;
            DAS_ASSERT(fn->classParent);
        }
        if ( str->macroInterface ) fn->macroFunction = true;
        auto block = new ExprBlock();
        block->at = str->at;
        // For a synth ctor of a class whose ancestor chain has a user ctor, emit a
        // chain body that calls the deepest USER ctor directly -- but only when
        // (a) the class itself has no user ctor (true implicit-default case)
        // AND (b) the chain target has a 0-arg-callable user ctor we can reach.
        // Otherwise fall through to the plain field-init body. The latter preserves
        // the long-standing `new Class(field=val)` named-init idiom for classes
        // with user ctors. The lint catches missing super in the user's own ctor,
        // which is the only path that actually runs invariants.
        Structure * chainTarget = nullptr;
        if ( !str->hasUserConstructor() ) {
            auto * cand = findChainCtorAncestor(str);
            if ( cand && cand->hasUserDefaultConstructor() ) {
                chainTarget = cand;
            }
        }
        if ( chainTarget ) {
            // let self = [[Derived()]]
            auto makeT = new ExprMakeStruct(str->at);
            makeT->alwaysSafe = true;
            makeT->useInitializer = true;
            makeT->nativeClassInitializer = true;
            makeT->makeType = new TypeDecl(str);
            makeT->structs.push_back(new MakeStruct());
            auto letS = new ExprLet();
            letS->at = str->at;
            letS->atInit = str->at;
            letS->visibility = str->at;
            letS->alwaysSafe = true;    // local class variable
            auto argT = new TypeDecl(str);
            argT->constant = false;
            auto argV = new Variable();
            argV->name = "self";
            argV->type = argT;
            argV->at = str->at;
            argV->generated = true;
            argV->capture_as_ref = true;
            argV->init = makeT;
            argV->init_via_move = true;
            letS->variables.push_back(argV);
            block->list.push_back(letS);
            // call ChainTarget`ChainTarget(self) -- closest ancestor with user ctor
            auto cll = new ExprCall(str->at, chainTarget->name + "`" + chainTarget->name);
            cll->arguments.push_back(new ExprVar(str->at, "self"));