Changeset 121ac13 for src/GenPoly/Specialize.cc

Timestamp:

Nov 6, 2017, 10:28:17 AM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

bbeb908

Parents:

59a0bde (diff), 9f4524b (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/Specialize.cc (modified) (6 diffs)

src/GenPoly/Specialize.cc

@@ -45 +45 @@
         struct Specialize final : public WithTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef<Specialize> {
                 Expression * postmutate( ApplicationExpr *applicationExpr );
-                Expression * postmutate( AddressExpr *castExpr );
                 Expression * postmutate( CastExpr *castExpr );
 
                 void handleExplicitParams( ApplicationExpr *appExpr );
                 Expression * createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams );
-                Expression * doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams = nullptr );
+                Expression * doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams );
 
                 std::string paramPrefix = "_p";
@@ -67 +66 @@
                                 if ( ! boundType ) continue;
                                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( boundType ) ) {
+                                        // bound to another type variable
                                         if ( closedVars.find( typeInst->get_name() ) == closedVars.end() ) {
+                                                // bound to a closed variable => must specialize
                                                 return true;
                                         } // if
                                 } else {
+                                        // variable is bound to a concrete type => must specialize
                                         return true;
                                 } // if
                         } // for
+                        // none of the type variables are bound
                         return false;
                 } else {
+                        // no env
                         return false;
                 } // if
@@ -131 +135 @@
                         if ( functionParameterSize( fftype ) != functionParameterSize( aftype ) ) return false;
                         // tuple-parameter sizes are the same, but actual parameter sizes differ - must tuple specialize
-                        if ( fftype->get_parameters().size() != aftype->get_parameters().size() ) return true;
+                        if ( fftype->parameters.size() != aftype->parameters.size() ) return true;
                         // total parameter size can be the same, while individual parameters can have different structure
-                        for ( auto params : group_iterate( fftype->get_parameters(), aftype->get_parameters() ) ) {
+                        for ( auto params : group_iterate( fftype->parameters, aftype->parameters ) ) {
                                 DeclarationWithType * formal = std::get<0>(params);
                                 DeclarationWithType * actual = std::get<1>(params);
@@ -150 +154 @@
                 if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
                         if ( FunctionType *funType = getFunctionType( formalType ) ) {
-                                ApplicationExpr *appExpr;
-                                VariableExpr *varExpr;
-                                if ( ( appExpr = dynamic_cast<ApplicationExpr*>( actual ) ) ) {
+                                if ( ApplicationExpr * appExpr = dynamic_cast<ApplicationExpr*>( actual ) ) {
                                         return createThunkFunction( funType, appExpr->get_function(), inferParams );
-                                } else if ( ( varExpr = dynamic_cast<VariableExpr*>( actual ) ) ) {
+                                } else if ( VariableExpr * varExpr = dynamic_cast<VariableExpr*>( actual ) ) {
                                         return createThunkFunction( funType, varExpr, inferParams );
                                 } else {
@@ -323 +325 @@
         }
 
-        Expression * Specialize::postmutate( AddressExpr *addrExpr ) {
-                assert( addrExpr->result );
-                addrExpr->set_arg( doSpecialization( addrExpr->result, addrExpr->arg ) );
-                return addrExpr;
-        }
-
         Expression * Specialize::postmutate( CastExpr *castExpr ) {
                 if ( castExpr->result->isVoid() ) {
@@ -334 +330 @@
                         return castExpr;
                 }
-                Expression *specialized = doSpecialization( castExpr->result, castExpr->arg );
+                Expression *specialized = doSpecialization( castExpr->result, castExpr->arg, &castExpr->inferParams );
                 if ( specialized != castExpr->arg ) {
                         // assume here that the specialization incorporates the cast