Changeset 0f889a77

Timestamp:

Dec 16, 2015, 3:21:05 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:

7754cde

Parents:

8360977

Message:

Added unfiltered version of isPoly{Type,Ptr}

Location:

src/GenPoly

Files:

• GenPoly.cc (modified) (4 diffs)
• GenPoly.h (modified) (1 diff)

src/GenPoly/GenPoly.cc

@@ -68 +68 @@
 
         namespace {
-                /// Checks a parameter list for polymorphic parameters
+                /// Checks a parameter list for polymorphic parameters; will substitute according to env if present
+                bool hasPolyParams( std::list< Expression* >& params, const TypeSubstitution *env ) {
+                        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");
+                                if ( isPolyType( paramType->get_type(), env ) ) return true;
+                        }
+                        return false;
+                }
+
+                /// Checks a parameter list for polymorphic parameters from tyVars; will substitute according to env if present
                 bool hasPolyParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
                         for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
@@ -78 +88 @@
                 }
         }
+
+        Type *isPolyType( Type *type, const TypeSubstitution *env ) {
+                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
+                        if ( env ) {
+                                if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
+                                        return isPolyType( newType, env );
+                                } // if
+                        } // if
+                        return type;
+                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
+                        if ( hasPolyParams( structType->get_parameters(), env ) ) return type;
+                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
+                        if ( hasPolyParams( unionType->get_parameters(), env ) ) return type;
+                }
+                return 0;
+        }
         
         Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
@@ -84 +110 @@
                                 if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
                                         return isPolyType( newType, tyVars, env );
+                                } // if
                         } // if
-                } // if
                         if ( tyVars.find( typeInst->get_name() ) != tyVars.end() ) {
                                 return type;
-        }
+                        }
                 } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
                         if ( hasPolyParams( structType->get_parameters(), tyVars, env ) ) return type;
@@ -97 +123 @@
         }
 
+        Type *isPolyPtr( Type *type, const TypeSubstitution *env ) {
+                if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
+                        return isPolyType( ptr->get_base(), env );
+                } else if ( env ) {
+                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( type ) ) {
+                                if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
+                                        return isPolyPtr( newType, env );
+                                } // if
+                        } // if
+                } // if
+                return 0;
+        }
+        
         Type *isPolyPtr( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
                 if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {

src/GenPoly/GenPoly.h

@@ -37 +37 @@
 
         /// returns polymorphic type if is polymorphic type, NULL otherwise; will look up substitution in env if provided
+        Type *isPolyType( Type *type, const TypeSubstitution *env = 0 );
+        
+        /// returns polymorphic type if is polymorphic type in tyVars, NULL otherwise; will look up substitution in env if provided
         Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
 
         /// returns polymorphic type if is pointer to polymorphic type, NULL otherwise; will look up substitution in env if provided
+        Type *isPolyPtr( Type *type, const TypeSubstitution *env = 0 );
+        
+        /// returns polymorphic type if is pointer to polymorphic type in tyVars, NULL otherwise; will look up substitution in env if provided
         Type *isPolyPtr( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );