Changes in src/GenPoly/SpecializeNew.cpp [9e23b446:c36814a]

File:

• src/GenPoly/SpecializeNew.cpp (modified) (12 diffs)

src/GenPoly/SpecializeNew.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// SpecializeNew.cpp --
+// SpecializeNew.cpp -- Generate thunks to specialize polymorphic functions.
 //
 // Author           : Andrew Beach
@@ -201 +201 @@
                         *formal, *actual, getInferredParams( expr ) );
         }
-        //for ( auto pair : group_iterate( formal->params, mut->args ) ) {
-        //      const ast::ptr<ast::Type> & formal = std::get<0>( pair );
-        //      ast::ptr<ast::Expr> & actual = std::get<1>( pair );
-        //      *actual = doSpecialization( (*actual)->location, *formal, *actual, getInferredParams( expr ) );
-        //}
         return mut;
 }
@@ -227 +222 @@
 }
 
-// Restructures the arguments to match the structure of the formal parameters
-// of the actual function. [begin, end) are the exploded arguments.
-template<typename Iterator, typename OutIterator>
-void structureArg( const CodeLocation & location, const ast::Type * type,
-                Iterator & begin, Iterator end, OutIterator out ) {
-        if ( auto tuple = dynamic_cast<const ast::TupleType *>( type ) ) {
-                std::vector<ast::ptr<ast::Expr>> exprs;
-                for ( const ast::Type * t : *tuple ) {
-                        structureArg( location, t, begin, end, std::back_inserter( exprs ) );
-                }
-                *out++ = new ast::TupleExpr( location, std::move( exprs ) );
-        } else {
-                assertf( begin != end, "reached the end of the arguments while structuring" );
-                *out++ = *begin++;
-        }
-}
-
-#if 0
+// Restructures arguments to match the structure of the formal parameters
+// of the actual function. Returns the next structured argument.
 template<typename Iterator>
 const ast::Expr * structureArg(
                 const CodeLocation& location, const ast::ptr<ast::Type> & type,
                 Iterator & begin, const Iterator & end ) {
-        if ( auto tuple = type->as<ast::TupleType>() ) {
+        if ( auto tuple = type.as<ast::TupleType>() ) {
                 std::vector<ast::ptr<ast::Expr>> exprs;
-                for ( const ast::Type * t : *tuple ) {
+                for ( const ast::ptr<ast::Type> & t : *tuple ) {
                         exprs.push_back( structureArg( location, t, begin, end ) );
                 }
@@ -260 +239 @@
         }
 }
-#endif
-
-namespace {
-        struct TypeInstFixer : public ast::WithShortCircuiting {
-                std::map<const ast::TypeDecl *, std::pair<int, int>> typeMap;
-
-                void previsit(const ast::TypeDecl *) { visit_children = false; }
-                const ast::TypeInstType * postvisit(const ast::TypeInstType * typeInst) {
-                        if (typeMap.count(typeInst->base)) {
-                                ast::TypeInstType * newInst = mutate(typeInst);
-                                newInst->expr_id = typeMap[typeInst->base].first;
-                                newInst->formal_usage = typeMap[typeInst->base].second;
-                                return newInst;
-                        }
-                        return typeInst;
-                }
-        };
-}
+
+struct TypeInstFixer final : public ast::WithShortCircuiting {
+        std::map<const ast::TypeDecl *, std::pair<int, int>> typeMap;
+
+        void previsit(const ast::TypeDecl *) { visit_children = false; }
+        const ast::TypeInstType * postvisit(const ast::TypeInstType * typeInst) {
+                if (typeMap.count(typeInst->base)) {
+                        ast::TypeInstType * newInst = mutate(typeInst);
+                        auto const & pair = typeMap[typeInst->base];
+                        newInst->expr_id = pair.first;
+                        newInst->formal_usage = pair.second;
+                        return newInst;
+                }
+                return typeInst;
+        }
+};
 
 const ast::Expr * SpecializeCore::createThunkFunction(
@@ -291 +268 @@
                 // Must replace only occurrences of type variables
                 // that occure free in the thunk's type.
-                //ast::TypeSubstitution::ApplyResult<ast::FunctionType>
-                //      typeSubs->applyFree( newType );
                 auto result = typeSubs->applyFree( newType );
                 newType = result.node.release();
@@ -300 +275 @@
         using DeclVector = std::vector<ast::ptr<ast::TypeDecl>>;
 
-        //const std::string & thunkName = thunkNamer.newName();
-        //UniqueName paramNamer(thunkName + "Param");
         UniqueName paramNamer( paramPrefix );
 
-        //auto toParamDecl = [&location, &paramNamer]( const ast::Type * type ) {
-        //      return new ast::ObjectDecl(
-        //              location, paramNamer.newName(), ast::deepCopy( type ) );
-        //};
-
         // Create new thunk with same signature as formal type.
-
-        // std::map<const ast::TypeDecl *, std::pair<int, int>> typeMap;
         ast::Pass<TypeInstFixer> fixer;
         for (const auto & kv : newType->forall) {
                 if (fixer.core.typeMap.count(kv->base)) {
-                        std::cerr << location << ' ' << kv->base->name << ' ' << kv->expr_id << '_' << kv->formal_usage << ',' 
-                        << fixer.core.typeMap[kv->base].first << '_' << fixer.core.typeMap[kv->base].second << std::endl;
+                        std::cerr << location << ' ' << kv->base->name
+                                << ' ' << kv->expr_id << '_' << kv->formal_usage
+                                << ',' << fixer.core.typeMap[kv->base].first
+                                << '_' << fixer.core.typeMap[kv->base].second << std::endl;
                         assertf(false, "multiple formals in specialize");
                 }
@@ -322 +290 @@
                         fixer.core.typeMap[kv->base] = std::make_pair(kv->expr_id, kv->formal_usage);
                 }
-        } 
+        }
 
         ast::CompoundStmt * thunkBody = new ast::CompoundStmt( location );
@@ -345 +313 @@
                 );
 
