Changes in src/ResolvExpr/AlternativeFinder.cc [a40d503:8a62d04]

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -83 +83 @@
         }
 
-        void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt ) {
-                Indenter indent = { Indenter::tabsize, indentAmt };
-                for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
-                        i->print( os, indent );
-                        os << std::endl;
-                }
-        }
-
         namespace {
+                void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt = 0 ) {
+                        Indenter indent = { Indenter::tabsize, indentAmt };
+                        for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
+                                i->print( os, indent );
+                                os << std::endl;
+                        }
+                }
+
                 void makeExprList( const AltList &in, std::list< Expression* > &out ) {
                         for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
@@ -469 +469 @@
                         std::cerr << std::endl;
                 )
-                std::list< SymTab::Indexer::IdData > candidates;
+                std::list< DeclarationWithType* > 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;
+                for ( std::list< DeclarationWithType* >::const_iterator candidate = candidates.begin(); candidate != candidates.end(); ++candidate ) {
                         PRINT(
                                 std::cerr << "inferRecursive: candidate is ";
-                                candidate->print( std::cerr );
+                                (*candidate)->print( std::cerr );
                                 std::cerr << std::endl;
                         )
@@ -483 +482 @@
                         TypeEnvironment newEnv( newAlt.env );
                         OpenVarSet newOpenVars( openVars );
-                        Type *adjType = candidate->get_type()->clone();
+                        Type *adjType = (*candidate)->get_type()->clone();
                         adjustExprType( adjType, newEnv, indexer );
                         adjType->accept( global_renamer );
@@ -501 +500 @@
                                 Alternative newerAlt( newAlt );
                                 newerAlt.env = newEnv;
-                                assertf( candidate->get_uniqueId(), "Assertion candidate does not have a unique ID: %s", toString( candidate ).c_str() );
+                                assertf( (*candidate)->get_uniqueId(), "Assertion candidate does not have a unique ID: %s", toString( *candidate ).c_str() );
+                                DeclarationWithType *candDecl = static_cast< DeclarationWithType* >( Declaration::declFromId( (*candidate)->get_uniqueId() ) );
 
                                 // everything with an empty idChain was pulled in by the current assertion.
@@ -516 +516 @@
                                 // DOESN'T WORK: grandchild nodes conflict with their cousins
                                 //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
-                                Expression *varExpr = data.combine();
+                                Expression *varExpr = new VariableExpr( candDecl );
                                 delete varExpr->get_result();
                                 varExpr->set_result( adjType->clone() );
@@ -522 +522 @@
                                         std::cerr << "satisfying assertion " << curDecl->get_uniqueId() << " ";
                                         curDecl->print( std::cerr );
-                                        std::cerr << " with declaration " << candidate->get_uniqueId() << " ";
-                                        candidate->print( std::cerr );
+                                        std::cerr << " with declaration " << (*candidate)->get_uniqueId() << " ";
+                                        (*candidate)->print( std::cerr );
                                         std::cerr << std::endl;
                                 )
@@ -532 +532 @@
                                 }
                                 // 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 );
+                                (*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 );
                         } else {
@@ -1317 +1317 @@
 
         void AlternativeFinder::visit( NameExpr *nameExpr ) {
-                std::list< SymTab::Indexer::IdData > declList;
+                std::list< DeclarationWithType* > declList;
                 indexer.lookupId( nameExpr->get_name(), declList );
                 PRINT( std::cerr << "nameExpr is " << nameExpr->get_name() << std::endl; )
-                for ( auto & data : declList ) {
-                        Expression * newExpr = data.combine();
-                        // xxx - add in extra cost for with-statement exprs?
-                        alternatives.push_back( Alternative( newExpr, env, Cost::zero ) );
+                for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) {
+                        VariableExpr newExpr( *i );
+                        alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) );
                         PRINT(
                                 std::cerr << "decl is ";
-                                data.id->print( std::cerr );
+                                (*i)->print( std::cerr );
                                 std::cerr << std::endl;
                                 std::cerr << "newExpr is ";
-                                newExpr->print( std::cerr );
+                                newExpr.print( std::cerr );
                                 std::cerr << std::endl;
                         )
@@ -1421 +1420 @@
         }
 
