Changeset 3c13c03

Timestamp:

Sep 17, 2016, 8:27:51 AM (9 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

8c49c0e

Parents:

12bc63a

Message:

expand TupleExpr? and TupleIndexExpr?, add UniqueExpr?

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (2 diffs)
• CodeGen/CodeGenerator.h (modified) (1 diff)
• CodeGen/GenType.cc (modified) (1 diff)
• Common/utility.h (modified) (2 diffs)
• ResolvExpr/Alternative.cc (modified) (1 diff)
• ResolvExpr/Alternative.h (modified) (4 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (2 diffs)
• SymTab/Validate.cc (modified) (1 diff)
• SynTree/Expression.cc (modified) (4 diffs)
• SynTree/Expression.h (modified) (2 diffs)
• SynTree/Mutator.cc (modified) (1 diff)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/TupleExpr.cc (modified) (5 diffs)
• SynTree/Visitor.cc (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)
• Tuples/TupleAssignment.cc (modified) (12 diffs)
• Tuples/TupleExpansion.cc (modified) (2 diffs)
• Tuples/Tuples.h (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -639 +639 @@
         }
 
-        void CodeGenerator::visit( TupleExpr * tupleExpr ) {}
+        void CodeGenerator::visit( TupleExpr * tupleExpr ) { assert( false ); }
 
         void CodeGenerator::visit( TypeExpr * typeExpr ) {}
@@ -655 +655 @@
         }
 
+        void CodeGenerator::visit( CompoundLiteralExpr *compLitExpr ) {
+                assert( compLitExpr->get_type() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
+                output << "(" << genType( compLitExpr->get_type(), "" ) << ")";
+                compLitExpr->get_initializer()->accept( *this );
+        }
+
         void CodeGenerator::visit( StmtExpr * stmtExpr ) {
-                output << "(";
-                stmtExpr->get_statements()->accept( *this );
-                output << ")";
+                std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
+                output << "({" << std::endl;
+                cur_indent += CodeGenerator::tabsize;
+                unsigned int numStmts = stmts.size();
+                unsigned int i = 0;
+                for ( Statement * stmt : stmts ) {
+                        output << indent << printLabels( stmt->get_labels() );
+                        if ( i+1 == numStmts ) {
+                                // last statement in a statement expression needs to be handled specially -
+                                // cannot cast to void, otherwise the expression statement has no value
+                                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
+                                        exprStmt->get_expr()->accept( *this );
+                                        output << ";" << endl;
+                                        ++i;
+                                        break;
+                                }
+                        }
+                        stmt->accept( *this );
+                        output << endl;
+                        if ( wantSpacing( stmt ) ) {
+                                output << endl;
+                        } // if
+                        ++i;
+                }
+                cur_indent -= CodeGenerator::tabsize;
+                output << indent << "})";
         }
 

src/CodeGen/CodeGenerator.h

@@ -70 +70 @@
                 virtual void visit( ConditionalExpr *conditionalExpr );
                 virtual void visit( CommaExpr *commaExpr );
+                virtual void visit( CompoundLiteralExpr *compLitExpr );
                 virtual void visit( TupleExpr *tupleExpr );
                 virtual void visit( TypeExpr *typeExpr );

src/CodeGen/GenType.cc

@@ -213 +213 @@
                         typeString = "_Atomic " + typeString;
                 } // if
-                if ( type->get_isAttribute() ) {
-                        typeString = "__attribute(( )) " + typeString;
-                } // if
         }
 } // namespace CodeGen

src/Common/utility.h

@@ -158 +158 @@
 }
 
+// replace element of list with all elements of another list
 template< typename T >
 void replace( std::list< T > &org, typename std::list< T >::iterator pos, std::list< T > &with ) {
@@ -168 +169 @@
 
         return;
+}
+
+// replace range of a list with a single element
+template< typename T >
+void replace( std::list< T > &org, typename std::list< T >::iterator begin, typename std::list< T >::iterator end, const T & with ) {
+        org.insert( begin, with );
+        org.erase( begin, end );
 }
 

