Changeset 2162c2c for src/GenPoly

Timestamp:

Jan 11, 2017, 4:11:02 PM (9 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

075734f

Parents:

bb82c03 (diff), d3a85240 (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

Location:

src/GenPoly

Files:

• Box.cc (modified) (9 diffs)
• InstantiateGeneric.cc (modified) (10 diffs)
• ScrubTyVars.cc (modified) (1 diff)
• Specialize.cc (modified) (11 diffs)

src/GenPoly/Box.cc

@@ -136 +136 @@
                         template< typename DeclClass >
                         DeclClass *handleDecl( DeclClass *decl, Type *type );
-
-                        using PolyMutator::mutate;
+                        template< typename AggDecl >
+                        AggDecl * handleAggDecl( AggDecl * aggDecl );
+
+                        typedef PolyMutator Parent;
+                        using Parent::mutate;
                         virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
                         virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
+                        virtual StructDecl *mutate( StructDecl *structDecl ) override;
+                        virtual UnionDecl *mutate( UnionDecl *unionDecl ) override;
                         virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
                         virtual TypedefDecl *mutate( TypedefDecl *typedefDecl ) override;
@@ -686 +691 @@
                         for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
                                 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assert(paramType && "Aggregate parameters should be type expressions");
+                                assertf(paramType, "Aggregate parameters should be type expressions");
                                 paramType->set_type( replaceWithConcrete( appExpr, paramType->get_type(), false ) );
                         }
@@ -783 +788 @@
                 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->get_parameters().end(); ++param, ++arg ) {
-                                assert( arg != appExpr->get_args().end() );
+                                assertf( arg != appExpr->get_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 );
@@ -1127 +1132 @@
                         makeTyVarMap( function, exprTyVars ); // xxx - should this take into account the variables already bound in scopeTyVars (i.e. remove them from exprTyVars?)
                         ReferenceToType *dynRetType = isDynRet( function, exprTyVars );
-                        Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();// ?: dynRetType; // xxx - is concRetType a good name?
-
+
+                        // 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 ) {
+                                Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();
                                 ret = addDynRetParam( appExpr, function, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType
                         } else if ( needsAdapter( function, scopeTyVars ) && ! needsAdapter( function, exprTyVars) ) { // xxx - exprTyVars is used above...?
@@ -1142 +1150 @@
                         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 );
@@ -1271 +1280 @@
                 template< typename DeclClass >
                 DeclClass * Pass2::handleDecl( DeclClass *decl, Type *type ) {
-                        DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
+                        DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
 
                         return ret;
@@ -1305 +1314 @@
                 }
 
+                template< typename AggDecl >
+                AggDecl * Pass2::handleAggDecl( AggDecl * aggDecl ) {
+                        // prevent tyVars from leaking into containing scope
+                        scopeTyVars.beginScope();
+                        Parent::mutate( aggDecl );
+                        scopeTyVars.endScope();
+                        return aggDecl;
+                }
+
+                StructDecl * Pass2::mutate( StructDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+
+                UnionDecl * Pass2::mutate( UnionDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+
                 TypeDecl * Pass2::mutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
@@ -1310 +1336 @@
                                 return handleDecl( typeDecl, typeDecl->get_base() );
                         } else {
-                                return Mutator::mutate( typeDecl );
+                                return Parent::mutate( typeDecl );
                         }
                 }
@@ -1322 +1348 @@
                         makeTyVarMap( pointerType, scopeTyVars );
 
-                        Type *ret = Mutator::mutate( pointerType );
+                        Type *ret = Parent::mutate( pointerType );
 
                         scopeTyVars.endScope();

src/GenPoly/InstantiateGeneric.cc

@@ -18 +18 @@
 #include <utility>
 #include <vector>
+#include <unordered_map>
 
 #include "InstantiateGeneric.h"
@@ -24 +25 @@
 #include "GenPoly.h"
 #include "ScopedSet.h"
+#include "PolyMutator.h"
 
 #include "ResolvExpr/typeops.h"
@@ -146 +148 @@
         }
 
