Changes in src/Tuples/TupleAssignment.cc [938dd75:753bf60]

File:

• src/Tuples/TupleAssignment.cc (modified) (5 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() ) );
                                         }
 
@@ -231 +231 @@
 
                         ResolvExpr::AlternativeFinder finder{ currentFinder.get_indexer(),
-                                currentFinder.get_environ() };
+                                matcher->compositeEnv };
+
                         try {
                                 finder.findWithAdjustment(*i);
@@ -298 +299 @@
         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 +319 @@
                 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 +339 @@
                         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 );
+
+                                // resolve the cast expression so that rhsAlt return type is bound by the cast type as needed, and transfer the resulting environment
+                                ResolvExpr::AlternativeFinder finder{ spotter.currentFinder.get_indexer(), compositeEnv };
+                                finder.findWithAdjustment( rhsAlt.expr );
+                                assert( finder.get_alternatives().size() == 1 );
+                                compositeEnv = std::move( finder.get_alternatives().front().env );
+                        }
                         tmpDecls.splice( tmpDecls.end(), ltmp );
                         tmpDecls.splice( tmpDecls.end(), rtmp );