Changeset 78315272

Timestamp:

Nov 8, 2017, 4:34:54 PM (7 years ago)

Author:

Aaron Moss <a3moss@…>

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:

3f7e12cb

Parents:

fae6f21

Message:

Switch in new TupleAssignment?

File:

• src/Tuples/TupleAssignment.cc (modified) (12 diffs)

src/Tuples/TupleAssignment.cc

@@ -20 +20 @@
 #include <memory>                          // for unique_ptr, allocator_trai...
 #include <string>                          // for string
+#include <vector>
 
 #include "CodeGen/OperatorTable.h"
@@ -60 +61 @@
                 struct Matcher {
                   public:
-                        Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts );
+                        Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, const 
+                                ResolvExpr::AltList& rhs );
                         virtual ~Matcher() {}
                         virtual void match( std::list< Expression * > &out ) = 0;
@@ -73 +75 @@
                 struct MassAssignMatcher : public Matcher {
                   public:
-                        MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts );
+                        MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, 
+                                const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
                         virtual void match( std::list< Expression * > &out );
                 };
@@ -79 +82 @@
                 struct MultipleAssignMatcher : public Matcher {
                   public:
-                        MultipleAssignMatcher( TupleAssignSpotter &spot, const ResolvExpr::AltList & alts );
+                        MultipleAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, 
+                                const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
                         virtual void match( std::list< Expression * > &out );
                 };
@@ -91 +95 @@
         bool isTuple( Expression *expr ) {
                 if ( ! expr ) return false;
-                assert( expr->result );
+                assert( expr->has_result() );
                 return dynamic_cast< TupleType * >( expr->get_result()->stripReferences() );
         }
@@ -116 +120 @@
 
         void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr, 
-                std::vector<ResolvExpr::AlternativeFinder> &args ) {
-        TupleAssignSpotter spotter( currentFinder );
-        spotter.spot( expr, args );
+                                std::vector<ResolvExpr::AlternativeFinder> &args ) {
+                TupleAssignSpotter spotter( currentFinder );
+                spotter.spot( expr, args );
         }
 
@@ -124 +128 @@
                 : currentFinder(f) {}
 
