Changeset 4b6ef70 for src/ResolvExpr

Timestamp:

Oct 20, 2017, 11:45:53 AM (8 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:

1fdfc23

Parents:

b5a8ef7

Message:

Fix one tuple bug in resolver refactor

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -564 +564 @@
         /// State to iteratively build a match of parameter expressions to arguments
         struct ArgPack {
-                AltList actuals;      ///< Arguments included in this pack
-                TypeEnvironment env;  ///< Environment for this pack
-                AssertionSet need;    ///< Assertions outstanding for this pack
-                AssertionSet have;    ///< Assertions found for this pack
-                OpenVarSet openVars;  ///< Open variables for this pack
-                unsigned nextArg;     ///< Index of next argument in arguments list
-                
-                /// Number of elements included in current tuple element (nested appropriately)
-                std::vector<unsigned> tupleEls;
+                AltList actuals;                 ///< Arguments included in this pack
+                TypeEnvironment env;             ///< Environment for this pack
+                AssertionSet need;               ///< Assertions outstanding for this pack
+                AssertionSet have;               ///< Assertions found for this pack
+                OpenVarSet openVars;             ///< Open variables for this pack
+                unsigned nextArg;                ///< Index of next argument in arguments list
+                std::vector<Alternative> expls;  ///< Exploded actuals left over from last match
+                unsigned nextExpl;               ///< Index of next exploded alternative to use
+                std::vector<unsigned> tupleEls;  /// Number of elements in current tuple element(s)
 
                 ArgPack(const TypeEnvironment& env, const AssertionSet& need, const AssertionSet& have, 
                                 const OpenVarSet& openVars)
                         : actuals(), env(env), need(need), have(have), openVars(openVars), nextArg(0),
-                          tupleEls() {}
+                          expls(), nextExpl(0), tupleEls() {}
                 
                 ArgPack(const ArgPack& old, Expression* actual, TypeEnvironment&& env, 
@@ -623 +623 @@
                         actuals.emplace_back( new TupleExpr( exprs ), this->env, cost );
                 }
+
+                /// Clones and adds an actual, returns this
+                ArgPack& withArg( Expression* expr ) {
+                        actuals.emplace_back( expr->clone(), this->env, Cost::zero );
+                        if ( ! tupleEls.empty() ) ++tupleEls.back();
+                        return *this;
+                }
         };
-
-        /// Iterates a result, exploding actuals as needed.
-        /// add is a function that takes the same parameters as this (with the exception of add)
-        template<typename F>
-        void addExplodedActual( ArgPack& result, Expression* expr, Cost cost, 
-                        std::vector<ArgPack>& nextResults, F add ) {
-                Type* res = expr->get_result()->stripReferences();
-                if ( TupleType* tupleType = dynamic_cast<TupleType*>( res ) ) {
-                        if ( TupleExpr* tupleExpr = dynamic_cast<TupleExpr*>( expr ) ) {
-                                // recursively explode tuple
-                                for ( Expression* sexpr : tupleExpr->get_exprs() ) {
-                                        addExplodedActual( result, sexpr, cost, nextResults, add );
-                                        cost = Cost::zero; // reset cost so not duplicated
-                                }
-                        } else {
-                                // tuple type, but not tuple expr - recursively index into components.
-                                // if expr type is reference, convert to value type
-                                Expression* arg = expr->clone();
-                                if ( Tuples::maybeImpureIgnoreUnique( arg ) ) {
-                                        // expressions which may contain side effects require a single unique instance of the expression.
-                                        arg = new UniqueExpr( arg );
-                                }
-                                // cast reference to value type to facilitate further explosion
-                                if ( dynamic_cast<ReferenceType*>( arg->get_result() ) ) {
-                                        arg = new CastExpr( arg, tupleType->clone() );
-                                }
-                                // explode tuple by index
-                                for ( unsigned i = 0; i < tupleType->size(); ++i ) {
-                                        TupleIndexExpr* idx = new TupleIndexExpr( arg->clone(), i );
-                                        addExplodedActual( result, idx, cost, nextResults, add );
-                                        cost = Cost::zero; // reset cost so not duplicated
-                                        delete idx;
-                                }
-                                delete arg;
-                        }
-                } else {
-                        // add non-tuple results directly
-                        add( result, expr->clone(), cost, nextResults );
-                }
-        }
 
         /// Instantiates an argument to match a formal, returns false if no results left
@@ -716 +683 @@
                                         // add each possible next argument
                                         for ( const Alternative& actual : args[result.nextArg] ) {
-                                                addExplodedActual( result, actual.expr, actual.cost, nextResults, 
-                                                        [&actual]( ArgPack& result, Expression* expr, Cost cost, 
-                                                                        std::vector<ArgPack>& nextResults ) {
-                                                                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 );
-                                                        } );
+                                                ArgPack aResult = result;  // copy to clone everything
+                                                // add details of actual to result
+                                                aResult.env.addActual( actual.env, aResult.openVars );
+                
+                                                // explode argument
+                                                std::vector<Alternative> exploded;
+                                                Tuples::explode( actual, indexer, back_inserter( exploded ) );
+                                                
+                                                // add exploded argument to tuple
+                                                for ( Alternative& aActual : exploded ) {
+                                                        aResult.withArg( aActual.expr );
+                                                }
+                                                ++aResult.nextArg;
+                                                nextResults.push_back( std::move(aResult) );
                                         }
                                 }