+        // 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:
+                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 {
@@ -154 +172 @@
                 /// Namer for concrete types
                 UniqueName typeNamer;
-
+                /// Reference to mapping of environments
+                const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap;
         public:
-                GenericInstantiator() : DeclMutator(), instantiations(), dtypeStatics(), typeNamer("_conc_") {}
+                GenericInstantiator( const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap ) : DeclMutator(), instantiations(), dtypeStatics(), typeNamer("_conc_"), envMap( envMap ) {}
 
                 using DeclMutator::mutate;
@@ -174 +193 @@
                 void insert( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs, UnionDecl *decl ) { instantiations.insert( inst->get_baseUnion(), typeSubs, decl ); }
 
+                void replaceParametersWithConcrete( std::list< Expression* >& params );
+                Type *replaceWithConcrete( Type *type, bool doClone );
+
                 /// Strips a dtype-static aggregate decl of its type parameters, marks it as stripped
                 void stripDtypeParams( AggregateDecl *base, std::list< TypeDecl* >& baseParams, const std::list< TypeExpr* >& typeSubs );
@@ -179 +201 @@
 
         void instantiateGeneric( std::list< Declaration* > &translationUnit ) {
-                GenericInstantiator instantiator;
+                EnvFinder finder;
+                mutateAll( translationUnit, finder );
+                GenericInstantiator instantiator( finder.envMap );
                 instantiator.mutateDeclarationList( translationUnit );
         }
@@ -209 +233 @@
                                 // can pretend that any ftype is `void (*)(void)`
                                 out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
+                                break;
+                        case TypeDecl::Ttype:
+                                assertf( false, "Ttype parameters are not currently allowed as parameters to generic types." );
                                 break;
                         }
@@ -253 +280 @@
         }
 
+        /// xxx - more or less copied from box -- these should be merged with those somehow...
+        void GenericInstantiator::replaceParametersWithConcrete( std::list< Expression* >& params ) {
+                for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
+                        TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
+                        assertf(paramType, "Aggregate parameters should be type expressions");
+                        paramType->set_type( replaceWithConcrete( paramType->get_type(), false ) );
+                }
+        }
+
+        Type *GenericInstantiator::replaceWithConcrete( Type *type, bool doClone ) {
+                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
+                        if ( envMap.count( typeInst ) ) {
+                                TypeSubstitution * env = envMap.at( typeInst );
+                                Type *concrete = env->lookup( typeInst->get_name() );
+                                if ( concrete ) {
+                                        return concrete->clone();
+                                }
+                                else return typeInst->clone();
+                        }
+                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
+                        if ( doClone ) {
+                                structType = structType->clone();
+                        }
+                        replaceParametersWithConcrete( structType->get_parameters() );
+                        return structType;
+                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
+                        if ( doClone ) {
+                                unionType = unionType->clone();
+                        }
+                        replaceParametersWithConcrete( unionType->get_parameters() );
+                        return unionType;
+                }
+                return type;
+        }
+
+
         Type* GenericInstantiator::mutate( StructInstType *inst ) {
                 // mutate subtypes
@@ -262 +325 @@
                 if ( inst->get_parameters().empty() ) return inst;
 
+                // need to replace type variables to ensure that generic types are instantiated for the return values of polymorphic functions (in particular, for thunks, because they are not [currently] copy constructed).
+                replaceWithConcrete( inst, false );
+
                 // check for an already-instantiatiated dtype-static type
                 if ( dtypeStatics.find( inst->get_baseStruct() ) != dtypeStatics.end() ) {
@@ -269 +335 @@
 
                 // check if type can be concretely instantiated; put substitutions into typeSubs
-                assert( inst->get_baseParameters() && "Base struct has parameters" );
+                assertf( inst->get_baseParameters(), "Base struct has parameters" );
                 std::list< TypeExpr* > typeSubs;
                 genericType gt = makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs );

src/GenPoly/ScrubTyVars.cc

@@ -31 +31 @@
                           case TypeDecl::Any:
                           case TypeDecl::Dtype:
+                          case TypeDecl::Ttype:
                                 {
                                         PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );

src/GenPoly/Specialize.cc

@@ -32 +32 @@
 #include "Common/utility.h"
 #include "InitTweak/InitTweak.h"
+#include "Tuples/Tuples.h"
 
 namespace GenPoly {
-        const std::list<Label> noLabels;
-
+        class Specializer;
         class Specialize final : public PolyMutator {
+                friend class Specializer;
           public:
-                Specialize( std::string paramPrefix = "_p" );
-
                 using PolyMutator::mutate;
                 virtual Expression * mutate( ApplicationExpr *applicationExpr ) override;
@@ -48 +47 @@
                 // virtual Expression * mutate( CommaExpr *commaExpr );
 
-          private:
-                Expression *createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams = 0 );
-                Expression *doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams = 0 );
+                Specializer * specializer = nullptr;
                 void handleExplicitParams( ApplicationExpr *appExpr );
-
-                UniqueName thunkNamer;
-                std::string paramPrefix;
         };
 
