Changes in / [87b5bf0:e64365c]

Files:

• doc/working/resolver_design.md (modified) (1 diff)
• src/ResolvExpr/AlternativeFinder.cc (modified) (7 diffs)

doc/working/resolver_design.md

@@ -1414 +1414 @@
 considered if no match was found in the previous class.
 
+Another source of efficiency would be to cache the best given interpretation 
+of a subexpression within an environment; this may not be incredibly useful 
+for explict parameters (though it may be useful for, e.g. `f( x, x )`, where 
+both parameters of `f` have the same type), but should pay some dividends for 
+the implicit assertion parameters, especially the otype parameters for the 
+argument of a generic type, which will generally be resolved in duplicate for 
+(at least) the assignment operator, constructor, copy constructor & destructor 
+of the generic type. 
+
 ## Appendix A: Partial and Total Orders ##
 The `<=` relation on integers is a commonly known _total order_, and 

src/ResolvExpr/AlternativeFinder.cc

@@ -411 +411 @@
         }
 
-        /// Map of declaration uniqueIds (intended to be the assertions in an AssertionSet) to their parents and the number of times they've been included
-        typedef std::unordered_map< UniqueId, std::unordered_map< UniqueId, unsigned > > AssertionParentSet;
+        // /// Map of declaration uniqueIds (intended to be the assertions in an AssertionSet) to their parents and the number of times they've been included
+        //typedef std::unordered_map< UniqueId, std::unordered_map< UniqueId, unsigned > > AssertionParentSet;
         
-        static const int recursionLimit = 10;  ///< Limit to depth of recursion satisfaction
-        static const unsigned recursionParentLimit = 1;  ///< Limit to the number of times an assertion can recursively use itself
+        static const int recursionLimit = /*10*/ 3;  ///< Limit to depth of recursion satisfaction
+        //static const unsigned recursionParentLimit = 1;  ///< Limit to the number of times an assertion can recursively use itself
 
         void addToIndexer( AssertionSet &assertSet, SymTab::Indexer &indexer ) {
@@ -426 +426 @@
         
         template< typename ForwardIterator, typename OutputIterator >
-        void inferRecursive( ForwardIterator begin, ForwardIterator end, const Alternative &newAlt, OpenVarSet &openVars, const SymTab::Indexer &decls, const AssertionSet &newNeed, const AssertionParentSet &needParents, 
+        void inferRecursive( ForwardIterator begin, ForwardIterator end, const Alternative &newAlt, OpenVarSet &openVars, const SymTab::Indexer &decls, const AssertionSet &newNeed, /*const AssertionParentSet &needParents,*/ 
                                                  int level, const SymTab::Indexer &indexer, OutputIterator out ) {
                 if ( begin == end ) {
@@ -440 +440 @@
                                         printAssertionSet( newNeed, std::cerr, 8 );
                                 )
-                                inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, needParents, level+1, indexer, out );
+                                inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, /*needParents,*/ level+1, indexer, out );
                                 return;
                         }
@@ -447 +447 @@
                 ForwardIterator cur = begin++;
                 if ( ! cur->second ) {
-                        inferRecursive( begin, end, newAlt, openVars, decls, newNeed, needParents, level, indexer, out );
+                        inferRecursive( begin, end, newAlt, openVars, decls, newNeed, /*needParents,*/ level, indexer, out );
                 }
                 DeclarationWithType *curDecl = cur->first;
@@ -488 +488 @@
                                 assert( (*candidate)->get_uniqueId() );
                                 DeclarationWithType *candDecl = static_cast< DeclarationWithType* >( Declaration::declFromId( (*candidate)->get_uniqueId() ) );
-                                AssertionParentSet newNeedParents( needParents );
+                                //AssertionParentSet newNeedParents( needParents );
                                 // skip repeatingly-self-recursive assertion satisfaction
-                                if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
+                                // DOESN'T WORK: grandchild nodes conflict with their cousins
+                                //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
                                 Expression *varExpr = new VariableExpr( candDecl );
                                 deleteAll( varExpr->get_results() );
@@ -505 +506 @@
                                 // XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions
                                 appExpr->get_inferParams()[ curDecl->get_uniqueId() ] = ParamEntry( (*candidate)->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
-                                inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, newNeedParents, level, indexer, out );
+                                inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, /*newNeedParents,*/ level, indexer, out );
                         } else {
                                 delete adjType;
@@ -527 +528 @@
                 addToIndexer( have, decls );
                 AssertionSet newNeed;
-                AssertionParentSet needParents;
-                inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, needParents, 0, indexer, out );
+                //AssertionParentSet needParents;
+                inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, /*needParents,*/ 0, indexer, out );
 //      PRINT(
 //          std::cerr << "declaration 14 is ";