Changeset 63be3387 for src/GenPoly/Box.cc

Timestamp:

Nov 14, 2022, 11:52:44 AM (3 years ago)

Author:

caparson <caparson@…>

Branches:

ADT, ast-experimental, master

Children:

7d9598d8

Parents:

b77f0e1 (diff), 19a8c40 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/GenPoly/Box.cc (modified) (62 diffs)

src/GenPoly/Box.cc

@@ -58 +58 @@
 namespace GenPoly {
         namespace {
-                FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
+                FunctionType *makeAdapterType( FunctionType const *adaptee, const TyVarMap &tyVars );
 
                 class BoxPass {
@@ -68 +68 @@
                 /// Adds layout-generation functions to polymorphic types.
                 class LayoutFunctionBuilder final : public WithDeclsToAdd, public WithVisitorRef<LayoutFunctionBuilder>, public WithShortCircuiting {
-                        // Current level of nested functions:
-                        unsigned int functionNesting = 0;
                 public:
-                        void previsit( FunctionDecl *functionDecl );
                         void previsit( StructDecl *structDecl );
                         void previsit( UnionDecl *unionDecl );
@@ -100 +97 @@
                         void passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes );
                         /// passes extra type parameters into a polymorphic function application
-                        void passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
+                        /// Returns an iterator to the first argument after the added
+                        /// arguments, which are added at the beginning.
+                        std::list< Expression *>::iterator passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, const TyVarMap &exprTyVars );
                         /// wraps a function application with a new temporary for the out-parameter return value
-                        Expression *addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg );
-                        /// Replaces all the type parameters of a generic type with their concrete equivalents under the current environment
-                        void replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params );
-                        /// Replaces a polymorphic type with its concrete equivalant under the current environment (returns itself if concrete).
-                        /// If `doClone` is set to false, will not clone interior types
-                        Type *replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone = true );
+                        /// The new out-parameter is the new first parameter.
+                        Expression *addRetParam( ApplicationExpr *appExpr, Type *retType );
                         /// wraps a function application returning a polymorphic type with a new temporary for the out-parameter return value
-                        Expression *addDynRetParam( ApplicationExpr *appExpr, Type *polyType, std::list< Expression *>::iterator &arg );
-                        Expression *applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
-                        void boxParam( Type *formal, Expression *&arg, const TyVarMap &exprTyVars );
-                        void boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
-                        void addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars );
+                        Expression *addDynRetParam( ApplicationExpr *appExpr, Type *polyType );
+                        /// Converts a function call into a call of the adapter with the
+                        /// original function as the first argument (all other arguments
+                        /// are pushed back). May adjust return value.
+                        Expression *applyAdapter( ApplicationExpr *appExpr, FunctionType *function );
+                        /// Modifies the `arg`, replacing it with a boxed expression
+                        /// that matches `formal` under the current TyVarMap.
+                        void boxParam( Expression *&arg, Type *formal, const TyVarMap &exprTyVars );
+                        /// Box an argument of `appExpr` for each parameter in `function`
+                        /// starting at `arg`.
+                        /// `exprTyVars` is the function's type variables.
+                        void boxParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *function, const TyVarMap &exprTyVars );
+                        /// Boxes each assertion and inserts them into `appExpr` at
+                        /// `arg`. `exprTyVars` is the function's type variables.
+                        void addInferredParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *functionType, const TyVarMap &tyVars );
                         /// Stores assignment operators from assertion list in local map of assignment operations
                         void passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars );
-                        FunctionDecl *makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars );
+                        /// Creates an adapter definition from `adaptee` to `realType`, using
+                        /// `mangleName` as the base name for the adapter. `tyVars` is the map of
+                        /// type variables for the function type of the adapted expression.
+                        FunctionDecl *makeAdapter( FunctionType const *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars );
                         /// Replaces intrinsic operator functions with their arithmetic desugaring
                         Expression *handleIntrinsics( ApplicationExpr *appExpr );
@@ -182 +190 @@
                         ObjectDecl *makeVar( const std::string &name, Type *type, Initializer *init = 0 );
                         /// returns true if the type has a dynamic layout; such a layout will be stored in appropriately-named local variables when the function returns
-                        bool findGeneric( Type *ty );
+                        bool findGeneric( Type const *ty );
                         /// adds type parameters to the layout call; will generate the appropriate parameters if needed
                         void addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams );
@@ -221 +229 @@
         } // anonymous namespace
 
