Changeset cac8a6e for src/Tuples

Timestamp:

May 22, 2018, 11:08:22 AM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

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, with_gc

Children:

639991a

Parents:

4a333d35 (diff), 2f0a0678 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/Tuples

Files:

• TupleAssignment.cc (modified) (4 diffs)
• TupleExpansion.cc (modified) (3 diffs)

src/Tuples/TupleAssignment.cc

@@ -154 +154 @@
                                                 lhsAlt.expr = new CastExpr( lhsAlt.expr,
                                                                 new ReferenceType( Type::Qualifiers(),
-                                                                        lhsAlt.expr->get_result()->clone() ) );
+                                                                        lhsAlt.expr->result->clone() ) );
                                         }
 
@@ -298 +298 @@
         ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) {
                 assert( expr->result && ! expr->get_result()->isVoid() );
-                ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
+                ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->result->clone(), new SingleInit( expr->clone() ) );
                 // if expression type is a reference, don't need to construct anything, a simple initializer is sufficient.
-                if ( ! dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
+                if ( ! dynamic_cast< ReferenceType * >( expr->result ) ) {
                         ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
                         ret->init = ctorInit;
@@ -318 +318 @@
                 assert( (! lhs.empty() && rhs.size() <= 1) || (lhs.empty() && rhs.empty()) );
 
+                // xxx - may need to split this up into multiple declarations, because potential conversion to references
+                //  probably should not reference local variable - see MultipleAssignMatcher::match
                 ObjectDecl * rtmp = rhs.size() == 1 ? newObject( rhsNamer, rhs.front().expr ) : nullptr;
                 for ( ResolvExpr::Alternative & lhsAlt : lhs ) {
@@ -336 +338 @@
                         std::list< ObjectDecl * > ltmp;
                         std::list< ObjectDecl * > rtmp;
-                        std::transform( lhs.begin(), lhs.end(), back_inserter( ltmp ), [&]( ResolvExpr::Alternative & alt ){
-                                return newObject( lhsNamer, alt.expr );
-                        });
-                        std::transform( rhs.begin(), rhs.end(), back_inserter( rtmp ), [&]( ResolvExpr::Alternative & alt ){
-                                return newObject( rhsNamer, alt.expr );
-                        });
-                        zipWith( ltmp.begin(), ltmp.end(), rtmp.begin(), rtmp.end(), back_inserter(out), [&](ObjectDecl * obj1, ObjectDecl * obj2 ) { return createFunc(spotter.fname, obj1, obj2); } );
+                        for ( auto p : group_iterate( lhs, rhs ) ) {
+                                ResolvExpr::Alternative & lhsAlt = std::get<0>(p);
+                                ResolvExpr::Alternative & rhsAlt = std::get<1>(p);
+                                // convert RHS to LHS type minus one reference -- important for the case where LHS is && and RHS is lvalue, etc.
+                                ReferenceType * lhsType = strict_dynamic_cast<ReferenceType *>( lhsAlt.expr->result );
+                                rhsAlt.expr = new CastExpr( rhsAlt.expr, lhsType->base->clone() );
+                                ObjectDecl * lobj = newObject( lhsNamer, lhsAlt.expr );
+                                ObjectDecl * robj = newObject( rhsNamer, rhsAlt.expr );
+                                out.push_back( createFunc(spotter.fname, lobj, robj) );
+                                ltmp.push_back( lobj );
+                                rtmp.push_back( robj );
+                        }
                         tmpDecls.splice( tmpDecls.end(), ltmp );
                         tmpDecls.splice( tmpDecls.end(), rtmp );

src/Tuples/TupleExpansion.cc

@@ -30 +30 @@
 #include "SynTree/Type.h"         // for Type, Type::Qualifiers, TupleType
 #include "SynTree/Visitor.h"      // for Visitor
+#include "Tuples.h"
 
 class CompoundStmt;
@@ -128 +129 @@
                         Expression * aggr = memberExpr->aggregate->clone()->acceptMutator( *visitor );
                         // aggregate expressions which might be impure must be wrapped in unique expressions
-                        // xxx - if there's a member-tuple expression nested in the aggregate, this currently generates the wrong code if a UniqueExpr is not used, and it's purely an optimization to remove the UniqueExpr
-                        // if ( Tuples::maybeImpureIgnoreUnique( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
-                        aggr = new UniqueExpr( aggr );
+                        if ( Tuples::maybeImpureIgnoreUnique( memberExpr->aggregate ) ) aggr = new UniqueExpr( aggr );
                         for ( Expression *& expr : tupleExpr->exprs ) {
                                 expr = reconstructMemberExpr( expr, aggr, memberExpr->location );
@@ -227 +226 @@
 
         Expression * TupleIndexExpander::postmutate( TupleIndexExpr * tupleExpr ) {
-                Expression * tuple = tupleExpr->get_tuple();
+                Expression * tuple = tupleExpr->tuple;
                 assert( tuple );
-                tupleExpr->set_tuple( nullptr );
-                unsigned int idx = tupleExpr->get_index();
-                TypeSubstitution * env = tupleExpr->get_env();
-                tupleExpr->set_env( nullptr );
+                tupleExpr->tuple = nullptr;
+                unsigned int idx = tupleExpr->index;
+                TypeSubstitution * env = tupleExpr->env;
+                tupleExpr->env = nullptr;
                 delete tupleExpr;
 
-                StructInstType * type = strict_dynamic_cast< StructInstType * >( tuple->get_result() );
-                StructDecl * structDecl = type->get_baseStruct();
-                assert( structDecl->get_members().size() > idx );
-                Declaration * member = *std::next(structDecl->get_members().begin(), idx);
+                if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * > ( tuple ) ) {
+                        if ( ! maybeImpureIgnoreUnique( tupleExpr ) ) {
+                                // optimization: definitely pure tuple expr => can reduce to the only relevant component.
+                                assert( tupleExpr->exprs.size() > idx );
+                                Expression *& expr = *std::next(tupleExpr->exprs.begin(), idx);
+                                Expression * ret = expr;
+                                ret->env = env;
+                                expr = nullptr; // remove from list so it can safely be deleted
+                                delete tupleExpr;
+                                return ret;
+                        }
+                }
+
+                StructInstType * type = strict_dynamic_cast< StructInstType * >( tuple->result );
+                StructDecl * structDecl = type->baseStruct;
+                assert( structDecl->members.size() > idx );
+                Declaration * member = *std::next(structDecl->members.begin(), idx);
                 MemberExpr * memExpr = new MemberExpr( strict_dynamic_cast< DeclarationWithType * >( member ), tuple );
-                memExpr->set_env( env );
+                memExpr->env = env;
                 return memExpr;
         }