Changeset 265e460 for src/GenPoly/GenPoly.cc

Timestamp:

Oct 8, 2022, 9:43:21 AM (3 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master

Children:

b2ddaf3

Parents:

815943f (diff), d8c96a9 (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 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/GenPoly/GenPoly.cc (modified) (14 diffs)

src/GenPoly/GenPoly.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Sep 14  9:24:00 2022
-// Update Count     : 15
+// Last Modified On : Fri Oct  7 15:25:00 2022
+// Update Count     : 16
 //
 
@@ -64 +64 @@
                 }
 
-                __attribute__((unused))
-                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
-                        for (auto &param : params) {
-                                auto paramType = param.strict_as<ast::TypeExpr>();
-                                if (isPolyType(paramType->type, tyVars, env)) return true;
-                        }
-                        return false;
-                }
-
                 /// Checks a parameter list for dynamic-layout parameters from tyVars; will substitute according to env if present
                 bool hasDynParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
@@ -83 +74 @@
                 }
 
-                bool hasDynParams( const std::vector<ast::ptr<ast::Expr>> & params, const TyVarMap &tyVars, const ast::TypeSubstitution *typeSubs ) {
-                        for ( ast::ptr<ast::Expr> const & param : params ) {
-                                auto paramType = param.as<ast::TypeExpr>();
-                                assertf( paramType, "Aggregate parameters should be type expressions." );
-                                if ( isDynType( paramType->type, tyVars, typeSubs ) ) {
+                bool hasDynParams(
+                                const std::vector<ast::ptr<ast::Expr>> & params,
+                                const TypeVarMap & typeVars,
+                                const ast::TypeSubstitution * subst ) {
+                        for ( ast::ptr<ast::Expr> const & paramExpr : params ) {
+                                auto param = paramExpr.as<ast::TypeExpr>();
+                                assertf( param, "Aggregate parameters should be type expressions." );
+                                if ( isDynType( param->type.get(), typeVars, subst ) ) {
                                         return true;
                                 }
@@ -195 +189 @@
         }
 
+const ast::Type * isPolyType( const ast::Type * type,
+                const TypeVarMap & typeVars, const ast::TypeSubstitution * subst ) {
+        type = replaceTypeInst( type, subst );
+
+        if ( auto inst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
+                if ( typeVars.find( inst->typeString() ) != typeVars.end() ) return type;
+        } else if ( auto array = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                return isPolyType( array->base, subst );
+        } else if ( auto sue = dynamic_cast< const ast::StructInstType * >( type ) ) {
+                if ( hasPolyParams( sue->params, subst ) ) return type;
+        } else if ( auto sue = dynamic_cast< const ast::UnionInstType * >( type ) ) {
+                if ( hasPolyParams( sue->params, subst ) ) return type;
+        }
+        return nullptr;
+}
+
         ReferenceToType *isDynType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
                 type = replaceTypeInst( type, env );
@@ -211 +221 @@
         }
 
-        const ast::BaseInstType *isDynType( const ast::Type *type, const TyVarMap &tyVars, const ast::TypeSubstitution *typeSubs ) {
-                type = replaceTypeInst( type, typeSubs );
-
-                if ( auto inst = dynamic_cast<ast::TypeInstType const *>( type ) ) {
-                        auto var = tyVars.find( inst->name );
-                        if ( var != tyVars.end() && var->second.isComplete ) {
-                                return inst;
-                        }
-                } else if ( auto inst = dynamic_cast<ast::StructInstType const *>( type ) ) {
-                        if ( hasDynParams( inst->params, tyVars, typeSubs ) ) {
-                                return inst;
-                        }
-                } else if ( auto inst = dynamic_cast<ast::UnionInstType const *>( type ) ) {
-                        if ( hasDynParams( inst->params, tyVars, typeSubs ) ) {
-                                return inst;
-                        }
-                }
-                return nullptr;
-        }
+const ast::BaseInstType * isDynType(
+                const ast::Type * type, const TypeVarMap & typeVars,
+                const ast::TypeSubstitution * subst ) {
+        type = replaceTypeInst( type, subst );
+
+        if ( auto inst = dynamic_cast<ast::TypeInstType const *>( type ) ) {
+                auto var = typeVars.find( inst->name );
+                if ( var != typeVars.end() && var->second.isComplete ) {
+
+                }
+        } else if ( auto inst = dynamic_cast<ast::StructInstType const *>( type ) ) {
+                if ( hasDynParams( inst->params, typeVars, subst ) ) {
+                        return inst;
+                }
+        } else if ( auto inst = dynamic_cast<ast::UnionInstType const *>( type ) ) {
+                if ( hasDynParams( inst->params, typeVars, subst ) ) {
+                        return inst;
+                }
+        }
+        return nullptr;
+}
 
         ReferenceToType *isDynRet( FunctionType *function, const TyVarMap &forallTypes ) {
@@ -236 +248 @@
                 return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes );
         }
+
+const ast::BaseInstType *isDynRet(
+                const ast::FunctionType * type, const TypeVarMap & typeVars ) {
+        if ( type->returns.empty() ) return nullptr;
+
+        return isDynType( type->returns.front(), typeVars );
+}
 
         ReferenceToType *isDynRet( FunctionType *function ) {
@@ -260 +279 @@
         }
 
+bool needsAdapter(
+                ast::FunctionType const * adaptee, const TypeVarMap & typeVars ) {
+        if ( isDynRet( adaptee, typeVars ) ) return true;
+
+        for ( auto param : adaptee->params ) {
+                if ( isDynType( param, typeVars ) ) {
+                        return true;
+                }
+        }
+        return false;
+}
+
         Type *isPolyPtr( Type *type, const TypeSubstitution *env ) {
                 type = replaceTypeInst( type, env );
@@ -311 +342 @@
                 return isPolyType( type, tyVars, env );
         }
+
+ast::Type const * hasPolyBase(
+                ast::Type const * type, const TypeVarMap & typeVars,
+                int * levels, const ast::TypeSubstitution * subst ) {
+        int level_count = 0;
+
+        while ( true ) {
+                type = replaceTypeInst( type, subst );
+
+                if ( auto ptr = dynamic_cast<ast::PointerType const *>( type ) ) {
+                        type = ptr->base;
+                        ++level_count;
+                } else {
+                        break;
+                }
+        }
+
+        if ( nullptr != levels ) { *levels = level_count; }
+        return isPolyType( type, typeVars, subst );
+}
 
         bool includesPolyType( Type *type, const TypeSubstitution *env ) {
@@ -685 +736 @@
 }
 
-        namespace {
-                // temporary hack to avoid re-implementing anything related to TyVarMap
-                // does this work? these two structs have identical definitions.
-                inline TypeDecl::Data convData(const ast::TypeDecl::Data & data) {
-                        return *reinterpret_cast<const TypeDecl::Data *>(&data);
-                }
-        }
-
         bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env ) {
                 // is parameter is not polymorphic, don't need to box
@@ -703 +746 @@
         }
 
-        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const TyVarMap &exprTyVars, const ast::TypeSubstitution * env) {
-                // is parameter is not polymorphic, don't need to box
-                if ( ! isPolyType( param, exprTyVars ) ) return false;
-                ast::ptr<ast::Type> newType = arg;
-                if ( env ) env->apply( newType );
-                // if the argument's type is polymorphic, we don't need to box again!
-                return ! isPolyType( newType );
-        }
+bool needsBoxing( const ast::Type * param, const ast::Type * arg,
+                const TypeVarMap & typeVars, const ast::TypeSubstitution * subst ) {
+        // Don't need to box if the parameter is not polymorphic.
+        if ( !isPolyType( param, typeVars ) ) return false;
+
+        ast::ptr<ast::Type> newType = arg;
+        if ( subst ) {
+                int count = subst->apply( newType );
+                (void)count;
+        }
+        // Only need to box if the argument is not also polymorphic.
+        return !isPolyType( newType );
+}
 
         bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env ) {
@@ -720 +768 @@
         }
 