-        /// version of mutateAll with special handling for translation unit so you can check the end of the prelude when debugging
-        template< typename MutatorType >
-        inline void mutateTranslationUnit( std::list< Declaration* > &translationUnit, MutatorType &mutator ) {
-                bool seenIntrinsic = false;
-                SemanticErrorException errors;
-                for ( typename std::list< Declaration* >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
-                        try {
-                                if ( *i ) {
-                                        if ( (*i)->get_linkage() == LinkageSpec::Intrinsic ) {
-                                                seenIntrinsic = true;
-                                        } else if ( seenIntrinsic ) {
-                                                seenIntrinsic = false; // break on this line when debugging for end of prelude
-                                        }
-
-                                        *i = dynamic_cast< Declaration* >( (*i)->acceptMutator( mutator ) );
-                                        assert( *i );
-                                } // if
-                        } catch( SemanticErrorException &e ) {
-                                errors.append( e );
-                        } // try
-                } // for
-                if ( ! errors.isEmpty() ) {
-                        throw errors;
-                } // if
-        }
-
         void box( std::list< Declaration *>& translationUnit ) {
                 PassVisitor<LayoutFunctionBuilder> layoutBuilder;
@@ -263 +245 @@
         ////////////////////////////////// LayoutFunctionBuilder ////////////////////////////////////////////
 
-        void LayoutFunctionBuilder::previsit( FunctionDecl *functionDecl ) {
-                visit_children = false;
-                maybeAccept( functionDecl->get_functionType(), *visitor );
-                ++functionNesting;
-                maybeAccept( functionDecl->get_statements(), *visitor );
-                --functionNesting;
-        }
-
         /// Get a list of type declarations that will affect a layout function
         std::list< TypeDecl* > takeOtypeOnly( std::list< TypeDecl* > &decls ) {
                 std::list< TypeDecl * > otypeDecls;
 
-                for ( std::list< TypeDecl* >::const_iterator decl = decls.begin(); decl != decls.end(); ++decl ) {
-                        if ( (*decl)->isComplete() ) {
-                                otypeDecls.push_back( *decl );
+                for ( TypeDecl * const decl : decls ) {
+                        if ( decl->isComplete() ) {
+                                otypeDecls.push_back( decl );
                         }
                 }
@@ -288 +262 @@
                 BasicType sizeAlignType( Type::Qualifiers(), BasicType::LongUnsignedInt );
 
-                for ( std::list< TypeDecl* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
-                        TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param );
+                for ( TypeDecl * const param : otypeParams ) {
+                        TypeInstType paramType( Type::Qualifiers(), param->get_name(), param );
                         std::string paramName = mangleType( &paramType );
                         layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
@@ -297 +271 @@
 
         /// Builds a layout function declaration
-        FunctionDecl *buildLayoutFunctionDecl( AggregateDecl *typeDecl, unsigned int functionNesting, FunctionType *layoutFnType ) {
+        FunctionDecl *buildLayoutFunctionDecl( AggregateDecl *typeDecl, bool isInFunction, FunctionType *layoutFnType ) {
                 // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
                 // because each unit generates copies of the default routines for each aggregate.
                 FunctionDecl *layoutDecl = new FunctionDecl( layoutofName( typeDecl ),
-                                                                                                         functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static ),
+                                                                                                         isInFunction ? Type::StorageClasses() : Type::StorageClasses( Type::Static ),
                                                                                                          LinkageSpec::AutoGen, layoutFnType, new CompoundStmt(),
                                                                                                          std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
                 layoutDecl->fixUniqueId();
                 return layoutDecl;
-        }
-
-        /// Makes a unary operation
-        Expression *makeOp( const std::string &name, Expression *arg ) {
-                UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
-                expr->args.push_back( arg );
-                return expr;
         }
 
@@ -380 +347 @@
 
                 // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl, functionNesting, layoutFnType );
+                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl, isInFunction(), layoutFnType );
 
                 // calculate struct layout in function body
@@ -387 +354 @@
                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant::from_ulong( 0 ) ) ) );
                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
-                unsigned long n_members = 0;
-                bool firstMember = true;
-                for ( Declaration* member : structDecl->get_members() ) {
-                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( member );
+                for ( auto index_member : enumerate( structDecl->members ) ) {
+                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( index_member.val );
                         assert( dwt );
                         Type *memberType = dwt->get_type();
 
-                        if ( firstMember ) {
-                                firstMember = false;
-                        } else {
+                        if ( 0 < index_member.idx ) {
                                 // make sure all members after the first (automatically aligned at 0) are properly padded for alignment
                                 addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), new AlignofExpr( memberType->clone() ) ) );
@@ -402 +365 @@
 
                         // place current size in the current offset index
-                        addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from_ulong( n_members ) ) ),
+                        addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from_ulong( index_member.idx ) ) ),
                                                                               derefVar( sizeParam ) ) );
-                        ++n_members;
 
                         // add member size to current size
@@ -439 +401 @@
 
                 // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl, functionNesting, layoutFnType );
+                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl, isInFunction(), layoutFnType );
 
                 // calculate union layout in function body
                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
-                for ( std::list< Declaration* >::const_iterator member = unionDecl->get_members().begin(); member != unionDecl->get_members().end(); ++member ) {
-                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member );
+                for ( Declaration * const member : unionDecl->members ) {
+                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( member );
                         assert( dwt );
                         Type *memberType = dwt->get_type();
@@ -464 +426 @@
 
         namespace {
-                std::string makePolyMonoSuffix( FunctionType * function, const TyVarMap &tyVars ) {
+                std::string makePolyMonoSuffix( FunctionType const * function, const TyVarMap &tyVars ) {
                         std::stringstream name;
 
@@ -473 +435 @@
                         // to take those polymorphic types as pointers. Therefore, there can be two different functions
                         // with the same mangled name, so we need to further mangle the names.
-                        for ( std::list< DeclarationWithType *>::iterator retval = function->get_returnVals().begin(); retval != function->get_returnVals().end(); ++retval ) {
-                                if ( isPolyType( (*retval)->get_type(), tyVars ) ) {
+                        for ( DeclarationWithType const * const ret : function->returnVals ) {
+                                if ( isPolyType( ret->get_type(), tyVars ) ) {
                                         name << "P";
                                 } else {
@@ -481 +443 @@
                         }
                         name << "_";
-                        std::list< DeclarationWithType *> &paramList = function->get_parameters();
-                        for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
-                                if ( isPolyType( (*arg)->get_type(), tyVars ) ) {
+                        for ( DeclarationWithType const * const arg : function->parameters ) {
+                                if ( isPolyType( arg->get_type(), tyVars ) ) {
                                         name << "P";
                                 } else {
@@ -492 +453 @@
                 }
 
-                std::string mangleAdapterName( FunctionType * function, const TyVarMap &tyVars ) {
+                std::string mangleAdapterName( FunctionType const * function, const TyVarMap &tyVars ) {
                         return SymTab::Mangler::mangle( function ) + makePolyMonoSuffix( function, tyVars );
                 }
@@ -499 +460 @@
                         return "_adapter" + mangleName;
                 }
+
+                /// Replaces a polymorphic type with its concrete equivalant under the current environment (returns itself if concrete).
+                /// If `doClone` is set to false, will not clone interior types
+                Type *replaceWithConcrete( Type *type, TypeSubstitution const * env, bool doClone = true );
 
                 Pass1::Pass1() : tempNamer( "_temp" ) {}
@@ -524 +489 @@
 
                                 std::list< DeclarationWithType *> &paramList = functionType->parameters;
-                                std::list< FunctionType *> functions;
-                                for ( Type::ForallList::iterator tyVar = functionType->forall.begin(); tyVar != functionType->forall.end(); ++tyVar ) {
-                                        for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) {
-                                                findFunction( (*assert)->get_type(), functions, scopeTyVars, needsAdapter );
+                                std::list< FunctionType const *> functions;
+                                for ( TypeDecl * const tyVar : functionType->forall ) {
+                                        for ( DeclarationWithType * const assert : tyVar->assertions ) {
+                                                findFunction( assert->get_type(), functions, scopeTyVars, needsAdapter );
                                         } // for
                                 } // for
-                                for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
-                                        findFunction( (*arg)->get_type(), functions, scopeTyVars, needsAdapter );
+                                for ( DeclarationWithType * const arg : paramList ) {
+                                        findFunction( arg->get_type(), functions, scopeTyVars, needsAdapter );
                                 } // for
 
-                                for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
-                                        std::string mangleName = mangleAdapterName( *funType, scopeTyVars );
+                                for ( FunctionType const * const funType : functions ) {
+                                        std::string mangleName = mangleAdapterName( funType, scopeTyVars );
                                         if ( adapters.find( mangleName ) == adapters.end() ) {
                                                 std::string adapterName = makeAdapterName( mangleName );
-                                                adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), nullptr ) ) );
+                                                adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( funType, scopeTyVars ) ), nullptr ) ) );
                                         } // if
                                 } // for
@@ -593 +558 @@
                 }
 
-                void Pass1::passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
+                std::list< Expression *>::iterator Pass1::passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, const TyVarMap &exprTyVars ) {
+                        assert( env );
+                        std::list< Expression *>::iterator arg = appExpr->args.begin();
                         // pass size/align for type variables
-                        for ( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) {
+                        for ( std::pair<std::string, TypeDecl::Data> const & tyParam : exprTyVars ) {
                                 ResolvExpr::EqvClass eqvClass;
-                                assert( env );
-                                if ( tyParm->second.isComplete ) {
-                                        Type *concrete = env->lookup( tyParm->first );
-                                        if ( concrete ) {
-                                                arg = appExpr->get_args().insert( arg, new SizeofExpr( concrete->clone() ) );
-                                                arg++;
-                                                arg = appExpr->get_args().insert( arg, new AlignofExpr( concrete->clone() ) );
-                                                arg++;
-                                        } else {
-                                                // xxx - should this be an assertion?
-                                                SemanticError( appExpr, toString( *env, "\nunbound type variable: ", tyParm->first, " in application " ) );
-                                        } // if
+                                if ( tyParam.second.isComplete ) {
+                                        Type *concrete = env->lookup( tyParam.first );
+                                        // If there is an unbound type variable, it should have detected already.
+                                        assertf( concrete, "Unbound type variable: %s in: %s",
+                                                toCString( tyParam.first ), toCString( *env ) );
+
+                                        arg = appExpr->get_args().insert( arg, new SizeofExpr( concrete->clone() ) );
+                                        arg++;
+                                        arg = appExpr->get_args().insert( arg, new AlignofExpr( concrete->clone() ) );
+                                        arg++;
                                 } // if
                         } // for
 
                         // add size/align for generic types to parameter list
-                        if ( ! appExpr->get_function()->result ) return;
+                        if ( ! appExpr->get_function()->result ) return arg;
                         FunctionType *funcType = getFunctionType( appExpr->get_function()->get_result() );
                         assert( funcType );
 
+                        // These iterators don't advance in unison.
                         std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin();
                         std::list< Expression* >::const_iterator fnArg = arg;
@@ -623 +589 @@
                         // a polymorphic return type may need to be added to the argument list
                         if ( polyRetType ) {
-                                Type *concRetType = replaceWithConcrete( appExpr, polyRetType );
+                                Type *concRetType = replaceWithConcrete( polyRetType, env );
                                 passArgTypeVars( appExpr, polyRetType, concRetType, arg, exprTyVars, seenTypes );
                                 ++fnArg; // skip the return parameter in the argument list
@@ -634 +600 @@
                                 passArgTypeVars( appExpr, (*fnParm)->get_type(), argType, arg, exprTyVars, seenTypes );
                         }
+                        return arg;
                 }
 
@@ -642 +609 @@
                 }
 
-                Expression *Pass1::addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg ) {
+                Expression *Pass1::addRetParam( ApplicationExpr *appExpr, Type *retType ) {
                         // Create temporary to hold return value of polymorphic function and produce that temporary as a result
                         // using a comma expression.
@@ -662 +629 @@
                                 paramExpr = new AddressExpr( paramExpr );
                         } // if
-                        arg = appExpr->args.insert( arg, paramExpr ); // add argument to function call
-                        arg++;
+                        // Add argument to function call.
+                        appExpr->args.push_front( paramExpr );
                         // Build a comma expression to call the function and emulate a normal return.
                         CommaExpr *commaExpr = new CommaExpr( appExpr, retExpr );
@@ -671 +638 @@
                 }
 
-                void Pass1::replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params ) {
-                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
+                /// Replaces all the type parameters of a generic type with their concrete equivalents under the current environment
+                void replaceParametersWithConcrete( std::list< Expression* >& params, TypeSubstitution const * env ) {
+                        for ( Expression * const param : params ) {
+                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( param );
                                 assertf(paramType, "Aggregate parameters should be type expressions");
-                                paramType->set_type( replaceWithConcrete( appExpr, paramType->get_type(), false ) );
-                        }
-                }
-
-                Type *Pass1::replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone ) {
+                                paramType->set_type( replaceWithConcrete( paramType->get_type(), env, false ) );
+                        }
+                }
+
+                // See forward definition.
+                Type *replaceWithConcrete( Type *type, TypeSubstitution const * env, bool doClone ) {
+                        assert( env );
                         if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
                                 Type *concrete = env->lookup( typeInst->get_name() );
@@ -690 +660 @@
                                         structType = structType->clone();
                                 }
-                                replaceParametersWithConcrete( appExpr, structType->get_parameters() );
+                                replaceParametersWithConcrete( structType->get_parameters(), env );
                                 return structType;
                         } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
@@ -696 +666 @@
                                         unionType = unionType->clone();
                                 }
-                                replaceParametersWithConcrete( appExpr, unionType->get_parameters() );
+                                replaceParametersWithConcrete( unionType->get_parameters(), env );
                                 return unionType;
                         }
@@ -702 +672 @@
                 }
 
