Changeset b1e63ac5 for src/GenPoly

Timestamp:

Jul 4, 2017, 9:40:16 AM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

208e5be

Parents:

9c951e3 (diff), f7cb0bc (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' into references

Location:

src/GenPoly

Files:

• Box.cc (modified) (23 diffs)
• CopyParams.cc (modified) (1 diff)
• DeclMutator.cc (modified) (15 diffs)
• InstantiateGeneric.cc (modified) (11 diffs)
• Lvalue.cc (modified) (1 diff)
• PolyMutator.cc (modified) (2 diffs)
• Specialize.cc (modified) (3 diffs)

src/GenPoly/Box.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat May 13 09:26:38 2017
-// Update Count     : 341
+// Last Modified On : Wed Jun 21 15:49:59 2017
+// Update Count     : 346
 //
 
@@ -62 +62 @@
 namespace GenPoly {
         namespace {
-                const std::list<Label> noLabels;
-
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
 
@@ -103 +101 @@
                         void passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         /// wraps a function application with a new temporary for the out-parameter return value
-                        Expression *addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg );
+                        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 );
@@ -110 +108 @@
                         Type *replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone = true );
                         /// wraps a function application returning a polymorphic type with a new temporary for the out-parameter return value
-                        Expression *addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *polyType, std::list< Expression *>::iterator &arg );
+                        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 );
@@ -136 +134 @@
                   public:
                         template< typename DeclClass >
-                        DeclClass *handleDecl( DeclClass *decl, Type *type );
+                        DeclClass *handleDecl( DeclClass *decl );
                         template< typename AggDecl >
                         AggDecl * handleAggDecl( AggDecl * aggDecl );
@@ -343 +341 @@
         Statement *makeAlignTo( Expression *lhs, Expression *rhs ) {
                 // check that the lhs is zeroed out to the level of rhs
-                Expression *ifCond = makeOp( "?&?", lhs, makeOp( "?-?", rhs, new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), "1" ) ) ) );
+                Expression *ifCond = makeOp( "?&?", lhs, makeOp( "?-?", rhs, new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
                 // if not aligned, increment to alignment
                 Expression *ifExpr = makeOp( "?+=?", lhs->clone(), makeOp( "?-?", rhs->clone(), ifCond->clone() ) );
@@ -386 +384 @@
 
                 // initialize size and alignment to 0 and 1 (will have at least one member to re-edit size)
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "0" ) ) ) );
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
+                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;
@@ -443 +441 @@
 
                 // calculate union layout in function body
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
+                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 );
@@ -506 +504 @@
                 DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
                         if ( functionDecl->get_statements() ) {         // empty routine body ?
+                                // std::cerr << "mutating function: " << functionDecl->get_mangleName() << std::endl;
                                 doBeginScope();
                                 scopeTyVars.beginScope();
@@ -550 +549 @@
                                 retval = oldRetval;
                                 doEndScope();
+                                // std::cerr << "end function: " << functionDecl->get_mangleName() << std::endl;
                         } // if
                         return functionDecl;
@@ -665 +665 @@
                 }
 
-                Expression *Pass1::addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg ) {
+                Expression *Pass1::addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg ) {
                         // Create temporary to hold return value of polymorphic function and produce that temporary as a result
                         // using a comma expression.
@@ -728 +728 @@
                 }
 
-                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *dynType, std::list< Expression *>::iterator &arg ) {
+                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, Type *dynType, std::list< Expression *>::iterator &arg ) {
                         assert( env );
                         Type *concrete = replaceWithConcrete( appExpr, dynType );
                         // add out-parameter for return value
-                        return addRetParam( appExpr, function, concrete, arg );
+                        return addRetParam( appExpr, concrete, arg );
                 }
 
@@ -739 +739 @@
 //                      if ( ! function->get_returnVals().empty() && isPolyType( function->get_returnVals().front()->get_type(), tyVars ) ) {
                         if ( isDynRet( function, tyVars ) ) {
-                                ret = addRetParam( appExpr, function, function->get_returnVals().front()->get_type(), arg );
+                                ret = addRetParam( appExpr, function->get_returnVals().front()->get_type(), arg );
                         } // if
                         std::string mangleName = mangleAdapterName( function, tyVars );
