Changeset 4c8621ac for src/ResolvExpr/AlternativeFinder.cc

Timestamp:

Dec 22, 2016, 4:07:58 PM (7 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:

1e3d5b6

Parents:

907eccb

Message:

allow construction, destruction, and assignment for empty tuples, allow matching a ttype parameter with an empty tuple, fix specialization to work with empty tuples and void functions

File:

• src/ResolvExpr/AlternativeFinder.cc (modified) (1 diff)

src/ResolvExpr/AlternativeFinder.cc

@@ -359 +359 @@
                         }
                         *out++ = new TupleExpr( exprs );
+                } else if ( TypeInstType * ttype = Tuples::isTtype( formalType ) ) {
+                        // xxx - mixing default arguments with variadic??
+                        std::list< Expression * > exprs;
+                        for ( ; actualIt != actualEnd; ++actualIt ) {
+                                exprs.push_back( actualIt->expr->clone() );
+                                cost += actualIt->cost;
+                        }
+                        Expression * arg = nullptr;
+                        if ( exprs.size() == 1 && Tuples::isTtype( exprs.front()->get_result() ) ) {
+                                // the case where a ttype value is passed directly is special, e.g. for argument forwarding purposes
+                                // xxx - what if passing multiple arguments, last of which is ttype?
+                                // xxx - what would happen if unify was changed so that unifying tuple types flattened both before unifying lists? then pass in TupleType(ttype) below.
+                                arg = exprs.front();
+                        } else {
+                                arg = new TupleExpr( exprs );
+                        }
+                        assert( arg && arg->get_result() );
+                        if ( ! unify( ttype, arg->get_result(), resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                return false;
+                        }
+                        *out++ = arg;
+                        return true;
                 } 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)