Changes in src/GenPoly/Box.cc [aa19ccf:4e284ea6]

File:

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

src/GenPoly/Box.cc

@@ -30 +30 @@
 #include "FindFunction.h"
 #include "ScopedMap.h"
-#include "ScopedSet.h"
 #include "ScrubTyVars.h"
 
@@ -63 +62 @@
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
 
-                /// Abstracts type equality for a list of parameter types
-                struct TypeList {
-                        TypeList() : params() {}
-                        TypeList( const std::list< Type* > &_params ) : params() { cloneAll(_params, params); }
-                        TypeList( std::list< Type* > &&_params ) : params( _params ) {}
-
-                        TypeList( const TypeList &that ) : params() { cloneAll(that.params, params); }
-                        TypeList( TypeList &&that ) : params( std::move( that.params ) ) {}
+                /// Key for a unique concrete type; generic base type paired with type parameter list
+                struct ConcreteType {
+                        ConcreteType() : base(NULL), params() {}
+
+                        ConcreteType(AggregateDecl *_base, const std::list< Type* >& _params) : base(_base), params() { cloneAll(_params, params); }
+
+                        ConcreteType(const ConcreteType& that) : base(that.base), params() { cloneAll(that.params, params); }
 
                         /// Extracts types from a list of TypeExpr*
-                        TypeList( const std::list< TypeExpr* >& _params ) : params() {
+                        ConcreteType(AggregateDecl *_base, const std::list< TypeExpr* >& _params) : base(_base), params() {
                                 for ( std::list< TypeExpr* >::const_iterator param = _params.begin(); param != _params.end(); ++param ) {
                                         params.push_back( (*param)->get_type()->clone() );
@@ -79 +77 @@
                         }
 
-                        TypeList& operator= ( const TypeList &that ) {
+                        ConcreteType& operator= (const ConcreteType& that) {
                                 deleteAll( params );
-
                                 params.clear();
+
+                                base = that.base;
                                 cloneAll( that.params, params );
 
@@ -88 +87 @@
                         }
 
-                        TypeList& operator= ( TypeList &&that ) {
-                                deleteAll( params );
-
-                                params = std::move( that.params );
-
-                                return *this;
-                        }
-
-                        ~TypeList() { deleteAll( params ); }
-
-                        bool operator== ( const TypeList& that ) const {
+                        ~ConcreteType() { deleteAll( params ); }
+
+                        bool operator== (const ConcreteType& that) const {
+                                if ( base != that.base ) return false;
+
+                                SymTab::Indexer dummy;
                                 if ( params.size() != that.params.size() ) return false;
-
-                                SymTab::Indexer dummy;
                                 for ( std::list< Type* >::const_iterator it = params.begin(), jt = that.params.begin(); it != params.end(); ++it, ++jt ) {
                                         if ( ! ResolvExpr::typesCompatible( *it, *jt, dummy ) ) return false;
@@ -108 +100 @@
                         }
 
+                        AggregateDecl *base;        ///< Base generic type
                         std::list< Type* > params;  ///< Instantiation parameters
                 };
 
-                /// Maps a key and a TypeList to the some value, accounting for scope
-                template< typename Key, typename Value >
+                /// Maps a concrete type to the some value, accounting for scope
+                template< typename Value >
                 class InstantiationMap {
-                        /// Wraps value for a specific (Key, TypeList) combination
-                        typedef std::pair< TypeList, Value* > Instantiation;
-                        /// List of TypeLists paired with their appropriate values
-                        typedef std::vector< Instantiation > ValueList;
-                        /// Underlying map type; maps keys to a linear list of corresponding TypeLists and values
-                        typedef ScopedMap< Key*, ValueList > InnerMap;
-
-                        InnerMap instantiations;  ///< instantiations
+                        /// Information about a specific instantiation of a generic type
+                        struct Instantiation {
+                                ConcreteType key;  ///< Instantiation parameters for this type
+                                Value *value;      ///< Value for this instantiation
+
+                                Instantiation() : key(), value(0) {}
+                                Instantiation(const ConcreteType &_key, Value *_value) : key(_key), value(_value) {}
+                        };
+                        /// Map of generic types to instantiations of them
+                        typedef std::map< AggregateDecl*, std::vector< Instantiation > > Scope;
+
+                        std::vector< Scope > scopes;  ///< list of scopes, from outermost to innermost
 
                 public:
                         /// Starts a new scope
-                        void beginScope() { instantiations.beginScope(); }
+                        void beginScope() {
+                                Scope scope;
+                                scopes.push_back(scope);
+                        }
 
                         /// Ends a scope
-                        void endScope() { instantiations.endScope(); }
-
-                        /// Gets the value for the (key, typeList) pair, returns NULL on none such.
-                        Value *lookup( Key *key, const std::list< TypeExpr* >& params ) const {
-                                TypeList typeList( params );
-                                
-                                // scan scopes for matches to the key
-                                for ( typename InnerMap::const_iterator insts = instantiations.find( key ); insts != instantiations.end(); insts = instantiations.findNext( insts, key ) ) {
-                                        for ( typename ValueList::const_reverse_iterator inst = insts->second.rbegin(); inst != insts->second.rend(); ++inst ) {
-                                                if ( inst->first == typeList ) return inst->second;
+                        void endScope() {
+                                scopes.pop_back();
+                        }
+
+                        /// Default constructor initializes with one scope
+                        InstantiationMap() { beginScope(); }
+
+//              private:
+                        /// Gets the value for the concrete instantiation of this type, assuming it has already been instantiated in the current scope.
+                        /// Returns NULL on none such.
+                        Value *lookup( AggregateDecl *generic, const std::list< TypeExpr* >& params ) {
+                                ConcreteType key(generic, params);
+                                // scan scopes from innermost out
+                                for ( typename std::vector< Scope >::const_reverse_iterator scope = scopes.rbegin(); scope != scopes.rend(); ++scope ) {
+                                        // skip scope if no instantiations of this generic type
+                                        typename Scope::const_iterator insts = scope->find( generic );
+                                        if ( insts == scope->end() ) continue;
+                                        // look through instantiations for matches to concrete type
+                                        for ( typename std::vector< Instantiation >::const_iterator inst = insts->second.begin(); inst != insts->second.end(); ++inst ) {
+                                                if ( inst->key == key ) return inst->value;
                                         }
                                 }
-                                // no matching instantiations found
+                                // no matching instantiation found
                                 return 0;
                         }
-
-                        /// Adds a value for a (key, typeList) pair to the current scope
-                        void insert( Key *key, const std::list< TypeExpr* > &params, Value *value ) {
-                                instantiations[ key ].push_back( Instantiation( TypeList( params ), value ) );
-                        }
+                public:
+//                      StructDecl* lookup( StructInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (StructDecl*)lookup( inst->get_baseStruct(), typeSubs ); }
+//                      UnionDecl* lookup( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (UnionDecl*)lookup( inst->get_baseUnion(), typeSubs ); }
+
+//              private:
+                        /// Adds a value for a concrete type to the current scope
+                        void insert( AggregateDecl *generic, const std::list< TypeExpr* > &params, Value *value ) {
+                                ConcreteType key(generic, params);
+                                scopes.back()[generic].push_back( Instantiation( key, value ) );
+                        }
+//              public:
+//                      void insert( StructInstType *inst, const std::list< TypeExpr* > &typeSubs, StructDecl *decl ) { insert( inst->get_baseStruct(), typeSubs, decl ); }
+//                      void insert( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs, UnionDecl *decl ) { insert( inst->get_baseUnion(), typeSubs, decl ); }
                 };
 
@@ -179 +197 @@
                         virtual void doEndScope();
                   private:
+                        /// Makes a new temporary array holding the offsets of the fields of `type`, and returns a new variable expression referencing it
+                        Expression *makeOffsetArray( StructInstType *type );
                         /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application
                         void passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes );
@@ -205 +225 @@
                         ObjectDecl *makeTemporary( Type *type );
 
-                        ScopedMap< std::string, DeclarationWithType *> assignOps;    ///< Currently known type variable assignment operators
-                        ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps;  ///< Currently known assignment operators
-                        ScopedMap< std::string, DeclarationWithType* > adapters;     ///< Set of adapter functions in the current scope
-                        
+                        std::map< std::string, DeclarationWithType *> assignOps;
+                        ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps;
+                        ScopedMap< std::string, DeclarationWithType* > adapters;
                         DeclarationWithType *retval;
                         bool useRetval;
@@ -214 +233 @@
                 };
 
-                /// * Moves polymorphic returns in function types to pointer-type parameters
-                /// * adds type size and assertion parameters to parameter lists
+                /// Moves polymorphic returns in function types to pointer-type parameters, adds type size and assertion parameters to parameter lists as well
                 class Pass2 : public PolyMutator {
                   public:
@@ -226 +244 @@
                         virtual Type *mutate( PointerType *pointerType );
                         virtual Type *mutate( FunctionType *funcType );
-                        
                   private:
                         void addAdapters( FunctionType *functionType );
@@ -236 +253 @@
                 class GenericInstantiator : public DeclMutator {
                         /// Map of (generic type, parameter list) pairs to concrete type instantiations
-                        InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
+                        InstantiationMap< AggregateDecl > instantiations;
                         /// Namer for concrete types
                         UniqueName typeNamer;
@@ -261 +278 @@
                 };
 
-                /// Replaces member and size/align/offsetof expressions on polymorphic generic types with calculated expressions.
-                /// * Replaces member expressions for polymorphic types with calculated add-field-offset-and-dereference
-                /// * Calculates polymorphic offsetof expressions from offset array
-                /// * Inserts dynamic calculation of polymorphic type layouts where needed
-                class PolyGenericCalculator : public PolyMutator {
-                public:
+                /// Replaces member expressions for polymorphic types with calculated add-field-offset-and-dereference;
+                /// also fixes offsetof expressions.
+                class MemberExprFixer : public PolyMutator {
+                  public:
                         template< typename DeclClass >
                         DeclClass *handleDecl( DeclClass *decl, Type *type );
@@ -277 +292 @@
                         virtual Type *mutate( FunctionType *funcType );
                         virtual Expression *mutate( MemberExpr *memberExpr );
-                        virtual Expression *mutate( SizeofExpr *sizeofExpr );
-                        virtual Expression *mutate( AlignofExpr *alignofExpr );
                         virtual Expression *mutate( OffsetofExpr *offsetofExpr );
-                        virtual Expression *mutate( OffsetPackExpr *offsetPackExpr );
-
-                        virtual void doBeginScope();
-                        virtual void doEndScope();
-
-                private:
-                        /// Makes a new variable in the current scope with the given name, type & optional initializer
-                        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 );
-                        /// adds type parameters to the layout call; will generate the appropriate parameters if needed
-                        void addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams );
-
-                        /// Enters a new scope for type-variables, adding the type variables from ty
-                        void beginTypeScope( Type *ty );
-                        /// Exits the type-variable scope
-                        void endTypeScope();
-                        
-                        ScopedSet< std::string > knownLayouts;          ///< Set of generic type layouts known in the current scope, indexed by sizeofName
-                        ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
                 };
 
@@ -349 +342 @@
                 Pass2 pass2;
                 GenericInstantiator instantiator;
-                PolyGenericCalculator polyCalculator;
+                MemberExprFixer memberFixer;
                 Pass3 pass3;
                 
@@ -355 +348 @@
                 mutateTranslationUnit/*All*/( translationUnit, pass1 );
                 mutateTranslationUnit/*All*/( translationUnit, pass2 );
+//              instantiateGeneric( translationUnit );
                 instantiator.mutateDeclarationList( translationUnit );
-                mutateTranslationUnit/*All*/( translationUnit, polyCalculator );
+                mutateTranslationUnit/*All*/( translationUnit, memberFixer );
                 mutateTranslationUnit/*All*/( translationUnit, pass3 );
         }
@@ -390 +384 @@
                 for ( std::list< TypeDecl* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
                         TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param );
-                        std::string paramName = mangleType( &paramType );
-                        layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
-                        layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
+                        layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( &paramType ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
+                        layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( &paramType ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
                 }
         }
 
         /// Builds a layout function declaration
-        FunctionDecl *buildLayoutFunctionDecl( AggregateDecl *typeDecl, unsigned int functionNesting, FunctionType *layoutFnType ) {
+        FunctionDecl *buildLayoutFunctionDecl( const std::string &typeName, unsigned int functionNesting, 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 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ), true, false );
+                        "__layoutof_" + typeName, functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ), true, false );
                 layoutDecl->fixUniqueId();
                 return layoutDecl;
@@ -468 +461 @@
                 PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
                 
-                ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
+                ObjectDecl *sizeParam = new ObjectDecl( "__sizeof_" + structDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
                 layoutFnType->get_parameters().push_back( sizeParam );
-                ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
+                ObjectDecl *alignParam = new ObjectDecl( "__alignof_" + structDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
                 layoutFnType->get_parameters().push_back( alignParam );
-                ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
+                ObjectDecl *offsetParam = new ObjectDecl( "__offsetof_" + structDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
                 layoutFnType->get_parameters().push_back( offsetParam );
                 addOtypeParams( layoutFnType, otypeParams );
 
                 // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl, functionNesting, layoutFnType );
+                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl->get_name(), functionNesting, layoutFnType );
 
                 // calculate struct layout in function body
@@ -529 +522 @@
                 PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
                 
-                ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
+                ObjectDecl *sizeParam = new ObjectDecl( "__sizeof_" + unionDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
                 layoutFnType->get_parameters().push_back( sizeParam );
-                ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
+                ObjectDecl *alignParam = new ObjectDecl( "__alignof_" + unionDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
                 layoutFnType->get_parameters().push_back( alignParam );
                 addOtypeParams( layoutFnType, otypeParams );
 
                 // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl, functionNesting, layoutFnType );
+                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl->get_name(), functionNesting, layoutFnType );
 
                 // calculate union layout in function body
@@ -660 +653 @@
 
                 DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
-                        // if this is a assignment function, put it in the map for this scope
+                        // if this is a polymorphic assignment function, put it in the map for this scope
                         if ( Type *assignedType = isAssignment( functionDecl ) ) {
                                 if ( ! dynamic_cast< TypeInstType* >( assignedType ) ) {
@@ -669 +662 @@
                         if ( functionDecl->get_statements() ) {         // empty routine body ?
                                 doBeginScope();
-                                scopeTyVars.beginScope();
-                                assignOps.beginScope();
+                                TyVarMap oldtyVars = scopeTyVars;
+                                std::map< std::string, DeclarationWithType *> oldassignOps = assignOps;
                                 DeclarationWithType *oldRetval = retval;
                                 bool oldUseRetval = useRetval;
@@ -711 +704 @@
                                 functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) );
 
-                                scopeTyVars.endScope();
-                                assignOps.endScope();
+                                scopeTyVars = oldtyVars;
+                                assignOps = oldassignOps;
+                                // std::cerr << "end FunctionDecl: ";
+                                // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
+                                //      std::cerr << i->first << " ";
+                                // }
+                                // std::cerr << "\n";
                                 retval = oldRetval;
                                 useRetval = oldUseRetval;
@@ -745 +743 @@
                 }
 
+                Expression *Pass1::makeOffsetArray( StructInstType *ty ) {
+                        std::list< Declaration* > &baseMembers = ty->get_baseStruct()->get_members();
+
+                        // make a new temporary array
+                        Type *offsetType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+                        std::stringstream lenGen;
+                        lenGen << baseMembers.size();
+                        ConstantExpr *lenExpr = new ConstantExpr( Constant( offsetType->clone(), lenGen.str() ) );
+                        ObjectDecl *arrayTemp = makeTemporary( new ArrayType( Type::Qualifiers(), offsetType, lenExpr, false, false ) );
+
+                        // build initializer list for temporary
+                        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();
+                                } else {
+                                        memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
+                                }
+                                inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
+                        }
+                        arrayTemp->set_init( new ListInit( inits ) );
+
+                        // return variable pointing to temporary
+                        return new VariableExpr( arrayTemp );
+                }
+
                 void Pass1::passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes ) {
-                        Type *polyType = isPolyType( parmType, exprTyVars );
-                        if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
-                                std::string typeName = mangleType( polyType );
-                                if ( seenTypes.count( typeName ) ) return;
+                        Type *polyBase = hasPolyBase( parmType, exprTyVars );
+                        if ( polyBase && ! dynamic_cast< TypeInstType* >( polyBase ) ) {
+                                std::string sizeName = sizeofName( polyBase );
+                                if ( seenTypes.count( sizeName ) ) return;
 
                                 arg = appExpr->get_args().insert( arg, new SizeofExpr( argBaseType->clone() ) );
@@ -755 +780 @@
                                 arg = appExpr->get_args().insert( arg, new AlignofExpr( argBaseType->clone() ) );
                                 arg++;
-                                if ( dynamic_cast< StructInstType* >( polyType ) ) {
+                                if ( dynamic_cast< StructInstType* >( polyBase ) ) {
                                         if ( StructInstType *argBaseStructType = dynamic_cast< StructInstType* >( argBaseType ) ) {
-                                                // zero-length arrays are forbidden by C, so don't pass offset for empty struct
-                                                if ( ! argBaseStructType->get_baseStruct()->get_members().empty() ) {
-                                                        arg = appExpr->get_args().insert( arg, new OffsetPackExpr( argBaseStructType->clone() ) );
-                                                        arg++;
-                                                }
+                                                arg = appExpr->get_args().insert( arg, makeOffsetArray( argBaseStructType ) );
+                                                arg++;
                                         } else {
                                                 throw SemanticError( "Cannot pass non-struct type for generic struct" );
@@ -767 +789 @@
                                 }
 
-                                seenTypes.insert( typeName );
+                                seenTypes.insert( sizeName );
                         }
                 }
@@ -909 +931 @@
                                         return;
                                 } else if ( arg->get_results().front()->get_isLvalue() ) {
-                                        // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
-                                        if ( CommaExpr *commaArg = dynamic_cast< CommaExpr* >( arg ) ) {
-                                                commaArg->set_arg2( new AddressExpr( commaArg->get_arg2() ) );
-                                        } else {
-                                                arg = new AddressExpr( arg );
-                                        }
+                                        // VariableExpr and MemberExpr are lvalues
+                                        arg = new AddressExpr( arg );
                                 } else {
                                         // use type computed in unification to declare boxed variables
@@ -1009 +1027 @@
                         } // for
                 }
+
+
 
                 FunctionDecl *Pass1::makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
@@ -1125 +1145 @@
                                 addAssign->get_args().push_back( appExpr->get_args().front() );
                         } // if
-                        addAssign->get_args().push_back( new NameExpr( sizeofName( mangleType( polyType ) ) ) );
+                        addAssign->get_args().push_back( new NameExpr( sizeofName( polyType ) ) );
                         addAssign->get_results().front() = appExpr->get_results().front()->clone();
                         if ( appExpr->get_env() ) {
@@ -1152 +1172 @@
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
                                                         multiply->get_args().push_back( appExpr->get_args().back() );
-                                                        multiply->get_args().push_back( new SizeofExpr( baseType1->clone() ) );
+                                                        multiply->get_args().push_back( new NameExpr( sizeofName( baseType1 ) ) );
                                                         ret->get_args().push_back( appExpr->get_args().front() );
                                                         ret->get_args().push_back( multiply );
@@ -1158 +1178 @@
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
                                                         multiply->get_args().push_back( appExpr->get_args().front() );
-                                                        multiply->get_args().push_back( new SizeofExpr( baseType2->clone() ) );
+                                                        multiply->get_args().push_back( new NameExpr( sizeofName( baseType2 ) ) );
                                                         ret->get_args().push_back( multiply );
                                                         ret->get_args().push_back( appExpr->get_args().back() );
@@ -1221 +1241 @@
                                                         UntypedExpr *divide = new UntypedExpr( new NameExpr( "?/?" ) );
                                                         divide->get_args().push_back( appExpr );
-                                                        divide->get_args().push_back( new SizeofExpr( baseType1->clone() ) );
+                                                        divide->get_args().push_back( new NameExpr( sizeofName( baseType1 ) ) );
                                                         divide->get_results().push_front( appExpr->get_results().front()->clone() );
                                                         if ( appExpr->get_env() ) {
@@ -1231 +1251 @@
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
                                                         multiply->get_args().push_back( appExpr->get_args().back() );
-                                                        multiply->get_args().push_back( new SizeofExpr( baseType1->clone() ) );
+                                                        multiply->get_args().push_back( new NameExpr( sizeofName( baseType1 ) ) );
                                                         appExpr->get_args().back() = multiply;
                                                 } else if ( baseType2 ) {
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
                                                         multiply->get_args().push_back( appExpr->get_args().front() );
-                                                        multiply->get_args().push_back( new SizeofExpr( baseType2->clone() ) );
+                                                        multiply->get_args().push_back( new NameExpr( sizeofName( baseType2 ) ) );
                                                         appExpr->get_args().front() = multiply;
                                                 } // if
@@ -1246 +1266 @@
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
                                                         multiply->get_args().push_back( appExpr->get_args().back() );
-                                                        multiply->get_args().push_back( new SizeofExpr( baseType->clone() ) );
+                                                        multiply->get_args().push_back( new NameExpr( sizeofName( baseType ) ) );
                                                         appExpr->get_args().back() = multiply;
                                                 } // if
@@ -1283 +1303 @@
                         std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
 
-                        TyVarMap exprTyVars( (TypeDecl::Kind)-1 );
+                        TyVarMap exprTyVars;
                         makeTyVarMap( function, exprTyVars );
                         ReferenceToType *polyRetType = isPolyRet( function );
@@ -1306 +1326 @@
 
                         boxParams( appExpr, function, arg, exprTyVars );
+
                         passAdapters( appExpr, function, exprTyVars );
 
@@ -1385 +1406 @@
                                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( retval->get_type() ) ) {
                                         // find assignment operator for type variable
-                                        ScopedMap< std::string, DeclarationWithType *>::const_iterator assignIter = assignOps.find( typeInst->get_name() );
+                                        std::map< std::string, DeclarationWithType *>::const_iterator assignIter = assignOps.find( typeInst->get_name() );
                                         if ( assignIter == assignOps.end() ) {
                                                 throw SemanticError( "Attempt to return dtype or ftype object in ", returnStmt->get_expr() );
@@ -1407 +1428 @@
                                         std::list< TypeDecl* >::const_iterator forallIt = forallParams.begin();
                                         for ( ; tyIt != tyParams.end() && forallIt != forallParams.end(); ++tyIt, ++forallIt ) {
-                                                // Add appropriate mapping to assignment expression environment
+                                                if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue; // skip types with no assign op (ftype/dtype)
+
+                                                std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions();
+                                                assert( ! asserts.empty() && "Type param needs assignment operator assertion" );
+                                                DeclarationWithType *actualDecl = asserts.front();
+                                                TypeInstType *actualType = isTypeInstAssignment( actualDecl );
+                                                assert( actualType && "First assertion of type with assertions should be assignment operator" );
                                                 TypeExpr *formalTypeExpr = dynamic_cast< TypeExpr* >( *tyIt );
                                                 assert( formalTypeExpr && "type parameters must be type expressions" );
                                                 Type *formalType = formalTypeExpr->get_type();
-                                                assignExpr->get_env()->add( (*forallIt)->get_name(), formalType );
-
-                                                // skip types with no assign op (ftype/dtype)
-                                                if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue;
-
-                                                // find assignment operator for formal type
+                                                assignExpr->get_env()->add( actualType->get_name(), formalType );
+                                                
                                                 DeclarationWithType *assertAssign = 0;
                                                 if ( TypeInstType *formalTypeInstType = dynamic_cast< TypeInstType* >( formalType ) ) {
-                                                        ScopedMap< std::string, DeclarationWithType *>::const_iterator assertAssignIt = assignOps.find( formalTypeInstType->get_name() );
+                                                        std::map< std::string, DeclarationWithType *>::const_iterator assertAssignIt = assignOps.find( formalTypeInstType->get_name() );
                                                         if ( assertAssignIt == assignOps.end() ) {
                                                                 throw SemanticError( "No assignment operation found for ", formalTypeInstType );
@@ -1430 +1453 @@
                                                         }
                                                 }
-
-                                                // add inferred parameter for field assignment operator to assignment expression
-                                                std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions();
-                                                assert( ! asserts.empty() && "Type param needs assignment operator assertion" );
-                                                DeclarationWithType *actualDecl = asserts.front();
+                                                
+
                                                 assignExpr->get_inferParams()[ actualDecl->get_uniqueId() ]
                                                         = ParamEntry( assertAssign->get_uniqueId(), assertAssign->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertAssign ) );
@@ -1460 +1480 @@
 
                 Type * Pass1::mutate( PointerType *pointerType ) {
-                        scopeTyVars.beginScope();
+                        TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( pointerType, scopeTyVars );
 
                         Type *ret = Mutator::mutate( pointerType );
 
-                        scopeTyVars.endScope();
+                        scopeTyVars = oldtyVars;
                         return ret;
                 }
 
                 Type * Pass1::mutate( FunctionType *functionType ) {
-                        scopeTyVars.beginScope();
+                        TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( functionType, scopeTyVars );
 
                         Type *ret = Mutator::mutate( functionType );
 
-                        scopeTyVars.endScope();
+                        scopeTyVars = oldtyVars;
                         return ret;
                 }
@@ -1540 +1560 @@
 
                 Type * Pass2::mutate( PointerType *pointerType ) {
-                        scopeTyVars.beginScope();
+                        TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( pointerType, scopeTyVars );
 
                         Type *ret = Mutator::mutate( pointerType );
 
-                        scopeTyVars.endScope();
+                        scopeTyVars = oldtyVars;
                         return ret;
                 }
 
                 Type *Pass2::mutate( FunctionType *funcType ) {
-                        scopeTyVars.beginScope();
+                        TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( funcType, scopeTyVars );
 
@@ -1567 +1587 @@
                         ObjectDecl newPtr( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0,
                                            new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
+//   ObjectDecl *newFunPtr = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 );
                         for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
                                 ObjectDecl *sizeParm, *alignParm;
@@ -1572 +1593 @@
                                 if ( (*tyParm)->get_kind() == TypeDecl::Any ) {
                                         TypeInstType parmType( Type::Qualifiers(), (*tyParm)->get_name(), *tyParm );
-                                        std::string parmName = mangleType( &parmType );
 
                                         sizeParm = newObj.clone();
-                                        sizeParm->set_name( sizeofName( parmName ) );
+                                        sizeParm->set_name( sizeofName( &parmType ) );
                                         last = funcType->get_parameters().insert( last, sizeParm );
                                         ++last;
 
                                         alignParm = newObj.clone();
-                                        alignParm->set_name( alignofName( parmName ) );
+                                        alignParm->set_name( alignofName( &parmType ) );
                                         last = funcType->get_parameters().insert( last, alignParm );
                                         ++last;
@@ -1595 +1615 @@
                         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 );
-                                if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
-                                        std::string typeName = mangleType( polyType );
-                                        if ( seenTypes.count( typeName ) ) continue;
+                                Type *polyBase = hasPolyBase( (*fnParm)->get_type(), scopeTyVars );
+                                if ( polyBase && ! dynamic_cast< TypeInstType* >( polyBase ) ) {
+                                        std::string sizeName = sizeofName( polyBase );
+                                        if ( seenTypes.count( sizeName ) ) continue;
 
                                         ObjectDecl *sizeParm, *alignParm, *offsetParm;
                                         sizeParm = newObj.clone();
-                                        sizeParm->set_name( sizeofName( typeName ) );
+                                        sizeParm->set_name( sizeName );
                                         last = funcType->get_parameters().insert( last, sizeParm );
                                         ++last;
 
                                         alignParm = newObj.clone();
-                                        alignParm->set_name( alignofName( typeName ) );
+                                        alignParm->set_name( alignofName( polyBase ) );
                                         last = funcType->get_parameters().insert( last, alignParm );
                                         ++last;
 
-                                        if ( StructInstType *polyBaseStruct = dynamic_cast< StructInstType* >( polyType ) ) {
-                                                // NOTE zero-length arrays are illegal in C, so empty structs have no offset array
-                                                if ( ! polyBaseStruct->get_baseStruct()->get_members().empty() ) {
-                                                        offsetParm = newPtr.clone();
-                                                        offsetParm->set_name( offsetofName( typeName ) );
-                                                        last = funcType->get_parameters().insert( last, offsetParm );
-                                                        ++last;
-                                                }
+                                        if ( dynamic_cast< StructInstType* >( polyBase ) ) {
+                                                offsetParm = newPtr.clone();
+                                                offsetParm->set_name( offsetofName( polyBase ) );
+                                                last = funcType->get_parameters().insert( last, offsetParm );
+                                                ++last;
                                         }
 
-                                        seenTypes.insert( typeName );
+                                        seenTypes.insert( sizeName );
                                 }
                         }
@@ -1631 +1648 @@
                         mutateAll( funcType->get_parameters(), *this );
 
-                        scopeTyVars.endScope();
+                        scopeTyVars = oldtyVars;
                         return funcType;
                 }
@@ -1824 +1841 @@
                 }
 
-////////////////////////////////////////// PolyGenericCalculator ////////////////////////////////////////////////////
-
-                void PolyGenericCalculator::beginTypeScope( Type *ty ) {
-                        scopeTyVars.beginScope();
-                        makeTyVarMap( ty, scopeTyVars );
-                }
-
-                void PolyGenericCalculator::endTypeScope() {
-                        scopeTyVars.endScope();
-                }
+////////////////////////////////////////// MemberExprFixer ////////////////////////////////////////////////////
 
                 template< typename DeclClass >
-                DeclClass * PolyGenericCalculator::handleDecl( DeclClass *decl, Type *type ) {
-                        beginTypeScope( type );
-                        knownLayouts.beginScope();
-                        knownOffsets.beginScope();
+                DeclClass * MemberExprFixer::handleDecl( DeclClass *decl, Type *type ) {
+                        TyVarMap oldtyVars = scopeTyVars;
+                        makeTyVarMap( type, scopeTyVars );
 
                         DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
 
-                        knownOffsets.endScope();
-                        knownLayouts.endScope();
-                        endTypeScope();
+                        scopeTyVars = oldtyVars;
                         return ret;
                 }
 
-                ObjectDecl * PolyGenericCalculator::mutate( ObjectDecl *objectDecl ) {
+                ObjectDecl * MemberExprFixer::mutate( ObjectDecl *objectDecl ) {
                         return handleDecl( objectDecl, objectDecl->get_type() );
                 }
 
-                DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) {
+                DeclarationWithType * MemberExprFixer::mutate( FunctionDecl *functionDecl ) {
                         return handleDecl( functionDecl, functionDecl->get_functionType() );
                 }
 
-                TypedefDecl * PolyGenericCalculator::mutate( TypedefDecl *typedefDecl ) {
+                TypedefDecl * MemberExprFixer::mutate( TypedefDecl *typedefDecl ) {
                         return handleDecl( typedefDecl, typedefDecl->get_base() );
                 }
 
-                TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) {
+                TypeDecl * MemberExprFixer::mutate( TypeDecl *typeDecl ) {
                         scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
                         return Mutator::mutate( typeDecl );
                 }
 
-                Type * PolyGenericCalculator::mutate( PointerType *pointerType ) {
-                        beginTypeScope( pointerType );
+                Type * MemberExprFixer::mutate( PointerType *pointerType ) {
+                        TyVarMap oldtyVars = scopeTyVars;
+                        makeTyVarMap( pointerType, scopeTyVars );
 
                         Type *ret = Mutator::mutate( pointerType );
 
-                        endTypeScope();
+                        scopeTyVars = oldtyVars;
                         return ret;
                 }
 
-                Type * PolyGenericCalculator::mutate( FunctionType *funcType ) {
-                        beginTypeScope( funcType );
-
-                        // 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 ) {
-                                // condition here duplicates that in Pass2::mutate( FunctionType* )
-                                Type *polyType = isPolyType( (*fnParm)->get_type(), scopeTyVars );
-                                if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
-                                        knownLayouts.insert( mangleType( polyType ) );
-                                }
-                        }
-                        
-                        Type *ret = Mutator::mutate( funcType );
-
-                        endTypeScope();
+                Type * MemberExprFixer::mutate( FunctionType *functionType ) {
+                        TyVarMap oldtyVars = scopeTyVars;
+                        makeTyVarMap( functionType, scopeTyVars );
+
+                        Type *ret = Mutator::mutate( functionType );
+
+                        scopeTyVars = oldtyVars;
                         return ret;
                 }
 
-                Statement *PolyGenericCalculator::mutate( DeclStmt *declStmt ) {
+                Statement *MemberExprFixer::mutate( DeclStmt *declStmt ) {
                         if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
-                                if ( findGeneric( objectDecl->get_type() ) ) {
+                                if ( isPolyType( objectDecl->get_type(), scopeTyVars ) ) {
                                         // change initialization of a polymorphic value object
                                         // to allocate storage with alloca
                                         Type *declType = objectDecl->get_type();
                                         UntypedExpr *alloc = new UntypedExpr( new NameExpr( "__builtin_alloca" ) );
-                                        alloc->get_args().push_back( new NameExpr( sizeofName( mangleType( declType ) ) ) );
+                                        alloc->get_args().push_back( new NameExpr( sizeofName( declType ) ) );
 
                                         delete objectDecl->get_init();
@@ -1932 +1930 @@
                         ConstantExpr *fieldIndex = new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), offset_namer.str() ) );
                         UntypedExpr *fieldOffset = new UntypedExpr( new NameExpr( "?[?]" ) );
-                        fieldOffset->get_args().push_back( new NameExpr( offsetofName( mangleType( objectType ) ) ) );
+                        fieldOffset->get_args().push_back( new NameExpr( offsetofName( objectType ) ) );
                         fieldOffset->get_args().push_back( fieldIndex );
                         return fieldOffset;
@@ -1947 +1945 @@
                 }
                 
-                Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
+                Expression *MemberExprFixer::mutate( MemberExpr *memberExpr ) {
                         // mutate, exiting early if no longer MemberExpr
                         Expression *expr = Mutator::mutate( memberExpr );
@@ -1964 +1962 @@
                         Type *objectType = hasPolyBase( objectDecl->get_type(), scopeTyVars, &tyDepth );
                         if ( ! objectType ) return memberExpr;
-                        findGeneric( objectType ); // ensure layout for this type is available
 
                         Expression *newMemberExpr = 0;
@@ -1996 +1993 @@
                 }
 
-                ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
-                        ObjectDecl *newObj = new ObjectDecl( name, DeclarationNode::NoStorageClass, LinkageSpec::C, 0, type, init );
-                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
-                        return newObj;
-                }
-
-                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 ) ) {
-                                        // push size/align vars for a generic parameter back
-                                        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() ) );
-                                }
-                        }
-                }
-
-                /// 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 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 ) {
-                                // skip non-otype parameters
-                                if ( (*baseParam)->get_kind() != TypeDecl::Any ) continue;
-                                TypeExpr *typeExpr = dynamic_cast< TypeExpr* >( *typeParam );
-                                assert( typeExpr && "all otype parameters should be type expressions" );
-
-                                Type *type = typeExpr->get_type();
-                                out.push_back( type );
-                                if ( isPolyType( type ) ) hasDynamicLayout = true;
-                        }
-                        assert( baseParam == baseParams.end() && typeParam == typeParams.end() );
-
-                        return hasDynamicLayout;
-                }
-
-                bool PolyGenericCalculator::findGeneric( Type *ty ) {
-                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
-                                // duplicate logic from isPolyType()
-                                if ( env ) {
-                                        if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
-                                                return findGeneric( newType );
-                                        } // if
-                                } // if
-                                if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() ) {
-                                        // NOTE assumes here that getting put in the scopeTyVars included having the layout variables set
-                                        return true;
-                                }
-                                return false;
-                        } else if ( StructInstType *structTy = dynamic_cast< StructInstType* >( ty ) ) {
-                                // check if this type already has a layout generated for it
-                                std::string typeName = mangleType( ty );
-                                if ( knownLayouts.find( typeName ) != knownLayouts.end() ) return true;
-
-                                // 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;
-
-                                // insert local variables for layout and generate call to layout function
-                                knownLayouts.insert( typeName );  // done early so as not to interfere with the later addition of parameters to the layout call
-                                Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-
-                                int n_members = structTy->get_baseStruct()->get_members().size();
-                                if ( n_members == 0 ) {
-                                        // all empty structs have the same layout - size 1, align 1
-                                        makeVar( sizeofName( typeName ), layoutType, new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
-                                        makeVar( alignofName( typeName ), layoutType->clone(), new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
-                                        // NOTE zero-length arrays are forbidden in C, so empty structs have no offsetof array
-                                } else {
-                                        ObjectDecl *sizeVar = makeVar( sizeofName( typeName ), layoutType );
-                                        ObjectDecl *alignVar = makeVar( alignofName( typeName ), layoutType->clone() );
-                                        ObjectDecl *offsetVar = makeVar( offsetofName( typeName ), new ArrayType( Type::Qualifiers(), layoutType->clone(), new ConstantExpr( Constant::from( n_members ) ), false, false ) );
-
-                                        // generate call to layout function
-                                        UntypedExpr *layoutCall = new UntypedExpr( new NameExpr( layoutofName( structTy->get_baseStruct() ) ) );
-                                        layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( sizeVar ) ) );
-                                        layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( alignVar ) ) );
-                                        layoutCall->get_args().push_back( new VariableExpr( offsetVar ) );
-                                        addOtypeParamsToLayoutCall( layoutCall, otypeParams );
-
-                                        stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
-                                }
-
-                                return true;
-                        } else if ( UnionInstType *unionTy = dynamic_cast< UnionInstType* >( ty ) ) {
-                                // check if this type already has a layout generated for it
-                                std::string typeName = mangleType( ty );
-                                if ( knownLayouts.find( typeName ) != knownLayouts.end() ) return true;
-
-                                // 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;
-
-                                // insert local variables for layout and generate call to layout function
-                                knownLayouts.insert( typeName );  // done early so as not to interfere with the later addition of parameters to the layout call
-                                Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-
-                                ObjectDecl *sizeVar = makeVar( sizeofName( typeName ), layoutType );
-                                ObjectDecl *alignVar = makeVar( alignofName( typeName ), layoutType->clone() );
-
-                                // generate call to layout function
-                                UntypedExpr *layoutCall = new UntypedExpr( new NameExpr( layoutofName( unionTy->get_baseUnion() ) ) );
-                                layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( sizeVar ) ) );
-                                layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( alignVar ) ) );
-                                addOtypeParamsToLayoutCall( layoutCall, otypeParams );
-
-                                stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
-
-                                return true;
-                        }
-
-                        return false;
-                }
-
-                Expression *PolyGenericCalculator::mutate( SizeofExpr *sizeofExpr ) {
-                        Type *ty = sizeofExpr->get_type();
-                        if ( findGeneric( ty ) ) {
-                                Expression *ret = new NameExpr( sizeofName( mangleType( ty ) ) );
-                                delete sizeofExpr;
-                                return ret;
-                        }
-                        return sizeofExpr;
-                }
-
-                Expression *PolyGenericCalculator::mutate( AlignofExpr *alignofExpr ) {
-                        Type *ty = alignofExpr->get_type();
-                        if ( findGeneric( ty ) ) {
-                                Expression *ret = new NameExpr( alignofName( mangleType( ty ) ) );
-                                delete alignofExpr;
-                                return ret;
-                        }
-                        return alignofExpr;
-                }
-
-                Expression *PolyGenericCalculator::mutate( OffsetofExpr *offsetofExpr ) {
+                Expression *MemberExprFixer::mutate( OffsetofExpr *offsetofExpr ) {
                         // mutate, exiting early if no longer OffsetofExpr
                         Expression *expr = Mutator::mutate( offsetofExpr );
@@ -2142 +2000 @@
 
                         // only mutate expressions for polymorphic structs/unions
-                        Type *ty = offsetofExpr->get_type();
-                        if ( ! findGeneric( ty ) ) return offsetofExpr;
-                        
+                        Type *ty = isPolyType( offsetofExpr->get_type(), scopeTyVars );
+                        if ( ! ty ) return offsetofExpr;
+
                         if ( StructInstType *structType = dynamic_cast< StructInstType* >( ty ) ) {
                                 // replace offsetof expression by index into offset array
@@ -2160 +2018 @@
                 }
 
-                Expression *PolyGenericCalculator::mutate( OffsetPackExpr *offsetPackExpr ) {
-                        StructInstType *ty = offsetPackExpr->get_type();
-
-                        Expression *ret = 0;
-                        if ( findGeneric( ty ) ) {
-                                // pull offset back from generated type information
-                                ret = new NameExpr( offsetofName( mangleType( ty ) ) );
-                        } else {
-                                std::string offsetName = offsetofName( mangleType( ty ) );
-                                if ( knownOffsets.find( offsetName ) != knownOffsets.end() ) {
-                                        // use the already-generated offsets for this type
-                                        ret = new NameExpr( offsetName );
-                                } else {
-                                        knownOffsets.insert( offsetName );
-
-                                        std::list< Declaration* > &baseMembers = ty->get_baseStruct()->get_members();
-                                        Type *offsetType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-
-                                        // build initializer list for offset array
-                                        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();
-                                                } else {
-                                                        memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
-                                                }
-                                                inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
-                                        }
-
-                                        // build the offset array and replace the pack with a reference to it
-                                        ObjectDecl *offsetArray = makeVar( offsetName, new ArrayType( Type::Qualifiers(), offsetType, new ConstantExpr( Constant::from( baseMembers.size() ) ), false, false ),
-                                                        new ListInit( inits ) );
-                                        ret = new VariableExpr( offsetArray );
-                                }
-                        }
-
-                        delete offsetPackExpr;
-                        return ret;
-                }
-
-                void PolyGenericCalculator::doBeginScope() {
-                        knownLayouts.beginScope();
-                        knownOffsets.beginScope();
-                }
-
-                void PolyGenericCalculator::doEndScope() {
-                        knownLayouts.endScope();
-                        knownOffsets.endScope();
-                }
-
 ////////////////////////////////////////// Pass3 ////////////////////////////////////////////////////
 
                 template< typename DeclClass >
                 DeclClass * Pass3::handleDecl( DeclClass *decl, Type *type ) {
-                        scopeTyVars.beginScope();
+                        TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( type, scopeTyVars );
 
@@ -2221 +2028 @@
                         ScrubTyVars::scrub( decl, scopeTyVars );
 
-                        scopeTyVars.endScope();
+                        scopeTyVars = oldtyVars;
                         return ret;
                 }
@@ -2251 +2058 @@
 
                 Type * Pass3::mutate( PointerType *pointerType ) {
-                        scopeTyVars.beginScope();
+                        TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( pointerType, scopeTyVars );
 
                         Type *ret = Mutator::mutate( pointerType );
 
-                        scopeTyVars.endScope();
+                        scopeTyVars = oldtyVars;
                         return ret;
                 }
 
                 Type * Pass3::mutate( FunctionType *functionType ) {
-                        scopeTyVars.beginScope();
+                        TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( functionType, scopeTyVars );
 
                         Type *ret = Mutator::mutate( functionType );
 
-                        scopeTyVars.endScope();
+                        scopeTyVars = oldtyVars;
                         return ret;
                 }