Changeset 2162c2c for src/GenPoly/InstantiateGeneric.cc

Timestamp:

Jan 11, 2017, 4:11:02 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

075734f

Parents:

bb82c03 (diff), d3a85240 (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

File:

• src/GenPoly/InstantiateGeneric.cc (modified) (10 diffs)

src/GenPoly/InstantiateGeneric.cc

@@ -18 +18 @@
 #include <utility>
 #include <vector>
+#include <unordered_map>
 
 #include "InstantiateGeneric.h"
@@ -24 +25 @@
 #include "GenPoly.h"
 #include "ScopedSet.h"
+#include "PolyMutator.h"
 
 #include "ResolvExpr/typeops.h"
@@ -146 +148 @@
         }
 
+        // collect the environments of each TypeInstType so that type variables can be replaced
+        // xxx - possibly temporary solution. Access to type environments is required in GenericInstantiator, but it needs to be a DeclMutator which does not provide easy access to the type environments.
+        class EnvFinder final : public GenPoly::PolyMutator {
+        public:
+                virtual Type * mutate( TypeInstType * inst ) override {
+                        if ( env ) envMap[inst] = env;
+                        return inst;
+                }
+
+                // don't want to associate an environment with TypeInstTypes that occur in function types - this may actually only apply to function types belonging to DeclarationWithTypes (or even just FunctionDecl)?
+                virtual Type * mutate( FunctionType * ftype ) override {
+                        return ftype;
+                }
+                std::unordered_map< ReferenceToType *, TypeSubstitution * > envMap;
+        };
+
         /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
         class GenericInstantiator final : public DeclMutator {
@@ -154 +172 @@
                 /// Namer for concrete types
                 UniqueName typeNamer;
-
+                /// Reference to mapping of environments
+                const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap;
         public:
-                GenericInstantiator() : DeclMutator(), instantiations(), dtypeStatics(), typeNamer("_conc_") {}
+                GenericInstantiator( const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap ) : DeclMutator(), instantiations(), dtypeStatics(), typeNamer("_conc_"), envMap( envMap ) {}
 
                 using DeclMutator::mutate;
@@ -174 +193 @@
                 void insert( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs, UnionDecl *decl ) { instantiations.insert( inst->get_baseUnion(), typeSubs, decl ); }
 
+                void replaceParametersWithConcrete( std::list< Expression* >& params );
+                Type *replaceWithConcrete( Type *type, bool doClone );
+
                 /// Strips a dtype-static aggregate decl of its type parameters, marks it as stripped
                 void stripDtypeParams( AggregateDecl *base, std::list< TypeDecl* >& baseParams, const std::list< TypeExpr* >& typeSubs );
@@ -179 +201 @@
 
         void instantiateGeneric( std::list< Declaration* > &translationUnit ) {
-                GenericInstantiator instantiator;
+                EnvFinder finder;
+                mutateAll( translationUnit, finder );
+                GenericInstantiator instantiator( finder.envMap );
                 instantiator.mutateDeclarationList( translationUnit );
         }
@@ -209 +233 @@
                                 // can pretend that any ftype is `void (*)(void)`
                                 out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
+                                break;
+                        case TypeDecl::Ttype:
+                                assertf( false, "Ttype parameters are not currently allowed as parameters to generic types." );
                                 break;
                         }
@@ -253 +280 @@
         }
 
+        /// xxx - more or less copied from box -- these should be merged with those somehow...
+        void GenericInstantiator::replaceParametersWithConcrete( std::list< Expression* >& params ) {
+                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");
+                        paramType->set_type( replaceWithConcrete( paramType->get_type(), false ) );
+                }
+        }
+
+        Type *GenericInstantiator::replaceWithConcrete( Type *type, bool doClone ) {
+                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
+                        if ( envMap.count( typeInst ) ) {
+                                TypeSubstitution * env = envMap.at( typeInst );
+                                Type *concrete = env->lookup( typeInst->get_name() );
+                                if ( concrete ) {
+                                        return concrete->clone();
+                                }
+                                else return typeInst->clone();
+                        }
+                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
+                        if ( doClone ) {
+                                structType = structType->clone();
+                        }
+                        replaceParametersWithConcrete( structType->get_parameters() );
+                        return structType;
+                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
+                        if ( doClone ) {
+                                unionType = unionType->clone();
+                        }
+                        replaceParametersWithConcrete( unionType->get_parameters() );
+                        return unionType;
+                }
+                return type;
+        }
+
+
         Type* GenericInstantiator::mutate( StructInstType *inst ) {
                 // mutate subtypes
@@ -262 +325 @@
                 if ( inst->get_parameters().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).
+                replaceWithConcrete( inst, false );
+
                 // check for an already-instantiatiated dtype-static type
                 if ( dtypeStatics.find( inst->get_baseStruct() ) != dtypeStatics.end() ) {
@@ -269 +335 @@
 
                 // check if type can be concretely instantiated; put substitutions into typeSubs
-                assert( inst->get_baseParameters() && "Base struct has parameters" );
+                assertf( inst->get_baseParameters(), "Base struct has parameters" );
                 std::list< TypeExpr* > typeSubs;
                 genericType gt = makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs );