Changeset f831177 for src/Tuples

Timestamp:

Jan 9, 2017, 3:37:36 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:

627f585

Parents:

6c3a988f

Message:

address exprs are now only exploded for tuple assignments

Location:

src/Tuples

Files:

• Explode.h (modified) (3 diffs)
• TupleAssignment.cc (modified) (9 diffs)

src/Tuples/Explode.h

@@ -33 +33 @@
         /// helper function used by explode
         template< typename OutputIterator >
-        void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, const SymTab::Indexer & indexer, OutputIterator out ) {
+        void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign ) {
+                if ( isTupleAssign ) {
+                        // tuple assignment needs AddressExprs to be recursively exploded to easily get at all of the components
+                        if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) {
+                                ResolvExpr::AltList alts;
+                                explodeUnique( addrExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
+                                for ( ResolvExpr::Alternative & alt : alts ) {
+                                        // distribute '&' over all components
+                                        alt.expr = distributeAddr( alt.expr );
+                                        *out++ = alt;
+                                }
+                                // in tuple assignment, still need to handle the other cases, but only if not already handled here (don't want to output too many alternatives)
+                                return;
+                        }
+                }
                 Type * res = expr->get_result();
-                if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) {
-                        ResolvExpr::AltList alts;
-                        explodeUnique( addrExpr->get_arg(), alt, indexer, back_inserter( alts ) );
-                        for ( ResolvExpr::Alternative & alt : alts ) {
-                                // distribute '&' over all components
-                                alt.expr = distributeAddr( alt.expr );
-                                *out++ = alt;
-                        }
-                } else if ( TupleType * tupleType = dynamic_cast< TupleType * > ( res ) ) {
+                if ( TupleType * tupleType = dynamic_cast< TupleType * > ( res ) ) {
                         if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( expr ) ) {
                                 // can open tuple expr and dump its exploded components
                                 for ( Expression * expr : tupleExpr->get_exprs() ) {
-                                        explodeUnique( expr, alt, indexer, out );
+                                        explodeUnique( expr, alt, indexer, out, isTupleAssign );
                                 }
                         } else {
@@ -58 +64 @@
                                 for ( unsigned int i = 0; i < tupleType->size(); i++ ) {
                                         TupleIndexExpr * idx = new TupleIndexExpr( arg->clone(), i );
-                                        explodeUnique( idx, alt, indexer, out );
+                                        explodeUnique( idx, alt, indexer, out, isTupleAssign );
                                         delete idx;
                                 }
@@ -71 +77 @@
         /// expands a tuple-valued alternative into multiple alternatives, each with a non-tuple-type
         template< typename OutputIterator >
-        void explode( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer, OutputIterator out ) {
-                explodeUnique( alt.expr, alt, indexer, out );
+        void explode( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
+                explodeUnique( alt.expr, alt, indexer, out, isTupleAssign );
         }
 
         // explode list of alternatives
         template< typename AltIterator, typename OutputIterator >
-        void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer, OutputIterator out ) {
+        void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
                 for ( ; altBegin != altEnd; ++altBegin ) {
-                        explode( *altBegin, indexer, out );
+                        explode( *altBegin, indexer, out, isTupleAssign );
                 }
         }
 
         template< typename OutputIterator >
-        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, OutputIterator out ) {
-                explode( alts.begin(), alts.end(), indexer, out );
+        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
+                explode( alts.begin(), alts.end(), indexer, out, isTupleAssign );
         }
 } // namespace Tuples

src/Tuples/TupleAssignment.cc

@@ -42 +42 @@
           private:
                 void match();
-                void handleEmptyTuple( const ResolvExpr::AltList & alts );
 
                 struct Matcher {
@@ -74 +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() );
         }
 
@@ -131 +130 @@
                                                 }
                                                 match();
-                                        } else {
-                                                // handle empty case specially. It is easy to cause conflicts for tuple assignment when we consider any expression with Tuple type to be a tuple.
-                                                // Instead, only tuple expressions and expressions with at least 2 results are considered tuples for tuple assignment. This most obviously leaves out the
-                                                // nullary and unary cases. The unary case is handled nicely by the alternative finder as is. For example, an expression of type [int] will be exploded
-                                                // into a list of one element (combined with the RHS elements), which will easily allow for intrinsic construction. This seems like a best case scenario anyway,
-                                                // since intrinsic construction is much simpler from a code-gen perspective than tuple construction is.
-                                                // This leaves the empty case, which is not easily handled by existing alternative finder logic. Instead, it seems simple enough to hanlde here that if the left
-                                                // side is an empty tuple, then the right side is allowed to be either an empty tuple or an empty list. Fortunately, these cases are identical when exploded.
-                                                handleEmptyTuple( *ali );
                                         }
                                 }
@@ -152 +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
@@ -196 +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
@@ -221 +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 );
         }
 
@@ -258 +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 ) );
@@ -273 +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;
@@ -288 +284 @@
                 }
         }
-
-        // empty case is okay when right side is also "empty" (empty explosion handles no argument case as well as empty tuple case)
-        void TupleAssignSpotter::handleEmptyTuple( const ResolvExpr::AltList & alts ) {
-                assert( ! alts.empty() );
-                Expression * lhs = alts.front().expr;
-                if ( PointerType * ptrType = dynamic_cast< PointerType * >( lhs->get_result() ) ) {
-                        if ( TupleType * tupleType = dynamic_cast< TupleType * >( ptrType->get_base() ) ) {
-                                if ( tupleType->size() == 0 ) {
-                                        ResolvExpr::AltList rhs;
-                                        explode( std::next(alts.begin(), 1), alts.end(), currentFinder.get_indexer(), back_inserter(rhs) );
-                                        if ( rhs.empty() ) {
-                                                // okay, no other case is allowed
-                                                ResolvExpr::TypeEnvironment compositeEnv;
-                                                simpleCombineEnvironments( alts.begin(), alts.end(), compositeEnv );
-                                                currentFinder.get_alternatives().push_front( ResolvExpr::Alternative( new TupleAssignExpr( std::list< Expression * >(), std::list< ObjectDecl * >() ), compositeEnv, ResolvExpr::sumCost( alts ) ) );
-                                        }
-                                }
-                        }
-                }
-        }
 } // namespace Tuples