Changeset b910d15 for src/Tuples/Explode.cc

Timestamp:

Jun 17, 2019, 3:55:21 PM (5 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

e6faef4

Parents:

6e55240

Message:

Implemented new versions of Tuples/Explode?.

File:

• src/Tuples/Explode.cc (modified) (2 diffs)

src/Tuples/Explode.cc

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Wed Nov 9 13:12:24 2016
-// Last Modified By : Rob Schluntz
-// Last Modified On : Wed Nov 9 13:20:24 2016
-// Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 12 16:40:00 2016
+// Update Count     : 3
 //
 
@@ -106 +106 @@
                 return expr;
         }
+
+namespace {
+
+// Remove one level of reference from a reference type.
+const ast::Type * getReferenceBase( const ast::Type * t ) {
+        if ( const ast::ReferenceType * ref = dynamic_cast< const ast::ReferenceType * >( t ) ) {
+                return ref->base;
+        } else {
+                assertf( false, "getReferenceBase for non-ref: %s", toString( t ).c_str() );
+                return nullptr;
+        }
+}
+
+struct CastExploderCore {
+        bool castAdded = false;
+        bool foundUniqueExpr = false;
+        const ast::Expr * applyCast( const ast::Expr * expr, bool first = true ) {
+                // On tuple push the cast down.
+                if ( const ast::TupleExpr * tupleExpr = dynamic_cast< const ast::TupleExpr * >( expr ) ) {
+                        foundUniqueExpr = true;
+                        std::vector< ast::ptr< ast::Expr > > exprs;
+                        for ( const ast::Expr * expr : tupleExpr->exprs ) {
+                                exprs.emplace_back( applyCast( expr, false ) );
+                                //exprs.emplace_back( ast::ptr< ast::Expr >( applyCast( expr, false ) ) );
+                        }
+                        if ( first ) {
+                                castAdded = true;
+                                const ast::Expr * tuple = new ast::TupleExpr(
+                                        tupleExpr->location, std::move( exprs ) );
+                                return new ast::CastExpr( tuple->location,
+                                        tuple, new ast::ReferenceType( tuple->result.get(), ast::CV::Qualifiers() ) );
+                        } else {
+                                return new ast::TupleExpr( tupleExpr->location, std::move( exprs ) );
+                        }
+                }
+                if ( dynamic_cast< const ast::ReferenceType * >( expr->result.get() ) ) {
+                        return expr;
+                } else {
+                        castAdded = true;
+                        return new ast::CastExpr( expr->location, expr,
+                                new ast::ReferenceType( expr->result, ast::CV::Qualifiers() ) );
+                }
+        }
+
+        const ast::Expr * postmutate( const ast::UniqueExpr * node ) {
+                // move cast into unique expr so that the unique expr has type T& rather than
+                // type T. In particular, this transformation helps with generating the
+                // correct code for reference-cast member tuple expressions, since the result
+                // should now be a tuple of references rather than a reference to a tuple.
+                // Still, this code is a bit awkward, and could use some improvement.
+                const ast::UniqueExpr * newNode = new ast::UniqueExpr( node->location,
+                                applyCast( node->expr ), node->id );
+                if ( castAdded ) {
+                        // if a cast was added by applyCast, then unique expr now has one more layer of reference
+                        // than it had coming into this function. To ensure types still match correctly, need to cast
+                        //  to reference base so that outer expressions are still correct.
+                        castAdded = false;
+                        const ast::Type * newType = getReferenceBase( newNode->result );
+                        return new ast::CastExpr( newNode->location, node, newType );
+                }
+                return newNode;
+        }
+
+        const ast::Expr * postmutate( const ast::TupleIndexExpr * tupleExpr ) {
+                // tuple index expr needs to be rebuilt to ensure that the type of the
+                // field is consistent with the type of the tuple expr, since the field
+                // may have changed from type T to T&.
+                return new ast::TupleIndexExpr( tupleExpr->location, tupleExpr->tuple, tupleExpr->index );
+        }
+};
+
+} // namespace
+
+const ast::Expr * distributeReference( const ast::Expr * expr ) {
+        ast::Pass<CastExploderCore> exploder;
+        expr = expr->accept( exploder );
+        if ( ! exploder.pass.foundUniqueExpr ) {
+                expr = new ast::CastExpr( expr->location, expr,
+                        new ast::ReferenceType( expr->result, ast::CV::Qualifiers() ) );
+        }
+        return expr;
+}
+
 } // namespace Tuples