Changeset 265e460 for src/GenPoly

Timestamp:

Oct 8, 2022, 9:43:21 AM (3 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master

Children:

b2ddaf3

Parents:

815943f (diff), d8c96a9 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/GenPoly

Files:

• Box.cc (modified) (4 diffs)
• GenPoly.cc (modified) (14 diffs)
• GenPoly.h (modified) (8 diffs)
• Lvalue.h (modified) (3 diffs)
• LvalueNew.cpp (added)
• ScrubTyVars.cc (modified) (5 diffs)
• ScrubTyVars.h (modified) (2 diffs)
• module.mk (modified) (1 diff)

src/GenPoly/Box.cc

@@ -66 +66 @@
                 };
 
-                /// Adds layout-generation functions to polymorphic types
+                /// Adds layout-generation functions to polymorphic types.
                 class LayoutFunctionBuilder final : public WithDeclsToAdd, public WithVisitorRef<LayoutFunctionBuilder>, public WithShortCircuiting {
-                        unsigned int functionNesting = 0;  // current level of nested functions
+                        // Current level of nested functions:
+                        unsigned int functionNesting = 0;
                 public:
                         void previsit( FunctionDecl *functionDecl );
@@ -75 +76 @@
                 };
 
-                /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
+                /// 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 {
                   public:
@@ -146 +149 @@
                 };
 
-                /// Replaces member and size/align/offsetof expressions on polymorphic generic types with calculated expressions.
+                /// * Replaces member and size/align/offsetof expressions on polymorphic generic types with calculated expressions.
                 /// * Replaces member expressions for polymorphic types with calculated add-field-offset-and-dereference
                 /// * Calculates polymorphic offsetof expressions from offset array
@@ -199 +202 @@
                 };
 
-                /// 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.
+                /// 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 >

src/GenPoly/GenPoly.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Sep 14  9:24:00 2022
-// Update Count     : 15
+// Last Modified On : Fri Oct  7 15:25:00 2022
+// Update Count     : 16
 //
 
@@ -64 +64 @@
                 }
 
-                __attribute__((unused))
-                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
-                        for (auto &param : params) {
-                                auto paramType = param.strict_as<ast::TypeExpr>();
-                                if (isPolyType(paramType->type, tyVars, env)) return true;
-                        }
-                        return false;
-                }
-
                 /// Checks a parameter list for dynamic-layout parameters from tyVars; will substitute according to env if present
                 bool hasDynParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
@@ -83 +74 @@
                 }
 
