Changeset 24d6572 for src/GenPoly/Box.cc

Timestamp:

Jun 12, 2023, 2:45:32 PM (2 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

ast-experimental, master

Children:

62d62db

Parents:

34b4268 (diff), 251ce80 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into ast-experimental

File:

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

src/GenPoly/Box.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Dec 13 23:40:34 2019
-// Update Count     : 347
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Dec 19 16:36:00 2022
+// Update Count     : 348
 //
+
+#include "Box.h"
 
 #include <algorithm>                     // for mismatch
@@ -24 +26 @@
 #include <utility>                       // for pair
 
-#include "Box.h"
-
 #include "CodeGen/OperatorTable.h"
 #include "Common/PassVisitor.h"          // for PassVisitor
@@ -31 +31 @@
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/UniqueName.h"           // for UniqueName
-#include "Common/utility.h"              // for toString
+#include "Common/ToString.hpp"           // for toCString
 #include "FindFunction.h"                // for findFunction, findAndReplace...
 #include "GenPoly/ErasableScopedMap.h"   // for ErasableScopedMap<>::const_i...
@@ -37 +37 @@
 #include "InitTweak/InitTweak.h"         // for getFunctionName, isAssignment
 #include "Lvalue.h"                      // for generalizedLvalue
-#include "ResolvExpr/typeops.h"          // for typesCompatible
+#include "ResolvExpr/Unify.h"            // for typesCompatible
 #include "ScopedSet.h"                   // for ScopedSet, ScopedSet<>::iter...
 #include "ScrubTyVars.h"                 // for ScrubTyVars
@@ -72 +72 @@
                 };
 
+                /// Updates the call sites of polymorphic functions.
                 /// Replaces polymorphic return types with out-parameters,
                 /// replaces calls to polymorphic functions with adapter calls,
                 /// and adds appropriate type variables to the function call.
-                class Pass1 final : public BoxPass, public WithConstTypeSubstitution, public WithStmtsToAdd, public WithGuards, public WithVisitorRef<Pass1>, public WithShortCircuiting {
+                class CallAdapter final : public BoxPass, public WithConstTypeSubstitution, public WithStmtsToAdd, public WithGuards, public WithVisitorRef<CallAdapter>, public WithShortCircuiting {
                   public:
-                        Pass1();
-
+                        CallAdapter();
+
+                        void premutate( Declaration * declaration );
                         void premutate( FunctionDecl * functionDecl );
                         void premutate( TypeDecl * typeDecl );
@@ -138 +140 @@
                 };
 
+                /// Updates declarations (and types) that require adapters.
                 /// * Moves polymorphic returns in function types to pointer-type parameters
                 /// * adds type size and assertion parameters to parameter lists
-                struct Pass2 final : public BoxPass, public WithGuards {
+                struct DeclAdapter final : public BoxPass, public WithGuards {
                         void handleAggDecl();
 
@@ -210 +213 @@
                 };
 
+                /// Erases unneeded/unwanted polymorphic information.
                 /// Replaces initialization of polymorphic values with alloca,
                 /// declaration of dtype/ftype with appropriate void expression,
                 /// sizeof expressions of polymorphic types with the proper variable,
                 /// and strips fields from generic struct declarations.
-                struct Pass3 final : public BoxPass, public WithGuards {
-                        template< typename DeclClass >
-                        void handleDecl( DeclClass * decl, Type * type );
-
+                struct Eraser final {
                         void premutate( ObjectDecl * objectDecl );
                         void premutate( FunctionDecl * functionDecl );
@@ -223 +224 @@
                         void premutate( StructDecl * structDecl );
                         void premutate( UnionDecl * unionDecl );
-                        void premutate( TypeDecl * typeDecl );
-                        void premutate( PointerType * pointerType );
-                        void premutate( FunctionType * funcType );
                 };
         } // anonymous namespace
@@ -231 +229 @@
         void box( std::list< Declaration *>& translationUnit ) {
                 PassVisitor<LayoutFunctionBuilder> layoutBuilder;
-                PassVisitor<Pass1> pass1;
-                PassVisitor<Pass2> pass2;
+                PassVisitor<CallAdapter> callAdapter;
+                PassVisitor<DeclAdapter> declAdapter;
                 PassVisitor<PolyGenericCalculator> polyCalculator;
-                PassVisitor<Pass3> pass3;
+                PassVisitor<Eraser> eraser;
 
                 acceptAll( translationUnit, layoutBuilder );
-                mutateAll( translationUnit, pass1 );
-                mutateAll( translationUnit, pass2 );
+                mutateAll( translationUnit, callAdapter );
+                mutateAll( translationUnit, declAdapter );
                 mutateAll( translationUnit, polyCalculator );
-                mutateAll( translationUnit, pass3 );
+                mutateAll( translationUnit, eraser );
         }
 
-        ////////////////////////////////// LayoutFunctionBuilder ////////////////////////////////////////////
+////////////////////////////////// LayoutFunctionBuilder ////////////////////////////////////////
 
         /// Get a list of type declarations that will affect a layout function
@@ -423 +421 @@
         }
 
-        ////////////////////////////////////////// Pass1 ////////////////////////////////////////////////////
+////////////////////////////////////////////// CallAdapter //////////////////////////////////////
 
         namespace {
                 std::string makePolyMonoSuffix( FunctionType const * function, const TyVarMap &tyVars ) {
-                        std::stringstream name;
-
                         // NOTE: this function previously used isPolyObj, which failed to produce
                         // the correct thing in some situations. It's not clear to me why this wasn't working.
@@ -435 +431 @@
                         // to take those polymorphic types as pointers. Therefore, there can be two different functions
                         // with the same mangled name, so we need to further mangle the names.
+                        std::stringstream name;
                         for ( DeclarationWithType const * const ret : function->returnVals ) {
-                                if ( isPolyType( ret->get_type(), tyVars ) ) {
-                                        name << "P";
-                                } else {
-                                        name << "M";
-                                }
-                        }
-                        name << "_";
+                                name << ( isPolyType( ret->get_type(), tyVars ) ? 'P' : 'M' );
+                        }
+                        name << '_';
                         for ( DeclarationWithType const * const arg : function->parameters ) {
-                                if ( isPolyType( arg->get_type(), tyVars ) ) {
-                                        name << "P";
-                                } else {
-                                        name << "M";
-                                }
-                        } // for
+                                name << ( isPolyType( arg->get_type(), tyVars ) ? 'P' : 'M' );
+                        }
                         return name.str();
                 }
