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

File:

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

src/GenPoly/SpecializeNew.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// SpecializeNew.cpp -- Generate thunks to specialize polymorphic functions.
+// SpecializeNew.cpp --
 //
 // 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;
 }
@@ -222 +227 @@
 }
 
-// Restructures arguments to match the structure of the formal parameters
-// of the actual function. Returns the next structured argument.
+// 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
 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::ptr<ast::Type> & t : *tuple ) {
+                for ( const ast::Type * t : *tuple ) {
                         exprs.push_back( structureArg( location, t, begin, end ) );
                 }
@@ -239 +260 @@
         }
 }
-
-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;
-        }
-};
+#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;
+                }
+        };
+}
 
 const ast::Expr * SpecializeCore::createThunkFunction(
@@ -268 +291 @@
                 // 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();
@@ -275 +300 @@
         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");
                 }
@@ -290 +322 @@
                         fixer.core.typeMap[kv->base] = std::make_pair(kv->expr_id, kv->formal_usage);
                 }
-        }
+        } 
 
         ast::CompoundStmt * thunkBody = new ast::CompoundStmt( location );
@@ -313 +345 @@
                 );
 
+        // thunkFunc->accept(fixer);
         thunkFunc->fixUniqueId();
+
+
 
         // Thunks may be generated and not used, avoid them.
@@ -340 +375 @@
                 // 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 ) );
@@ -350 +388 @@
                 argBegin = args.begin(), argEnd = args.end();
         for ( const auto & actualArg : actualType->params ) {
-                app->args.push_back(
-                        structureArg( location, actualArg.get(), argBegin, argEnd ) );
+                structureArg( location, actualArg.get(), argBegin, argEnd,
+                        std::back_inserter( app->args ) );
         }
         assertf( argBegin == argEnd, "Did not structure all arguments." );
@@ -431 +469 @@
         // Create thunks for the inferred parameters.
         // This is not needed for intrinsic calls, because they aren't
-        // 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.
+        // 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.
         ast::ApplicationExpr * mut = handleExplicitParams( expr );
         if ( !mut->inferred.hasParams() ) {
@@ -461 +500 @@
         if ( specialized != expr->arg ) {
                 // Assume that the specialization incorporates the cast.
+                std::cerr << expr <<std::endl;
                 return specialized;
         } else {