Changeset 4f748c5 for src/GenPoly

Timestamp:

Nov 2, 2017, 11:45:10 AM (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:

6de43b6

Parents:

b1e68d03 (diff), fde89cf6 (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 'fix-missing-cast-warning'

Location:

src/GenPoly

Files:

• Box.cc (modified) (6 diffs)
• InstantiateGeneric.cc (modified) (1 diff)
• ScrubTyVars.cc (modified) (1 diff)
• Specialize.cc (modified) (6 diffs)

src/GenPoly/Box.cc

@@ -734 +734 @@
                                 Type * newType = param->clone();
                                 if ( env ) env->apply( newType );
-                                ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
+                                ObjectDecl *newObj = ObjectDecl::newObject( tempNamer.newName(), newType, nullptr );
                                 newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
                                 stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
@@ -745 +745 @@
                 }
 
+                // find instances of polymorphic type parameters
+                struct PolyFinder {
+                        const TyVarMap * tyVars = nullptr;
+                        bool found = false;
+
+                        void previsit( TypeInstType * t ) {
+                                if ( isPolyType( t, *tyVars ) ) {
+                                        found = true;
+                                }
+                        }
+                };
+
+                // true if there is an instance of a polymorphic type parameter in t
+                bool hasPolymorphism( Type * t, const TyVarMap &tyVars ) {
+                        PassVisitor<PolyFinder> finder;
+                        finder.pass.tyVars = &tyVars;
+                        maybeAccept( t, finder );
+                        return finder.pass.found;
+                }
+
                 /// cast parameters to polymorphic functions so that types are replaced with
                 /// void * if they are type parameters in the formal type.
                 /// this gets rid of warnings from gcc.
                 void addCast( Expression *&actual, Type *formal, const TyVarMap &tyVars ) {
-                        if ( getFunctionType( formal ) ) {
+                        // type contains polymorphism, but isn't exactly a polytype, in which case it
+                        // has some real actual type (e.g. unsigned int) and casting to void * is wrong
+                        if ( hasPolymorphism( formal, tyVars ) && ! isPolyType( formal, tyVars ) ) {
                                 Type * newType = formal->clone();
                                 newType = ScrubTyVars::scrub( newType, tyVars );
@@ -757 +779 @@
 
                 void Pass1::boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
-                        for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->get_parameters().end(); ++param, ++arg ) {
-                                assertf( arg != appExpr->get_args().end(), "boxParams: missing argument for param %s to %s in %s", toString( *param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
+                        for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->parameters.end(); ++param, ++arg ) {
+                                assertf( arg != appExpr->args.end(), "boxParams: missing argument for param %s to %s in %s", toString( *param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
                                 addCast( *arg, (*param)->get_type(), exprTyVars );
                                 boxParam( (*param)->get_type(), *arg, exprTyVars );
@@ -767 +789 @@
                         std::list< Expression *>::iterator cur = arg;
                         for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
-                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
+                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) {
                                         InferredParams::const_iterator inferParam = appExpr->get_inferParams().find( (*assert)->get_uniqueId() );
-                                        if ( inferParam == appExpr->get_inferParams().end() ) {
-                                                std::cerr << "looking for assertion: " << (*assert) << std::endl << appExpr << std::endl;
-                                        }
-                                        assertf( inferParam != appExpr->get_inferParams().end(), "NOTE: Explicit casts of polymorphic functions to compatible monomorphic functions are currently unsupported" );
+                                        assertf( inferParam != appExpr->get_inferParams().end(), "addInferredParams missing inferred parameter: %s in: %s", toString( *assert ).c_str(), toString( appExpr ).c_str() );
                                         Expression *newExpr = inferParam->second.expr->clone();
                                         addCast( newExpr, (*assert)->get_type(), tyVars );
@@ -782 +801 @@
 
                 void makeRetParm( FunctionType *funcType ) {
-                        DeclarationWithType *retParm = funcType->get_returnVals().front();
+                        DeclarationWithType *retParm = funcType->returnVals.front();
 
                         // make a new parameter that is a pointer to the type of the old return value
@@ -795 +814 @@
                         // actually make the adapter type
                         FunctionType *adapter = adaptee->clone();
-//                      if ( ! adapter->get_returnVals().empty() && isPolyType( adapter->get_returnVals().front()->get_type(), tyVars ) ) {
                         if ( isDynRet( adapter, tyVars ) ) {
                                 makeRetParm( adapter );

src/GenPoly/InstantiateGeneric.cc

@@ -238 +238 @@
                                         assertf( false, "Ttype parameters are not currently allowed as parameters to generic types." );
                                         break;
-                                case TypeDecl::Any:
-                                        assertf( false, "otype parameters handled by baseParam->isComplete()." );
+                                default:
+                                        assertf( false, "Unhandled type parameter kind" );
                                         break;
                         }

src/GenPoly/ScrubTyVars.cc

@@ -40 +40 @@
                 if ( tyVar != tyVars->end() ) {
                         switch ( tyVar->second.kind ) {
-                          case TypeDecl::Any:
                           case TypeDecl::Dtype:
                           case TypeDecl::Ttype:

src/GenPoly/Specialize.cc

@@ -45 +45 @@
         struct Specialize final : public WithTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef<Specialize> {
                 Expression * postmutate( ApplicationExpr *applicationExpr );
-                Expression * postmutate( AddressExpr *castExpr );
                 Expression * postmutate( CastExpr *castExpr );
 
                 void handleExplicitParams( ApplicationExpr *appExpr );
                 Expression * createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams );
-                Expression * doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams = nullptr );
+                Expression * doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams );
 
                 std::string paramPrefix = "_p";
@@ -67 +66 @@
                                 if ( ! boundType ) continue;
                                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( boundType ) ) {
+                                        // bound to another type variable
                                         if ( closedVars.find( typeInst->get_name() ) == closedVars.end() ) {
+                                                // bound to a closed variable => must specialize
                                                 return true;
                                         } // if
                                 } else {
+                                        // variable is bound to a concrete type => must specialize
                                         return true;
                                 } // if
                         } // for
+                        // none of the type variables are bound
                         return false;
                 } else {
+                        // no env
                         return false;
                 } // if
@@ -131 +135 @@
                         if ( functionParameterSize( fftype ) != functionParameterSize( aftype ) ) return false;
                         // tuple-parameter sizes are the same, but actual parameter sizes differ - must tuple specialize
-                        if ( fftype->get_parameters().size() != aftype->get_parameters().size() ) return true;
+                        if ( fftype->parameters.size() != aftype->parameters.size() ) return true;
                         // total parameter size can be the same, while individual parameters can have different structure
-                        for ( auto params : group_iterate( fftype->get_parameters(), aftype->get_parameters() ) ) {
+                        for ( auto params : group_iterate( fftype->parameters, aftype->parameters ) ) {
                                 DeclarationWithType * formal = std::get<0>(params);
                                 DeclarationWithType * actual = std::get<1>(params);
@@ -150 +154 @@
                 if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
                         if ( FunctionType *funType = getFunctionType( formalType ) ) {
-                                ApplicationExpr *appExpr;
-                                VariableExpr *varExpr;
-                                if ( ( appExpr = dynamic_cast<ApplicationExpr*>( actual ) ) ) {
+                                if ( ApplicationExpr * appExpr = dynamic_cast<ApplicationExpr*>( actual ) ) {
                                         return createThunkFunction( funType, appExpr->get_function(), inferParams );
-                                } else if ( ( varExpr = dynamic_cast<VariableExpr*>( actual ) ) ) {
+                                } else if ( VariableExpr * varExpr = dynamic_cast<VariableExpr*>( actual ) ) {
                                         return createThunkFunction( funType, varExpr, inferParams );
                                 } else {
@@ -323 +325 @@
         }
 
-        Expression * Specialize::postmutate( AddressExpr *addrExpr ) {
-                assert( addrExpr->result );
-                addrExpr->set_arg( doSpecialization( addrExpr->result, addrExpr->arg ) );
-                return addrExpr;
-        }
-
         Expression * Specialize::postmutate( CastExpr *castExpr ) {
                 if ( castExpr->result->isVoid() ) {
@@ -334 +330 @@
                         return castExpr;
                 }
-                Expression *specialized = doSpecialization( castExpr->result, castExpr->arg );
+                Expression *specialized = doSpecialization( castExpr->result, castExpr->arg, &castExpr->inferParams );
                 if ( specialized != castExpr->arg ) {
                         // assume here that the specialization incorporates the cast