Changes in / [aa8f9df:fd782b2]

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (2 diffs)
• ControlStruct/LabelTypeChecker.cc (added)
• ControlStruct/LabelTypeChecker.h (added)
• ControlStruct/Mutate.cc (modified) (2 diffs)
• ControlStruct/module.mk (modified) (2 diffs)
• GenPoly/Box.cc (modified) (18 diffs)
• GenPoly/Lvalue.cc (modified) (6 diffs)
• GenPoly/Specialize.cc (modified) (4 diffs)
• InitTweak/FixInit.cc (modified) (6 diffs)
• InitTweak/InitTweak.cc (modified) (1 diff)
• Makefile.in (modified) (6 diffs)
• ResolvExpr/Alternative.cc (modified) (3 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (23 diffs)
• ResolvExpr/AlternativeFinder.h (modified) (1 diff)
• ResolvExpr/AlternativePrinter.cc (modified) (2 diffs)
• ResolvExpr/ResolveTypeof.cc (modified) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (6 diffs)
• ResolvExpr/Unify.cc (modified) (1 diff)
• ResolvExpr/typeops.h (modified) (6 diffs)
• SymTab/Autogen.cc (modified) (1 diff)
• SymTab/Indexer.cc (modified) (12 diffs)
• SynTree/AddressExpr.cc (modified) (2 diffs)
• SynTree/ApplicationExpr.cc (modified) (2 diffs)
• SynTree/CommaExpr.cc (modified) (1 diff)
• SynTree/Expression.cc (modified) (17 diffs)
• SynTree/Expression.h (modified) (2 diffs)
• SynTree/Mutator.cc (modified) (26 diffs)
• SynTree/TupleExpr.cc (modified) (6 diffs)
• SynTree/Type.h (modified) (5 diffs)
• SynTree/Visitor.cc (modified) (15 diffs)
• Tuples/TupleAssignment.cc (modified) (3 diffs)
• Tuples/TupleExpansion.cc (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -309 +309 @@
                                                         UntypedExpr * newExpr = new UntypedExpr( new NameExpr( "*?" ) );
                                                         newExpr->get_args().push_back( *arg );
-                                                        Type * type = InitTweak::getPointerBase( (*arg)->get_result() );
+                                                        assert( (*arg)->get_results().size() == 1 );
+                                                        Type * type = InitTweak::getPointerBase( (*arg)->get_results().front() );
                                                         assert( type );
-                                                        newExpr->set_result( type->clone() );
+                                                        newExpr->get_results().push_back( type->clone() );
                                                         *arg = newExpr;
                                                 } // if
@@ -526 +527 @@
                 extension( castExpr );
                 output << "(";
-                if ( castExpr->get_result()->isVoid() ) {
+                if ( castExpr->get_results().empty() ) {
                         output << "(void)" ;
-                } else if ( ! castExpr->get_result()->get_isLvalue() ) {
+                } else if ( ! castExpr->get_results().front()->get_isLvalue() ) {
                         // at least one result type of cast, but not an lvalue
                         output << "(";
-                        output << genType( castExpr->get_result(), "" );
+                        output << genType( castExpr->get_results().front(), "" );
                         output << ")";
                 } else {

src/ControlStruct/Mutate.cc

@@ -23 +23 @@
 #include "MLEMutator.h"
 #include "ForExprMutator.h"
+#include "LabelTypeChecker.h"
 //#include "ExceptMutator.h"
 
@@ -40 +41 @@
 
                 //ExceptMutator exc;
+                // LabelTypeChecker lbl;
 
                 mutateAll( translationUnit, formut );
                 acceptAll( translationUnit, lfix );
                 //mutateAll( translationUnit, exc );
+                //acceptAll( translationUnit, lbl );
         }
 } // namespace CodeGen

src/ControlStruct/module.mk

@@ -6 +6 @@
 ## file "LICENCE" distributed with Cforall.
 ##
-## module.mk --
+## module.mk -- 
 ##
 ## Author           : Richard C. Bilson
@@ -19 +19 @@
         ControlStruct/MLEMutator.cc \
         ControlStruct/Mutate.cc \
-        ControlStruct/ForExprMutator.cc
+        ControlStruct/ForExprMutator.cc \
+        ControlStruct/LabelTypeChecker.cc
 

src/GenPoly/Box.cc

@@ -782 +782 @@
 
                         // add size/align for generic types to parameter list
-                        if ( ! appExpr->get_function()->has_result() ) return;
-                        FunctionType *funcType = getFunctionType( appExpr->get_function()->get_result() );
+                        if ( appExpr->get_function()->get_results().empty() ) return;
+                        FunctionType *funcType = getFunctionType( appExpr->get_function()->get_results().front() );
                         assert( funcType );
 
@@ -799 +799 @@
                         for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
                                 VariableExpr *fnArgBase = getBaseVar( *fnArg );
-                                if ( ! fnArgBase ) continue; // xxx - previously had check for non-empty fnArgBase results
-                                passArgTypeVars( appExpr, (*fnParm)->get_type(), fnArgBase->get_result(), arg, exprTyVars, seenTypes );
+                                if ( ! fnArgBase || fnArgBase->get_results().empty() ) continue;
+                                passArgTypeVars( appExpr, (*fnParm)->get_type(), fnArgBase->get_results().front(), arg, exprTyVars, seenTypes );
                         }
                 }
@@ -890 +890 @@
                         Type * adapteeType = new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
                         appExpr->get_args().push_front( new CastExpr( appExpr->get_function(), adapteeType ) );
-                        appExpr->set_function( new NameExpr( adapterName ) ); // xxx - result is never set on NameExpr
+                        appExpr->set_function( new NameExpr( adapterName ) );
 
                         return ret;
@@ -896 +896 @@
 
                 void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
-                        assert( arg->has_result() );
+                        assert( ! arg->get_results().empty() );
                         if ( isPolyType( param, exprTyVars ) ) {
-                                if ( isPolyType( arg->get_result() ) ) {
+                                if ( isPolyType( arg->get_results().front() ) ) {
                                         // if the argument's type is polymorphic, we don't need to box again!
                                         return;
-                                } else if ( arg->get_result()->get_isLvalue() ) {
+                                } else if ( arg->get_results().front()->get_isLvalue() ) {
                                         // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
                                         // xxx - need to test that this code is still reachable
@@ -987 +987 @@
                                         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
                                         deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
-                                        deref->set_result( arg->get_type()->clone() );
+                                        deref->get_results().push_back( arg->get_type()->clone() );
                                         return deref;
                                 } // if
@@ -1124 +1124 @@
                         } // if
                         addAssign->get_args().push_back( new NameExpr( sizeofName( mangleType( polyType ) ) ) );
-                        addAssign->set_result( appExpr->get_result()->clone() );
+                        addAssign->get_results().front() = appExpr->get_results().front()->clone();
                         if ( appExpr->get_env() ) {
                                 addAssign->set_env( appExpr->get_env() );
@@ -1138 +1138 @@
                                 if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
                                         if ( varExpr->get_var()->get_name() == "?[?]" ) {
-                                                assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 2 );
-                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
-                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_result(), scopeTyVars, env );
+                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), scopeTyVars, env );
+                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), scopeTyVars, env );
                                                 assert( ! baseType1 || ! baseType2 ); // the arguments cannot both be polymorphic pointers
                                                 UntypedExpr *ret = 0;
