Changeset c6b4432 for src/GenPoly

Timestamp:

Nov 8, 2023, 2:01:11 PM (23 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

3e4bf0d, f5ec35a

Parents:

790d835

Message:

Remove BaseSyntaxNode and clean-up.

Location:

src/GenPoly

Files:

• Box.cc (deleted)
• FindFunction.cc (modified) (4 diffs)
• FindFunction.h (modified) (1 diff)
• GenPoly.cc (modified) (23 diffs)
• GenPoly.h (modified) (4 diffs)
• InstantiateGeneric.cc (deleted)
• Lvalue.cc (deleted)
• ScrubTyVars.cc (modified) (1 diff)
• ScrubTyVars.h (modified) (1 diff)
• Specialize.cc (deleted)
• SpecializeNew.cpp (modified) (1 diff)
• module.mk (modified) (2 diffs)

src/GenPoly/FindFunction.cc

@@ -20 +20 @@
 #include "AST/Pass.hpp"                 // for Pass
 #include "AST/Type.hpp"
-#include "Common/PassVisitor.h"         // for PassVisitor
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::iterator
 #include "GenPoly/GenPoly.h"            // for TyVarMap
 #include "ScrubTyVars.h"                // for ScrubTyVars
-#include "SynTree/Declaration.h"        // for DeclarationWithType, TypeDecl
-#include "SynTree/Mutator.h"            // for Mutator, mutateAll
-#include "SynTree/Type.h"               // for FunctionType, Type, Type::For...
 
 namespace GenPoly {
-        class FindFunction : public WithGuards, public WithVisitorRef<FindFunction>, public WithShortCircuiting {
-          public:
-                FindFunction( std::list< FunctionType const* > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate );
-
-                void premutate( FunctionType * functionType );
-                Type * postmutate( FunctionType * functionType );
-                void premutate( PointerType * pointerType );
-          private:
-                void handleForall( const Type::ForallList &forall );
-
-                std::list< FunctionType const * > & functions;
-                TyVarMap tyVars;
-                bool replaceMode;
-                FindFunctionPredicate predicate;
-        };
-
-        void findFunction( Type *type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
-                PassVisitor<FindFunction> finder( functions, tyVars, false, predicate );
-                type->acceptMutator( finder );
-        }
-
-        void findAndReplaceFunction( Type *&type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
-                PassVisitor<FindFunction> finder( functions, tyVars, true, predicate );
-                type = type->acceptMutator( finder );
-        }
-
-        FindFunction::FindFunction( std::list< FunctionType const * > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate )
-                : functions( functions ), tyVars( tyVars ), replaceMode( replaceMode ), predicate( predicate ) {
-        }
-
-        void FindFunction::handleForall( const Type::ForallList &forall ) {
-                for ( const Declaration * td : forall ) {
-                        TyVarMap::iterator var = tyVars.find( td->name );
-                        if ( var != tyVars.end() ) {
-                                tyVars.erase( var->first );
-                        } // if
-                } // for
-        }
-
-        void FindFunction::premutate( FunctionType * functionType ) {
-                visit_children = false;
-                GuardScope( tyVars );
-                handleForall( functionType->get_forall() );
-                mutateAll( functionType->get_returnVals(), *visitor );
-        }
-
-        Type * FindFunction::postmutate( FunctionType * functionType ) {
-                Type *ret = functionType;
-                if ( predicate( functionType, tyVars ) ) {
-                        functions.push_back( functionType );
-                        if ( replaceMode ) {
-                                // replace type parameters in function type with void*
-                                ret = ScrubTyVars::scrub( functionType->clone(), tyVars );
-                        } // if
-                } // if
-                return ret;
-        }
-
-        void FindFunction::premutate( PointerType * pointerType ) {
-                GuardScope( tyVars );
-                handleForall( pointerType->get_forall() );
-        }
 
 namespace {
@@ -154 +88 @@
 void FindFunctionCore::previsit( ast::PointerType const * /*type*/ ) {
         GuardScope( typeVars );
-        //handleForall( type->forall );
 }
 
@@ -164 +97 @@
         ast::Pass<FindFunctionCore> pass( functions, typeVars, predicate, false );
         type->accept( pass );
-        //(void)type;
-        //(void)functions;
-        //(void)typeVars;
-        //(void)predicate;
 }
 
@@ -175 +104 @@
         ast::Pass<FindFunctionCore> pass( functions, typeVars, predicate, true );
         return type->accept( pass );
-        //(void)functions;
-        //(void)typeVars;
-        //(void)predicate;
-        //return type;
 }
 

src/GenPoly/FindFunction.h

@@ -16 +16 @@
 #pragma once
 
-#include <list>       // for list
-
 #include "GenPoly.h"  // for TyVarMap
 
-class FunctionType;
-class Type;
-
 namespace GenPoly {
-        typedef bool (*FindFunctionPredicate)( FunctionType*, const TyVarMap& );
-
-        /// recursively walk `type`, placing all functions that match `predicate` under `tyVars` into `functions`
-        void findFunction( Type *type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate );
-        /// 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 & );

src/GenPoly/GenPoly.cc

@@ -29 +29 @@
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::const_it...
 #include "ResolvExpr/typeops.h"         // for flatten
-#include "SynTree/Constant.h"           // for Constant
-#include "SynTree/Expression.h"         // for Expression, TypeExpr, Constan...
-#include "SynTree/Type.h"               // for Type, StructInstType, UnionIn...
-#include "SynTree/TypeSubstitution.h"   // for TypeSubstitution
 
 using namespace std;
@@ -39 +35 @@
         namespace {
                 /// Checks a parameter list for polymorphic parameters; will substitute according to env if present
-                bool hasPolyParams( std::list< Expression* >& params, const TypeSubstitution *env ) {
-                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assertf(paramType, "Aggregate parameters should be type expressions");
-                                if ( isPolyType( paramType->get_type(), env ) ) return true;
-                        }
-                        return false;
-                }
-
                 bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const ast::TypeSubstitution * env ) {
                         for ( auto &param : params ) {
@@ -58 +45 @@
 
                 /// Checks a parameter list for polymorphic parameters from tyVars; will substitute according to env if present
-                bool hasPolyParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
-                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assertf(paramType, "Aggregate parameters should be type expressions");
-                                if ( isPolyType( paramType->get_type(), tyVars, env ) ) return true;
-                        }
-                        return false;
-                }
-
                 bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const TypeVarMap & typeVars, const ast::TypeSubstitution * env ) {
                         for ( auto & param : params ) {
@@ -77 +55 @@
 
                 /// 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 ) {
-                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assertf(paramType, "Aggregate parameters should be type expressions");
-                                if ( isDynType( paramType->get_type(), tyVars, env ) ) return true;
-                        }
-                        return false;
-                }
-
                 bool hasDynParams(
                                 const std::vector<ast::ptr<ast::Expr>> & params,
@@ -99 +68 @@
                         return false;
                 }
-
-                /// Checks a parameter list for inclusion of polymorphic parameters; will substitute according to env if present
-                bool includesPolyParams( std::list< Expression* >& params, const TypeSubstitution *env ) {
-                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assertf(paramType, "Aggregate parameters should be type expressions");
-                                if ( includesPolyType( paramType->get_type(), env ) ) return true;
-                        }
-                        return false;
-                }
-
-                /// Checks a parameter list for inclusion of polymorphic parameters from tyVars; will substitute according to env if present
-                bool includesPolyParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
-                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assertf(paramType, "Aggregate parameters should be type expressions");
-                                if ( includesPolyType( paramType->get_type(), tyVars, env ) ) return true;
-                        }
-                        return false;
-                }
-        }
-
-        Type* replaceTypeInst( Type* type, const TypeSubstitution* env ) {
-                if ( ! env ) return type;
-                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
-                        Type *newType = env->lookup( typeInst->get_name() );
-                        if ( newType ) return newType;
-                }
-                return type;
-        }
-
-        const Type* replaceTypeInst( const Type* type, const TypeSubstitution* env ) {
-                if ( ! env ) return type;
-                if ( auto typeInst = dynamic_cast< const TypeInstType* >( type ) ) {
-                        Type *newType = env->lookup( typeInst->get_name() );
-                        if ( newType ) return newType;
-                }
-                return type;
         }
 
@@ -146 +77 @@
                 }
                 return type;
-        }
-
-        Type *isPolyType( Type *type, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-
-                if ( dynamic_cast< TypeInstType * >( type ) ) {
-                        return type;
-                } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
-                        return isPolyType( arrayType->base, env );
-                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
-                        if ( hasPolyParams( structType->get_parameters(), env ) ) return type;
-                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
-                        if ( hasPolyParams( unionType->get_parameters(), env ) ) return type;
-                }
-                return 0;
         }
 
@@ -178 +94 @@
         }
 
-        Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-
-                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
-                        if ( tyVars.contains( typeInst->get_name() ) ) {
-                                return type;
-                        }
-                } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
-                        return isPolyType( arrayType->base, tyVars, env );
-                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
-                        if ( hasPolyParams( structType->get_parameters(), tyVars, env ) ) return type;
-                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
-                        if ( hasPolyParams( unionType->get_parameters(), tyVars, env ) ) return type;
-                }
-                return 0;
-        }
-
 const ast::Type * isPolyType( const ast::Type * type,
                 const TypeVarMap & typeVars, const ast::TypeSubstitution * subst ) {
@@ -211 +110 @@
 }
 
-        ReferenceToType *isDynType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-
-                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
-                        auto var = tyVars.find( typeInst->get_name() );
-                        if ( var != tyVars.end() && var->second.isComplete ) {
-                                return typeInst;
-                        }
-                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
-                        if ( hasDynParams( structType->get_parameters(), tyVars, env ) ) return structType;
-                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
-                        if ( hasDynParams( unionType->get_parameters(), tyVars, env ) ) return unionType;
-                }
-                return 0;
-        }
-
 const ast::BaseInstType * isDynType(
                 const ast::Type * type, const TypeVarMap & typeVars,
@@ -249 +132 @@
 }
 