-        // thunkFunc->accept(fixer);
         thunkFunc->fixUniqueId();
-
-
 
         // Thunks may be generated and not used, avoid them.
@@ -375 +340 @@
                 // Name each thunk parameter and explode it.
                 // These are then threaded back into the actual function call.
-                //param->name = paramNamer.newName();
                 ast::DeclWithType * mutParam = ast::mutate( param.get() );
-                // - Should be renamed earlier. -
-                //mutParam->name = paramNamer.newName();
                 explodeSimple( location, new ast::VariableExpr( location, mutParam ),
                         std::back_inserter( args ) );
@@ -388 +350 @@
                 argBegin = args.begin(), argEnd = args.end();
         for ( const auto & actualArg : actualType->params ) {
-                structureArg( location, actualArg.get(), argBegin, argEnd,
-                        std::back_inserter( app->args ) );
+                app->args.push_back(
+                        structureArg( location, actualArg.get(), argBegin, argEnd ) );
         }
         assertf( argBegin == argEnd, "Did not structure all arguments." );
@@ -469 +431 @@
         // Create thunks for the inferred parameters.
         // This is not needed for intrinsic calls, because they aren't
-        // actually passed
-        //
-        // need to handle explicit params before inferred params so that
-        // explicit params do not recieve a changed set of inferParams (and
-        // change them again) alternatively, if order starts to matter then
-        // copy appExpr's inferParams and pass them to handleExplicitParams.
+        // actually passed to the function. It needs to handle explicit params
+        // before inferred params so that explicit params do not recieve a
+        // changed set of inferParams (and change them again).
+        // Alternatively, if order starts to matter then copy expr's inferParams
+        // and pass them to handleExplicitParams.
         ast::ApplicationExpr * mut = handleExplicitParams( expr );
         if ( !mut->inferred.hasParams() ) {
@@ -500 +461 @@
         if ( specialized != expr->arg ) {
                 // Assume that the specialization incorporates the cast.
-                std::cerr << expr <<std::endl;
                 return specialized;
         } else {