Changeset 24d6572 for src/GenPoly

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

Location:

src/GenPoly

Files:

• Box.cc (modified) (44 diffs)
• ErasableScopedMap.h (modified) (4 diffs)
• FindFunction.cc (modified) (3 diffs)
• FindFunction.h (modified) (2 diffs)
• GenPoly.cc (modified) (10 diffs)
• GenPoly.h (modified) (1 diff)
• InstantiateGeneric.cc (modified) (1 diff)
• InstantiateGenericNew.cpp (modified) (2 diffs)
• Lvalue.cc (modified) (1 diff)
• LvalueNew.cpp (modified) (5 diffs)
• ScopedSet.h (modified) (1 diff)
• ScrubTyVars.cc (modified) (5 diffs)
• ScrubTyVars.h (modified) (5 diffs)
• SpecializeNew.cpp (modified) (1 diff)

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: //
-

src/GenPoly/ErasableScopedMap.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ScopedMap.h --
+// ErasableScopedMap.h --
 //
 // Author           : Aaron B. Moss
@@ -51 +51 @@
         typedef typename Scope::const_pointer const_pointer;
 
-        // Both iterator types are complete bidirection iterators, defined below.
+        // Both iterator types are complete bidirectional iterators, see below.
         class iterator;
         class const_iterator;
@@ -118 +118 @@
         std::pair< iterator, bool > insert( const Key &key, const Value &value ) { return insert( std::make_pair( key, value ) ); }
 
+        Value& operator[] ( const Key &key ) {
+                iterator slot = find( key );
+                if ( slot != end() ) return slot->second;
+                return insert( key, Value() ).first->second;
+        }
+
         /// Marks the given element as erased from this scope inward; returns 1 for erased an element, 0 otherwise
         size_type erase( const Key &key ) {
@@ -130 +136 @@
         }
 
-        Value& operator[] ( const Key &key ) {
-                iterator slot = find( key );
-                if ( slot != end() ) return slot->second;
-                return insert( key, Value() ).first->second;
+        bool contains( const Key & key ) const {
+                return find( key ) != cend();
         }
 };

src/GenPoly/FindFunction.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Fri Feb 05 12:22:20 2016
-// Update Count     : 6
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct  7 17:05:20 2022
+// Update Count     : 7
 //
 
@@ -18 +18 @@
 #include <utility>                      // for pair
 
+#include "AST/Pass.hpp"                 // for Pass
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"         // for PassVisitor
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::iterator
@@ -89 +91 @@
                 handleForall( pointerType->get_forall() );
         }
+
+namespace {
+
+struct FindFunctionCore :
+                public ast::WithGuards,
+                public ast::WithShortCircuiting,
+                public ast::WithVisitorRef<FindFunctionCore> {
+        FindFunctionCore(
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate,
+                bool replaceMode );
+
+        void previsit( ast::FunctionType const * type );
+        ast::Type const * postvisit( ast::FunctionType const * type );
+        void previsit( ast::PointerType const * type );
+private:
+        void handleForall( const ast::FunctionType::ForallList & forall );
+
+        std::vector<ast::ptr<ast::FunctionType>> &functions;
+        TypeVarMap typeVars;
+        FindFunctionPred predicate;
+        bool replaceMode;
+};
+
+FindFunctionCore::FindFunctionCore(
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap &typeVars, FindFunctionPred predicate,
+                bool replaceMode ) :
+        functions( functions ), typeVars( typeVars ),
+        predicate( predicate ), replaceMode( replaceMode ) {}
+
+void FindFunctionCore::handleForall( const ast::FunctionType::ForallList & forall ) {
+        for ( const ast::ptr<ast::TypeInstType> & td : forall ) {
+                TypeVarMap::iterator var = typeVars.find( *td );
+                if ( var != typeVars.end() ) {
+                        typeVars.erase( var->first );
+                } // if
+        } // for
+}
+
+void FindFunctionCore::previsit( ast::FunctionType const * type ) {
+        visit_children = false;
+        GuardScope( typeVars );
+        handleForall( type->forall );
+        //ast::accept_all( type->returns, *visitor );
+        // This might have to become ast::mutate_each with return.
+        ast::accept_each( type->returns, *visitor );
+}
+
+ast::Type const * FindFunctionCore::postvisit( ast::FunctionType const * type ) {
+        ast::Type const * ret = type;
+        if ( predicate( type, typeVars ) ) {
+                functions.push_back( type );
+                if ( replaceMode ) {
+                        // replace type parameters in function type with void*
+                        ret = scrubTypeVars( ast::deepCopy( type ), typeVars );
+                } // if
+        } // if
+        return ret;
+}
+
+void FindFunctionCore::previsit( ast::PointerType const * /*type*/ ) {
+        GuardScope( typeVars );
+        //handleForall( type->forall );
+}
+
+} // namespace
+
+void findFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate ) {
+        ast::Pass<FindFunctionCore> pass( functions, typeVars, predicate, false );
+        type->accept( pass );
+        //(void)type;
+        //(void)functions;
+        //(void)typeVars;
+        //(void)predicate;
+}
+
+const ast::Type * findAndReplaceFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate ) {
+        ast::Pass<FindFunctionCore> pass( functions, typeVars, predicate, true );
+        return type->accept( pass );
+        //(void)functions;
+        //(void)typeVars;
+        //(void)predicate;
+        //return type;
+}
+
 } // namespace GenPoly
 

