Changeset aadc9a4

Timestamp:

Jan 12, 2016, 6:12:10 PM (9 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:

4d7e8f5

Parents:

ebe9b3a

Message:

Refactor isPolyRet to include generic return types

Location:

src/GenPoly

Files:

• Box.cc (modified) (3 diffs)
• GenPoly.cc (modified) (2 diffs)
• GenPoly.h (modified) (3 diffs)
• PolyMutator.cc (modified) (1 diff)
• PolyMutator.h (modified) (1 diff)

src/GenPoly/Box.cc

@@ -231 +231 @@
                                 // process polymorphic return value
                                 retval = 0;
-                                std::string typeName;
-                                if ( isPolyRet( functionDecl->get_functionType(), typeName ) && functionDecl->get_linkage() == LinkageSpec::Cforall ) {
+                                if ( isPolyRet( functionDecl->get_functionType() ) && functionDecl->get_linkage() == LinkageSpec::Cforall ) {
                                         retval = functionDecl->get_functionType()->get_returnVals().front();
 
@@ -787 +786 @@
                         std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
 
-                        std::string typeName;
-                        if ( isPolyRet( function, typeName ) ) {
-                                ret = addPolyRetParam( appExpr, function, typeName, arg );
+                        if ( ReferenceToType *polyType = isPolyRet( function ) ) {
+                                ret = addPolyRetParam( appExpr, function, polyType->get_name(), arg );
                         } else if ( needsAdapter( function, scopeTyVars ) ) {
                                 // std::cerr << "needs adapter: ";
@@ -994 +992 @@
 
                         // move polymorphic return type to parameter list
-                        std::string typeName;
-                        if ( isPolyRet( funcType, typeName ) ) {
+                        if ( isPolyRet( funcType ) ) {
                                 DeclarationWithType *ret = funcType->get_returnVals().front();
                                 ret->set_type( new PointerType( Type::Qualifiers(), ret->get_type() ) );

src/GenPoly/GenPoly.cc

@@ -36 +36 @@
         }
 
-        bool isPolyRet( FunctionType *function, std::string &name, const TyVarMap &otherTyVars ) {
-                bool doTransform = false;
+        ReferenceToType *isPolyRet( FunctionType *function ) {
                 if ( ! function->get_returnVals().empty() ) {
-                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( function->get_returnVals().front()->get_type() ) ) {
-        
-                                // figure out if the return type is specified by a type parameter
-                                for ( std::list< TypeDecl *>::const_iterator tyVar = function->get_forall().begin(); tyVar != function->get_forall().end(); ++tyVar ) {
-                                        if ( (*tyVar)->get_name() == typeInst->get_name() ) {
-                                                doTransform = true;
-                                                name = typeInst->get_name();
-                                                break;
-                                        } // if
-                                } // for
-                                if ( ! doTransform && otherTyVars.find( typeInst->get_name() ) != otherTyVars.end() ) {
-                                        doTransform = true;
-                                } // if
-                        } // if
+                        TyVarMap forallTypes;
+                        makeTyVarMap( function, forallTypes );
+                        return (ReferenceToType*)isPolyType( function->get_returnVals().front()->get_type(), forallTypes );
                 } // if
-                return doTransform;
-        }
-
-        bool isPolyRet( FunctionType *function, std::string &name ) {
-                TyVarMap dummyTyVars;
-                return isPolyRet( function, name, dummyTyVars );
-        }
-
-        bool isPolyRet( FunctionType *function, const TyVarMap &otherTyVars ) {
-                std::string dummyString;
-                return isPolyRet( function, dummyString, otherTyVars );
+                return 0;
         }
 
@@ -158 +136 @@
         }
 
+        void makeTyVarMap( Type *type, TyVarMap &tyVarMap ) {
+                for ( std::list< TypeDecl* >::const_iterator tyVar = type->get_forall().begin(); tyVar != type->get_forall().end(); ++tyVar ) {
+                        assert( *tyVar );
+                        tyVarMap[ (*tyVar)->get_name() ] = (*tyVar)->get_kind();
+                }
+                if ( PointerType *pointer = dynamic_cast< PointerType* >( type ) ) {
+                        makeTyVarMap( pointer->get_base(), tyVarMap );
+                }
+        }
+        
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap ) {
                 for ( TyVarMap::const_iterator i = tyVarMap.begin(); i != tyVarMap.end(); ++i ) {

src/GenPoly/GenPoly.h

@@ -22 +22 @@
 
 #include "SynTree/Declaration.h"
+#include "SynTree/Type.h"
 #include "SynTree/TypeSubstitution.h"
 
@@ -32 +33 @@
 
         /// true iff function has polymorphic return type
-        bool isPolyRet( FunctionType *function, std::string &name, const TyVarMap &otherTyVars );
-        bool isPolyRet( FunctionType *function, std::string &name );
-        bool isPolyRet( FunctionType *function, const TyVarMap &otherTyVars );
+        ReferenceToType *isPolyRet( FunctionType *function );
 
         /// returns polymorphic type if is polymorphic type, NULL otherwise; will look up substitution in env if provided
@@ -51 +50 @@
         FunctionType * getFunctionType( Type *ty );
 
+        /// 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 );
+        
         /// Prints type variable map
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap );

src/GenPoly/PolyMutator.cc

@@ -152 +152 @@
         }
 
-
-        /* static class method */
-        void PolyMutator::makeTyVarMap( Type *type, TyVarMap &tyVarMap ) {
-                for ( std::list< TypeDecl* >::const_iterator tyVar = type->get_forall().begin(); tyVar != type->get_forall().end(); ++tyVar ) {
-                        assert( *tyVar );
-                        tyVarMap[ (*tyVar)->get_name() ] = (*tyVar)->get_kind();
-                }
-                if ( PointerType *pointer = dynamic_cast< PointerType* >( type ) ) {
-                        makeTyVarMap( pointer->get_base(), tyVarMap );
-                }
-        }
 } // namespace GenPoly
 

src/GenPoly/PolyMutator.h

@@ -51 +51 @@
                 virtual void doBeginScope() {}
                 virtual void doEndScope() {}
-                
-                static void makeTyVarMap( Type *type, TyVarMap &tyVarMap );
           protected:
                 void mutateStatementList( std::list< Statement* > &statements );