Function generateStructureFinalizer

src/ast/ast_generate.cpp:526–596

    }

    FunctionPtr generateStructureFinalizer ( const StructurePtr & ls ) {
        auto pFunc = new Function();
        pFunc->privateFunction = true;
        pFunc->generated = true;
        pFunc->at = pFunc->atDecl = ls->at;
        pFunc->name = "finalize";
        if ( ls->isClass ) {
            pFunc->isClassMethod = true;
            pFunc->classParent = ls;
            DAS_ASSERT(pFunc->classParent);
        }
        if ( ls->macroInterface ) pFunc->macroFunction = true;
        auto fb = new ExprBlock();
        fb->at = ls->at;
        // For a class whose ancestry has a user finalizer, chain to the immediate
        // parent: this finalizer owns only its own slice of the fields (everything
        // past the parent prefix), then `delete cast<Parent>(__this)` runs the
        // parent's finalize — the user one, or a generated chain finalizer that
        // recurses the same way. Derived slice first, parent second (dtor order).
        Structure * chainParent = ( ls->isClass && findChainFinalizerAncestor(ls) ) ? ls->parent : nullptr;
        size_t firstOwnField = chainParent ? chainParent->fields.size() : 0;
        // now finalize
        bool needUnsafe = false;
        for ( int stage=0; stage!=2; ++stage ) {
            // stage 0 is iterators, stage 1 is everything else
            for ( size_t fi=firstOwnField, fis=ls->fields.size(); fi!=fis; ++fi ) {
                const auto & fl = ls->fields[fi];
                if ( !fl.type->constant && !fl.capturedConstant && fl.type->needDelete() ) {
                    if ( !fl.doNotDelete && !fl.capturedRef ) {
                        if ( stage==0 && !fl.type->isIterator() ) continue;
                        if ( stage==1 && fl.type->isIterator() ) continue;
                        if ( fl.type->isPointer() && fl.type->firstType && fl.type->firstType->constant ) continue;
                        if ( ls->isLambda && !fl.type->isSafeToDelete() ) continue; // we don't do unsafe delete for lambda
                        auto fva = new ExprVar(fl.at, "__this");
                        auto fld = new ExprField(fl.at, fva, fl.name);
                        fld->ignoreCaptureConst = true;
                        auto delf = new ExprDelete(fl.at, fld);
                        delf->alwaysSafe = true;
                        fb->list.emplace_back(delf);
                        if ( fl.type->isPointer() ) {
                            needUnsafe = true;
                        }
                    }
                }
            }
        }
        if ( chainParent ) {
            auto chthis = new ExprVar(ls->at, "__this");
            auto chcast = new ExprCast(ls->at, chthis, new TypeDecl(chainParent));
            auto chdel = new ExprDelete(ls->at, chcast);
            chdel->alwaysSafe = true;
            fb->list.push_back(chdel);
        }
        auto mz = new ExprMemZero(ls->at, "memzero");
        auto lvar = new ExprVar(ls->at, "__this");
        mz->arguments.push_back(lvar);
        fb->list.push_back(mz);
        pFunc->body = fb;