src/ResolvExpr/Alternative.cc

@@ -20 +20 @@
 
 namespace ResolvExpr {
-        Alternative::Alternative() : expr( 0 ) {}
+        Alternative::Alternative() : cost( Cost::zero ), cvtCost( Cost::zero ), expr( 0 ) {}
 
         Alternative::Alternative( Expression *expr, const TypeEnvironment &env, const Cost& cost )

src/ResolvExpr/Alternative.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Alternative.h -- 
+// Alternative.h --
 //
 // Author           : Richard C. Bilson
@@ -12 +12 @@
 // Last Modified On : Sat May 16 23:54:39 2015
 // Update Count     : 2
-// 
+//
 
 #ifndef ALTERNATIVE_H
@@ -33 +33 @@
                 Alternative &operator=( const Alternative &other );
                 ~Alternative();
-  
+
                 void initialize( const Alternative &src, Alternative &dest );
-  
+
                 void print( std::ostream &os, int indent = 0 ) const;
-  
+
                 Cost cost;
                 Cost cvtCost;
@@ -43 +43 @@
                 TypeEnvironment env;
         };
+
+        /// helper function used by explode
+        template< typename OutputIterator >
+        void explodeUnique( Expression * expr, const Alternative & alt, OutputIterator out ) {
+                Type * res = expr->get_result();
+                if ( TupleType * tupleType = dynamic_cast< TupleType * > ( res ) ) {
+                        if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( alt.expr ) ) {
+                                for ( Expression * expr : tupleExpr->get_exprs() ) {
+                                        explodeUnique( expr, alt, out );
+                                }
+                        } else {
+                                UniqueExpr * unq = new UniqueExpr( expr->clone() );
+                                for ( unsigned int i = 0; i < tupleType->size(); i++ ) {
+                                        TupleIndexExpr * idx = new TupleIndexExpr( unq->clone(), i );
+                                        explodeUnique( idx, alt, out );
+                                        delete idx;
+                                }
+                                delete unq;
+                        }
+                } else {
+                        *out++ = Alternative( expr->clone(), alt.env, alt.cost, alt.cvtCost );
+                }
+        }
+
+        /// expands a tuple-valued alternative into multiple alternatives, each with a non-tuple-type
+        template< typename OutputIterator >
+        void explode( Alternative &alt, OutputIterator out ) {
+                explodeUnique( alt.expr, alt, out );
+        }
+
+        // explode list of alternatives
+        template< typename OutputIterator >
+        void explode( AltList & alts, OutputIterator out ) {
+                for ( Alternative & alt : alts ) {
+                        explode( alt, out );
+                }
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/AlternativeFinder.cc

@@ -380 +380 @@
 
                 std::list< DeclarationWithType* >::iterator formal = formals.begin();
+
+                AltList newActuals;
+                explode( actuals, back_inserter( newActuals ) );
 
                 std::list< Type * > formalTypes;
@@ -994 +997 @@
                         TupleExpr *newExpr = new TupleExpr;
                         makeExprList( *i, newExpr->get_exprs() );
-                        TupleType *tupleType = new TupleType( Type::Qualifiers(true, true, true, true, true, true) );
-                        Type::Qualifiers &qualifiers = tupleType->get_qualifiers();
-                        for ( Expression * resultExpr : newExpr->get_exprs() ) {
-                                Type * type = resultExpr->get_result()->clone();
-                                tupleType->get_types().push_back( type );
-                                qualifiers &= type->get_qualifiers();
-                        } // for
-                        newExpr->set_result( tupleType );
+                        newExpr->set_result( Tuples::makeTupleType( newExpr->get_exprs() ) );
 
                         TypeEnvironment compositeEnv;

src/SymTab/Validate.cc

@@ -23 +23 @@
 // - All enumeration constants have type EnumInstType.
 //
-// - The type "void" never occurs in lists of function parameter or return types; neither do tuple types.  A function
-//   taking no arguments has no argument types, and tuples are flattened.
+// - The type "void" never occurs in lists of function parameter or return types.  A function
+//   taking no arguments has no argument types.
 //
 // - No context instances exist; they are all replaced by the set of declarations signified by the context, instantiated

src/SynTree/Expression.cc

@@ -522 +522 @@
 
 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
+        assert( type && initializer );
         set_result( type->clone() );
 }
 
-CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
+CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( other.type->clone() ), initializer( other.initializer->clone() ) {}
 
 CompoundLiteralExpr::~CompoundLiteralExpr() {
@@ -534 +535 @@
 void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
         os << "Compound Literal Expression: " << std::endl;
-        if ( type ) type->print( os, indent + 2 );
-        if ( initializer ) initializer->print( os, indent + 2 );
+        os << std::string( indent+2, ' ' );
+        type->print( os, indent + 2 );
+        os << std::string( indent+2, ' ' );
+        initializer->print( os, indent + 2 );
 }
 
@@ -549 +552 @@
 
 RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
-RangeExpr::RangeExpr( const RangeExpr &other ) : low( other.low->clone() ), high( other.high->clone() ) {}
+RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
 void RangeExpr::print( std::ostream &os, int indent ) const {
-        os << std::string( indent, ' ' ) << "Range Expression: ";
+        os << "Range Expression: ";
         low->print( os, indent );
         os << " ... ";
@@ -566 +569 @@
         }
 }
-StmtExpr::StmtExpr( const StmtExpr &other ) : statements( other.statements->clone() ) {}
+StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {}
 StmtExpr::~StmtExpr() {
         delete statements;
 }
 void StmtExpr::print( std::ostream &os, int indent ) const {
-        os << std::string( indent, ' ' ) << "Statement Expression: " << std::endl;
+        os << "Statement Expression: " << std::endl << std::string( indent, ' ' );
         statements->print( os, indent+2 );
+}
+
+
+UniqueExpr::UniqueExpr( Expression *expr ) : expr( new Expression* ) {
+        set_expr( expr );
+        assert( expr );
+        assert( expr->has_result() );
+        set_result( expr->get_result()->clone() );
+}
+UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( other.expr ) {
+}
+UniqueExpr::~UniqueExpr() {
+        if ( expr.unique() ) {
+                delete *expr;
+        }
+}
+void UniqueExpr::print( std::ostream &os, int indent ) const {
+        os << "Unique Expression: " << std::endl << std::string( indent+2, ' ' );
+        get_expr()->print( os, indent+2 );
 }
 

src/SynTree/Expression.h

@@ -639 +639 @@
 class TupleExpr : public Expression {
   public:
-        TupleExpr( Expression *_aname = nullptr );
+        TupleExpr( const std::list< Expression * > & exprs = std::list< Expression * >(), Expression *_aname = nullptr );
         TupleExpr( const TupleExpr &other );
         virtual ~TupleExpr();
@@ -733 +733 @@
 };
 
+class UniqueExpr : public Expression {
+public:
+        UniqueExpr( Expression * expr );
+        UniqueExpr( const UniqueExpr & other );
+        ~UniqueExpr();
+
+        Expression * get_expr() const { return *expr; }
+        UniqueExpr * set_expr( Expression * newValue ) { *expr = newValue; return this; }
+
+        virtual UniqueExpr *clone() const { return new UniqueExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+        std::shared_ptr< Expression * > expr;
+};
+
 std::ostream & operator<<( std::ostream & out, const Expression * expr );
 

src/SynTree/Mutator.cc

@@ -384 +384 @@
 }
 
+Expression *Mutator::mutate( UniqueExpr *uniqueExpr ) {
+        uniqueExpr->set_result( maybeMutate( uniqueExpr->get_result(), *this ) );
+        uniqueExpr->set_expr( maybeMutate( uniqueExpr->get_expr(), *this ) );
+        return uniqueExpr;
+}
+
 Type *Mutator::mutate( VoidType *voidType ) {
         mutateAll( voidType->get_forall(), *this );

src/SynTree/Mutator.h

@@ -83 +83 @@
         virtual Expression* mutate( TupleAssignExpr *assignExpr );
         virtual Expression* mutate( StmtExpr * stmtExpr );
+        virtual Expression* mutate( UniqueExpr * uniqueExpr );
 
         virtual Type* mutate( VoidType *basicType );

src/SynTree/SynTree.h

@@ -88 +88 @@
 class TupleAssignExpr;
 class StmtExpr;
+class UniqueExpr;
 
 class Type;

src/SynTree/TupleExpr.cc

@@ -18 +18 @@
 #include "Type.h"
 #include "Declaration.h"
+#include "Tuples/Tuples.h"
 
-TupleExpr::TupleExpr( Expression *_aname ) : Expression( _aname ) {
+TupleExpr::TupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
+        if ( ! exprs.empty() ) {
+                if ( std::all_of( exprs.begin(), exprs.end(), [](Expression * expr) { return expr->get_result(); } ) ) {
+                        set_result( Tuples::makeTupleType( exprs ) );
+                }
+        }
 }
 
@@ -36 +42 @@
 }
 
