Function generateLambdaMakeStruct

src/ast/ast_generate.cpp:828–892

    }

    ExpressionPtr generateLambdaMakeStruct ( const StructurePtr & ls, const FunctionPtr & lf, const FunctionPtr & lff,
                                            const safe_var_set & capt, const vector<CaptureEntry> & capture,
                                            const LineInfo & at, const LineInfo & captureAt, Program * thisProgram ) {
        auto asc = new ExprAscend();
        asc->at = at;
        asc->needTypeInfo = true;
        auto makeS = new ExprMakeStruct();
        // makeS->useInitializer = true;
        makeS->at = at;
        makeS->makeType = new TypeDecl(ls);
        auto ms = new MakeStruct();
        auto atTHIS = new ExprAddr(lf->at, "_::" + lf->name);
        // TODO: expand atTHIS->funcType, so that it points to correct function by type as well
        auto mTHIS = new MakeFieldDecl(lf->at, "__lambda", atTHIS, false, false);
        ms->push_back(mTHIS);
        auto atTHISF = new ExprAddr(lff->at, "_::" + lff->name);
        auto mTHISF = new MakeFieldDecl(lf->at, "__finalize", atTHISF, false, false);
        ms->push_back(mTHISF);
        for ( auto cV : capt ) {
            CaptureMode mode = CaptureMode::capture_any;
            auto it = find_if ( capture.begin(), capture.end(), [&] ( const auto & entry ){
                return entry.name == cV->name;
            });
            if ( it != capture.end() ) {
                mode = it->mode;
            }
            if ( isCaptureAsRef(cV) || mode==CaptureMode::capture_by_reference ) {
                auto varV = new ExprVar(captureAt, cV->name);
                auto addrV = new ExprRef2Ptr(captureAt, varV);
                addrV->alwaysSafe = true;
                auto mV = new MakeFieldDecl(captureAt, cV->name, addrV, false, false);
                ms->push_back(mV);
            } else {
                bool moveS = false;
                bool cloneS = false;
                switch ( mode ) {
                    case CaptureMode::capture_by_clone:     cloneS = true; break;
                    case CaptureMode::capture_by_move:      moveS = true; break;
                    case CaptureMode::capture_any:          moveS = !cV->type->canCopy(); break;
                    default: ;
                }
                auto varV = new ExprVar(captureAt, cV->name);
                auto mV = new MakeFieldDecl(captureAt, cV->name, varV, moveS, cloneS);
                ms->push_back(mV);
            }
            auto & lexpr = ms->back();
            thisProgram->library.foreach([&](Module * mod){
                for ( auto & cm : mod->captureMacros ) {
                    auto cexpr = cm->captureExpression(thisProgram, thisProgram->thisModule.get(), lexpr->value, cV->type);
                    if ( cexpr != nullptr ) {
                        lexpr->value = cexpr;
                    }
                }
                return true;
            },"*");
        }
        makeS->structs.push_back(ms);
        asc->subexpr = makeS;