Changeset c43c171

Timestamp:

Oct 5, 2017, 3:55:26 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:

b5a8ef7

Parents:

a585396

Message:

Add tuple handling to iterative resolver rewrite

Location:

src

Files:

• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• Tuples/Explode.h (modified) (2 diffs)
• Tuples/TupleAssignment.cc (modified) (9 diffs)
• Tuples/Tuples.h (modified) (2 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -887 +887 @@
                 // take care of possible tuple assignments
                 // if not tuple assignment, assignment is taken care of as a normal function call
-/*FIX   Tuples::handleTupleAssignment( *this, untypedExpr, possibilities );
-*/
+                Tuples::handleTupleAssignment( *this, untypedExpr, argAlternatives );
+
                 // find function operators
                 AlternativeFinder funcOpFinder( indexer, env );

src/Tuples/Explode.h

@@ -30 +30 @@
         Expression * distributeReference( Expression * );
 
+        static inline CastExpr * isReferenceCast( Expression * expr ) {
+                if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
+                        if ( dynamic_cast< ReferenceType * >( castExpr->result ) ) {
+                                return castExpr;
+                        }
+                }
+                return nullptr;
+        }
+
         /// helper function used by explode
         template< typename OutputIterator >
@@ -35 +44 @@
                 if ( isTupleAssign ) {
                         // tuple assignment needs CastExprs to be recursively exploded to easily get at all of the components
-                        if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
+                        if ( CastExpr * castExpr = isReferenceCast( expr ) ) {
                                 ResolvExpr::AltList alts;
                                 explodeUnique( castExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );

src/Tuples/TupleAssignment.cc

@@ -20 +20 @@
 #include <memory>                          // for unique_ptr, allocator_trai...
 #include <string>                          // for string
+#include <vector>
 
 #include "CodeGen/OperatorTable.h"
@@ -33 +34 @@
 #include "ResolvExpr/Resolver.h"           // for resolveCtorInit
 #include "ResolvExpr/TypeEnvironment.h"    // for TypeEnvironment
+#include "ResolvExpr/typeops.h"            // for combos
 #include "SynTree/Declaration.h"           // for ObjectDecl
 #include "SynTree/Expression.h"            // for Expression, CastExpr, Name...
@@ -46 +48 @@
                 // dispatcher for Tuple (multiple and mass) assignment operations
                 TupleAssignSpotter( ResolvExpr::AlternativeFinder & );
-                void spot( UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities );
+                void spot( UntypedExpr * expr, std::vector<ResolvExpr::AlternativeFinder> &args );
 
           private:
@@ -53 +55 @@
                 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;
@@ -66 +69 @@
                 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 );
                 };
@@ -72 +76 @@
                 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 );
                 };
@@ -108 +113 @@
         }
 
-        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities ) {
+        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr, 
+                                std::vector<ResolvExpr::AlternativeFinder> &args ) {
                 TupleAssignSpotter spotter( currentFinder );
-                spotter.spot( expr, possibilities );
+                spotter.spot( expr, args );
         }
 
@@ -116 +122 @@
                 : currentFinder(f) {}
 
-        void TupleAssignSpotter::spot( UntypedExpr * expr, const std::list<ResolvExpr::AltList> &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();
-                                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;
+
+                                // 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();
-                                        if ( refToTuple(alt1.expr) ) {
-                                                if ( isMultAssign( begin, end ) ) {
-                                                        matcher.reset( new MultipleAssignMatcher( *this, *ali ) );
-                                                } else {
-                                                        // mass assignment
-                                                        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() ) );
                                                 }
-                                                match();
+                                        }
+
+                                        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();
+                                                }
                                         }
                                 }
@@ -183 +236 @@
         }
 
-        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 );
-        }
+        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 ) ) {}
 
         UntypedExpr * createFunc( const std::string &fname, ObjectDecl *left, ObjectDecl *right ) {

src/Tuples/Tuples.h

@@ -17 +17 @@
 
 #include <string>
+#include <vector>
 
 #include "SynTree/Expression.h"
@@ -26 +27 @@
 namespace Tuples {
         // TupleAssignment.cc
-        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * assign, const std::list<ResolvExpr::AltList> & possibilities );
-
+        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * assign, 
+                std::vector< ResolvExpr::AlternativeFinder >& args );
+        
         // TupleExpansion.cc
         /// expands z.[a, b.[x, y], c] into [z.a, z.b.x, z.b.y, z.c], inserting UniqueExprs as appropriate