-        void TupleAssignSpotter::spot( UntypedExpr * expr, std::vector<ResolvExpr::AlternativeFinder> &args ) {
-                std::list<ResolvExpr::AltList> possibilities;
-                combos( args.begin(), args.end(), back_inserter( possibilities ) );
-
+        void TupleAssignSpotter::spot( UntypedExpr * expr, 
+                        std::vector<ResolvExpr::AlternativeFinder> &args ) {
                 if (  NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) {
                         if ( CodeGen::isCtorDtorAssign( op->get_name() ) ) {
-                               fname = op->get_name();
-                                PRINT( std::cerr << "TupleAssignment: " << fname << std::endl; )
-                                for ( std::list<ResolvExpr::AltList>::const_iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) {
-                                        if ( ali->size() == 0 ) continue; // AlternativeFinder will natrually handle this case, if it's legal
-                                        if ( ali->size() <= 1 && CodeGen::isAssignment( op->get_name() ) ) {
-                                                // what does it mean if an assignment takes 1 argument? maybe someone defined such a function, in which case AlternativeFinder will naturally handle it
-                                                continue;
+                                fname = op->get_name();
+
+                                // AlternativeFinder will naturally handle this case case, if it's legal
+                                if ( args.size() == 0 ) return;
+
+                                // if an assignment only takes 1 argument, that's odd, but maybe someone wrote 
+                                // the function, in which case AlternativeFinder will handle it normally
+                                if ( args.size() == 1 && CodeGen::isAssignment( fname ) ) return;
+
+                                // look over all possible left-hand-sides
+                                for ( ResolvExpr::Alternative& lhsAlt : args[0] ) {
+                                        // skip non-tuple LHS
+                                        if ( ! refToTuple(lhsAlt.expr) ) continue;
+
+                                        // explode is aware of casts - ensure every LHS expression is sent into explode 
+                                        // with a reference cast
+                                        // xxx - this seems to change the alternatives before the normal 
+                                        //  AlternativeFinder flow; maybe this is desired?
+                                        if ( ! dynamic_cast<CastExpr*>( lhsAlt.expr ) ) {
+                                                lhsAlt.expr = new CastExpr( lhsAlt.expr, 
+                                                                new ReferenceType( Type::Qualifiers(), 
+                                                                        lhsAlt.expr->get_result()->clone() ) );
                                         }
 
-                                        assert( ! ali->empty() );
-                                        // grab args 2-N and group into a TupleExpr
-                                        const ResolvExpr::Alternative & alt1 = ali->front();
-                                        auto begin = std::next(ali->begin(), 1), end = ali->end();
-                                        PRINT( std::cerr << "alt1 is " << alt1.expr << std::endl; )
-                                        if ( refToTuple(alt1.expr) ) {
-                                                PRINT( std::cerr << "and is reference to tuple" << std::endl; )
-                                                if ( isMultAssign( begin, end ) ) {
-                                                        PRINT( std::cerr << "possible multiple assignment" << std::endl; )
-                                                        matcher.reset( new MultipleAssignMatcher( *this, *ali ) );
-                                                } else {
-                                                        // mass assignment
-                                                        PRINT( std::cerr << "possible mass assignment" << std::endl; )
-                                                        matcher.reset( new MassAssignMatcher( *this,  *ali ) );
+                                        // explode the LHS so that each field of a tuple-valued-expr is assigned
+                                        ResolvExpr::AltList lhs;
+                                        explode( lhsAlt, currentFinder.get_indexer(), back_inserter(lhs), true );
+                                        for ( ResolvExpr::Alternative& alt : lhs ) {
+                                                // each LHS value must be a reference - some come in with a cast expression, 
+                                                // if not just cast to reference here
+                                                if ( ! dynamic_cast<ReferenceType*>( alt.expr->get_result() ) ) {
+                                                        alt.expr = new CastExpr( alt.expr, 
+                                                                new ReferenceType( Type::Qualifiers(), 
+                                                                        alt.expr->get_result()->clone() ) );
                                                 }
+                                        }
+
+                                        if ( args.size() == 1 ) {
+                                                // mass default-initialization/destruction
+                                                ResolvExpr::AltList rhs{};
+                                                matcher.reset( new MassAssignMatcher( *this, lhs, rhs ) );
                                                 match();
+                                        } else if ( args.size() > 2 ) {
+                                                // expand all possible RHS possibilities
+                                                // TODO build iterative version of this instead of using combos
+                                                std::vector< ResolvExpr::AltList > rhsAlts;
+                                                combos( std::next(args.begin(), 1), args.end(), 
+                                                        std::back_inserter( rhsAlts ) );
+                                                for ( const ResolvExpr::AltList& rhsAlt : rhsAlts ) {
+                                                        // multiple assignment
+                                                        ResolvExpr::AltList rhs;
+                                                        explode( rhsAlt, currentFinder.get_indexer(), 
+                                                                std::back_inserter(rhs), true );
+                                                        matcher.reset( new MultipleAssignMatcher( *this, lhs, rhs ) );
+                                                        match();
+                                                }
+                                        } else {
+                                                for ( const ResolvExpr::Alternative& rhsAlt : args[1] ) {
+                                                        ResolvExpr::AltList rhs;
+                                                        if ( isTuple(rhsAlt.expr) ) {
+                                                                // multiple assignment
+                                                                explode( rhsAlt, currentFinder.get_indexer(),  
+                                                                        std::back_inserter(rhs), true );
+                                                                matcher.reset( new MultipleAssignMatcher( *this, lhs, rhs ) );
+                                                        } else {
+                                                                // mass assignment
+                                                                rhs.push_back( rhsAlt );
+                                                                matcher.reset( new MassAssignMatcher( *this, lhs, rhs ) );
+                                                        }
+                                                        match();
+                                                }
                                         }
                                 }
@@ -174 +222 @@
                 ResolvExpr::AltList current;
                 // now resolve new assignments
-                for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
+                for ( std::list< Expression * >::iterator i = new_assigns.begin(); 
+                                i != new_assigns.end(); ++i ) {
                         PRINT(
                                 std::cerr << "== resolving tuple assign ==" << std::endl;
@@ -180 +229 @@
                         )
 
-                        ResolvExpr::AlternativeFinder finder( currentFinder.get_indexer(), currentFinder.get_environ() );
+                        ResolvExpr::AlternativeFinder finder{ currentFinder.get_indexer(), 
+                                currentFinder.get_environ() };
                         try {
                                 finder.findWithAdjustment(*i);
@@ -201 +251 @@
                 // combine assignment environments into combined expression environment
                 simpleCombineEnvironments( current.begin(), current.end(), matcher->compositeEnv );
-                currentFinder.get_alternatives().push_front( ResolvExpr::Alternative(new TupleAssignExpr(solved_assigns, matcher->tmpDecls), matcher->compositeEnv, ResolvExpr::sumCost( current  ) + matcher->baseCost ) );
-        }
-
-        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList &alts ) : spotter(spotter), baseCost( ResolvExpr::sumCost( alts ) ) {
-                assert( ! alts.empty() );
-                // combine argument environments into combined expression environment
-                simpleCombineEnvironments( alts.begin(), alts.end(), compositeEnv );
-
-                ResolvExpr::Alternative lhsAlt = alts.front();
-                // explode is aware of casts - ensure every LHS expression is sent into explode with a reference cast
-                if ( ! dynamic_cast< CastExpr * >( lhsAlt.expr ) ) {
-                        lhsAlt.expr = new CastExpr( lhsAlt.expr, new ReferenceType( Type::Qualifiers(), lhsAlt.expr->get_result()->clone() ) );
-                }
-
-                // explode the lhs so that each field of the tuple-valued-expr is assigned.
-                explode( lhsAlt, spotter.currentFinder.get_indexer(), back_inserter(lhs), true );
-
-                for ( ResolvExpr::Alternative & alt : lhs ) {
-                        // every LHS value must be a reference - some come in with a cast expression, if it doesn't just cast to reference here.
-                        if ( ! dynamic_cast< ReferenceType * >( alt.expr->get_result() ) ) {
-                                alt.expr = new CastExpr( alt.expr, new ReferenceType( Type::Qualifiers(), alt.expr->get_result()->clone() ) );
-                        }
-                }
-        }
-
-        TupleAssignSpotter::MassAssignMatcher::MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts ) : Matcher( spotter, alts ) {
-                assert( alts.size() == 1 || alts.size() == 2 );
-                if ( alts.size() == 2 ) {
-                        rhs.push_back( alts.back() );
-                }
-        }
-
-        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), true );
+                currentFinder.get_alternatives().push_front( ResolvExpr::Alternative(
+                        new TupleAssignExpr(solved_assigns, matcher->tmpDecls), matcher->compositeEnv, 
+                        ResolvExpr::sumCost( current ) + matcher->baseCost ) );
+        }
+
+        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter, 
+                const ResolvExpr::AltList &lhs, const ResolvExpr::AltList &rhs ) 
+        : lhs(lhs), rhs(rhs), spotter(spotter), 
+          baseCost( ResolvExpr::sumCost( lhs ) + ResolvExpr::sumCost( rhs ) ) {
+                simpleCombineEnvironments( lhs.begin(), lhs.end(), compositeEnv );
+                simpleCombineEnvironments( rhs.begin(), rhs.end(), compositeEnv );
         }
 
@@ -259 +285 @@
 
         ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) {
-                assert( expr->result && ! expr->get_result()->isVoid() );
+                assert( expr->has_result() && ! expr->get_result()->isVoid() );
                 ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
                 // if expression type is a reference, don't need to construct anything, a simple initializer is sufficient.
@@ -269 +295 @@
                         ctorInit->accept( rm );
                 }
-                PRINT( std::cerr << "new object: " << ret << std::endl; )
                 return ret;
         }