-        void convertSpecializations( std::list< Declaration* >& translationUnit ) {
-                Specialize specializer;
-                mutateAll( translationUnit, specializer );
-        }
-
-        Specialize::Specialize( std::string paramPrefix )
-                : thunkNamer( "_thunk" ), paramPrefix( paramPrefix ) {
-        }
+        class Specializer {
+          public:
+                Specializer( Specialize & spec ) : spec( spec ), env( spec.env ), stmtsToAdd( spec.stmtsToAdd ) {}
+                virtual bool needsSpecialization( Type * formalType, Type * actualType, TypeSubstitution * env ) = 0;
+                virtual Expression *createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) = 0;
+                virtual Expression *doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams = 0 );
+
+          protected:
+                Specialize & spec;
+                std::string paramPrefix = "_p";
+                TypeSubstitution *& env;
+                std::list< Statement * > & stmtsToAdd;
+        };
+
+        // for normal polymorphic -> monomorphic function conversion
+        class PolySpecializer : public Specializer {
+          public:
+                PolySpecializer( Specialize & spec ) : Specializer( spec ) {}
+                virtual bool needsSpecialization( Type * formalType, Type * actualType, TypeSubstitution * env ) override;
+                virtual Expression *createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) override;
+        };
+
+        // // for tuple -> non-tuple function conversion
+        class TupleSpecializer : public Specializer {
+          public:
+                TupleSpecializer( Specialize & spec ) : Specializer( spec ) {}
+                virtual bool needsSpecialization( Type * formalType, Type * actualType, TypeSubstitution * env ) override;
+                virtual Expression *createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) override;
+        };
 
         /// Looks up open variables in actual type, returning true if any of them are bound in the environment or formal type.
-        bool needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
+        bool PolySpecializer::needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
                 if ( env ) {
                         using namespace ResolvExpr;
@@ -92 +107 @@
 
         /// Generates a thunk that calls `actual` with type `funType` and returns its address
-        Expression * Specialize::createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) {
+        Expression * PolySpecializer::createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) {
+                static UniqueName thunkNamer( "_thunk" );
+
                 FunctionType *newType = funType->clone();
                 if ( env ) {
-                        TypeSubstitution newEnv( *env );
                         // it is important to replace only occurrences of type variables that occur free in the
                         // thunk's type
-                        newEnv.applyFree( newType );
+                        env->applyFree( newType );
                 } // if
                 // create new thunk with same signature as formal type (C linkage, empty body)
@@ -125 +141 @@
                 std::list< Statement* > oldStmts;
                 oldStmts.splice( oldStmts.end(), stmtsToAdd );
-                handleExplicitParams( appExpr );
+                spec.handleExplicitParams( appExpr );
                 paramPrefix = oldParamPrefix;
                 // write any statements added for recursive specializations into the thunk body
@@ -147 +163 @@
         }
 
-        Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
+        Expression * Specializer::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
                 assertf( actual->has_result(), "attempting to specialize an untyped expression" );
                 if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
