Changeset b940dc71

Timestamp:

Dec 21, 2016, 4:15:47 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

53e3b4a

Parents:

626dbc10

Message:

replace type variables in InstantiateGeneric?, fix call passTypeVars so that the correct type is passed

Location:

src/GenPoly

Files:

• Box.cc (modified) (2 diffs)
• InstantiateGeneric.cc (modified) (10 diffs)

src/GenPoly/Box.cc ¶

@@ -1127 +1127 @@
                         makeTyVarMap( function, exprTyVars ); // xxx - should this take into account the variables already bound in scopeTyVars (i.e. remove them from exprTyVars?)
                         ReferenceToType *dynRetType = isDynRet( function, exprTyVars );
-                        Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();// ?: dynRetType; // xxx - is concRetType a good name?
-
+
+                        // NOTE: addDynRetParam needs to know the actual (generated) return type so it can make a temp variable, so pass the result type from the appExpr
+                        // passTypeVars needs to know the program-text return type (i.e. the distinction between _conc_T30 and T3(int))
+                        // concRetType may not be a good name in one or both of these places. A more appropriate name change is welcome.
                         if ( dynRetType ) {
+                                Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();
                                 ret = addDynRetParam( appExpr, function, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType
                         } else if ( needsAdapter( function, scopeTyVars ) && ! needsAdapter( function, exprTyVars) ) { // xxx - exprTyVars is used above...?
@@ -1142 +1145 @@
                         arg = appExpr->get_args().begin();
 
+                        Type *concRetType = replaceWithConcrete( appExpr, dynRetType );
                         passTypeVars( appExpr, concRetType, arg, exprTyVars ); // xxx - used to use dynRetType instead of concRetType; this changed so that the correct type paramaters are passed for return types (it should be the concrete type's parameters, not the formal type's)
                         addInferredParams( appExpr, function, arg, exprTyVars );

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 );