-        ReferenceToType *isDynRet( FunctionType *function, const TyVarMap &forallTypes ) {
-                if ( function->get_returnVals().empty() ) return 0;
-
-                return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes );
-        }
-
 const ast::BaseInstType *isDynRet(
                 const ast::FunctionType * type, const TypeVarMap & typeVars ) {
@@ -262 +139 @@
 }
 
-        ReferenceToType *isDynRet( FunctionType *function ) {
-                if ( function->get_returnVals().empty() ) return 0;
-
-                TyVarMap forallTypes( TypeDecl::Data{} );
-                makeTyVarMap( function, forallTypes );
-                return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes );
-        }
-
 const ast::BaseInstType *isDynRet( const ast::FunctionType * func ) {
         if ( func->returns.empty() ) return nullptr;
@@ -278 +147 @@
 }
 
-        bool needsAdapter( FunctionType *adaptee, const TyVarMap &tyVars ) {
-//              if ( ! adaptee->get_returnVals().empty() && isPolyType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
-//                      return true;
-//              } // if
-                if ( isDynRet( adaptee, tyVars ) ) return true;
-
-                for ( std::list< DeclarationWithType* >::const_iterator innerArg = adaptee->get_parameters().begin(); innerArg != adaptee->get_parameters().end(); ++innerArg ) {
-//                      if ( isPolyType( (*innerArg)->get_type(), tyVars ) ) {
-                        if ( isDynType( (*innerArg)->get_type(), tyVars ) ) {
-                                return true;
-                        } // if
-                } // for
-                return false;
-        }
-
 bool needsAdapter(
                 ast::FunctionType const * adaptee, const TypeVarMap & typeVars ) {
@@ -304 +158 @@
         return false;
 }
-
-        Type *isPolyPtr( Type *type, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-
-                if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
-                        return isPolyType( ptr->get_base(), env );
-                }
-                return 0;
-        }
-
-        Type *isPolyPtr( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-
-                if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
-                        return isPolyType( ptr->get_base(), tyVars, env );
-                }
-                return 0;
-        }
 
 const ast::Type * isPolyPtr(
@@ -333 +169 @@
         return nullptr;
 }
-
-        Type * hasPolyBase( Type *type, int *levels, const TypeSubstitution *env ) {
-                int dummy;
-                if ( ! levels ) { levels = &dummy; }
-                *levels = 0;
-
-                while ( true ) {
-                        type = replaceTypeInst( type, env );
-
-                        if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
-                                type = ptr->get_base();
-                                ++(*levels);
-                        } else break;
-                }
-
-                return isPolyType( type, env );
-        }
-
-        Type * hasPolyBase( Type *type, const TyVarMap &tyVars, int *levels, const TypeSubstitution *env ) {
-                int dummy;
-                if ( ! levels ) { levels = &dummy; }
-                *levels = 0;
-
-                while ( true ) {
-                        type = replaceTypeInst( type, env );
-
-                        if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
-                                type = ptr->get_base();
-                                ++(*levels);
-                        } else break;
-                }
-
-                return isPolyType( type, tyVars, env );
-        }
 
 ast::Type const * hasPolyBase(
@@ -388 +190 @@
 }
 
