Changeset 53e3b4a for src/ResolvExpr/AlternativeFinder.cc

Timestamp:

Dec 21, 2016, 5:13:15 PM (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:

64eae56

Parents:

b940dc71

git-author:

Rob Schluntz <rschlunt@…> (12/21/16 16:32:57)

git-committer:

Rob Schluntz <rschlunt@…> (12/21/16 17:13:15)

Message:

refactored computeConversionCost, add ttype parameter handling to instantiate argument, add simple ttype handling code to Unify

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -267 +267 @@
                 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 ) {
-
+                        Type * actualType = (*actualExpr)->get_result();
                         PRINT(
                                 std::cerr << "actual expression:" << std::endl;
                                 (*actualExpr)->print( std::cerr, 8 );
                                 std::cerr << "--- results are" << std::endl;
-                                (*actualExpr)->get_result()->print( std::cerr, 8 );
-                        )
-                        std::list< DeclarationWithType* >::iterator startFormal = formal;
+                                actualType->print( std::cerr, 8 );
+                        )
                         Cost actualCost;
-                        std::list< Type * > flatActualTypes;
-                        flatten( (*actualExpr)->get_result(), back_inserter( flatActualTypes ) );
-                        for ( std::list< Type* >::iterator actualType = flatActualTypes.begin(); actualType != flatActualTypes.end(); ++actualType ) {
-
-
-                                // 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;
+                        if ( formal == formals.end() ) {
+                                if ( function->get_isVarArgs() ) {
+                                        convCost += Cost( 1, 0, 0 );
+                                        continue;
+                                } else {
+                                        return Cost::infinity;
                                 }
-
-                                PRINT(
-                                        std::cerr << std::endl << "converting ";
-                                        (*actualType)->print( std::cerr, 8 );
-                                        std::cerr << std::endl << " to ";
-                                        (*formalType)->print( std::cerr, 8 );
-                                )
-                                Cost newCost = conversionCost( *actualType, *formalType, indexer, alt.env );
-                                PRINT(
-                                        std::cerr << std::endl << "cost is" << newCost << std::endl;
-                                )
-
-                                if ( newCost == Cost::infinity ) {
-                                        return newCost;
-                                }
-                                convCost += newCost;
-                                actualCost += newCost;
-
-                                convCost += Cost( 0, polyCost( *formalType, alt.env, indexer ) + polyCost( *actualType, alt.env, indexer ), 0 );
-
-                                formalType++;
-                        }
+                        }
+                        Type * formalType = (*formal)->get_type();
+                        PRINT(
+                                std::cerr << std::endl << "converting ";
+                                actualType->print( std::cerr, 8 );
+                                std::cerr << std::endl << " to ";
+                                formalType->print( std::cerr, 8 );
+                        )
+                        Cost newCost = conversionCost( actualType, formalType, indexer, alt.env );
+                        PRINT(
+                                std::cerr << std::endl << "cost is" << newCost << std::endl;
+                        )
+
+                        if ( newCost == Cost::infinity ) {
+                                return newCost;
+                        }
+                        convCost += newCost;
+                        actualCost += newCost;
                         if ( actualCost != Cost( 0, 0, 0 ) ) {
-                                std::list< DeclarationWithType* >::iterator startFormalPlusOne = startFormal;
-                                startFormalPlusOne++;
-                                if ( formal == startFormalPlusOne ) {
-                                        // not a tuple type
-                                        Type *newType = (*startFormal)->get_type()->clone();
-                                        alt.env.apply( newType );
-                                        *actualExpr = new CastExpr( *actualExpr, newType );
-                                } else {
-                                        TupleType *newType = new TupleType( Type::Qualifiers() );
-                                        for ( std::list< DeclarationWithType* >::iterator i = startFormal; i != formal; ++i ) {
-                                                newType->get_types().push_back( (*i)->get_type()->clone() );
-                                        }
-                                        alt.env.apply( newType );
-                                        *actualExpr = new CastExpr( *actualExpr, newType );
-                                }
-                        }
-
+                                Type *newType = formalType->clone();
+                                alt.env.apply( newType );
+                                *actualExpr = new CastExpr( *actualExpr, newType );
+                        }
+                        convCost += Cost( 0, polyCost( formalType, alt.env, indexer ) + polyCost( actualType, alt.env, indexer ), 0 );
+                        ++formal; // can't be in for-loop update because of the continue
                 }
                 if ( formal != formals.end() ) {
@@ -364 +328 @@
                         }
                         convCost += newCost;
-
                         convCost += Cost( 0, polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ), 0 );
                 }
@@ -398 +361 @@
                         *out++ = tupleExpr;
                 } else if ( actualIt != actualEnd ) {
+                        if ( TypeInstType * ttype = Tuples::isTtype( formalType ) ) {
+                                // xxx - mixing default arguments with variadic??
+                                if ( ! Tuples::isTtype( actualIt->expr->get_result() ) ) {
+                                        // xxx - what if passing multiple arguments, last of which is ttype?
+
+                                        // consume all remaining arguments, variadic style
+                                        std::list< Expression * > exprs;
+                                        for ( ; actualIt != actualEnd; ++actualIt ) {
+                                                exprs.push_back( actualIt->expr->clone() );
+                                                cost += actualIt->cost;
+                                        }
+                                        TupleExpr * arg = new TupleExpr( exprs );
+                                        assert( arg->get_result() );
+                                        // unification run for side effects
+                                        bool unifyResult = unify( ttype, arg->get_result(), resultEnv, resultNeed, resultHave, openVars, indexer );
+                                        assertf( unifyResult, "Somehow unifying ttype failed..." );
+                                        *out++ = arg;
+                                        return true;
+                                }
+                        }
                         // both actualType and formalType are atomic (non-tuple) types - if they unify
                         // then accept actual as an argument, otherwise return false (fail to instantiate argument)
@@ -609 +592 @@
                 makeUnifiableVars( funcType, openVars, resultNeed );
                 AltList instantiatedActuals; // filled by instantiate function
-                if ( targetType && ! targetType->isVoid() ) {
+                if ( targetType && ! targetType->isVoid() && ! funcType->get_returnVals().empty() ) {
                         // attempt to narrow based on expected target type
                         Type * returnType = funcType->get_returnVals().front()->get_type();