Changeset 4573e3c

Timestamp:

Oct 25, 2017, 4:31:58 PM (7 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:

b226721

Parents:

13a6154

Message:

Fix pointer cast warning

File:

• src/GenPoly/Box.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 );