-        bool includesPolyType( Type *type, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-
-                if ( dynamic_cast< TypeInstType * >( type ) ) {
-                        return true;
-                } else if ( PointerType *pointerType = dynamic_cast< PointerType* >( type ) ) {
-                        if ( includesPolyType( pointerType->get_base(), env ) ) return true;
-                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
-                        if ( includesPolyParams( structType->get_parameters(), env ) ) return true;
-                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
-                        if ( includesPolyParams( unionType->get_parameters(), env ) ) return true;
-                }
-                return false;
-        }
-
-        bool includesPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-
-                if ( TypeInstType *typeInstType = dynamic_cast< TypeInstType * >( type ) ) {
-                        if ( tyVars.contains( typeInstType->get_name() ) ) {
-                                return true;
-                        }
-                } else if ( PointerType *pointerType = dynamic_cast< PointerType* >( type ) ) {
-                        if ( includesPolyType( pointerType->get_base(), tyVars, env ) ) return true;
-                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
-                        if ( includesPolyParams( structType->get_parameters(), tyVars, env ) ) return true;
-                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
-                        if ( includesPolyParams( unionType->get_parameters(), tyVars, env ) ) return true;
-                }
-                return false;
-        }
-
-        FunctionType * getFunctionType( Type *ty ) {
-                PointerType *ptrType;
-                if ( ( ptrType = dynamic_cast< PointerType* >( ty ) ) ) {
-                        return dynamic_cast< FunctionType* >( ptrType->get_base() ); // pointer if FunctionType, NULL otherwise
-                } else {
-                        return dynamic_cast< FunctionType* >( ty ); // pointer if FunctionType, NULL otherwise
-                }
-        }
-
         const ast::FunctionType * getFunctionType( const ast::Type * ty ) {
                 if ( auto pty = dynamic_cast< const ast::PointerType * >( ty ) ) {
@@ -437 +198 @@
         }
 
-        VariableExpr * getBaseVar( Expression *expr, int *levels ) {
-                int dummy;
-                if ( ! levels ) { levels = &dummy; }
-                *levels = 0;
-
-                while ( true ) {
-                        if ( VariableExpr *varExpr = dynamic_cast< VariableExpr* >( expr ) ) {
-                                return varExpr;
-                        } else if ( MemberExpr *memberExpr = dynamic_cast< MemberExpr* >( expr ) ) {
-                                expr = memberExpr->get_aggregate();
-                        } else if ( AddressExpr *addressExpr = dynamic_cast< AddressExpr* >( expr ) ) {
-                                expr = addressExpr->get_arg();
-                        } else if ( UntypedExpr *untypedExpr = dynamic_cast< UntypedExpr* >( expr ) ) {
-                                // look for compiler-inserted dereference operator
-                                NameExpr *fn = dynamic_cast< NameExpr* >( untypedExpr->get_function() );
-                                if ( ! fn || fn->get_name() != std::string("*?") ) return 0;
-                                expr = *untypedExpr->begin_args();
-                        } else if ( CommaExpr *commaExpr = dynamic_cast< CommaExpr* >( expr ) ) {
-                                // copy constructors insert comma exprs, look at second argument which contains the variable
-                                expr = commaExpr->get_arg2();
-                                continue;
-                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( expr ) ) {
-                                int lvl1;
-                                int lvl2;
-                                VariableExpr * var1 = getBaseVar( condExpr->get_arg2(), &lvl1 );
-                                VariableExpr * var2 = getBaseVar( condExpr->get_arg3(), &lvl2 );
-                                if ( lvl1 == lvl2 && var1 && var2 && var1->get_var() == var2->get_var() ) {
-                                        *levels = lvl1;
-                                        return var1;
-                                }
-                                break;
-                        } else break;
-
-                        ++(*levels);
-                }
-
-                return 0;
-        }
-
         namespace {
                 /// Checks if is a pointer to D
@@ -488 +210 @@
                 inline D const * as( B const * p ) {
                         return reinterpret_cast<D const *>( p );
-                }
-
-                /// Flattens a declaration list
-                template<typename Output>
-                void flattenList( list< DeclarationWithType* > src, Output out ) {
-                        for ( DeclarationWithType* decl : src ) {
-                                ResolvExpr::flatten( decl->get_type(), out );
-                        }
-                }
-
-                /// Flattens a list of types
-                template<typename Output>
-                void flattenList( list< Type* > src, Output out ) {
-                        for ( Type* ty : src ) {
-                                ResolvExpr::flatten( ty, out );
-                        }
                 }
 
@@ -515 +221 @@
                 }
 
-                /// Checks if two lists of parameters are equal up to polymorphic substitution.
-                bool paramListsPolyCompatible( const list< Expression* >& aparams, const list< Expression* >& bparams ) {
-                        if ( aparams.size() != bparams.size() ) return false;
-
-                        for ( list< Expression* >::const_iterator at = aparams.begin(), bt = bparams.begin();
-                                        at != aparams.end(); ++at, ++bt ) {
-                                TypeExpr *aparam = dynamic_cast< TypeExpr* >(*at);
-                                assertf(aparam, "Aggregate parameters should be type expressions");
-                                TypeExpr *bparam = dynamic_cast< TypeExpr* >(*bt);
-                                assertf(bparam, "Aggregate parameters should be type expressions");
-
-                                // xxx - might need to let VoidType be a wildcard here too; could have some voids
-                                // stuffed in for dtype-statics.
-                                // if ( is<VoidType>( aparam->get_type() ) || is<VoidType>( bparam->get_type() ) ) continue;
-                                if ( ! typesPolyCompatible( aparam->get_type(), bparam->get_type() ) ) return false;
-                        }
-
-                        return true;
-                }
-
                 bool paramListsPolyCompatible(
                                 std::vector<ast::ptr<ast::Expr>> const & lparams,
@@ -559 +245 @@
                         return true;
                 }
-        }
-
-        bool typesPolyCompatible( Type *a, Type *b ) {
-                type_index aid{ typeid(*a) };
-                // polymorphic types always match
-                if ( aid == type_index{typeid(TypeInstType)} ) return true;
-
-                type_index bid{ typeid(*b) };
-                // polymorphic types always match
-                if ( bid == type_index{typeid(TypeInstType)} ) return true;
-
-                // can't match otherwise if different types
-                if ( aid != bid ) return false;
-
-                // recurse through type structure (conditions borrowed from Unify.cc)
-                if ( aid == type_index{typeid(BasicType)} ) {
-                        return as<BasicType>(a)->get_kind() == as<BasicType>(b)->get_kind();
-                } else if ( aid == type_index{typeid(PointerType)} ) {
-                        PointerType *ap = as<PointerType>(a), *bp = as<PointerType>(b);
-
-                        // void pointers should match any other pointer type
-                        return is<VoidType>( ap->get_base() ) || is<VoidType>( bp->get_base() )
-                                || typesPolyCompatible( ap->get_base(), bp->get_base() );
-                } else if ( aid == type_index{typeid(ReferenceType)} ) {
-                        ReferenceType *ap = as<ReferenceType>(a), *bp = as<ReferenceType>(b);
-                        return is<VoidType>( ap->get_base() ) || is<VoidType>( bp->get_base() )
-                                || typesPolyCompatible( ap->get_base(), bp->get_base() );
-                } else if ( aid == type_index{typeid(ArrayType)} ) {
-                        ArrayType *aa = as<ArrayType>(a), *ba = as<ArrayType>(b);
-
-                        if ( aa->get_isVarLen() ) {
-                                if ( ! ba->get_isVarLen() ) return false;
-                        } else {
-                                if ( ba->get_isVarLen() ) return false;
-
-                                ConstantExpr *ad = dynamic_cast<ConstantExpr*>( aa->get_dimension() );
-                                ConstantExpr *bd = dynamic_cast<ConstantExpr*>( ba->get_dimension() );
-                                if ( ad && bd
-                                                && ad->get_constant()->get_value() != bd->get_constant()->get_value() )
-                                        return false;
-                        }
-
-                        return typesPolyCompatible( aa->get_base(), ba->get_base() );
-                } else if ( aid == type_index{typeid(FunctionType)} ) {
-                        FunctionType *af = as<FunctionType>(a), *bf = as<FunctionType>(b);
-
-                        vector<Type*> aparams, bparams;
-                        flattenList( af->get_parameters(), back_inserter( aparams ) );
-                        flattenList( bf->get_parameters(), back_inserter( bparams ) );
-                        if ( aparams.size() != bparams.size() ) return false;
-
-                        vector<Type*> areturns, breturns;
-                        flattenList( af->get_returnVals(), back_inserter( areturns ) );
-                        flattenList( bf->get_returnVals(), back_inserter( breturns ) );
-                        if ( areturns.size() != breturns.size() ) return false;
-
-                        for ( unsigned i = 0; i < aparams.size(); ++i ) {
-                                if ( ! typesPolyCompatible( aparams[i], bparams[i] ) ) return false;
-                        }
-                        for ( unsigned i = 0; i < areturns.size(); ++i ) {
-                                if ( ! typesPolyCompatible( areturns[i], breturns[i] ) ) return false;
-                        }
-                        return true;
-                } else if ( aid == type_index{typeid(StructInstType)} ) {
-                        StructInstType *aa = as<StructInstType>(a), *ba = as<StructInstType>(b);
-
-                        if ( aa->get_name() != ba->get_name() ) return false;
-                        return paramListsPolyCompatible( aa->get_parameters(), ba->get_parameters() );
-                } else if ( aid == type_index{typeid(UnionInstType)} ) {
-                        UnionInstType *aa = as<UnionInstType>(a), *ba = as<UnionInstType>(b);
-
-                        if ( aa->get_name() != ba->get_name() ) return false;
-                        return paramListsPolyCompatible( aa->get_parameters(), ba->get_parameters() );
-                } else if ( aid == type_index{typeid(EnumInstType)} ) {
-                        return as<EnumInstType>(a)->get_name() == as<EnumInstType>(b)->get_name();
-                } else if ( aid == type_index{typeid(TraitInstType)} ) {
-                        return as<TraitInstType>(a)->get_name() == as<TraitInstType>(b)->get_name();
-                } else if ( aid == type_index{typeid(TupleType)} ) {
-                        TupleType *at = as<TupleType>(a), *bt = as<TupleType>(b);
-
-                        vector<Type*> atypes, btypes;
-                        flattenList( at->get_types(), back_inserter( atypes ) );
-                        flattenList( bt->get_types(), back_inserter( btypes ) );
-                        if ( atypes.size() != btypes.size() ) return false;
-
-                        for ( unsigned i = 0; i < atypes.size(); ++i ) {
-                                if ( ! typesPolyCompatible( atypes[i], btypes[i] ) ) return false;
-                        }
-                        return true;
-                } else return true; // VoidType, VarArgsType, ZeroType & OneType just need the same type
         }
 