@@ -1161 +1161 @@
                                                 } // if
                                                 if ( baseType1 || baseType2 ) {
-                                                        ret->set_result( appExpr->get_result()->clone() );
+                                                        ret->get_results().push_front( appExpr->get_results().front()->clone() );
                                                         if ( appExpr->get_env() ) {
                                                                 ret->set_env( appExpr->get_env() );
@@ -1171 +1171 @@
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "*?" ) {
-                                                assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( ! appExpr->get_args().empty() );
-                                                if ( isPolyType( appExpr->get_result(), scopeTyVars, env ) ) {
+                                                if ( isPolyType( appExpr->get_results().front(), scopeTyVars, env ) ) {
                                                         Expression *ret = appExpr->get_args().front();
-                                                        delete ret->get_result();
-                                                        ret->set_result( appExpr->get_result()->clone() );
+                                                        delete ret->get_results().front();
+                                                        ret->get_results().front() = appExpr->get_results().front()->clone();
                                                         if ( appExpr->get_env() ) {
                                                                 ret->set_env( appExpr->get_env() );
@@ -1186 +1186 @@
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) {
-                                                assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 1 );
-                                                if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
-                                                        Type *tempType = appExpr->get_result()->clone();
+                                                if ( Type *baseType = isPolyPtr( appExpr->get_results().front(), scopeTyVars, env ) ) {
+                                                        Type *tempType = appExpr->get_results().front()->clone();
                                                         if ( env ) {
                                                                 env->apply( tempType );
@@ -1206 +1206 @@
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) {
-                                                assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 1 );
-                                                if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
+                                                if ( Type *baseType = isPolyPtr( appExpr->get_results().front(), scopeTyVars, env ) ) {
                                                         return makeIncrDecrExpr( appExpr, baseType, varExpr->get_var()->get_name() == "++?" );
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
-                                                assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 2 );
-                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
-                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_result(), scopeTyVars, env );
+                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), scopeTyVars, env );
+                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), scopeTyVars, env );
                                                 if ( baseType1 && baseType2 ) {
                                                         UntypedExpr *divide = new UntypedExpr( new NameExpr( "?/?" ) );
                                                         divide->get_args().push_back( appExpr );
                                                         divide->get_args().push_back( new SizeofExpr( baseType1->clone() ) );
-                                                        divide->set_result( appExpr->get_result()->clone() );
+                                                        divide->get_results().push_front( appExpr->get_results().front()->clone() );
                                                         if ( appExpr->get_env() ) {
                                                                 divide->set_env( appExpr->get_env() );
@@ -1238 +1238 @@
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) {
-                                                assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 2 );
-                                                Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env );
+                                                Type *baseType = isPolyPtr( appExpr->get_results().front(), scopeTyVars, env );
                                                 if ( baseType ) {
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
@@ -1266 +1266 @@
                         useRetval = oldUseRetval;
 
-                        assert( appExpr->get_function()->has_result() );
-                        PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
-                        FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
+                        assert( ! appExpr->get_function()->get_results().empty() );
+                        PointerType *pointer = dynamic_cast< PointerType *>( appExpr->get_function()->get_results().front() );
+                        assert( pointer );
+                        FunctionType *function = dynamic_cast< FunctionType *>( pointer->get_base() );
+                        assert( function );
 
                         if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
@@ -1306 +1308 @@
 
                 Expression *Pass1::mutate( UntypedExpr *expr ) {
-                        if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
+                        if ( ! expr->get_results().empty() && isPolyType( expr->get_results().front(), scopeTyVars, env ) ) {
                                 if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
                                         if ( name->get_name() == "*?" ) {
@@ -1320 +1322 @@
 
                 Expression *Pass1::mutate( AddressExpr *addrExpr ) {
-                        assert( addrExpr->get_arg()->has_result() && ! addrExpr->get_arg()->get_result()->isVoid() );
+                        assert( ! addrExpr->get_arg()->get_results().empty() );
 
                         bool needs = false;
                         if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->get_arg() ) ) {
-                                if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
+                                if ( ! expr->get_results().empty() && isPolyType( expr->get_results().front(), scopeTyVars, env ) ) {
                                         if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
                                                 if ( name->get_name() == "*?" ) {
                                                         if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) {
-                                                                assert( appExpr->get_function()->has_result() );
-                                                                PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
-                                                                FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
+                                                                assert( ! appExpr->get_function()->get_results().empty() );
+                                                                PointerType *pointer = dynamic_cast< PointerType *>( appExpr->get_function()->get_results().front() );
+                                                                assert( pointer );
+                                                                FunctionType *function = dynamic_cast< FunctionType *>( pointer->get_base() );
+                                                                assert( function );
                                                                 needs = needsAdapter( function, scopeTyVars );
                                                         } // if
@@ -1339 +1343 @@
                         // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
                         // out of the if condition.
-                        bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env );
+                        bool polytype = isPolyType( addrExpr->get_arg()->get_results().front(), scopeTyVars, env );
                         addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
                         if ( polytype || needs ) {
                                 Expression *ret = addrExpr->get_arg();
-                                delete ret->get_result();
-                                ret->set_result( addrExpr->get_result()->clone() );
+                                delete ret->get_results().front();
+                                ret->get_results().front() = addrExpr->get_results().front()->clone();
                                 addrExpr->set_arg( 0 );
                                 delete addrExpr;
@@ -1382 +1386 @@
                 Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
                         if ( retval && returnStmt->get_expr() ) {
-                                assert( returnStmt->get_expr()->has_result() && ! returnStmt->get_expr()->get_result()->isVoid() );
+                                assert( ! returnStmt->get_expr()->get_results().empty() );
                                 // ***** Code Removal ***** After introducing a temporary variable for all return expressions, the following code appears superfluous.
                                 // if ( returnStmt->get_expr()->get_results().front()->get_isLvalue() ) {
@@ -1462 +1466 @@
                                 // replace return statement with appropriate assignment to out parameter
                                 Expression *retParm = new NameExpr( retval->get_name() );
-                                retParm->set_result( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
+                                retParm->get_results().push_back( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
                                 assignExpr->get_args().push_back( retParm );
                                 assignExpr->get_args().push_back( returnStmt->get_expr() );

src/GenPoly/Lvalue.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Lvalue.cc --
+// Lvalue.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -41 +41 @@
                   public:
                         Pass1();
-
+  
                         virtual Expression *mutate( ApplicationExpr *appExpr );
                         virtual Statement *mutate( ReturnStmt *appExpr );
@@ -99 +99 @@
                         appExpr->get_function()->acceptMutator( *this );
                         mutateAll( appExpr->get_args(), *this );
+  
+                        assert( ! appExpr->get_function()->get_results().empty() );
 
-                        PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
-                        FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+                        PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
+                        assert( pointer );
+                        FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
+                        assert( function );
 
                         Type *funType = isLvalueRet( function );
                         if ( funType && ! isIntrinsicApp( appExpr ) ) {
                                 Expression *expr = appExpr;
-                                Type *appType = appExpr->get_result();
+                                Type *appType = appExpr->get_results().front();
                                 if ( isPolyType( funType ) && ! isPolyType( appType ) ) {
                                         // make sure cast for polymorphic type is inside dereference
@@ -112 +116 @@
                                 }
                                 UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-                                deref->set_result( appType->clone() );
-                                appExpr->set_result( new PointerType( Type::Qualifiers(), appType ) );
+                                deref->get_results().push_back( appType->clone() );
+                                appExpr->get_results().front() = new PointerType( Type::Qualifiers(), appType );
                                 deref->get_args().push_back( expr );
                                 return deref;
@@ -123 +127 @@
                 Statement * Pass1::mutate(ReturnStmt *retStmt) {
                         if ( retval && retStmt->get_expr() ) {
-                                if ( retStmt->get_expr()->get_result()->get_isLvalue() ) {
+                                assert( ! retStmt->get_expr()->get_results().empty() );
+                                if ( retStmt->get_expr()->get_results().front()->get_isLvalue() ) {
                                         // ***** Code Removal ***** because casts may be stripped already
 
@@ -150 +155 @@
                                 retParm->set_type( new PointerType( Type::Qualifiers(), retParm->get_type() ) );
                         } // if
-
+  
                         Visitor::visit( funType );
                 }

src/GenPoly/Specialize.cc

@@ -147 +147 @@
 
         Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
-                assert( actual->has_result() );
-                if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
+                assert( ! actual->get_results().empty() ); // using front, should have this assert
+                if ( needsSpecialization( formalType, actual->get_results().front(), env ) ) {
                         FunctionType *funType;
                         if ( ( funType = getFunctionType( formalType ) ) ) {
@@ -171 +171 @@
         void Specialize::handleExplicitParams( ApplicationExpr *appExpr ) {
                 // create thunks for the explicit parameters
-                assert( appExpr->get_function()->has_result() );
-                FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
+                assert( ! appExpr->get_function()->get_results().empty() );
+                FunctionType *function = getFunctionType( appExpr->get_function()->get_results().front() );
                 assert( function );
                 std::list< DeclarationWithType* >::iterator formal;
@@ -200 +200 @@
         Expression * Specialize::mutate( AddressExpr *addrExpr ) {
                 addrExpr->get_arg()->acceptMutator( *this );
-                assert( addrExpr->has_result() );
-                addrExpr->set_arg( doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
+                assert( ! addrExpr->get_results().empty() );
+                addrExpr->set_arg( doSpecialization( addrExpr->get_results().front(), addrExpr->get_arg() ) );
                 return addrExpr;
         }
@@ -207 +207 @@
         Expression * Specialize::mutate( CastExpr *castExpr ) {
                 castExpr->get_arg()->acceptMutator( *this );
-                if ( castExpr->get_result()->isVoid() ) {
+                if ( castExpr->get_results().empty() ) {
                         // can't specialize if we don't have a return value
                         return castExpr;
                 }
-                Expression *specialized = doSpecialization( castExpr->get_result(), castExpr->get_arg() );
+                Expression *specialized = doSpecialization( castExpr->get_results().front(), castExpr->get_arg() );
                 if ( specialized != castExpr->get_arg() ) {
                         // assume here that the specialization incorporates the cast

src/InitTweak/FixInit.cc

@@ -391 +391 @@
                                 CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *impCpCtorExpr->get_env() << std::endl; )
                                 // xxx - need to handle tuple arguments
-                                assert( arg->has_result() );
-                                Type * result = arg->get_result();
+                                assert( ! arg->get_results().empty() );
+                                Type * result = arg->get_results().front();
                                 if ( skipCopyConstruct( result ) ) continue; // skip certain non-copyable types
                                 // type may involve type variables, so apply type substitution to get temporary variable's actual type
@@ -423 +423 @@
                         // level. Trying to pass that environment along.
                         callExpr->set_env( impCpCtorExpr->get_env()->clone() );
-                        Type * result = appExpr->get_result();
-                        if ( ! result->isVoid() ) {
-                                // need to flatten result type and construct each
+                        for ( Type * result : appExpr->get_results() ) {
                                 result = result->clone();
                                 impCpCtorExpr->get_env()->apply( result );
@@ -481 +479 @@
                                 // know the result type of the assignment is the type of the LHS (minus the pointer), so
                                 // add that onto the assignment expression so that later steps have the necessary information
-                                assign->set_result( returnDecl->get_type()->clone() );
+                                assign->add_result( returnDecl->get_type()->clone() );
 
                                 Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
-                                if ( callExpr->get_result()->get_isLvalue() ) {
+                                if ( callExpr->get_results().front()->get_isLvalue() ) {
                                         // lvalue returning functions are funny. Lvalue.cc inserts a *? in front of any lvalue returning
                                         // non-intrinsic function. Add an AddressExpr to the call to negate the derefence and change the
@@ -502 +500 @@
                                         UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
                                         deref->get_args().push_back( retExpr );
-                                        deref->set_result( resultType );
+                                        deref->add_result( resultType );
                                         retExpr = deref;
                                 } // if
@@ -941 +939 @@
                 Expression * FixCtorExprs::mutate( ConstructorExpr * ctorExpr ) {
                         static UniqueName tempNamer( "_tmp_ctor_expr" );
-                        assert( ctorExpr->has_result() && ctorExpr->get_result()->size() == 1 );
-                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
+                        assert( ctorExpr->get_results().size() == 1 );
+                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_results().front()->clone(), nullptr );
                         addDeclaration( tmp );
 
@@ -954 +952 @@
                         assign->get_args().push_back( new VariableExpr( tmp ) );
                         assign->get_args().push_back( firstArg );
-                        assign->set_result( ctorExpr->get_result()->clone() );
+                        cloneAll( ctorExpr->get_results(), assign->get_results() );
                         firstArg = assign;
 

src/InitTweak/InitTweak.cc

@@ -340 +340 @@
                 return allofCtorDtor( stmt, []( Expression * callExpr ){
                         if ( ApplicationExpr * appExpr = isIntrinsicCallExpr( callExpr ) ) {
-                                FunctionType *funcType = GenPoly::getFunctionType( appExpr->get_function()->get_result() );
+                                assert( ! appExpr->get_function()->get_results().empty() );
+                                FunctionType *funcType = GenPoly::getFunctionType( appExpr->get_function()->get_results().front() );
                                 assert( funcType );
                                 return funcType->get_parameters().size() == 1;

src/Makefile.in

@@ -104 +104 @@
         ControlStruct/driver_cfa_cpp-Mutate.$(OBJEXT) \
         ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT) \
+        ControlStruct/driver_cfa_cpp-LabelTypeChecker.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-Box.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT) \
@@ -360 +361 @@
         ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \
         ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \
-        ControlStruct/ForExprMutator.cc GenPoly/Box.cc \
+        ControlStruct/ForExprMutator.cc \
+        ControlStruct/LabelTypeChecker.cc GenPoly/Box.cc \
         GenPoly/GenPoly.cc GenPoly/PolyMutator.cc \
         GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \
@@ -533 +535 @@
         ControlStruct/$(DEPDIR)/$(am__dirstamp)
 ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT):  \
+        ControlStruct/$(am__dirstamp) \
+        ControlStruct/$(DEPDIR)/$(am__dirstamp)
+ControlStruct/driver_cfa_cpp-LabelTypeChecker.$(OBJEXT):  \
         ControlStruct/$(am__dirstamp) \
         ControlStruct/$(DEPDIR)/$(am__dirstamp)
@@ -786 +791 @@
         -rm -f ControlStruct/driver_cfa_cpp-LabelFixer.$(OBJEXT)
         -rm -f ControlStruct/driver_cfa_cpp-LabelGenerator.$(OBJEXT)
+        -rm -f ControlStruct/driver_cfa_cpp-LabelTypeChecker.$(OBJEXT)
         -rm -f ControlStruct/driver_cfa_cpp-MLEMutator.$(OBJEXT)
         -rm -f ControlStruct/driver_cfa_cpp-Mutate.$(OBJEXT)
@@ -890 +896 @@
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelFixer.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelGenerator.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-MLEMutator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-Mutate.Po@am__quote@
@@ -1204 +1211 @@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ControlStruct/driver_cfa_cpp-ForExprMutator.obj `if test -f 'ControlStruct/ForExprMutator.cc'; then $(CYGPATH_W) 'ControlStruct/ForExprMutator.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/ForExprMutator.cc'; fi`
 
+ControlStruct/driver_cfa_cpp-LabelTypeChecker.o: ControlStruct/LabelTypeChecker.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ControlStruct/driver_cfa_cpp-LabelTypeChecker.o -MD -MP -MF ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo -c -o ControlStruct/driver_cfa_cpp-LabelTypeChecker.o `test -f 'ControlStruct/LabelTypeChecker.cc' || echo '$(srcdir)/'`ControlStruct/LabelTypeChecker.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ControlStruct/LabelTypeChecker.cc' object='ControlStruct/driver_cfa_cpp-LabelTypeChecker.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ControlStruct/driver_cfa_cpp-LabelTypeChecker.o `test -f 'ControlStruct/LabelTypeChecker.cc' || echo '$(srcdir)/'`ControlStruct/LabelTypeChecker.cc
+
+ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj: ControlStruct/LabelTypeChecker.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj -MD -MP -MF ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo -c -o ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj `if test -f 'ControlStruct/LabelTypeChecker.cc'; then $(CYGPATH_W) 'ControlStruct/LabelTypeChecker.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/LabelTypeChecker.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ControlStruct/LabelTypeChecker.cc' object='ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj `if test -f 'ControlStruct/LabelTypeChecker.cc'; then $(CYGPATH_W) 'ControlStruct/LabelTypeChecker.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/LabelTypeChecker.cc'; fi`
+
 GenPoly/driver_cfa_cpp-Box.o: GenPoly/Box.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-Box.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-Box.Tpo -c -o GenPoly/driver_cfa_cpp-Box.o `test -f 'GenPoly/Box.cc' || echo '$(srcdir)/'`GenPoly/Box.cc

src/ResolvExpr/Alternative.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Alternative.cc --
+// Alternative.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -12 +12 @@
 // Last Modified On : Sat May 16 23:54:23 2015
 // Update Count     : 2
-//
+// 
 
 #include "Alternative.h"
@@ -54 +54 @@
                         expr->print( os, indent );
                         os << "(types:" << std::endl;
-                        os << std::string( indent+4, ' ' );
-                        expr->get_result()->print( os, indent + 4 );
-                        os << std::endl << ")" << std::endl;
+                        printAll( expr->get_results(), os, indent + 4 );
+                        os << ")" << std::endl;
                 } else {
                         os << "Null expression!" << std::endl;

src/ResolvExpr/AlternativeFinder.cc

@@ -100 +100 @@
                                 PruneStruct current( candidate );
                                 std::string mangleName;
-                                {
-                                        Type * newType = candidate->expr->get_result()->clone();
+                                for ( std::list< Type* >::const_iterator retType = candidate->expr->get_results().begin(); retType != candidate->expr->get_results().end(); ++retType ) {
+                                        Type *newType = (*retType)->clone();
                                         candidate->env.apply( newType );
-                                        mangleName = SymTab::Mangler::mangle( newType );
+                                        mangleName += SymTab::Mangler::mangle( newType );
                                         delete newType;
                                 }
@@ -132 +132 @@
                                 if ( ! target->second.isAmbiguous ) {
                                         Alternative &alt = *target->second.candidate;
-                                        alt.env.applyFree( alt.expr->get_result() );
+                                        for ( std::list< Type* >::iterator result = alt.expr->get_results().begin(); result != alt.expr->get_results().end(); ++result ) {
+                                                alt.env.applyFree( *result );
+                                        }
                                         *out++ = alt;
                                 }
                         }
+
                 }
 
@@ -146 +149 @@
 
                 void renameTypes( Expression *expr ) {
-                        expr->get_result()->accept( global_renamer );
+                        for ( std::list< Type* >::iterator i = expr->get_results().begin(); i != expr->get_results().end(); ++i ) {
+                                (*i)->accept( global_renamer );
+                        }
+                }
+
+                // flatten tuple type into list of types
+                template< typename OutputIterator >
+                void flatten( Type * type, OutputIterator out ) {
+                        if ( TupleType * tupleType = dynamic_cast< TupleType * >( type ) ) {
+                                for ( Type * t : *tupleType ) {
+                                        flatten( t, out );
+                                }
+                        } else {
+                                *out++ = type;
+                        }
                 }
         }
@@ -178 +195 @@
                 for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
                         if ( adjust ) {
-                                adjustExprType( i->expr->get_result(), i->env, indexer );
+                                adjustExprTypeList( i->expr->get_results().begin(), i->expr->get_results().end(), i->env, indexer );
                         }
                 }
@@ -248 +265 @@
         Cost computeConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
                 ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( alt.expr );
-                PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
+                PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
                 FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
 
@@ -265 +282 @@
                                 (*actualExpr)->print( std::cerr, 8 );
                                 std::cerr << "--- results are" << std::endl;
-                                (*actualExpr)->get_result()->print( std::cerr, 8 );
+                                printAll( (*actualExpr)->get_results(), std::cerr, 8 );
                         )
                         std::list< DeclarationWithType* >::iterator startFormal = formal;
                         Cost actualCost;
-                        std::list< Type * > flatActualTypes;
-                        flatten( (*actualExpr)->get_result(), back_inserter( flatActualTypes ) );
-                        for ( std::list< Type* >::iterator actualType = flatActualTypes.begin(); actualType != flatActualTypes.end(); ++actualType ) {
-
+                        for ( std::list< Type* >::iterator actualType = (*actualExpr)->get_results().begin(); actualType != (*actualExpr)->get_results().end(); ++actualType ) {
 
                                 // tuple handling code
@@ -385 +399 @@
 
                 for ( AltList::const_iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
-                        std::list< Type * > flatActualTypes;
-                        flatten( actualExpr->expr->get_result(), back_inserter( flatActualTypes ) );
-                        for ( std::list< Type* >::iterator actualType = flatActualTypes.begin(); actualType != flatActualTypes.end(); ++actualType, ++formalType ) {
+                        std::list< Type* > & actualTypes = actualExpr->expr->get_results();
+                        for ( std::list< Type* >::iterator actualType = actualTypes.begin(); actualType != actualTypes.end(); ++actualType ) {
                                 if ( formalType == formalTypes.end() ) {
                                         // the type of the formal parameter may be a tuple type. To make this easier to work with,
@@ -403 +416 @@
                                 PRINT(
                                         std::cerr << "formal type is ";
-                                        (*formalType)->print( std::cerr );
+                                        (*formal)->get_type()->print( std::cerr );
                                         std::cerr << std::endl << "actual type is ";
                                         (*actualType)->print( std::cerr );
@@ -411 +424 @@
                                         return false;
                                 }
+                                ++formalType;
                         }
                 }
@@ -518 +532 @@
                                 //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
                                 Expression *varExpr = new VariableExpr( candDecl );
-                                delete varExpr->get_result();
-                                varExpr->set_result( adjType->clone() );
+                                deleteAll( varExpr->get_results() );
+                                varExpr->get_results().clear();
+                                varExpr->get_results().push_front( adjType->clone() );
                                 PRINT(
                                         std::cerr << "satisfying assertion " << curDecl->get_uniqueId() << " ";
@@ -591 +606 @@
                                 PointerType pt( Type::Qualifiers(), v.clone() );
                                 UntypedExpr *vexpr = untypedExpr->clone();
-                                vexpr->set_result( pt.clone() );
+                                vexpr->get_results().push_front( pt.clone() );
                                 alternatives.push_back( Alternative( vexpr, env, Cost()) );
                                 return;
@@ -619 +634 @@
                                 // check if the type is pointer to function
                                 PointerType *pointer;
-                                if ( ( pointer = dynamic_cast< PointerType* >( func->expr->get_result() ) ) ) {
+                                if ( func->expr->get_results().size() == 1 && ( pointer = dynamic_cast< PointerType* >( func->expr->get_results().front() ) ) ) {
                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
                                                 for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
@@ -655 +670 @@
                                                 // check if the type is pointer to function
                                                 PointerType *pointer;
-                                                if ( ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result() ) ) ) {
+                                                if ( funcOp->expr->get_results().size() == 1
+                                                        && ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_results().front() ) ) ) {
                                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
                                                                 for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
@@ -680 +696 @@
                         PRINT(
                                 ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( withFunc->expr );
-                                PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
+                                PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
                                 FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
                                 std::cerr << "Case +++++++++++++" << std::endl;
@@ -703 +719 @@
 
         bool isLvalue( Expression *expr ) {
-                // xxx - recurse into tuples?
-                return expr->has_result() && expr->get_result()->get_isLvalue();
+                for ( std::list< Type* >::const_iterator i = expr->get_results().begin(); i != expr->get_results().end(); ++i ) {
+                        if ( !(*i)->get_isLvalue() ) return false;
+                } // for
+                return true;
         }
 
@@ -718 +736 @@
 
         void AlternativeFinder::visit( CastExpr *castExpr ) {
-                Type *& toType = castExpr->get_result();
-                toType = resolveTypeof( toType, indexer );
-                SymTab::validateType( toType, &indexer );
-                adjustExprType( toType, env, indexer );
+                for ( std::list< Type* >::iterator i = castExpr->get_results().begin(); i != castExpr->get_results().end(); ++i ) {
+                        *i = resolveTypeof( *i, indexer );
+                        SymTab::validateType( *i, &indexer );
+                        adjustExprType( *i, env, indexer );
+                } // for
 
                 AlternativeFinder finder( indexer, env );
@@ -735 +754 @@
                         // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
                         // to.
-                        int discardedValues = (*i).expr->get_result()->size() - castExpr->get_result()->size();
+                        int discardedValues = (*i).expr->get_results().size() - castExpr->get_results().size();
                         if ( discardedValues < 0 ) continue;
-                        // xxx - may need to go into tuple types and extract relavent types and use unifyList
+                        std::list< Type* >::iterator candidate_end = (*i).expr->get_results().begin();
+                        std::advance( candidate_end, castExpr->get_results().size() );
                         // unification run for side-effects
-                        unify( castExpr->get_result(), (*i).expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer );
-                        Cost thisCost = castCost( (*i).expr->get_result(), castExpr->get_result(), indexer, i->env );
+                        unifyList( castExpr->get_results().begin(), castExpr->get_results().end(),
+                                           (*i).expr->get_results().begin(), candidate_end,
+                                   i->env, needAssertions, haveAssertions, openVars, indexer );
+                        Cost thisCost = castCostList( (*i).expr->get_results().begin(), candidate_end,
+                                                                                  castExpr->get_results().begin(), castExpr->get_results().end(),
+                                                                                  indexer, i->env );
                         if ( thisCost != Cost::infinity ) {
                                 // count one safe conversion for each value that is thrown away
@@ -763 +787 @@
 
                 for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) {
-                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_result() ) ) {
-                                addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
-                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_result() ) ) {
-                                addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                        if ( agg->expr->get_results().size() == 1 ) {
+                                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_results().front() ) ) {
+                                        addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_results().front() ) ) {
+                                        addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                                } // if
                         } // if
                 } // for
@@ -897 +923 @@
                         alternatives.push_back( Alternative( new AttrExpr( new VariableExpr( funcDecl ), argType->clone() ), env, Cost::zero ) );
                         for ( std::list< DeclarationWithType* >::iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
-                                alternatives.back().expr->set_result( (*i)->get_type()->clone() );
+                                alternatives.back().expr->get_results().push_back( (*i)->get_type()->clone() );
                         } // for
                 } // if
@@ -920 +946 @@
                                                         finder.find( attrExpr->get_expr() );
                                                         for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) {
-                                                                if ( choice->expr->get_result()->size() == 1 ) {
-                                                                        resolveAttr(*i, function, choice->expr->get_result(), choice->env );
+                                                                if ( choice->expr->get_results().size() == 1 ) {
+                                                                        resolveAttr(*i, function, choice->expr->get_results().front(), choice->env );
                                                                 } // fi
                                                         } // for
@@ -963 +989 @@
                                         AssertionSet needAssertions, haveAssertions;
                                         Alternative newAlt( 0, third->env, first->cost + second->cost + third->cost );
-                                        Type* commonType;
-                                        if ( unify( second->expr->get_result(), third->expr->get_result(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
+                                        std::list< Type* > commonTypes;
+                                        if ( unifyList( second->expr->get_results().begin(), second->expr->get_results().end(), third->expr->get_results().begin(), third->expr->get_results().end(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonTypes ) ) {
                                                 ConditionalExpr *newExpr = new ConditionalExpr( first->expr->clone(), second->expr->clone(), third->expr->clone() );
-                                                newExpr->set_result( commonType ? commonType : second->expr->get_result()->clone() );
+                                                std::list< Type* >::const_iterator original = second->expr->get_results().begin();
+                                                std::list< Type* >::const_iterator commonType = commonTypes.begin();
+                                                for ( ; original != second->expr->get_results().end() && commonType != commonTypes.end(); ++original, ++commonType ) {
+                                                        if ( *commonType ) {
+                                                                newExpr->get_results().push_back( *commonType );
+                                                        } else {
+                                                                newExpr->get_results().push_back( (*original)->clone() );
+                                                        } // if
+                                                } // for
                                                 newAlt.expr = newExpr;
                                                 inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( alternatives ) );
@@ -994 +1028 @@
                         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 ( std::list< Expression* >::const_iterator resultExpr = newExpr->get_exprs().begin(); resultExpr != newExpr->get_exprs().end(); ++resultExpr ) {
+                                for ( std::list< Type* >::const_iterator resultType = (*resultExpr)->get_results().begin(); resultType != (*resultExpr)->get_results().end(); ++resultType ) {
+                                        newExpr->get_results().push_back( (*resultType)->clone() );
+                                } // for
                         } // for
-                        newExpr->set_result( tupleType );
 
                         TypeEnvironment compositeEnv;
@@ -1026 +1057 @@
                 alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
         }
-
-        void AlternativeFinder::visit( TupleAssignExpr *tupleAssignExpr ) {
-                alternatives.push_back( Alternative( tupleAssignExpr->clone(), env, Cost::zero ) );
-        }
 } // namespace ResolvExpr
 

src/ResolvExpr/AlternativeFinder.h

@@ -68 +68 @@
                 virtual void visit( ConstructorExpr * ctorExpr );
                 virtual void visit( TupleIndexExpr *tupleExpr );
-                virtual void visit( TupleAssignExpr *tupleExpr );
                 /// Runs a new alternative finder on each element in [begin, end)
                 /// and writes each alternative finder to out.

src/ResolvExpr/AlternativePrinter.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// AlternativePrinter.cc --
+// AlternativePrinter.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -33 +33 @@
                 for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
                         os << "Alternative " << count++ << " ==============" << std::endl;
-                        i->expr->get_result()->print( os );
+                        printAll( i->expr->get_results(), os );
                         //    i->print( os );
                         os << std::endl;

src/ResolvExpr/ResolveTypeof.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ResolveTypeof.cc --
+// ResolveTypeof.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -58 +58 @@
                 if ( typeofType->get_expr() ) {
                         Expression *newExpr = resolveInVoidContext( typeofType->get_expr(), indexer );
-                        assert( newExpr->has_result() && ! newExpr->get_result()->isVoid() );
-                        Type *newType = newExpr->get_result();
+                        assert( newExpr->get_results().size() > 0 );
+                        Type *newType;
+                        if ( newExpr->get_results().size() > 1 ) {
+                                TupleType *tupleType = new TupleType( Type::Qualifiers() );
+                                cloneAll( newExpr->get_results(), tupleType->get_types() );
+                                newType = tupleType;
+                        } else {
+                                newType = newExpr->get_results().front()->clone();
+                        } // if
                         delete typeofType;
                         return newType;

src/ResolvExpr/Resolver.cc

@@ -19 +19 @@
 #include "RenameVars.h"
 #include "ResolveTypeof.h"
-#include "typeops.h"
 #include "SynTree/Statement.h"
 #include "SynTree/Type.h"
@@ -68 +67 @@
           void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & );
           void fallbackInit( ConstructorInit * ctorInit );
-                Type * functionReturn;
+                std::list< Type * > functionReturn;
                 Type *initContext;
                 Type *switchType;
@@ -156 +155 @@
                         const TypeEnvironment *newEnv = 0;
                         for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
-                                if ( i->expr->get_result()->size() == 1 && isIntegralType( i->expr->get_result() ) ) {
+                                if ( i->expr->get_results().size() == 1 && isIntegralType( i->expr->get_results().front() ) ) {
                                         if ( newExpr ) {
                                                 throw SemanticError( "Too many interpretations for case control expression", untyped );
@@ -233 +232 @@
                 Type *new_type = resolveTypeof( functionDecl->get_type(), *this );
                 functionDecl->set_type( new_type );
-                ValueGuard< Type * > oldFunctionReturn( functionReturn );
-                functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
+                std::list< Type * > oldFunctionReturn = functionReturn;
+                functionReturn.clear();
+                for ( std::list< DeclarationWithType * >::const_iterator i = functionDecl->get_functionType()->get_returnVals().begin(); i != functionDecl->get_functionType()->get_returnVals().end(); ++i ) {
+                        functionReturn.push_back( (*i)->get_type() );
+                } // for
                 SymTab::Indexer::visit( functionDecl );
+                functionReturn = oldFunctionReturn;
         }
 
@@ -333 +336 @@
         void Resolver::visit( ReturnStmt *returnStmt ) {
                 if ( returnStmt->get_expr() ) {
-                        CastExpr *castExpr = new CastExpr( returnStmt->get_expr(), functionReturn->clone() );
+                        CastExpr *castExpr = new CastExpr( returnStmt->get_expr() );
+                        cloneAll( functionReturn, castExpr->get_results() );
                         Expression *newExpr = findSingleExpression( castExpr, *this );
                         delete castExpr;
@@ -378 +382 @@
                                 if ( isCharType( at->get_base() ) ) {
                                         // check if the resolved type is char *
-                                        if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
+                                        if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_results().front() ) ) {
                                                 if ( isCharType( pt->get_base() ) ) {
                                                         // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";

src/ResolvExpr/Unify.cc

@@ -588 +588 @@
         }
 
-        // xxx - compute once and store in the FunctionType?
-        Type * extractResultType( FunctionType * function ) {
-                if ( function->get_returnVals().size() == 0 ) {
-                        return new VoidType( Type::Qualifiers() );
-                } else if ( function->get_returnVals().size() == 1 ) {
-                        return function->get_returnVals().front()->get_type()->clone();
-                } else {
-                        TupleType * tupleType = new TupleType( Type::Qualifiers() );
-                        for ( DeclarationWithType * decl : function->get_returnVals() ) {
-                                tupleType->get_types().push_back( decl->get_type()->clone() );
-                        } // for
-                        return tupleType;
-                }
-        }
-
 } // namespace ResolvExpr
 

src/ResolvExpr/typeops.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// typeops.h --
+// typeops.h -- 
 //
 // Author           : Richard C. Bilson
@@ -30 +30 @@
                 typedef typename InputIterator::value_type SetType;
                 typedef typename std::list< typename SetType::value_type > ListType;
-
+  
                 if ( begin == end )     {
                         *out++ = ListType();
                         return;
                 } // if
-
+  
                 InputIterator current = begin;
                 begin++;
@@ -41 +41 @@
                 std::list< ListType > recursiveResult;
                 combos( begin, end, back_inserter( recursiveResult ) );
-
+  
                 for ( typename std::list< ListType >::const_iterator i = recursiveResult.begin(); i != recursiveResult.end(); ++i ) {
                         for ( typename ListType::const_iterator j = current->begin(); j != current->end(); ++j ) {
@@ -52 +52 @@
                 } // for
         }
-
+  
         // in AdjustExprType.cc
         /// Replaces array types with the equivalent pointer, and function types with a pointer-to-function
@@ -144 +144 @@
         }
 
-        /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value.
-        Type * extractResultType( FunctionType * functionType );
-
         // in CommonType.cc
         Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
@@ -155 +152 @@
         // in Occurs.cc
         bool occurs( Type *type, std::string varName, const TypeEnvironment &env );
-
-        // flatten tuple type into list of types
-        template< typename OutputIterator >
-        void flatten( Type * type, OutputIterator out ) {
-                if ( TupleType * tupleType = dynamic_cast< TupleType * >( type ) ) {
-                        for ( Type * t : tupleType->get_types() ) {
-                                flatten( t, out );
-                        }
-                } else {
-                        *out++ = type;
-                }
-        }
 } // namespace ResolvExpr
 

src/SymTab/Autogen.cc

@@ -116 +116 @@
                 // This happens before function pointer type conversion, so need to do it manually here
                 VariableExpr * assignVarExpr = new VariableExpr( assignDecl );
-                Type * assignVarExprType = assignVarExpr->get_result();
+                Type *& assignVarExprType = assignVarExpr->get_results().front();
                 assignVarExprType = new PointerType( Type::Qualifiers(), assignVarExprType );
-                assignVarExpr->set_result( assignVarExprType );
                 ApplicationExpr * assignExpr = new ApplicationExpr( assignVarExpr );
                 assignExpr->get_args().push_back( new VariableExpr( dstParam ) );

src/SymTab/Indexer.cc

@@ -40 +40 @@
 
 namespace SymTab {
-        template< typename TreeType, typename VisitorType >
-        inline void acceptNewScope( TreeType *tree, VisitorType &visitor ) {
+        template< typename Container, typename VisitorType >
+        inline void acceptAllNewScope( Container &container, VisitorType &visitor ) {
                 visitor.enterScope();
-                maybeAccept( tree, visitor );
+                acceptAll( container, visitor );
                 visitor.leaveScope();
         }
@@ -337 +337 @@
 
         void Indexer::visit( ApplicationExpr *applicationExpr ) {
-                acceptNewScope( applicationExpr->get_result(), *this );
+                acceptAllNewScope( applicationExpr->get_results(), *this );
                 maybeAccept( applicationExpr->get_function(), *this );
                 acceptAll( applicationExpr->get_args(), *this );
@@ -343 +343 @@
 
         void Indexer::visit( UntypedExpr *untypedExpr ) {
-                acceptNewScope( untypedExpr->get_result(), *this );
+                acceptAllNewScope( untypedExpr->get_results(), *this );
                 acceptAll( untypedExpr->get_args(), *this );
         }
 
         void Indexer::visit( NameExpr *nameExpr ) {
-                acceptNewScope( nameExpr->get_result(), *this );
+                acceptAllNewScope( nameExpr->get_results(), *this );
         }
 
         void Indexer::visit( AddressExpr *addressExpr ) {
-                acceptNewScope( addressExpr->get_result(), *this );
+                acceptAllNewScope( addressExpr->get_results(), *this );
                 maybeAccept( addressExpr->get_arg(), *this );
         }
 
         void Indexer::visit( LabelAddressExpr *labAddressExpr ) {
-                acceptNewScope( labAddressExpr->get_result(), *this );
+                acceptAllNewScope( labAddressExpr->get_results(), *this );
                 maybeAccept( labAddressExpr->get_arg(), *this );
         }
 
         void Indexer::visit( CastExpr *castExpr ) {
-                acceptNewScope( castExpr->get_result(), *this );
+                acceptAllNewScope( castExpr->get_results(), *this );
                 maybeAccept( castExpr->get_arg(), *this );
         }
 
         void Indexer::visit( UntypedMemberExpr *memberExpr ) {
-                acceptNewScope( memberExpr->get_result(), *this );
+                acceptAllNewScope( memberExpr->get_results(), *this );
                 maybeAccept( memberExpr->get_aggregate(), *this );
         }
 
         void Indexer::visit( MemberExpr *memberExpr ) {
-                acceptNewScope( memberExpr->get_result(), *this );
+                acceptAllNewScope( memberExpr->get_results(), *this );
                 maybeAccept( memberExpr->get_aggregate(), *this );
         }
 
         void Indexer::visit( VariableExpr *variableExpr ) {
-                acceptNewScope( variableExpr->get_result(), *this );
+                acceptAllNewScope( variableExpr->get_results(), *this );
         }
 
         void Indexer::visit( ConstantExpr *constantExpr ) {
-                acceptNewScope( constantExpr->get_result(), *this );
+                acceptAllNewScope( constantExpr->get_results(), *this );
                 maybeAccept( constantExpr->get_constant(), *this );
         }
 
         void Indexer::visit( SizeofExpr *sizeofExpr ) {
-                acceptNewScope( sizeofExpr->get_result(), *this );
+                acceptAllNewScope( sizeofExpr->get_results(), *this );
                 if ( sizeofExpr->get_isType() ) {
                         maybeAccept( sizeofExpr->get_type(), *this );
@@ -395 +395 @@
 
         void Indexer::visit( AlignofExpr *alignofExpr ) {
-                acceptNewScope( alignofExpr->get_result(), *this );
+                acceptAllNewScope( alignofExpr->get_results(), *this );
                 if ( alignofExpr->get_isType() ) {
                         maybeAccept( alignofExpr->get_type(), *this );
@@ -404 +404 @@
 
         void Indexer::visit( UntypedOffsetofExpr *offsetofExpr ) {
-                acceptNewScope( offsetofExpr->get_result(), *this );
+                acceptAllNewScope( offsetofExpr->get_results(), *this );
                 maybeAccept( offsetofExpr->get_type(), *this );
         }
 
         void Indexer::visit( OffsetofExpr *offsetofExpr ) {
-                acceptNewScope( offsetofExpr->get_result(), *this );
+                acceptAllNewScope( offsetofExpr->get_results(), *this );
                 maybeAccept( offsetofExpr->get_type(), *this );
                 maybeAccept( offsetofExpr->get_member(), *this );
@@ -415 +415 @@
 
         void Indexer::visit( OffsetPackExpr *offsetPackExpr ) {
-                acceptNewScope( offsetPackExpr->get_result(), *this );
+                acceptAllNewScope( offsetPackExpr->get_results(), *this );
                 maybeAccept( offsetPackExpr->get_type(), *this );
         }
 
         void Indexer::visit( AttrExpr *attrExpr ) {
-                acceptNewScope( attrExpr->get_result(), *this );
+                acceptAllNewScope( attrExpr->get_results(), *this );
                 if ( attrExpr->get_isType() ) {
                         maybeAccept( attrExpr->get_type(), *this );
@@ -429 +429 @@
 
         void Indexer::visit( LogicalExpr *logicalExpr ) {
-                acceptNewScope( logicalExpr->get_result(), *this );
+                acceptAllNewScope( logicalExpr->get_results(), *this );
                 maybeAccept( logicalExpr->get_arg1(), *this );
                 maybeAccept( logicalExpr->get_arg2(), *this );
@@ -435 +435 @@
 
         void Indexer::visit( ConditionalExpr *conditionalExpr ) {
-                acceptNewScope( conditionalExpr->get_result(), *this );
+                acceptAllNewScope( conditionalExpr->get_results(), *this );
                 maybeAccept( conditionalExpr->get_arg1(), *this );
                 maybeAccept( conditionalExpr->get_arg2(), *this );
@@ -442 +442 @@
 
         void Indexer::visit( CommaExpr *commaExpr ) {
-                acceptNewScope( commaExpr->get_result(), *this );
+                acceptAllNewScope( commaExpr->get_results(), *this );
                 maybeAccept( commaExpr->get_arg1(), *this );
                 maybeAccept( commaExpr->get_arg2(), *this );
@@ -448 +448 @@
 
         void Indexer::visit( TupleExpr *tupleExpr ) {
-                acceptNewScope( tupleExpr->get_result(), *this );
+                acceptAllNewScope( tupleExpr->get_results(), *this );
                 acceptAll( tupleExpr->get_exprs(), *this );
         }
 
         void Indexer::visit( TupleAssignExpr *tupleExpr ) {
-                acceptNewScope( tupleExpr->get_result(), *this );
+                acceptAllNewScope( tupleExpr->get_results(), *this );
                 enterScope();
                 acceptAll( tupleExpr->get_tempDecls(), *this );
@@ -461 +461 @@
 
         void Indexer::visit( TypeExpr *typeExpr ) {
-                acceptNewScope( typeExpr->get_result(), *this );
+                acceptAllNewScope( typeExpr->get_results(), *this );
                 maybeAccept( typeExpr->get_type(), *this );
         }
@@ -472 +472 @@
 
         void Indexer::visit( UntypedValofExpr *valofExpr ) {
-                acceptNewScope( valofExpr->get_result(), *this );
+                acceptAllNewScope( valofExpr->get_results(), *this );
                 maybeAccept( valofExpr->get_body(), *this );
         }

src/SynTree/AddressExpr.cc

@@ -19 +19 @@
 
 AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
-        if ( arg->has_result() ) {
-                set_result( new PointerType( Type::Qualifiers(), arg->get_result()->clone() ) );
-        }
+        for ( std::list< Type* >::const_iterator i = arg->get_results().begin(); i != arg->get_results().end(); ++i ) {
+                get_results().push_back( new PointerType( Type::Qualifiers(), (*i)->clone() ) );
+        } // for
 }
 
@@ -35 +35 @@
         if ( arg ) {
                 os << std::string( indent+2, ' ' );
-                arg->print( os, indent+2 );
+    arg->print( os, indent+2 );
         } // if
 }

src/SynTree/ApplicationExpr.cc

@@ -21 +21 @@
 #include "TypeSubstitution.h"
 #include "Common/utility.h"
-#include "ResolvExpr/typeops.h"
+
 
 ParamEntry::ParamEntry( const ParamEntry &other ) :
@@ -43 +43 @@
 
 ApplicationExpr::ApplicationExpr( Expression *funcExpr ) : function( funcExpr ) {
-        PointerType *pointer = safe_dynamic_cast< PointerType* >( funcExpr->get_result() );
-        FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+        PointerType *pointer = dynamic_cast< PointerType* >( funcExpr->get_results().front() );
+        assert( pointer );
+        FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
+        assert( function );
 
-        set_result( ResolvExpr::extractResultType( function ) );
-
-        assert( has_result() );
+        for ( std::list< DeclarationWithType* >::const_iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
+                get_results().push_back( (*i)->get_type()->clone() );
+        } // for
 }
 

src/SynTree/CommaExpr.cc

@@ -23 +23 @@
         // to false on all result types. Actually doing this causes some strange things
         // to happen in later passes (particularly, Specialize, Lvalue, and Box). This needs to be looked into.
-        set_result( maybeClone( arg2->get_result() ) );
-        // get_type->set_isLvalue( false );
+        cloneAll( arg2->get_results(), get_results() );
+        // for ( Type *& type : get_results() ) {
+        //      type->set_isLvalue( false );
+        // }
 }
 

src/SynTree/Expression.cc

@@ -31 +31 @@
 
 
-Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
-
-Expression::Expression( const Expression &other ) : result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
+Expression::Expression( Expression *_aname ) : env( 0 ), argName( _aname ) {}
+
+Expression::Expression( const Expression &other ) : env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
+        cloneAll( other.results, results );
 }
 
@@ -39 +40 @@
         delete env;
         delete argName; // xxx -- there's a problem in cloning ConstantExpr I still don't know how to fix
-        delete result;
+        deleteAll( results );
+}
+
+void Expression::add_result( Type *t ) {
+        if ( TupleType *tuple = dynamic_cast< TupleType* >( t ) ) {
+                std::copy( tuple->get_types().begin(), tuple->get_types().end(), back_inserter( results ) );
+        } else {
+                results.push_back(t);
+        } // if
 }
 
@@ -59 +68 @@
 
 ConstantExpr::ConstantExpr( Constant _c, Expression *_aname ) : Expression( _aname ), constant( _c ) {
-        set_result( constant.get_type()->clone() );
+        add_result( constant.get_type()->clone() );
 }
 
@@ -76 +85 @@
         assert( var );
         assert( var->get_type() );
-        Type * type = var->get_type()->clone();
-        type->set_isLvalue( true );
-        set_result( type );
+        add_result( var->get_type()->clone() );
+        for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
+                (*i)->set_isLvalue( true );
+        } // for
 }
 
@@ -100 +110 @@
 SizeofExpr::SizeofExpr( Expression *expr_, Expression *_aname ) :
                 Expression( _aname ), expr(expr_), type(0), isType(false) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
 SizeofExpr::SizeofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -131 +141 @@
 AlignofExpr::AlignofExpr( Expression *expr_, Expression *_aname ) :
                 Expression( _aname ), expr(expr_), type(0), isType(false) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
 AlignofExpr::AlignofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -162 +172 @@
 UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type_, const std::string &member_, Expression *_aname ) :
                 Expression( _aname ), type(type_), member(member_) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -187 +197 @@
 OffsetofExpr::OffsetofExpr( Type *type_, DeclarationWithType *member_, Expression *_aname ) :
                 Expression( _aname ), type(type_), member(member_) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -219 +229 @@
 
 OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) {
-        set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
+        add_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
 }
 
@@ -274 +284 @@
 
 CastExpr::CastExpr( Expression *arg_, Type *toType, Expression *_aname ) : Expression( _aname ), arg(arg_) {
-        set_result(toType);
+        add_result(toType);
 }
 
 CastExpr::CastExpr( Expression *arg_, Expression *_aname ) : Expression( _aname ), arg(arg_) {
-        set_result( new VoidType( Type::Qualifiers() ) );
 }
 
@@ -294 +303 @@
         arg->print(os, indent+2);
         os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
-        os << std::string( indent+2, ' ' );
-        if ( result->isVoid() ) {
-                os << "nothing";
+        if ( results.empty() ) {
+                os << std::string( indent+2, ' ' ) << "nothing" << std::endl;
         } else {
-                result->print( os, indent+2 );
+                printAll(results, os, indent+2);
         } // if
-        os << std::endl;
         Expression::print( os, indent );
 }
@@ -334 +341 @@
 MemberExpr::MemberExpr( DeclarationWithType *_member, Expression *_aggregate, Expression *_aname ) :
                 Expression( _aname ), member(_member), aggregate(_aggregate) {
-        set_result( member->get_type()->clone() );
-        get_result()->set_isLvalue( true );
+        add_result( member->get_type()->clone() );
+        for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
+                (*i)->set_isLvalue( true );
+        } // for
 }
 
@@ -410 +419 @@
 LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp, Expression *_aname ) :
                 Expression( _aname ), arg1(arg1_), arg2(arg2_), isAnd(andp) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
 }
 
@@ -468 +477 @@
 ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( ApplicationExpr * callExpr ) : callExpr( callExpr ) {
         assert( callExpr );
-        assert( callExpr->has_result() );
-        set_result( callExpr->get_result()->clone() );
+        cloneAll( callExpr->get_results(), results );
 }
 
@@ -502 +510 @@
         Expression * arg = InitTweak::getCallArg( callExpr, 0 );
         assert( arg );
-        set_result( maybeClone( arg->get_result() ) );
+        cloneAll( arg->get_results(), results );
 }
 
@@ -522 +530 @@
 
 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
-        set_result( type->clone() );
+        add_result( type->clone() );
 }
 
@@ -562 +570 @@
         if ( ! body.empty() ) {
                 if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( body.back() ) ) {
-                        set_result( maybeClone( exprStmt->get_expr()->get_result() ) );
+                        cloneAll( exprStmt->get_expr()->get_results(), get_results() );
                 }
         }

src/SynTree/Expression.h

@@ -32 +32 @@
         virtual ~Expression();
 
-        Type *& get_result() { return result; }
-        void set_result( Type *newValue ) { result = newValue; }
-        bool has_result() const { return result != nullptr; }
+        std::list<Type *>& get_results() { return results; }
+        void add_result( Type *t );
 
         TypeSubstitution *get_env() const { return env; }
@@ -48 +47 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
   protected:
-        Type * result;
+        std::list<Type *> results;
         TypeSubstitution *env;
         Expression* argName; // if expression is used as an argument, it can be "designated" by this name

src/SynTree/Mutator.cc

@@ -178 +178 @@
 
 Expression *Mutator::mutate( ApplicationExpr *applicationExpr ) {
-        applicationExpr->set_result( maybeMutate( applicationExpr->get_result(), *this ) );
+        mutateAll( applicationExpr->get_results(), *this );
         applicationExpr->set_function( maybeMutate( applicationExpr->get_function(), *this ) );
         mutateAll( applicationExpr->get_args(), *this );
@@ -185 +185 @@
 
 Expression *Mutator::mutate( UntypedExpr *untypedExpr ) {
-        untypedExpr->set_result( maybeMutate( untypedExpr->get_result(), *this ) );
+        mutateAll( untypedExpr->get_results(), *this );
         mutateAll( untypedExpr->get_args(), *this );
         return untypedExpr;
@@ -191 +191 @@
 
 Expression *Mutator::mutate( NameExpr *nameExpr ) {
-        nameExpr->set_result( maybeMutate( nameExpr->get_result(), *this ) );
+        mutateAll( nameExpr->get_results(), *this );
         return nameExpr;
 }
 
 Expression *Mutator::mutate( AddressExpr *addressExpr ) {
-        addressExpr->set_result( maybeMutate( addressExpr->get_result(), *this ) );
+        mutateAll( addressExpr->get_results(), *this );
         addressExpr->set_arg( maybeMutate( addressExpr->get_arg(), *this ) );
         return addressExpr;
@@ -202 +202 @@
 
 Expression *Mutator::mutate( LabelAddressExpr *labelAddressExpr ) {
-        labelAddressExpr->set_result( maybeMutate( labelAddressExpr->get_result(), *this ) );
+        mutateAll( labelAddressExpr->get_results(), *this );
         labelAddressExpr->set_arg( maybeMutate( labelAddressExpr->get_arg(), *this ) );
         return labelAddressExpr;
@@ -208 +208 @@
 
 Expression *Mutator::mutate( CastExpr *castExpr ) {
-        castExpr->set_result( maybeMutate( castExpr->get_result(), *this ) );
+        mutateAll( castExpr->get_results(), *this );
         castExpr->set_arg( maybeMutate( castExpr->get_arg(), *this ) );
         return castExpr;
@@ -214 +214 @@
 
 Expression *Mutator::mutate( UntypedMemberExpr *memberExpr ) {
-        memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
+        mutateAll( memberExpr->get_results(), *this );
         memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
         memberExpr->set_member( maybeMutate( memberExpr->get_member(), *this ) );
@@ -221 +221 @@
 
 Expression *Mutator::mutate( MemberExpr *memberExpr ) {
-        memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
+        mutateAll( memberExpr->get_results(), *this );
         memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
         return memberExpr;
@@ -227 +227 @@
 
 Expression *Mutator::mutate( VariableExpr *variableExpr ) {
-        variableExpr->set_result( maybeMutate( variableExpr->get_result(), *this ) );
+        mutateAll( variableExpr->get_results(), *this );
         return variableExpr;
 }
 
 Expression *Mutator::mutate( ConstantExpr *constantExpr ) {
-        constantExpr->set_result( maybeMutate( constantExpr->get_result(), *this ) );
+        mutateAll( constantExpr->get_results(), *this );
 //  maybeMutate( constantExpr->get_constant(), *this )
         return constantExpr;
@@ -238 +238 @@
 
 Expression *Mutator::mutate( SizeofExpr *sizeofExpr ) {
-        sizeofExpr->set_result( maybeMutate( sizeofExpr->get_result(), *this ) );
+        mutateAll( sizeofExpr->get_results(), *this );
         if ( sizeofExpr->get_isType() ) {
                 sizeofExpr->set_type( maybeMutate( sizeofExpr->get_type(), *this ) );
@@ -248 +248 @@
 
 Expression *Mutator::mutate( AlignofExpr *alignofExpr ) {
-        alignofExpr->set_result( maybeMutate( alignofExpr->get_result(), *this ) );
+        mutateAll( alignofExpr->get_results(), *this );
         if ( alignofExpr->get_isType() ) {
                 alignofExpr->set_type( maybeMutate( alignofExpr->get_type(), *this ) );
@@ -258 +258 @@
 
 Expression *Mutator::mutate( UntypedOffsetofExpr *offsetofExpr ) {
-        offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
+        mutateAll( offsetofExpr->get_results(), *this );
         offsetofExpr->set_type( maybeMutate( offsetofExpr->get_type(), *this ) );
         return offsetofExpr;
@@ -264 +264 @@
 
 Expression *Mutator::mutate( OffsetofExpr *offsetofExpr ) {
-        offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
+        mutateAll( offsetofExpr->get_results(), *this );
         offsetofExpr->set_type( maybeMutate( offsetofExpr->get_type(), *this ) );
         offsetofExpr->set_member( maybeMutate( offsetofExpr->get_member(), *this ) );
@@ -271 +271 @@
 
 Expression *Mutator::mutate( OffsetPackExpr *offsetPackExpr ) {
-        offsetPackExpr->set_result( maybeMutate( offsetPackExpr->get_result(), *this ) );
+        mutateAll( offsetPackExpr->get_results(), *this );
         offsetPackExpr->set_type( maybeMutate( offsetPackExpr->get_type(), *this ) );
         return offsetPackExpr;
@@ -277 +277 @@
 
 Expression *Mutator::mutate( AttrExpr *attrExpr ) {
-        attrExpr->set_result( maybeMutate( attrExpr->get_result(), *this ) );
+        mutateAll( attrExpr->get_results(), *this );
         if ( attrExpr->get_isType() ) {
                 attrExpr->set_type( maybeMutate( attrExpr->get_type(), *this ) );
@@ -287 +287 @@
 
 Expression *Mutator::mutate( LogicalExpr *logicalExpr ) {
-        logicalExpr->set_result( maybeMutate( logicalExpr->get_result(), *this ) );
+        mutateAll( logicalExpr->get_results(), *this );
         logicalExpr->set_arg1( maybeMutate( logicalExpr->get_arg1(), *this ) );
         logicalExpr->set_arg2( maybeMutate( logicalExpr->get_arg2(), *this ) );
@@ -294 +294 @@
 
 Expression *Mutator::mutate( ConditionalExpr *conditionalExpr ) {
-        conditionalExpr->set_result( maybeMutate( conditionalExpr->get_result(), *this ) );
+        mutateAll( conditionalExpr->get_results(), *this );
         conditionalExpr->set_arg1( maybeMutate( conditionalExpr->get_arg1(), *this ) );
         conditionalExpr->set_arg2( maybeMutate( conditionalExpr->get_arg2(), *this ) );
@@ -302 +302 @@
 
 Expression *Mutator::mutate( CommaExpr *commaExpr ) {
-        commaExpr->set_result( maybeMutate( commaExpr->get_result(), *this ) );
+        mutateAll( commaExpr->get_results(), *this );
         commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
         commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
@@ -309 +309 @@
 
 Expression *Mutator::mutate( TypeExpr *typeExpr ) {
-        typeExpr->set_result( maybeMutate( typeExpr->get_result(), *this ) );
+        mutateAll( typeExpr->get_results(), *this );
         typeExpr->set_type( maybeMutate( typeExpr->get_type(), *this ) );
         return typeExpr;
@@ -329 +329 @@
 
 Expression* Mutator::mutate( ConstructorExpr *ctorExpr ) {
-        ctorExpr->set_result( maybeMutate( ctorExpr->get_result(), *this ) );
+        mutateAll( ctorExpr->get_results(), *this );
         ctorExpr->set_callExpr( maybeMutate( ctorExpr->get_callExpr(), *this ) );
         return ctorExpr;
@@ -335 +335 @@
 
 Expression *Mutator::mutate( CompoundLiteralExpr *compLitExpr ) {
-        compLitExpr->set_result( maybeMutate( compLitExpr->get_result(), *this ) );
+        mutateAll( compLitExpr->get_results(), *this );
         compLitExpr->set_type( maybeMutate( compLitExpr->get_type(), *this ) );
         compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) );
@@ -342 +342 @@
 
 Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
-        valofExpr->set_result( maybeMutate( valofExpr->get_result(), *this ) );
+        mutateAll( valofExpr->get_results(), *this );
         return valofExpr;
 }
@@ -353 +353 @@
 
 Expression *Mutator::mutate( TupleExpr *tupleExpr ) {
-        tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
+        mutateAll( tupleExpr->get_results(), *this );
         mutateAll( tupleExpr->get_exprs(), *this );
         return tupleExpr;
@@ -359 +359 @@
 
 Expression *Mutator::mutate( TupleIndexExpr *tupleExpr ) {
-        tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
+        mutateAll( tupleExpr->get_results(), *this );
         tupleExpr->set_tuple( maybeMutate( tupleExpr->get_tuple(), *this ) );
         return tupleExpr;
@@ -365 +365 @@
 
 Expression *Mutator::mutate( MemberTupleExpr *tupleExpr ) {
-        tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
+        mutateAll( tupleExpr->get_results(), *this );
         tupleExpr->set_member( maybeMutate( tupleExpr->get_member(), *this ) );
         tupleExpr->set_aggregate( maybeMutate( tupleExpr->get_aggregate(), *this ) );
@@ -372 +372 @@
 
 Expression *Mutator::mutate( TupleAssignExpr *assignExpr ) {
-        assignExpr->set_result( maybeMutate( assignExpr->get_result(), *this ) );
+        mutateAll( assignExpr->get_results(), *this );
         mutateAll( assignExpr->get_tempDecls(), *this );
         mutateAll( assignExpr->get_assigns(), *this );
@@ -379 +379 @@
 
 Expression *Mutator::mutate( StmtExpr *stmtExpr ) {
-        stmtExpr->set_result( maybeMutate( stmtExpr->get_result(), *this ) );
+        mutateAll( stmtExpr->get_results(), *this );
         stmtExpr->set_statements( maybeMutate( stmtExpr->get_statements(), *this ) );
         return stmtExpr;

src/SynTree/TupleExpr.cc

@@ -31 +31 @@
 
 void TupleExpr::print( std::ostream &os, int indent ) const {
-        os << "Tuple:" << std::endl;
+        os << std::string( indent, ' ' ) << "Tuple:" << std::endl;
         printAll( exprs, os, indent+2 );
         Expression::print( os, indent );
@@ -37 +37 @@
 
 TupleIndexExpr::TupleIndexExpr( Expression * tuple, unsigned int index ) {
-        TupleType * type = safe_dynamic_cast< TupleType * >( tuple->get_result() );
-        assert( type->size() >= index );
-        set_result( *std::next( type->get_types().begin(), index ) );
+        // TupleType * type = safe_dynamic_cast< TypeType * >( tuple->get_ )
+        assert( tuple->get_results().size() >= index );
+        add_result( *std::next( tuple->get_results().begin(), index ) );
 }
 
@@ -50 +50 @@
 
 void TupleIndexExpr::print( std::ostream &os, int indent ) const {
-        os << "Tuple Index Expression, with tuple:" << std::endl;
+        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;
@@ -57 +57 @@
 
 MemberTupleExpr::MemberTupleExpr( Expression * member, Expression * aggregate, Expression * _aname ) : Expression( _aname ) {
-        set_result( maybeClone( member->get_result() ) ); // xxx - ???
+        cloneAll( member->get_results(), get_results() ); // xxx - ???
 }
 
@@ -69 +69 @@
 
 void MemberTupleExpr::print( std::ostream &os, int indent ) const {
-        os << "Member Tuple Expression, with aggregate:" << std::endl;
+        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;
@@ -78 +78 @@
 
 TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname ) : Expression( _aname ), assigns( assigns ), tempDecls( tempDecls ) {
-        TupleType * type = new TupleType( Type::Qualifiers() );
         for ( Expression * expr : assigns ) {
-                assert( expr->has_result() );
-                type->get_types().push_back( expr->get_result()->clone() );
+                cloneAll( expr->get_results(), get_results() );
         }
-        set_result( type );
 }
 

src/SynTree/Type.h

@@ -27 +27 @@
                 Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic, bool isAttribute ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ), isAttribute( isAttribute ) {}
 
-                Qualifiers &operator&=( const Qualifiers &other );
                 Qualifiers &operator+=( const Qualifiers &other );
                 Qualifiers &operator-=( const Qualifiers &other );
@@ -66 +65 @@
         std::list<TypeDecl*>& get_forall() { return forall; }
 
-        /// How many elemental types are represented by this type
-        virtual unsigned size() const { return 1; };
-        virtual bool isVoid() const { return size() == 0; }
-
         virtual Type *clone() const = 0;
         virtual void accept( Visitor &v ) = 0;
@@ -82 +77 @@
   public:
         VoidType( const Type::Qualifiers &tq );
-
-        virtual unsigned size() const { return 0; };
 
         virtual VoidType *clone() const { return new VoidType( *this ); }
@@ -364 +357 @@
 
         std::list<Type*>& get_types() { return types; }
-        virtual unsigned size() const { return types.size(); };
 
         iterator begin() { return types.begin(); }
@@ -433 +425 @@
 };
 
-inline Type::Qualifiers &Type::Qualifiers::operator&=( const Type::Qualifiers &other ) {
-        isConst &= other.isConst;
-        isVolatile &= other.isVolatile;
-        isRestrict &= other.isRestrict;
-        isLvalue &= other.isLvalue;
-        isAtomic &= other.isAtomic;
-        return *this;
-}
-
 inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
         isConst |= other.isConst;

src/SynTree/Visitor.cc

@@ -150 +150 @@
 
 void Visitor::visit( ApplicationExpr *applicationExpr ) {
-        maybeAccept( applicationExpr->get_result(), *this );
+        acceptAll( applicationExpr->get_results(), *this );
         maybeAccept( applicationExpr->get_function(), *this );
         acceptAll( applicationExpr->get_args(), *this );
@@ -156 +156 @@
 
 void Visitor::visit( UntypedExpr *untypedExpr ) {
-        maybeAccept( untypedExpr->get_result(), *this );
+        acceptAll( untypedExpr->get_results(), *this );
         acceptAll( untypedExpr->get_args(), *this );
 }
 
 void Visitor::visit( NameExpr *nameExpr ) {
-        maybeAccept( nameExpr->get_result(), *this );
+        acceptAll( nameExpr->get_results(), *this );
 }
 
 void Visitor::visit( AddressExpr *addressExpr ) {
-        maybeAccept( addressExpr->get_result(), *this );
+        acceptAll( addressExpr->get_results(), *this );
         maybeAccept( addressExpr->get_arg(), *this );
 }
 
 void Visitor::visit( LabelAddressExpr *labAddressExpr ) {
-        maybeAccept( labAddressExpr->get_result(), *this );
+        acceptAll( labAddressExpr->get_results(), *this );
         maybeAccept( labAddressExpr->get_arg(), *this );
 }
 
 void Visitor::visit( CastExpr *castExpr ) {
-        maybeAccept( castExpr->get_result(), *this );
+        acceptAll( castExpr->get_results(), *this );
         maybeAccept( castExpr->get_arg(), *this );
 }
 
 void Visitor::visit( UntypedMemberExpr *memberExpr ) {
-        maybeAccept( memberExpr->get_result(), *this );
+        acceptAll( memberExpr->get_results(), *this );
         maybeAccept( memberExpr->get_aggregate(), *this );
         maybeAccept( memberExpr->get_member(), *this );
@@ -186 +186 @@
 
 void Visitor::visit( MemberExpr *memberExpr ) {
-        maybeAccept( memberExpr->get_result(), *this );
+        acceptAll( memberExpr->get_results(), *this );
         maybeAccept( memberExpr->get_aggregate(), *this );
 }
 
 void Visitor::visit( VariableExpr *variableExpr ) {
-        maybeAccept( variableExpr->get_result(), *this );
+        acceptAll( variableExpr->get_results(), *this );
 }
 
 void Visitor::visit( ConstantExpr *constantExpr ) {
-        maybeAccept( constantExpr->get_result(), *this );
+        acceptAll( constantExpr->get_results(), *this );
         maybeAccept( constantExpr->get_constant(), *this );
 }
 
 void Visitor::visit( SizeofExpr *sizeofExpr ) {
-        maybeAccept( sizeofExpr->get_result(), *this );
+        acceptAll( sizeofExpr->get_results(), *this );
         if ( sizeofExpr->get_isType() ) {
                 maybeAccept( sizeofExpr->get_type(), *this );
@@ -209 +209 @@
 
 void Visitor::visit( AlignofExpr *alignofExpr ) {
-        maybeAccept( alignofExpr->get_result(), *this );
+        acceptAll( alignofExpr->get_results(), *this );
         if ( alignofExpr->get_isType() ) {
                 maybeAccept( alignofExpr->get_type(), *this );
@@ -218 +218 @@
 
 void Visitor::visit( UntypedOffsetofExpr *offsetofExpr ) {
-        maybeAccept( offsetofExpr->get_result(), *this );
+        acceptAll( offsetofExpr->get_results(), *this );
         maybeAccept( offsetofExpr->get_type(), *this );
 }
 
 void Visitor::visit( OffsetofExpr *offsetofExpr ) {
-        maybeAccept( offsetofExpr->get_result(), *this );
+        acceptAll( offsetofExpr->get_results(), *this );
         maybeAccept( offsetofExpr->get_type(), *this );
         maybeAccept( offsetofExpr->get_member(), *this );
@@ -229 +229 @@
 
 void Visitor::visit( OffsetPackExpr *offsetPackExpr ) {
-        maybeAccept( offsetPackExpr->get_result(), *this );
+        acceptAll( offsetPackExpr->get_results(), *this );
         maybeAccept( offsetPackExpr->get_type(), *this );
 }
 
 void Visitor::visit( AttrExpr *attrExpr ) {
-        maybeAccept( attrExpr->get_result(), *this );
+        acceptAll( attrExpr->get_results(), *this );
         if ( attrExpr->get_isType() ) {
                 maybeAccept( attrExpr->get_type(), *this );
@@ -243 +243 @@
 
 void Visitor::visit( LogicalExpr *logicalExpr ) {
-        maybeAccept( logicalExpr->get_result(), *this );
+        acceptAll( logicalExpr->get_results(), *this );
         maybeAccept( logicalExpr->get_arg1(), *this );
         maybeAccept( logicalExpr->get_arg2(), *this );
@@ -249 +249 @@
 
 void Visitor::visit( ConditionalExpr *conditionalExpr ) {
-        maybeAccept( conditionalExpr->get_result(), *this );
+        acceptAll( conditionalExpr->get_results(), *this );
         maybeAccept( conditionalExpr->get_arg1(), *this );
         maybeAccept( conditionalExpr->get_arg2(), *this );
@@ -256 +256 @@
 
 void Visitor::visit( CommaExpr *commaExpr ) {
-        maybeAccept( commaExpr->get_result(), *this );
+        acceptAll( commaExpr->get_results(), *this );
         maybeAccept( commaExpr->get_arg1(), *this );
         maybeAccept( commaExpr->get_arg2(), *this );
@@ -262 +262 @@
 
 void Visitor::visit( TypeExpr *typeExpr ) {
-        maybeAccept( typeExpr->get_result(), *this );
+        acceptAll( typeExpr->get_results(), *this );
         maybeAccept( typeExpr->get_type(), *this );
 }
@@ -279 +279 @@
 
 void Visitor::visit( ConstructorExpr * ctorExpr ) {
-        maybeAccept( ctorExpr->get_result(), *this );
+        acceptAll( ctorExpr->get_results(), *this );
         maybeAccept( ctorExpr->get_callExpr(), *this );
 }
 
 void Visitor::visit( CompoundLiteralExpr *compLitExpr ) {
-        maybeAccept( compLitExpr->get_result(), *this );
+        acceptAll( compLitExpr->get_results(), *this );
         maybeAccept( compLitExpr->get_type(), *this );
         maybeAccept( compLitExpr->get_initializer(), *this );
@@ -290 +290 @@
 
 void Visitor::visit( UntypedValofExpr *valofExpr ) {
-        maybeAccept( valofExpr->get_result(), *this );
+        acceptAll( valofExpr->get_results(), *this );
         maybeAccept( valofExpr->get_body(), *this );
 }
@@ -300 +300 @@
 
 void Visitor::visit( TupleExpr *tupleExpr ) {
-        maybeAccept( tupleExpr->get_result(), *this );
+        acceptAll( tupleExpr->get_results(), *this );
         acceptAll( tupleExpr->get_exprs(), *this );
 }
 
 void Visitor::visit( TupleIndexExpr *tupleExpr ) {
-        maybeAccept( tupleExpr->get_result(), *this );
+        acceptAll( tupleExpr->get_results(), *this );
         maybeAccept( tupleExpr->get_tuple(), *this );
 }
 
 void Visitor::visit( MemberTupleExpr *tupleExpr ) {
-        maybeAccept( tupleExpr->get_result(), *this );
+        acceptAll( tupleExpr->get_results(), *this );
         maybeAccept( tupleExpr->get_member(), *this );
         maybeAccept( tupleExpr->get_aggregate(), *this );
@@ -316 +316 @@
 
 void Visitor::visit( TupleAssignExpr *assignExpr ) {
-        maybeAccept( assignExpr->get_result(), *this );
+        acceptAll( assignExpr->get_results(), *this );
         acceptAll( assignExpr->get_tempDecls(), *this );
         acceptAll( assignExpr->get_assigns(), *this );
@@ -322 +322 @@
 
 void Visitor::visit( StmtExpr *stmtExpr ) {
-        maybeAccept( stmtExpr->get_result(), *this );
+        acceptAll( stmtExpr->get_results(), *this );
         maybeAccept( stmtExpr->get_statements(), *this );
 }

src/Tuples/TupleAssignment.cc

@@ -88 +88 @@
         bool isTuple( Expression *expr ) {
                 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;
+                return dynamic_cast<TupleExpr *>(expr) || expr->get_results().size() > 1;
         }
 
@@ -102 +102 @@
 
         bool isTupleExpr( Expression *expr ) {
-                assert( expr->has_result() );
-                return expr->get_result()->size() > 1;
+                return expr->get_results().size() > 1;
         }
 
@@ -192 +191 @@
 
         ObjectDecl * newObject( UniqueName & namer, Expression * expr ) {
-                assert( expr->has_result() && ! expr->get_result()->isVoid() );
-                return new ObjectDecl( namer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
+                Type * type;
+                assert( expr->get_results().size() >= 1 );
+                if ( expr->get_results().size() > 1 ) {
+                        TupleType * tt = new TupleType( Type::Qualifiers() );
+                        cloneAll( expr->get_results(), tt->get_types() );
+                        type = tt;
+                } else {
+                        type = expr->get_results().front()->clone();
+                }
+                return new ObjectDecl( namer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, type, new SingleInit( expr->clone() ) );
         }
 

src/Tuples/TupleExpansion.cc

@@ -85 +85 @@
                         addDeclaration( decl );
                 }
-                Type::Qualifiers qualifiers = newType->get_qualifiers();
                 delete newType;
-                return new StructInstType( qualifiers, typeMap[mangleName] );
+                return new StructInstType( newType->get_qualifiers(), typeMap[mangleName] );
         }