-                        FunctionType *funType;
-                        if ( ( funType = getFunctionType( formalType ) ) ) {
+                        if ( FunctionType *funType = getFunctionType( formalType ) ) {
                                 ApplicationExpr *appExpr;
                                 VariableExpr *varExpr;
@@ -170 +185 @@
         }
 
+        bool TupleSpecializer::needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
+                if ( FunctionType * ftype = getFunctionType( formalType ) ) {
+                        return ftype->isTtype();
+                }
+                return false;
+        }
+
+        /// restructures arg to match the structure of a single formal parameter. Assumes that atomic types are compatible (as the Resolver should have ensured this)
+        template< typename OutIterator >
+        void matchOneFormal( Expression * arg, unsigned & idx, Type * formal, OutIterator out ) {
+                if ( TupleType * tupleType = dynamic_cast< TupleType * >( formal ) ) {
+                        std::list< Expression * > exprs;
+                        for ( Type * t : *tupleType ) {
+                                matchOneFormal( arg, idx, t, back_inserter( exprs ) );
+                        }
+                        *out++ = new TupleExpr( exprs );
+                } else {
+                        *out++ = new TupleIndexExpr( arg->clone(), idx++ );
+                }
+        }
+
+        /// restructures the ttype argument to match the structure of the formal parameters of the actual function.
+        // [begin, end) are the formal parameters.
+        // args is the list of arguments currently given to the actual function, the last of which needs to be restructured.
+        template< typename Iterator, typename OutIterator >
+        void fixLastArg( Expression * last, Iterator begin, Iterator end, OutIterator out ) {
+                // safe_dynamic_cast for the assertion
+                safe_dynamic_cast< TupleType * >( last->get_result() );
+                unsigned idx = 0;
+                for ( ; begin != end; ++begin ) {
+                        DeclarationWithType * formal = *begin;
+                        Type * formalType = formal->get_type();
+                        matchOneFormal( last, idx, formalType, out );
+                }
+                delete last;
+        }
+
+        Expression * TupleSpecializer::createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) {
+                static UniqueName thunkNamer( "_tupleThunk" );
+
+                FunctionType *newType = funType->clone();
+                if ( env ) {
+                        // it is important to replace only occurrences of type variables that occur free in the
+                        // thunk's type
+                        env->applyFree( newType );
+                } // if
+                // create new thunk with same signature as formal type (C linkage, empty body)
+                FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, newType, new CompoundStmt( noLabels ), false, false );
+                thunkFunc->fixUniqueId();
+
+                // thunks may be generated and not used - silence warning with attribute
+                thunkFunc->get_attributes().push_back( new Attribute( "unused" ) );
+
+                // thread thunk parameters into call to actual function, naming thunk parameters as we go
+                UniqueName paramNamer( paramPrefix );
+                ApplicationExpr *appExpr = new ApplicationExpr( actual );
+
+                FunctionType * actualType = getFunctionType( actual->get_result() )->clone();
+                if ( env ) {
+                        // need to apply the environment to the actual function's type, since it may itself be polymorphic
+                        env->apply( actualType );
+                }
+                std::unique_ptr< FunctionType > actualTypeManager( actualType ); // for RAII
+                std::list< DeclarationWithType * >::iterator actualBegin = actualType->get_parameters().begin();
+                std::list< DeclarationWithType * >::iterator actualEnd = actualType->get_parameters().end();
+                std::list< DeclarationWithType * >::iterator formalBegin = funType->get_parameters().begin();
+                std::list< DeclarationWithType * >::iterator formalEnd = funType->get_parameters().end();
+
+                Expression * last = nullptr;
+                for ( DeclarationWithType* param : thunkFunc->get_functionType()->get_parameters() ) {
+                        // walk the parameters to the actual function alongside the parameters to the thunk to find the location where the ttype parameter begins to satisfy parameters in the actual function.
+                        param->set_name( paramNamer.newName() );
+                        assertf( formalBegin != formalEnd, "Reached end of formal parameters before finding ttype parameter" );
+                        if ( Tuples::isTtype((*formalBegin)->get_type()) ) {
+                                last = new VariableExpr( param );
+                                break;
+                        }
+                        assertf( actualBegin != actualEnd, "reached end of actual function's arguments before finding ttype parameter" );
+                        ++actualBegin;
+                        ++formalBegin;
+
+                        appExpr->get_args().push_back( new VariableExpr( param ) );
+                } // for
+                assert( last );
+                fixLastArg( last, actualBegin, actualEnd, back_inserter( appExpr->get_args() ) );
+                appExpr->set_env( maybeClone( env ) );
+                if ( inferParams ) {
+                        appExpr->get_inferParams() = *inferParams;
+                } // if
+
+                // handle any specializations that may still be present
+                std::string oldParamPrefix = paramPrefix;
+                paramPrefix += "p";
+                // save stmtsToAdd in oldStmts
+                std::list< Statement* > oldStmts;
+                oldStmts.splice( oldStmts.end(), stmtsToAdd );
+                spec.mutate( appExpr );
+                paramPrefix = oldParamPrefix;
+                // write any statements added for recursive specializations into the thunk body
+                thunkFunc->get_statements()->get_kids().splice( thunkFunc->get_statements()->get_kids().end(), stmtsToAdd );
+                // restore oldStmts into stmtsToAdd
+                stmtsToAdd.splice( stmtsToAdd.end(), oldStmts );
+
+                // add return (or valueless expression) to the thunk
+                Statement *appStmt;
+                if ( funType->get_returnVals().empty() ) {
+                        appStmt = new ExprStmt( noLabels, appExpr );
+                } else {
+                        appStmt = new ReturnStmt( noLabels, appExpr );
+                } // if
+                thunkFunc->get_statements()->get_kids().push_back( appStmt );
+
+                // add thunk definition to queue of statements to add
+                stmtsToAdd.push_back( new DeclStmt( noLabels, thunkFunc ) );
+                // return address of thunk function as replacement expression
+                return new AddressExpr( new VariableExpr( thunkFunc ) );
+        }
+
         void Specialize::handleExplicitParams( ApplicationExpr *appExpr ) {
                 // create thunks for the explicit parameters
@@ -178 +311 @@
                 std::list< Expression* >::iterator actual;
                 for ( formal = function->get_parameters().begin(), actual = appExpr->get_args().begin(); formal != function->get_parameters().end() && actual != appExpr->get_args().end(); ++formal, ++actual ) {
-                        *actual = doSpecialization( (*formal )->get_type(), *actual, &appExpr->get_inferParams() );
+                        *actual = specializer->doSpecialization( (*formal )->get_type(), *actual, &appExpr->get_inferParams() );
                 }
         }
