Changeset 1a59641 for src/ResolvExpr/AlternativeFinder.cc

Timestamp:

Jul 27, 2018, 2:41:34 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env

Children:

6fa409e

Parents:

5a3e1f1

Message:

Fix open var handling in BF assn resolution; memory usage reasonable again

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -687 +687 @@
                 /// as appropriate.
                 void bindAssertion( const DeclarationWithType* curDecl, const AssertionSetValue& assnInfo, 
-                                AssertionResnState& resn, AssertionPack&& match ) {
-                        addToIndexer( match.have, resn.indexer );
-                        resn.newNeed.insert( match.need.begin(), match.need.end() );
-                        resn.openVars = std::move(match.openVars);
-                        resn.alt.env = std::move(match.env);
+                                Alternative& alt, AssertionPack& match ) {
 
                         DeclarationWithType* candidate = match.cdata.id;
@@ -702 +698 @@
                         }
 
-                        Expression* varExpr = match.cdata.combine( resn.alt.cvtCost );
+                        Expression* varExpr = match.cdata.combine( alt.cvtCost );
                         varExpr->result = match.adjType;
 
@@ -708 +704 @@
                         // parameters to add the candidate o (i.e. the set of inferred parameters belonging 
                         // to the entity which requested the assertion parameter)
-                        InferredParams* inferParams = &resn.alt.expr->inferParams;
+                        InferredParams* inferParams = &alt.expr->inferParams;
                         for ( UniqueId id : assnInfo.idChain ) {
                                 inferParams = (*inferParams)[ id ].inferParams.get();
@@ -759 +755 @@
 
                         // otherwise bind current match in ongoing scope
-                        bindAssertion( curDecl, assnInfo, resn, std::move(matches.front()) );
+                        AssertionPack& match = matches.front();
+                        addToIndexer( match.have, resn.indexer );
+                        resn.newNeed.insert( match.need.begin(), match.need.end() );
+                        resn.openVars = std::move(match.openVars);
+                        resn.alt.env = std::move(match.env);
+
+                        bindAssertion( curDecl, assnInfo, resn.alt, match );
                         return true;
                 }
@@ -771 +773 @@
                         /// Stack of environments, to support backtracking
                         std::vector<TypeEnvironment> envs;
+                        /// Open variables for environment combination
+                        std::vector<OpenVarSet> varSets;
                         /// Indexer to use for environment merges
                         const SymTab::Indexer& indexer;
                 public:
-                        /// Outputs a pair consisting of the merged environment and the list of interpretations
-                        using OutType = std::pair<TypeEnvironment, std::vector<DeferElement>>;
-
-                        InterpretationEnvMerger( const TypeEnvironment& env, const SymTab::Indexer& indexer ) 
-                                : crnt{}, envs{}, indexer{indexer} { envs.push_back( env ); }
+                        /// The merged environment/open variables and the list of interpretations
+                        struct OutType {
+                                TypeEnvironment env;
+                                OpenVarSet openVars;
+                                std::vector<DeferElement> assns;
+
+                                OutType( const TypeEnvironment& env, const OpenVarSet& openVars, 
+                                        const std::vector<DeferElement>& assns )
+                                        : env(env), openVars(openVars), assns(assns) {}
+                        };
+
+                        InterpretationEnvMerger( const TypeEnvironment& env, const OpenVarSet& openVars, 
+                                const SymTab::Indexer& indexer ) : crnt{}, envs{}, varSets{}, indexer{indexer} {
+                                envs.push_back( env );
+                                varSets.push_back( openVars );
+                        }
 
                         ComboResult append( DeferElement i ) {
                                 TypeEnvironment env = envs.back();
-                                if ( ! env.combine( i.match.env, indexer ) ) return ComboResult::REJECT_THIS;
+                                OpenVarSet openVars = varSets.back();
+                                mergeOpenVars( openVars, i.match.openVars );
+
+                                if ( ! env.combine( i.match.env, openVars, indexer ) )
+                                        return ComboResult::REJECT_THIS;
+                                
                                 crnt.push_back( i );
                                 envs.push_back( env );
+                                varSets.push_back( openVars );
                                 return ComboResult::ACCEPT;
                         }
@@ -791 +812 @@
                                 crnt.pop_back();
                                 envs.pop_back();
-                        }
-
-                        OutType finalize() { return { envs.back(), crnt }; }
+                                varSets.pop_back();
+                        }
+
+                        OutType finalize() { return { envs.back(), varSets.back(), crnt }; }
                 };
         }
@@ -833 +855 @@
 
                                         std::vector<InterpretationEnvMerger::OutType> compatible = filterCombos( 
-                                                resn.deferred, InterpretationEnvMerger{ resn.alt.env, resn.indexer });
+                                                resn.deferred, 
+                                                InterpretationEnvMerger{ resn.alt.env, resn.openVars, resn.indexer } );
                                         
                                         for ( auto& compat : compatible ) {
@@ -839 +862 @@
 
                                                 // add compatible assertions to new resolution state
-                                                for ( DeferElement el : compat.second ) {
-                                                        bindAssertion( 
-                                                                el.curDecl, el.assnInfo, new_resn, AssertionPack{el.match} );
+                                                for ( DeferElement el : compat.assns ) {
+                                                        AssertionPack match = el.match;
+                                                        addToIndexer( match.have, new_resn.indexer );
+                                                        resn.newNeed.insert( match.need.begin(), match.need.end() );
+                                                        
+                                                        bindAssertion( el.curDecl, el.assnInfo, new_resn.alt, match );
                                                 }
 
                                                 // set mutual environment into resolution state
-                                                new_resn.alt.env = std::move(compat.first);
+                                                new_resn.alt.env = std::move(compat.env);
+                                                new_resn.openVars = std::move(compat.openVars);
 
                                                 // add successful match or push back next state