src/GenPoly/FindFunction.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:23:36 2017
-// Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct  7 10:30:00 2022
+// Update Count     : 3
 //
 
@@ -30 +30 @@
         /// like `findFunction`, but also replaces the function type with void ()(void)
         void findAndReplaceFunction( Type *&type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate );
+
+typedef bool (*FindFunctionPred)( const ast::FunctionType *, const TypeVarMap & );
+
+/// Recursively walks `type`, placing all functions that match `predicate`
+/// under `typeVars` into `functions`.
+void findFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate );
+/// Like findFunction, but also replaces the function type with `void ()(void)`.
+const ast::Type * findAndReplaceFunction( const ast::Type * type,
+                std::vector<ast::ptr<ast::FunctionType>> & functions,
+                const TypeVarMap & typeVars, FindFunctionPred predicate );
+
 } // namespace GenPoly
 

src/GenPoly/GenPoly.cc

@@ -24 +24 @@
 #include <vector>                       // for vector
 
+#include "AST/Expr.hpp"
 #include "AST/Type.hpp"
+#include "AST/TypeSubstitution.hpp"
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::const_it...
 #include "ResolvExpr/typeops.h"         // for flatten
@@ -170 +172 @@
 
                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
-                        if ( tyVars.find( typeInst->get_name() ) != tyVars.end() ) {
+                        if ( tyVars.contains( typeInst->get_name() ) ) {
                                 return type;
                         }
@@ -187 +189 @@
 
                 if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
-                        return tyVars.find(typeInst->typeString()) != tyVars.end() ? type : nullptr;
+                        if ( tyVars.contains( typeInst->typeString() ) ) return type;
                 } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
                         return isPolyType( arrayType->base, env );
@@ -203 +205 @@
 
         if ( auto inst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
-                if ( typeVars.find( *inst ) != typeVars.end() ) return type;
+                if ( typeVars.contains( *inst ) ) return type;
         } else if ( auto array = dynamic_cast< const ast::ArrayType * >( type ) ) {
                 return isPolyType( array->base, subst );
@@ -272 +274 @@
                 return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes );
         }
+
+const ast::BaseInstType *isDynRet( const ast::FunctionType * func ) {
+        if ( func->returns.empty() ) return nullptr;
+
+        TypeVarMap forallTypes = { ast::TypeData() };
+        makeTypeVarMap( func, forallTypes );
+        return isDynType( func->returns.front(), forallTypes );
+}
 
         bool needsAdapter( FunctionType *adaptee, const TyVarMap &tyVars ) {
@@ -317 +327 @@
                 return 0;
         }