@@ -190 +323 @@
                         // don't need to do this for intrinsic calls, because they aren't actually passed
                         for ( InferredParams::iterator inferParam = appExpr->get_inferParams().begin(); inferParam != appExpr->get_inferParams().end(); ++inferParam ) {
-                                inferParam->second.expr = doSpecialization( inferParam->second.formalType, inferParam->second.expr, &appExpr->get_inferParams() );
+                                inferParam->second.expr = specializer->doSpecialization( inferParam->second.formalType, inferParam->second.expr, inferParam->second.inferParams.get() );
                         }
-
                         handleExplicitParams( appExpr );
                 }
-
                 return appExpr;
         }
@@ -202 +333 @@
                 addrExpr->get_arg()->acceptMutator( *this );
                 assert( addrExpr->has_result() );
-                addrExpr->set_arg( doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
+                addrExpr->set_arg( specializer->doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
                 return addrExpr;
         }
@@ -212 +343 @@
                         return castExpr;
                 }
-                Expression *specialized = doSpecialization( castExpr->get_result(), castExpr->get_arg() );
+                Expression *specialized = specializer->doSpecialization( castExpr->get_result(), castExpr->get_arg() );
                 if ( specialized != castExpr->get_arg() ) {
                         // assume here that the specialization incorporates the cast
@@ -236 +367 @@
         //      return commaExpr;
         // }
+
+        void convertSpecializations( std::list< Declaration* >& translationUnit ) {
+                Specialize spec;
+
+                TupleSpecializer tupleSpec( spec );
+                spec.specializer = &tupleSpec;
+                mutateAll( translationUnit, spec );
+
+                PolySpecializer polySpec( spec );
+                spec.specializer = &polySpec;
+                mutateAll( translationUnit, spec );
+        }
 } // namespace GenPoly