@@ -737 +709 @@
                 
                 // iterate each current subresult
-                for ( ArgPack& result : results ) {
-                        if ( result.nextArg >= args.size() ) {
-                                // If run out of actuals, handle default values
+                for ( unsigned iResult = 0; iResult < results.size(); ++iResult ) {
+                        ArgPack& result = results[iResult];
+
+                        if ( result.nextExpl < result.expls.size() ) {
+                                // use remainder of exploded tuple if present
+                                const Alternative& actual = result.expls[result.nextExpl];
+                                result.env.addActual( actual.env, result.openVars );
+                                Type* actualType = actual.expr->get_result();
+
+                                PRINT(
+                                        std::cerr << "formal type is ";
+                                        formalType->print( std::cerr );
+                                        std::cerr << std::endl << "actual type is ";
+                                        actualType->print( std::cerr );
+                                        std::cerr << std::endl;
+                                )
+                                
+                                if ( unify( formalType, actualType, result.env, result.need, result.have, 
+                                                result.openVars, indexer ) ) {
+                                        ++result.nextExpl;
+                                        nextResults.push_back( std::move(result.withArg( actual.expr )) );
+                                }
+
+                                continue;
+                        } else if ( result.nextArg >= args.size() ) {
+                                // use default initializers if out of arguments
                                 if ( ConstantExpr* cnstExpr = getDefaultValue( initializer ) ) {
                                         if ( Constant* cnst = dynamic_cast<Constant*>( cnstExpr->get_constant() ) ) {
-                                                TypeEnvironment resultEnv = result.env;
-                                                AssertionSet resultNeed = result.need, resultHave = result.have;
-                                                if ( unify( formalType, cnst->get_type(), 
-                                                                resultEnv, resultNeed, resultHave, result.openVars, 
-                                                                indexer ) ) {
-                                                        nextResults.emplace_back( result, cnstExpr->clone(), 
-                                                                std::move(resultEnv), std::move(resultNeed), 
-                                                                std::move(resultHave), OpenVarSet{ result.openVars } );
+                                                if ( unify( formalType, cnst->get_type(), result.env, result.need, 
+                                                                result.have, result.openVars, indexer ) ) {
+                                                        nextResults.push_back( std::move(result.withArg( cnstExpr )) );
                                                 }
                                         }
@@ -758 +748 @@
                         // Check each possible next argument
                         for ( const Alternative& actual : args[result.nextArg] ) {
-                                addExplodedActual( result, actual.expr, actual.cost, nextResults, 
-                                        [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(
-                                                        std::cerr << "formal type is ";
-                                                        formalType->print( std::cerr );
-                                                        std::cerr << std::endl << "actual type is ";
-                                                        actualType->print( std::cerr );
-                                                        std::cerr << std::endl;
-                                                )
-
-                                                if ( unify( formalType, actualType, resultEnv, resultNeed, resultHave, 
-                                                                resultOpenVars, indexer ) ) {
-                                                        nextResults.emplace_back( result, expr->clone(), 
-                                                                std::move(resultEnv), std::move(resultNeed), std::move(resultHave),
-                                                                std::move(resultOpenVars), cost );
-                                                }
-                                        } );
+                                ArgPack aResult = result;  // copy to clone everything
+                                // add details of actual to result
+                                aResult.env.addActual( actual.env, aResult.openVars );
+
+                                // explode argument
+                                std::vector<Alternative> exploded;
+                                Tuples::explode( actual, indexer, back_inserter( exploded ) );
+                                if ( exploded.empty() ) {
+                                        // skip empty tuple arguments
+                                        ++aResult.nextArg;
+                                        results.push_back( std::move(aResult) );
+                                        continue;
+                                }
+
+                                // consider only first exploded actual
+                                const Alternative& aActual = exploded.front();
+                                Type* actualType = aActual.expr->get_result();
+
+                                PRINT(
+                                        std::cerr << "formal type is ";
+                                        formalType->print( std::cerr );
+                                        std::cerr << std::endl << "actual type is ";
+                                        actualType->print( std::cerr );
+                                        std::cerr << std::endl;
+                                )
+
+                                // attempt to unify types
+                                if ( unify( formalType, actualType, aResult.env, aResult.need, aResult.have, aResult.openVars, indexer ) ) {
+                                        // add argument
+                                        aResult.withArg( aActual.expr );
+                                        if ( exploded.size() == 1 ) {
+                                                // argument consumed
+                                                ++aResult.nextArg;
+                                        } else {
+                                                // other parts of tuple left over
+                                                aResult.expls = std::move( exploded );
+                                                aResult.nextExpl = 1;
+                                        }
+                                        nextResults.push_back( std::move(aResult) );
+                                }
                         }
                 }