-                bool hasDynParams( const std::vector<ast::ptr<ast::Expr>> & params, const TyVarMap &tyVars, const ast::TypeSubstitution *typeSubs ) {
-                        for ( ast::ptr<ast::Expr> const & param : params ) {
-                                auto paramType = param.as<ast::TypeExpr>();
-                                assertf( paramType, "Aggregate parameters should be type expressions." );
-                                if ( isDynType( paramType->type, tyVars, typeSubs ) ) {
+                bool hasDynParams(
+                                const std::vector<ast::ptr<ast::Expr>> & params,
+                                const TypeVarMap & typeVars,
+                                const ast::TypeSubstitution * subst ) {
+                        for ( ast::ptr<ast::Expr> const & paramExpr : params ) {
+                                auto param = paramExpr.as<ast::TypeExpr>();
+                                assertf( param, "Aggregate parameters should be type expressions." );
+                                if ( isDynType( param->type.get(), typeVars, subst ) ) {
                                         return true;
                                 }
@@ -195 +189 @@
         }
 
+const ast::Type * isPolyType( const ast::Type * type,
+                const TypeVarMap & typeVars, const ast::TypeSubstitution * subst ) {
+        type = replaceTypeInst( type, subst );
+
+        if ( auto inst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
+                if ( typeVars.find( inst->typeString() ) != typeVars.end() ) return type;
+        } else if ( auto array = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                return isPolyType( array->base, subst );
+        } else if ( auto sue = dynamic_cast< const ast::StructInstType * >( type ) ) {
+                if ( hasPolyParams( sue->params, subst ) ) return type;
+        } else if ( auto sue = dynamic_cast< const ast::UnionInstType * >( type ) ) {
+                if ( hasPolyParams( sue->params, subst ) ) return type;
+        }
+        return nullptr;
+}
+
         ReferenceToType *isDynType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
                 type = replaceTypeInst( type, env );
@@ -211 +221 @@
         }
 
-        const ast::BaseInstType *isDynType( const ast::Type *type, const TyVarMap &tyVars, const ast::TypeSubstitution *typeSubs ) {
-                type = replaceTypeInst( type, typeSubs );
-
-                if ( auto inst = dynamic_cast<ast::TypeInstType const *>( type ) ) {
-                        auto var = tyVars.find( inst->name );
-                        if ( var != tyVars.end() && var->second.isComplete ) {
-                                return inst;
-                        }
-                } else if ( auto inst = dynamic_cast<ast::StructInstType const *>( type ) ) {
-                        if ( hasDynParams( inst->params, tyVars, typeSubs ) ) {
-                                return inst;
-                        }
-                } else if ( auto inst = dynamic_cast<ast::UnionInstType const *>( type ) ) {
-                        if ( hasDynParams( inst->params, tyVars, typeSubs ) ) {
-                                return inst;
-                        }
-                }
-                return nullptr;
-        }
+const ast::BaseInstType * isDynType(
+                const ast::Type * type, const TypeVarMap & typeVars,
+                const ast::TypeSubstitution * subst ) {
+        type = replaceTypeInst( type, subst );
+
+        if ( auto inst = dynamic_cast<ast::TypeInstType const *>( type ) ) {
+                auto var = typeVars.find( inst->name );
+                if ( var != typeVars.end() && var->second.isComplete ) {
+
+                }
+        } else if ( auto inst = dynamic_cast<ast::StructInstType const *>( type ) ) {
+                if ( hasDynParams( inst->params, typeVars, subst ) ) {
+                        return inst;
+                }
+        } else if ( auto inst = dynamic_cast<ast::UnionInstType const *>( type ) ) {
+                if ( hasDynParams( inst->params, typeVars, subst ) ) {
+                        return inst;
+                }
+        }
+        return nullptr;
+}
 
         ReferenceToType *isDynRet( FunctionType *function, const TyVarMap &forallTypes ) {
@@ -236 +248 @@
                 return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes );
         }
+
+const ast::BaseInstType *isDynRet(
+                const ast::FunctionType * type, const TypeVarMap & typeVars ) {
+        if ( type->returns.empty() ) return nullptr;
+
+        return isDynType( type->returns.front(), typeVars );
+}
 
         ReferenceToType *isDynRet( FunctionType *function ) {
@@ -260 +279 @@
         }
 
+bool needsAdapter(
+                ast::FunctionType const * adaptee, const TypeVarMap & typeVars ) {
+        if ( isDynRet( adaptee, typeVars ) ) return true;
+
+        for ( auto param : adaptee->params ) {
+                if ( isDynType( param, typeVars ) ) {
+                        return true;
+                }
+        }
+        return false;
+}
+
         Type *isPolyPtr( Type *type, const TypeSubstitution *env ) {
                 type = replaceTypeInst( type, env );
@@ -311 +342 @@
                 return isPolyType( type, tyVars, env );
         }
+
+ast::Type const * hasPolyBase(
+                ast::Type const * type, const TypeVarMap & typeVars,
+                int * levels, const ast::TypeSubstitution * subst ) {
+        int level_count = 0;
+
+        while ( true ) {
+                type = replaceTypeInst( type, subst );
+
+                if ( auto ptr = dynamic_cast<ast::PointerType const *>( type ) ) {
+                        type = ptr->base;
+                        ++level_count;
+                } else {
+                        break;
+                }
+        }
+
+        if ( nullptr != levels ) { *levels = level_count; }
+        return isPolyType( type, typeVars, subst );
+}
 
         bool includesPolyType( Type *type, const TypeSubstitution *env ) {
@@ -685 +736 @@
 }
 
-        namespace {
-                // temporary hack to avoid re-implementing anything related to TyVarMap
-                // does this work? these two structs have identical definitions.
-                inline TypeDecl::Data convData(const ast::TypeDecl::Data & data) {
-                        return *reinterpret_cast<const TypeDecl::Data *>(&data);
-                }
-        }
-
         bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env ) {
                 // is parameter is not polymorphic, don't need to box
@@ -703 +746 @@
         }
 
-        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const TyVarMap &exprTyVars, const ast::TypeSubstitution * env) {
-                // is parameter is not polymorphic, don't need to box
-                if ( ! isPolyType( param, exprTyVars ) ) return false;
-                ast::ptr<ast::Type> newType = arg;
-                if ( env ) env->apply( newType );
-                // if the argument's type is polymorphic, we don't need to box again!
-                return ! isPolyType( newType );
-        }
+bool needsBoxing( const ast::Type * param, const ast::Type * arg,
+                const TypeVarMap & typeVars, const ast::TypeSubstitution * subst ) {
+        // Don't need to box if the parameter is not polymorphic.
+        if ( !isPolyType( param, typeVars ) ) return false;
+
+        ast::ptr<ast::Type> newType = arg;
+        if ( subst ) {
+                int count = subst->apply( newType );
+                (void)count;
+        }
+        // Only need to box if the argument is not also polymorphic.
+        return !isPolyType( newType );
+}
 
         bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env ) {
@@ -720 +768 @@
         }
 
