Ignore:
Timestamp:
Nov 23, 2017, 4:24:48 PM (7 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
178e4ec
Parents:
a8b27c6
Message:

Reduce duplication of cost/env in ExplodedActual?

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/ResolvExpr/AlternativeFinder.cc

    ra8b27c6 r62194cb  
    676676                                        auto nextArg = results[i].nextArg;
    677677
    678                                         // use remainder of exploded tuple if present
     678                                        // use next element of exploded tuple if present
    679679                                        if ( results[i].hasExpl() ) {
    680680                                                const ExplodedActual& expl = results[i].getExpl( args );
    681                                                 const Alternative& actual = expl.alts[results[i].nextExpl];
    682681                                               
    683                                                 TypeEnvironment env = results[i].env;
    684                                                 OpenVarSet openVars = results[i].openVars;
    685 
    686                                                 env.addActual( actual.env, openVars );
    687 
    688682                                                unsigned nextExpl = results[i].nextExpl + 1;
    689                                                 if ( nextExpl == expl.alts.size() ) {
     683                                                if ( nextExpl == expl.exprs.size() ) {
    690684                                                        nextExpl = 0;
    691685                                                }
    692686
    693687                                                results.emplace_back(
    694                                                         i, actual.expr, move(env), copy(results[i].need),
    695                                                         copy(results[i].have), move(openVars), nextArg, nTuples,
    696                                                         Cost::zero, nextExpl, results[i].explAlt );
     688                                                        i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
     689                                                        copy(results[i].need), copy(results[i].have),
     690                                                        copy(results[i].openVars), nextArg, nTuples, Cost::zero, nextExpl,
     691                                                        results[i].explAlt );
    697692                                               
    698693                                                continue;
    … …  
    758753
    759754                                                // skip empty tuple arguments by (near-)cloning parent into next gen
    760                                                 if ( expl.alts.empty() ) {
     755                                                if ( expl.exprs.empty() ) {
    761756                                                        results.emplace_back(
    762757                                                                results[i], move(env), copy(results[i].need),
    … …  
    768763                                                // add new result
    769764                                                results.emplace_back(
    770                                                         i, expl.alts.front().expr, move(env), copy(results[i].need),
     765                                                        i, expl.exprs.front().get(), move(env), copy(results[i].need),
    771766                                                        copy(results[i].have), move(openVars), nextArg + 1,
    772                                                         nTuples, expl.cost, expl.alts.size() == 1 ? 0 : 1, j );
     767                                                        nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    773768                                        }
    774769                                }
    … …  
    794789                        if ( results[i].hasExpl() ) {
    795790                                const ExplodedActual& expl = results[i].getExpl( args );
    796                                 const Alternative& actual = expl.alts[results[i].nextExpl];
     791                                Expression* expr = expl.exprs[results[i].nextExpl].get();
    797792                               
    798793                                TypeEnvironment env = results[i].env;
    … …  
    800795                                OpenVarSet openVars = results[i].openVars;
    801796
    802                                 env.addActual( actual.env, openVars );
    803                                 Type* actualType = actual.expr->get_result();
     797                                Type* actualType = expr->get_result();
    804798
    805799                                PRINT(
    … …  
    813807                                if ( unify( formalType, actualType, env, need, have, openVars, indexer ) ) {
    814808                                        unsigned nextExpl = results[i].nextExpl + 1;
    815                                         if ( nextExpl == expl.alts.size() ) {
     809                                        if ( nextExpl == expl.exprs.size() ) {
    816810                                                nextExpl = 0;
    817811                                        }
    818812                                       
    819813                                        results.emplace_back(
    820                                                 i, actual.expr, move(env), move(need), move(have), move(openVars),
    821                                                 nextArg, nTuples, Cost::zero, nextExpl, results[i].explAlt );
     814                                                i, expr, move(env), move(need), move(have), move(openVars), nextArg,
     815                                                nTuples, Cost::zero, nextExpl, results[i].explAlt );
    822816                                }
    823817
    … …  
    857851                               
    858852                                // skip empty tuple arguments by (near-)cloning parent into next gen
    859                                 if ( expl.alts.empty() ) {
     853                                if ( expl.exprs.empty() ) {
    860854                                        results.emplace_back(
    861855                                                results[i], move(env), move(need), move(have), move(openVars),
    … …  
    866860
    867861                                // consider only first exploded actual
    868                                 const Alternative& actual = expl.alts.front();
    869                                 Type* actualType = actual.expr->get_result()->clone();
     862                                Expression* expr = expl.exprs.front().get();
     863                                Type* actualType = expr->get_result()->clone();
    870864
    871865                                PRINT(
    … …  
    881875                                        // add new result
    882876                                        results.emplace_back(
    883                                                 i, actual.expr, move(env), move(need), move(have), move(openVars),
    884                                                 nextArg + 1, nTuples, expl.cost, expl.alts.size() == 1 ? 0 : 1, j );
     877                                                i, expr, move(env), move(need), move(have), move(openVars), nextArg + 1,
     878                                                nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    885879                                }
    886880                        }
    … …  
    962956                                        if ( results[i].hasExpl() ) {
    963957                                                const ExplodedActual& expl = results[i].getExpl( args );
    964                                                 const Alternative& actual = expl.alts[results[i].nextExpl];
    965958                                               
    966                                                 TypeEnvironment env = results[i].env;
    967                                                 OpenVarSet openVars = results[i].openVars;
    968 
    969                                                 env.addActual( actual.env, openVars );
    970 
    971959                                                unsigned nextExpl = results[i].nextExpl + 1;
    972                                                 if ( nextExpl == expl.alts.size() ) {
     960                                                if ( nextExpl == expl.exprs.size() ) {
    973961                                                        nextExpl = 0;
    974962                                                }
    975963
    976964                                                results.emplace_back(
    977                                                         i, actual.expr, move(env), copy(results[i].need),
    978                                                         copy(results[i].have), move(openVars), nextArg, 0,
    979                                                         Cost::zero, nextExpl, results[i].explAlt );
     965                                                        i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
     966                                                        copy(results[i].need), copy(results[i].have),
     967                                                        copy(results[i].openVars), nextArg, 0, Cost::zero, nextExpl,
     968                                                        results[i].explAlt );
    980969                                               
    981970                                                continue;
    … …  
    1000989
    1001990                                                // skip empty tuple arguments by (near-)cloning parent into next gen
    1002                                                 if ( expl.alts.empty() ) {
     991                                                if ( expl.exprs.empty() ) {
    1003992                                                        results.emplace_back(
    1004993                                                                results[i], move(env), copy(results[i].need),
    … …  
    1010999                                                // add new result
    10111000                                                results.emplace_back(
    1012                                                         i, expl.alts.front().expr, move(env), copy(results[i].need),
     1001                                                        i, expl.exprs.front().get(), move(env), copy(results[i].need),
    10131002                                                        copy(results[i].have), move(openVars), nextArg + 1, 0,
    1014                                                         expl.cost, expl.alts.size() == 1 ? 0 : 1, j );
     1003                                                        expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
    10151004                                        }
    10161005                                }
Note: See TracChangeset for help on using the changeset viewer.