@@ -1118 +1118 @@
 
                 Expression *Pass1::mutate( ApplicationExpr *appExpr ) {
-                        // std::cerr << "mutate appExpr: ";
+                        // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl;
                         // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
                         //      std::cerr << i->first << " ";
@@ -1143 +1143 @@
                         ReferenceToType *dynRetType = isDynRet( function, exprTyVars );
 
+                        // std::cerr << function << std::endl;
+                        // std::cerr << "scopeTyVars: ";
+                        // printTyVarMap( std::cerr, scopeTyVars );
+                        // std::cerr << "exprTyVars: ";
+                        // printTyVarMap( std::cerr, exprTyVars );
+                        // std::cerr << "env: " << *env << std::endl;
+                        // std::cerr << needsAdapter( function, scopeTyVars ) << ! needsAdapter( function, exprTyVars) << std::endl;
+
                         // NOTE: addDynRetParam needs to know the actual (generated) return type so it can make a temp variable, so pass the result type from the appExpr
                         // passTypeVars needs to know the program-text return type (i.e. the distinction between _conc_T30 and T3(int))
                         // concRetType may not be a good name in one or both of these places. A more appropriate name change is welcome.
                         if ( dynRetType ) {
+                                // std::cerr << "dynRetType: " << dynRetType << std::endl;
                                 Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();
-                                ret = addDynRetParam( appExpr, function, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType
+                                ret = addDynRetParam( appExpr, concRetType, arg ); // 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.
@@ -1282 +1291 @@
 
                 template< typename DeclClass >
-                DeclClass * Pass2::handleDecl( DeclClass *decl, Type *type ) {
+                DeclClass * Pass2::handleDecl( DeclClass *decl ) {
                         DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
 
@@ -1296 +1305 @@
 
                 DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) {
-                        functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl, functionDecl->get_functionType() ) );
+                        functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
                         FunctionType * ftype = functionDecl->get_functionType();
                         if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
@@ -1321 +1330 @@
 
                 ObjectDecl * Pass2::mutate( ObjectDecl *objectDecl ) {
-                        return handleDecl( objectDecl, objectDecl->get_type() );
+                        return handleDecl( objectDecl );
                 }
 
@@ -1344 +1353 @@
                         addToTyVarMap( typeDecl, scopeTyVars );
                         if ( typeDecl->get_base() ) {
-                                return handleDecl( typeDecl, typeDecl->get_base() );
+                                return handleDecl( typeDecl );
                         } else {
                                 return Parent::mutate( typeDecl );
@@ -1351 +1360 @@
 
                 TypedefDecl * Pass2::mutate( TypedefDecl *typedefDecl ) {
-                        return handleDecl( typedefDecl, typedefDecl->get_base() );
+                        return handleDecl( typedefDecl );
                 }
 
@@ -1566 +1575 @@
                 /// Returns an index expression into the offset array for a type
                 Expression *makeOffsetIndex( Type *objectType, long i ) {
-                        std::stringstream offset_namer;
-                        offset_namer << i;
-                        ConstantExpr *fieldIndex = new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), offset_namer.str() ) );
+                        ConstantExpr *fieldIndex = new ConstantExpr( Constant::from_ulong( i ) );
                         UntypedExpr *fieldOffset = new UntypedExpr( new NameExpr( "?[?]" ) );
                         fieldOffset->get_args().push_back( new NameExpr( offsetofName( mangleType( objectType ) ) ) );
@@ -1781 +1788 @@
                                 // all union members are at offset zero
                                 delete offsetofExpr;
-                                return new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), "0" ) );
+                                return new ConstantExpr( Constant::from_ulong( 0 ) );
                         } else return offsetofExpr;
                 }