-        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const ast::ApplicationExpr * appExpr, const ast::TypeSubstitution * env) {
-                const ast::FunctionType * function = getFunctionType(appExpr->func->result);
-                assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->func->result ).c_str() );
-                TyVarMap exprTyVars(TypeDecl::Data{});
-                makeTyVarMap(function, exprTyVars);
-                return needsBoxing(param, arg, exprTyVars, env);
-
-        }
+bool needsBoxing(
+                const ast::Type * param, const ast::Type * arg,
+                const ast::ApplicationExpr * expr,
+                const ast::TypeSubstitution * subst ) {
+        const ast::FunctionType * function = getFunctionType( expr->func->result );
+        assertf( function, "ApplicationExpr has non-function type: %s", toString( expr->func->result ).c_str() );
+        TypeVarMap exprTyVars = { ast::TypeDecl::Data() };
+        makeTypeVarMap( function, exprTyVars );
+        return needsBoxing( param, arg, exprTyVars, subst );
+}
 
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
@@ -733 +783 @@
         }
 
-        void addToTyVarMap( const ast::TypeInstType * tyVar, TyVarMap & tyVarMap) {
-                tyVarMap.insert(tyVar->typeString(), convData(ast::TypeDecl::Data{tyVar->base}));
-        }
+void addToTypeVarMap( const ast::TypeInstType * type, TypeVarMap & typeVars ) {
+        typeVars.insert( type->typeString(), ast::TypeDecl::Data( type->base ) );
+}
 
         void makeTyVarMap( Type *type, TyVarMap &tyVarMap ) {
@@ -747 +797 @@
         }
 
-        void makeTyVarMap(const ast::Type * type, TyVarMap & tyVarMap) {
-                if (auto ptype = dynamic_cast<const ast::FunctionType *>(type)) {
-                        for (auto & tyVar : ptype->forall) {
-                                assert (tyVar);
-                                addToTyVarMap(tyVar, tyVarMap);
-                        }
-                }
-                if (auto pointer = dynamic_cast<const ast::PointerType *>(type)) {
-                        makeTyVarMap(pointer->base, tyVarMap);
-                }
-        }
+void makeTypeVarMap( const ast::Type * type, TypeVarMap & typeVars ) {
+        if ( auto func = dynamic_cast<ast::FunctionType const *>( type ) ) {
+                for ( auto & typeVar : func->forall ) {
+                        assert( typeVar );
+                        addToTypeVarMap( typeVar, typeVars );
+                }
+        }
+        if ( auto pointer = dynamic_cast<ast::PointerType const *>( type ) ) {
+                makeTypeVarMap( pointer->base, typeVars );
+        }
+}
 
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap ) {
@@ -766 +816 @@
         }
 
+void printTypeVarMap( std::ostream &os, const TypeVarMap & typeVars ) {
+        for ( auto const & pair : typeVars ) {
+                os << pair.first << " (" << pair.second << ") ";
+        } // for
+        os << std::endl;
+}
+
 } // namespace GenPoly
 

src/GenPoly/GenPoly.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Aug 19 16:03:00 2022
-// Update Count     : 8
+// Last Modified On : Fri Oct  7 15:06:00 2022
+// Update Count     : 9
 //
 
@@ -20 +20 @@
 
 #include "ErasableScopedMap.h"    // for ErasableScopedMap
