Changes in src/ResolvExpr/AlternativeFinder.cc [d97c3a4:73ac10e]

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 23:52:08 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Nov  1 21:00:56 2018
-// Update Count     : 35
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Oct -5 10:01:00 2018
+// Update Count     : 34
 //
 
@@ -500 +500 @@
                                 needAssertions[ *assert ].isUsed = true;
                         }
-                }
-        }
+///     needAssertions.insert( needAssertions.end(), (*tyvar)->get_assertions().begin(), (*tyvar)->get_assertions().end() );
+                }
+        }
+
+//      template< typename ForwardIterator, typename OutputIterator >
+//      void inferRecursive( ForwardIterator begin, ForwardIterator end, const Alternative &newAlt, OpenVarSet &openVars, const SymTab::Indexer &decls, const AssertionSet &newNeed, int level, const SymTab::Indexer &indexer, OutputIterator out ) {
+//              if ( newAlt.cost == Cost::infinity ) return; // don't proceed down this dead end
+//              if ( begin == end ) {
+//                      if ( newNeed.empty() ) {
+//                              PRINT(
+//                                      std::cerr << "all assertions satisfied, output alternative: ";
+//                                      newAlt.print( std::cerr );
+//                                      std::cerr << std::endl;
+//                              );
+//                              *out++ = newAlt;
+//                              return;
+//                      } else if ( level >= recursionLimit ) {
+//                              SemanticError( newAlt.expr->location, "Too many recursive assertions" );
+//                      } else {
+//                              AssertionSet newerNeed;
+//                              PRINT(
+//                                      std::cerr << "recursing with new set:" << std::endl;
+//                                      printAssertionSet( newNeed, std::cerr, 8 );
+//                              )
+//                              inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, level+1, indexer, out );
+//                              return;
+//                      }
+//              }
+
+//              ForwardIterator cur = begin++;
+//              if ( ! cur->second.isUsed ) {
+//                      inferRecursive( begin, end, newAlt, openVars, decls, newNeed, level, indexer, out );
+//                      return; // xxx - should this continue? previously this wasn't here, and it looks like it should be
+//              }
+//              DeclarationWithType *curDecl = cur->first;
+
+//              PRINT(
+//                      std::cerr << "inferRecursive: assertion is ";
+//                      curDecl->print( std::cerr );
+//                      std::cerr << std::endl;
+//              )
+//              std::list< SymTab::Indexer::IdData > candidates;
+//              decls.lookupId( curDecl->get_name(), candidates );
+// ///   if ( candidates.empty() ) { std::cerr << "no candidates!" << std::endl; }
+//              for ( const auto & data : candidates ) {
+//                      DeclarationWithType * candidate = data.id;
+//                      PRINT(
+//                              std::cerr << "inferRecursive: candidate is ";
+//                              candidate->print( std::cerr );
+//                              std::cerr << std::endl;
+//                      )
+
+//                      AssertionSet newHave, newerNeed( newNeed );
+//                      TypeEnvironment newEnv( newAlt.env );
+//                      OpenVarSet newOpenVars( openVars );
+//                      Type *adjType = candidate->get_type()->clone();
+//                      adjustExprType( adjType, newEnv, indexer );
+//                      renameTyVars( adjType );
+//                      PRINT(
+//                              std::cerr << "unifying ";
+//                              curDecl->get_type()->print( std::cerr );
+//                              std::cerr << " with ";
+//                              adjType->print( std::cerr );
+//                              std::cerr << std::endl;
+//                      )
+//                      if ( unify( curDecl->get_type(), adjType, newEnv, newerNeed, newHave, newOpenVars, indexer ) ) {
+//                              PRINT(
+//                                      std::cerr << "success!" << std::endl;
+//                              )
+//                              SymTab::Indexer newDecls( decls );
+//                              addToIndexer( newHave, newDecls );
+//                              Alternative newerAlt( newAlt );
+//                              newerAlt.env = newEnv;
+//                              assertf( candidate->get_uniqueId(), "Assertion candidate does not have a unique ID: %s", toString( candidate ).c_str() );
+
+//                              // everything with an empty idChain was pulled in by the current assertion.
+//                              // add current assertion's idChain + current assertion's ID so that the correct inferParameters can be found.
+//                              for ( auto & a : newerNeed ) {
+//                                      if ( a.second.idChain.empty() ) {
+//                                              a.second.idChain = cur->second.idChain;
+//                                              a.second.idChain.push_back( curDecl->get_uniqueId() );
+//                                      }
+//                              }
+
+//                              Expression *varExpr = data.combine( newerAlt.cvtCost );
+//                              delete varExpr->get_result();
+//                              varExpr->set_result( adjType->clone() );
+//                              PRINT(
+//                                      std::cerr << "satisfying assertion " << curDecl->get_uniqueId() << " ";
+//                                      curDecl->print( std::cerr );
+//                                      std::cerr << " with declaration " << candidate->get_uniqueId() << " ";
+//                                      candidate->print( std::cerr );
+//                                      std::cerr << std::endl;
+//                              )
+//                              // follow the current assertion's ID chain to find the correct set of inferred parameters to add the candidate to (i.e. the set of inferred parameters belonging to the entity which requested the assertion parameter).
+//                              InferredParams * inferParameters = &newerAlt.expr->inferParams;
+//                              for ( UniqueId id : cur->second.idChain ) {
+//                                      inferParameters = (*inferParameters)[ id ].inferParams.get();
+//                              }
+//                              // XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions
+//                              (*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( candidate->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
+//                              inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, level, indexer, out );
+//                      } else {
+//                              delete adjType;
+//                      }
+//              }
+//      }
 
         /// Unique identifier for matching expression resolutions to their requesting expression
@@ -508 +613 @@
         template< typename OutputIterator >
         void AlternativeFinder::Finder::inferParameters( Alternative &newAlt, OutputIterator out ) {
+                // SymTab::Indexer decls( indexer );
+                // addToIndexer( have, decls );
+                // AssertionSet newNeed;
+                // PRINT(
+                //      std::cerr << "env is: " << std::endl;
+                //      newAlt.env.print( std::cerr, 0 );
+                //      std::cerr << std::endl;
+                // )
+
+                // inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, 0, indexer, out );
+
                 // Set need bindings for any unbound assertions
                 UniqueId crntResnSlot = 0;  // matching ID for this expression's assertions
@@ -1229 +1345 @@
                                 Alternative newAlt{ 
                                         restructureCast( alt.expr->clone(), toType, castExpr->isGenerated ), 
-                                        alt.env, openVars, needAssertions, alt.cost + thisCost, thisCost };
+                                        alt.env, openVars, needAssertions, alt.cost, thisCost };
                                 inferParameters( newAlt, back_inserter( candidates ) );
                         } // if
@@ -1257 +1373 @@
                 /// Gets name from untyped member expression (member must be NameExpr)
                 const std::string& get_member_name( UntypedMemberExpr *memberExpr ) {
-                        if ( dynamic_cast< ConstantExpr * >( memberExpr->get_member() ) ) {
-                                SemanticError( memberExpr, "Indexed access to struct fields unsupported: " );
-                        } // if
                         NameExpr * nameExpr = dynamic_cast< NameExpr * >( memberExpr->get_member() );
                         assert( nameExpr );