+
+const ast::Type * isPolyPtr(
+                const ast::Type * type, const TypeVarMap & typeVars,
+                const ast::TypeSubstitution * typeSubs ) {
+        type = replaceTypeInst( type, typeSubs );
+
+        if ( auto * ptr = dynamic_cast<ast::PointerType const *>( type ) ) {
+                return isPolyType( ptr->base, typeVars, typeSubs );
+        }
+        return nullptr;
+}
 
         Type * hasPolyBase( Type *type, int *levels, const TypeSubstitution *env ) {
@@ -391 +412 @@
 
                 if ( TypeInstType *typeInstType = dynamic_cast< TypeInstType * >( type ) ) {
-                        if ( tyVars.find( typeInstType->get_name() ) != tyVars.end() ) {
+                        if ( tyVars.contains( typeInstType->get_name() ) ) {
                                 return true;
                         }
@@ -490 +511 @@
                 }
 
+                /// Flattens a list of types.
+                // There is another flattenList in Unify.
                 void flattenList( vector<ast::ptr<ast::Type>> const & src,
                                 vector<ast::ptr<ast::Type>> & out ) {
@@ -792 +815 @@
         }
 
+void addToTypeVarMap( const ast::TypeDecl * decl, TypeVarMap & typeVars ) {
+        typeVars.insert( ast::TypeEnvKey( decl, 0, 0 ), ast::TypeData( decl ) );
+}
+
 void addToTypeVarMap( const ast::TypeInstType * type, TypeVarMap & typeVars ) {
-        typeVars.insert( *type, ast::TypeData( type->base ) );
+        typeVars.insert( ast::TypeEnvKey( *type ), ast::TypeData( type->base ) );
 }
 
@@ -818 +845 @@
 }
 
+void makeTypeVarMap( const ast::FunctionDecl * decl, TypeVarMap & typeVars ) {
+        for ( auto & typeDecl : decl->type_params ) {
+                addToTypeVarMap( typeDecl, typeVars );
+        }
+}
+
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap ) {
                 for ( TyVarMap::const_iterator i = tyVarMap.begin(); i != tyVarMap.end(); ++i ) {

src/GenPoly/GenPoly.h

@@ -111 +111 @@
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap );
         void addToTypeVarMap( const ast::TypeDecl * type, TypeVarMap & typeVars );
+        void addToTypeVarMap( const ast::TypeInstType * type, TypeVarMap & typeVars );
 
         /// Adds the declarations in the forall list of type (and its pointed-to type if it's a pointer type) to `tyVarMap`
         void makeTyVarMap( Type *type, TyVarMap &tyVarMap );
         void makeTypeVarMap( const ast::Type * type, TypeVarMap & typeVars );
+        void makeTypeVarMap( const ast::FunctionDecl * decl, TypeVarMap & typeVars );
 
         /// Prints type variable map

src/GenPoly/InstantiateGeneric.cc

@@ -28 +28 @@
 #include "GenPoly.h"                   // for isPolyType, typesPolyCompatible
 #include "InitTweak/InitTweak.h"
-#include "ResolvExpr/typeops.h"
+#include "ResolvExpr/AdjustExprType.hpp"  // for adjustExprType
+#include "ResolvExpr/Unify.h"          // for typesCompatible
 #include "ScopedSet.h"                 // for ScopedSet, ScopedSet<>::iterator
 #include "ScrubTyVars.h"               // for ScrubTyVars

src/GenPoly/InstantiateGenericNew.cpp

@@ -32 +32 @@
 #include "GenPoly/GenPoly.h"           // for isPolyType, typesPolyCompatible
 #include "GenPoly/ScrubTyVars.h"       // for scrubAll
-#include "ResolvExpr/typeops.h"        // for typesCompatible
+#include "ResolvExpr/AdjustExprType.hpp"  // for adjustExprType
+#include "ResolvExpr/Unify.h"          // for typesCompatible
 
 namespace GenPoly {
@@ -361 +362 @@
                         ResolvExpr::typesCompatible(
                                 memberExpr->result,
-                                memberExpr->member->get_type(), ast::SymbolTable() ) ) {
+                                memberExpr->member->get_type() ) ) {
                 return memberExpr;
         }

src/GenPoly/Lvalue.cc

@@ -17 +17 @@
 #include <string>                        // for string
 
+#include "Common/ToString.hpp"           // for toCString
 #include "Common/UniqueName.h"
 #include "Common/PassVisitor.h"

src/GenPoly/LvalueNew.cpp

@@ -25 +25 @@
 #include "AST/Pass.hpp"
 #include "Common/SemanticError.h"      // for SemanticWarning
+#include "Common/ToString.hpp"         // for toCString
 #include "Common/UniqueName.h"         // for UniqueName
 #include "GenPoly/GenPoly.h"           // for genFunctionType
@@ -358 +359 @@
                                 !ResolvExpr::typesCompatible(
                                         srcType,
-                                        strict_dynamic_cast<ast::ReferenceType const *>( dstType )->base,
-                                        ast::SymbolTable() ) ) {
+                                        strict_dynamic_cast<ast::ReferenceType const *>( dstType )->base ) ) {
                         // Must keep cast if cast-to type is different from the actual type.
                         return ast::mutate_field( expr, &ast::CastExpr::arg, ret );
@@ -376 +376 @@
                 if ( !ResolvExpr::typesCompatibleIgnoreQualifiers(
                                 dstType->stripReferences(),
-                                srcType->stripReferences(),
-                                ast::SymbolTable() ) ) {
+                                srcType->stripReferences() ) ) {
                         return ast::mutate_field( expr, &ast::CastExpr::arg, ret );
                 }
