source: src/GenPoly/InstantiateGeneric.cpp @ 2325b57

//
// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// InstantiateGeneric.cpp -- Create concrete instances of generic types.
//
// Author           : Andrew Beach
// Created On       : Tue Aug 16 10:51:00 2022
// Last Modified By : Andrew Beach
// Last Modified On : Mon Oct 31 16:48:00 2022
// Update Count     : 1
//

#include "InstantiateGeneric.hpp"

#include <cassert>                     // for assertf, assert
#include <set>                         // for set
#include <utility>                     // for move, pair
#include <vector>                      // for vector

#include "AST/Copy.hpp"                // for deepCopy
#include "AST/Create.hpp"              // for asForward
#include "AST/Inspect.hpp"             // for getFunction
#include "AST/Pass.hpp"                // for Pass, WithGuard, WithShortCi...
#include "AST/TranslationUnit.hpp"     // for TranslationUnit
#include "AST/Vector.hpp"              // for vector
#include "CodeGen/OperatorTable.hpp"   // for isAssignment
#include "Common/ScopedMap.hpp"        // for ScopedMap
#include "Common/UniqueName.hpp"       // for UniqueName
#include "GenPoly/GenPoly.hpp"         // for isPolyType, typesPolyCompatible
#include "GenPoly/ScrubTypeVars.hpp"   // for scrubAllTypeVars
#include "ResolvExpr/AdjustExprType.hpp"  // for adjustExprType
#include "ResolvExpr/Unify.hpp"        // for typesCompatible

namespace GenPoly {

namespace {

// Utilities:

using type_vector = ast::vector< ast::TypeExpr >;

/// Abstracts type equality for a list of parameter types.
struct TypeList {
        TypeList() : params() {}
        TypeList( ast::vector< ast::Type > const & params ) :
                params( params ) {}
        TypeList( ast::vector< ast::Type > && params ) :
                params( std::move( params ) ) {}
        TypeList( TypeList const & that ) : params( that.params ) {}
        TypeList( TypeList && that ) : params( std::move( that.params ) ) {}

        TypeList( ast::vector< ast::TypeExpr > const & exprs ) :
                        params() {
                for ( auto expr : exprs ) {
                        params.emplace_back( ast::deepCopy( expr->type ) );
                }
        }

        TypeList & operator=( TypeList const & that ) {
                params = that.params;
                return *this;
        }

        TypeList & operator=( TypeList && that ) {
                params = std::move( that.params );
                return *this;
        }

        bool operator==( TypeList const & that ) const {
                if ( params.size() != that.params.size() ) {
                        return false;
                }

                for ( auto it = params.begin(), jt = that.params.begin() ;
                                it != params.end() ; ++it, ++jt ) {
                        if ( !typesPolyCompatible( it->get(), jt->get() ) ) {
                                return false;
                        }
                }
                return true;
        }

        ast::vector<ast::Type> params;
};

/// Maps a key and a TypeList to a valuue. Also supports scoping.
class InstantiationMap final {
        /// Wraps value for a specific (AggregateDecl, TypeList) combination.
        using Instantiation = std::pair<TypeList, ast::ptr<ast::AggregateDecl>>;
        /// List of TypeLists paired with the appropriate values.
        using ValueList = std::vector<Instantiation>;
        /// Underlying map type; maps keys to a linear list of corresponding
        /// TypeLists and values.
        using InnerMap = ScopedMap<ast::ptr<ast::AggregateDecl>, ValueList>;

        InnerMap data;
public:
        void beginScope() { data.beginScope(); }
        void endScope() { data.endScope(); }

        /// Gets the value for the (declaration, type list) pair,
        /// returns null if no such value exists.
        ast::AggregateDecl const * lookup(
                        ast::AggregateDecl const * key,
                        type_vector const & params ) const {
                // This type repackaging is used for the helpers.
                ast::ptr<ast::AggregateDecl> ptr = key;
                TypeList typeList( params );

                // Scan scopes for matches to the key.
                for ( auto insts = data.find( key ) ;
                                insts != data.end() ; insts = data.findNext( insts, ptr )) {
                        for ( auto inst = insts->second.rbegin() ;
                                        inst != insts->second.rend() ; ++inst ) {
                                if ( inst->first == typeList ) {
                                        return inst->second;
                                }
                        }
                }
                return nullptr;
        }

        /// Adds a value for a (key, type list) pair to the current scope.
        void insert( ast::AggregateDecl const * key, type_vector const & params,
                        ast::AggregateDecl const * value ) {
                auto it = data.findAt( data.currentScope(), key );
                if ( it == data.end() ) {
                        data.insert( key, ValueList( 1,
                                Instantiation( TypeList( params ), value ) ) );
                } else {
                        it->second.emplace_back(
                                Instantiation( TypeList( params ), value ) );
                }
        }
};

/// Possible options for a given specialization of a generic type.
enum class GenericType {
        /// Concrete instatiation based solely on {d,f}type-to-void conversions.
        dtypeStatic,
        /// Concrete instatiation requiring at least one parameters type.
        concrete,
        /// No concrete instantiation.
        dynamic
};

GenericType & operator|=( GenericType & gt, const GenericType & ht ) {
        if ( gt < ht ) gt = ht;
        return gt;
}

bool isDtypeStatic( ast::vector<ast::TypeDecl> const & baseParams ) {
        return std::all_of( baseParams.begin(), baseParams.end(),
                []( ast::TypeDecl const * td ){ return !td->isComplete(); }
        );
}

/// Makes substitutions of params into baseParams; returns dtypeStatic if
/// there is a concrete instantiation based only on {d,f}type-to-void
/// conversions, concrete if there is a concrete instantiation requiring at
/// least one parameter type, and dynamic if there is no concrete instantiation.
GenericType makeSubstitutions(
                ast::vector<ast::TypeExpr> & out,
                ast::vector<ast::TypeDecl> const & baseParams,
                ast::vector<ast::Expr> const & params ) {
        GenericType gt = GenericType::dtypeStatic;

        // Substitute concrete types for given parameters,
        // using incomplete types for placeholders.
        auto baseParam = baseParams.begin();
        auto param = params.begin();
        for ( ; baseParam != baseParams.end() && param != params.end() ;
                        ++baseParam, ++param ) {
                ast::TypeExpr const * paramExpr = param->as<ast::TypeExpr>();
                assertf( paramExpr, "Aggregate parameters should be type expressions." );

                if ( (*baseParam)->isComplete() ) {
                        // Substitute parameter for complete (otype or sized dtype) type.
                        if ( isPolyType( paramExpr->type ) ) {
                                // Substitute polymorphic parameter type in to generic type.
                                out.push_back( ast::deepCopy( paramExpr ) );
                                gt = GenericType::dynamic;
                        } else {
                                // Normalize possibly dtype-static parameter type.
                                out.emplace_back( new ast::TypeExpr( paramExpr->location,
                                        scrubAllTypeVars( ast::deepCopy( paramExpr->type ) ) ) );
                                gt |= GenericType::concrete;
                        }
                } else switch ( (*baseParam)->kind ) {
                case ast::TypeDecl::Dtype:
                        // Here, pretend that any incomplete dtype is `void`.
                        out.emplace_back( new ast::TypeExpr( paramExpr->location,
                                new ast::VoidType() ) );
                        break;
                case ast::TypeDecl::Ftype:
                        // Here, pretend that any ftype is `void (*)(void)`.
                        out.emplace_back( new ast::TypeExpr( paramExpr->location,
                                new ast::FunctionType() ) );
                        break;
                case ast::TypeDecl::Ttype:
                        assertf( false, "Ttype parameters are not currently allowed as parameters to generic types." );
                        break;
                default:
                        assertf( false, "Unhandled type parameter kind" );
                        break;
                }
        }

        assertf( baseParam == baseParams.end(), "Base Parameters not exausted." );
        assertf( param == params.end(), "Type parameters not exausted." );
        return gt;
}

/// Substitutes types of members according to baseParams => typeSubs,
/// returning the result in a new vector.
ast::vector<ast::Decl> substituteMembers(
                ast::vector<ast::Decl> const & members,
                ast::vector<ast::TypeDecl> const & baseParams,
                ast::vector<ast::TypeExpr> const & typeSubs ) {
        ast::vector<ast::Decl> out;
        ast::TypeSubstitution subs( baseParams, typeSubs );
        for ( ast::ptr<ast::Decl> const & member : members ) {
                // Create a manual copy to avoid in-place mutation.
                // If being a PureVisitor is decided to be part of apply's interface,
                // then we can actually skip this step as it will never mutate in-
                // place. (Then we don't need the extra guard to free temp value.)
                ast::ptr<ast::Decl> copy = ast::deepCopy( member.get() );
                auto result = subs.apply( copy.get() );
                out.emplace_back( result.node );
        }
        return out;
}

/// Substitutes types of members according to baseParams => typeSubs,
/// modifying them in-place.
void substituteMembersHere(
                ast::vector<ast::Decl> & members,
                ast::vector<ast::TypeDecl> const & baseParams,
                ast::vector<ast::TypeExpr> const & typeSubs ) {
        ast::TypeSubstitution subs( baseParams, typeSubs );
        for ( ast::ptr<ast::Decl> & member : members ) {
                // The member must be mutated in place to avoid breaking
                assert( member->unique() );

                auto field = member.strict_as<ast::ObjectDecl>();
                auto result = subs.apply( field->type.get() );
                auto copy = ast::mutate_field(
                        field, &ast::ObjectDecl::type, result.node );

                // I'm not kidding, it is very important.
                assert( copy == member.get() );
        }
}

/// Strips the instances' type parameters.
void stripInstParams( ast::BaseInstType * inst ) {
        inst->params.clear();
}

bool isGenericType( ast::Type const * type ) {
        if ( auto inst = dynamic_cast<ast::StructInstType const *>( type ) ) {
                return !inst->params.empty();
        } else if ( auto inst = dynamic_cast<ast::UnionInstType const *>( type ) ) {
                return !inst->params.empty();
        } else {
                return false;
        }
}

// The Passes:

struct FixDtypeStatic final :
                public ast::WithGuards,
                public ast::WithVisitorRef<FixDtypeStatic>,
                public ast::WithShortCircuiting,
                public ast::WithStmtsToAdd<> {
        ast::ApplicationExpr const * previsit( ast::ApplicationExpr const * expr );
        void previsit( ast::AddressExpr const * expr );

        ast::Expr const * postvisit( ast::MemberExpr const * expr );
private:
        template<typename Aggr>
        ast::Expr const * fixMemberExpr(
                Aggr const * inst, ast::MemberExpr const * memberExpr );

        ast::Expr const * fixMemberExpr(
                ast::vector<ast::TypeDecl> const & baseParams,
                ast::MemberExpr const * memberExpr );

        bool isLValueArg = false;
};

ast::ApplicationExpr const * FixDtypeStatic::previsit(
                ast::ApplicationExpr const * expr ) {
        GuardValue( isLValueArg ) = false;
        ast::Decl const * function = ast::getFunction( expr );
        if ( ast::Linkage::Intrinsic != function->linkage
                        || !CodeGen::isAssignment( function->name ) ) {
                return expr;
        }

        // Explicity visit children because only the first element must be a
        // C lvalue (normally, it can only send info to both or neither).
        visit_children = false;
        expr = mutate_field( expr, &ast::ApplicationExpr::env,
                maybe_accept( expr->env.get(), *visitor ) );
        expr = mutate_field( expr, &ast::ApplicationExpr::result,
                maybe_accept( expr->result.get(), *visitor ) );
        expr = mutate_field( expr, &ast::ApplicationExpr::func,
                maybe_accept( expr->func.get(), *visitor ) );
        isLValueArg = true;
        for ( unsigned i = 0; i < expr->args.size(); ++i ) {
                ast::Expr const * newExpr = expr->args[i]->accept( *visitor );
                // This is declared here for lifetime reasons.
                ast::ptr<ast::CastExpr> cast;
                if ( newExpr != expr->args[i].get() &&
                                (cast = dynamic_cast<ast::CastExpr const *>( newExpr )) ) {
                        newExpr = cast->arg.get();
                }
                expr = mutate_field_index( expr, &ast::ApplicationExpr::args,
                        i, newExpr );
                isLValueArg = false;
        }
        return expr;
}

void FixDtypeStatic::previsit( ast::AddressExpr const * ) {
        // The argument of an address expression (`&`) must be a C lvalue.
        GuardValue( isLValueArg ) = true;
}

ast::Expr const * FixDtypeStatic::postvisit( ast::MemberExpr const * expr ) {
        ast::ptr<ast::Type> const & type = expr->aggregate->result;
        if ( auto inst = type.as<ast::StructInstType>() ) {
                if ( !inst->params.empty() ) return fixMemberExpr( inst, expr );
        } else if ( auto inst = type.as<ast::UnionInstType>() ) {
                if ( !inst->params.empty() ) return fixMemberExpr( inst, expr );
        }
        return expr;
}

template<typename Aggr>
ast::Expr const * FixDtypeStatic::fixMemberExpr(
                Aggr const * inst, ast::MemberExpr const * memberExpr ) {
        return fixMemberExpr( inst->base->params, memberExpr );
}

ast::Expr const * FixDtypeStatic::fixMemberExpr(
                ast::vector<ast::TypeDecl> const & baseParams,
                ast::MemberExpr const * memberExpr ) {
        // Need to cast dtype-static member expressions to their actual type
        // before the actual type type is erased.
        // NOTE: The casts here have the third argument (isGenerated) set to
        // ExplicitCast so that they casts persist until Box, where they are needed.

        if ( !isDtypeStatic( baseParams ) ||
                        ResolvExpr::typesCompatible(
                                memberExpr->result,
                                memberExpr->member->get_type() ) ) {
                return memberExpr;
        }

        // Type of member and type of expression differ.
        ast::Type const * concType = ast::deepCopy( memberExpr->result );
        CodeLocation const & location = memberExpr->location;
        if ( isLValueArg ) {
                // The result must be a C lvalue expression. So make a new reference
                // variable with the correct actual type to replace the
                // member expression.
                //   forall(T &)
                //   struct Ptr {
                //     T * x;
                //   };
                //   Ptr(int) p;
                //   int i;
                // The original expression:
                //   p.x = &i;
                // Becomes the expression/declaration:
                //   int *& _dtype_static_member_0;
                //   (_dtype_static_member_0 = (int**)&p.x,
                //    _dtype_static_member_0) = &i;

                // The declaration is simple:
                static UniqueName tmpNamer( "_dtype_static_member_" );
                ast::ObjectDecl * tmp = new ast::ObjectDecl( location,
                        tmpNamer.newName(),
                        new ast::ReferenceType( concType ),
                        nullptr,
                        ast::Storage::Classes(),
                        ast::Linkage::C
                );
                stmtsToAddBefore.push_back( new ast::DeclStmt( location, tmp ) );

                // The expression is more complex, uses references and reference /
                // pointer parity. But breaking it up risks reordering.
                return new ast::CommaExpr( location,
                        ast::UntypedExpr::createAssign( location,
                                new ast::VariableExpr( location, tmp ),
                                new ast::CastExpr( location,
                                        new ast::AddressExpr( location, memberExpr ),
                                        new ast::PointerType( ast::deepCopy( concType ) ),
                                        ast::ExplicitCast
                                )
                        ),
                        new ast::VariableExpr( location, tmp )
                );
        } else {
                // Here, it can simply add a cast to actual types.
                return new ast::CastExpr( location,
                        memberExpr,
                        concType,
                        ast::ExplicitCast
                );
        }
}

struct GenericInstantiator final :
                public ast::WithCodeLocation,
                public ast::WithConstTypeSubstitution,
                public ast::WithDeclsToAdd<>,
                public ast::WithGuards,
                public ast::WithVisitorRef<GenericInstantiator>
{
        /// Map of (generic type, parameter list) pairs
        /// to concrete type instantiations.
        InstantiationMap instantiations;
        /// Set of types which are dtype-only generic
        /// (and therefore have static layout).
        std::set<ast::AggregateDecl const *> dtypeStatics;
        /// Namer for concrete types.
        UniqueName typeNamer;
        /// Should not make use of type environment to replace types of function
        /// parameter and return values.
        bool inFunctionType = false;
        /// Index of current member, used to recreate MemberExprs with the
        /// member from an instantiation.
        int memberIndex = -1;

        GenericInstantiator() :
                instantiations(), dtypeStatics(), typeNamer("_conc_") {}

        ast::Type const * postvisit( ast::StructInstType const * inst );
        ast::Type const * postvisit( ast::UnionInstType const * inst );

        void previsit( ast::MemberExpr const * expr );
        ast::Expr const * postvisit( ast::MemberExpr const * expr );
        ast::Expr const * postvisit( ast::Expr const * expr );
        ast::Designation const * postvisit( ast::Designation const * );

        void previsit( ast::ParseNode const * node ) {
                GuardValue( location ) = &node->location;
        }
        void previsit( ast::FunctionType const * ) {
                GuardValue( inFunctionType ) = true;
        }
        void beginScope() {
                instantiations.beginScope();
        }
        void endScope() {
                instantiations.endScope();
        }
private:
        /// Wrap instantiation lookup for structures.
        ast::StructDecl const * lookup(
                ast::StructInstType const * inst, type_vector const & typeSubs ) const;
        /// Wrap instantiation lookup for unions.
        ast::UnionDecl const * lookup(
                ast::UnionInstType const * inst, type_vector const & typeSubs ) const;
        /// Wrap instantiation insertion for structures.
        void insert( ast::StructInstType const * inst,
                type_vector const & typeSubs, ast::StructDecl const * decl );
        /// Wrap instantiation insertion for unions.
        void insert( ast::UnionInstType const * inst,
                type_vector const & typeSubs, ast::UnionDecl const * decl );

        void replaceParametersWithConcrete( ast::vector<ast::Expr> & params );
        ast::Type const * replaceWithConcrete( ast::Type const * type, bool doClone );

        template<typename AggrDecl>
        ast::Type const * fixInstType( ast::SueInstType<AggrDecl> const * inst );

        /// Strips a dtype-static aggregate decl of its type parameters,
        /// marks it as stripped.
        void stripDtypeParams( ast::AggregateDecl * base,
                ast::vector<ast::TypeDecl> & baseParams,
                ast::vector<ast::TypeExpr> const & typeSubs );
};

ast::Type const * GenericInstantiator::postvisit(
                ast::StructInstType const * inst ) {
        return fixInstType( inst );
}

ast::Type const * GenericInstantiator::postvisit(
                ast::UnionInstType const * inst ) {
        return fixInstType( inst );
}

template<typename AggrDecl>
ast::Type const * GenericInstantiator::fixInstType(
                ast::SueInstType<AggrDecl> const * inst ) {
        assert( location );

        // There is nothing to mutate if the params are empty.
        if ( inst->params.empty() ) return inst;

        // Need to replace type variables to ensure that generic types are
        // instantiated for the return values of polymorphic functions (in
        // particular, for thunks, because they are not [currently] copy
        // constructed).
        // (This used to be run only on structures, but I believe both need it.)
        inst = strict_dynamic_cast<ast::SueInstType<AggrDecl> const *>(
                replaceWithConcrete( inst, false ) );

        // Check for an already-instantiatiated dtype-static type.
        if ( dtypeStatics.find( inst->base ) != dtypeStatics.end() ) {
                auto mutInst = ast::mutate( inst );
                stripInstParams( mutInst );
                return mutInst;
        }

        // Check if the type can be concretely instantiated;
        // and put substitutions in typeSubs.
        assertf( inst->base, "Base data-type has parameters." );
        ast::vector<ast::TypeExpr> typeSubs;
        GenericType gt = makeSubstitutions( typeSubs, inst->base->params, inst->params );
        switch ( gt ) {
        case GenericType::dtypeStatic:
        {
                auto mutInst = ast::mutate( inst );
                assert( mutInst->base->unique() );
                auto mutBase = mutInst->base.get_and_mutate();
                stripDtypeParams( mutBase, mutBase->params, typeSubs );
                stripInstParams( mutInst );
                return mutInst;
        }
        case GenericType::concrete:
        {
                // Make concrete instantiation of generic type.
                AggrDecl const * concDecl = lookup( inst, typeSubs );
                if ( !concDecl ) {
                        // Set concDecl to new type, insert type declaration
                        // into statements to add.
                        AggrDecl * newDecl = new AggrDecl( *location,
                                typeNamer.newName( inst->name )
                        );
                        newDecl->body = inst->base->body;
                        newDecl->members = substituteMembers(
                                inst->base->members,
                                inst->base->params,
                                typeSubs
                        );

                        // Forward declare before recursion. (TODO: Only when needed, #199.)
                        insert( inst, typeSubs, newDecl );
                        if ( AggrDecl const * forwardDecl = ast::asForward( newDecl ) ) {
                                declsToAddBefore.push_back( forwardDecl );
                        }
                        // Recursively instantiate members:
                        concDecl = strict_dynamic_cast<AggrDecl const *>(
                                newDecl->accept( *visitor ) );
                        // Must occur before declaration is added so
                        // that member instantiation appear first.
                        declsToAddBefore.push_back( concDecl );
                }
                return new ast::SueInstType<AggrDecl>( concDecl, inst->qualifiers );
        }
        case GenericType::dynamic:
                // Do nothing.
        default:
                // Should never happen.
                return inst;
        }
}

void GenericInstantiator::previsit( ast::MemberExpr const * expr ) {
        GuardValue( location ) = &expr->location;
        GuardValue( memberIndex ) = -1;
        // Only run on expressions where the field being accessed is generic.
        if ( isGenericType( expr->aggregate->result ) ) {
                // Find the location of the member:
                ast::AggregateDecl const * aggr =
                        expr->aggregate->result.strict_as<ast::BaseInstType>()->aggr();
                ast::vector<ast::Decl> const & members = aggr->members;
                auto it = std::find( members.begin(), members.end(), expr->member );
                memberIndex = std::distance( members.begin(), it );
                assertf( memberIndex < (int)members.size(), "Could not find member %s in generic type %s.", toString( expr->member ).c_str(), toString( expr->aggregate ).c_str() );
        }
}

ast::Expr const * GenericInstantiator::postvisit(
                ast::MemberExpr const * expr ) {
        if ( memberIndex == -1 ) {
                return expr;
        }

        // Using the location from the generic type, find the member
        // in the instantiation and rebuild the member expression.
        ast::AggregateDecl const * aggr =
                expr->aggregate->result.strict_as<ast::BaseInstType>()->aggr();
        assertf( memberIndex < (int)aggr->members.size(), "Instantiation somehow has fewer members than the generic type." );
        ast::Decl const * member = *std::next( aggr->members.begin(), memberIndex );
        assertf( member->name == expr->member->name, "Instantiation has different member order than the generic type. %s / %s", toString( member ).c_str(), toString( expr->member ).c_str() );
        auto field = strict_dynamic_cast< ast::DeclWithType const * >( member );
        ast::MemberExpr * ret = new ast::MemberExpr( expr->location,
                field,
                ast::deepCopy( expr->aggregate )
        );
        // For pointer decay:
        ret->result = ResolvExpr::adjustExprType(
                ret->result,
                ast::TypeEnvironment(),
                ast::SymbolTable()
        );
        ret->env = expr->env;
        return ret;
}

ast::Expr const * GenericInstantiator::postvisit( ast::Expr const * expr ) {
        // We are not modifying env on MemberExpr, but that seems to work.
        if ( expr->env ) {
                auto newEnv = expr->env->accept( *visitor );
                expr = ast::mutate_field( expr, &ast::Expr::env, newEnv );
        }
        return expr;
}

// This attempts to figure out what the final name of the field will be.
// Pretty printing can cause this to become incorrect.
std::string getPrintName( ast::DeclWithType const * decl ) {
        return ( decl->linkage.is_mangled )
                ? decl->scopedMangleName() : decl->name;
}

ast::Designation const * GenericInstantiator::postvisit(
                ast::Designation const * designation ) {
        // Disconnect designator names from their fields.
        // It is now incorrect to point at the generic definition where the used
        // type now is replaced with a concrete instance. Ideally, new variable
        // expressions would point at fields in the concrete instances, but that
        // is work and that information should not be needed this late in
        // compilation.

        // Modify all designations, even if not needed.
        auto mutNode = mutate( designation );
        for ( ast::ptr<ast::Expr> & designator : mutNode->designators ) {
                if ( auto var = designator.as<ast::VariableExpr>() ) {
                        designator = new ast::NameExpr(
                                var->location, getPrintName( var->var ) );
                }
        }
        return mutNode;
}

ast::StructDecl const * GenericInstantiator::lookup(
                ast::StructInstType const * inst,
                type_vector const & typeSubs ) const {
        auto ret = instantiations.lookup( inst->base, typeSubs );
        return strict_dynamic_cast<ast::StructDecl const *, nullptr>( ret );
}

ast::UnionDecl const * GenericInstantiator::lookup(
                ast::UnionInstType const * inst,
                type_vector const & typeSubs ) const {
        auto ret = instantiations.lookup( inst->base, typeSubs );
        return strict_dynamic_cast<ast::UnionDecl const *, nullptr>( ret );
}

void GenericInstantiator::insert( ast::StructInstType const * inst,
                type_vector const & typeSubs, ast::StructDecl const * decl ) {
        instantiations.insert( inst->base, typeSubs, decl );
}

void GenericInstantiator::insert( ast::UnionInstType const * inst,
                type_vector const & typeSubs, ast::UnionDecl const * decl ) {
        instantiations.insert( inst->base, typeSubs, decl );
}

void GenericInstantiator::replaceParametersWithConcrete(
                ast::vector<ast::Expr> & params ) {
        for ( ast::ptr<ast::Expr> & param : params ) {
                auto paramType = param.as<ast::TypeExpr>();
                assertf( paramType, "Aggregate parameters should be type expressions." );
                auto type = replaceWithConcrete( paramType->type, false );
                param = ast::mutate_field( paramType, &ast::TypeExpr::type, type );
        }
}

ast::Type const * GenericInstantiator::replaceWithConcrete(
                ast::Type const * type, bool doClone ) {
        if ( auto inst = dynamic_cast<ast::TypeInstType const *>( type ) ) {
                if ( typeSubs && !inFunctionType ) {
                        ast::Type const * concType = typeSubs->lookup( inst );
                        return ast::deepCopy( ( concType ) ? concType : inst );
                }
        } else if ( auto inst = dynamic_cast<ast::StructInstType const *>( type ) ) {
                auto mut = ( doClone ) ? ast::deepCopy( inst ) : ast::mutate( inst );
                replaceParametersWithConcrete( mut->params );
                return mut;
        } else if ( auto inst = dynamic_cast<ast::UnionInstType const *>( type ) ) {
                auto mut = ( doClone ) ? ast::deepCopy( inst ) : ast::mutate( inst );
                replaceParametersWithConcrete( mut->params );
                return mut;
        }
        return type;
}

void GenericInstantiator::stripDtypeParams(
                ast::AggregateDecl * base,
                ast::vector<ast::TypeDecl> & baseParams,
                ast::vector<ast::TypeExpr> const & typeSubs ) {
        substituteMembersHere( base->members, baseParams, typeSubs );

        baseParams.clear();

        dtypeStatics.insert( base );
}

} // namespace

void instantiateGeneric( ast::TranslationUnit & translationUnit ) {
        ast::Pass<FixDtypeStatic>::run( translationUnit );
        ast::Pass<GenericInstantiator>::run( translationUnit );
}

} // namespace GenPoly

// Local Variables: //
// tab-width: 4 //
// mode: c++ //
// compile-command: "make install" //
// End: //