@@ -1806 +1813 @@
                                         std::list< Initializer* > inits;
                                         for ( std::list< Declaration* >::const_iterator member = baseMembers.begin(); member != baseMembers.end(); ++member ) {
-                                                DeclarationWithType *memberDecl;
-                                                if ( DeclarationWithType *origMember = dynamic_cast< DeclarationWithType* >( *member ) ) {
-                                                        memberDecl = origMember->clone();
+                                                if ( DeclarationWithType *memberDecl = dynamic_cast< DeclarationWithType* >( *member ) ) {
+                                                        inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
                                                 } else {
-                                                        memberDecl = new ObjectDecl( (*member)->get_name(), Type::StorageClasses(), LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
+                                                        assertf( false, "Requesting offset of Non-DWT member: %s", toString( *member ).c_str() );
                                                 }
-                                                inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
                                         }
 

src/GenPoly/CopyParams.cc

@@ -45 +45 @@
 
         CopyParams::CopyParams() : namer( "_cp" ) {}
-
-        static const std::list< Label > noLabels;
 
         void CopyParams::visit( FunctionDecl *funcDecl ) {

src/GenPoly/DeclMutator.cc

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Fri Nov 27 14:44:00 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug  4 11:16:43 2016
-// Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jun 22 13:49:00 2017
+// Update Count     : 4
 //
 
@@ -20 +20 @@
 
 namespace GenPoly {
-        namespace {
-                const std::list<Label> noLabels;
-        }
-
         DeclMutator::DeclMutator() : Mutator(), declsToAdd(1), declsToAddAfter(1) {}
 
         DeclMutator::~DeclMutator() {}
-        
+
         void DeclMutator::mutateDeclarationList( std::list< Declaration* > &decls ) {
                 for ( std::list< Declaration* >::iterator decl = decls.begin(); ; ++decl ) {
@@ -34 +30 @@
 
                         if ( decl == decls.end() ) break;
-                        
+
                         // run mutator on declaration
                         *decl = maybeMutate( *decl, *this );
@@ -55 +51 @@
                 newBack->splice( newBack->end(), *back );
                 declsToAdd.pop_back();
-                
+
                 back = declsToAddAfter.rbegin();
                 newBack = back + 1;
@@ -66 +62 @@
                 CompoundStmt *compoundStmt = dynamic_cast< CompoundStmt* >(stmt);
                 if ( compoundStmt ) return mutate( compoundStmt );
-                
+
                 doBeginScope();
-                
+
                 // run mutator on statement
                 stmt = maybeMutate( stmt, *this );
@@ -102 +98 @@
                 doBeginScope();
 
-                
+
                 for ( std::list< Statement* >::iterator stmt = stmts.begin(); ; ++stmt ) {
                         // add any new declarations after the previous statement
@@ -112 +108 @@
 
                         if ( stmt == stmts.end() ) break;
-                        
+
                         // run mutator on statement
                         *stmt = maybeMutate( *stmt, *this );
@@ -123 +119 @@
                         declsToAdd.back().clear();
                 }
-                
+
                 doEndScope();
         }
@@ -139 +135 @@
                 return compoundStmt;
         }
-        
+
         Statement* DeclMutator::mutate(IfStmt *ifStmt) {
                 ifStmt->set_condition( maybeMutate( ifStmt->get_condition(), *this ) );
@@ -146 +142 @@
                 return ifStmt;
         }
-        
+
         Statement* DeclMutator::mutate(WhileStmt *whileStmt) {
                 whileStmt->set_condition( maybeMutate( whileStmt->get_condition(), *this ) );
@@ -152 +148 @@
                 return whileStmt;
         }
-        
+
         Statement* DeclMutator::mutate(ForStmt *forStmt) {
                 mutateAll( forStmt->get_initialization(), *this );
@@ -160 +156 @@
                 return forStmt;
         }
-        
+
         Statement* DeclMutator::mutate(SwitchStmt *switchStmt) {
                 switchStmt->set_condition( maybeMutate( switchStmt->get_condition(), *this ) );
@@ -166 +162 @@
                 return switchStmt;
         }
-        
+
         Statement* DeclMutator::mutate(CaseStmt *caseStmt) {
                 caseStmt->set_condition( maybeMutate( caseStmt->get_condition(), *this ) );
@@ -172 +168 @@
                 return caseStmt;
         }
-        
+
         Statement* DeclMutator::mutate(TryStmt *tryStmt) {
                 tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
@@ -179 +175 @@
                 return tryStmt;
         }
-        
+
         Statement* DeclMutator::mutate(CatchStmt *catchStmt) {
                 catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) );
+                catchStmt->set_cond( maybeMutate( catchStmt->get_cond(), *this ) );
                 catchStmt->set_body( mutateStatement( catchStmt->get_body() ) );
                 return catchStmt;

src/GenPoly/InstantiateGeneric.cc

@@ -22 +22 @@
 #include "InstantiateGeneric.h"
 
-#include "DeclMutator.h"
 #include "GenPoly.h"
 #include "ScopedSet.h"
 #include "ScrubTyVars.h"
-#include "PolyMutator.h"
+
+#include "Common/PassVisitor.h"
+#include "Common/ScopedMap.h"
+#include "Common/UniqueName.h"
+#include "Common/utility.h"
 
 #include "ResolvExpr/typeops.h"
@@ -34 +37 @@
 #include "SynTree/Type.h"
 
-#include "Common/ScopedMap.h"
-#include "Common/UniqueName.h"
-#include "Common/utility.h"
+
+#include "InitTweak/InitTweak.h"
+
 
 namespace GenPoly {
@@ -153 +156 @@
         }
 
-        // collect the environments of each TypeInstType so that type variables can be replaced
-        // xxx - possibly temporary solution. Access to type environments is required in GenericInstantiator, but it needs to be a DeclMutator which does not provide easy access to the type environments.
-        class EnvFinder final : public GenPoly::PolyMutator {
-        public:
-                using GenPoly::PolyMutator::mutate;
-                virtual Type * mutate( TypeInstType * inst ) override {
-                        if ( env ) envMap[inst] = env;
-                        return inst;
-                }
-
-                // don't want to associate an environment with TypeInstTypes that occur in function types - this may actually only apply to function types belonging to DeclarationWithTypes (or even just FunctionDecl)?
-                virtual Type * mutate( FunctionType * ftype ) override {
-                        return ftype;
-                }
-                std::unordered_map< ReferenceToType *, TypeSubstitution * > envMap;
-        };
-
         /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
-        class GenericInstantiator final : public DeclMutator {
+        struct GenericInstantiator final : public WithTypeSubstitution, public WithDeclsToAdd, public WithVisitorRef<GenericInstantiator>, public WithGuards {
                 /// Map of (generic type, parameter list) pairs to concrete type instantiations
                 InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
@@ -178 +164 @@
                 /// Namer for concrete types
                 UniqueName typeNamer;
-                /// Reference to mapping of environments
-                const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap;
-        public:
-                GenericInstantiator( const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap ) : DeclMutator(), instantiations(), dtypeStatics(), typeNamer("_conc_"), envMap( envMap ) {}
-
-                using DeclMutator::mutate;
-                virtual Type* mutate( StructInstType *inst ) override;
-                virtual Type* mutate( UnionInstType *inst ) override;
-
-                virtual void doBeginScope() override;
-                virtual void doEndScope() override;
+                /// Should not make use of type environment to replace types of function parameter and return values.
+                bool inFunctionType = false;
+                GenericInstantiator() : instantiations(), dtypeStatics(), typeNamer("_conc_") {}
+
+                Type* postmutate( StructInstType *inst );
+                Type* postmutate( UnionInstType *inst );
+
+                void premutate( FunctionType * ftype ) {
+                        GuardValue( inFunctionType );
+                        inFunctionType = true;
+                }
+
+                void beginScope();
+                void endScope();
         private:
                 /// Wrap instantiation lookup for structs
@@ -207 +196 @@
 
         void instantiateGeneric( std::list< Declaration* > &translationUnit ) {
-                EnvFinder finder;
-                mutateAll( translationUnit, finder );
-                GenericInstantiator instantiator( finder.envMap );
-                instantiator.mutateDeclarationList( translationUnit );
+                PassVisitor<GenericInstantiator> instantiator;
+                mutateAll( translationUnit, instantiator );
         }
 
@@ -306 +293 @@
         Type *GenericInstantiator::replaceWithConcrete( Type *type, bool doClone ) {
                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
-                        if ( envMap.count( typeInst ) ) {
-                                TypeSubstitution * env = envMap.at( typeInst );
+                        if ( env && ! inFunctionType ) {
                                 Type *concrete = env->lookup( typeInst->get_name() );
                                 if ( concrete ) {
@@ -331 +317 @@
 
 
-        Type* GenericInstantiator::mutate( StructInstType *inst ) {
-                // mutate subtypes
-                Type *mutated = Mutator::mutate( inst );
-                inst = dynamic_cast< StructInstType* >( mutated );
-                if ( ! inst ) return mutated;
-
+        Type* GenericInstantiator::postmutate( StructInstType *inst ) {
                 // exit early if no need for further mutation
                 if ( inst->get_parameters().empty() ) return inst;
@@ -367 +348 @@
                                 concDecl->set_body( inst->get_baseStruct()->has_body() );
                                 substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
-                                DeclMutator::addDeclaration( concDecl );
-                                insert( inst, typeSubs, concDecl );
-                                concDecl->acceptMutator( *this ); // recursively instantiate members
+                                insert( inst, typeSubs, concDecl ); // must insert before recursion
+                                concDecl->acceptMutator( *visitor ); // recursively instantiate members
+                                declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first
                         }
                         StructInstType *newInst = new StructInstType( inst->get_qualifiers(), concDecl->get_name() );
@@ -388 +369 @@
         }
 
-        Type* GenericInstantiator::mutate( UnionInstType *inst ) {
-                // mutate subtypes
-                Type *mutated = Mutator::mutate( inst );
-                inst = dynamic_cast< UnionInstType* >( mutated );
-                if ( ! inst ) return mutated;
-
+        Type* GenericInstantiator::postmutate( UnionInstType *inst ) {
                 // exit early if no need for further mutation
                 if ( inst->get_parameters().empty() ) return inst;
@@ -422 +398 @@
                                 concDecl->set_body( inst->get_baseUnion()->has_body() );
                                 substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
-                                DeclMutator::addDeclaration( concDecl );
-                                insert( inst, typeSubs, concDecl );
-                                concDecl->acceptMutator( *this ); // recursively instantiate members
+                                insert( inst, typeSubs, concDecl ); // must insert before recursion
+                                concDecl->acceptMutator( *visitor ); // recursively instantiate members
+                                declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first
                         }
                         UnionInstType *newInst = new UnionInstType( inst->get_qualifiers(), concDecl->get_name() );
@@ -442 +418 @@
         }
 
-        void GenericInstantiator::doBeginScope() {
-                DeclMutator::doBeginScope();
+        void GenericInstantiator::beginScope() {
                 instantiations.beginScope();
                 dtypeStatics.beginScope();
         }
 
-        void GenericInstantiator::doEndScope() {
-                DeclMutator::doEndScope();
+        void GenericInstantiator::endScope() {
                 instantiations.endScope();
                 dtypeStatics.endScope();

src/GenPoly/Lvalue.cc

@@ -36 +36 @@
 namespace GenPoly {
         namespace {
-                const std::list<Label> noLabels;
-
                 /// Replace uses of lvalue returns with appropriate pointers
                 class Pass1 : public Mutator {

src/GenPoly/PolyMutator.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug  4 11:26:22 2016
-// Update Count     : 16
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jun 22 13:47:00 2017
+// Update Count     : 17
 //
 
@@ -123 +123 @@
 
         Statement * PolyMutator::mutate(TryStmt *tryStmt) {
-                tryStmt->set_block(  maybeMutate( tryStmt->get_block(), *this ) );
+                tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
                 mutateAll( tryStmt->get_catchers(), *this );
+                tryStmt->set_finally( maybeMutate( tryStmt->get_finally(), *this ) );
                 return tryStmt;
         }
 
         Statement * PolyMutator::mutate(CatchStmt *cathStmt) {
-                cathStmt->set_body(  mutateStatement( cathStmt->get_body() ) );
-                cathStmt->set_decl(  maybeMutate( cathStmt->get_decl(), *this ) );
+                cathStmt->set_body( mutateStatement( cathStmt->get_body() ) );
+                cathStmt->set_cond( maybeMutate( cathStmt->get_cond(), *this ) );
+                cathStmt->set_decl( maybeMutate( cathStmt->get_decl(), *this ) );
                 return cathStmt;
         }

src/GenPoly/Specialize.cc

@@ -93 +93 @@
         }
 
-        bool needsTupleSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
+        bool needsTupleSpecialization( Type *formalType, Type *actualType ) {
                 // Needs tuple specialization if the structure of the formal type and actual type do not match.
                 // This is the case if the formal type has ttype polymorphism, or if the structure  of tuple types
@@ -99 +99 @@
                 if ( FunctionType * fftype = getFunctionType( formalType ) ) {
                         if ( fftype->isTtype() ) return true;
+                        // conversion of 0 (null) to function type does not require tuple specialization
+                        if ( dynamic_cast< ZeroType * >( actualType ) ) return false;
                         FunctionType * aftype = getFunctionType( actualType );
                         assertf( aftype, "formal type is a function type, but actual type is not." );
@@ -112 +114 @@
 
         bool needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
-                return needsPolySpecialization( formalType, actualType, env ) || needsTupleSpecialization( formalType, actualType, env );
+                return needsPolySpecialization( formalType, actualType, env ) || needsTupleSpecialization( formalType, actualType );
         }