@@ -465 +454 @@
                 Type *replaceWithConcrete( Type *type, TypeSubstitution const * env, bool doClone = true );
 
-                Pass1::Pass1() : tempNamer( "_temp" ) {}
-
-                void Pass1::premutate( FunctionDecl *functionDecl ) {
+                CallAdapter::CallAdapter() : tempNamer( "_temp" ) {}
+
+                void CallAdapter::premutate( Declaration * ) {
+                        // Prevent type declaration information from leaking out.
+                        GuardScope( scopeTyVars );
+                }
+
+                void CallAdapter::premutate( FunctionDecl *functionDecl ) {
                         if ( functionDecl->get_statements() ) {         // empty routine body ?
                                 // std::cerr << "mutating function: " << functionDecl->get_mangleName() << std::endl;
@@ -500 +494 @@
                                 for ( FunctionType const * const funType : functions ) {
                                         std::string mangleName = mangleAdapterName( funType, scopeTyVars );
-                                        if ( adapters.find( mangleName ) == adapters.end() ) {
+                                        if ( !adapters.contains( mangleName ) ) {
                                                 std::string adapterName = makeAdapterName( mangleName );
                                                 adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( funType, scopeTyVars ) ), nullptr ) ) );
@@ -509 +503 @@
                 }
 
-                void Pass1::premutate( TypeDecl *typeDecl ) {
+                void CallAdapter::premutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
                 }
 
-                void Pass1::premutate( CommaExpr *commaExpr ) {
+                void CallAdapter::premutate( CommaExpr *commaExpr ) {
                         // Attempting to find application expressions that were mutated by the copy constructor passes
                         // to use an explicit return variable, so that the variable can be reused as a parameter to the
@@ -531 +525 @@
                 }
 
-                std::list< Expression *>::iterator Pass1::passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes ) {
+                std::list< Expression *>::iterator CallAdapter::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 ) ) {
@@ -558 +552 @@
                 }
 
