Changeset a585396 for src

Timestamp:

Oct 5, 2017, 1:36:59 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:

c43c171

Parents:

e472d54

Message:

Fix missing environment/open vars update in iterative resolver

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (7 diffs)
• TypeEnvironment.cc (modified) (1 diff)
• TypeEnvironment.h (modified) (1 diff)

src/ResolvExpr/AlternativeFinder.cc

@@ -579 +579 @@
                           tupleEls() {}
                 
-                ArgPack(const ArgPack& old, Expression* actual, const Cost& cost = Cost::zero)
-                        : actuals(old.actuals), env(old.env), need(old.need), have(old.have), 
-                          openVars(old.openVars), nextArg(old.nextArg + 1), tupleEls(old.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, const Cost& cost = Cost::zero)
+                                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(old.openVars), nextArg(old.nextArg + 1), 
+                          have(std::move(have)), openVars(std::move(openVars)), nextArg(old.nextArg + 1), 
                           tupleEls(old.tupleEls) {
                         // add new actual
@@ -713 +717 @@
                                         for ( const Alternative& actual : args[result.nextArg] ) {
                                                 addExplodedActual( result, actual.expr, actual.cost, nextResults, 
-                                                        []( ArgPack& result, Expression* expr, Cost cost, 
+                                                        [&actual]( ArgPack& result, Expression* expr, Cost cost, 
                                                                         std::vector<ArgPack>& nextResults ) {
-                                                                nextResults.emplace_back( result, expr, cost );
+                                                                TypeEnvironment env{ result.env };
+                                                                OpenVarSet openVars{ result.openVars };
+                                                                env.addActual( actual.env, openVars );
+                                                                nextResults.emplace_back( result, expr, std::move(env), 
+                                                                        std::move(openVars), cost );
                                                         } );
                                         }
@@ -741 +749 @@
                                                         nextResults.emplace_back( result, cnstExpr->clone(), 
                                                                 std::move(resultEnv), std::move(resultNeed), 
-                                                                std::move(resultHave) );
+                                                                std::move(resultHave), OpenVarSet{ result.openVars } );
                                                 }
                                         }
@@ -751 +759 @@
                         for ( const Alternative& actual : args[result.nextArg] ) {
                                 addExplodedActual( result, actual.expr, actual.cost, nextResults, 
-                                        [formalType,&indexer]( ArgPack& result, Expression* expr, Cost cost, 
+                                        [formalType,&indexer,&actual]( ArgPack& result, Expression* expr, Cost cost, 
                                                         std::vector<ArgPack>& nextResults ) {
                                                 // attempt to unify actual with parameter
                                                 TypeEnvironment resultEnv = result.env;
                                                 AssertionSet resultNeed = result.need, resultHave = result.have;
+                                                OpenVarSet resultOpenVars = result.openVars;
+                                                resultEnv.addActual( actual.env, resultOpenVars );
                                                 Type* actualType = expr->get_result();
+
 
                                                 PRINT(
@@ -767 +778 @@
 
                                                 if ( unify( formalType, actualType, resultEnv, resultNeed, resultHave, 
-                                                                result.openVars, indexer ) ) {
+                                                                resultOpenVars, indexer ) ) {
                                                         nextResults.emplace_back( result, expr->clone(), 
                                                                 std::move(resultEnv), std::move(resultNeed), std::move(resultHave),
-                                                                cost );
+                                                                std::move(resultOpenVars), cost );
                                                 }
                                         } );
@@ -829 +840 @@
                                         // add each possible next argument
                                         for ( const Alternative& actual : args[result.nextArg] ) {
-                                                nextResults.emplace_back( result, actual.expr, actual.cost );
+                                                TypeEnvironment env{ result.env };
+                                                OpenVarSet openVars{ result.openVars };
+                                                env.addActual( actual.env, openVars );
+                                                nextResults.emplace_back( result, actual.expr, std::move(env), 
+                                                        std::move(openVars), actual.cost );
                                         }
                                 }
@@ -1368 +1383 @@
                 findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), back_inserter( subExprAlternatives ) );
                 std::list< AltList > possibilities;
+                // TODO re-write to use iterative method
                 combos( subExprAlternatives.begin(), subExprAlternatives.end(), back_inserter( possibilities ) );
                 for ( std::list< AltList >::const_iterator i = possibilities.begin(); i != possibilities.end(); ++i ) {

src/ResolvExpr/TypeEnvironment.cc

@@ -201 +201 @@
         }
 
+        void TypeEnvironment::addActual( const TypeEnvironment& actualEnv, OpenVarSet& openVars ) {
+                for ( const EqvClass& c : actualEnv ) {
+                        EqvClass c2 = c;
+                        c2.allowWidening = false;
+                        for ( const std::string& var : c2.vars ) {
+                                openVars[ var ] = c2.data;
+                        }
+                        env.push_back( std::move(c2) );
+                }
+        }
+
 } // namespace ResolvExpr
 

src/ResolvExpr/TypeEnvironment.h

@@ -86 +86 @@
                 TypeEnvironment *clone() const { return new TypeEnvironment( *this ); }
 
+                /// Iteratively adds the environment of a new actual (with allowWidening = false), 
+                /// and extracts open variables.
+                void addActual( const TypeEnvironment& actualEnv, OpenVarSet& openVars );
+
                 typedef std::list< EqvClass >::iterator iterator;
                 iterator begin() { return env.begin(); }