Changes in src/Tuples/TupleAssignment.cc [1d2b64f:f831177]

File:

• src/Tuples/TupleAssignment.cc (modified) (6 diffs)

src/Tuples/TupleAssignment.cc

@@ -73 +73 @@
         };
 
-        /// true if expr is an expression of tuple type, i.e. a tuple expression, tuple variable, or MRV (multiple-return-value) function
+        /// true if expr is an expression of tuple type
         bool isTuple( Expression *expr ) {
                 if ( ! expr ) return false;
                 assert( expr->has_result() );
-                return dynamic_cast<TupleExpr *>(expr) || expr->get_result()->size() > 1;
+                return dynamic_cast< TupleType * >( expr->get_result() );
         }
 
@@ -142 +142 @@
                 matcher->match( new_assigns );
 
-                if ( new_assigns.empty() ) return;
+                if ( ! matcher->lhs.empty() || ! matcher->rhs.empty() ) {
+                        // if both lhs and rhs are empty then this is the empty tuple case, wherein it's okay for new_assigns to be empty.
+                        // if not the empty tuple case, return early so that no new alternatives are generated.
+                        if ( new_assigns.empty() ) return;
+                }
                 ResolvExpr::AltList current;
                 // now resolve new assignments
@@ -186 +190 @@
 
                 // explode the lhs so that each field of the tuple-valued-expr is assigned.
-                explode( lhsAlt, spotter.currentFinder.get_indexer(), back_inserter(lhs) );
+                explode( lhsAlt, spotter.currentFinder.get_indexer(), back_inserter(lhs), true );
 
                 // and finally, re-add the cast to each lhs expr, so that qualified tuple fields can be constructed
@@ -211 +215 @@
         TupleAssignSpotter::MultipleAssignMatcher::MultipleAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts ) : Matcher( spotter, alts ) {
                 // explode the rhs so that each field of the tuple-valued-expr is assigned.
-                explode( std::next(alts.begin(), 1), alts.end(), spotter.currentFinder.get_indexer(), back_inserter(rhs) );
+                explode( std::next(alts.begin(), 1), alts.end(), spotter.currentFinder.get_indexer(), back_inserter(rhs), true );
         }
 
@@ -248 +252 @@
                 static UniqueName lhsNamer( "__massassign_L" );
                 static UniqueName rhsNamer( "__massassign_R" );
-                assert ( ! lhs.empty() && rhs.size() <= 1);
+                // empty tuple case falls into this matcher, hence the second part of the assert
+                assert( (! lhs.empty() && rhs.size() <= 1) || (lhs.empty() && rhs.empty()) );
 
                 ObjectDecl * rtmp = rhs.size() == 1 ? newObject( rhsNamer, rhs.front().expr ) : nullptr;
                 for ( ResolvExpr::Alternative & lhsAlt : lhs ) {
+                        // create a temporary object for each value in the lhs and create a call involving the rhs
                         ObjectDecl * ltmp = newObject( lhsNamer, lhsAlt.expr );
                         out.push_back( createFunc( spotter.fname, ltmp, rtmp ) );
@@ -263 +269 @@
                 static UniqueName rhsNamer( "__multassign_R" );
 
-                // xxx - need more complicated matching?
                 if ( lhs.size() == rhs.size() ) {
+                        // produce a new temporary object for each value in the lhs and rhs and pairwise create the calls
                         std::list< ObjectDecl * > ltmp;
                         std::list< ObjectDecl * > rtmp;