Changes in src/ResolvExpr/AlternativeFinder.cc [0362d42:85517ddb]

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -42 +42 @@
 #include "Common/utility.h"
 #include "InitTweak/InitTweak.h"
+#include "ResolveTypeof.h"
 
 extern bool resolvep;
@@ -267 +268 @@
                 std::list< DeclarationWithType* >::iterator formal = formals.begin();
                 std::list< Expression* >& actuals = appExpr->get_args();
-
                 for ( std::list< Expression* >::iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
                         PRINT(
@@ -277 +277 @@
                         std::list< DeclarationWithType* >::iterator startFormal = formal;
                         Cost actualCost;
-                        for ( std::list< Type* >::iterator actualType = (*actualExpr)->get_results().begin(); actualType != (*actualExpr)->get_results().end(); ++actualType ) {
-                                // xxx - need tuple handling code here
+                        for ( std::list< Type* >::iterator actual = (*actualExpr)->get_results().begin(); actual != (*actualExpr)->get_results().end(); ++actual ) {
                                 if ( formal == formals.end() ) {
                                         if ( function->get_isVarArgs() ) {
@@ -289 +288 @@
                                 PRINT(
                                         std::cerr << std::endl << "converting ";
-                                        (*actualType)->print( std::cerr, 8 );
+                                        (*actual)->print( std::cerr, 8 );
                                         std::cerr << std::endl << " to ";
                                         (*formal)->get_type()->print( std::cerr, 8 );
                                 )
-                                Cost newCost = conversionCost( *actualType, (*formal)->get_type(), indexer, alt.env );
+                                Cost newCost = conversionCost( *actual, (*formal)->get_type(), indexer, alt.env );
                                 PRINT(
                                         std::cerr << std::endl << "cost is" << newCost << std::endl;
@@ -304 +303 @@
                                 actualCost += newCost;
 
-                                convCost += Cost( 0, polyCost( (*formal)->get_type(), alt.env, indexer ) + polyCost( *actualType, alt.env, indexer ), 0 );
+                                convCost += Cost( 0, polyCost( (*formal)->get_type(), alt.env, indexer ) + polyCost( *actual, alt.env, indexer ), 0 );
 
                                 formal++;
@@ -364 +363 @@
         }
 
-        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;
-                }
-        }
-
         bool AlternativeFinder::instantiateFunction( std::list< DeclarationWithType* >& formals, /*const*/ AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave ) {
                 simpleCombineEnvironments( actuals.begin(), actuals.end(), resultEnv );
@@ -392 +380 @@
                 */
                 std::list< DeclarationWithType* >::iterator formal = formals.begin();
-
-                std::list< Type * > formalTypes;
-                std::list< Type * >::iterator formalType = formalTypes.end();
-
                 for ( AltList::const_iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
-                        std::list< Type* > & actualTypes = actualExpr->expr->get_results();
-                        for ( std::list< Type* >::iterator actualType = actualTypes.begin(); actualType != actualTypes.end(); ++actualType ) {
-                                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() ) {
-                                                return isVarArgs;
-                                        }
-                                        formalTypes.clear();
-                                        flatten( (*formal)->get_type(), back_inserter( formalTypes ) );
-                                        formalType = formalTypes.begin();
-                                        ++formal;
+                        for ( std::list< Type* >::iterator actual = actualExpr->expr->get_results().begin(); actual != actualExpr->expr->get_results().end(); ++actual ) {
+                                if ( formal == formals.end() ) {
+                                        return isVarArgs;
                                 }
                                 PRINT(
@@ -416 +389 @@
                                         (*formal)->get_type()->print( std::cerr );
                                         std::cerr << std::endl << "actual type is ";
-                                        (*actualType)->print( std::cerr );
+                                        (*actual)->print( std::cerr );
                                         std::cerr << std::endl;
                                 )
-                                if ( ! unify( *formalType, *actualType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                if ( ! unify( (*formal)->get_type(), *actual, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
                                         return false;
                                 }
-                                ++formalType;
-                        }
-                }
-
-                // xxx - a tuple type was not completely matched
-                // partially handle the tuple with default arguments??
-                if ( formalType != formalTypes.end() ) return false;
-
+                                formal++;
+                        }
+                }
                 // Handling of default values
                 while ( formal != formals.end() ) {
@@ -740 +708 @@
         void AlternativeFinder::visit( CastExpr *castExpr ) {
                 for ( std::list< Type* >::iterator i = castExpr->get_results().begin(); i != castExpr->get_results().end(); ++i ) {
+                        *i = resolveTypeof( *i, indexer );
                         SymTab::validateType( *i, &indexer );
                         adjustExprType( *i, env, indexer );
@@ -828 +797 @@
 
         void AlternativeFinder::visit( VariableExpr *variableExpr ) {
-                alternatives.push_back( Alternative( variableExpr->clone(), env, Cost::zero ) );
+                // not sufficient to clone here, because variable's type may have changed
+                // since the VariableExpr was originally created.
+                alternatives.push_back( Alternative( new VariableExpr( variableExpr->get_var() ), env, Cost::zero ) );
         }
 
@@ -837 +808 @@
         void AlternativeFinder::visit( SizeofExpr *sizeofExpr ) {
                 if ( sizeofExpr->get_isType() ) {
+                        // xxx - resolveTypeof?
                         alternatives.push_back( Alternative( sizeofExpr->clone(), env, Cost::zero ) );
                 } else {
@@ -856 +828 @@
         void AlternativeFinder::visit( AlignofExpr *alignofExpr ) {
                 if ( alignofExpr->get_isType() ) {
+                        // xxx - resolveTypeof?
                         alternatives.push_back( Alternative( alignofExpr->clone(), env, Cost::zero ) );
                 } else {
@@ -889 +862 @@
         void AlternativeFinder::visit( UntypedOffsetofExpr *offsetofExpr ) {
                 AlternativeFinder funcFinder( indexer, env );
+                // xxx - resolveTypeof?
                 if ( StructInstType *structInst = dynamic_cast< StructInstType* >( offsetofExpr->get_type() ) ) {
                         addOffsetof( structInst, offsetofExpr->get_member() );