Changeset 48ca586

Timestamp:

Jan 13, 2016, 2:31:28 PM (8 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

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

Children:

52bbd67

Parents:

4d7e8f5

Message:

addPolyRetParam now handles polymorphic generic types

File:

• src/GenPoly/Box.cc (modified) (3 diffs)

src/GenPoly/Box.cc

@@ -70 +70 @@
                   private:
                         void passTypeVars( ApplicationExpr *appExpr, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
+                        /// wraps a function application with a new temporary for the out-parameter return value
                         Expression *addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg );
-                        Expression *addPolyRetParam( ApplicationExpr *appExpr, FunctionType *function, std::string typeName, std::list< Expression *>::iterator &arg );
+                        /// Replaces all the type parameters of a generic type with their concrete equivalents under the current environment
+                        void replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params );
+                        /// Replaces a polymorphic type with its concrete equivalant under the current environment (returns itself if concrete).
+                        /// If `doClone` is set to false, will not clone interior types
+                        Type *replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone = true );
+                        /// wraps a function application returning a polymorphic type with a new temporary for the out-parameter return value
+                        Expression *addPolyRetParam( ApplicationExpr *appExpr, FunctionType *function, ReferenceToType *polyType, std::list< Expression *>::iterator &arg );
                         Expression *applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         void boxParam( Type *formal, Expression *&arg, const TyVarMap &exprTyVars );
@@ -385 +392 @@
                 }
 
-                Expression *Pass1::addPolyRetParam( ApplicationExpr *appExpr, FunctionType *function, std::string typeName, std::list< Expression *>::iterator &arg ) {
-                        ResolvExpr::EqvClass eqvClass;
+                void Pass1::replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params ) {
+                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
+                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
+                                assert(paramType && "Aggregate parameters should be type expressions");
+                                paramType->set_type( replaceWithConcrete( appExpr, paramType->get_type(), false ) );
+                        }
+                }
+                
+                Type *Pass1::replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone ) {
+                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
+                                Type *concrete = env->lookup( typeInst->get_name() );
+                                if ( concrete == 0 ) {
+                                        throw SemanticError( "Unbound type variable " + typeInst->get_name() + " in ", appExpr );
+                                } // if
+                                return concrete;
+                        } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
+                                if ( doClone ) {
+                                        structType = structType->clone();
+                                }
+                                replaceParametersWithConcrete( appExpr, structType->get_parameters() );
+                                return structType;
+                        } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
+                                if ( doClone ) {
+                                        unionType = unionType->clone();
+                                }
+                                replaceParametersWithConcrete( appExpr, unionType->get_parameters() );
+                                return unionType;
+                        }
+                        return type;
+                }
+
+                Expression *Pass1::addPolyRetParam( ApplicationExpr *appExpr, FunctionType *function, ReferenceToType *polyType, std::list< Expression *>::iterator &arg ) {
                         assert( env );
-                        Type *concrete = env->lookup( typeName );
-                        if ( concrete == 0 ) {
-                                throw SemanticError( "Unbound type variable " + typeName + " in ", appExpr );
-                        } // if
+                        Type *concrete = replaceWithConcrete( appExpr, polyType );
                         return addRetParam( appExpr, function, concrete, arg );
                 }
@@ -787 +821 @@
 
                         if ( ReferenceToType *polyType = isPolyRet( function ) ) {
-                                ret = addPolyRetParam( appExpr, function, polyType->get_name(), arg );
+                                ret = addPolyRetParam( appExpr, function, polyType, arg );
                         } else if ( needsAdapter( function, scopeTyVars ) ) {
                                 // std::cerr << "needs adapter: ";