-TupleIndexExpr::TupleIndexExpr( Expression * tuple, unsigned int index ) {
+TupleIndexExpr::TupleIndexExpr( Expression * tuple, unsigned int index ) : tuple( tuple ), index( index )  {
         TupleType * type = safe_dynamic_cast< TupleType * >( tuple->get_result() );
-        assert( type->size() >= index );
-        set_result( *std::next( type->get_types().begin(), index ) );
+        assert( type->size() > index );
+        set_result( (*std::next( type->get_types().begin(), index ))->clone() );
 }
 
@@ -51 +57 @@
 void TupleIndexExpr::print( std::ostream &os, int indent ) const {
         os << "Tuple Index Expression, with tuple:" << std::endl;
+        os << std::string( indent+2, ' ' );
         tuple->print( os, indent+2 );
         os << std::string( indent+2, ' ' ) << "with index: " << index << std::endl;
@@ -70 +77 @@
 void MemberTupleExpr::print( std::ostream &os, int indent ) const {
         os << "Member Tuple Expression, with aggregate:" << std::endl;
+        os << std::string( indent+2, ' ' );
         aggregate->print( os, indent+2 );
         os << std::string( indent+2, ' ' ) << "with member: " << std::endl;
+        os << std::string( indent+2, ' ' );
         member->print( os, indent+2 );
         Expression::print( os, indent );
@@ -97 +106 @@
 
 void TupleAssignExpr::print( std::ostream &os, int indent ) const {
-        os << std::string( indent, ' ' ) << "Tuple Assignment Expression, with temporaries:" << std::endl;
+        os << "Tuple Assignment Expression, with temporaries:" << std::endl;
         printAll( tempDecls, os, indent+4 );
         os << std::string( indent+2, ' ' ) << "with assignments: " << std::endl;

src/SynTree/Visitor.cc

@@ -326 +326 @@
 }
 
+void Visitor::visit( UniqueExpr *uniqueExpr ) {
+        maybeAccept( uniqueExpr->get_result(), *this );
+        maybeAccept( uniqueExpr->get_expr(), *this );
+}
+
 void Visitor::visit( VoidType *voidType ) {
         acceptAll( voidType->get_forall(), *this );

src/SynTree/Visitor.h

@@ -83 +83 @@
         virtual void visit( TupleAssignExpr *assignExpr );
         virtual void visit( StmtExpr * stmtExpr );
+        virtual void visit( UniqueExpr * uniqueExpr );
 
         virtual void visit( VoidType *basicType );

src/Tuples/TupleAssignment.cc

@@ -39 +39 @@
           private:
                 void match();
-                // records for assignment generation
-                struct Options {
-                        void print( std::ostream & );
-                        int size() const { return options.size(); }
-                        bool empty() const { return options.empty(); }
-                        typedef std::list< ResolvExpr::AltList >::iterator iterator;
-                        iterator begin() { return options.begin(); }
-                        iterator end() { return options.end(); }
-
-                        std::list< ResolvExpr::AltList > options;
-                };
 
                 struct Matcher {
                   public:
-                        Matcher( TupleAssignSpotter &spotter, Expression *_lhs, Expression *_rhs );
+                        Matcher( TupleAssignSpotter &spotter, ResolvExpr::Alternative & lhs, ResolvExpr::Alternative & rhs );
                         virtual ~Matcher() {}
                         virtual void match( std::list< Expression * > &out ) = 0;
-                        std::list< Expression * > lhs, rhs;
+                        ResolvExpr::AltList lhs, rhs;
                         TupleAssignSpotter &spotter;
                         std::list< ObjectDecl * > tmpDecls;
@@ -63 +52 @@
                 struct MassAssignMatcher : public Matcher {
                   public:
-                        MassAssignMatcher( TupleAssignSpotter &spotter, Expression *lhs, Expression *rhs ) : Matcher( spotter, lhs, rhs ) {
-                                this->rhs.push_back( rhs );
-                        }
+                        MassAssignMatcher( TupleAssignSpotter &spotter, ResolvExpr::Alternative & lhs, ResolvExpr::Alternative & rhs );
                         virtual void match( std::list< Expression * > &out );
                 };
@@ -71 +58 @@
                 struct MultipleAssignMatcher : public Matcher {
                   public:
-                        MultipleAssignMatcher( TupleAssignSpotter &spot, Expression *lhs, Expression *rhs );
+                        MultipleAssignMatcher( TupleAssignSpotter &spot, ResolvExpr::Alternative & lhs, ResolvExpr::Alternative & rhs );
                         virtual void match( std::list< Expression * > &out );
                 };
@@ -78 +65 @@
                 // Expression *rhs, *lhs;
                 Matcher *matcher = nullptr;
-                Options options;
         };
-
-        bool isTupleVar( DeclarationWithType *decl ) {
-                return dynamic_cast< TupleType * >( decl->get_type() );
-        }
 
         /// true if expr is an expression of tuple type, i.e. a tuple expression, tuple variable, or MRV (multiple-return-value) function
@@ -89 +71 @@
                 if ( ! expr ) return false;
                 assert( expr->has_result() );
-                // xxx - used to include cast to varExpr and call to isTupleVar, but this doesn't seem like it should be necessary
                 return dynamic_cast<TupleExpr *>(expr) || expr->get_result()->size() > 1;
         }
@@ -101 +82 @@
         }
 
-        bool isTupleExpr( Expression *expr ) {
-                assert( expr->has_result() );
-                return expr->get_result()->size() > 1;
-        }
-
         void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr, std::list<ResolvExpr::AltList> &possibilities ) {
                 TupleAssignSpotter spotter( currentFinder );
@@ -116 +92 @@
         void TupleAssignSpotter::spot( UntypedExpr * expr, std::list<ResolvExpr::AltList> &possibilities ) {
                 if (  NameExpr *assgnop = dynamic_cast< NameExpr * >(expr->get_function()) ) {
-                        if ( assgnop->get_name() == std::string("?=?") ) {
+                        if ( assgnop->get_name() == "?=?" ) {
                                 for ( std::list<ResolvExpr::AltList>::iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) {
-                                        assert( ali->size() == 2 );
-                                        ResolvExpr::Alternative op1 = ali->front(), op2 = ali->back();
-
-                                        MultipleAssignMatcher multiMatcher( *this, op1.expr, op2.expr );
-                                        MassAssignMatcher massMatcher( *this, op1.expr, op2.expr );
-                                        if ( pointsToTuple(op1.expr) ) { // also handles tuple vars
-                                                if ( isTuple( op2.expr ) ) {
+                                        if ( ali->size() != 2 ) continue; // what does it mean if an assignment takes >2 arguments? grab args 2-N and group into a TupleExpr, then proceed?
+                                        ResolvExpr::Alternative & alt1 = ali->front(), & alt2 = ali->back();
+
+                                        if ( pointsToTuple(alt1.expr) ) {
+                                                MultipleAssignMatcher multiMatcher( *this, alt1, alt2 );
+                                                MassAssignMatcher massMatcher( *this,  alt1, alt2 );
+                                                if ( isTuple( alt2.expr ) ) {
                                                         matcher = &multiMatcher;
                                                 } else {
@@ -131 +107 @@
                                                 }
                                                 match();
-                                        } else if ( isTuple( op2.expr ) ) {
+                                        } else if ( isTuple( alt2.expr ) ) {
                                                 throw SemanticError("Cannot assign a tuple value into a non-tuple lvalue.", expr);
                                         }
@@ -170 +146 @@
         }
 
-        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter, Expression *lhs, Expression *rhs ) : spotter(spotter) {
-                // xxx - shouldn't need to be &<tuple-expr>, just &<lvalue-tuple-type>
-                if (AddressExpr *addr = dynamic_cast<AddressExpr *>(lhs) )
-                        if ( TupleExpr *tuple = dynamic_cast<TupleExpr *>(addr->get_arg()) )
-                                std::copy( tuple->get_exprs().begin(), tuple->get_exprs().end(), back_inserter(this->lhs) );
-        }
-
-        TupleAssignSpotter::MultipleAssignMatcher::MultipleAssignMatcher( TupleAssignSpotter &spotter, Expression *lhs, Expression *rhs ) : Matcher( spotter, lhs, rhs ) {
-
-                if ( TupleExpr *tuple = dynamic_cast<TupleExpr *>(rhs) )
-                        std::copy( tuple->get_exprs().begin(), tuple->get_exprs().end(), back_inserter(this->rhs) );
+        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter, ResolvExpr::Alternative & lhs, ResolvExpr::Alternative & rhs ) : spotter(spotter) {
+                if (AddressExpr *addr = dynamic_cast<AddressExpr *>(lhs.expr) ) {
+                        // xxx - not every assignment NEEDS to have the first argument as address-taken, e.g. a manual call to assignment. What to do in this case? skip it as a possibility for TupleAssignment, since the type will always be T*, where T can never be a tuple? Is this true?
+
+                        // explode the lhs so that each field of the tuple-valued-expr is assigned.
+                        ResolvExpr::Alternative lhsAlt( addr->get_arg()->clone(), lhs.env, lhs.cost, lhs.cvtCost );
+                        explode( lhsAlt, back_inserter(this->lhs) );
+                }
+        }
+
+        TupleAssignSpotter::MassAssignMatcher::MassAssignMatcher( TupleAssignSpotter &spotter, ResolvExpr::Alternative & lhs, ResolvExpr::Alternative & rhs ) : Matcher( spotter, lhs, rhs ) {
+                this->rhs.push_back( rhs );
+        }
+
+        TupleAssignSpotter::MultipleAssignMatcher::MultipleAssignMatcher( TupleAssignSpotter &spotter, ResolvExpr::Alternative & lhs, ResolvExpr::Alternative & rhs ) : Matcher( spotter, lhs, rhs ) {
+
+                // explode the rhs so that each field of the tuple-valued-expr is assigned.
+                explode( rhs, back_inserter(this->rhs) );
         }
 
@@ -201 +184 @@
                 assert ( ! lhs.empty() && rhs.size() == 1);
 
-                ObjectDecl * rtmp = newObject( rhsNamer, rhs.front() );
-                for ( Expression * l : lhs ) {
-                        ObjectDecl * ltmp = newObject( lhsNamer, new AddressExpr( l ) );
+                ObjectDecl * rtmp = newObject( rhsNamer, rhs.front().expr );
+                for ( ResolvExpr::Alternative & lhsAlt : lhs ) {
+                        ObjectDecl * ltmp = newObject( lhsNamer, new AddressExpr( lhsAlt.expr ) );
                         out.push_back( createAssgn( ltmp, rtmp ) );
                         tmpDecls.push_back( ltmp );
@@ -217 +200 @@
                         std::list< ObjectDecl * > ltmp;
                         std::list< ObjectDecl * > rtmp;
-                        std::transform( lhs.begin(), lhs.end(), back_inserter( ltmp ), []( Expression * expr ){
-                                return newObject( lhsNamer, new AddressExpr( expr ) );
+                        std::transform( lhs.begin(), lhs.end(), back_inserter( ltmp ), []( ResolvExpr::Alternative & alt ){
+                                return newObject( lhsNamer, new AddressExpr( alt.expr ) );
                         });
-                        std::transform( rhs.begin(), rhs.end(), back_inserter( rtmp ), []( Expression * expr ){
-                                return newObject( rhsNamer, 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), createAssgn );
@@ -227 +210 @@
                         tmpDecls.splice( tmpDecls.end(), rtmp );
                 }
-        }
-
-        void TupleAssignSpotter::Options::print( std::ostream &ostr ) {
-                for ( ResolvExpr::AltList & l : options ) {
-                        for ( ResolvExpr::Alternative & alt : l ) {
-                                alt.print( ostr );
-                                ostr << " ";
-                        }
-                        ostr << std::endl;
-                } // for
         }
 } // namespace Tuples

src/Tuples/TupleExpansion.cc

@@ -23 +23 @@
 #include "SynTree/Declaration.h"
 #include "SynTree/Type.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Initializer.h"
 #include "SymTab/Mangler.h"
 #include "Common/ScopedMap.h"
 
 namespace Tuples {
-        class TupleAssignExpander : public Mutator {
-        public:
-                virtual Expression * mutate( TupleAssignExpr * tupleExpr );
-        };
+        namespace {
+                class UniqueExprExpander : public GenPoly::DeclMutator {
+                public:
+                        typedef GenPoly::DeclMutator Parent;
+                        virtual Expression * mutate( UniqueExpr * unqExpr );
+                        std::map< Expression *, ObjectDecl * > decls;
+                };
 
-        class TupleTypeReplacer : public GenPoly::DeclMutator {
-          public:
-                typedef GenPoly::DeclMutator Parent;
+                class TupleAssignExpander : public Mutator {
+                public:
+                        typedef Mutator Parent;
+                        virtual Expression * mutate( TupleAssignExpr * tupleExpr );
+                };
 
-                virtual Type * mutate( TupleType * tupleType );
+                class TupleTypeReplacer : public GenPoly::DeclMutator {
+                  public:
+                        typedef GenPoly::DeclMutator Parent;
 
-                virtual CompoundStmt * mutate( CompoundStmt * stmt ) {
-                        typeMap.beginScope();
-                        stmt = Parent::mutate( stmt );
-                        typeMap.endScope();
-                        return stmt;
-                }
-          private:
-                ScopedMap< std::string, StructDecl * > typeMap;
-        };
+                        virtual Type * mutate( TupleType * tupleType );
+
+                        virtual CompoundStmt * mutate( CompoundStmt * stmt ) {
+                                typeMap.beginScope();
+                                stmt = Parent::mutate( stmt );
+                                typeMap.endScope();
+                                return stmt;
+                        }
+                  private:
+                        ScopedMap< std::string, StructDecl * > typeMap;
+                };
+
+                class TupleIndexExpander : public Mutator {
+                public:
+                        typedef Mutator Parent;
+                        virtual Expression * mutate( TupleIndexExpr * tupleExpr );
+                };
+
+                class TupleExprExpander : public Mutator {
+                public:
+                        typedef Mutator Parent;
+                        virtual Expression * mutate( TupleExpr * tupleExpr );
+                };
+        }
 
         void expandTuples( std::list< Declaration * > & translationUnit ) {
-                TupleAssignExpander expander;
-                mutateAll( translationUnit, expander );
+                UniqueExprExpander unqExpander;
+                unqExpander.mutateDeclarationList( translationUnit );
+
+                TupleAssignExpander assnExpander;
+                mutateAll( translationUnit, assnExpander );
 
                 TupleTypeReplacer replacer;
                 replacer.mutateDeclarationList( translationUnit );
+
+                TupleIndexExpander idxExpander;
+                mutateAll( translationUnit, idxExpander );
+
+                TupleExprExpander exprExpander;
+                mutateAll( translationUnit, exprExpander );
         }
 
-        Expression * TupleAssignExpander::mutate( TupleAssignExpr * tupleExpr ) {
+        Expression * UniqueExprExpander::mutate( UniqueExpr * unqExpr ) {
+                static UniqueName tempNamer( "_unq_expr_" );
+                unqExpr = safe_dynamic_cast< UniqueExpr * > ( Parent::mutate( unqExpr ) );
+                if ( ! decls.count( unqExpr->get_expr() ) ) {
+                        // xxx - it's possible (likely?) that expressions can appear in the wrong order because of this. Need to ensure they're placed in the correct location.
+                        ObjectDecl * decl = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, unqExpr->get_result()->clone(), new SingleInit( unqExpr->get_expr()->clone() ) );
+                        decls[unqExpr->get_expr()] = decl;
+                        addDeclaration( decl );
+                }
+                return new VariableExpr( decls[unqExpr->get_expr()] );
+        }
+
+        Expression * TupleAssignExpander::mutate( TupleAssignExpr * assnExpr ) {
+                // xxx - Parent::mutate?
                 CompoundStmt * compoundStmt = new CompoundStmt( noLabels );
                 std::list< Statement * > & stmts = compoundStmt->get_kids();
-                for ( ObjectDecl * obj : tupleExpr->get_tempDecls() ) {
+                for ( ObjectDecl * obj : assnExpr->get_tempDecls() ) {
                         stmts.push_back( new DeclStmt( noLabels, obj ) );
                 }
-                for ( Expression * assign : tupleExpr->get_assigns() ) {
-                        stmts.push_back( new ExprStmt( noLabels, assign ) );
-                }
-                tupleExpr->get_tempDecls().clear();
-                tupleExpr->get_assigns().clear();
-                delete tupleExpr;
+                TupleExpr * tupleExpr = new TupleExpr( assnExpr->get_assigns() );
+                assert( tupleExpr->get_result() );
+                stmts.push_back( new ExprStmt( noLabels, tupleExpr ) );
+                assnExpr->get_tempDecls().clear();
+                assnExpr->get_assigns().clear();
+                delete assnExpr;
                 return new StmtExpr( compoundStmt );
         }
@@ -90 +136 @@
         }
 
+        Expression * TupleIndexExpander::mutate( TupleIndexExpr * tupleExpr ) {
+                Expression * tuple = maybeMutate( tupleExpr->get_tuple(), *this );
+                assert( tuple );
+                tupleExpr->set_tuple( nullptr );
+                unsigned int idx = tupleExpr->get_index();
+                delete tupleExpr;
+
+                StructInstType * type = safe_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);
+                return new MemberExpr( safe_dynamic_cast< DeclarationWithType * >( member ), tuple );
+        }
+
+        Expression * TupleExprExpander::mutate( TupleExpr * tupleExpr ) {
+                assert( tupleExpr->get_result() );
+                std::list< Initializer * > inits;
+                for ( Expression * expr : tupleExpr->get_exprs() ) {
+                        inits.push_back( new SingleInit( expr ) );
+                }
+                return new CompoundLiteralExpr( tupleExpr->get_result(), new ListInit( inits ) );
+        }
+
+        TupleType * makeTupleType( const std::list< Expression * > & exprs ) {
+                TupleType *tupleType = new TupleType( Type::Qualifiers(true, true, true, true, true, false) );
+                Type::Qualifiers &qualifiers = tupleType->get_qualifiers();
+                for ( Expression * expr : exprs ) {
+                        assert( expr->get_result() );
+                        Type * type = expr->get_result()->clone();
+                        tupleType->get_types().push_back( type );
+                        qualifiers &= type->get_qualifiers();
+                } // for
+                return tupleType;
+        }
 } // namespace Tuples
 

src/Tuples/Tuples.h

@@ -31 +31 @@
         // TupleExpansion.cc
         void expandTuples( std::list< Declaration * > & translationUnit );
+
+  TupleType * makeTupleType( const std::list< Expression * > & exprs );
 } // namespace Tuples