Changeset c532847 for src/GenPoly/GenPoly.cc

Timestamp:

Oct 24, 2020, 9:42:38 AM (4 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

a3f36dc

Parents:

76d73fc (diff), e7d6968 (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) (9 diffs)

src/GenPoly/GenPoly.cc

@@ -46 +46 @@
                 }
 
+                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const ast::TypeSubstitution * env) {
+                        for (auto &param : params) {
+                                auto paramType = param.strict_as<ast::TypeExpr>();
+                                if (isPolyType(paramType->type, env)) return true;
+                        }
+                        return false;
+                }
+
                 /// Checks a parameter list for polymorphic parameters from tyVars; will substitute according to env if present
                 bool hasPolyParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
@@ -56 +64 @@
                 }
 
+                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 ) {
@@ -92 +108 @@
                         Type *newType = env->lookup( typeInst->get_name() );
                         if ( newType ) return newType;
+                }
+                return type;
+        }
+
+        const ast::Type * replaceTypeInst(const ast::Type * type, const ast::TypeSubstitution * env) {
+                if (!env) return type;
+                if (auto typeInst = dynamic_cast<const ast::TypeInstType*> (type)) {
+                        auto newType = env->lookup(typeInst->name);
+                        if (newType) return newType;
                 }
                 return type;
@@ -111 +136 @@
         }
 
+        const ast::Type * isPolyType(const ast::Type * type, const ast::TypeSubstitution * env) {
+                type = replaceTypeInst( type, env );
+
+                if ( dynamic_cast< const ast::TypeInstType * >( type ) ) {
+                        return type;
+                } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        return isPolyType( arrayType->base, env );
+                } else if ( auto structType = dynamic_cast< const ast::StructInstType* >( type ) ) {
+                        if ( hasPolyParams( structType->params, env ) ) return type;
+                } else if ( auto unionType = dynamic_cast< const ast::UnionInstType* >( type ) ) {
+                        if ( hasPolyParams( unionType->params, env ) ) return type;
+                }
+                return 0;
+        }
+
         Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
                 type = replaceTypeInst( type, env );
@@ -126 +166 @@
                 }
                 return 0;
+        }
+
+        const ast::Type * isPolyType(const ast::Type * type, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
+                type = replaceTypeInst( type, env );
+
+                if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
+                        return tyVars.find(typeInst->name) != tyVars.end() ? type : nullptr;
+                } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        return isPolyType( arrayType->base, env );
+                } else if ( auto structType = dynamic_cast< const ast::StructInstType* >( type ) ) {
+                        if ( hasPolyParams( structType->params, env ) ) return type;
+                } else if ( auto unionType = dynamic_cast< const ast::UnionInstType* >( type ) ) {
+                        if ( hasPolyParams( unionType->params, env ) ) return type;
+                }
+                return nullptr;
         }
 
@@ -449 +504 @@
         }
 
+        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
@@ -459 +522 @@
         }
 
+        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( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env ) {
                 FunctionType * function = getFunctionType( appExpr->function->result );
@@ -467 +539 @@
         }
 
+        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);
+
+        }
+
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
                 tyVarMap.insert( tyVar->name, TypeDecl::Data{ tyVar } );
+        }
+
+        void addToTyVarMap( const ast::TypeDecl * tyVar, TyVarMap & tyVarMap) {
+                tyVarMap.insert(tyVar->name, convData(ast::TypeDecl::Data{tyVar}));
         }
 
@@ -478 +563 @@
                 if ( PointerType *pointer = dynamic_cast< PointerType* >( type ) ) {
                         makeTyVarMap( pointer->get_base(), tyVarMap );
+                }
+        }
+
+        void makeTyVarMap(const ast::Type * type, TyVarMap & tyVarMap) {
+                if (auto ptype = dynamic_cast<const ast::ParameterizedType *>(type)) {
+                        for (auto & tyVar : ptype->forall) {
+                                assert (tyVar);
+                                addToTyVarMap(tyVar, tyVarMap);
+                        }
+                }
+                if (auto pointer = dynamic_cast<const ast::PointerType *>(type)) {
+                        makeTyVarMap(pointer->base, tyVarMap);
                 }
         }