-#include "AST/Fwd.hpp"
+#include "AST/Decl.hpp"           // for TypeDecl::Data
+#include "AST/Fwd.hpp"            // for ApplicationExpr, BaseInstType, Func...
 #include "SymTab/Mangler.h"       // for Mangler
 #include "SynTree/Declaration.h"  // for TypeDecl::Data, AggregateDecl, Type...
@@ -29 +30 @@
         // TODO Via some tricks this works for ast::TypeDecl::Data as well.
         typedef ErasableScopedMap< std::string, TypeDecl::Data > TyVarMap;
+        using TypeVarMap = ErasableScopedMap< std::string, ast::TypeDecl::Data >;
 
         /// Replaces a TypeInstType by its referrent in the environment, if applicable
@@ -39 +41 @@
         /// returns polymorphic type if is polymorphic type in tyVars, NULL otherwise; will look up substitution in env if provided
         Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
-        const ast::Type * isPolyType(const ast::Type * type, const TyVarMap & tyVars, const ast::TypeSubstitution * env = nullptr);
+        const ast::Type * isPolyType( const ast::Type * type, const TypeVarMap & typeVars, const ast::TypeSubstitution * subst = nullptr );
 
         /// returns dynamic-layout type if is dynamic-layout type in tyVars, NULL otherwise; will look up substitution in env if provided
         ReferenceToType *isDynType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
-        const ast::BaseInstType *isDynType( const ast::Type *type, const TyVarMap &tyVars, const ast::TypeSubstitution *typeSubs = 0 );
+        const ast::BaseInstType *isDynType( const ast::Type * type, const TypeVarMap & typeVars, const ast::TypeSubstitution * subst = 0 );
 
         /// true iff function has dynamic-layout return type under the given type variable map
         ReferenceToType *isDynRet( FunctionType *function, const TyVarMap &tyVars );
+        const ast::BaseInstType *isDynRet( const ast::FunctionType * type, const TypeVarMap & typeVars );
 
         /// true iff function has dynamic-layout return type under the type variable map generated from its forall-parameters
@@ -53 +56 @@
         /// A function needs an adapter if it returns a dynamic-layout value or if any of its parameters have dynamic-layout type
         bool needsAdapter( FunctionType *adaptee, const TyVarMap &tyVarr );
+        bool needsAdapter( ast::FunctionType const * adaptee, const TypeVarMap & typeVars );
 
         /// returns polymorphic type if is pointer to polymorphic type, NULL otherwise; will look up substitution in env if provided
@@ -59 +63 @@
         /// returns polymorphic type if is pointer to polymorphic type in tyVars, NULL otherwise; will look up substitution in env if provided
         Type *isPolyPtr( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
+        const ast::Type * isPolyPtr( const ast::Type * type, const TypeVarMap & typeVars, const ast::TypeSubstitution * env = 0 );
 
         /// if the base type (after dereferencing N >= 0 pointers) is a polymorphic type, returns the base type, NULL otherwise;
@@ -67 +72 @@
         /// N will be stored in levels, if provided, will look up substitution in env if provided
         Type *hasPolyBase( Type *type, const TyVarMap &tyVars, int *levels = 0, const TypeSubstitution *env = 0 );
+        const ast::Type * hasPolyBase( const ast::Type * type, const TypeVarMap & typeVars, int * levels = 0, const ast::TypeSubstitution * env = 0 );
 
         /// true iff this type or some base of this type after dereferencing pointers is either polymorphic or a generic type with at least one
@@ -90 +96 @@
         /// true if arg requires boxing given exprTyVars
         bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env );
-        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const TyVarMap &exprTyVars, const ast::TypeSubstitution * env);
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const TypeVarMap & typeVars, const ast::TypeSubstitution * subst );
 
         /// true if arg requires boxing in the call to appExpr
         bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env );
-        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const ast::ApplicationExpr * appExpr, const ast::TypeSubstitution * env);
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const ast::ApplicationExpr * expr, const ast::TypeSubstitution * subst );
 
         /// Adds the type variable `tyVar` to `tyVarMap`
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap );
+        void addToTypeVarMap( const ast::TypeDecl * 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 makeTyVarMap(const ast::Type * type, TyVarMap & tyVarMap);
+        void makeTypeVarMap( const ast::Type * type, TypeVarMap & typeVars );
 
         /// Prints type variable map
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap );
+        void printTypeVarMap( std::ostream &os, const TypeVarMap & typeVars );
 
         /// Gets the mangled name of this type; alias for SymTab::Mangler::mangleType().

