Index: src/SymTab/Autogen.cc
===================================================================
--- src/SymTab/Autogen.cc	(revision 89e6ffcdff36e5cf99ff1d6c8bde150e2fb05235)
+++ src/SymTab/Autogen.cc	(revision 1132b62939ee72e624dd65d3bacb0e67cb1a0347)
@@ -116,6 +116,7 @@
 		// This happens before function pointer type conversion, so need to do it manually here
 		VariableExpr * assignVarExpr = new VariableExpr( assignDecl );
-		Type *& assignVarExprType = assignVarExpr->get_results().front();
+		Type * assignVarExprType = assignVarExpr->get_result();
 		assignVarExprType = new PointerType( Type::Qualifiers(), assignVarExprType );
+		assignVarExpr->set_result( assignVarExprType );
 		ApplicationExpr * assignExpr = new ApplicationExpr( assignVarExpr );
 		assignExpr->get_args().push_back( new VariableExpr( dstParam ) );
Index: src/SymTab/Indexer.cc
===================================================================
--- src/SymTab/Indexer.cc	(revision 89e6ffcdff36e5cf99ff1d6c8bde150e2fb05235)
+++ src/SymTab/Indexer.cc	(revision 1132b62939ee72e624dd65d3bacb0e67cb1a0347)
@@ -40,8 +40,8 @@
 
 namespace SymTab {
-	template< typename Container, typename VisitorType >
-	inline void acceptAllNewScope( Container &container, VisitorType &visitor ) {
+	template< typename TreeType, typename VisitorType >
+	inline void acceptNewScope( TreeType *tree, VisitorType &visitor ) {
 		visitor.enterScope();
-		acceptAll( container, visitor );
+		maybeAccept( tree, visitor );
 		visitor.leaveScope();
 	}
@@ -143,5 +143,5 @@
 		for ( DeclarationWithType * decl : copy ) {
 			if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl ) ) {
-				std::list< DeclarationWithType * > params = function->get_functionType()->get_parameters();
+				std::list< DeclarationWithType * > & params = function->get_functionType()->get_parameters();
 				assert( ! params.empty() );
 				// use base type of pointer, so that qualifiers on the pointer type aren't considered.
@@ -337,5 +337,5 @@
 
 	void Indexer::visit( ApplicationExpr *applicationExpr ) {
-		acceptAllNewScope( applicationExpr->get_results(), *this );
+		acceptNewScope( applicationExpr->get_result(), *this );
 		maybeAccept( applicationExpr->get_function(), *this );
 		acceptAll( applicationExpr->get_args(), *this );
@@ -343,48 +343,48 @@
 
 	void Indexer::visit( UntypedExpr *untypedExpr ) {
-		acceptAllNewScope( untypedExpr->get_results(), *this );
+		acceptNewScope( untypedExpr->get_result(), *this );
 		acceptAll( untypedExpr->get_args(), *this );
 	}
 
 	void Indexer::visit( NameExpr *nameExpr ) {
-		acceptAllNewScope( nameExpr->get_results(), *this );
+		acceptNewScope( nameExpr->get_result(), *this );
 	}
 
 	void Indexer::visit( AddressExpr *addressExpr ) {
-		acceptAllNewScope( addressExpr->get_results(), *this );
+		acceptNewScope( addressExpr->get_result(), *this );
 		maybeAccept( addressExpr->get_arg(), *this );
 	}
 
 	void Indexer::visit( LabelAddressExpr *labAddressExpr ) {
-		acceptAllNewScope( labAddressExpr->get_results(), *this );
+		acceptNewScope( labAddressExpr->get_result(), *this );
 		maybeAccept( labAddressExpr->get_arg(), *this );
 	}
 
 	void Indexer::visit( CastExpr *castExpr ) {
-		acceptAllNewScope( castExpr->get_results(), *this );
+		acceptNewScope( castExpr->get_result(), *this );
 		maybeAccept( castExpr->get_arg(), *this );
 	}
 
 	void Indexer::visit( UntypedMemberExpr *memberExpr ) {
-		acceptAllNewScope( memberExpr->get_results(), *this );
+		acceptNewScope( memberExpr->get_result(), *this );
 		maybeAccept( memberExpr->get_aggregate(), *this );
 	}
 
 	void Indexer::visit( MemberExpr *memberExpr ) {
-		acceptAllNewScope( memberExpr->get_results(), *this );
+		acceptNewScope( memberExpr->get_result(), *this );
 		maybeAccept( memberExpr->get_aggregate(), *this );
 	}
 
 	void Indexer::visit( VariableExpr *variableExpr ) {
-		acceptAllNewScope( variableExpr->get_results(), *this );
+		acceptNewScope( variableExpr->get_result(), *this );
 	}
 
 	void Indexer::visit( ConstantExpr *constantExpr ) {
-		acceptAllNewScope( constantExpr->get_results(), *this );
+		acceptNewScope( constantExpr->get_result(), *this );
 		maybeAccept( constantExpr->get_constant(), *this );
 	}
 
 	void Indexer::visit( SizeofExpr *sizeofExpr ) {
-		acceptAllNewScope( sizeofExpr->get_results(), *this );
+		acceptNewScope( sizeofExpr->get_result(), *this );
 		if ( sizeofExpr->get_isType() ) {
 			maybeAccept( sizeofExpr->get_type(), *this );
@@ -395,5 +395,5 @@
 
 	void Indexer::visit( AlignofExpr *alignofExpr ) {
-		acceptAllNewScope( alignofExpr->get_results(), *this );
+		acceptNewScope( alignofExpr->get_result(), *this );
 		if ( alignofExpr->get_isType() ) {
 			maybeAccept( alignofExpr->get_type(), *this );
@@ -404,10 +404,10 @@
 
 	void Indexer::visit( UntypedOffsetofExpr *offsetofExpr ) {
-		acceptAllNewScope( offsetofExpr->get_results(), *this );
+		acceptNewScope( offsetofExpr->get_result(), *this );
 		maybeAccept( offsetofExpr->get_type(), *this );
 	}
 
 	void Indexer::visit( OffsetofExpr *offsetofExpr ) {
-		acceptAllNewScope( offsetofExpr->get_results(), *this );
+		acceptNewScope( offsetofExpr->get_result(), *this );
 		maybeAccept( offsetofExpr->get_type(), *this );
 		maybeAccept( offsetofExpr->get_member(), *this );
@@ -415,10 +415,10 @@
 
 	void Indexer::visit( OffsetPackExpr *offsetPackExpr ) {
-		acceptAllNewScope( offsetPackExpr->get_results(), *this );
+		acceptNewScope( offsetPackExpr->get_result(), *this );
 		maybeAccept( offsetPackExpr->get_type(), *this );
 	}
 
 	void Indexer::visit( AttrExpr *attrExpr ) {
-		acceptAllNewScope( attrExpr->get_results(), *this );
+		acceptNewScope( attrExpr->get_result(), *this );
 		if ( attrExpr->get_isType() ) {
 			maybeAccept( attrExpr->get_type(), *this );
@@ -429,5 +429,5 @@
 
 	void Indexer::visit( LogicalExpr *logicalExpr ) {
-		acceptAllNewScope( logicalExpr->get_results(), *this );
+		acceptNewScope( logicalExpr->get_result(), *this );
 		maybeAccept( logicalExpr->get_arg1(), *this );
 		maybeAccept( logicalExpr->get_arg2(), *this );
@@ -435,5 +435,5 @@
 
 	void Indexer::visit( ConditionalExpr *conditionalExpr ) {
-		acceptAllNewScope( conditionalExpr->get_results(), *this );
+		acceptNewScope( conditionalExpr->get_result(), *this );
 		maybeAccept( conditionalExpr->get_arg1(), *this );
 		maybeAccept( conditionalExpr->get_arg2(), *this );
@@ -442,5 +442,5 @@
 
 	void Indexer::visit( CommaExpr *commaExpr ) {
-		acceptAllNewScope( commaExpr->get_results(), *this );
+		acceptNewScope( commaExpr->get_result(), *this );
 		maybeAccept( commaExpr->get_arg1(), *this );
 		maybeAccept( commaExpr->get_arg2(), *this );
@@ -448,15 +448,18 @@
 
 	void Indexer::visit( TupleExpr *tupleExpr ) {
-		acceptAllNewScope( tupleExpr->get_results(), *this );
+		acceptNewScope( tupleExpr->get_result(), *this );
 		acceptAll( tupleExpr->get_exprs(), *this );
 	}
 
-	void Indexer::visit( SolvedTupleExpr *tupleExpr ) {
-		acceptAllNewScope( tupleExpr->get_results(), *this );
-		acceptAll( tupleExpr->get_exprs(), *this );
+	void Indexer::visit( TupleAssignExpr *tupleExpr ) {
+		acceptNewScope( tupleExpr->get_result(), *this );
+		enterScope();
+		acceptAll( tupleExpr->get_tempDecls(), *this );
+		acceptAll( tupleExpr->get_assigns(), *this );
+		leaveScope();
 	}
 
 	void Indexer::visit( TypeExpr *typeExpr ) {
-		acceptAllNewScope( typeExpr->get_results(), *this );
+		acceptNewScope( typeExpr->get_result(), *this );
 		maybeAccept( typeExpr->get_type(), *this );
 	}
@@ -469,5 +472,5 @@
 
 	void Indexer::visit( UntypedValofExpr *valofExpr ) {
-		acceptAllNewScope( valofExpr->get_results(), *this );
+		acceptNewScope( valofExpr->get_result(), *this );
 		maybeAccept( valofExpr->get_body(), *this );
 	}
Index: src/SymTab/Indexer.h
===================================================================
--- src/SymTab/Indexer.h	(revision 89e6ffcdff36e5cf99ff1d6c8bde150e2fb05235)
+++ src/SymTab/Indexer.h	(revision 1132b62939ee72e624dd65d3bacb0e67cb1a0347)
@@ -64,9 +64,9 @@
 		virtual void visit( ConditionalExpr *conditionalExpr );
 		virtual void visit( CommaExpr *commaExpr );
-		virtual void visit( TupleExpr *tupleExpr );
-		virtual void visit( SolvedTupleExpr *tupleExpr );
 		virtual void visit( TypeExpr *typeExpr );
 		virtual void visit( AsmExpr *asmExpr );
 		virtual void visit( UntypedValofExpr *valofExpr );
+		virtual void visit( TupleExpr *tupleExpr );
+		virtual void visit( TupleAssignExpr *tupleExpr );
 
 		virtual void visit( TraitInstType *contextInst );
Index: src/SymTab/Mangler.cc
===================================================================
--- src/SymTab/Mangler.cc	(revision 89e6ffcdff36e5cf99ff1d6c8bde150e2fb05235)
+++ src/SymTab/Mangler.cc	(revision 1132b62939ee72e624dd65d3bacb0e67cb1a0347)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Mangler.cc -- 
+// Mangler.cc --
 //
 // Author           : Richard C. Bilson
@@ -35,8 +35,8 @@
 		return mangler.get_mangleName();
 	}
-	
+
 	Mangler::Mangler( bool mangleOverridable, bool typeMode )
 		: nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ) {}
-		
+
 	Mangler::Mangler( const Mangler &rhs ) : mangleName() {
 		varNums = rhs.varNums;
@@ -115,5 +115,5 @@
 			"Ir",	// LongDoubleImaginary
 		};
-  
+
 		printQualifiers( basicType );
 		mangleName << btLetter[ basicType->get_kind() ];
@@ -253,10 +253,10 @@
 		// skip if not including qualifiers
 		if ( typeMode ) return;
-		
+
 		if ( ! type->get_forall().empty() ) {
 			std::list< std::string > assertionNames;
 			int tcount = 0, dcount = 0, fcount = 0;
 			mangleName << "A";
-			for ( std::list< TypeDecl* >::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+			for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
 				switch ( (*i)->get_kind() ) {
 				  case TypeDecl::Any:
Index: src/SymTab/Validate.cc
===================================================================
--- src/SymTab/Validate.cc	(revision 89e6ffcdff36e5cf99ff1d6c8bde150e2fb05235)
+++ src/SymTab/Validate.cc	(revision 1132b62939ee72e624dd65d3bacb0e67cb1a0347)
@@ -23,6 +23,6 @@
 // - 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
@@ -429,5 +429,5 @@
 	/// Fix up assertions
 	void forallFixer( Type *func ) {
-		for ( std::list< TypeDecl * >::iterator type = func->get_forall().begin(); type != func->get_forall().end(); ++type ) {
+		for ( Type::ForallList::iterator type = func->get_forall().begin(); type != func->get_forall().end(); ++type ) {
 			std::list< DeclarationWithType * > toBeDone, nextRound;
 			toBeDone.splice( toBeDone.end(), (*type )->get_assertions() );
