Changeset 4c8621ac for src/ResolvExpr

Timestamp:

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

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

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (1 diff)
• Unify.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)

src/ResolvExpr/Unify.cc ¶

@@ -517 +517 @@
                         } // if
                 } // for
-                if ( list1Begin != list1End || list2Begin != list2End ) {
-                        return false;
+                // if ( list1Begin != list1End || list2Begin != list2End ) {
+                //      return false;
+                if ( list1Begin != list1End ) {
+                        // try unifying empty tuple type with ttype
+                        Type * t1 = (*list1Begin)->get_type();
+                        if ( Tuples::isTtype( t1 ) ) {
+                                Type * combinedType = combineTypes( list2Begin, list2End );
+                                return unifyExact( t1, combinedType, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                        } else return false;
+                } else if ( list2Begin != list2End ) {
+                        // try unifying empty tuple type with ttype
+                        Type * t2 = (*list2Begin)->get_type();
+                        if ( Tuples::isTtype( t2 ) ) {
+                                Type * combinedType = combineTypes( list1Begin, list1End );
+                                return unifyExact( combinedType, t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                        } else return false;
                 } else {
                         return true;