Changeset 00ac42e for src/ResolvExpr/AlternativeFinder.cc

Timestamp:

Jun 1, 2018, 2:54:55 PM (6 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, with_gc

Children:

262bd63

Parents:

41e16b1

git-author:

Aaron Moss <a3moss@…> (05/31/18 16:24:49)

git-committer:

Aaron Moss <a3moss@…> (06/01/18 14:54:55)

Message:

stop eagerly copying EqvClass? on lookup

File:

• src/ResolvExpr/AlternativeFinder.cc (modified) (14 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 );
@@ -472 +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 ) {
@@ -487 +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() ) {
@@ -506 +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;
                         }
@@ -513 +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
                 }
@@ -566 +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();
@@ -588 +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;
@@ -610 +594 @@
                 addToIndexer( have, decls );
                 AssertionSet newNeed;
-                //AssertionParentSet needParents;
                 PRINT(
                         std::cerr << "env is: " << std::endl;
@@ -617 +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 ";
@@ -1096 +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;
@@ -1133 +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 );
@@ -1350 +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 );
@@ -1362 +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() );