Changeset d551d0a for src/ResolvExpr/AlternativeFinder.cc

Timestamp:

Oct 20, 2017, 4:48:05 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:

76a395a

Parents:

1fdfc23

Message:

Fix one use-after-free in resolver refactor

File:

• src/ResolvExpr/AlternativeFinder.cc (modified) (6 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -579 +579 @@
                           expls(), nextExpl(0), tupleEls() {}
                 
-                ArgPack(const ArgPack& old, Expression* actual, TypeEnvironment&& env, 
-                                OpenVarSet&& openVars, const Cost& cost = Cost::zero)
-                        : actuals(old.actuals), env(std::move(env)), need(old.need), have(old.have), 
-                          openVars(std::move(openVars)), nextArg(old.nextArg + 1), tupleEls(old.tupleEls) {
-                        // add new actual
-                        actuals.emplace_back( actual, this->env, cost );
-                        // count tuple elements, if applicable
-                        if ( ! tupleEls.empty() ) ++tupleEls.back();
-                }
-                
-                ArgPack(const ArgPack& old, Expression* actual, TypeEnvironment&& env, AssertionSet&& need, 
-                                AssertionSet&& have, OpenVarSet&& openVars, const Cost& cost = Cost::zero)
-                        : actuals(old.actuals), env(std::move(env)), need(std::move(need)), 
-                          have(std::move(have)), openVars(std::move(openVars)), nextArg(old.nextArg + 1), 
-                          tupleEls(old.tupleEls) {
-                        // add new actual
-                        actuals.emplace_back( actual, this->env, cost );
-                        // count tuple elements, if applicable
-                        if ( ! tupleEls.empty() ) ++tupleEls.back();
-                }
-
                 /// Starts a new tuple expression
                 void beginTuple() {
@@ -676 +655 @@
                                                 if ( unify( ttype, argType, result.env, result.need, result.have, 
                                                                 result.openVars, indexer ) ) {
-                                                        finalResults.emplace_back( std::move(result) );
+                                                        finalResults.push_back( std::move(result) );
                                                 }
                                                 continue;
@@ -766 +745 @@
                                 // consider only first exploded actual
                                 const Alternative& aActual = exploded.front();
-                                Type* actualType = aActual.expr->get_result();
+                                Type* actualType = aActual.expr->get_result()->clone();
 
                                 PRINT(
@@ -840 +819 @@
                                         // keep if used all arguments
                                         if ( result.nextArg >= args.size() ) {
-                                                finalResults.emplace_back( std::move(result) );
+                                                finalResults.push_back( std::move(result) );
                                                 continue;
                                         }
@@ -846 +825 @@
                                         // add each possible next argument
                                         for ( const Alternative& actual : args[result.nextArg] ) {
-                                                TypeEnvironment env{ result.env };
-                                                OpenVarSet openVars{ result.openVars };
-                                                env.addActual( actual.env, openVars );
-                                                nextResults.emplace_back( result, actual.expr->clone(), std::move(env), 
-                                                        std::move(openVars), actual.cost );
+                                                ArgPack aResult = result; // copy to clone everything
+                                                // add details of actual to result
+                                                aResult.env.addActual( actual.env, aResult.openVars );
+                                                Cost cost = actual.cost;
+
+                                                // explode argument
+                                                std::vector<Alternative> exploded;
+                                                Tuples::explode( actual, indexer, back_inserter( exploded ) );
+
+                                                // add exploded argument to arg list
+                                                for ( Alternative& aActual : exploded ) {
+                                                        aResult.withArg( aActual.expr, cost );
+                                                        cost = Cost::zero;
+                                                }
+                                                ++aResult.nextArg;
+                                                nextResults.push_back( std::move(aResult) );
                                         }
                                 }
@@ -862 +852 @@
                         for ( ArgPack& result : results ) {
                                 if ( result.nextArg >= args.size() ) {
-                                        finalResults.emplace_back( std::move(result) );
+                                        finalResults.push_back( std::move(result) );
                                 }
                         }