@@ -392 +391 @@
                                 ResolvExpr::typesCompatible(
                                         expr->result,
-                                        expr->arg->result, ast::SymbolTable() ) ) {
+                                        expr->arg->result ) ) {
                         PRINT(
                                 std::cerr << "types are compatible, removing cast: " << expr << '\n';
@@ -589 +588 @@
                 ast::OpenVarSet openVars;
                 ResolvExpr::unify( ret->arg2->result, ret->arg3->result, newEnv,
-                        needAssertions, haveAssertions, openVars,
-                        ast::SymbolTable(), common );
+                        needAssertions, haveAssertions, openVars, common );
                 ret->result = common ? common : ast::deepCopy( ret->arg2->result );
                 return ret;

src/GenPoly/ScopedSet.h

@@ -21 +21 @@
 
 namespace GenPoly {
-        /// A set where the items are placed into nested scopes;
-        /// inserted items are placed into the innermost scope, lookup looks from the innermost scope outward
-        template<typename Value>
-        class ScopedSet {
-                typedef std::set< Value > Scope;
-                typedef std::vector< Scope > ScopeList;
-
-                ScopeList scopes; ///< scoped list of sets
-        public:
-                typedef typename Scope::key_type key_type;
-                typedef typename Scope::value_type value_type;
-                typedef typename ScopeList::size_type size_type;
-                typedef typename ScopeList::difference_type difference_type;
-                typedef typename Scope::reference reference;
-                typedef typename Scope::const_reference const_reference;
-                typedef typename Scope::pointer pointer;
-                typedef typename Scope::const_pointer const_pointer;
-
-                class iterator : public std::iterator< std::bidirectional_iterator_tag,
-                                                       value_type > {
-                friend class ScopedSet;
-                friend class const_iterator;
-                        typedef typename std::set< Value >::iterator wrapped_iterator;
-                        typedef typename std::vector< std::set< Value > > scope_list;
-                        typedef typename scope_list::size_type size_type;
-
-                        /// Checks if this iterator points to a valid item
-                        bool is_valid() const {
-                                return it != (*scopes)[i].end();
-                        }
-
-                        /// Increments on invalid
-                        iterator& next_valid() {
-                                if ( ! is_valid() ) { ++(*this); }
-                                return *this;
-                        }
-
-                        /// Decrements on invalid
-                        iterator& prev_valid() {
-                                if ( ! is_valid() ) { --(*this); }
-                                return *this;
-                        }
-
-                        iterator(scope_list const &_scopes, const wrapped_iterator &_it, size_type _i)
-                                : scopes(&_scopes), it(_it), i(_i) {}
-                public:
-                        iterator(const iterator &that) : scopes(that.scopes), it(that.it), i(that.i) {}
-                        iterator& operator= (const iterator &that) {
-                                scopes = that.scopes; i = that.i; it = that.it;
-                                return *this;
-                        }
-
-                        reference operator* () { return *it; }
-                        pointer operator-> () { return it.operator->(); }
-
-                        iterator& operator++ () {
-                                if ( it == (*scopes)[i].end() ) {
-                                        if ( i == 0 ) return *this;
-                                        --i;
-                                        it = (*scopes)[i].begin();
-                                } else {
-                                        ++it;
-                                }
-                                return next_valid();
-                        }
-                        iterator operator++ (int) { iterator tmp = *this; ++(*this); return tmp; }
-
-                        iterator& operator-- () {
-                                // may fail if this is the begin iterator; allowed by STL spec
-                                if ( it == (*scopes)[i].begin() ) {
-                                        ++i;
-                                        it = (*scopes)[i].end();
-                                }
-                                --it;
-                                return prev_valid();
-                        }
-                        iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
-
-                        bool operator== (const iterator &that) {
-                                return scopes == that.scopes && i == that.i && it == that.it;
-                        }
-                        bool operator!= (const iterator &that) { return !( *this == that ); }
-
-                        size_type get_level() const { return i; }
-
-                private:
-                        scope_list const *scopes;
-                        wrapped_iterator it;
-                        size_type i;
-                };
-
-                class const_iterator : public std::iterator< std::bidirectional_iterator_tag,
-                                                             value_type > {
-                friend class ScopedSet;
-                        typedef typename std::set< Value >::iterator wrapped_iterator;
-                        typedef typename std::set< Value >::const_iterator wrapped_const_iterator;
-                        typedef typename std::vector< std::set< Value > > scope_list;
-                        typedef typename scope_list::size_type size_type;
-
-                        /// Checks if this iterator points to a valid item
-                        bool is_valid() const {
-                                return it != (*scopes)[i].end();
-                        }
-
-                        /// Increments on invalid
-                        const_iterator& next_valid() {
-                                if ( ! is_valid() ) { ++(*this); }
-                                return *this;
-                        }
-
-                        /// Decrements on invalid
-                        const_iterator& prev_valid() {
-                                if ( ! is_valid() ) { --(*this); }
-                                return *this;
-                        }
-
-                        const_iterator(scope_list const &_scopes, const wrapped_const_iterator &_it, size_type _i)
-                                : scopes(&_scopes), it(_it), i(_i) {}
-                public:
-                        const_iterator(const iterator &that) : scopes(that.scopes), it(that.it), i(that.i) {}
-                        const_iterator(const const_iterator &that) : scopes(that.scopes), it(that.it), i(that.i) {}
-                        const_iterator& operator= (const iterator &that) {
-                                scopes = that.scopes; i = that.i; it = that.it;
-                                return *this;
-                        }
-                        const_iterator& operator= (const const_iterator &that) {
-                                scopes = that.scopes; i = that.i; it = that.it;
-                                return *this;
-                        }
-
-                        const_reference operator* () { return *it; }
-                        const_pointer operator-> () { return it.operator->(); }
-
-                        const_iterator& operator++ () {
-                                if ( it == (*scopes)[i].end() ) {
-                                        if ( i == 0 ) return *this;
-                                        --i;
-                                        it = (*scopes)[i].begin();
-                                } else {
-                                        ++it;
-                                }
-                                return next_valid();
-                        }
-                        const_iterator operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; }
-
-                        const_iterator& operator-- () {
-                                // may fail if this is the begin iterator; allowed by STL spec
-                                if ( it == (*scopes)[i].begin() ) {
-                                        ++i;
-                                        it = (*scopes)[i].end();
-                                }
-                                --it;
-                                return prev_valid();
-                        }
-                        const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
-
-                        bool operator== (const const_iterator &that) {
-                                return scopes == that.scopes && i == that.i && it == that.it;
-                        }
-                        bool operator!= (const const_iterator &that) { return !( *this == that ); }
-
-                        size_type get_level() const { return i; }
-
-                private:
-                        scope_list const *scopes;
-                        wrapped_const_iterator it;
-                        size_type i;
-                };
-
-                /// Starts a new scope
-                void beginScope() {
-                        Scope scope;
-                        scopes.push_back(scope);
-                }
-
-                /// Ends a scope; invalidates any iterators pointing to elements of that scope
-                void endScope() {
-                        scopes.pop_back();
-                }
-
-                /// Default constructor initializes with one scope
-                ScopedSet() { beginScope(); }
-
-                iterator begin() { return iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
-                const_iterator begin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
-                const_iterator cbegin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
-                iterator end() { return iterator(scopes, scopes[0].end(), 0); }
-                const_iterator end() const { return const_iterator(scopes, scopes[0].end(), 0); }
-                const_iterator cend() const { return const_iterator(scopes, scopes[0].end(), 0); }
-
-                /// Gets the index of the current scope (counted from 1)
-                size_type currentScope() const { return scopes.size(); }
-
-                /// Finds the given key in the outermost scope it occurs; returns end() for none such
-                iterator find( const Value &key ) {
-                        for ( size_type i = scopes.size() - 1; ; --i ) {
-                                typename Scope::iterator val = scopes[i].find( key );
-                                if ( val != scopes[i].end() ) return iterator( scopes, val, i );
-                                if ( i == 0 ) break;
-                        }
-                        return end();
-                }
-                const_iterator find( const Value &key ) const {
-                        return const_iterator( const_cast< ScopedSet< Value >* >(this)->find( key ) );
-                }
-
-                /// Finds the given key in the outermost scope inside the given scope where it occurs
-                iterator findNext( const_iterator &it, const Value &key ) {
-                        if ( it.i == 0 ) return end();
+
+/// A set where the items are placed into nested scopes;
+/// inserted items are placed into the innermost scope, lookup looks from the innermost scope outward
+template<typename Value>
+class ScopedSet {
+        typedef std::set< Value > Scope;
+        typedef std::vector< Scope > ScopeList;
+
+        /// Scoped list of sets.
+        ScopeList scopes;
+public:
+        typedef typename Scope::key_type key_type;
+        typedef typename Scope::value_type value_type;
+        typedef typename ScopeList::size_type size_type;
+        typedef typename ScopeList::difference_type difference_type;
+        typedef typename Scope::reference reference;
+        typedef typename Scope::const_reference const_reference;
+        typedef typename Scope::pointer pointer;
+        typedef typename Scope::const_pointer const_pointer;
+
+        // Both iterator types are complete bidirectional iterators, see below.
+        class iterator;
+        class const_iterator;
+
+        /// Starts a new scope
+        void beginScope() {
+                Scope scope;
+                scopes.push_back(scope);
+        }
+
+        /// Ends a scope; invalidates any iterators pointing to elements of that scope
+        void endScope() {
+                scopes.pop_back();
+        }
+
+        /// Default constructor initializes with one scope
+        ScopedSet() { beginScope(); }
+
+        iterator begin() { return iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
+        const_iterator begin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
+        const_iterator cbegin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
+        iterator end() { return iterator(scopes, scopes[0].end(), 0); }
+        const_iterator end() const { return const_iterator(scopes, scopes[0].end(), 0); }
+        const_iterator cend() const { return const_iterator(scopes, scopes[0].end(), 0); }
+
+        /// Gets the index of the current scope (counted from 1)
+        size_type currentScope() const { return scopes.size(); }
+
+        /// Finds the given key in the outermost scope it occurs; returns end() for none such
+        iterator find( const Value &key ) {
+                for ( size_type i = scopes.size() - 1; ; --i ) {
+                        typename Scope::iterator val = scopes[i].find( key );
+                        if ( val != scopes[i].end() ) return iterator( scopes, val, i );
+                        if ( i == 0 ) break;
+                }
+                return end();
+        }
+        const_iterator find( const Value &key ) const {
+                return const_iterator( const_cast< ScopedSet< Value >* >(this)->find( key ) );
+        }
+
+        /// Finds the given key in the outermost scope inside the given scope where it occurs
+        iterator findNext( const_iterator &it, const Value &key ) {
+                if ( it.i == 0 ) return end();
                         for ( size_type i = it.i - 1; ; --i ) {
-                                typename Scope::iterator val = scopes[i].find( key );
-                                if ( val != scopes[i].end() ) return iterator( scopes, val, i );
-                                if ( i == 0 ) break;
-                        }
-                        return end();
-                }
-                const_iterator findNext( const_iterator &it, const Value &key ) const {
-                        return const_iterator( const_cast< ScopedSet< Value >* >(this)->findNext( it, key ) );
-                }
-
-                /// Inserts the given value into the outermost scope
-                std::pair< iterator, bool > insert( const value_type &value ) {
-                        std::pair< typename Scope::iterator, bool > res = scopes.back().insert( value );
-                        return std::make_pair( iterator(scopes, res.first, scopes.size()-1), res.second );
-                }
-
-        };
+                        typename Scope::iterator val = scopes[i].find( key );
+                        if ( val != scopes[i].end() ) return iterator( scopes, val, i );
+                        if ( i == 0 ) break;
+                }
+                return end();
+        }
+        const_iterator findNext( const_iterator &it, const Value &key ) const {
+                return const_iterator( const_cast< ScopedSet< Value >* >(this)->findNext( it, key ) );
+        }
+
+        /// Inserts the given value into the outermost scope
+        std::pair< iterator, bool > insert( const value_type &value ) {
+                std::pair< typename Scope::iterator, bool > res = scopes.back().insert( value );
+                return std::make_pair( iterator(scopes, res.first, scopes.size()-1), res.second );
+        }
+
+        bool contains( const Value & key ) const {
+                return find( key ) != cend();
+        }
+};
+
+template<typename Value>
+class ScopedSet<Value>::iterator :
+                public std::iterator< std::bidirectional_iterator_tag, value_type > {
+        friend class ScopedSet;
+        friend class const_iterator;
+        typedef typename std::set< Value >::iterator wrapped_iterator;
+        typedef typename std::vector< std::set< Value > > scope_list;
+        typedef typename scope_list::size_type size_type;
+
+        /// Checks if this iterator points to a valid item
+        bool is_valid() const {
+                return it != (*scopes)[i].end();
+        }
+
+        /// Increments on invalid
+        iterator& next_valid() {
+                if ( ! is_valid() ) { ++(*this); }
+                return *this;
+        }
+
+        /// Decrements on invalid
+        iterator& prev_valid() {
+                if ( ! is_valid() ) { --(*this); }
+                return *this;
+        }
+
+        iterator(scope_list const &_scopes, const wrapped_iterator &_it, size_type _i)
+                : scopes(&_scopes), it(_it), i(_i) {}
+public:
+        iterator(const iterator &that) : scopes(that.scopes), it(that.it), i(that.i) {}
+        iterator& operator= (const iterator &that) {
+                scopes = that.scopes; i = that.i; it = that.it;
+                return *this;
+        }
+
+        reference operator* () { return *it; }
+        pointer operator-> () { return it.operator->(); }
+
+        iterator& operator++ () {
+                if ( it == (*scopes)[i].end() ) {
+                        if ( i == 0 ) return *this;
+                        --i;
+                        it = (*scopes)[i].begin();
+                } else {
+                        ++it;
+                }
+                return next_valid();
+        }
+        iterator operator++ (int) { iterator tmp = *this; ++(*this); return tmp; }
+
+        iterator& operator-- () {
+                // may fail if this is the begin iterator; allowed by STL spec
+                if ( it == (*scopes)[i].begin() ) {
+                        ++i;
+                        it = (*scopes)[i].end();
+                }
+                --it;
+                return prev_valid();
+        }
+        iterator operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
+
+        bool operator== (const iterator &that) {
+                return scopes == that.scopes && i == that.i && it == that.it;
+        }
+        bool operator!= (const iterator &that) { return !( *this == that ); }
+
+        size_type get_level() const { return i; }
+
+private:
+        scope_list const *scopes;
+        wrapped_iterator it;
+        size_type i;
+};
+
+template<typename Value>
+class ScopedSet<Value>::const_iterator :
+                public std::iterator< std::bidirectional_iterator_tag, value_type > {
+        friend class ScopedSet;
+        typedef typename std::set< Value >::iterator wrapped_iterator;
+        typedef typename std::set< Value >::const_iterator wrapped_const_iterator;
+        typedef typename std::vector< std::set< Value > > scope_list;
+        typedef typename scope_list::size_type size_type;
+
+        /// Checks if this iterator points to a valid item
+        bool is_valid() const {
+                return it != (*scopes)[i].end();
+        }
+
+        /// Increments on invalid
+        const_iterator& next_valid() {
+                if ( ! is_valid() ) { ++(*this); }
+                return *this;
+        }
+
+        /// Decrements on invalid
+        const_iterator& prev_valid() {
+                if ( ! is_valid() ) { --(*this); }
+                return *this;
+        }
+
+        const_iterator(scope_list const &_scopes, const wrapped_const_iterator &_it, size_type _i)
+                : scopes(&_scopes), it(_it), i(_i) {}
+public:
+        const_iterator(const iterator &that) : scopes(that.scopes), it(that.it), i(that.i) {}
+        const_iterator(const const_iterator &that) : scopes(that.scopes), it(that.it), i(that.i) {}
+        const_iterator& operator= (const iterator &that) {
+                scopes = that.scopes; i = that.i; it = that.it;
+                return *this;
+        }
+        const_iterator& operator= (const const_iterator &that) {
+                scopes = that.scopes; i = that.i; it = that.it;
+                return *this;
+        }
+
+        const_reference operator* () { return *it; }
+        const_pointer operator-> () { return it.operator->(); }
+
+        const_iterator& operator++ () {
+                if ( it == (*scopes)[i].end() ) {
+                        if ( i == 0 ) return *this;
+                        --i;
+                        it = (*scopes)[i].begin();
+                } else {
+                        ++it;
+                }
+                return next_valid();
+        }
+        const_iterator operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; }
+
+        const_iterator& operator-- () {
+                // may fail if this is the begin iterator; allowed by STL spec
+                if ( it == (*scopes)[i].begin() ) {
+                        ++i;
+                        it = (*scopes)[i].end();
+                }
+                --it;
+                return prev_valid();
+        }
+        const_iterator operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
+
+        bool operator== (const const_iterator &that) {
+                return scopes == that.scopes && i == that.i && it == that.it;
+        }
+        bool operator!= (const const_iterator &that) { return !( *this == that ); }
+
+        size_type get_level() const { return i; }
+
+private:
+        scope_list const *scopes;
+        wrapped_const_iterator it;
+        size_type i;
+};
+
 } // namespace GenPoly
 

