Changes in src/ResolvExpr/AlternativeFinder.cc [25fcb84:00ac42e]

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -102 +102 @@
                 void addAnonConversions( const Alternative & alt );
                 /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
-                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
+                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name );
                 /// Adds alternatives for member expressions where the left side has tuple type
                 void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
@@ -307 +307 @@
 
                 if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->result ) ) {
-                        NameExpr nameExpr( "" );
-                        addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
+                        addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, "" );
                 } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->result ) ) {
-                        NameExpr nameExpr( "" );
-                        addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
+                        addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, "" );
                 } // if
         }
 
         template< typename StructOrUnionType >
-        void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
-                // by this point, member must be a name expr
-                NameExpr * nameExpr = dynamic_cast< NameExpr * >( member );
-                if ( ! nameExpr ) return;
-                const std::string & name = nameExpr->name;
+        void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name ) {
                 std::list< Declaration* > members;
                 aggInst->lookup( name, members );
 
-                for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) {
-                        if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( *i ) ) {
-                                alternatives.push_back( Alternative( new MemberExpr( dwt, expr->clone() ), env, newCost ) );
-                                renameTypes( alternatives.back().expr );
-                                addAnonConversions( alternatives.back() ); // add anonymous member interpretations whenever an aggregate value type is seen as a member expression.
+                for ( Declaration * decl : members ) {
+                        if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( decl ) ) {
+                                // addAnonAlternatives uses vector::push_back, which invalidates references to existing elements, so
+                                // can't construct in place and use vector::back
+                                Alternative newAlt( new MemberExpr( dwt, expr->clone() ), env, newCost );
+                                renameTypes( newAlt.expr );
+                                addAnonConversions( newAlt ); // add anonymous member interpretations whenever an aggregate value type is seen as a member expression.
+                                alternatives.push_back( std::move(newAlt) );
                         } else {
                                 assert( false );
@@ -469 +466 @@
         }
 
-        // /// 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*/ 4;  ///< 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 ) {
@@ -484 +477 @@
 
         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,*/
-                                                 int level, const SymTab::Indexer &indexer, OutputIterator out ) {
+        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 ( begin == end ) {
                         if ( newNeed.empty() ) {
@@ -503 +495 @@
                                         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, level+1, indexer, out );
                                 return;
                         }
@@ -510 +502 @@
                 ForwardIterator cur = begin++;
                 if ( ! cur->second.isUsed ) {
-                        inferRecursive( begin, end, newAlt, openVars, decls, newNeed, /*needParents,*/ level, indexer, out );
+                        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
                 }
@@ -563 +555 @@
                                 }
 
-                                //AssertionParentSet newNeedParents( needParents );
-                                // skip repeatingly-self-recursive assertion satisfaction
-                                // DOESN'T WORK: grandchild nodes conflict with their cousins
-                                //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
-
                                 Expression *varExpr = data.combine( newerAlt.cvtCost );
                                 delete varExpr->get_result();
@@ -585 +572 @@
                                 // 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, /*newNeedParents,*/ level, indexer, out );
+                                inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, level, indexer, out );
                         } else {
                                 delete adjType;
@@ -607 +594 @@
                 addToIndexer( have, decls );
                 AssertionSet newNeed;
-                //AssertionParentSet needParents;
                 PRINT(
                         std::cerr << "env is: " << std::endl;
@@ -614 +600 @@
                 )
 
-                inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, /*needParents,*/ 0, indexer, out );
+                inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, 0, indexer, out );
 //      PRINT(
 //          std::cerr << "declaration 14 is ";
@@ -1093 +1079 @@
                 AlternativeFinder funcOpFinder( indexer, env );
                 // it's ok if there aren't any defined function ops
-                funcOpFinder.maybeFind( opExpr);
+                funcOpFinder.maybeFind( opExpr );
                 PRINT(
                         std::cerr << "known function ops:" << std::endl;
@@ -1130 +1116 @@
                                         }
                                 } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( func->expr->result->stripReferences() ) ) { // handle ftype (e.g. *? on function pointer)
-                                        EqvClass eqvClass;
-                                        if ( func->env.lookup( typeInst->name, eqvClass ) && eqvClass.type ) {
-                                                if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
+                                        if ( const EqvClass *eqvClass = func->env.lookup( typeInst->name ) ) {
+                                                if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass->type ) ) {
                                                         Alternative newFunc( *func );
                                                         referenceToRvalueConversion( newFunc.expr, newFunc.cost );
@@ -1347 +1332 @@
         }
 
+        namespace {
+                /// Gets name from untyped member expression (member must be NameExpr)
+                const std::string& get_member_name( UntypedMemberExpr *memberExpr ) {
+                        NameExpr * nameExpr = dynamic_cast< NameExpr * >( memberExpr->get_member() );
+                        assert( nameExpr );
+                        return nameExpr->get_name();
+                }
+        }
+
         void AlternativeFinder::Finder::postvisit( UntypedMemberExpr *memberExpr ) {
                 AlternativeFinder funcFinder( indexer, env );
@@ -1359 +1353 @@
                         // find member of the given type
                         if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
-                                addAggMembers( structInst, aggrExpr, cost, agg->env, memberExpr->get_member() );
+                                addAggMembers( structInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) );
                         } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
-                                addAggMembers( unionInst, aggrExpr, cost, agg->env, memberExpr->get_member() );
+                                addAggMembers( unionInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) );
                         } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( aggrExpr->get_result() ) ) {
                                 addTupleMembers( tupleType, aggrExpr, cost, agg->env, memberExpr->get_member() );
@@ -1379 +1373 @@
                         Cost cost = Cost::zero;
                         Expression * newExpr = data.combine( cost );
-                        alternatives.push_back( Alternative( newExpr, env, Cost::zero, cost ) );
+
+                        // addAnonAlternatives uses vector::push_back, which invalidates references to existing elements, so
+                        // can't construct in place and use vector::back
+                        Alternative newAlt( newExpr, env, Cost::zero, cost );
                         PRINT(
                                 std::cerr << "decl is ";
@@ -1388 +1385 @@
                                 std::cerr << std::endl;
                         )
-                        renameTypes( alternatives.back().expr );
-                        addAnonConversions( alternatives.back() ); // add anonymous member interpretations whenever an aggregate value type is seen as a name expression.
+                        renameTypes( newAlt.expr );
+                        addAnonConversions( newAlt ); // add anonymous member interpretations whenever an aggregate value type is seen as a name expression.
+                        alternatives.push_back( std::move(newAlt) );
                 } // for
         }