-                std::list< Expression *>::iterator Pass1::passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, const TyVarMap &exprTyVars ) {
+                std::list< Expression *>::iterator CallAdapter::passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, const TyVarMap &exprTyVars ) {
                         assert( env );
                         std::list< Expression *>::iterator arg = appExpr->args.begin();
@@ -568 +562 @@
                         // even when converted to strings, sort in the original order.
                         // (At least, that is the best explination I have.)
-                        for ( std::pair<std::string, TypeDecl::Data> const & tyParam : exprTyVars ) {
+                        for ( std::pair<const std::string, TypeDecl::Data> const & tyParam : exprTyVars ) {
                                 if ( !tyParam.second.isComplete ) continue;
                                 Type *concrete = env->lookup( tyParam.first );
@@ -611 +605 @@
                 }
 
-                ObjectDecl *Pass1::makeTemporary( Type *type ) {
+                ObjectDecl *CallAdapter::makeTemporary( Type *type ) {
                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, type, 0 );
                         stmtsToAddBefore.push_back( new DeclStmt( newObj ) );
@@ -617 +611 @@
                 }
 
-                Expression *Pass1::addRetParam( ApplicationExpr *appExpr, Type *retType ) {
+                Expression *CallAdapter::addRetParam( ApplicationExpr *appExpr, Type *retType ) {
                         // Create temporary to hold return value of polymorphic function and produce that temporary as a result
                         // using a comma expression.
@@ -680 +674 @@
                 }
 
-                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, Type *dynType ) {
+                Expression *CallAdapter::addDynRetParam( ApplicationExpr *appExpr, Type *dynType ) {
                         Type *concrete = replaceWithConcrete( dynType, env );
                         // add out-parameter for return value
@@ -686 +680 @@
                 }
 
-                Expression *Pass1::applyAdapter( ApplicationExpr *appExpr, FunctionType *function ) {
+                Expression *CallAdapter::applyAdapter( ApplicationExpr *appExpr, FunctionType *function ) {
                         Expression *ret = appExpr;
                         if ( isDynRet( function, scopeTyVars ) ) {
@@ -735 +729 @@
                 }
 
-                void Pass1::boxParam( Expression *&arg, Type *param, const TyVarMap &exprTyVars ) {
+                void CallAdapter::boxParam( Expression *&arg, Type *param, const TyVarMap &exprTyVars ) {
                         assertf( arg->result, "arg does not have result: %s", toString( arg ).c_str() );
                         addCast( arg, param, exprTyVars );
@@ -770 +764 @@
                 }
 
-                void Pass1::boxParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *function, const TyVarMap &exprTyVars ) {
+                void CallAdapter::boxParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *function, const TyVarMap &exprTyVars ) {
                         for ( DeclarationWithType * param : function->parameters ) {
                                 assertf( arg != appExpr->args.end(), "boxParams: missing argument for param %s to %s in %s", toString( param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
@@ -778 +772 @@
                 }
 
-                void Pass1::addInferredParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *functionType, const TyVarMap &tyVars ) {
+                void CallAdapter::addInferredParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *functionType, const TyVarMap &tyVars ) {
                         for ( TypeDecl * const tyVar : functionType->forall ) {
                                 for ( DeclarationWithType * const assert : tyVar->assertions ) {
@@ -846 +840 @@
                 }
 
-                FunctionDecl *Pass1::makeAdapter( FunctionType const *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
+                FunctionDecl *CallAdapter::makeAdapter( FunctionType const *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
                         FunctionType *adapterType = makeAdapterType( adaptee, tyVars );
                         adapterType = ScrubTyVars::scrub( adapterType, tyVars );
@@ -906 +900 @@
                 }
 
-                void Pass1::passAdapters( ApplicationExpr * appExpr, FunctionType * functionType, const TyVarMap & exprTyVars ) {
+                void CallAdapter::passAdapters( ApplicationExpr * appExpr, FunctionType * functionType, const TyVarMap & exprTyVars ) {
                         // collect a list of function types passed as parameters or implicit parameters (assertions)
                         std::list<FunctionType const *> functions;
@@ -923 +917 @@
 
                         for ( FunctionType const * const funType : functions ) {
-                                FunctionType *originalFunction = funType->clone();
-                                FunctionType *realFunction = funType->clone();
-                                std::string mangleName = SymTab::Mangler::mangle( realFunction );
+                                std::string mangleName = SymTab::Mangler::mangle( funType );
 
                                 // only attempt to create an adapter or pass one as a parameter if we haven't already done so for this
                                 // pre-substitution parameter function type.
                                 // The second part of the insert result is "is the value new".
-                                if ( adaptersDone.insert( mangleName ).second ) {
-
-                                        // apply substitution to type variables to figure out what the adapter's type should look like
-                                        assert( env );
-                                        env->apply( realFunction );
-                                        mangleName = SymTab::Mangler::mangle( realFunction );
-                                        mangleName += makePolyMonoSuffix( originalFunction, exprTyVars );
-
-                                        typedef ScopedMap< std::string, DeclarationWithType* >::iterator AdapterIter;
-                                        AdapterIter adapter = adapters.find( mangleName );
-                                        if ( adapter == adapters.end() ) {
-                                                // adapter has not been created yet in the current scope, so define it
-                                                FunctionDecl *newAdapter = makeAdapter( funType, realFunction, mangleName, exprTyVars );
-                                                std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) );
-                                                adapter = answer.first;
-                                                stmtsToAddBefore.push_back( new DeclStmt( newAdapter ) );
-                                        } // if
-                                        assert( adapter != adapters.end() );
-
-                                        // add the appropriate adapter as a parameter
-                                        appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
+                                if ( !adaptersDone.insert( mangleName ).second ) continue;
+
+                                // Apply substitution to type variables to figure out what the adapter's type should look like.
+                                assert( env );
+                                FunctionType *realType = funType->clone();
+                                env->apply( realType );
+                                mangleName = SymTab::Mangler::mangle( realType );
+                                mangleName += makePolyMonoSuffix( funType, exprTyVars );
+
+                                typedef ScopedMap< std::string, DeclarationWithType* >::iterator AdapterIter;
+                                AdapterIter adapter = adapters.find( mangleName );
+                                if ( adapter == adapters.end() ) {
+                                        // Adapter has not been created yet in the current scope, so define it.
+                                        FunctionDecl *newAdapter = makeAdapter( funType, realType, mangleName, exprTyVars );
+                                        std::pair< AdapterIter, bool > answer = adapters.insert( mangleName, newAdapter );
+                                        adapter = answer.first;
+                                        stmtsToAddBefore.push_back( new DeclStmt( newAdapter ) );
                                 } // if
+                                assert( adapter != adapters.end() );
+
+                                // Add the appropriate adapter as a parameter.
+                                appExpr->args.push_front( new VariableExpr( adapter->second ) );
                         } // for
                 } // passAdapters
@@ -974 +966 @@
                 }
 
-                Expression *Pass1::handleIntrinsics( ApplicationExpr *appExpr ) {
+                Expression *CallAdapter::handleIntrinsics( ApplicationExpr *appExpr ) {
                         if ( VariableExpr *varExpr = dynamic_cast< VariableExpr *>( appExpr->function ) ) {
                                 if ( varExpr->var->linkage == LinkageSpec::Intrinsic ) {
@@ -1097 +1089 @@
                 }
 
-                Expression *Pass1::postmutate( ApplicationExpr *appExpr ) {
+                Expression *CallAdapter::postmutate( ApplicationExpr *appExpr ) {
                         // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl;
                         // for ( auto tyVar : scopeTyVars ) {
@@ -1169 +1161 @@
                 }
 
-                Expression * Pass1::postmutate( UntypedExpr *expr ) {
+                Expression * CallAdapter::postmutate( UntypedExpr *expr ) {
                         if ( isPolyDeref( expr, scopeTyVars, env ) ) {
                                 Expression *ret = expr->args.front();
@@ -1179 +1171 @@
                 }
 
-                void Pass1::premutate( AddressExpr * ) { visit_children = false; }
-
-                Expression * Pass1::postmutate( AddressExpr * addrExpr ) {
+                void CallAdapter::premutate( AddressExpr * ) { visit_children = false; }
+
+                Expression * CallAdapter::postmutate( AddressExpr * addrExpr ) {
                         assert( addrExpr->arg->result && ! addrExpr->arg->result->isVoid() );
 
@@ -1212 +1204 @@
                 }
 
-                void Pass1::premutate( ReturnStmt *returnStmt ) {
+                void CallAdapter::premutate( ReturnStmt *returnStmt ) {
                         if ( retval && returnStmt->expr ) {
                                 assert( returnStmt->expr->result && ! returnStmt->expr->result->isVoid() );
@@ -1220 +1212 @@
                 }
 
-                void Pass1::premutate( PointerType *pointerType ) {
+                void CallAdapter::premutate( PointerType *pointerType ) {
                         GuardScope( scopeTyVars );
                         makeTyVarMap( pointerType, scopeTyVars );
                 }
 
-                void Pass1::premutate( FunctionType *functionType ) {
+                void CallAdapter::premutate( FunctionType *functionType ) {
                         GuardScope( scopeTyVars );
                         makeTyVarMap( functionType, scopeTyVars );
                 }
 
-                void Pass1::beginScope() {
+                void CallAdapter::beginScope() {
                         adapters.beginScope();
                 }
 
-                void Pass1::endScope() {
+                void CallAdapter::endScope() {
                         adapters.endScope();
                 }
 
-////////////////////////////////////////// Pass2 ////////////////////////////////////////////////////
-
-                void Pass2::addAdapters( FunctionType *functionType ) {
+////////////////////////////////////////// DeclAdapter //////////////////////////////////////////
+
+                void DeclAdapter::addAdapters( FunctionType *functionType ) {
                         std::list< FunctionType const *> functions;
                         for ( DeclarationWithType * const arg : functionType->parameters ) {
@@ -1260 +1252 @@
                 }
 
-                DeclarationWithType * Pass2::postmutate( FunctionDecl *functionDecl ) {
+                DeclarationWithType * DeclAdapter::postmutate( FunctionDecl *functionDecl ) {
                         FunctionType * ftype = functionDecl->type;
                         if ( ! ftype->returnVals.empty() && functionDecl->statements ) {
@@ -1285 +1277 @@
                 }
 
-                void Pass2::premutate( StructDecl * ) {
+                void DeclAdapter::premutate( StructDecl * ) {
                         // prevent tyVars from leaking into containing scope
                         GuardScope( scopeTyVars );
                 }
 
-                void Pass2::premutate( UnionDecl * ) {
+                void DeclAdapter::premutate( UnionDecl * ) {
                         // prevent tyVars from leaking into containing scope
                         GuardScope( scopeTyVars );
                 }
 
-                void Pass2::premutate( TraitDecl * ) {
+                void DeclAdapter::premutate( TraitDecl * ) {
                         // prevent tyVars from leaking into containing scope
                         GuardScope( scopeTyVars );
                 }
 
-                void Pass2::premutate( TypeDecl *typeDecl ) {
+                void DeclAdapter::premutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
                 }
 
-                void Pass2::premutate( PointerType *pointerType ) {
+                void DeclAdapter::premutate( PointerType *pointerType ) {
                         GuardScope( scopeTyVars );
                         makeTyVarMap( pointerType, scopeTyVars );
                 }
 
-                void Pass2::premutate( FunctionType *funcType ) {
+                void DeclAdapter::premutate( FunctionType *funcType ) {
                         GuardScope( scopeTyVars );
                         makeTyVarMap( funcType, scopeTyVars );
@@ -1393 +1385 @@
                 }
 
-////////////////////////////////////////// PolyGenericCalculator ////////////////////////////////////////////////////
+////////////////////////////////////////// PolyGenericCalculator ////////////////////////////////
 
                 PolyGenericCalculator::PolyGenericCalculator()
@@ -1474 +1466 @@
                         // make sure that any type information passed into the function is accounted for
                         for ( DeclarationWithType * const fnParam : funcType->get_parameters() ) {
-                                // condition here duplicates that in Pass2::mutate( FunctionType* )
+                                // condition here duplicates that in DeclAdapter::mutate( FunctionType* )
                                 Type *polyType = isPolyType( fnParam->get_type(), scopeTyVars );
                                 if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
@@ -1501 +1493 @@
                                         if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
                                                 // do not try to monomorphize generic parameters
-                                                if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() && ! genericParams.count( typeInst->name ) ) {
+                                                if ( scopeTyVars.contains( typeInst->get_name() ) && ! genericParams.count( typeInst->name ) ) {
                                                         // polymorphic aggregate members should be converted into monomorphic members.
                                                         // Using char[size_T] here respects the expected sizing rules of an aggregate type.
@@ -1710 +1702 @@
 
                         if ( auto typeInst = dynamic_cast< TypeInstType const * >( ty ) ) {
-                                if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() ) {
+                                if ( scopeTyVars.contains( typeInst->get_name() ) ) {
                                         // NOTE assumes here that getting put in the scopeTyVars included having the layout variables set
                                         return true;
@@ -1718 +1710 @@
                                 // check if this type already has a layout generated for it
                                 std::string typeName = mangleType( ty );
-                                if ( knownLayouts.find( typeName ) != knownLayouts.end() ) return true;
+                                if ( knownLayouts.contains( typeName ) ) return true;
 
                                 // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
@@ -1755 +1747 @@
                                 // check if this type already has a layout generated for it
                                 std::string typeName = mangleType( ty );
-                                if ( knownLayouts.find( typeName ) != knownLayouts.end() ) return true;
+                                if ( knownLayouts.contains( typeName ) ) return true;
 
                                 // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
@@ -1846 +1838 @@
                         } else {
                                 std::string offsetName = offsetofName( mangleType( ty ) );
-                                if ( knownOffsets.find( offsetName ) != knownOffsets.end() ) {
+                                if ( knownOffsets.contains( offsetName ) ) {
                                         // use the already-generated offsets for this type
                                         ret = new NameExpr( offsetName );
@@ -1884 +1876 @@
                 }
 
-////////////////////////////////////////// Pass3 ////////////////////////////////////////////////////
-
-                template< typename DeclClass >
-                void Pass3::handleDecl( DeclClass * decl, Type * type ) {
-                        GuardScope( scopeTyVars );
-                        makeTyVarMap( type, scopeTyVars );
-                        ScrubTyVars::scrubAll( decl );
-                }
-
-                void Pass3::premutate( ObjectDecl * objectDecl ) {
-                        handleDecl( objectDecl, objectDecl->type );
-                }
-
-                void Pass3::premutate( FunctionDecl * functionDecl ) {
-                        handleDecl( functionDecl, functionDecl->type );
-                }
-
-                void Pass3::premutate( TypedefDecl * typedefDecl ) {
-                        handleDecl( typedefDecl, typedefDecl->base );
+////////////////////////////////////////// Eraser ///////////////////////////////////////////////
+
+                void Eraser::premutate( ObjectDecl * objectDecl ) {
+                        ScrubTyVars::scrubAll( objectDecl );
+                }
+
+                void Eraser::premutate( FunctionDecl * functionDecl ) {
+                        ScrubTyVars::scrubAll( functionDecl );
+                }
+
+                void Eraser::premutate( TypedefDecl * typedefDecl ) {
+                        ScrubTyVars::scrubAll( typedefDecl );
                 }
 
                 /// Strips the members from a generic aggregate
-                void stripGenericMembers(AggregateDecl * decl) {
+                static void stripGenericMembers( AggregateDecl * decl ) {
                         if ( ! decl->parameters.empty() ) decl->members.clear();
                 }
 
-                void Pass3::premutate( StructDecl * structDecl ) {
+                void Eraser::premutate( StructDecl * structDecl ) {
                         stripGenericMembers( structDecl );
                 }
 
-                void Pass3::premutate( UnionDecl * unionDecl ) {
+                void Eraser::premutate( UnionDecl * unionDecl ) {
                         stripGenericMembers( unionDecl );
-                }
-
-                void Pass3::premutate( TypeDecl * typeDecl ) {
-                        addToTyVarMap( typeDecl, scopeTyVars );
-                }
-
-                void Pass3::premutate( PointerType * pointerType ) {
-                        GuardScope( scopeTyVars );
-                        makeTyVarMap( pointerType, scopeTyVars );
-                }
-
-                void Pass3::premutate( FunctionType * functionType ) {
-                        GuardScope( scopeTyVars );
-                        makeTyVarMap( functionType, scopeTyVars );
                 }
         } // anonymous namespace
@@ -1939 +1910 @@
 // compile-command: "make install" //
 // End: //
-