-        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const ast::ApplicationExpr * appExpr, const ast::TypeSubstitution * env) {
-                const ast::FunctionType * function = getFunctionType(appExpr->func->result);
-                assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->func->result ).c_str() );
-                TyVarMap exprTyVars(TypeDecl::Data{});
-                makeTyVarMap(function, exprTyVars);
-                return needsBoxing(param, arg, exprTyVars, env);
-
-        }
+bool needsBoxing(
+                const ast::Type * param, const ast::Type * arg,
+                const ast::ApplicationExpr * expr,
+                const ast::TypeSubstitution * subst ) {
+        const ast::FunctionType * function = getFunctionType( expr->func->result );
+        assertf( function, "ApplicationExpr has non-function type: %s", toString( expr->func->result ).c_str() );
+        TypeVarMap exprTyVars = { ast::TypeDecl::Data() };
+        makeTypeVarMap( function, exprTyVars );
+        return needsBoxing( param, arg, exprTyVars, subst );
+}
 
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
@@ -733 +783 @@
         }
 
-        void addToTyVarMap( const ast::TypeInstType * tyVar, TyVarMap & tyVarMap) {
-                tyVarMap.insert(tyVar->typeString(), convData(ast::TypeDecl::Data{tyVar->base}));
-        }
+void addToTypeVarMap( const ast::TypeInstType * type, TypeVarMap & typeVars ) {
+        typeVars.insert( type->typeString(), ast::TypeDecl::Data( type->base ) );
+}
 
         void makeTyVarMap( Type *type, TyVarMap &tyVarMap ) {
@@ -747 +797 @@
         }
 
-        void makeTyVarMap(const ast::Type * type, TyVarMap & tyVarMap) {
-                if (auto ptype = dynamic_cast<const ast::FunctionType *>(type)) {
-                        for (auto & tyVar : ptype->forall) {
-                                assert (tyVar);
-                                addToTyVarMap(tyVar, tyVarMap);
-                        }
-                }
-                if (auto pointer = dynamic_cast<const ast::PointerType *>(type)) {
-                        makeTyVarMap(pointer->base, tyVarMap);
-                }
-        }
+void makeTypeVarMap( const ast::Type * type, TypeVarMap & typeVars ) {
+        if ( auto func = dynamic_cast<ast::FunctionType const *>( type ) ) {
+                for ( auto & typeVar : func->forall ) {
+                        assert( typeVar );
+                        addToTypeVarMap( typeVar, typeVars );
+                }
+        }
+        if ( auto pointer = dynamic_cast<ast::PointerType const *>( type ) ) {
+                makeTypeVarMap( pointer->base, typeVars );
+        }
+}
 
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap ) {
@@ -766 +816 @@
         }
 
+void printTypeVarMap( std::ostream &os, const TypeVarMap & typeVars ) {
+        for ( auto const & pair : typeVars ) {
+                os << pair.first << " (" << pair.second << ") ";
+        } // for
+        os << std::endl;
+}
+
 } // namespace GenPoly