Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/ResolvExpr/AlternativeFinder.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -434,7 +434,7 @@ Cost convCost = Cost::zero; - std::list< DeclarationWithType* >& formals = function->parameters; - std::list< DeclarationWithType* >::iterator formal = formals.begin(); - std::list< Expression* >& actuals = appExpr->args; + auto & formals = function->parameters; + auto formal = formals.begin(); + auto & actuals = appExpr->args; for ( Expression*& actualExpr : actuals ) { @@ -493,8 +493,8 @@ /// Adds type variables to the open variable set and marks their assertions void makeUnifiableVars( Type *type, OpenVarSet &unifiableVars, AssertionSet &needAssertions ) { - for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) { - unifiableVars[ (*tyvar)->get_name() ] = TypeDecl::Data{ *tyvar }; - for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->assertions.begin(); assert != (*tyvar)->assertions.end(); ++assert ) { - needAssertions[ *assert ].isUsed = true; + for ( auto tyvar : type->forall ) { + unifiableVars[ tyvar->get_name() ] = TypeDecl::Data{ tyvar }; + for ( auto assert : tyvar->assertions ) { + needAssertions[ assert ].isUsed = true; } } @@ -1407,5 +1407,5 @@ // assume no polymorphism // assume no implicit conversions - assert( function->get_parameters().size() == 1 ); + assert( function->parameters.size() == 1 ); PRINT( std::cerr << "resolvAttr: funcDecl is "; @@ -1417,5 +1417,5 @@ const SymTab::Indexer & indexer = finder.get_indexer(); AltList & alternatives = finder.get_alternatives(); - if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) { + if ( typesCompatibleIgnoreQualifiers( argType, function->parameters.front()->get_type(), indexer, env ) ) { Cost cost = Cost::zero; Expression * newExpr = data.combine( cost ); @@ -1442,5 +1442,5 @@ if ( FunctionType *function = dynamic_cast< FunctionType* >( id->get_type() ) ) { // assume exactly one parameter - if ( function->get_parameters().size() == 1 ) { + if ( function->parameters.size() == 1 ) { if ( attrExpr->get_isType() ) { resolveAttr( data, function, attrExpr->get_type(), env, altFinder); Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/ResolvExpr/ConversionCost.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -388,6 +388,6 @@ Cost c = Cost::zero; if ( TupleType * destAsTuple = dynamic_cast< TupleType * >( dest ) ) { - std::list< Type * >::const_iterator srcIt = tupleType->types.begin(); - std::list< Type * >::const_iterator destIt = destAsTuple->types.begin(); + std::vector< Type * >::const_iterator srcIt = tupleType->types.begin(); + std::vector< Type * >::const_iterator destIt = destAsTuple->types.begin(); while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) { Cost newCost = costFunc( *srcIt++, *destIt++, indexer, env ); Index: src/ResolvExpr/FindOpenVars.cc =================================================================== --- src/ResolvExpr/FindOpenVars.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/ResolvExpr/FindOpenVars.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -50,28 +50,18 @@ void FindOpenVars::common_action( Type *type ) { if ( nextIsOpen ) { - for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) { - openVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) }; - for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) { - needAssertions[ *assert ].isUsed = false; + for ( const auto i : type->get_forall() ) { + openVars[ i->get_name() ] = TypeDecl::Data{ i }; + for ( const auto assert : i->assertions ) { + needAssertions[ assert ].isUsed = false; } -/// cloneAll( (*i)->get_assertions(), needAssertions ); -/// needAssertions.insert( needAssertions.end(), (*i)->get_assertions().begin(), (*i)->get_assertions().end() ); } } else { - for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) { - closedVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) }; - for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) { - haveAssertions[ *assert ].isUsed = false; + for ( const auto i : type->get_forall() ) { + closedVars[ i->get_name() ] = TypeDecl::Data{ i }; + for ( const auto assert : i->assertions ) { + haveAssertions[ assert ].isUsed = false; } -/// cloneAll( (*i)->get_assertions(), haveAssertions ); -/// haveAssertions.insert( haveAssertions.end(), (*i)->get_assertions().begin(), (*i)->get_assertions().end() ); } // for } // if -/// std::cerr << "type is "; -/// type->print( std::cerr ); -/// std::cerr << std::endl << "need is" << std::endl; -/// printAssertionSet( needAssertions, std::cerr ); -/// std::cerr << std::endl << "have is" << std::endl; -/// printAssertionSet( haveAssertions, std::cerr ); } Index: src/ResolvExpr/SpecCost.cc =================================================================== --- src/ResolvExpr/SpecCost.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/ResolvExpr/SpecCost.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -42,5 +42,5 @@ private: // takes minimum non-negative count over parameter/return list - void takeminover( int& mincount, std::list& dwts ) { + void takeminover( int& mincount, std::vector & dwts ) { for ( DeclarationWithType* dwt : dwts ) { count = -1; @@ -61,5 +61,5 @@ visit_children = false; } - + private: // returns minimum non-negative count + 1 over type parameters (-1 if none such) @@ -80,5 +80,5 @@ visit_children = false; } - + // look for polymorphic parameters void previsit(UnionInstType* uty) { Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/ResolvExpr/Unify.cc (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -283,5 +283,5 @@ void markAssertions( AssertionSet &assertion1, AssertionSet &assertion2, Type *type ) { for ( auto tyvar : type->get_forall() ) { - for ( auto assert : tyvar->get_assertions() ) { + for ( auto assert : tyvar->assertions ) { markAssertionSet( assertion1, assert ); markAssertionSet( assertion2, assert ); @@ -336,5 +336,5 @@ template< typename Iterator, typename Func > std::unique_ptr combineTypes( Iterator begin, Iterator end, Func & toType ) { - std::list< Type * > types; + std::vector< Type * > types; for ( ; begin != end; ++begin ) { // it's guaranteed that a ttype variable will be bound to a flat tuple, so ensure that this results in a flat tuple @@ -404,5 +404,5 @@ /// flattens a list of declarations, so that each tuple type has a single declaration. /// makes use of TtypeExpander to ensure ttypes are flat as well. - void flattenList( std::list< DeclarationWithType * > src, std::list< DeclarationWithType * > & dst, TypeEnvironment & env ) { + void flattenList( std::vector< DeclarationWithType * > src, std::vector< DeclarationWithType * > & dst, TypeEnvironment & env ) { dst.clear(); for ( DeclarationWithType * dcl : src ) { @@ -429,6 +429,6 @@ std::unique_ptr flatFunc( functionType->clone() ); std::unique_ptr flatOther( otherFunction->clone() ); - flattenList( flatFunc->get_parameters(), flatFunc->get_parameters(), env ); - flattenList( flatOther->get_parameters(), flatOther->get_parameters(), env ); + flattenList( flatFunc ->parameters, flatFunc ->parameters, env ); + flattenList( flatOther->parameters, flatOther->parameters, env ); // sizes don't have to match if ttypes are involved; need to be more precise wrt where the ttype is to prevent errors @@ -481,5 +481,5 @@ } else if ( tupleParam ) { // bundle other parameters into tuple to match - std::list< Type * > binderTypes; + std::vector< Type * > binderTypes; do { @@ -497,5 +497,5 @@ } else if ( otherTupleParam ) { // bundle parameters into tuple to match other - std::list< Type * > binderTypes; + std::vector< Type * > binderTypes; do { @@ -626,11 +626,11 @@ // xxx - compute once and store in the FunctionType? Type * extractResultType( FunctionType * function ) { - if ( function->get_returnVals().size() == 0 ) { + if ( function->returnVals.size() == 0 ) { return new VoidType( Type::Qualifiers() ); - } else if ( function->get_returnVals().size() == 1 ) { - return function->get_returnVals().front()->get_type()->clone(); + } else if ( function->returnVals.size() == 1 ) { + return function->returnVals.front()->get_type()->clone(); } else { - std::list< Type * > types; - for ( DeclarationWithType * decl : function->get_returnVals() ) { + std::vector< Type * > types; + for ( DeclarationWithType * decl : function->returnVals ) { types.push_back( decl->get_type()->clone() ); } // for Index: src/ResolvExpr/typeops.h =================================================================== --- src/ResolvExpr/typeops.h (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) +++ src/ResolvExpr/typeops.h (revision 2f42718dd1dafad85f808eaefd91c3a4c1871b20) @@ -73,5 +73,5 @@ // in AlternativeFinder.cc - Cost computeConversionCost( Type *actualType, Type *formalType, + Cost computeConversionCost( Type *actualType, Type *formalType, const SymTab::Indexer &indexer, const TypeEnvironment &env ); @@ -112,5 +112,5 @@ bool occurs( Type *type, std::string varName, const TypeEnvironment &env ); - template + template bool occursIn( Type* ty, Iter begin, Iter end, const TypeEnvironment &env ) { while ( begin != end ) { @@ -128,5 +128,5 @@ void flatten( Type * type, OutputIterator out ) { if ( TupleType * tupleType = dynamic_cast< TupleType * >( type ) ) { - for ( Type * t : tupleType->get_types() ) { + for ( Type * t : tupleType->types ) { flatten( t, out ); }