-                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, Type *dynType, std::list< Expression *>::iterator &arg ) {
-                        assert( env );
-                        Type *concrete = replaceWithConcrete( appExpr, dynType );
+                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, Type *dynType ) {
+                        Type *concrete = replaceWithConcrete( dynType, env );
                         // add out-parameter for return value
-                        return addRetParam( appExpr, concrete, arg );
-                }
-
-                Expression *Pass1::applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) {
+                        return addRetParam( appExpr, concrete );
+                }
+
+                Expression *Pass1::applyAdapter( ApplicationExpr *appExpr, FunctionType *function ) {
                         Expression *ret = appExpr;
 //                      if ( ! function->get_returnVals().empty() && isPolyType( function->get_returnVals().front()->get_type(), tyVars ) ) {
-                        if ( isDynRet( function, tyVars ) ) {
-                                ret = addRetParam( appExpr, function->returnVals.front()->get_type(), arg );
+                        if ( isDynRet( function, scopeTyVars ) ) {
+                                ret = addRetParam( appExpr, function->returnVals.front()->get_type() );
                         } // if
-                        std::string mangleName = mangleAdapterName( function, tyVars );
+                        std::string mangleName = mangleAdapterName( function, scopeTyVars );
                         std::string adapterName = makeAdapterName( mangleName );
 
@@ -724 +693 @@
 
                         return ret;
-                }
-
-                void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
-                        assertf( arg->result, "arg does not have result: %s", toString( arg ).c_str() );
-                        if ( ! needsBoxing( param, arg->result, exprTyVars, env ) ) return;
-
-                        if ( arg->get_lvalue() ) {
-                                // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
-                                // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) {
-                                //      if ( dynamic_cast<ArrayType *>( varExpr->var->get_type() ) ){
-                                //              // temporary hack - don't box arrays, because &arr is not the same as &arr[0]
-                                //              return;
-                                //      }
-                                // }
-                                arg =  generalizedLvalue( new AddressExpr( arg ) );
-                                if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
-                                        // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
-                                        arg = new CastExpr( arg, param->clone() );
-                                }
-                        } else {
-                                // use type computed in unification to declare boxed variables
-                                Type * newType = param->clone();
-                                if ( env ) env->apply( newType );
-                                ObjectDecl *newObj = ObjectDecl::newObject( tempNamer.newName(), newType, nullptr );
-                                newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
-                                stmtsToAddBefore.push_back( new DeclStmt( newObj ) );
-                                UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); // TODO: why doesn't this just use initialization syntax?
-                                assign->get_args().push_back( new VariableExpr( newObj ) );
-                                assign->get_args().push_back( arg );
-                                stmtsToAddBefore.push_back( new ExprStmt( assign ) );
-                                arg = new AddressExpr( new VariableExpr( newObj ) );
-                        } // if
                 }
 
@@ -791 +728 @@
                 }
 
