Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 99614c25485a445fe8b29250bef7718bb7bb7883) +++ src/CodeGen/CodeGenerator.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) @@ -330,5 +330,5 @@ void CodeGenerator::postvisit( Designation * designation ) { - std::list< Expression * > designators = designation->get_designators(); + auto & designators = designation->designators; if ( designators.size() == 0 ) return; for ( Expression * des : designators ) { @@ -354,6 +354,6 @@ auto initBegin = init->begin(); auto initEnd = init->end(); - auto desigBegin = init->get_designations().begin(); - auto desigEnd = init->get_designations().end(); + auto desigBegin = init->designations.begin(); + auto desigEnd = init->designations.end(); output << "{ "; Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision 99614c25485a445fe8b29250bef7718bb7bb7883) +++ src/InitTweak/InitTweak.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) @@ -41,5 +41,5 @@ // short circuit if we already know there are designations if ( hasDesignations ) visit_children = false; - else if ( ! des->get_designators().empty() ) { + else if ( ! des->designators.empty() ) { hasDesignations = true; visit_children = false; Index: src/Parser/InitializerNode.cc =================================================================== --- src/Parser/InitializerNode.cc (revision 99614c25485a445fe8b29250bef7718bb7bb7883) +++ src/Parser/InitializerNode.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) @@ -89,5 +89,5 @@ if ( aggregate ) { // steal designators from children - std::list< Designation * > designlist; + std::vector< Designation * > designlist; InitializerNode * child = next_init(); for ( ; child != nullptr; child = dynamic_cast< InitializerNode * >( child->get_next() ) ) { Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision 99614c25485a445fe8b29250bef7718bb7bb7883) +++ src/ResolvExpr/AlternativeFinder.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) @@ -367,5 +367,5 @@ std::string tmp; if ( val >= 0 && (unsigned long long)val < tupleType->size() ) { - alternatives.push_back( Alternative{ + alternatives.push_back( Alternative{ alt, new TupleIndexExpr( expr->clone(), val ), newCost } ); } // if @@ -474,5 +474,5 @@ } - // specialization cost of return types can't be accounted for directly, it disables + // specialization cost of return types can't be accounted for directly, it disables // otherwise-identical calls, like this example based on auto-newline in the I/O lib: // @@ -1225,6 +1225,6 @@ // count one safe conversion for each value that is thrown away thisCost.incSafe( discardedValues ); - Alternative newAlt{ - restructureCast( alt.expr->clone(), toType, castExpr->isGenerated ), + Alternative newAlt{ + restructureCast( alt.expr->clone(), toType, castExpr->isGenerated ), alt.env, openVars, needAssertions, alt.cost, alt.cost + thisCost }; inferParameters( newAlt, back_inserter( candidates ) ); @@ -1290,5 +1290,5 @@ void AlternativeFinder::Finder::postvisit( NameExpr *nameExpr ) { - std::list< SymTab::Indexer::IdData > declList; + std::vector< SymTab::Indexer::IdData > declList; indexer.lookupId( nameExpr->name, declList ); PRINT( std::cerr << "nameExpr is " << nameExpr->name << std::endl; ) @@ -1327,5 +1327,5 @@ if ( sizeofExpr->get_isType() ) { Type * newType = sizeofExpr->get_type()->clone(); - alternatives.push_back( Alternative{ + alternatives.push_back( Alternative{ new SizeofExpr{ resolveTypeof( newType, indexer ) }, env } ); } else { @@ -1342,5 +1342,5 @@ Alternative &choice = winners.front(); referenceToRvalueConversion( choice.expr, choice.cost ); - alternatives.push_back( Alternative{ + alternatives.push_back( Alternative{ choice, new SizeofExpr( choice.expr->clone() ), Cost::zero } ); } // if @@ -1350,5 +1350,5 @@ if ( alignofExpr->get_isType() ) { Type * newType = alignofExpr->get_type()->clone(); - alternatives.push_back( Alternative{ + alternatives.push_back( Alternative{ new AlignofExpr{ resolveTypeof( newType, indexer ) }, env } ); } else { @@ -1365,5 +1365,5 @@ Alternative &choice = winners.front(); referenceToRvalueConversion( choice.expr, choice.cost ); - alternatives.push_back( Alternative{ + alternatives.push_back( Alternative{ choice, new AlignofExpr{ choice.expr->clone() }, Cost::zero } ); } // if @@ -1376,5 +1376,5 @@ for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) { if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( *i ) ) { - alternatives.push_back( Alternative{ + alternatives.push_back( Alternative{ new OffsetofExpr{ aggInst->clone(), dwt }, env } ); renameTypes( alternatives.back().expr ); @@ -1420,6 +1420,6 @@ Cost cost = Cost::zero; Expression * newExpr = data.combine( cost ); - alternatives.push_back( Alternative{ - new AttrExpr{ newExpr, argType->clone() }, env, OpenVarSet{}, + alternatives.push_back( Alternative{ + new AttrExpr{ newExpr, argType->clone() }, env, OpenVarSet{}, AssertionList{}, Cost::zero, cost } ); for ( DeclarationWithType * retVal : function->returnVals ) { @@ -1434,5 +1434,5 @@ NameExpr *nameExpr = dynamic_cast< NameExpr* >( attrExpr->get_attr() ); assert( nameExpr ); - std::list< SymTab::Indexer::IdData > attrList; + std::vector< SymTab::Indexer::IdData > attrList; indexer.lookupId( nameExpr->get_name(), attrList ); if ( attrExpr->get_isType() || attrExpr->get_expr() ) { @@ -1461,5 +1461,5 @@ Cost cost = Cost::zero; Expression * newExpr = data.combine( cost ); - alternatives.push_back( Alternative{ + alternatives.push_back( Alternative{ newExpr, env, OpenVarSet{}, AssertionList{}, Cost::zero, cost } ); renameTypes( alternatives.back().expr ); @@ -1485,8 +1485,8 @@ cloneAll( second.need, need ); - LogicalExpr *newExpr = new LogicalExpr{ + LogicalExpr *newExpr = new LogicalExpr{ first.expr->clone(), second.expr->clone(), logicalExpr->get_isAnd() }; - alternatives.push_back( Alternative{ - newExpr, std::move(compositeEnv), std::move(openVars), + alternatives.push_back( Alternative{ + newExpr, std::move(compositeEnv), std::move(openVars), AssertionList( need.begin(), need.end() ), first.cost + second.cost } ); } @@ -1521,21 +1521,21 @@ cloneAll( third.need, need ); AssertionSet have; - + // unify true and false types, then infer parameters to produce new alternatives Type* commonType = nullptr; - if ( unify( second.expr->result, third.expr->result, compositeEnv, + if ( unify( second.expr->result, third.expr->result, compositeEnv, need, have, openVars, indexer, commonType ) ) { - ConditionalExpr *newExpr = new ConditionalExpr{ + ConditionalExpr *newExpr = new ConditionalExpr{ first.expr->clone(), second.expr->clone(), third.expr->clone() }; newExpr->result = commonType ? commonType : second.expr->result->clone(); // convert both options to the conditional result type Cost cost = first.cost + second.cost + third.cost; - cost += computeExpressionConversionCost( + cost += computeExpressionConversionCost( newExpr->arg2, newExpr->result, indexer, compositeEnv ); - cost += computeExpressionConversionCost( + cost += computeExpressionConversionCost( newExpr->arg3, newExpr->result, indexer, compositeEnv ); // output alternative - Alternative newAlt{ - newExpr, std::move(compositeEnv), std::move(openVars), + Alternative newAlt{ + newExpr, std::move(compositeEnv), std::move(openVars), AssertionList( need.begin(), need.end() ), cost }; inferParameters( newAlt, back_inserter( alternatives ) ); @@ -1552,5 +1552,5 @@ secondFinder.findWithAdjustment( commaExpr->get_arg2() ); for ( const Alternative & alt : secondFinder.alternatives ) { - alternatives.push_back( Alternative{ + alternatives.push_back( Alternative{ alt, new CommaExpr{ newFirstArg->clone(), alt.expr->clone() }, alt.cost } ); } // for @@ -1578,11 +1578,11 @@ Type* commonType = nullptr; - if ( unify( first.expr->result, second.expr->result, compositeEnv, need, have, + if ( unify( first.expr->result, second.expr->result, compositeEnv, need, have, openVars, indexer, commonType ) ) { - RangeExpr * newExpr = + RangeExpr * newExpr = new RangeExpr{ first.expr->clone(), second.expr->clone() }; newExpr->result = commonType ? commonType : first.expr->result->clone(); - Alternative newAlt{ - newExpr, std::move(compositeEnv), std::move(openVars), + Alternative newAlt{ + newExpr, std::move(compositeEnv), std::move(openVars), AssertionList( need.begin(), need.end() ), first.cost + second.cost }; inferParameters( newAlt, back_inserter( alternatives ) ); @@ -1611,7 +1611,7 @@ cloneAll( alt.need, need ); } - - alternatives.push_back( Alternative{ - new TupleExpr{ exprs }, std::move(compositeEnv), std::move(openVars), + + alternatives.push_back( Alternative{ + new TupleExpr{ exprs }, std::move(compositeEnv), std::move(openVars), AssertionList( need.begin(), need.end() ), sumCost( alts ) } ); } // for @@ -1632,5 +1632,5 @@ finder.findWithoutPrune( ctorExpr->get_callExpr() ); for ( Alternative & alt : finder.alternatives ) { - alternatives.push_back( Alternative{ + alternatives.push_back( Alternative{ alt, new ConstructorExpr( alt.expr->clone() ), alt.cost } ); } @@ -1684,21 +1684,21 @@ cloneAll( alt.need, need ); AssertionSet have; - OpenVarSet openVars( alt.openVars ); - // xxx - find things in env that don't have a "representative type" and claim + OpenVarSet openVars( alt.openVars ); + // xxx - find things in env that don't have a "representative type" and claim // those are open vars? PRINT( std::cerr << " @ " << toType << " " << initAlt.designation << std::endl; ) - // It's possible that a cast can throw away some values in a multiply-valued - // expression. (An example is a cast-to-void, which casts from one value to - // zero.) Figure out the prefix of the subexpression results that are cast - // directly. The candidate is invalid if it has fewer results than there are + // It's possible that a cast can throw away some values in a multiply-valued + // expression. (An example is a cast-to-void, which casts from one value to + // zero.) Figure out the prefix of the subexpression results that are cast + // directly. The candidate is invalid if it has fewer results than there are // types to cast to. int discardedValues = alt.expr->result->size() - toType->size(); if ( discardedValues < 0 ) continue; - // xxx - may need to go into tuple types and extract relevant types and use - // unifyList. Note that currently, this does not allow casting a tuple to an + // xxx - may need to go into tuple types and extract relevant types and use + // unifyList. Note that currently, this does not allow casting a tuple to an // atomic type (e.g. (int)([1, 2, 3])) - + // unification run for side-effects unify( toType, alt.expr->result, newEnv, need, have, openVars, indexer ); @@ -1709,8 +1709,8 @@ // count one safe conversion for each value that is thrown away thisCost.incSafe( discardedValues ); - Alternative newAlt{ - new InitExpr{ - restructureCast( alt.expr->clone(), toType, true ), initAlt.designation->clone() }, - std::move(newEnv), std::move(openVars), + Alternative newAlt{ + new InitExpr{ + restructureCast( alt.expr->clone(), toType, true ), initAlt.designation->clone() }, + std::move(newEnv), std::move(openVars), AssertionList( need.begin(), need.end() ), alt.cost, thisCost }; inferParameters( newAlt, back_inserter( candidates ) ); Index: src/ResolvExpr/CurrentObject.cc =================================================================== --- src/ResolvExpr/CurrentObject.cc (revision 99614c25485a445fe8b29250bef7718bb7bb7883) +++ src/ResolvExpr/CurrentObject.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) @@ -228,5 +228,5 @@ std::vector ret = memberIter->first(); for ( InitAlternative & alt : ret ) { - alt.designation->get_designators().push_front( new ConstantExpr( Constant::from_ulong( index ) ) ); + alt.designation->designators.push_front( new ConstantExpr( Constant::from_ulong( index ) ) ); } return ret; @@ -294,5 +294,5 @@ for ( InitAlternative & alt : ret ) { PRINT( std::cerr << "iterating and adding designators" << std::endl; ) - alt.designation->get_designators().push_front( new VariableExpr( strict_dynamic_cast< ObjectDecl * >( *curMember ) ) ); + alt.designation->designators.push_front( new VariableExpr( strict_dynamic_cast< ObjectDecl * >( *curMember ) ) ); // need to substitute for generic types, so that casts are to concrete types PRINT( std::cerr << " type is: " << alt.type; ) @@ -354,5 +354,5 @@ for ( InitAlternative & alt : ret ) { PRINT( std::cerr << "iterating and adding designators" << std::endl; ) - alt.designation->get_designators().push_front( new VariableExpr( strict_dynamic_cast< ObjectDecl * >( *curMember ) ) ); + alt.designation->designators.push_front( new VariableExpr( strict_dynamic_cast< ObjectDecl * >( *curMember ) ) ); } } @@ -465,5 +465,5 @@ assertf( ! objStack.empty(), "obj stack empty in setNext" ); PRINT( std::cerr << "____setNext" << designation << std::endl; ) - objStack.top()->setPosition( designation->get_designators() ); + objStack.top()->setPosition( designation->designators ); } @@ -472,9 +472,9 @@ PRINT( std::cerr << "___findNext" << std::endl; ) // find all the d's - std::list desigAlts{ { } }, newDesigAlts; + std::vector desigAlts{ { } }, newDesigAlts; std::list curTypes { (objStack.top())->getType() }, newTypes; - for ( Expression * expr : designation->get_designators() ) { + for ( Expression * expr : designation->designators ) { PRINT( std::cerr << "____untyped: " << expr << std::endl; ) - std::list::iterator dit = desigAlts.begin(); + auto dit = desigAlts.begin(); if ( NameExpr * nexpr = dynamic_cast(expr) ) { for ( Type * t : curTypes ) { Index: src/ResolvExpr/ResolveAssertions.cc =================================================================== --- src/ResolvExpr/ResolveAssertions.cc (revision 99614c25485a445fe8b29250bef7718bb7bb7883) +++ src/ResolvExpr/ResolveAssertions.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) @@ -47,7 +47,7 @@ UniqueId resnSlot; ///< Slot for any recursive assertion IDs - AssnCandidate( const SymTab::Indexer::IdData& cdata, Type* adjType, TypeEnvironment&& env, - AssertionSet&& have, AssertionSet&& need, OpenVarSet&& openVars, UniqueId resnSlot ) - : cdata(cdata), adjType(adjType), env(std::move(env)), have(std::move(have)), + AssnCandidate( const SymTab::Indexer::IdData& cdata, Type* adjType, TypeEnvironment&& env, + AssertionSet&& have, AssertionSet&& need, OpenVarSet&& openVars, UniqueId resnSlot ) + : cdata(cdata), adjType(adjType), env(std::move(env)), have(std::move(have)), need(std::move(need)), openVars(std::move(openVars)), resnSlot(resnSlot) {} }; @@ -86,5 +86,5 @@ const AssnCache* cache; ///< Cache storing assertion item std::string key; ///< Key into cache - + DeferItem( const AssnCache& cache, const std::string& key ) : cache(&cache), key(key) {} @@ -99,5 +99,5 @@ // sortable by key - // TODO look into optimizing combination process with other sort orders (e.g. by number + // TODO look into optimizing combination process with other sort orders (e.g. by number // of matches in candidate) bool operator< ( const DeferItem& o ) const { return key < o.key; } @@ -108,5 +108,5 @@ using DeferList = std::vector; - /// Combo iterator that combines candidates into an output list, merging their environments. + /// Combo iterator that combines candidates into an output list, merging their environments. /// Rejects an appended candidate if the environments cannot be merged. class CandidateEnvMerger { @@ -119,5 +119,5 @@ /// Indexer to use for merges const SymTab::Indexer& indexer; - + public: /// The merged environment/open variables and the list of candidates @@ -127,10 +127,10 @@ std::vector assns; - OutType( const TypeEnvironment& env, const OpenVarSet& openVars, + OutType( const TypeEnvironment& env, const OpenVarSet& openVars, const std::vector& assns ) : env(env), openVars(openVars), assns(assns) {} }; - CandidateEnvMerger( const TypeEnvironment& env, const OpenVarSet& openVars, + CandidateEnvMerger( const TypeEnvironment& env, const OpenVarSet& openVars, const SymTab::Indexer& indexer ) : crnt(), envs{ env }, varSets{ openVars }, indexer(indexer) {} @@ -158,5 +158,5 @@ }; - /// Comparator for CandidateEnvMerger outputs that sums their costs and caches the stored + /// Comparator for CandidateEnvMerger outputs that sums their costs and caches the stored /// sums struct CandidateCost { @@ -176,6 +176,6 @@ Cost k = Cost::zero; for ( const auto& assn : x.assns ) { - k += computeConversionCost( - assn.match.adjType, assn.item.deferIds[0].decl->get_type(), indexer, + k += computeConversionCost( + assn.match.adjType, assn.item.deferIds[0].decl->get_type(), indexer, x.env ); } @@ -184,5 +184,5 @@ return it->second; } - + /// compares elements by cost bool operator() ( const Element& a, const Element& b ) const { @@ -214,12 +214,12 @@ /// Updated resolution state with new need-list ResnState( ResnState&& o, IterateFlag ) - : alt(std::move(o.alt)), need(o.newNeed.begin(), o.newNeed.end()), newNeed(), deferred(), + : alt(std::move(o.alt)), need(o.newNeed.begin(), o.newNeed.end()), newNeed(), deferred(), inferred(std::move(o.inferred)), indexer(o.indexer) {} }; /// Binds a single assertion, updating resolution state - void bindAssertion( const DeclarationWithType* decl, AssertionSetValue info, Alternative& alt, + void bindAssertion( const DeclarationWithType* decl, AssertionSetValue info, Alternative& alt, AssnCandidate& match, InferCache& inferred ) { - + DeclarationWithType* candidate = match.cdata.id; assertf( candidate->get_uniqueId(), "Assertion candidate does not have a unique ID: %s", toString( candidate ).c_str() ); @@ -232,5 +232,5 @@ // place newly-inferred assertion in proper place in cache inferred[ info.resnSlot ][ decl->get_uniqueId() ] = ParamEntry{ - candidate->get_uniqueId(), match.adjType->clone(), decl->get_type()->clone(), + candidate->get_uniqueId(), match.adjType->clone(), decl->get_type()->clone(), varExpr }; } @@ -260,5 +260,5 @@ if ( it == cache.end() ) { // lookup candidates for this assertion - std::list< SymTab::Indexer::IdData > candidates; + std::vector< SymTab::Indexer::IdData > candidates; resn.indexer.lookupId( assn.decl->name, candidates ); @@ -277,5 +277,5 @@ // keep unifying candidates - if ( unify( assn.decl->get_type(), adjType, newEnv, newNeed, have, newOpenVars, + if ( unify( assn.decl->get_type(), adjType, newEnv, newNeed, have, newOpenVars, resn.indexer ) ) { // set up binding slot for recursive assertions @@ -288,5 +288,5 @@ } - matches.emplace_back( cdata, adjType, std::move(newEnv), std::move(have), + matches.emplace_back( cdata, adjType, std::move(newEnv), std::move(have), std::move(newNeed), std::move(newOpenVars), crntResnSlot ); } else { @@ -339,5 +339,5 @@ } InferredParams& inferParams = it->second; - + // place inferred parameters into proper place in expression for ( auto& entry : inferParams ) { @@ -402,5 +402,5 @@ // resolve deferred assertions by mutual compatibility std::vector compatible = filterCombos( - resn.deferred, + resn.deferred, CandidateEnvMerger{ resn.alt.env, resn.alt.openVars, resn.indexer } ); // sort by cost @@ -431,5 +431,5 @@ // for each deferred assertion with the same form for ( AssnId id : r.item.deferIds ) { - bindAssertion( + bindAssertion( id.decl, id.info, new_resn.alt, match, new_resn.inferred ); } @@ -455,5 +455,5 @@ new_resns.clear(); } - + // exceeded recursion limit if reaches here if ( out.empty() ) { Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 99614c25485a445fe8b29250bef7718bb7bb7883) +++ src/ResolvExpr/Resolver.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) @@ -839,6 +839,6 @@ // xxx - fix this so that the list isn't copied, iterator should be used to change current // element - std::list newDesignations; - for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) { + std::vector newDesignations; + for ( auto p : group_iterate(listInit->designations, listInit->initializers) ) { // iterate designations and initializers in pairs, moving the cursor to the current // designated object and resolving the initializer against that object. @@ -849,5 +849,5 @@ } // set the set of 'resolved' designations and leave the brace-enclosed initializer-list - listInit->get_designations() = newDesignations; // xxx - memory management + listInit->designations = newDesignations; // xxx - memory management currentObject.exitListInit(); Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision 99614c25485a445fe8b29250bef7718bb7bb7883) +++ src/SymTab/Indexer.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) @@ -102,5 +102,5 @@ } - void Indexer::removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const { + void Indexer::removeSpecialOverrides( const std::string &id, std::vector< IdData > & out ) const { // only need to perform this step for constructors, destructors, and assignment functions if ( ! CodeGen::isCtorDtorAssign( id ) ) return; @@ -116,5 +116,5 @@ bool existsUserDefinedCopyFunc = false; // user-defined copy ctor found BaseSyntaxNode * deleteStmt = nullptr; // non-null if a user-defined function is found - std::list< DeclBall > decls; + std::vector< DeclBall > decls; // another FunctionDecl for the current type was found - determine @@ -135,6 +135,6 @@ }; // ValueType - std::list< IdData > copy; - copy.splice( copy.end(), out ); + std::vector< IdData > copy; + swap( copy, out ); // organize discovered declarations by type @@ -231,5 +231,5 @@ } - void Indexer::lookupId( const std::string &id, std::list< IdData > &out ) const { + void Indexer::lookupId( const std::string &id, std::vector< IdData > &out ) const { std::unordered_set< std::string > foundMangleNames; Index: src/SymTab/Indexer.h =================================================================== --- src/SymTab/Indexer.h (revision 99614c25485a445fe8b29250bef7718bb7bb7883) +++ src/SymTab/Indexer.h (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) @@ -60,5 +60,5 @@ /// Gets all declarations with the given ID - void lookupId( const std::string &id, std::list< IdData > &out ) const; + void lookupId( const std::string &id, std::vector< IdData > &out ) const; /// Gets the top-most type declaration with the given ID NamedTypeDecl *lookupType( const std::string &id ) const; @@ -140,5 +140,5 @@ // so that they will not be selected // void removeSpecialOverrides( FunctionDecl *decl ); - void removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const; + void removeSpecialOverrides( const std::string &id, std::vector< IdData > & out ) const; /// Ensures that tables variable is writable (i.e. allocated, uniquely owned by this Indexer, and at the current scope) Index: src/SynTree/Initializer.cc =================================================================== --- src/SynTree/Initializer.cc (revision 99614c25485a445fe8b29250bef7718bb7bb7883) +++ src/SynTree/Initializer.cc (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) @@ -70,5 +70,5 @@ -ListInit::ListInit( const std::vector< Initializer * > &inits, const std::list &des, bool maybeConstructed ) +ListInit::ListInit( const std::vector< Initializer * > & inits, const std::vector & des, bool maybeConstructed ) : Initializer( maybeConstructed ), initializers( inits ), designations( des ) { // handle the common case where a ListInit is created without designations by making a list of empty designations with the same length as the initializer Index: src/SynTree/Initializer.h =================================================================== --- src/SynTree/Initializer.h (revision 99614c25485a445fe8b29250bef7718bb7bb7883) +++ src/SynTree/Initializer.h (revision 43e0949c5f8c1f5a4cfb68e9506dd718e55a6b07) @@ -36,6 +36,4 @@ virtual ~Designation(); - std::list< Expression * > & get_designators() { return designators; } - virtual Designation * clone() const override { return new Designation( *this ); }; virtual void accept( Visitor &v ) override { v.visit( this ); } @@ -44,5 +42,5 @@ }; -const std::list noDesignators; +const std::vector noDesignators; // Initializer: base class for object initializers (provide default values) @@ -87,13 +85,10 @@ public: std::vector< Initializer * > initializers; // order *is* important - std::list designations; // order/length is consistent with initializers + std::vector designations; // order/length is consistent with initializers ListInit( const std::vector< Initializer * > &initializers, - const std::list &designators = {}, bool maybeConstructed = false ); + const std::vector &designators = {}, bool maybeConstructed = false ); ListInit( const ListInit & other ); virtual ~ListInit(); - - std::list & get_designations() { return designations; } - std::vector< Initializer * > & get_initializers() { return initializers; } typedef std::vector< Initializer * >::iterator iterator;