src/GenPoly/ScrubTyVars.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Oct  7 15:42:00 2022
-// Update Count     : 5
+// Last Modified On : Wed Dec  7 17:01:00 2022
+// Update Count     : 6
 //
 
@@ -117 +117 @@
 namespace {
 
-enum class ScrubMode {
-        FromMap,
-        DynamicFromMap,
-        All,
-};
-
 struct ScrubTypeVars :
         public ast::WithGuards,
@@ -184 +178 @@
 
 ast::Type const * ScrubTypeVars::postvisit( ast::TypeInstType const * type ) {
+        ast::TypeDecl::Kind kind;
         // This implies that mode == ScrubMode::All.
         if ( !typeVars ) {
-                if ( ast::TypeDecl::Ftype == type->kind ) {
-                        return new ast::PointerType(
-                                new ast::FunctionType( ast::FixedArgs ) );
-                } else {
-                        return new ast::PointerType(
-                                new ast::VoidType( type->qualifiers ) );
-                }
-        }
-
-        auto typeVar = typeVars->find( *type );
-        if ( typeVar == typeVars->end() ) {
-                return type;
-        }
-
-        switch ( typeVar->second.kind ) {
-        case ::TypeDecl::Dtype:
-        case ::TypeDecl::Ttype:
+                kind = type->kind;
+        } else {
+                // Otherwise, only scrub the type var if it is in map.
+                auto typeVar = typeVars->find( *type );
+                if ( typeVar == typeVars->end() ) {
+                        return type;
+                }
+                kind = typeVar->second.kind;
+        }
+
+        switch ( kind ) {
+        case ast::TypeDecl::Dtype:
+        case ast::TypeDecl::Ttype:
                 return new ast::PointerType(
                         new ast::VoidType( type->qualifiers ) );
-        case ::TypeDecl::Ftype:
+        case ast::TypeDecl::Ftype:
                 return new ast::PointerType(
                         new ast::FunctionType( ast::VariableArgs ) );
         default:
-                assertf( false,
-                        "Unhandled type variable kind: %d", typeVar->second.kind );
+                assertf( false, "Unhandled type variable kind: %d", kind );
                 throw; // Just in case the assert is removed, stop here.
         }
@@ -253 +243 @@
 }
 
+} // namespace
+
 const ast::Node * scrubTypeVarsBase(
-                const ast::Node * target,
-                ScrubMode mode, const TypeVarMap * typeVars ) {
+                const ast::Node * node, const TypeVarMap * typeVars, ScrubMode mode ) {
         if ( ScrubMode::All == mode ) {
                 assert( nullptr == typeVars );
@@ -262 +253 @@
         }
         ast::Pass<ScrubTypeVars> visitor( mode, typeVars );
-        return target->accept( visitor );
-}
-
-} // namespace
-
-template<>
-ast::Node const * scrubTypeVars<ast::Node>(
-        const ast::Node * target, const TypeVarMap & typeVars ) {
-        return scrubTypeVarsBase( target, ScrubMode::FromMap, &typeVars );
-}
-
-template<>
-ast::Node const * scrubTypeVarsDynamic<ast::Node>(
-        ast::Node const * target, const TypeVarMap & typeVars ) {
-        return scrubTypeVarsBase( target, ScrubMode::DynamicFromMap, &typeVars );
-}
-
-template<>
-ast::Node const * scrubAllTypeVars<ast::Node>( const ast::Node * target ) {
-        return scrubTypeVarsBase( target, ScrubMode::All, nullptr );
+        return node->accept( visitor );
 }
 

