Changeset e76acbe for src/ResolvExpr

Timestamp:

Sep 7, 2016, 10:46:55 AM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

4e7f0f1

Parents:

1ced874

Message:

modify computeConversionCost so that it allows formal parameters with tuple type to have a finite cost

File:

• src/ResolvExpr/AlternativeFinder.cc (modified) (6 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -174 +174 @@
                         }
                 }
+
+                // flatten tuple type into list of types
+                template< typename OutputIterator >
+                void flatten( Type * type, OutputIterator out ) {
+                        if ( TupleType * tupleType = dynamic_cast< TupleType * >( type ) ) {
+                                for ( Type * t : *tupleType ) {
+                                        flatten( t, out );
+                                }
+                        } else {
+                                *out++ = type;
+                        }
+                }
         }
 
@@ -269 +281 @@
                 std::list< Expression* >& actuals = appExpr->get_args();
 
+                std::list< Type * > formalTypes;
+                std::list< Type * >::iterator formalType = formalTypes.end();
+
                 for ( std::list< Expression* >::iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
+
                         PRINT(
                                 std::cerr << "actual expression:" << std::endl;
@@ -279 +295 @@
                         Cost actualCost;
                         for ( std::list< Type* >::iterator actualType = (*actualExpr)->get_results().begin(); actualType != (*actualExpr)->get_results().end(); ++actualType ) {
-                                // xxx - need tuple handling code here
-                                if ( formal == formals.end() ) {
-                                        if ( function->get_isVarArgs() ) {
-                                                convCost += Cost( 1, 0, 0 );
-                                                break;
-                                        } else {
-                                                return Cost::infinity;
+
+                                // tuple handling code
+                                if ( formalType == formalTypes.end() ) {
+                                        // the type of the formal parameter may be a tuple type. To make this easier to work with,
+                                        // flatten the tuple type and traverse the resulting list of types, incrementing the formal
+                                        // iterator once its types have been extracted. Once a particular formal parameter's type has
+                                        // been exhausted load the next formal parameter's type.
+                                        if ( formal == formals.end() ) {
+                                                if ( function->get_isVarArgs() ) {
+                                                        convCost += Cost( 1, 0, 0 );
+                                                        break;
+                                                } else {
+                                                        return Cost::infinity;
+                                                }
                                         }
+                                        formalTypes.clear();
+                                        flatten( (*formal)->get_type(), back_inserter( formalTypes ) );
+                                        formalType = formalTypes.begin();
+                                        ++formal;
                                 }
+
                                 PRINT(
                                         std::cerr << std::endl << "converting ";
@@ -294 +322 @@
                                         (*formal)->get_type()->print( std::cerr, 8 );
                                 )
-                                Cost newCost = conversionCost( *actualType, (*formal)->get_type(), indexer, alt.env );
+                                Cost newCost = conversionCost( *actualType, *formalType, indexer, alt.env );
                                 PRINT(
                                         std::cerr << std::endl << "cost is" << newCost << std::endl;
@@ -305 +333 @@
                                 actualCost += newCost;
 
-                                convCost += Cost( 0, polyCost( (*formal)->get_type(), alt.env, indexer ) + polyCost( *actualType, alt.env, indexer ), 0 );
-
-                                formal++;
+                                convCost += Cost( 0, polyCost( *formalType, alt.env, indexer ) + polyCost( *actualType, alt.env, indexer ), 0 );
+
+                                formalType++;
                         }
                         if ( actualCost != Cost( 0, 0, 0 ) ) {
@@ -362 +390 @@
                         }
 ///     needAssertions.insert( needAssertions.end(), (*tyvar)->get_assertions().begin(), (*tyvar)->get_assertions().end() );
-                }
-        }
-
-        template< typename OutputIterator >
-        void flatten( Type * type, OutputIterator out ) {
-                if ( TupleType * tupleType = dynamic_cast< TupleType * >( type ) ) {
-                        for ( Type * t : *tupleType ) {
-                                flatten( t, out );
-                        }
-                } else {
-                        *out++ = type;
                 }
         }