Index: src/SynTree/Expression.cc
===================================================================
--- src/SynTree/Expression.cc	(revision b6fe7e6c491f467e31d7ef488c6c0c23df6534a8)
+++ src/SynTree/Expression.cc	(revision 8f7cea185385710ca47eaacdb8bc3a59fb752db5)
@@ -311,23 +311,26 @@
 }
 
-UntypedMemberExpr::UntypedMemberExpr( std::string _member, Expression *_aggregate, Expression *_aname ) :
+UntypedMemberExpr::UntypedMemberExpr( Expression * _member, Expression *_aggregate, Expression *_aname ) :
 		Expression( _aname ), member(_member), aggregate(_aggregate) {}
 
 UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
-		Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
+		Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
 }
 
 UntypedMemberExpr::~UntypedMemberExpr() {
 	delete aggregate;
+	delete member;
 }
 
 void UntypedMemberExpr::print( std::ostream &os, int indent ) const {
-	os << "Untyped Member Expression, with field: " << get_member();
+	os << "Untyped Member Expression, with field: " << std::endl;
+	get_member()->print(os, indent+4);
+	os << std::string( indent+2, ' ' );
 
 	Expression *agg = get_aggregate();
-	os << ", from aggregate: ";
+	os << "from aggregate: " << std::endl;
 	if (agg != 0) {
-		os << std::string( indent + 2, ' ' );
-		agg->print(os, indent + 2);
+		os << std::string( indent + 4, ' ' );
+		agg->print(os, indent + 4);
 	}
 	os << std::string( indent+2, ' ' );
Index: src/SynTree/Expression.h
===================================================================
--- src/SynTree/Expression.h	(revision b6fe7e6c491f467e31d7ef488c6c0c23df6534a8)
+++ src/SynTree/Expression.h	(revision 8f7cea185385710ca47eaacdb8bc3a59fb752db5)
@@ -200,10 +200,10 @@
 class UntypedMemberExpr : public Expression {
   public:
-	UntypedMemberExpr( std::string member, Expression *aggregate, Expression *_aname = nullptr );
+	UntypedMemberExpr( Expression *member, Expression *aggregate, Expression *_aname = nullptr );
 	UntypedMemberExpr( const UntypedMemberExpr &other );
 	virtual ~UntypedMemberExpr();
 
-	std::string get_member() const { return member; }
-	void set_member( const std::string &newValue ) { member = newValue; }
+	Expression * get_member() const { return member; }
+	void set_member( Expression * newValue ) { member = newValue; }
 	Expression *get_aggregate() const { return aggregate; }
 	void set_aggregate( Expression *newValue ) { aggregate = newValue; }
@@ -214,5 +214,5 @@
 	virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
-	std::string member;
+	Expression *member;
 	Expression *aggregate;
 };
@@ -618,5 +618,5 @@
 	CompoundLiteralExpr( Type * type, Initializer * initializer );
 	CompoundLiteralExpr( const CompoundLiteralExpr &other );
-	~CompoundLiteralExpr();
+	virtual ~CompoundLiteralExpr();
 
 	Type * get_type() const { return type; }
@@ -670,4 +670,88 @@
   private:
 	Expression *low, *high;
+};
+
+/// TupleIndexExpr represents an element selection operation on a tuple value, e.g. t.3 after processing by the expression analyzer
+class TupleIndexExpr : public Expression {
+  public:
+	TupleIndexExpr( Expression * tuple, unsigned int index );
+	TupleIndexExpr( const TupleIndexExpr &other );
+	virtual ~TupleIndexExpr();
+
+	Expression * get_tuple() const { return tuple; }
+	int get_index() const { return index; }
+	TupleIndexExpr * set_tuple( Expression *newValue ) { tuple = newValue; return this; }
+	TupleIndexExpr * set_index( unsigned int newValue ) { index = newValue; return this; }
+
+	virtual TupleIndexExpr *clone() const { return new TupleIndexExpr( *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:
+	Expression * tuple;
+	unsigned int index;
+};
+
+/// MemberTupleExpr represents a tuple member selection operation on a struct type, e.g. s.[a, b, c] after processing by the expression analyzer
+class MemberTupleExpr : public Expression {
+  public:
+	MemberTupleExpr( Expression * member, Expression * aggregate, Expression * _aname = nullptr );
+	MemberTupleExpr( const MemberTupleExpr &other );
+	virtual ~MemberTupleExpr();
+
+	Expression * get_member() const { return member; }
+	Expression * get_aggregate() const { return aggregate; }
+	MemberTupleExpr * set_member( Expression *newValue ) { member = newValue; return this; }
+	MemberTupleExpr * set_aggregate( Expression *newValue ) { aggregate = newValue; return this; }
+
+	virtual MemberTupleExpr *clone() const { return new MemberTupleExpr( *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:
+	Expression * member;
+	Expression * aggregate;
+};
+
+/// MultipleAssignExpr represents a multiple assignment operation, where both sides of the assignment have tuple type, e.g. [a, b, c] = [d, e, f];
+class MultipleAssignExpr : public Expression {
+  public:
+	MultipleAssignExpr( Expression * lhs, Expression * rhs );
+	MultipleAssignExpr( const MultipleAssignExpr &other );
+	virtual ~MultipleAssignExpr();
+
+	Expression * get_lhs() const { return lhs; }
+	Expression * get_rhs() const { return rhs; }
+	MultipleAssignExpr * set_lhs( Expression *newValue ) { lhs = newValue; return this; }
+	MultipleAssignExpr * set_rhs( Expression *newValue ) { rhs = newValue; return this; }
+
+	virtual MultipleAssignExpr *clone() const { return new MultipleAssignExpr( *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:
+	Expression * lhs;
+	Expression * rhs;
+};
+
+/// MassAssignExpr represents a mass assignment operations, where the left hand side has tuple type and the right hand side does not, e.g. [a, b, c] = 5.0;
+class MassAssignExpr : public Expression {
+  public:
+	MassAssignExpr( Expression * tuple, int field );
+	MassAssignExpr( const MassAssignExpr &other );
+	virtual ~MassAssignExpr();
+
+	Expression * get_lhs() const { return lhs; }
+	Expression * get_rhs() const { return rhs; }
+	MassAssignExpr * set_lhs( Expression *newValue ) { lhs = newValue; return this; }
+	MassAssignExpr * set_rhs( Expression *newValue ) { rhs = newValue; return this; }
+
+	virtual MassAssignExpr *clone() const { return new MassAssignExpr( *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:
+	Expression * lhs; // multiple exprs
+	Expression * rhs; // single expr
 };
 
Index: src/SynTree/Mutator.cc
===================================================================
--- src/SynTree/Mutator.cc	(revision b6fe7e6c491f467e31d7ef488c6c0c23df6534a8)
+++ src/SynTree/Mutator.cc	(revision 8f7cea185385710ca47eaacdb8bc3a59fb752db5)
@@ -216,4 +216,5 @@
 	mutateAll( memberExpr->get_results(), *this );
 	memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
+	memberExpr->set_member( maybeMutate( memberExpr->get_member(), *this ) );
 	return memberExpr;
 }
@@ -361,4 +362,31 @@
 	rangeExpr->set_high( maybeMutate( rangeExpr->get_high(), *this ) );
 	return rangeExpr;
+}
+
+Expression *Mutator::mutate( TupleIndexExpr *tupleExpr ) {
+	mutateAll( tupleExpr->get_results(), *this );
+	tupleExpr->set_tuple( maybeMutate( tupleExpr->get_tuple(), *this ) );
+	return tupleExpr;
+}
+
+Expression *Mutator::mutate( MemberTupleExpr *tupleExpr ) {
+	mutateAll( tupleExpr->get_results(), *this );
+	tupleExpr->set_member( maybeMutate( tupleExpr->get_member(), *this ) );
+	tupleExpr->set_aggregate( maybeMutate( tupleExpr->get_aggregate(), *this ) );
+	return tupleExpr;
+}
+
+Expression *Mutator::mutate( MultipleAssignExpr *assignExpr ) {
+	mutateAll( assignExpr->get_results(), *this );
+	assignExpr->set_lhs( maybeMutate( assignExpr->get_lhs(), *this ) );
+	assignExpr->set_rhs( maybeMutate( assignExpr->get_rhs(), *this ) );
+	return assignExpr;
+}
+
+Expression *Mutator::mutate( MassAssignExpr *assignExpr ) {
+	mutateAll( assignExpr->get_results(), *this );
+	assignExpr->set_lhs( maybeMutate( assignExpr->get_lhs(), *this ) );
+	assignExpr->set_rhs( maybeMutate( assignExpr->get_rhs(), *this ) );
+	return assignExpr;
 }
 
Index: src/SynTree/Mutator.h
===================================================================
--- src/SynTree/Mutator.h	(revision b6fe7e6c491f467e31d7ef488c6c0c23df6534a8)
+++ src/SynTree/Mutator.h	(revision 8f7cea185385710ca47eaacdb8bc3a59fb752db5)
@@ -80,4 +80,8 @@
 	virtual Expression* mutate( UntypedValofExpr *valofExpr );
 	virtual Expression* mutate( RangeExpr *rangeExpr );
+	virtual Expression* mutate( TupleIndexExpr *tupleExpr );
+	virtual Expression* mutate( MemberTupleExpr *tupleExpr );
+	virtual Expression* mutate( MultipleAssignExpr *assignExpr );
+	virtual Expression* mutate( MassAssignExpr *assignExpr );
 
 	virtual Type* mutate( VoidType *basicType );
Index: src/SynTree/SynTree.h
===================================================================
--- src/SynTree/SynTree.h	(revision b6fe7e6c491f467e31d7ef488c6c0c23df6534a8)
+++ src/SynTree/SynTree.h	(revision 8f7cea185385710ca47eaacdb8bc3a59fb752db5)
@@ -85,4 +85,8 @@
 class UntypedValofExpr;
 class RangeExpr;
+class TupleIndexExpr;
+class MemberTupleExpr;
+class MultipleAssignExpr;
+class MassAssignExpr;
 
 class Type;
Index: src/SynTree/TupleExpr.cc
===================================================================
--- src/SynTree/TupleExpr.cc	(revision b6fe7e6c491f467e31d7ef488c6c0c23df6534a8)
+++ src/SynTree/TupleExpr.cc	(revision 8f7cea185385710ca47eaacdb8bc3a59fb752db5)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// TupleExpr.cc -- 
+// TupleExpr.cc --
 //
 // Author           : Richard C. Bilson
@@ -16,4 +16,5 @@
 #include "Expression.h"
 #include "Common/utility.h"
+#include "Type.h"
 
 TupleExpr::TupleExpr( Expression *_aname ) : Expression( _aname ) {
@@ -48,4 +49,45 @@
 }
 
+TupleIndexExpr::TupleIndexExpr( Expression * tuple, unsigned int index ) {
+	// TupleType * type = safe_dynamic_cast< TypeType * >( tuple->get_ )
+	assert( tuple->get_results().size() >= index );
+	add_result( *std::next( tuple->get_results().begin(), index ) );
+}
+
+TupleIndexExpr::TupleIndexExpr( const TupleIndexExpr &other ) : Expression( other ), tuple( other.tuple->clone() ), index( other.index ) {
+}
+
+TupleIndexExpr::~TupleIndexExpr() {
+	delete tuple;
+}
+
+void TupleIndexExpr::print( std::ostream &os, int indent ) const {
+	os << std::string( indent, ' ' ) << "Tuple Index Expression, with tuple:" << std::endl;
+	tuple->print( os, indent+2 );
+	os << std::string( indent+2, ' ' ) << "with index: " << index << std::endl;
+	Expression::print( os, indent );
+}
+
+MemberTupleExpr::MemberTupleExpr( Expression * member, Expression * aggregate, Expression * _aname ) : Expression( _aname ) {
+	cloneAll( member->get_results(), get_results() ); // xxx - ???
+}
+
+MemberTupleExpr::MemberTupleExpr( const MemberTupleExpr &other ) : Expression( other ), member( other.member->clone() ), aggregate( other.aggregate->clone() ) {
+}
+
+MemberTupleExpr::~MemberTupleExpr() {
+	delete member;
+	delete aggregate;
+}
+
+void MemberTupleExpr::print( std::ostream &os, int indent ) const {
+	os << std::string( indent, ' ' ) << "Member Tuple Expression, with aggregate:" << std::endl;
+	aggregate->print( os, indent+2 );
+	os << std::string( indent+2, ' ' ) << "with member: " << std::endl;
+	member->print( os, indent+2 );
+	Expression::print( os, indent );
+}
+
+
 // Local Variables: //
 // tab-width: 4 //
Index: src/SynTree/Type.h
===================================================================
--- src/SynTree/Type.h	(revision b6fe7e6c491f467e31d7ef488c6c0c23df6534a8)
+++ src/SynTree/Type.h	(revision 8f7cea185385710ca47eaacdb8bc3a59fb752db5)
@@ -352,5 +352,11 @@
 	virtual ~TupleType();
 
+	typedef std::list<Type*> value_type;
+	typedef value_type::iterator iterator;
+
 	std::list<Type*>& get_types() { return types; }
+
+	iterator begin() { return types.begin(); }
+	iterator end() { return types.end(); }
 
 	virtual TupleType *clone() const { return new TupleType( *this ); }
Index: src/SynTree/Visitor.cc
===================================================================
--- src/SynTree/Visitor.cc	(revision b6fe7e6c491f467e31d7ef488c6c0c23df6534a8)
+++ src/SynTree/Visitor.cc	(revision 8f7cea185385710ca47eaacdb8bc3a59fb752db5)
@@ -182,4 +182,5 @@
 	acceptAll( memberExpr->get_results(), *this );
 	maybeAccept( memberExpr->get_aggregate(), *this );
+	maybeAccept( memberExpr->get_member(), *this );
 }
 
@@ -306,4 +307,27 @@
 	maybeAccept( rangeExpr->get_low(), *this );
 	maybeAccept( rangeExpr->get_high(), *this );
+}
+
+void Visitor::visit( TupleIndexExpr *tupleExpr ) {
+	acceptAll( tupleExpr->get_results(), *this );
+	maybeAccept( tupleExpr->get_tuple(), *this );
+}
+
+void Visitor::visit( MemberTupleExpr *tupleExpr ) {
+	acceptAll( tupleExpr->get_results(), *this );
+	maybeAccept( tupleExpr->get_member(), *this );
+	maybeAccept( tupleExpr->get_aggregate(), *this );
+}
+
+void Visitor::visit( MultipleAssignExpr *assignExpr ) {
+	acceptAll( assignExpr->get_results(), *this );
+	maybeAccept( assignExpr->get_lhs(), *this );
+	maybeAccept( assignExpr->get_rhs(), *this );
+}
+
+void Visitor::visit( MassAssignExpr *assignExpr ) {
+	acceptAll( assignExpr->get_results(), *this );
+	maybeAccept( assignExpr->get_lhs(), *this );
+	maybeAccept( assignExpr->get_rhs(), *this );
 }
 
Index: src/SynTree/Visitor.h
===================================================================
--- src/SynTree/Visitor.h	(revision b6fe7e6c491f467e31d7ef488c6c0c23df6534a8)
+++ src/SynTree/Visitor.h	(revision 8f7cea185385710ca47eaacdb8bc3a59fb752db5)
@@ -80,4 +80,8 @@
 	virtual void visit( UntypedValofExpr *valofExpr );
 	virtual void visit( RangeExpr *rangeExpr );
+	virtual void visit( TupleIndexExpr *tupleExpr );
+	virtual void visit( MemberTupleExpr *tupleExpr );
+	virtual void visit( MultipleAssignExpr *assignExpr );
+	virtual void visit( MassAssignExpr *assignExpr );
 
 	virtual void visit( VoidType *basicType );