@@ -763 +359 @@
 }
 
-        bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env ) {
-                // is parameter is not polymorphic, don't need to box
-                if ( ! isPolyType( param, exprTyVars ) ) return false;
-                Type * newType = arg->clone();
-                if ( env ) env->apply( newType );
-                std::unique_ptr<Type> manager( 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 ) {
@@ -786 +372 @@
         return !isPolyType( newType );
 }
-
-        bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env ) {
-                FunctionType * function = getFunctionType( appExpr->function->result );
-                assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->function->result ).c_str() );
-                TyVarMap exprTyVars( TypeDecl::Data{} );
-                makeTyVarMap( function, exprTyVars );
-                return needsBoxing( param, arg, exprTyVars, env );
-        }
 
 bool needsBoxing(
@@ -806 +384 @@
 }
 
-        void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
-                tyVarMap.insert( tyVar->name, TypeDecl::Data{ tyVar } );
-        }
-
 void addToTypeVarMap( const ast::TypeDecl * decl, TypeVarMap & typeVars ) {
         typeVars.insert( ast::TypeEnvKey( decl, 0, 0 ), ast::TypeData( decl ) );
@@ -817 +391 @@
         typeVars.insert( ast::TypeEnvKey( *type ), ast::TypeData( type->base ) );
 }
