Changeset 90152a4 for src/Tuples/TupleAssignment.cc

Timestamp:

Aug 27, 2018, 4:40:34 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

b7c89aa

Parents:

f9feab8 (diff), 305581d (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' into cleanup-dtors

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);
@@ -272 +273 @@
                 // args.push_back( new AddressExpr( new VariableExpr( left ) ) );
                 if ( right ) args.push_back( new VariableExpr( right ) );
-                return new UntypedExpr( new NameExpr( fname ), args );
-        }
-
-        // removes environments from subexpressions within statement exprs, which could throw off later passes like those in Box which rely on PolyMutator.
+                if ( left->type->referenceDepth() > 1 && CodeGen::isConstructor( fname ) ) {
+                        args.front() = new AddressExpr( args.front() );
+                        if ( right ) args.back() = new AddressExpr( args.back() );
+                        return new UntypedExpr( new NameExpr( "?=?" ), args );
+                } else {
+                        return new UntypedExpr( new NameExpr( fname ), args );
+                }
+        }
+
+        // removes environments from subexpressions within statement exprs, which could throw off later passes like those in Box which rely on PolyMutator, and adds the bindings to the compositeEnv
         // xxx - maybe this should happen in alternative finder for every StmtExpr?
-        // xxx - it's possible that these environments could contain some useful information. Maybe the right thing to do is aggregate the environments and pass the aggregate back to be added into the compositeEnv
         struct EnvRemover {
                 void previsit( ExprStmt * stmt ) {
-                        delete stmt->expr->env;
-                        stmt->expr->env = nullptr;
-                }
+                        assert( compositeEnv );
+                        if ( stmt->expr->env ) {
+                                compositeEnv->add( *stmt->expr->env );
+                                delete stmt->expr->env;
+                                stmt->expr->env = nullptr;
+                        }
+                }
+
+                ResolvExpr::TypeEnvironment * compositeEnv = nullptr;
         };
 
         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->set_init( ctorInit );
+                        ret->init = ctorInit;
                         ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
                         PassVisitor<EnvRemover> rm; // remove environments from subexpressions of StmtExprs
+                        rm.pass.compositeEnv = &compositeEnv;
                         ctorInit->accept( rm );
                 }
@@ -306 +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 ) {
@@ -324 +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 );