-        namespace {
-                void resolveAttr( SymTab::Indexer::IdData data, FunctionType *function, Type *argType, const TypeEnvironment &env, AlternativeFinder & finder ) {
-                        // assume no polymorphism
-                        // assume no implicit conversions
-                        assert( function->get_parameters().size() == 1 );
-                        PRINT(
-                                std::cerr << "resolvAttr: funcDecl is ";
-                                data.id->print( std::cerr );
-                                std::cerr << " argType is ";
-                                argType->print( std::cerr );
-                                std::cerr << std::endl;
-                        )
-                        const SymTab::Indexer & indexer = finder.get_indexer();
-                        AltList & alternatives = finder.get_alternatives();
-                        if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) {
-                                alternatives.push_back( Alternative( new AttrExpr( data.combine(), argType->clone() ), env, Cost::zero ) );
-                                for ( DeclarationWithType * retVal : function->returnVals ) {
-                                        alternatives.back().expr->result = retVal->get_type()->clone();
-                                } // for
-                        } // if
-                }
+        void AlternativeFinder::resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env ) {
+                // assume no polymorphism
+                // assume no implicit conversions
+                assert( function->get_parameters().size() == 1 );
+                PRINT(
+                        std::cerr << "resolvAttr: funcDecl is ";
+                        funcDecl->print( std::cerr );
+                        std::cerr << " argType is ";
+                        argType->print( std::cerr );
+                        std::cerr << std::endl;
+                )
+                if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) {
+                        alternatives.push_back( Alternative( new AttrExpr( new VariableExpr( funcDecl ), argType->clone() ), env, Cost::zero ) );
+                        for ( std::list< DeclarationWithType* >::iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
+                                alternatives.back().expr->set_result( (*i)->get_type()->clone() );
+                        } // for
+                } // if
         }
 
@@ -1448 +1443 @@
                 NameExpr *nameExpr = dynamic_cast< NameExpr* >( attrExpr->get_attr() );
                 assert( nameExpr );
-                std::list< SymTab::Indexer::IdData > attrList;
+                std::list< DeclarationWithType* > attrList;
                 indexer.lookupId( nameExpr->get_name(), attrList );
                 if ( attrExpr->get_isType() || attrExpr->get_expr() ) {
-                        for ( auto & data : attrList ) {
-                                DeclarationWithType * id = data.id;
+                        for ( std::list< DeclarationWithType* >::iterator i = attrList.begin(); i != attrList.end(); ++i ) {
                                 // check if the type is function
-                                if ( FunctionType *function = dynamic_cast< FunctionType* >( id->get_type() ) ) {
+                                if ( FunctionType *function = dynamic_cast< FunctionType* >( (*i)->get_type() ) ) {
                                         // assume exactly one parameter
                                         if ( function->get_parameters().size() == 1 ) {
                                                 if ( attrExpr->get_isType() ) {
-                                                        resolveAttr( data, function, attrExpr->get_type(), env, *this );
+                                                        resolveAttr( *i, function, attrExpr->get_type(), env );
                                                 } else {
                                                         AlternativeFinder finder( indexer, env );
@@ -1464 +1458 @@
                                                         for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) {
                                                                 if ( choice->expr->get_result()->size() == 1 ) {
-                                                                        resolveAttr(data, function, choice->expr->get_result(), choice->env, *this );
+                                                                        resolveAttr(*i, function, choice->expr->get_result(), choice->env );
                                                                 } // fi
                                                         } // for
@@ -1472 +1466 @@
                         } // for
                 } else {
-                        for ( auto & data : attrList ) {
-                                alternatives.push_back( Alternative( data.combine(), env, Cost::zero ) );
+                        for ( std::list< DeclarationWithType* >::iterator i = attrList.begin(); i != attrList.end(); ++i ) {
+                                VariableExpr newExpr( *i );
+                                alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) );
                                 renameTypes( alternatives.back().expr );
                         } // for