-                void Pass1::boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
-                        for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->parameters.end(); ++param, ++arg ) {
-                                assertf( arg != appExpr->args.end(), "boxParams: missing argument for param %s to %s in %s", toString( *param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
-                                addCast( *arg, (*param)->get_type(), exprTyVars );
-                                boxParam( (*param)->get_type(), *arg, exprTyVars );
+                void Pass1::boxParam( Expression *&arg, Type *param, const TyVarMap &exprTyVars ) {
+                        assertf( arg->result, "arg does not have result: %s", toString( arg ).c_str() );
+                        addCast( arg, param, exprTyVars );
+                        if ( ! needsBoxing( param, arg->result, exprTyVars, env ) ) return;
+
+                        if ( arg->get_lvalue() ) {
+                                // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
+                                // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) {
+                                //      if ( dynamic_cast<ArrayType *>( varExpr->var->get_type() ) ){
+                                //              // temporary hack - don't box arrays, because &arr is not the same as &arr[0]
+                                //              return;
+                                //      }
+                                // }
+                                arg = generalizedLvalue( new AddressExpr( arg ) );
+                                if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
+                                        // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
+                                        arg = new CastExpr( arg, param->clone() );
+                                }
+                        } else {
+                                // use type computed in unification to declare boxed variables
+                                Type * newType = param->clone();
+                                if ( env ) env->apply( newType );
+                                ObjectDecl *newObj = makeTemporary( newType );
+                                // TODO: is this right??? (Why wouldn't it be?)
+                                newObj->get_type()->get_qualifiers() = Type::Qualifiers();
+                                // TODO: why doesn't this just use initialization syntax?
+                                // (Possibly to ensure code is run at the right time.)
+                                UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
+                                assign->get_args().push_back( new VariableExpr( newObj ) );
+                                assign->get_args().push_back( arg );
+                                stmtsToAddBefore.push_back( new ExprStmt( assign ) );
+                                arg = new AddressExpr( new VariableExpr( newObj ) );
+                        } // if
+                }
+
+                void Pass1::boxParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *function, const TyVarMap &exprTyVars ) {
+                        for ( DeclarationWithType * param : function->parameters ) {
+                                assertf( arg != appExpr->args.end(), "boxParams: missing argument for param %s to %s in %s", toString( param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
+                                boxParam( *arg, param->get_type(), exprTyVars );
+                                ++arg;
                         } // for
                 }
 
-                void Pass1::addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) {
+                void Pass1::addInferredParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *functionType, const TyVarMap &tyVars ) {
                         std::list< Expression *>::iterator cur = arg;
-                        for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
-                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) {
-                                        InferredParams::const_iterator inferParam = appExpr->inferParams.find( (*assert)->get_uniqueId() );
-                                        assertf( inferParam != appExpr->inferParams.end(), "addInferredParams missing inferred parameter: %s in: %s", toString( *assert ).c_str(), toString( appExpr ).c_str() );
+                        for ( TypeDecl * const tyVar : functionType->forall ) {
+                                for ( DeclarationWithType * const assert : tyVar->assertions ) {
+                                        InferredParams::const_iterator inferParam = appExpr->inferParams.find( assert->get_uniqueId() );
+                                        assertf( inferParam != appExpr->inferParams.end(), "addInferredParams missing inferred parameter: %s in: %s", toString( assert ).c_str(), toString( appExpr ).c_str() );
                                         Expression *newExpr = inferParam->second.expr->clone();
-                                        addCast( newExpr, (*assert)->get_type(), tyVars );
-                                        boxParam( (*assert)->get_type(), newExpr, tyVars );
+                                        boxParam( newExpr, assert->get_type(), tyVars );
                                         appExpr->get_args().insert( cur, newExpr );
                                 } // for
@@ -824 +795 @@
                 }
 
-                FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars ) {
+                FunctionType *makeAdapterType( FunctionType const *adaptee, const TyVarMap &tyVars ) {
                         // actually make the adapter type
                         FunctionType *adapter = adaptee->clone();
@@ -834 +805 @@
                 }
 
-                Expression *makeAdapterArg( DeclarationWithType *param, DeclarationWithType *arg, DeclarationWithType *realParam, const TyVarMap &tyVars ) {
+                Expression *makeAdapterArg(
+                                DeclarationWithType *param,
+                                DeclarationWithType const *arg,
+                                DeclarationWithType const *realParam,
+                                const TyVarMap &tyVars ) {
                         assert( param );
                         assert( arg );
-                        if ( isPolyType( realParam->get_type(), tyVars ) ) {
-                                if ( ! isPolyType( arg->get_type() ) ) {
-                                        UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-                                        deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
-                                        deref->result = arg->get_type()->clone();
-                                        return deref;
-                                } // if
+                        if ( isPolyType( realParam->get_type(), tyVars )
+                                        && ! isPolyType( arg->get_type() ) ) {
+                                UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+                                deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
+                                deref->result = arg->get_type()->clone();
+                                return deref;
                         } // if
                         return new VariableExpr( param );
                 }
 
-                void addAdapterParams( ApplicationExpr *adapteeApp, std::list< DeclarationWithType *>::iterator arg, std::list< DeclarationWithType *>::iterator param, std::list< DeclarationWithType *>::iterator paramEnd, std::list< DeclarationWithType *>::iterator realParam, const TyVarMap &tyVars ) {
+                void addAdapterParams(
+                                ApplicationExpr *adapteeApp,
+                                std::list< DeclarationWithType *>::const_iterator arg,
+                                std::list< DeclarationWithType *>::const_iterator param,
+                                std::list< DeclarationWithType *>::const_iterator paramEnd,
+                                std::list< DeclarationWithType *>::const_iterator realParam,
+                                const TyVarMap &tyVars ) {
                         UniqueName paramNamer( "_p" );
                         for ( ; param != paramEnd; ++param, ++arg, ++realParam ) {
@@ -859 +839 @@
                 }
 
-                FunctionDecl *Pass1::makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
+                FunctionDecl *Pass1::makeAdapter( FunctionType const *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
                         FunctionType *adapterType = makeAdapterType( adaptee, tyVars );
                         adapterType = ScrubTyVars::scrub( adapterType, tyVars );
@@ -876 +856 @@
                         Statement *bodyStmt;
 
-                        Type::ForallList::iterator tyArg = realType->get_forall().begin();
-                        Type::ForallList::iterator tyParam = adapterType->get_forall().begin();
-                        Type::ForallList::iterator realTyParam = adaptee->get_forall().begin();
-                        for ( ; tyParam != adapterType->get_forall().end(); ++tyArg, ++tyParam, ++realTyParam ) {
-                                assert( tyArg != realType->get_forall().end() );
-                                std::list< DeclarationWithType *>::iterator assertArg = (*tyArg)->get_assertions().begin();
-                                std::list< DeclarationWithType *>::iterator assertParam = (*tyParam)->get_assertions().begin();
-                                std::list< DeclarationWithType *>::iterator realAssertParam = (*realTyParam)->get_assertions().begin();
-                                for ( ; assertParam != (*tyParam)->get_assertions().end(); ++assertArg, ++assertParam, ++realAssertParam ) {
-                                        assert( assertArg != (*tyArg)->get_assertions().end() );
-                                        adapteeApp->get_args().push_back( makeAdapterArg( *assertParam, *assertArg, *realAssertParam, tyVars ) );
+                        for ( auto tys : group_iterate( realType->forall, adapterType->forall, adaptee->forall ) ) {
+                                TypeDecl * tyArg = std::get<0>( tys );
+                                TypeDecl * tyParam = std::get<1>( tys );
+                                TypeDecl * realTyParam = std::get<2>( tys );
+                                for ( auto asserts : group_iterate( tyArg->assertions, tyParam->assertions, realTyParam->assertions ) ) {
+                                        DeclarationWithType * assertArg = std::get<0>( asserts );
+                                        DeclarationWithType * assertParam = std::get<1>( asserts );
+                                        DeclarationWithType * realAssertParam = std::get<2>( asserts );
+                                        adapteeApp->args.push_back( makeAdapterArg( assertParam, assertArg, realAssertParam, tyVars ) );
                                 } // for
                         } // for
 
-                        std::list< DeclarationWithType *>::iterator arg = realType->get_parameters().begin();
-                        std::list< DeclarationWithType *>::iterator param = adapterType->get_parameters().begin();
-                        std::list< DeclarationWithType *>::iterator realParam = adaptee->get_parameters().begin();
+                        std::list< DeclarationWithType *>::const_iterator arg = realType->parameters.begin();
+                        std::list< DeclarationWithType *>::const_iterator param = adapterType->parameters.begin();
+                        std::list< DeclarationWithType *>::const_iterator realParam = adaptee->parameters.begin();
                         param++;                // skip adaptee parameter in the adapter type
                         if ( realType->get_returnVals().empty() ) {
@@ -898 +876 @@
                                 addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
                                 bodyStmt = new ExprStmt( adapteeApp );
-                        } else if ( isDynType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
+                        } else if ( isDynType( adaptee->returnVals.front()->get_type(), tyVars ) ) {
                                 // return type T
                                 if ( (*param)->get_name() == "" ) {
@@ -923 +901 @@
                 void Pass1::passAdapters( ApplicationExpr * appExpr, FunctionType * functionType, const TyVarMap & exprTyVars ) {
                         // collect a list of function types passed as parameters or implicit parameters (assertions)
-                        std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
-                        std::list< FunctionType *> functions;
-                        for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
-                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
-                                        findFunction( (*assert)->get_type(), functions, exprTyVars, needsAdapter );
+                        std::list<FunctionType const *> functions;
+                        for ( TypeDecl * const tyVar : functionType->get_forall() ) {
+                                for ( DeclarationWithType * const assert : tyVar->get_assertions() ) {
+                                        findFunction( assert->get_type(), functions, exprTyVars, needsAdapter );
                                 } // for
                         } // for
-                        for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
-                                findFunction( (*arg)->get_type(), functions, exprTyVars, needsAdapter );
+                        for ( DeclarationWithType * const arg : functionType->get_parameters() ) {
+                                findFunction( arg->get_type(), functions, exprTyVars, needsAdapter );
                         } // for
 
@@ -938 +915 @@
                         std::set< std::string > adaptersDone;
 
-                        for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
-                                FunctionType *originalFunction = (*funType)->clone();
-                                FunctionType *realFunction = (*funType)->clone();
+                        for ( FunctionType const * const funType : functions ) {
+                                FunctionType *originalFunction = funType->clone();
+                                FunctionType *realFunction = funType->clone();
                                 std::string mangleName = SymTab::Mangler::mangle( realFunction );
 
@@ -958 +935 @@
                                         if ( adapter == adapters.end() ) {
                                                 // adapter has not been created yet in the current scope, so define it
-                                                FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars );
+                                                FunctionDecl *newAdapter = makeAdapter( funType, realFunction, mangleName, exprTyVars );
                                                 std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) );
                                                 adapter = answer.first;
@@ -972 +949 @@
 
                 Expression *makeIncrDecrExpr( ApplicationExpr *appExpr, Type *polyType, bool isIncr ) {
-                        NameExpr *opExpr;
-                        if ( isIncr ) {
-                                opExpr = new NameExpr( "?+=?" );
-                        } else {
-                                opExpr = new NameExpr( "?-=?" );
-                        } // if
+                        NameExpr *opExpr = new NameExpr( ( isIncr ) ? "?+=?" : "?-=?" );
                         UntypedExpr *addAssign = new UntypedExpr( opExpr );
                         if ( AddressExpr *address = dynamic_cast< AddressExpr *>( appExpr->get_args().front() ) ) {
@@ -1120 +1092 @@
                 Expression *Pass1::postmutate( ApplicationExpr *appExpr ) {
                         // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl;
-                        // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
-                        //      std::cerr << i->first << " ";
+                        // for ( auto tyVar : scopeTyVars ) {
+                        //      std::cerr << tyVar.first << " ";
                         // }
                         // std::cerr << "\n";
@@ -1134 +1106 @@
 
                         Expression *ret = appExpr;
-
-                        std::list< Expression *>::iterator arg = appExpr->get_args().begin();
                         std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
 
@@ -1156 +1126 @@
                                 // std::cerr << "dynRetType: " << dynRetType << std::endl;
                                 Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();
-                                ret = addDynRetParam( appExpr, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType
+                                ret = addDynRetParam( appExpr, concRetType ); // xxx - used to use dynRetType instead of concRetType
                         } else if ( needsAdapter( function, scopeTyVars ) && ! needsAdapter( function, exprTyVars) ) { // xxx - exprTyVars is used above...?
                                 // xxx - the ! needsAdapter check may be incorrect. It seems there is some situation where an adapter is applied where it shouldn't be, and this fixes it for some cases. More investigation is needed.
@@ -1164 +1134 @@
                                 // std::cerr << *env << std::endl;
                                 // change the application so it calls the adapter rather than the passed function
-                                ret = applyAdapter( appExpr, function, arg, scopeTyVars );
+                                ret = applyAdapter( appExpr, function );
                         } // if
-                        arg = appExpr->get_args().begin();
-
-                        Type *concRetType = replaceWithConcrete( appExpr, dynRetType );
-                        passTypeVars( appExpr, concRetType, arg, exprTyVars ); // xxx - used to use dynRetType instead of concRetType; this changed so that the correct type paramaters are passed for return types (it should be the concrete type's parameters, not the formal type's)
-                        addInferredParams( appExpr, function, arg, exprTyVars );
-
-                        arg = paramBegin;
-
-                        boxParams( appExpr, function, arg, exprTyVars );
+
+                        Type *concRetType = replaceWithConcrete( dynRetType, env );
+                        std::list< Expression *>::iterator arg =
+                                passTypeVars( appExpr, concRetType, exprTyVars ); // xxx - used to use dynRetType instead of concRetType; this changed so that the correct type paramaters are passed for return types (it should be the concrete type's parameters, not the formal type's)
+                        addInferredParams( appExpr, arg, function, exprTyVars );
+
+                        // This needs to point at the original first argument.
+                        boxParams( appExpr, paramBegin, function, exprTyVars );
+
                         passAdapters( appExpr, function, exprTyVars );
 
@@ -1180 +1150 @@
                 }
 
-                Expression * Pass1::postmutate( UntypedExpr *expr ) {
+                bool isPolyDeref( UntypedExpr const * expr, TyVarMap const & scopeTyVars, TypeSubstitution const * env ) {
                         if ( expr->result && isPolyType( expr->result, scopeTyVars, env ) ) {
-                                if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->function ) ) {
+                                if ( auto name = dynamic_cast<NameExpr const *>( expr->function ) ) {
                                         if ( name->name == "*?" ) {
-                                                Expression *ret = expr->args.front();
-                                                expr->args.clear();
-                                                delete expr;
-                                                return ret;
+                                                return true;
                                         } // if
                                 } // if
                         } // if
+                        return false;
+                }
+
+                Expression * Pass1::postmutate( UntypedExpr *expr ) {
+                        if ( isPolyDeref( expr, scopeTyVars, env ) ) {
+                                Expression *ret = expr->args.front();
+                                expr->args.clear();
+                                delete expr;
+                                return ret;
+                        }
                         return expr;
                 }
@@ -1200 +1177 @@
                         bool needs = false;
                         if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->arg ) ) {
-                                if ( expr->result && isPolyType( expr->result, scopeTyVars, env ) ) {
-                                        if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->function ) ) {
-                                                if ( name->name == "*?" ) {
-                                                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->args.front() ) ) {
-                                                                assert( appExpr->function->result );
-                                                                FunctionType *function = getFunctionType( appExpr->function->result );
-                                                                assert( function );
-                                                                needs = needsAdapter( function, scopeTyVars );
-                                                        } // if
-                                                } // if
+                                if ( isPolyDeref( expr, scopeTyVars, env ) ) {
+                                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->args.front() ) ) {
+                                                assert( appExpr->function->result );
+                                                FunctionType *function = getFunctionType( appExpr->function->result );
+                                                assert( function );
+                                                needs = needsAdapter( function, scopeTyVars );
                                         } // if
                                 } // if
@@ -1260 +1233 @@
                 void Pass2::addAdapters( FunctionType *functionType ) {
                         std::list< DeclarationWithType *> &paramList = functionType->parameters;
-                        std::list< FunctionType *> functions;
-                        for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
-                                Type *orig = (*arg)->get_type();
+                        std::list< FunctionType const *> functions;
+                        for ( DeclarationWithType * const arg : functionType->parameters ) {
+                                Type *orig = arg->get_type();
                                 findAndReplaceFunction( orig, functions, scopeTyVars, needsAdapter );
-                                (*arg)->set_type( orig );
+                                arg->set_type( orig );
                         }
                         std::set< std::string > adaptersDone;
-                        for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
-                                std::string mangleName = mangleAdapterName( *funType, scopeTyVars );
+                        for ( FunctionType const * const funType : functions ) {
+                                std::string mangleName = mangleAdapterName( funType, scopeTyVars );
                                 if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
                                         std::string adapterName = makeAdapterName( mangleName );
                                         // adapter may not be used in body, pass along with unused attribute.
-                                        paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0, { new Attribute( "unused" ) } ) );
+                                        paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( funType, scopeTyVars ) ), 0, { new Attribute( "unused" ) } ) );
                                         adaptersDone.insert( adaptersDone.begin(), mangleName );
                                 }
@@ -1349 +1322 @@
                         ObjectDecl newPtr( "", Type::StorageClasses(), LinkageSpec::C, 0,
                                            new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
-                        for ( Type::ForallList::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
+                        for ( TypeDecl * const tyParam : funcType->get_forall() ) {
                                 ObjectDecl *sizeParm, *alignParm;
                                 // add all size and alignment parameters to parameter list
-                                if ( (*tyParm)->isComplete() ) {
-                                        TypeInstType parmType( Type::Qualifiers(), (*tyParm)->get_name(), *tyParm );
+                                if ( tyParam->isComplete() ) {
+                                        TypeInstType parmType( Type::Qualifiers(), tyParam->get_name(), tyParam );
                                         std::string parmName = mangleType( &parmType );
 
@@ -1367 +1340 @@
                                 }
                                 // move all assertions into parameter list
-                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
+                                for ( DeclarationWithType * const assert : tyParam->get_assertions() ) {
                                         // assertion parameters may not be used in body, pass along with unused attribute.
-                                        (*assert)->get_attributes().push_back( new Attribute( "unused" ) );
-                                        inferredParams.push_back( *assert );
-                                }
-                                (*tyParm)->get_assertions().clear();
+                                        assert->get_attributes().push_back( new Attribute( "unused" ) );
+                                        inferredParams.push_back( assert );
+                                }
+                                tyParam->get_assertions().clear();
                         }
 
                         // add size/align for generic parameter types to parameter list
                         std::set< std::string > seenTypes; // sizeofName for generic types we've seen
-                        for ( std::list< DeclarationWithType* >::const_iterator fnParm = last; fnParm != funcType->get_parameters().end(); ++fnParm ) {
-                                Type *polyType = isPolyType( (*fnParm)->get_type(), scopeTyVars );
+                        for ( DeclarationWithType * const fnParam : funcType->get_parameters() ) {
+                                Type *polyType = isPolyType( fnParam->get_type(), scopeTyVars );
                                 if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
                                         std::string typeName = mangleType( polyType );
@@ -1482 +1455 @@
 
                         if(!expect_func_type) {
-                                GuardAction( [this]() {
-                                        knownLayouts.endScope();
-                                        knownOffsets.endScope();
-                                });
                                 // If this is the first function type we see
                                 // Then it's the type of the declaration and we care about it
-                                knownLayouts.beginScope();
-                                knownOffsets.beginScope();
+                                GuardScope( *this );
                         }
 
@@ -1497 +1465 @@
 
                         // make sure that any type information passed into the function is accounted for
-                        for ( std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin(); fnParm != funcType->get_parameters().end(); ++fnParm ) {
+                        for ( DeclarationWithType * const fnParam : funcType->get_parameters() ) {
                                 // condition here duplicates that in Pass2::mutate( FunctionType* )
-                                Type *polyType = isPolyType( (*fnParm)->get_type(), scopeTyVars );
+                                Type *polyType = isPolyType( fnParam->get_type(), scopeTyVars );
                                 if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
                                         knownLayouts.insert( mangleType( polyType ) );
@@ -1507 +1475 @@
 
                 /// converts polymorphic type T into a suitable monomorphic representation, currently: __attribute__((aligned(8)) char[size_T]
-                Type * polyToMonoType( Type * declType ) {
+                Type * polyToMonoType( Type const * declType ) {
                         Type * charType = new BasicType( Type::Qualifiers(), BasicType::Kind::Char);
                         Expression * size = new NameExpr( sizeofName( mangleType(declType) ) );
@@ -1572 +1540 @@
                 /// Finds the member in the base list that matches the given declaration; returns its index, or -1 if not present
                 long findMember( DeclarationWithType *memberDecl, std::list< Declaration* > &baseDecls ) {
-                        long i = 0;
-                        for(std::list< Declaration* >::const_iterator decl = baseDecls.begin(); decl != baseDecls.end(); ++decl, ++i ) {
-                                if ( memberDecl->get_name() != (*decl)->get_name() )
+                        for ( auto pair : enumerate( baseDecls ) ) {
+                                Declaration * decl = pair.val;
+                                size_t i = pair.idx;
+                                if ( memberDecl->get_name() != decl->get_name() )
                                         continue;
 
                                 if ( memberDecl->get_name().empty() ) {
                                         // plan-9 field: match on unique_id
-                                        if ( memberDecl->get_uniqueId() == (*decl)->get_uniqueId() )
+                                        if ( memberDecl->get_uniqueId() == decl->get_uniqueId() )
                                                 return i;
                                         else
@@ -1585 +1554 @@
                                 }
 
-                                DeclarationWithType *declWithType = strict_dynamic_cast< DeclarationWithType* >( *decl );
+                                DeclarationWithType *declWithType = strict_dynamic_cast< DeclarationWithType* >( decl );
 
                                 if ( memberDecl->get_mangleName().empty() || declWithType->get_mangleName().empty() ) {
@@ -1603 +1572 @@
 
                 /// Returns an index expression into the offset array for a type
-                Expression *makeOffsetIndex( Type *objectType, long i ) {
+                Expression *makeOffsetIndex( Type const *objectType, long i ) {
                         ConstantExpr *fieldIndex = new ConstantExpr( Constant::from_ulong( i ) );
                         UntypedExpr *fieldOffset = new UntypedExpr( new NameExpr( "?[?]" ) );
@@ -1696 +1665 @@
 
                 void PolyGenericCalculator::addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams ) {
-                        for ( std::list< Type* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
-                                if ( findGeneric( *param ) ) {
+                        for ( Type * const param : otypeParams ) {
+                                if ( findGeneric( param ) ) {
                                         // push size/align vars for a generic parameter back
-                                        std::string paramName = mangleType( *param );
+                                        std::string paramName = mangleType( param );
                                         layoutCall->get_args().push_back( new NameExpr( sizeofName( paramName ) ) );
                                         layoutCall->get_args().push_back( new NameExpr( alignofName( paramName ) ) );
                                 } else {
-                                        layoutCall->get_args().push_back( new SizeofExpr( (*param)->clone() ) );
-                                        layoutCall->get_args().push_back( new AlignofExpr( (*param)->clone() ) );
+                                        layoutCall->get_args().push_back( new SizeofExpr( param->clone() ) );
+                                        layoutCall->get_args().push_back( new AlignofExpr( param->clone() ) );
                                 }
                         }
@@ -1710 +1679 @@
 
                 /// returns true if any of the otype parameters have a dynamic layout and puts all otype parameters in the output list
-                bool findGenericParams( std::list< TypeDecl* > &baseParams, std::list< Expression* > &typeParams, std::list< Type* > &out ) {
+                bool findGenericParams( std::list< TypeDecl* > const &baseParams, std::list< Expression* > const &typeParams, std::list< Type* > &out ) {
                         bool hasDynamicLayout = false;
 
-                        std::list< TypeDecl* >::const_iterator baseParam = baseParams.begin();
-                        std::list< Expression* >::const_iterator typeParam = typeParams.begin();
-                        for ( ; baseParam != baseParams.end() && typeParam != typeParams.end(); ++baseParam, ++typeParam ) {
+                        for ( auto paramPair : group_iterate( baseParams, typeParams ) ) {
+                                TypeDecl * baseParam = std::get<0>( paramPair );
+                                Expression * typeParam = std::get<1>( paramPair );
                                 // skip non-otype parameters
-                                if ( ! (*baseParam)->isComplete() ) continue;
-                                TypeExpr *typeExpr = dynamic_cast< TypeExpr* >( *typeParam );
+                                if ( ! baseParam->isComplete() ) continue;
+                                TypeExpr *typeExpr = dynamic_cast< TypeExpr* >( typeParam );
                                 assert( typeExpr && "all otype parameters should be type expressions" );
 
@@ -1725 +1694 @@
                                 if ( isPolyType( type ) ) hasDynamicLayout = true;
                         }
-                        assert( baseParam == baseParams.end() && typeParam == typeParams.end() );
 
                         return hasDynamicLayout;
                 }
 
-                bool PolyGenericCalculator::findGeneric( Type *ty ) {
+                bool PolyGenericCalculator::findGeneric( Type const *ty ) {
                         ty = replaceTypeInst( ty, env );
 
-                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
+                        if ( auto typeInst = dynamic_cast< TypeInstType const * >( ty ) ) {
                                 if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() ) {
                                         // NOTE assumes here that getting put in the scopeTyVars included having the layout variables set
@@ -1739 +1707 @@
                                 }
                                 return false;
-                        } else if ( StructInstType *structTy = dynamic_cast< StructInstType* >( ty ) ) {
+                        } else if ( auto structTy = dynamic_cast< StructInstType const * >( ty ) ) {
                                 // check if this type already has a layout generated for it
                                 std::string typeName = mangleType( ty );
@@ -1746 +1714 @@
                                 // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
                                 std::list< Type* > otypeParams;
-                                if ( ! findGenericParams( *structTy->get_baseParameters(), structTy->get_parameters(), otypeParams ) ) return false;
+                                if ( ! findGenericParams( *structTy->get_baseParameters(), structTy->parameters, otypeParams ) ) return false;
 
                                 // insert local variables for layout and generate call to layout function
@@ -1776 +1744 @@
 
                                 return true;
-                        } else if ( UnionInstType *unionTy = dynamic_cast< UnionInstType* >( ty ) ) {
+                        } else if ( auto unionTy = dynamic_cast< UnionInstType const * >( ty ) ) {
                                 // check if this type already has a layout generated for it
                                 std::string typeName = mangleType( ty );
@@ -1783 +1751 @@
                                 // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
                                 std::list< Type* > otypeParams;
-                                if ( ! findGenericParams( *unionTy->get_baseParameters(), unionTy->get_parameters(), otypeParams ) ) return false;
+                                if ( ! findGenericParams( *unionTy->get_baseParameters(), unionTy->parameters, otypeParams ) ) return false;
 
                                 // insert local variables for layout and generate call to layout function
@@ -1881 +1849 @@
                                         // build initializer list for offset array
                                         std::list< Initializer* > inits;
-                                        for ( std::list< Declaration* >::const_iterator member = baseMembers.begin(); member != baseMembers.end(); ++member ) {
-                                                if ( DeclarationWithType *memberDecl = dynamic_cast< DeclarationWithType* >( *member ) ) {
-                                                        inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
-                                                } else {
-                                                        assertf( false, "Requesting offset of Non-DWT member: %s", toString( *member ).c_str() );
-                                                }
+                                        for ( Declaration * const member : baseMembers ) {
+                                                DeclarationWithType *memberDecl = dynamic_cast< DeclarationWithType* >( member );
+                                                assertf( memberDecl, "Requesting offset of Non-DWT member: %s", toString( member ).c_str() );
+                                                inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
                                         }
 
@@ -1965 +1931 @@
 // compile-command: "make install" //
 // End: //
+