-
-        void makeTyVarMap( Type *type, TyVarMap &tyVarMap ) {
-                for ( Type::ForallList::const_iterator tyVar = type->get_forall().begin(); tyVar != type->get_forall().end(); ++tyVar ) {
-                        assert( *tyVar );
-                        addToTyVarMap( *tyVar, tyVarMap );
-                }
-                if ( PointerType *pointer = dynamic_cast< PointerType* >( type ) ) {
-                        makeTyVarMap( pointer->get_base(), tyVarMap );
-                }
-        }
 
 void makeTypeVarMap( const ast::Type * type, TypeVarMap & typeVars ) {
@@ -846 +410 @@
 }
 
-        void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap ) {
-                for ( TyVarMap::const_iterator i = tyVarMap.begin(); i != tyVarMap.end(); ++i ) {
-                        os << i->first << " (" << i->second << ") ";
-                } // for
-                os << std::endl;
-        }
-
 } // namespace GenPoly
 

src/GenPoly/GenPoly.h

@@ -23 +23 @@
 #include "AST/Fwd.hpp"            // for ApplicationExpr, BaseInstType, Func...
 #include "SymTab/Mangler.h"       // for Mangler
-#include "SynTree/Declaration.h"  // for TypeDecl::Data, AggregateDecl, Type...
-#include "SynTree/SynTree.h"      // for Visitor Nodes
 
 namespace ast {
@@ -32 +30 @@
 namespace GenPoly {
 
-        typedef ErasableScopedMap< std::string, TypeDecl::Data > TyVarMap;
         struct TypeVarMap : public ErasableScopedMap<ast::TypeEnvKey, ast::TypeData> {
                 TypeVarMap() : ErasableScopedMap( ast::TypeData() ) {}
@@ -38 +35 @@
 
         /// Replaces a TypeInstType by its referrent in the environment, if applicable
-        Type* replaceTypeInst( Type* type, const TypeSubstitution* env );
-        const Type* replaceTypeInst( const Type* type, const TypeSubstitution* env );
         const ast::Type * replaceTypeInst( const ast::Type *, const ast::TypeSubstitution * );
 
         /// returns polymorphic type if is polymorphic type, NULL otherwise; will look up substitution in env if provided
-        Type *isPolyType( Type *type, const TypeSubstitution *env = 0 );
         const ast::Type * isPolyType(const ast::Type * type, const ast::TypeSubstitution * env = nullptr);
 
         /// 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 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 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
-        ReferenceToType *isDynRet( FunctionType *function );
         const ast::BaseInstType *isDynRet( const ast::FunctionType * func );
 
         /// 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
-        Type *isPolyPtr( Type *type, const TypeSubstitution *env = 0 );
-
         /// 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;
-        /// N will be stored in levels, if provided, will look up substitution in env if provided
-        Type *hasPolyBase( Type *type, int *levels = 0, const TypeSubstitution *env = 0 );
 
         /// if the base type (after dereferencing N >= 0 pointers) is a polymorphic type in tyVars, returns the base type, NULL otherwise;
         /// 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
-        /// polymorphic parameter; will look up substitution in env if provided.
-        bool includesPolyType( Type *type, const TypeSubstitution *env = 0 );
-
-        /// true iff this type or some base of this type after dereferencing pointers is either polymorphic in tyVars, or a generic type with
-        /// at least one polymorphic parameter in tyVars; will look up substitution in env if provided.
-        bool includesPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
-
         /// Returns a pointer to the base FunctionType if ty is the type of a function (or pointer to one), NULL otherwise
-        FunctionType *getFunctionType( Type *ty );
         const ast::FunctionType * getFunctionType( const ast::Type * ty );
 
-        /// If expr (after dereferencing N >= 0 pointers) is a variable expression, returns the variable expression, NULL otherwise;
-        /// N will be stored in levels, if provided
-        VariableExpr *getBaseVar( Expression *expr, int *levels = 0 );
-
         /// true iff types are structurally identical, where TypeInstType's match any type.
-        bool typesPolyCompatible( Type *aty, Type *bty );
         bool typesPolyCompatible( ast::Type const * lhs, ast::Type const * rhs );
 
         /// 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 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 * 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 );
         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
-        void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap );
-
-        /// Gets the mangled name of this type; alias for SymTab::Mangler::mangleType().
-        inline std::string mangleType( const Type *ty ) { return SymTab::Mangler::mangleType( ty ); }
 
         /// Gets the name of the sizeof parameter for the type, given its mangled name
@@ -136 +92 @@
 
         /// Gets the name of the layout function for a given aggregate type, given its declaration
-        inline std::string layoutofName( AggregateDecl *decl ) { return std::string( "_layoutof_" ) + decl->get_name(); }
         inline std::string layoutofName( ast::AggregateDecl const * decl ) {
                 return std::string( "_layoutof_" ) + decl->name;

src/GenPoly/ScrubTyVars.cc

@@ -21 +21 @@
 #include "ScrubTyVars.h"
 #include "SymTab/Mangler.h"             // for mangleType
-#include "SynTree/Declaration.h"        // for TypeDecl, TypeDecl::Data, Typ...
-#include "SynTree/Expression.h"         // for Expression (ptr only), NameExpr
-#include "SynTree/Mutator.h"            // for Mutator
-#include "SynTree/Type.h"               // for PointerType, TypeInstType, Type
 
 namespace GenPoly {
-        Type * ScrubTyVars::postmutate( TypeInstType * typeInst ) {
-                if ( ! tyVars ) {
-                        if ( typeInst->get_isFtype() ) {
-                                delete typeInst;
-                                return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
-                        } else {
-                                PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
-                                delete typeInst;
-                                return ret;
-                        }
-                }
-
-                TyVarMap::const_iterator tyVar = tyVars->find( typeInst->name );
-                if ( tyVar != tyVars->end() ) {
-                        switch ( tyVar->second.kind ) {
-                          case TypeDecl::Dtype:
-                          case TypeDecl::Ttype:
-                                {
-                                        PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
-                                        delete typeInst;
-                                        return ret;
-                                }
-                          case TypeDecl::Ftype:
-                                delete typeInst;
-                                return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
-                          default:
-                                assertf(false, "Unhandled tyvar kind: %d", tyVar->second.kind);
-                        } // switch
-                } // if
-                return typeInst;
-        }
-
-        Type * ScrubTyVars::mutateAggregateType( Type * ty ) {
-                if ( shouldScrub( ty ) ) {
-                        PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) );
-                        delete ty;
-                        return ret;
-                }
-                return ty;
-        }
-
-        Type * ScrubTyVars::postmutate( StructInstType * structInst ) {
-                return mutateAggregateType( structInst );
-        }
-
-        Type * ScrubTyVars::postmutate( UnionInstType * unionInst ) {
-                return mutateAggregateType( unionInst );
-        }
-
-        void ScrubTyVars::primeBaseScrub( Type * type ) {
-                // need to determine whether type needs to be scrubbed to determine whether
-                // automatic recursion is necessary
-                if ( Type * t = shouldScrub( type ) ) {
-                        visit_children = false;
-                        GuardValue( dynType );
-                        dynType = t;
-                }
-        }
-
-        Expression * ScrubTyVars::postmutate( SizeofExpr * szeof ) {
-                // sizeof( T ) => _sizeof_T parameter, which is the size of T
-                if ( dynType ) {
-                        Expression *expr = new NameExpr( sizeofName( mangleType( dynType ) ) );
-                        return expr;
-                } // if
-                return szeof;
-        }
-
-        Expression * ScrubTyVars::postmutate( AlignofExpr * algnof ) {
-                // alignof( T ) => _alignof_T parameter, which is the alignment of T
-                if ( dynType ) {
-                        Expression *expr = new NameExpr( alignofName( mangleType( dynType ) ) );
-                        return expr;
-                } // if
-                return algnof;
-        }
-
-        Type * ScrubTyVars::postmutate( PointerType * pointer ) {
-                if ( dynType ) {
-                        Type * ret = dynType->acceptMutator( *visitor );
-                        ret->get_qualifiers() |= pointer->get_qualifiers();
-                        pointer->base = nullptr;
-                        delete pointer;
-                        return ret;
-                }
-                return pointer;
-        }
 
 namespace {

src/GenPoly/ScrubTyVars.h

@@ -19 +19 @@
 
 #include "AST/Fwd.hpp"        // for Node
-#include "Common/PassVisitor.h"
 #include "GenPoly.h"          // for TyVarMap, isPolyType, isDynType
-#include "SynTree/Mutator.h"  // for Mutator
-#include "SynTree/Type.h"     // for Type (ptr only), PointerType (ptr only)
-
-class AlignofExpr;
-class Expression;
-class SizeofExpr;
 
 namespace GenPoly {
-        struct ScrubTyVars : public WithVisitorRef<ScrubTyVars>, public WithShortCircuiting, public WithGuards {
-                /// Whether to scrub all type variables from the provided map, dynamic type variables from the provided map, or all type variables
-                enum ScrubMode { FromMap, DynamicFromMap, All };
-
-                ScrubTyVars() : tyVars(nullptr), mode( All ) {}
-
-                ScrubTyVars( const TyVarMap &tyVars, ScrubMode mode = FromMap ): tyVars( &tyVars ), mode( mode ) {}
-
-        public:
-                /// For all polymorphic types with type variables in `tyVars`, replaces generic types, dtypes, and ftypes with the appropriate void type,
-                /// and sizeof/alignof expressions with the proper variable
-                template< typename SynTreeClass >
-                static SynTreeClass *scrub( SynTreeClass *target, const TyVarMap &tyVars );
-
-                /// For all dynamic-layout types with type variables in `tyVars`, replaces generic types, dtypes, and ftypes with the appropriate void type,
-                /// and sizeof/alignof expressions with the proper variable
-                template< typename SynTreeClass >
-                static SynTreeClass *scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars );
-
-                /// For all polymorphic types, replaces generic types, dtypes, and ftypes with the appropriate void type,
-                /// and sizeof/alignof expressions with the proper variable
-                template< typename SynTreeClass >
-                static SynTreeClass *scrubAll( SynTreeClass *target );
-
-                /// determine if children should be visited based on whether base type should be scrubbed.
-                void primeBaseScrub( Type * );
-
-                void premutate( TypeInstType * ) { visit_children = false; }
-                void premutate( StructInstType * ) { visit_children = false; }
-                void premutate( UnionInstType * ) { visit_children = false; }
-                void premutate( SizeofExpr * szeof ) { primeBaseScrub( szeof->type ); }
-                void premutate( AlignofExpr * algnof ) { primeBaseScrub( algnof->type ); }
-                void premutate( PointerType * pointer ) { primeBaseScrub( pointer->base ); }
-
-                Type * postmutate( TypeInstType * typeInst );
-                Type * postmutate( StructInstType * structInst );
-                Type * postmutate( UnionInstType * unionInst );
-                Expression * postmutate( SizeofExpr * szeof );
-                Expression * postmutate( AlignofExpr * algnof );
-                Type * postmutate( PointerType * pointer );
-
-          private:
-                /// Returns the type if it should be scrubbed, NULL otherwise.
-                Type* shouldScrub( Type *ty ) {
-                        switch ( mode ) {
-                        case FromMap: return isPolyType( ty, *tyVars );
-                        case DynamicFromMap: return isDynType( ty, *tyVars );
-                        case All: return isPolyType( ty );
-                        }
-                        assert(false); return nullptr; // unreachable
-                        // return dynamicOnly ? isDynType( ty, tyVars ) : isPolyType( ty, tyVars );
-                }
-
-                /// Mutates (possibly generic) aggregate types appropriately
-                Type* mutateAggregateType( Type *ty );
-
-                const TyVarMap *tyVars;  ///< Type variables to scrub
-                ScrubMode mode;          ///< which type variables to scrub? [FromMap]
-
-                Type * dynType = nullptr; ///< result of shouldScrub
-        };
-
-        template< typename SynTreeClass >
-        SynTreeClass * ScrubTyVars::scrub( SynTreeClass *target, const TyVarMap &tyVars ) {
-                PassVisitor<ScrubTyVars> scrubber( tyVars );
-                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
-        }
-
-        template< typename SynTreeClass >
-        SynTreeClass * ScrubTyVars::scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars ) {
-                PassVisitor<ScrubTyVars> scrubber( tyVars, ScrubTyVars::DynamicFromMap );
-                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
-        }
-
-        template< typename SynTreeClass >
-        SynTreeClass * ScrubTyVars::scrubAll( SynTreeClass *target ) {
-                PassVisitor<ScrubTyVars> scrubber;
-                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
-        }
 
 // ScrubMode and scrubTypeVarsBase are internal.

src/GenPoly/SpecializeNew.cpp

@@ -23 +23 @@
 #include "GenPoly/GenPoly.h"             // for getFunctionType
 #include "ResolvExpr/FindOpenVars.h"     // for findOpenVars
-#include "ResolvExpr/TypeEnvironment.h"  // for FirstOpen, FirstClosed
 
 namespace GenPoly {

src/GenPoly/module.mk

@@ -23 +23 @@
 SRC += $(SRC_GENPOLY) \
         GenPoly/BoxNew.cpp \
-        GenPoly/Box.cc \
         GenPoly/Box.h \
         GenPoly/ErasableScopedMap.h \
@@ -29 +28 @@
         GenPoly/FindFunction.h \
         GenPoly/InstantiateGenericNew.cpp \
-        GenPoly/InstantiateGeneric.cc \
         GenPoly/InstantiateGeneric.h \
         GenPoly/LvalueNew.cpp \
-        GenPoly/Lvalue.cc \
         GenPoly/ScopedSet.h \
         GenPoly/ScrubTyVars.cc \
         GenPoly/ScrubTyVars.h \
-        GenPoly/Specialize.cc \
         GenPoly/SpecializeNew.cpp \
         GenPoly/Specialize.h