src/GenPoly/Lvalue.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:21:59 2017
-// Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Sep 15 14:13:00 2022
+// Update Count     : 3
 //
 
@@ -20 +20 @@
 class Declaration;
 class Expression;
+namespace ast {
+        class Expr;
+        class TranslationUnit;
+}
 
 namespace GenPoly {
         /// replaces return type of `lvalue T` with `T*`, along with appropriate address-of and dereference operators
         void convertLvalue( std::list< Declaration* >& translationUnit );
+        void convertLvalue( ast::TranslationUnit & translationUnit );
 
         /// true after reference types have been eliminated from the source code. After this point, reference types should not be added to the AST.
@@ -30 +35 @@
         /// applies transformations that allow GCC to accept more complicated lvalue expressions, e.g. &(a, b)
         Expression * generalizedLvalue( Expression * expr );
+        ast::Expr const * generalizedLvalue( ast::Expr const * expr );
 } // 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 Aug 19 16:10:00 2022
-// Update Count     : 4
+// Last Modified On : Fri Oct  7 15:42:00 2022
+// Update Count     : 5
 //
 
@@ -128 +128 @@
         public ast::WithVisitorRef<ScrubTypeVars> {
 
-        ScrubTypeVars( ScrubMode m, TyVarMap const * tv ) :
+        ScrubTypeVars( ScrubMode m, TypeVarMap const * tv ) :
                         mode ( m ), typeVars( tv ) {}
 
@@ -148 +148 @@
         ScrubMode const mode;
         /// Type varriables to scrub.
-        TyVarMap const * const typeVars;
+        TypeVarMap const * const typeVars;
         /// Value cached by primeBaseScrub.
         ast::Type const * dynType = nullptr;
@@ -255 +255 @@
 const ast::Node * scrubTypeVarsBase(
                 const ast::Node * target,
-                ScrubMode mode, const TyVarMap * typeVars ) {
+                ScrubMode mode, const TypeVarMap * typeVars ) {
         if ( ScrubMode::All == mode ) {
                 assert( nullptr == typeVars );
@@ -266 +266 @@
 
 } // 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<>

src/GenPoly/ScrubTyVars.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Aug 19 14:14:00 2022
-// Update Count     : 3
+// Last Modified On : Fri Oct  7 15:51:00 2022
+// Update Count     : 4
 //
 
@@ -109 +109 @@
         }
 
+/// For all polymorphic types with type variables in `typeVars`,
+/// replaces generic types, dtypes, and ftypes with the appropriate void type,
+/// and sizeof/alignof expressions with the proper variable.
+template<typename node_t>
+node_t const * scrubTypeVars(
+                node_t const * target, const TypeVarMap & typeVars ) {
+        return strict_dynamic_cast<node_t const *>(
+                        scrubTypeVars<ast::Node>( target ) );
+}
+
+/// For all dynamic-layout types with type variables in `typeVars`,
+/// replaces generic types, dtypes, and ftypes with the appropriate void type,
+/// and sizeof/alignof expressions with the proper variable.
+template<typename node_t>
+ast::Node const * scrubTypeVarsDynamic(
+                node_t const * target, const TypeVarMap & typeVars ) {
+        return strict_dynamic_cast<node_t const *>(
+                        scrubTypeVarsDynamic<ast::Node>( target, typeVars ) );
+}
+
 /// For all polymorphic types, replaces generic types, with the appropriate
 /// void type, and sizeof/alignof expressions with the proper variable.
 template<typename node_t>
 node_t const * scrubAllTypeVars( node_t const * target ) {
-        return strict_dynamic_cast<node_t const *>( scrubAllTypeVars<ast::Node>( target ) );
+        return strict_dynamic_cast<node_t const *>(
+                        scrubAllTypeVars<ast::Node>( target ) );
 }
+
+// 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<>

src/GenPoly/module.mk

@@ -30 +30 @@
         GenPoly/InstantiateGeneric.cc \
         GenPoly/InstantiateGeneric.h \
+        GenPoly/LvalueNew.cpp \
         GenPoly/Lvalue.cc \
         GenPoly/ScopedSet.h \