Changeset d551d0a


Ignore:
Timestamp:
Oct 20, 2017, 4:48:05 PM (4 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
76a395a
Parents:
1fdfc23
Message:

Fix one use-after-free in resolver refactor

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/ResolvExpr/AlternativeFinder.cc

    r1fdfc23 rd551d0a  
    579579                          expls(), nextExpl(0), tupleEls() {}
    580580               
    581                 ArgPack(const ArgPack& old, Expression* actual, TypeEnvironment&& env,
    582                                 OpenVarSet&& openVars, const Cost& cost = Cost::zero)
    583                         : actuals(old.actuals), env(std::move(env)), need(old.need), have(old.have),
    584                           openVars(std::move(openVars)), nextArg(old.nextArg + 1), tupleEls(old.tupleEls) {
    585                         // add new actual
    586                         actuals.emplace_back( actual, this->env, cost );
    587                         // count tuple elements, if applicable
    588                         if ( ! tupleEls.empty() ) ++tupleEls.back();
    589                 }
    590                
    591                 ArgPack(const ArgPack& old, Expression* actual, TypeEnvironment&& env, AssertionSet&& need,
    592                                 AssertionSet&& have, OpenVarSet&& openVars, const Cost& cost = Cost::zero)
    593                         : actuals(old.actuals), env(std::move(env)), need(std::move(need)),
    594                           have(std::move(have)), openVars(std::move(openVars)), nextArg(old.nextArg + 1),
    595                           tupleEls(old.tupleEls) {
    596                         // add new actual
    597                         actuals.emplace_back( actual, this->env, cost );
    598                         // count tuple elements, if applicable
    599                         if ( ! tupleEls.empty() ) ++tupleEls.back();
    600                 }
    601 
    602581                /// Starts a new tuple expression
    603582                void beginTuple() {
     
    676655                                                if ( unify( ttype, argType, result.env, result.need, result.have,
    677656                                                                result.openVars, indexer ) ) {
    678                                                         finalResults.emplace_back( std::move(result) );
     657                                                        finalResults.push_back( std::move(result) );
    679658                                                }
    680659                                                continue;
     
    766745                                // consider only first exploded actual
    767746                                const Alternative& aActual = exploded.front();
    768                                 Type* actualType = aActual.expr->get_result();
     747                                Type* actualType = aActual.expr->get_result()->clone();
    769748
    770749                                PRINT(
     
    840819                                        // keep if used all arguments
    841820                                        if ( result.nextArg >= args.size() ) {
    842                                                 finalResults.emplace_back( std::move(result) );
     821                                                finalResults.push_back( std::move(result) );
    843822                                                continue;
    844823                                        }
     
    846825                                        // add each possible next argument
    847826                                        for ( const Alternative& actual : args[result.nextArg] ) {
    848                                                 TypeEnvironment env{ result.env };
    849                                                 OpenVarSet openVars{ result.openVars };
    850                                                 env.addActual( actual.env, openVars );
    851                                                 nextResults.emplace_back( result, actual.expr->clone(), std::move(env),
    852                                                         std::move(openVars), actual.cost );
     827                                                ArgPack aResult = result; // copy to clone everything
     828                                                // add details of actual to result
     829                                                aResult.env.addActual( actual.env, aResult.openVars );
     830                                                Cost cost = actual.cost;
     831
     832                                                // explode argument
     833                                                std::vector<Alternative> exploded;
     834                                                Tuples::explode( actual, indexer, back_inserter( exploded ) );
     835
     836                                                // add exploded argument to arg list
     837                                                for ( Alternative& aActual : exploded ) {
     838                                                        aResult.withArg( aActual.expr, cost );
     839                                                        cost = Cost::zero;
     840                                                }
     841                                                ++aResult.nextArg;
     842                                                nextResults.push_back( std::move(aResult) );
    853843                                        }
    854844                                }
     
    862852                        for ( ArgPack& result : results ) {
    863853                                if ( result.nextArg >= args.size() ) {
    864                                         finalResults.emplace_back( std::move(result) );
     854                                        finalResults.push_back( std::move(result) );
    865855                                }
    866856                        }
Note: See TracChangeset for help on using the changeset viewer.