Changeset f6aa89c for src/GenPoly/Box.cc

Timestamp:

Nov 3, 2022, 10:27:45 AM (20 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, ast-experimental, master

Children:

7ed7b4a

Parents:

7cf8006

Message:

Cleaning old box pass for easier translation. Isolated the replaceWithConcrete helpers.

File:

• src/GenPoly/Box.cc (modified) (8 diffs)

src/GenPoly/Box.cc

@@ -100 +100 @@
                         /// wraps a function application with a new temporary for the out-parameter return value
                         Expression *addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg );
-                        /// Replaces all the type parameters of a generic type with their concrete equivalents under the current environment
-                        void replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params );
-                        /// Replaces a polymorphic type with its concrete equivalant under the current environment (returns itself if concrete).
-                        /// If `doClone` is set to false, will not clone interior types
-                        Type *replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone = true );
                         /// wraps a function application returning a polymorphic type with a new temporary for the out-parameter return value
                         Expression *addDynRetParam( ApplicationExpr *appExpr, Type *polyType, std::list< Expression *>::iterator &arg );
@@ -450 +445 @@
                 }
 
+                /// Replaces a polymorphic type with its concrete equivalant under the current environment (returns itself if concrete).
+                /// If `doClone` is set to false, will not clone interior types
+                Type *replaceWithConcrete( Type *type, TypeSubstitution const * env, bool doClone = true );
+
                 Pass1::Pass1() : tempNamer( "_temp" ) {}
 
@@ -572 +571 @@
                         // a polymorphic return type may need to be added to the argument list
                         if ( polyRetType ) {
-                                Type *concRetType = replaceWithConcrete( appExpr, polyRetType );
+                                Type *concRetType = replaceWithConcrete( polyRetType, env );
                                 passArgTypeVars( appExpr, polyRetType, concRetType, arg, exprTyVars, seenTypes );
                                 ++fnArg; // skip the return parameter in the argument list
@@ -620 +619 @@
                 }
 
-                void Pass1::replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params ) {
+                /// Replaces all the type parameters of a generic type with their concrete equivalents under the current environment
+                void replaceParametersWithConcrete( std::list< Expression* >& params, TypeSubstitution const * env ) {
                         for ( Expression * const param : params ) {
                                 TypeExpr *paramType = dynamic_cast< TypeExpr* >( param );
                                 assertf(paramType, "Aggregate parameters should be type expressions");
-                                paramType->set_type( replaceWithConcrete( appExpr, paramType->get_type(), false ) );
-                        }
-                }
-
-                Type *Pass1::replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone ) {
+                                paramType->set_type( replaceWithConcrete( paramType->get_type(), env, false ) );
+                        }
+                }
+
+                // See forward definition.
+                Type *replaceWithConcrete( Type *type, TypeSubstitution const * env, bool doClone ) {
                         if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
                                 Type *concrete = env->lookup( typeInst->get_name() );
@@ -639 +640 @@
                                         structType = structType->clone();
                                 }
-                                replaceParametersWithConcrete( appExpr, structType->get_parameters() );
+                                replaceParametersWithConcrete( structType->get_parameters(), env );
                                 return structType;
                         } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
@@ -645 +646 @@
                                         unionType = unionType->clone();
                                 }
-                                replaceParametersWithConcrete( appExpr, unionType->get_parameters() );
+                                replaceParametersWithConcrete( unionType->get_parameters(), env );
                                 return unionType;
                         }
@@ -653 +654 @@
                 Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, Type *dynType, std::list< Expression *>::iterator &arg ) {
                         assert( env );
-                        Type *concrete = replaceWithConcrete( appExpr, dynType );
+                        Type *concrete = replaceWithConcrete( dynType, env );
                         // add out-parameter for return value
                         return addRetParam( appExpr, concrete, arg );
@@ -1115 +1116 @@
                         arg = appExpr->get_args().begin();
 
-                        Type *concRetType = replaceWithConcrete( appExpr, dynRetType );
+                        Type *concRetType = replaceWithConcrete( dynRetType, env );
                         passTypeVars( appExpr, concRetType, arg, exprTyVars ); // xxx - used to use dynRetType instead of concRetType; this changed so that the correct type paramaters are passed for return types (it should be the concrete type's parameters, not the formal type's)
                         addInferredParams( appExpr, function, arg, exprTyVars );