src/GenPoly/ScrubTyVars.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Oct  7 15:51:00 2022
-// Update Count     : 4
+// Last Modified On : Wed Dec  7 16:57:00 2022
+// Update Count     : 5
 //
 
@@ -109 +109 @@
         }
 
+// ScrubMode and scrubTypeVarsBase are internal.
+enum class ScrubMode { FromMap, DynamicFromMap, All };
+
+const ast::Node * scrubTypeVarsBase(
+        const ast::Node * target, const TypeVarMap * typeVars, ScrubMode mode );
+
+
 /// For all polymorphic types with type variables in `typeVars`,
 /// replaces generic types, dtypes, and ftypes with the appropriate void type,
@@ -116 +123 @@
                 node_t const * target, const TypeVarMap & typeVars ) {
         return strict_dynamic_cast<node_t const *>(
-                        scrubTypeVars<ast::Node>( target, typeVars ) );
+                        scrubTypeVarsBase( target, &typeVars, ScrubMode::FromMap ) );
 }
 
@@ -123 +130 @@
 /// and sizeof/alignof expressions with the proper variable.
 template<typename node_t>
-ast::Node const * scrubTypeVarsDynamic(
+node_t const * scrubTypeVarsDynamic(
                 node_t const * target, const TypeVarMap & typeVars ) {
         return strict_dynamic_cast<node_t const *>(
-                        scrubTypeVarsDynamic<ast::Node>( target, typeVars ) );
+                        scrubTypeVarsBase( target, &typeVars, ScrubMode::DynamicFromMap ) );
 }
 
@@ -134 +141 @@
 node_t const * scrubAllTypeVars( node_t const * target ) {
         return strict_dynamic_cast<node_t const *>(
-                        scrubAllTypeVars<ast::Node>( target ) );
+                        scrubTypeVarsBase( target, nullptr, ScrubMode::All ) );
 }
-
-// We specialize for Node as a base case.
-template<>
-ast::Node const * scrubTypeVars<ast::Node>(
-                const ast::Node * target, const TypeVarMap & typeVars );
-
-template<>
-ast::Node const * scrubTypeVarsDynamic<ast::Node>(
-                ast::Node const * target, const TypeVarMap & typeVars );
-
-template<>
-ast::Node const * scrubAllTypeVars<ast::Node>( const ast::Node * target );
 
 } // namespace GenPoly

src/GenPoly/SpecializeNew.cpp

@@ -16 +16 @@
 #include "Specialize.h"
 
+#include "AST/Copy.hpp"                  // for deepCopy
 #include "AST/Inspect.hpp"               // for isIntrinsicCallExpr
 #include "AST/Pass.hpp"                  // for Pass