Changes in / [66f8528:596f987b]

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (3 diffs)
• CodeGen/CodeGenerator.h (modified) (2 diffs)
• GenPoly/Box.cc (modified) (34 diffs)
• GenPoly/CopyParams.cc (modified) (2 diffs)
• GenPoly/GenPoly.cc (modified) (5 diffs)
• GenPoly/GenPoly.h (modified) (6 diffs)
• GenPoly/InstantiateGeneric.cc (modified) (2 diffs)
• GenPoly/PolyMutator.cc (modified) (3 diffs)
• GenPoly/PolyMutator.h (modified) (1 diff)
• GenPoly/ScrubTyVars.cc (modified) (3 diffs)
• InitTweak/FixInit.cc (modified) (23 diffs)
• InitTweak/GenInit.cc (modified) (6 diffs)
• ResolvExpr/AdjustExprType.cc (modified) (1 diff)
• ResolvExpr/AlternativeFinder.cc (modified) (14 diffs)
• ResolvExpr/AlternativeFinder.h (modified) (2 diffs)
• ResolvExpr/CommonType.cc (modified) (3 diffs)
• ResolvExpr/FindOpenVars.cc (modified) (2 diffs)
• ResolvExpr/PtrsCastable.cc (modified) (3 diffs)
• ResolvExpr/Resolver.cc (modified) (15 diffs)
• ResolvExpr/Resolver.h (modified) (1 diff)
• ResolvExpr/TypeEnvironment.cc (modified) (5 diffs)
• ResolvExpr/TypeEnvironment.h (modified) (2 diffs)
• ResolvExpr/Unify.cc (modified) (10 diffs)
• ResolvExpr/Unify.h (modified) (2 diffs)
• SymTab/Autogen.cc (modified) (19 diffs)
• SymTab/Indexer.cc (modified) (2 diffs)
• SymTab/Indexer.h (modified) (1 diff)
• SymTab/Validate.cc (modified) (15 diffs)
• SynTree/ApplicationExpr.cc (modified) (1 diff)
• SynTree/CompoundStmt.cc (modified) (1 diff)
• SynTree/Declaration.h (modified) (4 diffs)
• SynTree/Expression.cc (modified) (7 diffs)
• SynTree/Expression.h (modified) (5 diffs)
• SynTree/Initializer.cc (modified) (1 diff)
• SynTree/Initializer.h (modified) (1 diff)
• SynTree/Mutator.cc (modified) (4 diffs)
• SynTree/ReferenceToType.cc (modified) (4 diffs)
• SynTree/TupleExpr.cc (modified) (1 diff)
• SynTree/Type.h (modified) (3 diffs)
• SynTree/TypeDecl.cc (modified) (3 diffs)
• SynTree/VarExprReplacer.cc (modified) (1 diff)
• SynTree/Visitor.cc (modified) (4 diffs)
• Tuples/Explode.cc (modified) (2 diffs)
• Tuples/TupleAssignment.cc (modified) (6 diffs)
• Tuples/TupleExpansion.cc (modified) (7 diffs)
• main.cc (modified) (2 diffs)
• prelude/prelude.cf (modified) (1 diff)
• tests/.expect/32/declarationSpecifier.txt (modified) (25 diffs)
• tests/.expect/32/extension.txt (modified) (4 diffs)
• tests/.expect/32/gccExtensions.txt (modified) (11 diffs)
• tests/.expect/64/declarationSpecifier.txt (modified) (25 diffs)
• tests/.expect/64/extension.txt (modified) (4 diffs)
• tests/.expect/64/gccExtensions.txt (modified) (11 diffs)
• tests/.expect/castError.txt (modified) (1 diff)
• tests/.expect/completeTypeError.txt (deleted)
• tests/.expect/memberCtors.txt (modified) (3 diffs)
• tests/.expect/scopeErrors.txt (modified) (1 diff)
• tests/.expect/simpleGenericTriple.txt (deleted)
• tests/.expect/tupleCast.txt (deleted)
• tests/.expect/tuplePolymorphism.txt (deleted)
• tests/Makefile.am (modified) (1 diff)
• tests/Makefile.in (modified) (1 diff)
• tests/completeTypeError.c (deleted)
• tests/memberCtors.c (modified) (2 diffs)
• tests/shortCircuit.c (modified) (2 diffs)
• tests/simpleGenericTriple.c (deleted)
• tests/tupleAssign.c (modified) (2 diffs)
• tests/tupleCast.c (deleted)
• tests/tupleFunction.c (modified) (3 diffs)
• tests/tupleMember.c (modified) (2 diffs)
• tests/tuplePolymorphism.c (deleted)

src/CodeGen/CodeGenerator.cc

@@ -179 +179 @@
                         output << aggDecl->get_name();
 
-                // std::list< Declaration * > & memb = aggDecl->get_members();
-                // if ( ! memb.empty() ) {
-                if ( aggDecl->has_body() ) {
-                        std::list< Declaration * > & memb = aggDecl->get_members();
+                std::list< Declaration * > & memb = aggDecl->get_members();
+                if ( ! memb.empty() ) {
+//              if ( aggDecl->has_body() ) {
+//                      std::list< Declaration * > & memb = aggDecl->get_members();
                         output << " {" << endl;
 
@@ -291 +291 @@
                 } // if
                 output << " }";
-        }
-
-        void CodeGenerator::visit( ConstructorInit * init ){
-                assertf( false, "ConstructorInit nodes should not make it to CodeGen." );
         }
 
@@ -921 +917 @@
                 } // switch
         }
-
-        std::string genName( DeclarationWithType * decl ) {
-                CodeGen::OperatorInfo opInfo;
-                if ( operatorLookup( decl->get_name(), opInfo ) ) {
-                        return opInfo.outputName;
-                } else {
-                        return decl->get_name();
-                } // if
-        }
 } // namespace CodeGen
 

src/CodeGen/CodeGenerator.h

@@ -47 +47 @@
                 virtual void visit( SingleInit * );
                 virtual void visit( ListInit * );
-                virtual void visit( ConstructorInit * );
 
                 //*** Constant
@@ -145 +144 @@
                 return true;
         }
-
-        /// returns C-compatible name of declaration
-        std::string genName( DeclarationWithType * decl );
 } // namespace CodeGen
 

src/GenPoly/Box.cc

@@ -55 +55 @@
 #include "Common/utility.h"
 
-#include "InitTweak/InitTweak.h"
-
 #include <ext/functional> // temporary
 
@@ -100 +98 @@
                         void passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes );
                         /// passes extra type parameters into a polymorphic function application
-                        void passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
+                        void passTypeVars( ApplicationExpr *appExpr, ReferenceToType *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         /// wraps a function application with a new temporary for the out-parameter return value
                         Expression *addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg );
@@ -109 +107 @@
                         Type *replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone = true );
                         /// wraps a function application returning a polymorphic type with a new temporary for the out-parameter return value
-                        Expression *addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *polyType, std::list< Expression *>::iterator &arg );
+                        Expression *addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, ReferenceToType *polyType, std::list< Expression *>::iterator &arg );
                         Expression *applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         void boxParam( Type *formal, Expression *&arg, const TyVarMap &exprTyVars );
@@ -115 +113 @@
                         void addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars );
                         /// Stores assignment operators from assertion list in local map of assignment operations
+                        void findTypeOps( const Type::ForallList &forall );
                         void passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars );
                         FunctionDecl *makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars );
@@ -122 +121 @@
                         ObjectDecl *makeTemporary( Type *type );
 
+                        ScopedMap< std::string, DeclarationWithType* > assignOps;    ///< Currently known type variable assignment operators
+                        ScopedMap< std::string, DeclarationWithType* > ctorOps;      ///< Currently known type variable constructors
+                        ScopedMap< std::string, DeclarationWithType* > copyOps;      ///< Currently known type variable copy constructors
+                        ScopedMap< std::string, DeclarationWithType* > dtorOps;      ///< Currently known type variable destructors
+                        ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps;  ///< Currently known assignment operators
+                        ResolvExpr::TypeMap< DeclarationWithType > scopedCtorOps;    ///< Currently known assignment operators
+                        ResolvExpr::TypeMap< DeclarationWithType > scopedCopyOps;    ///< Currently known assignment operators
+                        ResolvExpr::TypeMap< DeclarationWithType > scopedDtorOps;    ///< Currently known assignment operators
                         ScopedMap< std::string, DeclarationWithType* > adapters;     ///< Set of adapter functions in the current scope
 
-                        std::map< ApplicationExpr *, Expression * > retVals;
-
                         DeclarationWithType *retval;
+                        bool useRetval;
                         UniqueName tempNamer;
                 };
@@ -269 +275 @@
 
                 for ( std::list< TypeDecl* >::const_iterator decl = decls.begin(); decl != decls.end(); ++decl ) {
-                        if ( (*decl)->isComplete() ) {
+                        if ( (*decl)->get_kind() == TypeDecl::Any ) {
                                 otypeDecls.push_back( *decl );
                         }
@@ -491 +497 @@
                 }
 
-                Pass1::Pass1() : tempNamer( "_temp" ) {}
+                Pass1::Pass1() : useRetval( false ), tempNamer( "_temp" ) {}
+
+                /// Returns T if the given declaration is a function with parameter (T*) for some TypeInstType T, NULL otherwise
+                TypeInstType *isTypeInstPtrFn( DeclarationWithType *decl ) {
+                        if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) {
+                                if ( funType->get_parameters().size() == 1 ) {
+                                        if ( PointerType *pointer = dynamic_cast< PointerType *>( funType->get_parameters().front()->get_type() ) ) {
+                                                if ( TypeInstType *refType = dynamic_cast< TypeInstType *>( pointer->get_base() ) ) {
+                                                        return refType;
+                                                } // if
+                                        } // if
+                                } // if
+                        } // if
+                        return 0;
+                }
+
+                /// Returns T if the given declaration is a function with parameters (T*, T) for some TypeInstType T, NULL otherwise
+                TypeInstType *isTypeInstPtrValFn( DeclarationWithType *decl ) {
+                        if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) {
+                                if ( funType->get_parameters().size() == 2 ) {
+                                        if ( PointerType *pointer = dynamic_cast< PointerType *>( funType->get_parameters().front()->get_type() ) ) {
+                                                if ( TypeInstType *refType = dynamic_cast< TypeInstType *>( pointer->get_base() ) ) {
+                                                        if ( TypeInstType *refType2 = dynamic_cast< TypeInstType *>( funType->get_parameters().back()->get_type() ) ) {
+                                                                if ( refType->get_name() == refType2->get_name() ) {
+                                                                        return refType;
+                                                                } // if
+                                                        } // if
+                                                } // if
+                                        } // if
+                                } // if
+                        } // if
+                        return 0;
+                }
+
+                /// Returns T if the given declaration is (*?=?)(T *, T) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise
+                TypeInstType *isTypeInstAssignment( DeclarationWithType *decl ) {
+                        return decl->get_name() == "?=?" ? isTypeInstPtrValFn( decl ) : 0;
+                }
+
+                /// Returns T if the given declaration is (*?{})(T *) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise
+                TypeInstType *isTypeInstCtor( DeclarationWithType *decl ) {
+                        return decl->get_name() == "?{}" ? isTypeInstPtrFn( decl ) : 0;
+                }
+
+                /// Returns T if the given declaration is (*?{})(T *, T) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise
+                TypeInstType *isTypeInstCopy( DeclarationWithType *decl ) {
+                        return decl->get_name() == "?{}" ? isTypeInstPtrValFn( decl ) : 0;
+                }
+
+                /// Returns T if the given declaration is (*^?{})(T *) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise
+                TypeInstType *isTypeInstDtor( DeclarationWithType *decl ) {
+                        return decl->get_name() == "^?{}" ? isTypeInstPtrFn( decl ) : 0;
+                }
+
+                /// Returns T if the given declaration is a function with parameters (T*, T) for some type T, where neither parameter is cv-qualified,
+                /// NULL otherwise
+                Type *isNoCvPtrFn( DeclarationWithType *decl ) {
+                        if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) {
+                                if ( funType->get_parameters().size() == 1 ) {
+                                        Type::Qualifiers defaultQualifiers;
+                                        Type *paramType = funType->get_parameters().front()->get_type();
+                                        if ( paramType->get_qualifiers() != defaultQualifiers ) return 0;
+
+                                        if ( PointerType *pointerType = dynamic_cast< PointerType* >( paramType ) ) {
+                                                Type *baseType = pointerType->get_base();
+                                                if ( baseType->get_qualifiers() == defaultQualifiers ) {
+                                                        return baseType;
+                                                } // if
+                                        } // if
+                                } // if
+                        } // if
+                        return 0;
+                }
+
+                /// Returns T if the given declaration is a function with parameters (T*, T) for some type T, where neither parameter is cv-qualified,
+                /// NULL otherwise
+                Type *isNoCvPtrValFn( DeclarationWithType *decl ) {
+                        if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) {
+                                if ( funType->get_parameters().size() == 2 ) {
+                                        Type::Qualifiers defaultQualifiers;
+                                        Type *paramType1 = funType->get_parameters().front()->get_type();
+                                        if ( paramType1->get_qualifiers() != defaultQualifiers ) return 0;
+                                        Type *paramType2 = funType->get_parameters().back()->get_type();
+                                        if ( paramType2->get_qualifiers() != defaultQualifiers ) return 0;
+
+                                        if ( PointerType *pointerType = dynamic_cast< PointerType* >( paramType1 ) ) {
+                                                Type *baseType1 = pointerType->get_base();
+                                                if ( baseType1->get_qualifiers() != defaultQualifiers ) return 0;
+                                                SymTab::Indexer dummy;
+                                                if ( ResolvExpr::typesCompatible( baseType1, paramType2, dummy ) ) {
+                                                        return baseType1;
+                                                } // if
+                                        } // if
+                                } // if
+                        } // if
+                        return 0;
+                }
+
+                /// returns T if the given declaration is: (*?=?)(T *, T) for some type T (return not checked, but maybe should be), NULL otherwise
+                /// Only picks assignments where neither parameter is cv-qualified
+                Type *isAssignment( DeclarationWithType *decl ) {
+                        return decl->get_name() == "?=?" ? isNoCvPtrValFn( decl ) : 0;
+                }
+
+                /// returns T if the given declaration is: (*?{})(T *) for some type T, NULL otherwise
+                /// Only picks ctors where the parameter is not cv-qualified
+                Type *isCtor( DeclarationWithType *decl ) {
+                        return decl->get_name() == "?{}" ? isNoCvPtrFn( decl ) : 0;
+                }
+
+                /// returns T if the given declaration is: (*?{})(T *, T) for some type T (return not checked, but maybe should be), NULL otherwise
+                /// Only picks copy constructors where neither parameter is cv-qualified
+                Type *isCopy( DeclarationWithType *decl ) {
+                        return decl->get_name() == "?{}" ? isNoCvPtrValFn( decl ) : 0;
+                }
+
+                /// returns T if the given declaration is: (*?{})(T *) for some type T, NULL otherwise
+                /// Only picks ctors where the parameter is not cv-qualified
+                Type *isDtor( DeclarationWithType *decl ) {
+                        return decl->get_name() == "^?{}" ? isNoCvPtrFn( decl ) : 0;
+                }
+
+                void Pass1::findTypeOps( const Type::ForallList &forall ) {
+                        // what if a nested function uses an assignment operator?
+                        // assignOps.clear();
+                        for ( Type::ForallList::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
+                                for ( std::list< DeclarationWithType *>::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
+                                        std::string typeName;
+                                        if ( TypeInstType *typeInst = isTypeInstAssignment( *assert ) ) {
+                                                assignOps[ typeInst->get_name() ] = *assert;
+                                        } else if ( TypeInstType *typeInst = isTypeInstCtor( *assert ) ) {
+                                                ctorOps[ typeInst->get_name() ] = *assert;
+                                        } else if ( TypeInstType *typeInst = isTypeInstCopy( *assert ) ) {
+                                                copyOps[ typeInst->get_name() ] = *assert;
+                                        } else if ( TypeInstType *typeInst = isTypeInstDtor( *assert ) ) {
+                                                dtorOps[ typeInst->get_name() ] = *assert;
+                                        } // if
+                                } // for
+                        } // for
+                }
 
                 DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
+                        // if this is a assignment function, put it in the map for this scope
+                        if ( Type *paramType = isAssignment( functionDecl ) ) {
+                                if ( ! dynamic_cast< TypeInstType* >( paramType ) ) {
+                                        scopedAssignOps.insert( paramType, functionDecl );
+                                }
+                        } else if ( Type *paramType = isCtor( functionDecl ) ) {
+                                if ( ! dynamic_cast< TypeInstType* >( paramType ) ) {
+                                        scopedCtorOps.insert( paramType, functionDecl );
+                                }
+                        } else if ( Type *paramType = isCopy( functionDecl ) ) {
+                                if ( ! dynamic_cast< TypeInstType* >( paramType ) ) {
+                                        scopedCopyOps.insert( paramType, functionDecl );
+                                }
+                        } else if ( Type *paramType = isDtor( functionDecl ) ) {
+                                if ( ! dynamic_cast< TypeInstType* >( paramType ) ) {
+                                        scopedDtorOps.insert( paramType, functionDecl );
+                                }
+                        }
+
                         if ( functionDecl->get_statements() ) {         // empty routine body ?
                                 doBeginScope();
                                 scopeTyVars.beginScope();
+                                assignOps.beginScope();
+                                ctorOps.beginScope();
+                                copyOps.beginScope();
+                                dtorOps.beginScope();
 
                                 DeclarationWithType *oldRetval = retval;
+                                bool oldUseRetval = useRetval;
 
                                 // process polymorphic return value
-                                retval = nullptr;
-                                if ( isDynRet( functionDecl->get_functionType() ) && functionDecl->get_linkage() != LinkageSpec::C ) {
+                                retval = 0;
+                                if ( isDynRet( functionDecl->get_functionType() ) && functionDecl->get_linkage() == LinkageSpec::Cforall ) {
                                         retval = functionDecl->get_functionType()->get_returnVals().front();
 
@@ -514 +683 @@
                                 FunctionType *functionType = functionDecl->get_functionType();
                                 makeTyVarMap( functionDecl->get_functionType(), scopeTyVars );
+                                findTypeOps( functionDecl->get_functionType()->get_forall() );
 
                                 std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
@@ -530 +700 @@
                                         if ( adapters.find( mangleName ) == adapters.end() ) {
                                                 std::string adapterName = makeAdapterName( mangleName );
-                                                adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), nullptr ) ) );
+                                                adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) ) );
                                         } // if
                                 } // for
@@ -537 +707 @@
 
                                 scopeTyVars.endScope();
+                                assignOps.endScope();
+                                ctorOps.endScope();
+                                copyOps.endScope();
+                                dtorOps.endScope();
                                 retval = oldRetval;
+                                useRetval = oldUseRetval;
                                 doEndScope();
                         } // if
@@ -544 +719 @@
 
                 TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) {
-                        addToTyVarMap( typeDecl, scopeTyVars );
+                        scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
                         return Mutator::mutate( typeDecl );
                 }
 
                 Expression *Pass1::mutate( CommaExpr *commaExpr ) {
-                        // Attempting to find application expressions that were mutated by the copy constructor passes
-                        // to use an explicit return variable, so that the variable can be reused as a parameter to the
-                        // call rather than creating a new temp variable. Previously this step was an optimization, but
-                        // with the introduction of tuples and UniqueExprs, it is necessary to ensure that they use the same variable.
-                        // Essentially, looking for pattern: (x=f(...), x)
-                        // To compound the issue, the right side can be *x, etc. because of lvalue-returning functions
-                        if ( UntypedExpr * assign = dynamic_cast< UntypedExpr * >( commaExpr->get_arg1() ) ) {
-                                if ( InitTweak::isAssignment( InitTweak::getFunctionName( assign ) ) ) {
-                                        assert( assign->get_args().size() == 2 );
-                                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( assign->get_args().back() ) ) {
-                                                // first argument is assignable, so it must be an lvalue, so it should be legal to take its address.
-                                                retVals[appExpr] = assign->get_args().front();
-                                        }
-                                }
-                        }
-
+                        bool oldUseRetval = useRetval;
+                        useRetval = false;
                         commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
+                        useRetval = oldUseRetval;
                         commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
                         return commaExpr;
@@ -571 +733 @@
 
                 Expression *Pass1::mutate( ConditionalExpr *condExpr ) {
+                        bool oldUseRetval = useRetval;
+                        useRetval = false;
                         condExpr->set_arg1( maybeMutate( condExpr->get_arg1(), *this ) );
+                        useRetval = oldUseRetval;
                         condExpr->set_arg2( maybeMutate( condExpr->get_arg2(), *this ) );
                         condExpr->set_arg3( maybeMutate( condExpr->get_arg3(), *this ) );
@@ -604 +769 @@
                 }
 
-                void Pass1::passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
+                void Pass1::passTypeVars( ApplicationExpr *appExpr, ReferenceToType *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
                         // pass size/align for type variables
                         for ( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) {
                                 ResolvExpr::EqvClass eqvClass;
                                 assert( env );
-                                if ( tyParm->second.isComplete ) {
+                                if ( tyParm->second == TypeDecl::Any ) {
                                         Type *concrete = env->lookup( tyParm->first );
                                         if ( concrete ) {
@@ -618 +783 @@
                                         } else {
                                                 // xxx - should this be an assertion?
-                                                std::string x = env ? toString( *env ) : "missing env";
-                                                throw SemanticError( x + "\n" + "unbound type variable: " + tyParm->first + " in application ", appExpr );
+                                                throw SemanticError( "unbound type variable: " + tyParm->first + " in application ", appExpr );
                                         } // if
                                 } // if
@@ -637 +801 @@
                                 Type *concRetType = replaceWithConcrete( appExpr, polyRetType );
                                 passArgTypeVars( appExpr, polyRetType, concRetType, arg, exprTyVars, seenTypes );
-                                ++fnArg; // skip the return parameter in the argument list
                         }
 
                         // add type information args for presently unseen types in parameter list
                         for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
-                                if ( ! (*fnArg)->get_result() ) continue;
-                                Type * argType = (*fnArg)->get_result();
-                                passArgTypeVars( appExpr, (*fnParm)->get_type(), argType, arg, exprTyVars, seenTypes );
+                                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 );
                         }
                 }
@@ -655 +818 @@
 
                 Expression *Pass1::addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg ) {
+                        // ***** Code Removal ***** After introducing a temporary variable for all return expressions, the following code appears superfluous.
+                        // if ( useRetval ) {
+                        //      assert( retval );
+                        //      arg = appExpr->get_args().insert( arg, new VariableExpr( retval ) );
+                        //      arg++;
+                        // } else {
+
                         // Create temporary to hold return value of polymorphic function and produce that temporary as a result
-                        // using a comma expression.
-                        assert( retType );
-
-                        Expression * paramExpr = nullptr;
-                        // try to use existing return value parameter if it exists, otherwise create a new temporary
-                        if ( retVals.count( appExpr ) ) {
-                                paramExpr = retVals[appExpr]->clone();
-                        } else {
-                                ObjectDecl *newObj = makeTemporary( retType->clone() );
-                                paramExpr = new VariableExpr( newObj );
-                        }
-                        Expression * retExpr = paramExpr->clone();
+                        // using a comma expression.  Possibly change comma expression into statement expression "{}" for multiple
+                        // return values.
+                        ObjectDecl *newObj = makeTemporary( retType->clone() );
+                        Expression *paramExpr = new VariableExpr( newObj );
 
                         // If the type of the temporary is not polymorphic, box temporary by taking its address;
                         // otherwise the temporary is already boxed and can be used directly.
-                        if ( ! isPolyType( paramExpr->get_result(), scopeTyVars, env ) ) {
+                        if ( ! isPolyType( newObj->get_type(), scopeTyVars, env ) ) {
                                 paramExpr = new AddressExpr( paramExpr );
                         } // if
@@ -677 +839 @@
                         arg++;
                         // Build a comma expression to call the function and emulate a normal return.
-                        CommaExpr *commaExpr = new CommaExpr( appExpr, retExpr );
+                        CommaExpr *commaExpr = new CommaExpr( appExpr, new VariableExpr( newObj ) );
                         commaExpr->set_env( appExpr->get_env() );
                         appExpr->set_env( 0 );
                         return commaExpr;
+                        // } // if
+                        // return appExpr;
                 }
 
@@ -695 +859 @@
                                 Type *concrete = env->lookup( typeInst->get_name() );
                                 if ( concrete == 0 ) {
-                                        // xxx - should this be an assertion?
-                                        std::string x = env ? toString( *env ) : "missing env";
-                                        throw SemanticError( x + "\n" + "Unbound type variable " + typeInst->get_name() + " in ", appExpr );
+                                        throw SemanticError( "Unbound type variable " + typeInst->get_name() + " in ", appExpr );
                                 } // if
                                 return concrete;
@@ -716 +878 @@
                 }
 
-                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *dynType, std::list< Expression *>::iterator &arg ) {
+                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, ReferenceToType *dynType, std::list< Expression *>::iterator &arg ) {
                         assert( env );
                         Type *concrete = replaceWithConcrete( appExpr, dynType );
@@ -794 +956 @@
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
                                         InferredParams::const_iterator inferParam = appExpr->get_inferParams().find( (*assert)->get_uniqueId() );
-                                        if ( inferParam == appExpr->get_inferParams().end() ) {
-                                                std::cerr << "looking for assertion: " << (*assert) << std::endl << appExpr << std::endl;
-                                        }
-                                        assertf( inferParam != appExpr->get_inferParams().end(), "NOTE: Explicit casts of polymorphic functions to compatible monomorphic functions are currently unsupported" );
+                                        assert( inferParam != appExpr->get_inferParams().end() && "NOTE: Explicit casts of polymorphic functions to compatible monomorphic functions are currently unsupported" );
                                         Expression *newExpr = inferParam->second.expr->clone();
                                         addCast( newExpr, (*assert)->get_type(), tyVars );
@@ -1108 +1267 @@
                         // }
                         // std::cerr << "\n";
+                        bool oldUseRetval = useRetval;
+                        useRetval = false;
                         appExpr->get_function()->acceptMutator( *this );
                         mutateAll( appExpr->get_args(), *this );
+                        useRetval = oldUseRetval;
 
                         assert( appExpr->get_function()->has_result() );
@@ -1124 +1286 @@
                         std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
 
-                        TyVarMap exprTyVars( TypeDecl::Data{} );
-                        makeTyVarMap( function, exprTyVars ); // xxx - should this take into account the variables already bound in scopeTyVars (i.e. remove them from exprTyVars?)
+                        TyVarMap exprTyVars( (TypeDecl::Kind)-1 );
+                        makeTyVarMap( function, exprTyVars );
                         ReferenceToType *dynRetType = isDynRet( function, exprTyVars );
-                        Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();// ?: dynRetType; // xxx - is concRetType a good name?
 
                         if ( dynRetType ) {
-                                ret = addDynRetParam( appExpr, function, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType
-                        } else if ( needsAdapter( function, scopeTyVars ) && ! needsAdapter( function, exprTyVars) ) { // xxx - exprTyVars is used above...?
-                                // xxx - the ! needsAdapter check may be incorrect. It seems there is some situation where an adapter is applied where it shouldn't be, and this fixes it for some cases. More investigation is needed.
-
+                                ret = addDynRetParam( appExpr, function, dynRetType, arg );
+                        } else if ( needsAdapter( function, scopeTyVars ) ) {
                                 // std::cerr << "needs adapter: ";
                                 // printTyVarMap( std::cerr, scopeTyVars );
@@ -1142 +1301 @@
                         arg = appExpr->get_args().begin();
 
-                        passTypeVars( appExpr, concRetType, arg, exprTyVars ); // xxx - used to use dynRetType instead of concRetType; this changed so that the correct type paramaters are passed for return types (it should be the concrete type's parameters, not the formal type's)
+                        passTypeVars( appExpr, dynRetType, arg, exprTyVars );
                         addInferredParams( appExpr, function, arg, exprTyVars );
 
@@ -1201 +1360 @@
                 }
 
+                /// Wraps a function declaration in a new pointer-to-function variable expression
+                VariableExpr *wrapFunctionDecl( DeclarationWithType *functionDecl ) {
+                        // line below cloned from FixFunction.cc
+                        // xxx - functionObj is never added to a list of declarations...
+                        ObjectDecl *functionObj = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0,
+                                                                  new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0 );
+                        functionObj->set_mangleName( functionDecl->get_mangleName() );
+                        functionObj->set_scopeLevel( functionDecl->get_scopeLevel() );
+                        return new VariableExpr( functionObj );
+                }
+
+                /// Finds the operation declaration for a given type in one of the two maps
+                DeclarationWithType* findOpForType( Type *formalType, const ScopedMap< std::string, DeclarationWithType* >& ops, ResolvExpr::TypeMap< DeclarationWithType >& scopedOps ) {
+                        if ( TypeInstType *formalTypeInstType = dynamic_cast< TypeInstType* >( formalType ) ) {
+                                ScopedMap< std::string, DeclarationWithType *>::const_iterator opIt = ops.find( formalTypeInstType->get_name() );
+                                return opIt == ops.end() ? 0 : opIt->second;
+                        } else {
+                                return scopedOps.find( formalType );
+                        }
+                }
+
+                /// Adds an assertion parameter to the application expression for the actual assertion declaration valued with the assert op
+                void addAssertionFor( ApplicationExpr *appExpr, DeclarationWithType *actualDecl, DeclarationWithType *assertOp ) {
+                        appExpr->get_inferParams()[ actualDecl->get_uniqueId() ]
+                                        = ParamEntry( assertOp->get_uniqueId(), assertOp->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertOp ) );
+                }
+
                 Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
-                        // maybe need access to the env when mutating the expr
-                        if ( Expression * expr = returnStmt->get_expr() ) {
-                                if ( expr->get_env() ) {
-                                        env = expr->get_env();
-                                }
-                        }
-
                         if ( retval && returnStmt->get_expr() ) {
                                 assert( returnStmt->get_expr()->has_result() && ! returnStmt->get_expr()->get_result()->isVoid() );
-                                delete returnStmt->get_expr();
+                                // ***** 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() ) {
+                                // by this point, a cast expr on a polymorphic return value is redundant
+                                while ( CastExpr *castExpr = dynamic_cast< CastExpr *>( returnStmt->get_expr() ) ) {
+                                        returnStmt->set_expr( castExpr->get_arg() );
+                                        returnStmt->get_expr()->set_env( castExpr->get_env() );
+                                        castExpr->set_env( 0 );
+                                        castExpr->set_arg( 0 );
+                                        delete castExpr;
+                                } //while
+
+                                // find assignment operator for (polymorphic) return type
+                                ApplicationExpr *assignExpr = 0;
+                                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( retval->get_type() ) ) {
+                                        // find assignment operator for type variable
+                                        ScopedMap< std::string, DeclarationWithType *>::const_iterator assignIter = assignOps.find( typeInst->get_name() );
+                                        if ( assignIter == assignOps.end() ) {
+                                                throw SemanticError( "Attempt to return dtype or ftype object in ", returnStmt->get_expr() );
+                                        } // if
+                                        assignExpr = new ApplicationExpr( new VariableExpr( assignIter->second ) );
+                                } else if ( ReferenceToType *refType = dynamic_cast< ReferenceToType *>( retval->get_type() ) ) {
+                                        // find assignment operator for generic type
+                                        DeclarationWithType *functionDecl = scopedAssignOps.find( refType );
+                                        if ( ! functionDecl ) {
+                                                throw SemanticError( "Attempt to return dtype or ftype generic object in ", returnStmt->get_expr() );
+                                        }
+
+                                        // wrap it up in an application expression
+                                        assignExpr = new ApplicationExpr( wrapFunctionDecl( functionDecl ) );
+                                        assignExpr->set_env( env->clone() );
+
+                                        // find each of its needed secondary assignment operators
+                                        std::list< Expression* > &tyParams = refType->get_parameters();
+                                        Type::ForallList &forallParams = functionDecl->get_type()->get_forall();
+                                        std::list< Expression* >::const_iterator tyIt = tyParams.begin();
+                                        Type::ForallList::const_iterator forallIt = forallParams.begin();
+                                        for ( ; tyIt != tyParams.end() && forallIt != forallParams.end(); ++tyIt, ++forallIt ) {
+                                                // Add appropriate mapping to assignment expression environment
+                                                TypeExpr *formalTypeExpr = dynamic_cast< TypeExpr* >( *tyIt );
+                                                assert( formalTypeExpr && "type parameters must be type expressions" );
+                                                Type *formalType = formalTypeExpr->get_type();
+                                                assignExpr->get_env()->add( (*forallIt)->get_name(), formalType );
+
+                                                // skip non-otype parameters (ftype/dtype)
+                                                if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue;
+
+                                                // find otype operators for formal type
+                                                DeclarationWithType *assertAssign = findOpForType( formalType, assignOps, scopedAssignOps );
+                                                if ( ! assertAssign ) throw SemanticError( "No assignment operation found for ", formalType );
+
+                                                DeclarationWithType *assertCtor = findOpForType( formalType, ctorOps, scopedCtorOps );
+                                                if ( ! assertCtor ) throw SemanticError( "No default constructor found for ", formalType );
+
+                                                DeclarationWithType *assertCopy = findOpForType( formalType, copyOps, scopedCopyOps );
+                                                if ( ! assertCopy ) throw SemanticError( "No copy constructor found for ", formalType );
+
+                                                DeclarationWithType *assertDtor = findOpForType( formalType, dtorOps, scopedDtorOps );
+                                                if ( ! assertDtor ) throw SemanticError( "No destructor found for ", formalType );
+
+                                                // add inferred parameters for otype operators to assignment expression
+                                                // NOTE: Code here assumes that first four assertions are assign op, ctor, copy ctor, dtor, in that order
+                                                std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions();
+                                                assert( asserts.size() >= 4 && "Type param needs otype operator assertions" );
+
+                                                std::list< DeclarationWithType* >::iterator actualIt = asserts.begin();
+                                                addAssertionFor( assignExpr, *actualIt, assertAssign );
+                                                ++actualIt;
+                                                addAssertionFor( assignExpr, *actualIt, assertCtor );
+                                                ++actualIt;
+                                                addAssertionFor( assignExpr, *actualIt, assertCopy );
+                                                ++actualIt;
+                                                addAssertionFor( assignExpr, *actualIt, assertDtor );
+
+                                        }
+                                }
+                                assert( assignExpr );
+
+                                // 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() ) );
+                                assignExpr->get_args().push_back( retParm );
+                                assignExpr->get_args().push_back( returnStmt->get_expr() );
+                                stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( assignExpr ) ) );
+                                // } else {
+                                //      useRetval = true;
+                                //      stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( returnStmt->get_expr() ) ) );
+                                //      useRetval = false;
+                                // } // if
                                 returnStmt->set_expr( 0 );
                         } else {
@@ -1241 +1507 @@
                 void Pass1::doBeginScope() {
                         adapters.beginScope();
+                        scopedAssignOps.beginScope();
+                        scopedCtorOps.beginScope();
+                        scopedCopyOps.beginScope();
+                        scopedDtorOps.beginScope();
                 }
 
                 void Pass1::doEndScope() {
                         adapters.endScope();
+                        scopedAssignOps.endScope();
+                        scopedCtorOps.endScope();
+                        scopedCopyOps.endScope();
+                        scopedDtorOps.endScope();
                 }
 
@@ -1276 +1550 @@
                 }
 
-                /// determines if `pref` is a prefix of `str`
-                bool isPrefix( const std::string & str, const std::string & pref ) {
-                        if ( pref.size() > str.size() ) return false;
-                        auto its = std::mismatch( pref.begin(), pref.end(), str.begin() );
-                        return its.first == pref.end();
-                }
-
                 DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) {
-                        functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl, functionDecl->get_functionType() ) );
-                        FunctionType * ftype = functionDecl->get_functionType();
-                        if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
-                                if ( functionDecl->get_name() != "?=?" && ! isPrefix( functionDecl->get_name(), "_thunk" ) ) { // xxx - remove check for ?=? once reference types are in; remove check for prefix once thunks properly use ctor/dtors
-                                        assert( ftype->get_returnVals().size() == 1 );
-                                        DeclarationWithType * retval = ftype->get_returnVals().front();
-                                        if ( retval->get_name() == "" ) {
-                                                retval->set_name( "_retval" );
-                                        }
-                                        functionDecl->get_statements()->get_kids().push_front( new DeclStmt( noLabels, retval ) );
-                                        DeclarationWithType * newRet = retval->clone(); // for ownership purposes
-                                        ftype->get_returnVals().front() = newRet;
-                                }
-                        }
-                        return functionDecl;
+                        return handleDecl( functionDecl, functionDecl->get_functionType() );
                 }
 
@@ -1306 +1559 @@
 
                 TypeDecl * Pass2::mutate( TypeDecl *typeDecl ) {
-                        addToTyVarMap( typeDecl, scopeTyVars );
+                        scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
                         if ( typeDecl->get_base() ) {
                                 return handleDecl( typeDecl, typeDecl->get_base() );
@@ -1334 +1587 @@
                         // move polymorphic return type to parameter list
                         if ( isDynRet( funcType ) ) {
-                                ObjectDecl *ret = safe_dynamic_cast< ObjectDecl* >( funcType->get_returnVals().front() );
+                                DeclarationWithType *ret = funcType->get_returnVals().front();
                                 ret->set_type( new PointerType( Type::Qualifiers(), ret->get_type() ) );
                                 funcType->get_parameters().push_front( ret );
                                 funcType->get_returnVals().pop_front();
-                                ret->set_init( nullptr ); // xxx - memory leak?
                         }
 
@@ -1350 +1602 @@
                                 ObjectDecl *sizeParm, *alignParm;
                                 // add all size and alignment parameters to parameter list
-                                if ( (*tyParm)->isComplete() ) {
+                                if ( (*tyParm)->get_kind() == TypeDecl::Any ) {
                                         TypeInstType parmType( Type::Qualifiers(), (*tyParm)->get_name(), *tyParm );
                                         std::string parmName = mangleType( &parmType );
@@ -1459 +1711 @@
 
                 TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) {
-                        addToTyVarMap( typeDecl, scopeTyVars );
+                        scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
                         return Parent::mutate( typeDecl );
                 }
@@ -1573 +1825 @@
                                 // replace member expression with pointer to base plus offset
                                 UntypedExpr *fieldLoc = new UntypedExpr( new NameExpr( "?+?" ) );
-                                Expression * aggr = memberExpr->get_aggregate()->clone();
-                                delete aggr->get_env(); // xxx - there's a problem with keeping the env for some reason, so for now just get rid of it
-                                aggr->set_env( nullptr );
-                                fieldLoc->get_args().push_back( aggr );
+                                fieldLoc->get_args().push_back( makeDerefdVar( varExpr->clone(), varDepth ) );
                                 fieldLoc->get_args().push_back( makeOffsetIndex( objectType, i ) );
                                 newMemberExpr = fieldLoc;
@@ -1626 +1875 @@
                         for ( ; baseParam != baseParams.end() && typeParam != typeParams.end(); ++baseParam, ++typeParam ) {
                                 // skip non-otype parameters
-                                if ( ! (*baseParam)->isComplete() ) continue;
+                                if ( (*baseParam)->get_kind() != TypeDecl::Any ) continue;
                                 TypeExpr *typeExpr = dynamic_cast< TypeExpr* >( *typeParam );
                                 assert( typeExpr && "all otype parameters should be type expressions" );
@@ -1838 +2087 @@
 //   Initializer *init = 0;
 //   std::list< Expression *> designators;
-//   addToTyVarMap( typeDecl, scopeTyVars );
+//   scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
 //   if ( typeDecl->get_base() ) {
 //     init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators );
@@ -1844 +2093 @@
 //   return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init );
 
-                        addToTyVarMap( typeDecl, scopeTyVars );
+                        scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
                         return Mutator::mutate( typeDecl );
                 }

src/GenPoly/CopyParams.cc

@@ -38 +38 @@
         };
 
-        /// creates local copies of polymorphic function parameters
         void copyParams( std::list< Declaration* > &translationUnit ) {
                 CopyParams copier;
@@ -54 +53 @@
                         if ( ! modVars.empty() ) {
                                 std::map< std::string, DeclarationWithType* > assignOps;
-                                // xxx - this needs to use constructors, not assignment operators
                                 // assume the assignment operator is the first assert param after any "type" parameter
                                 for ( Type::ForallList::const_iterator tyVar = funcDecl->get_functionType()->get_forall().begin(); tyVar != funcDecl->get_functionType()->get_forall().end(); ++tyVar ) {

src/GenPoly/GenPoly.cc

@@ -92 +92 @@
         }
 
-        ReferenceToType *isDynType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
+        Type *isDynType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
                 type = replaceTypeInst( type, env );
 
                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
                         auto var = tyVars.find( typeInst->get_name() );
-                        if ( var != tyVars.end() && var->second.isComplete ) {
-                                return typeInst;
+                        if ( var != tyVars.end() && var->second == TypeDecl::Any ) {
+                                return type;
                         }
                 } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
-                        if ( hasDynParams( structType->get_parameters(), tyVars, env ) ) return structType;
+                        if ( hasDynParams( structType->get_parameters(), tyVars, env ) ) return type;
                 } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
-                        if ( hasDynParams( unionType->get_parameters(), tyVars, env ) ) return unionType;
+                        if ( hasDynParams( unionType->get_parameters(), tyVars, env ) ) return type;
                 }
                 return 0;
@@ -117 +117 @@
                 if ( function->get_returnVals().empty() ) return 0;
 
-                TyVarMap forallTypes( TypeDecl::Data{} );
+                TyVarMap forallTypes( (TypeDecl::Kind)-1 );
                 makeTyVarMap( function, forallTypes );
                 return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes );
@@ -219 +219 @@
                                 expr = commaExpr->get_arg2();
                                 continue;
-                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( expr ) ) {
-                                int lvl1;
-                                int lvl2;
-                                VariableExpr * var1 = getBaseVar( condExpr->get_arg2(), &lvl1 );
-                                VariableExpr * var2 = getBaseVar( condExpr->get_arg3(), &lvl2 );
-                                if ( lvl1 == lvl2 && var1 && var2 && var1->get_var() == var2->get_var() ) {
-                                        *levels = lvl1;
-                                        return var1;
-                                }
-                                break;
                         } else break;
 
@@ -235 +225 @@
 
                 return 0;
-        }
-
-        void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
-                tyVarMap[ tyVar->get_name() ] = TypeDecl::Data{ tyVar };
         }
 
@@ -244 +230 @@
                 for ( Type::ForallList::const_iterator tyVar = type->get_forall().begin(); tyVar != type->get_forall().end(); ++tyVar ) {
                         assert( *tyVar );
-                        addToTyVarMap( *tyVar, tyVarMap );
+                        tyVarMap[ (*tyVar)->get_name() ] = (*tyVar)->get_kind();
                 }
                 if ( PointerType *pointer = dynamic_cast< PointerType* >( type ) ) {

src/GenPoly/GenPoly.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// GenPoly.h --
+// GenPoly.h -- 
 //
 // Author           : Richard C. Bilson
@@ -30 +30 @@
 
 namespace GenPoly {
-        typedef ErasableScopedMap< std::string, TypeDecl::Data > TyVarMap;
+        typedef ErasableScopedMap< std::string, TypeDecl::Kind > TyVarMap;
 
         /// Replaces a TypeInstType by its referrent in the environment, if applicable
         Type* replaceTypeInst( Type* type, const TypeSubstitution* env );
-
+        
         /// returns polymorphic type if is polymorphic type, NULL otherwise; will look up substitution in env if provided
         Type *isPolyType( Type *type, const TypeSubstitution *env = 0 );
-
+        
         /// returns polymorphic type if is polymorphic type in tyVars, NULL otherwise; will look up substitution in env if provided
         Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
 
         /// returns dynamic-layout type if is dynamic-layout type in tyVars, NULL otherwise; will look up substitution in env if provided
-        ReferenceToType *isDynType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
+        Type *isDynType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
 
         /// true iff function has dynamic-layout return type under the given type variable map
@@ -55 +55 @@
         /// returns polymorphic type if is pointer to polymorphic type, NULL otherwise; will look up substitution in env if provided
         Type *isPolyPtr( Type *type, const TypeSubstitution *env = 0 );
-
+        
         /// returns polymorphic type if is pointer to polymorphic type in tyVars, NULL otherwise; will look up substitution in env if provided
         Type *isPolyPtr( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
@@ -74 +74 @@
         VariableExpr *getBaseVar( Expression *expr, int *levels = 0 );
 
-        /// Adds the type variable `tyVar` to `tyVarMap`
-        void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap );
-
         /// Adds the declarations in the forall list of type (and its pointed-to type if it's a pointer type) to `tyVarMap`
         void makeTyVarMap( Type *type, TyVarMap &tyVarMap );
-
+        
         /// Prints type variable map
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap );
@@ -85 +82 @@
         /// Gets the mangled name of this type; alias for SymTab::Mangler::mangleType().
         inline std::string mangleType( Type *ty ) { return SymTab::Mangler::mangleType( ty ); }
-
+        
         /// Gets the name of the sizeof parameter for the type, given its mangled name
         inline std::string sizeofName( const std::string &name ) { return std::string( "_sizeof_" ) + name; }
@@ -97 +94 @@
         /// Gets the name of the layout function for a given aggregate type, given its declaration
         inline std::string layoutofName( AggregateDecl *decl ) { return std::string( "_layoutof_" ) + decl->get_name(); }
-
+        
 } // namespace GenPoly
 

src/GenPoly/InstantiateGeneric.cc

@@ -284 +284 @@
                                 // set concDecl to new type, insert type declaration into statements to add
                                 concDecl = new StructDecl( typeNamer.newName( inst->get_name() ) );
-                                concDecl->set_body( inst->get_baseStruct()->has_body() );
                                 substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs,        concDecl->get_members() );
                                 DeclMutator::addDeclaration( concDecl );
@@ -338 +337 @@
                                 // set concDecl to new type, insert type declaration into statements to add
                                 concDecl = new UnionDecl( typeNamer.newName( inst->get_name() ) );
-                                concDecl->set_body( inst->get_baseUnion()->has_body() );
                                 substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
                                 DeclMutator::addDeclaration( concDecl );

src/GenPoly/PolyMutator.cc

@@ -23 +23 @@
 
 namespace GenPoly {
-        PolyMutator::PolyMutator() : scopeTyVars( TypeDecl::Data{} ), env( 0 ) {}
+        namespace {
+                const std::list<Label> noLabels;
+        }
+
+        PolyMutator::PolyMutator() : scopeTyVars( (TypeDecl::Kind)-1 ), env( 0 ) {}
 
         void PolyMutator::mutateStatementList( std::list< Statement* > &statements ) {
@@ -145 +149 @@
         }
 
-        Expression *PolyMutator::mutate( StmtExpr * stmtExpr ) {
-                // don't want statements from outer CompoundStmts to be added to this StmtExpr
-                ValueGuard< std::list< Statement* > > oldStmtsToAdd( stmtsToAdd );
-                ValueGuard< std::list< Statement* > > oldStmtsToAddAfter( stmtsToAddAfter );
-                ValueGuard< TypeSubstitution * > oldEnv( env );
-
-                // xxx - not sure if this is needed, along with appropriate reset, but I don't think so...
-                // ValueGuard< TyVarMap > oldScopeTyVars( scopeTyVars );
-
-                stmtsToAdd.clear();
-                stmtsToAddAfter.clear();
-                // scopeTyVars.clear();
-
-                return Parent::mutate( stmtExpr );
-        }
 
         Initializer *PolyMutator::mutate( SingleInit *singleInit ) {
@@ -165 +154 @@
                 return singleInit;
         }
+
 } // namespace GenPoly
 

src/GenPoly/PolyMutator.h

@@ -47 +47 @@
 
                 virtual Expression* mutate(UntypedExpr *untypedExpr);
-                virtual Expression* mutate( StmtExpr *stmtExpr );
 
                 virtual Initializer* mutate(SingleInit *SingleInit);

src/GenPoly/ScrubTyVars.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ScrubTyVars.cc --
+// ScrubTyVars.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -28 +28 @@
                 TyVarMap::const_iterator tyVar = tyVars.find( typeInst->get_name() );
                 if ( tyVar != tyVars.end() ) {
-                        switch ( tyVar->second.kind ) {
+                        switch ( tyVar->second ) {
                           case TypeDecl::Any:
                           case TypeDecl::Dtype:
@@ -52 +52 @@
                 return ty;
         }
-
+        
         Type * ScrubTyVars::mutate( StructInstType *structInst ) {
                 return mutateAggregateType( structInst );

src/InitTweak/FixInit.cc

@@ -49 +49 @@
 namespace InitTweak {
         namespace {
-                typedef std::unordered_map< Expression *, TypeSubstitution * > EnvMap;
-
                 class InsertImplicitCalls final : public GenPoly::PolyMutator {
                 public:
                         /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
                         /// function calls need their parameters to be copy constructed
-                        static void insert( std::list< Declaration * > & translationUnit, EnvMap & envMap );
-
-                        InsertImplicitCalls( EnvMap & envMap ) : envMap( envMap ) {}
-                        typedef GenPoly::PolyMutator Parent;
-                        using Parent::mutate;
+                        static void insert( std::list< Declaration * > & translationUnit );
+
+                        using GenPoly::PolyMutator::mutate;
                         virtual Expression * mutate( ApplicationExpr * appExpr ) override;
-                        virtual Expression * mutate( StmtExpr * stmtExpr ) override;
-
-                        // collects environments for relevant nodes
-                        EnvMap & envMap;
                 };
 
@@ -72 +64 @@
                         /// generate/resolve copy construction expressions for each, and generate/resolve destructors for both
                         /// arguments and return value temporaries
-                        static void resolveImplicitCalls( std::list< Declaration * > & translationUnit, const EnvMap & envMap );
+                        static void resolveImplicitCalls( std::list< Declaration * > & translationUnit );
 
                         typedef SymTab::Indexer Parent;
                         using Parent::visit;
 
-                        ResolveCopyCtors( const EnvMap & envMap ) : envMap( envMap ) {}
-
                         virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
-                        virtual void visit( UniqueExpr * unqExpr ) override;
-                        virtual void visit( StmtExpr * stmtExpr ) override;
+                        virtual void visit( UniqueExpr * unqExpr );
 
                         /// create and resolve ctor/dtor expression: fname(var, [cpArg])
@@ -90 +79 @@
                         void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr );
                         void destructRet( Expression * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
-
+                private:
                         TypeSubstitution * env;
-                        const EnvMap & envMap;
                 };
 
@@ -186 +174 @@
                         static void fixInitializers( std::list< Declaration * > &translationUnit );
 
-                        typedef GenPoly::PolyMutator Parent;
-                        using Parent::mutate;
+                        using GenPoly::PolyMutator::mutate;
                         virtual DeclarationWithType * mutate( ObjectDecl *objDecl ) override;
 
@@ -199 +186 @@
                         static void fixCopyCtors( std::list< Declaration * > &translationUnit );
 
-                        typedef GenPoly::PolyMutator Parent;
-                        using Parent::mutate;
+                        using GenPoly::PolyMutator::mutate;
                         virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
                         virtual Expression * mutate( UniqueExpr * unqExpr ) override;
-                        virtual Expression * mutate( StmtExpr * stmtExpr ) override;
                 };
 
@@ -263 +248 @@
                 InitTweak::fixGlobalInit( translationUnit, filename, inLibrary );
 
-                EnvMap envMap;
-
-                InsertImplicitCalls::insert( translationUnit, envMap );
-                ResolveCopyCtors::resolveImplicitCalls( translationUnit, envMap );
+
+                InsertImplicitCalls::insert( translationUnit );
+                ResolveCopyCtors::resolveImplicitCalls( translationUnit );
                 InsertDtors::insert( translationUnit );
                 FixInit::fixInitializers( translationUnit );
@@ -285 +269 @@
 
         namespace {
-                void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit, EnvMap & envMap ) {
-                        InsertImplicitCalls inserter( envMap );
+                void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit ) {
+                        InsertImplicitCalls inserter;
                         mutateAll( translationUnit, inserter );
                 }
 
-                void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit, const EnvMap & envMap ) {
-                        ResolveCopyCtors resolver( envMap );
+                void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit ) {
+                        ResolveCopyCtors resolver;
                         acceptAll( translationUnit, resolver );
                 }
@@ -342 +326 @@
 
                 Expression * InsertImplicitCalls::mutate( ApplicationExpr * appExpr ) {
-                        appExpr = dynamic_cast< ApplicationExpr * >( Parent::mutate( appExpr ) );
+                        appExpr = dynamic_cast< ApplicationExpr * >( Mutator::mutate( appExpr ) );
                         assert( appExpr );
 
@@ -355 +339 @@
                                                 Type * t1 = ftype->get_parameters().front()->get_type();
                                                 Type * t2 = ftype->get_parameters().back()->get_type();
-                                                PointerType * ptrType = safe_dynamic_cast< PointerType * > ( t1 );
+                                                PointerType * ptrType = dynamic_cast< PointerType * > ( t1 );
+                                                assert( ptrType );
 
                                                 if ( ResolvExpr::typesCompatible( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
@@ -372 +357 @@
                         // wrap each function call so that it is easy to identify nodes that have to be copy constructed
                         ImplicitCopyCtorExpr * expr = new ImplicitCopyCtorExpr( appExpr );
-                        // save the type substitution into the envMap so that it is easy to find.
+                        // save the type substitution onto the new node so that it is easy to find.
                         // Ensure it is not deleted with the ImplicitCopyCtorExpr by removing it before deletion.
                         // The substitution is needed to obtain the type of temporary variables so that copy constructor
@@ -381 +366 @@
                         // constructor calls together.
                         assert( env );
-                        envMap[expr] = env;
+                        expr->set_env( env );
                         return expr;
-                }
-
-                Expression * InsertImplicitCalls::mutate( StmtExpr * stmtExpr ) {
-                        assert( env );
-                        envMap[stmtExpr] = env;
-                        return Parent::mutate( stmtExpr );
                 }
 
@@ -413 +392 @@
                         assert( resolved );
                         if ( resolved->get_env() ) {
-                                // Extract useful information and discard new environments. Keeping them causes problems in PolyMutator passes.
                                 env->add( *resolved->get_env() );
-                                delete resolved->get_env();
-                                resolved->set_env( nullptr );
                         } // if
 
@@ -425 +401 @@
                 void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr ) {
                         static UniqueName tempNamer("_tmp_cp");
-                        assert( env );
-                        CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *env << std::endl; )
+                        CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *impCpCtorExpr->get_env() << std::endl; )
                         assert( arg->has_result() );
                         Type * result = arg->get_result();
@@ -433 +408 @@
                         // type may involve type variables, so apply type substitution to get temporary variable's actual type
                         result = result->clone();
-                        env->apply( result );
+                        impCpCtorExpr->get_env()->apply( result );
                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
                         tmp->get_type()->set_isConst( false );
@@ -462 +437 @@
                         CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
                         Parent::visit( impCpCtorExpr );
-                        env = envMap.at(impCpCtorExpr);
-                        assert( env );
+                        env = impCpCtorExpr->get_env(); // xxx - maybe we really should just have a PolyIndexer...
 
                         ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
@@ -474 +448 @@
                         // each return value from the call needs to be connected with an ObjectDecl at the call site, which is
                         // initialized with the return value and is destructed later
-                        // xxx - handle named return values?
+                        // xxx - handle multiple return values
+                        ApplicationExpr * callExpr = impCpCtorExpr->get_callExpr();
+                        // xxx - is this right? callExpr may not have the right environment, because it was attached at a higher
+                        // level. Trying to pass that environment along.
+                        callExpr->set_env( impCpCtorExpr->get_env()->clone() );
                         Type * result = appExpr->get_result();
                         if ( ! result->isVoid() ) {
                                 static UniqueName retNamer("_tmp_cp_ret");
                                 result = result->clone();
-                                env->apply( result );
+                                impCpCtorExpr->get_env()->apply( result );
                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
                                 ret->get_type()->set_isConst( false );
@@ -490 +468 @@
                         } // for
                         CP_CTOR_PRINT( std::cerr << "after Resolving: " << impCpCtorExpr << std::endl; )
-                }
-
-                void ResolveCopyCtors::visit( StmtExpr * stmtExpr ) {
-                        Parent::visit( stmtExpr );
-                        env = envMap.at(stmtExpr);
-                        assert( stmtExpr->get_result() );
-                        Type * result = stmtExpr->get_result();
-                        if ( ! result->isVoid() ) {
-                                static UniqueName retNamer("_tmp_stmtexpr_ret");
-
-                                // create variable that will hold the result of the stmt expr
-                                result = result->clone();
-                                env->apply( result );
-                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
-                                ret->get_type()->set_isConst( false );
-                                stmtExpr->get_returnDecls().push_front( ret );
-
-                                // must have a non-empty body, otherwise it wouldn't have a result
-                                CompoundStmt * body = stmtExpr->get_statements();
-                                assert( ! body->get_kids().empty() );
-                                // must be an ExprStmt, otherwise it wouldn't have a result
-                                ExprStmt * last = safe_dynamic_cast< ExprStmt * >( body->get_kids().back() );
-                                last->set_expr( makeCtorDtor( "?{}", ret, last->get_expr() ) );
-
-                                stmtExpr->get_dtors().push_front( makeCtorDtor( "^?{}", new AddressExpr( new VariableExpr( ret ) ) ) );
-                        } // if
-
                 }
 
@@ -541 +492 @@
                 }
 
+
                 Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
                         CP_CTOR_PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; )
 
-                        impCpCtorExpr = safe_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) );
+                        impCpCtorExpr = dynamic_cast< ImplicitCopyCtorExpr * >( Mutator::mutate( impCpCtorExpr ) );
+                        assert( impCpCtorExpr );
+
                         std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls();
                         std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls();
@@ -604 +558 @@
                                         retExpr = UntypedExpr::createDeref( retExpr );
                                 } // if
-                                // move env from callExpr to retExpr
-                                retExpr->set_env( callExpr->get_env() );
-                                callExpr->set_env( nullptr );
+                                retExpr->set_env( env->clone() );
                                 return retExpr;
                         } else {
@@ -613 +565 @@
                 }
 
-                Expression * FixCopyCtors::mutate( StmtExpr * stmtExpr ) {
-                        stmtExpr = safe_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) );
-                        assert( stmtExpr->get_result() );
-                        Type * result = stmtExpr->get_result();
-                        if ( ! result->isVoid() ) {
-                                for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
-                                        stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
-                                } // for
-                                // add destructors after current statement
-                                for ( Expression * dtor : stmtExpr->get_dtors() ) {
-                                        stmtsToAddAfter.push_back( new ExprStmt( noLabels, dtor ) );
-                                } // for
-                                // must have a non-empty body, otherwise it wouldn't have a result
-                                CompoundStmt * body = stmtExpr->get_statements();
-                                assert( ! body->get_kids().empty() );
-                                assert( ! stmtExpr->get_returnDecls().empty() );
-                                body->get_kids().push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
-                        }
-                        stmtExpr->get_returnDecls().clear();
-                        stmtExpr->get_dtors().clear();
-                        return stmtExpr;
-                }
-
                 Expression * FixCopyCtors::mutate( UniqueExpr * unqExpr ) {
                         static std::unordered_map< int, UniqueExpr * > unqMap;
                         static std::unordered_set< int > addDeref;
                         // has to be done to clean up ImplicitCopyCtorExpr nodes, even when this node was skipped in previous passes
+                        unqExpr = safe_dynamic_cast< UniqueExpr * >( Parent::mutate( unqExpr ) );
                         if ( unqMap.count( unqExpr->get_id() ) ) {
                                 // take data from other UniqueExpr to ensure consistency
@@ -652 +582 @@
                                 return unqExpr;
                         }
-                        unqExpr = safe_dynamic_cast< UniqueExpr * >( Parent::mutate( unqExpr ) ); // stmtexprs contained should not be separately fixed, so this must occur after the lookup
                         unqMap[unqExpr->get_id()] = unqExpr;
                         if ( UntypedExpr * deref = dynamic_cast< UntypedExpr * >( unqExpr->get_expr() ) ) {
@@ -670 +599 @@
                         // first recursively handle pieces of ObjectDecl so that they aren't missed by other visitors when the init
                         // is removed from the ObjectDecl
-                        objDecl = dynamic_cast< ObjectDecl * >( Parent::mutate( objDecl ) );
+                        objDecl = dynamic_cast< ObjectDecl * >( Mutator::mutate( objDecl ) );
+
                         if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {
                                 // a decision should have been made by the resolver, so ctor and init are not both non-NULL
@@ -974 +904 @@
                                         // insert and resolve default/copy constructor call for each field that's unhandled
                                         std::list< Statement * > stmt;
-                                        UntypedExpr * deref = UntypedExpr::createDeref( new VariableExpr( thisParam ) );
+                                        UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
+                                        deref->get_args().push_back( new VariableExpr( thisParam ) );
 
                                         Expression * arg2 = 0;

src/InitTweak/GenInit.cc

@@ -46 +46 @@
                 ReturnFixer();
 
-                typedef GenPoly::PolyMutator Parent;
-                using Parent::mutate;
+                using GenPoly::PolyMutator::mutate;
                 virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
                 virtual Statement * mutate( ReturnStmt * returnStmt ) override;
@@ -53 +52 @@
           protected:
                 FunctionType * ftype;
+                UniqueName tempNamer;
                 std::string funcName;
         };
@@ -135 +135 @@
         }
 
-        ReturnFixer::ReturnFixer() {}
+        ReturnFixer::ReturnFixer() : tempNamer( "_retVal" ) {}
 
         Statement *ReturnFixer::mutate( ReturnStmt *returnStmt ) {
@@ -142 +142 @@
                 // hands off if the function returns an lvalue - we don't want to allocate a temporary if a variable's address
                 // is being returned
-                // Note: under the assumption that assignments return *this, checking for ?=? here is an optimization, since it shouldn't be necessary to copy construct `this`. This is a temporary optimization until reference types are added, at which point this should be removed, along with the analogous optimization in copy constructor generation.
                 if ( returnStmt->get_expr() && returnVals.size() == 1 && funcName != "?=?" && ! returnVals.front()->get_type()->get_isLvalue() ) {
-                        // explicitly construct the return value using the return expression and the retVal object
-                        assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() );
+                        // ensure return value is not destructed by explicitly creating
+                        // an empty SingleInit node wherein maybeConstruct is false
+                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, returnVals.front()->get_type()->clone(), new ListInit( std::list<Initializer*>(), noDesignators, false ) );
+                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
+
+                        // and explicitly create the constructor expression separately
                         UntypedExpr *construct = new UntypedExpr( new NameExpr( "?{}" ) );
-                        construct->get_args().push_back( new AddressExpr( new VariableExpr( returnVals.front() ) ) );
+                        construct->get_args().push_back( new AddressExpr( new VariableExpr( newObj ) ) );
                         construct->get_args().push_back( returnStmt->get_expr() );
                         stmtsToAdd.push_back(new ExprStmt(noLabels, construct));
 
-                        // return the retVal object
-                        returnStmt->set_expr( new VariableExpr( returnVals.front() ) );
+                        returnStmt->set_expr( new VariableExpr( newObj ) );
                 } // if
                 return returnStmt;
@@ -158 +160 @@
 
         DeclarationWithType* ReturnFixer::mutate( FunctionDecl *functionDecl ) {
+                // xxx - need to handle named return values - this pass may need to happen
+                // after resolution? the ordering is tricky because return statements must be
+                // constructed - the simplest way to do that (while also handling multiple
+                // returns) is to structure the returnVals into a tuple, as done here.
+                // however, if the tuple return value is structured before resolution,
+                // it's difficult to resolve named return values, since the name is lost
+                // in conversion to a tuple. this might be easiest to deal with
+                // after reference types are added, as it may then be possible to
+                // uniformly move named return values to the parameter list directly
                 ValueGuard< FunctionType * > oldFtype( ftype );
                 ValueGuard< std::string > oldFuncName( funcName );
 
                 ftype = functionDecl->get_functionType();
+                std::list< DeclarationWithType * > & retVals = ftype->get_returnVals();
+                if ( retVals.size() > 1 ) {
+                        TupleType * tupleType = safe_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
+                        ObjectDecl * newRet = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
+                        retVals.clear();
+                        retVals.push_back( newRet );
+                }
                 funcName = functionDecl->get_name();
-                return Parent::mutate( functionDecl );
+                DeclarationWithType * decl = Mutator::mutate( functionDecl );
+                return decl;
         }
 
@@ -227 +246 @@
                         }
                 }
-                // a type is managed if it appears in the map of known managed types, or if it contains any polymorphism (is a type variable or generic type containing a type variable)
-                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end() || GenPoly::isPolyType( type );
+                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end();
         }
 

src/ResolvExpr/AdjustExprType.cc

@@ -97 +97 @@
                 EqvClass eqvClass;
                 if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
-                        if ( eqvClass.data.kind == TypeDecl::Ftype ) {
+                        if ( eqvClass.kind == TypeDecl::Ftype ) {
                                 PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
                                 return pointerType;

src/ResolvExpr/AlternativeFinder.cc

@@ -44 +44 @@
 #include "InitTweak/GenInit.h"
 #include "ResolveTypeof.h"
-#include "Resolver.h"
 
 extern bool resolvep;
@@ -186 +185 @@
                         if ( alternatives.begin() == oldBegin ) {
                                 std::ostringstream stream;
-                                stream << "Can't choose between " << alternatives.size() << " alternatives for expression ";
+                                stream << "Can't choose between alternatives for expression ";
                                 expr->print( stream );
                                 stream << "Alternatives are:";
@@ -309 +308 @@
                                         (*actualType)->print( std::cerr, 8 );
                                         std::cerr << std::endl << " to ";
-                                        (*formalType)->print( std::cerr, 8 );
+                                        (*formal)->get_type()->print( std::cerr, 8 );
                                 )
                                 Cost newCost = conversionCost( *actualType, *formalType, indexer, alt.env );
@@ -374 +373 @@
         void makeUnifiableVars( Type *type, OpenVarSet &unifiableVars, AssertionSet &needAssertions ) {
                 for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
-                        unifiableVars[ (*tyvar)->get_name() ] = TypeDecl::Data{ *tyvar };
+                        unifiableVars[ (*tyvar)->get_name() ] = (*tyvar)->get_kind();
                         for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->get_assertions().begin(); assert != (*tyvar)->get_assertions().end(); ++assert ) {
                                 needAssertions[ *assert ] = true;
@@ -512 +511 @@
                 if ( ! cur->second ) {
                         inferRecursive( begin, end, newAlt, openVars, decls, newNeed, /*needParents,*/ level, indexer, out );
-                        return; // xxx - should this continue? previously this wasn't here, and it looks like it should be
                 }
                 DeclarationWithType *curDecl = cur->first;
-
                 PRINT(
                         std::cerr << "inferRecursive: assertion is ";
@@ -609 +606 @@
                 makeUnifiableVars( funcType, openVars, resultNeed );
                 AltList instantiatedActuals; // filled by instantiate function
-                if ( targetType && ! targetType->isVoid() ) {
-                        // attempt to narrow based on expected target type
-                        Type * returnType = funcType->get_returnVals().front()->get_type();
-                        if ( ! unify( returnType, targetType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
-                                // unification failed, don't pursue this alternative
-                                return;
-                        }
-                }
-
                 if ( instantiateFunction( funcType->get_parameters(), actualAlt, funcType->get_isVarArgs(), openVars, resultEnv, resultNeed, resultHave, instantiatedActuals ) ) {
                         ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
@@ -661 +649 @@
                 AltList candidates;
                 SemanticError errors;
+
                 for ( AltList::const_iterator func = funcFinder.alternatives.begin(); func != funcFinder.alternatives.end(); ++func ) {
                         try {
@@ -750 +739 @@
 
                 findMinCost( candidates.begin(), candidates.end(), std::back_inserter( alternatives ) );
-
-                if ( alternatives.empty() && targetType && ! targetType->isVoid() ) {
-                        // xxx - this is a temporary hack. If resolution is unsuccessful with a target type, try again without a
-                        // target type, since it will sometimes succeed when it wouldn't easily with target type binding. For example,
-                        //   forall( otype T ) lvalue T ?[?]( T *, ptrdiff_t );
-                        //   const char * x = "hello world";
-                        //   unsigned char ch = x[0];
-                        // Fails with simple return type binding. First, T is bound to unsigned char, then (x: const char *) is unified
-                        // with unsigned char *, which fails because pointer base types must be unified exactly. The new resolver should
-                        // fix this issue in a more robust way.
-                        targetType = nullptr;
-                        visit( untypedExpr );
-                }
         }
 
@@ -782 +758 @@
         void AlternativeFinder::visit( CastExpr *castExpr ) {
                 Type *& toType = castExpr->get_result();
-                assert( toType );
                 toType = resolveTypeof( toType, indexer );
                 SymTab::validateType( toType, &indexer );
@@ -788 +763 @@
 
                 AlternativeFinder finder( indexer, env );
-                finder.targetType = toType;
                 finder.findWithAdjustment( castExpr->get_arg() );
 
@@ -802 +776 @@
                         int discardedValues = (*i).expr->get_result()->size() - castExpr->get_result()->size();
                         if ( discardedValues < 0 ) continue;
-                        // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
-                        // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
+                        // xxx - may need to go into tuple types and extract relavent types and use unifyList
                         // unification run for side-effects
                         unify( castExpr->get_result(), (*i).expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer );
@@ -810 +783 @@
                                 // count one safe conversion for each value that is thrown away
                                 thisCost += Cost( 0, 0, discardedValues );
-
-                                Expression * argExpr = i->expr->clone();
-                                if ( argExpr->get_result()->size() > 1 && ! castExpr->get_result()->isVoid() ) {
-                                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
-                                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
-                                        // more components of the tuple than components in the target type, then excess components do not
-                                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
-                                        if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
-                                                // expressions which may contain side effects require a single unique instance of the expression.
-                                                argExpr = new UniqueExpr( argExpr );
-                                        }
-                                        std::list< Expression * > componentExprs;
-                                        for ( unsigned int i = 0; i < castExpr->get_result()->size(); i++ ) {
-                                                // cast each component
-                                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
-                                                componentExprs.push_back( new CastExpr( idx, castExpr->get_result()->getComponent( i )->clone() ) );
-                                        }
-                                        delete argExpr;
-                                        assert( componentExprs.size() > 0 );
-                                        // produce the tuple of casts
-                                        candidates.push_back( Alternative( new TupleExpr( componentExprs ), i->env, i->cost, thisCost ) );
-                                } else {
-                                        // handle normally
-                                        candidates.push_back( Alternative( new CastExpr( argExpr->clone(), toType->clone() ), i->env, i->cost, thisCost ) );
-                                }
+                                CastExpr *newExpr = castExpr->clone();
+                                newExpr->set_arg( i->expr->clone() );
+                                candidates.push_back( Alternative( newExpr, i->env, i->cost, thisCost ) );
                         } // if
                 } // for
@@ -849 +800 @@
                 AlternativeFinder funcFinder( indexer, env );
                 funcFinder.findWithAdjustment( memberExpr->get_aggregate() );
+
                 for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) {
                         if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_result() ) ) {
@@ -1123 +1075 @@
         }
 
-        void AlternativeFinder::visit( StmtExpr *stmtExpr ) {
-                StmtExpr * newStmtExpr = stmtExpr->clone();
-                ResolvExpr::resolveStmtExpr( newStmtExpr, indexer );
-                // xxx - this env is almost certainly wrong, and needs to somehow contain the combined environments from all of the statements in the stmtExpr...
-                alternatives.push_back( Alternative( newStmtExpr, env, Cost::zero ) );
-        }
-
 } // namespace ResolvExpr
 

src/ResolvExpr/AlternativeFinder.h

@@ -70 +70 @@
                 virtual void visit( TupleAssignExpr *tupleExpr );
                 virtual void visit( UniqueExpr *unqExpr );
-                virtual void visit( StmtExpr *stmtExpr );
                 /// Runs a new alternative finder on each element in [begin, end)
                 /// and writes each alternative finder to out.
@@ -92 +91 @@
                 AltList alternatives;
                 const TypeEnvironment &env;
-                Type * targetType = nullptr;
         }; // AlternativeFinder
 

src/ResolvExpr/CommonType.cc

@@ -58 +58 @@
                 Type *result = visitor.get_result();
                 if ( ! result ) {
-                        // this appears to be handling for opaque type declarations
                         if ( widenSecond ) {
-                                if ( TypeInstType *inst = dynamic_cast< TypeInstType* >( type2 ) ) {
-                                        if ( NamedTypeDecl *nt = indexer.lookupType( inst->get_name() ) ) {
-                                                TypeDecl *type = safe_dynamic_cast< TypeDecl* >( nt );
+                                TypeInstType *inst = dynamic_cast< TypeInstType* >( type2 );
+                                if ( inst ) {
+                                        NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
+                                        if ( nt ) {
+                                                TypeDecl *type = dynamic_cast< TypeDecl* >( nt );
+                                                assert( type );
                                                 if ( type->get_base() ) {
                                                         Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers();
@@ -156 +158 @@
                 result->get_qualifiers() += otherPointer->get_qualifiers();
         }
-
+        
         void CommonType::visit( PointerType *pointerType ) {
                 if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
@@ -221 +223 @@
                         NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
                         if ( nt ) {
-                                TypeDecl *type = safe_dynamic_cast< TypeDecl* >( nt );
+                                TypeDecl *type = dynamic_cast< TypeDecl* >( nt );
+                                assert( type );
                                 if ( type->get_base() ) {
                                         Type::Qualifiers tq1 = inst->get_qualifiers(), tq2 = type2->get_qualifiers();

src/ResolvExpr/FindOpenVars.cc

@@ -48 +48 @@
                 if ( nextIsOpen ) {
                         for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
-                                openVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
+                                openVars[ (*i)->get_name() ] = (*i)->get_kind();
                                 for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
                                         needAssertions[ *assert ] = false;
@@ -57 +57 @@
                 } else {
                         for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
-                                closedVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
+                                closedVars[ (*i)->get_name() ] = (*i)->get_kind();
                                 for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
                                         haveAssertions[ *assert ] = false;

src/ResolvExpr/PtrsCastable.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// PtrsCastable.cc --
+// PtrsCastable.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -25 +25 @@
           public:
                 PtrsCastable( Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
-
+  
                 int get_result() const { return result; }
 
@@ -61 +61 @@
                                 } //if
                         } else if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
-                                if ( eqvClass.data.kind == TypeDecl::Ftype ) {
+                                if ( eqvClass.kind == TypeDecl::Ftype ) {
                                         return -1;
                                 } // if

src/ResolvExpr/Resolver.cc

@@ -36 +36 @@
           public:
                 Resolver() : SymTab::Indexer( false ) {}
-                Resolver( const SymTab:: Indexer & other ) : SymTab::Indexer( other ) {
-                        if ( const Resolver * res = dynamic_cast< const Resolver * >( &other ) ) {
-                                functionReturn = res->functionReturn;
-                                initContext = res->initContext;
-                                inEnumDecl = res->inEnumDecl;
-                        }
-                }
-
-                typedef SymTab::Indexer Parent;
-                using Parent::visit;
+
+                using SymTab::Indexer::visit;
                 virtual void visit( FunctionDecl *functionDecl ) override;
                 virtual void visit( ObjectDecl *functionDecl ) override;
@@ -74 +66 @@
                 void handlePtrType( PtrType * type );
 
-          void resolveAggrInit( ReferenceToType *, InitIterator &, InitIterator & );
-          void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator &, TypeSubstitution sub );
+          void resolveAggrInit( AggregateDecl *, InitIterator &, InitIterator & );
+          void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & );
           void fallbackInit( ConstructorInit * ctorInit );
 
@@ -200 +192 @@
                         initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
                 }
-                Parent::visit( objectDecl );
+                SymTab::Indexer::visit( objectDecl );
                 if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
                         // delete newly created signed int type
@@ -220 +212 @@
         void Resolver::visit( ArrayType * at ) {
                 handlePtrType( at );
-                Parent::visit( at );
+                Visitor::visit( at );
         }
 
         void Resolver::visit( PointerType * pt ) {
                 handlePtrType( pt );
-                Parent::visit( pt );
+                Visitor::visit( pt );
         }
 
@@ -233 +225 @@
                         typeDecl->set_base( new_type );
                 } // if
-                Parent::visit( typeDecl );
+                SymTab::Indexer::visit( typeDecl );
         }
 
@@ -246 +238 @@
                 ValueGuard< Type * > oldFunctionReturn( functionReturn );
                 functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
-                Parent::visit( functionDecl );
+                SymTab::Indexer::visit( functionDecl );
         }
 
         void Resolver::visit( EnumDecl * enumDecl ) {
                 // in case we decide to allow nested enums
-                ValueGuard< bool > oldInEnumDecl( inEnumDecl );
+                bool oldInEnumDecl = inEnumDecl;
                 inEnumDecl = true;
-                Parent::visit( enumDecl );
+                SymTab::Indexer::visit( enumDecl );
+                inEnumDecl = oldInEnumDecl;
         }
 
         void Resolver::visit( ExprStmt *exprStmt ) {
-                assertf( exprStmt->get_expr(), "ExprStmt has null Expression in resolver" );
-                Expression *newExpr = findVoidExpression( exprStmt->get_expr(), *this );
-                delete exprStmt->get_expr();
-                exprStmt->set_expr( newExpr );
+                if ( exprStmt->get_expr() ) {
+                        Expression *newExpr = findVoidExpression( exprStmt->get_expr(), *this );
+                        delete exprStmt->get_expr();
+                        exprStmt->set_expr( newExpr );
+                } // if
         }
 
@@ -283 +277 @@
                 delete ifStmt->get_condition();
                 ifStmt->set_condition( newExpr );
-                Parent::visit( ifStmt );
+                Visitor::visit( ifStmt );
         }
 
@@ -290 +284 @@
                 delete whileStmt->get_condition();
                 whileStmt->set_condition( newExpr );
-                Parent::visit( whileStmt );
+                Visitor::visit( whileStmt );
         }
 
         void Resolver::visit( ForStmt *forStmt ) {
-                Parent::visit( forStmt );
+                SymTab::Indexer::visit( forStmt );
 
                 if ( forStmt->get_condition() ) {
@@ -324 +318 @@
 
         void Resolver::visit( CaseStmt *caseStmt ) {
-                Parent::visit( caseStmt );
+                Visitor::visit( caseStmt );
         }
 
@@ -402 +396 @@
         }
 
-        template< typename AggrInst >
-        TypeSubstitution makeGenericSubstitutuion( AggrInst * inst ) {
-                assert( inst );
-                assert( inst->get_baseParameters() );
-                std::list< TypeDecl * > baseParams = *inst->get_baseParameters();
-                std::list< Expression * > typeSubs = inst->get_parameters();
-                TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
-                return subs;
-        }
-
-        ReferenceToType * isStructOrUnion( Type * type ) {
-                if ( StructInstType * sit = dynamic_cast< StructInstType * >( type ) ) {
-                        return sit;
-                } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( type ) ) {
-                        return uit;
-                }
-                return nullptr;
-        }
-
-        void Resolver::resolveSingleAggrInit( Declaration * dcl, InitIterator & init, InitIterator & initEnd, TypeSubstitution sub ) {
+        void Resolver::resolveSingleAggrInit( Declaration * dcl, InitIterator & init, InitIterator & initEnd ) {
                 DeclarationWithType * dt = dynamic_cast< DeclarationWithType * >( dcl );
                 assert( dt );
-                // need to substitute for generic types, so that casts are to concrete types
-                initContext = dt->get_type()->clone();
-                sub.apply( initContext );
-
+                initContext = dt->get_type();
                 try {
                         if ( init == initEnd ) return; // stop when there are no more initializers
@@ -434 +406 @@
                 } catch( SemanticError & ) {
                         // need to delve deeper, if you can
-                        if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
-                                resolveAggrInit( type, init, initEnd );
+                        if ( StructInstType * sit = dynamic_cast< StructInstType * >( dt->get_type() ) ) {
+                                resolveAggrInit( sit->get_baseStruct(), init, initEnd );
+                        } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( dt->get_type() ) ) {
+                                resolveAggrInit( uit->get_baseUnion(), init, initEnd );
                         } else {
                                 // member is not an aggregate type, so can't go any deeper
@@ -445 +419 @@
         }
 
-        void Resolver::resolveAggrInit( ReferenceToType * inst, InitIterator & init, InitIterator & initEnd ) {
-                if ( StructInstType * sit = dynamic_cast< StructInstType * >( inst ) ) {
-                        TypeSubstitution sub = makeGenericSubstitutuion( sit );
-                        StructDecl * st = sit->get_baseStruct();
+        void Resolver::resolveAggrInit( AggregateDecl * aggr, InitIterator & init, InitIterator & initEnd ) {
+                if ( StructDecl * st = dynamic_cast< StructDecl * >( aggr ) ) {
                         // want to resolve each initializer to the members of the struct,
                         // but if there are more initializers than members we should stop
                         list< Declaration * >::iterator it = st->get_members().begin();
                         for ( ; it != st->get_members().end(); ++it) {
-                                resolveSingleAggrInit( *it, init, initEnd, sub );
+                                resolveSingleAggrInit( *it, init, initEnd );
                         }
-                } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( inst ) ) {
-                        TypeSubstitution sub = makeGenericSubstitutuion( uit );
-                        UnionDecl * un = uit->get_baseUnion();
+                } else if ( UnionDecl * un = dynamic_cast< UnionDecl * >( aggr ) ) {
                         // only resolve to the first member of a union
-                        resolveSingleAggrInit( *un->get_members().begin(), init, initEnd, sub );
+                        resolveSingleAggrInit( *un->get_members().begin(), init, initEnd );
                 } // if
         }
@@ -479 +449 @@
                                 (*iter++)->accept( *this );
                         }
-                } else if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
-                        resolveAggrInit( type, iter, end );
+                } else if ( StructInstType * st = dynamic_cast< StructInstType * >( initContext ) ) {
+                        resolveAggrInit( st->get_baseStruct(), iter, end );
+                } else if ( UnionInstType * st = dynamic_cast< UnionInstType * >( initContext ) ) {
+                        resolveAggrInit( st->get_baseUnion(), iter, end );
                 } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
                         Type * base = tt->get_baseType()->get_base();
@@ -489 +461 @@
                         } else {
                                 // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
-                                Parent::visit( listInit );
+                                Visitor::visit( listInit );
                         }
                 } else {
                         assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext )
-                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) || dynamic_cast < EnumInstType * > ( initContext ) );
+                                || dynamic_cast< ZeroType * >( initContext ) || dynamic_cast< OneType * >( initContext ) );
                         // basic types are handled here
-                        Parent::visit( listInit );
+                        Visitor::visit( listInit );
                 }
 
@@ -561 +533 @@
         }
 
-        // needs to be callable from outside the resolver, so this is a standalone function
-        void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ) {
-                assert( ctorInit );
-                Resolver resolver( indexer );
-                ctorInit->accept( resolver );
-        }
-
-        void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ) {
-                assert( stmtExpr );
-                Resolver resolver( indexer );
-                stmtExpr->accept( resolver );
-        }
-
         void Resolver::visit( ConstructorInit *ctorInit ) {
                 // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit

src/ResolvExpr/Resolver.h

@@ -25 +25 @@
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
         Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
-        void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
-        void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );
 } // namespace ResolvExpr
 

src/ResolvExpr/TypeEnvironment.cc

@@ -32 +32 @@
         //
         // I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this comparator.
-        bool AssertCompare::operator()( DeclarationWithType * d1, DeclarationWithType * d2 ) const {
+        bool AssertCompare::operator()( DeclarationWithType * d1, DeclarationWithType * d2 ) {
                         // Objects are always less than functions
                         if ( ObjectDecl * objectDecl1 = dynamic_cast< ObjectDecl * >( d1 ) ) {
@@ -94 +94 @@
                 dest.type = maybeClone( src.type );
                 dest.allowWidening = src.allowWidening;
-                dest.data = src.data;
+                dest.kind = src.kind;
         }
 
@@ -162 +162 @@
                         EqvClass newClass;
                         newClass.vars.insert( (*i)->get_name() );
-                        newClass.data = TypeDecl::Data{ (*i) };
+                        newClass.kind = (*i)->get_kind();
                         env.push_back( newClass );
                 } // for
@@ -177 +177 @@
                                         sub.add( *theVar, theClass->type );
                                 } else if ( theVar != theClass->vars.begin() ) {
-                                        TypeInstType *newTypeInst = new TypeInstType( Type::Qualifiers(), *theClass->vars.begin(), theClass->data.kind == TypeDecl::Ftype );
+                                        TypeInstType *newTypeInst = new TypeInstType( Type::Qualifiers(), *theClass->vars.begin(), theClass->kind == TypeDecl::Ftype );
 ///         std::cout << " bound to variable " << *theClass->vars.begin() << std::endl;
                                         sub.add( *theVar, newTypeInst );
@@ -243 +243 @@
                 for ( std::list< EqvClass >::const_iterator eqvClass = env.begin(); eqvClass != env.end(); ++eqvClass ) {
                         for ( std::set< std::string >::const_iterator var = eqvClass->vars.begin(); var != eqvClass->vars.end(); ++var ) {
-                                openVars[ *var ] = eqvClass->data;
+                                openVars[ *var ] = eqvClass->kind;
                         } // for
                 } // for

src/ResolvExpr/TypeEnvironment.h

@@ -29 +29 @@
 namespace ResolvExpr {
         struct AssertCompare {
-                bool operator()( DeclarationWithType * d1, DeclarationWithType * d2 ) const;
+                bool operator()( DeclarationWithType * d1, DeclarationWithType * d2 );
         };
         typedef std::map< DeclarationWithType*, bool, AssertCompare > AssertionSet;
-        typedef std::map< std::string, TypeDecl::Data > OpenVarSet;
+        typedef std::map< std::string, TypeDecl::Kind > OpenVarSet;
 
         void printAssertionSet( const AssertionSet &, std::ostream &, int indent = 0 );
@@ -41 +41 @@
                 Type *type;
                 bool allowWidening;
-                TypeDecl::Data data;
+                TypeDecl::Kind kind;
 
                 void initialize( const EqvClass &src, EqvClass &dest );

src/ResolvExpr/Unify.cc

@@ -99 +99 @@
                 newFirst->get_qualifiers() = Type::Qualifiers();
                 newSecond->get_qualifiers() = Type::Qualifiers();
-///   std::cerr << "first is ";
-///   first->print( std::cerr );
-///   std::cerr << std::endl << "second is ";
-///   second->print( std::cerr );
-///   std::cerr << std::endl << "newFirst is ";
-///   newFirst->print( std::cerr );
-///   std::cerr << std::endl << "newSecond is ";
-///   newSecond->print( std::cerr );
-///   std::cerr << std::endl;
+///   std::cout << "first is ";
+///   first->print( std::cout );
+///   std::cout << std::endl << "second is ";
+///   second->print( std::cout );
+///   std::cout << std::endl << "newFirst is ";
+///   newFirst->print( std::cout );
+///   std::cout << std::endl << "newSecond is ";
+///   newSecond->print( std::cout );
+///   std::cout << std::endl;
                 bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
                 delete newFirst;
@@ -123 +123 @@
         }
 
-        struct CompleteTypeChecker : public Visitor {
-                virtual void visit( VoidType *basicType ) { status = false; }
-                virtual void visit( BasicType *basicType ) {}
-                virtual void visit( PointerType *pointerType ) {}
-                virtual void visit( ArrayType *arrayType ) { status = ! arrayType->get_isVarLen(); }
-                virtual void visit( FunctionType *functionType ) {}
-                virtual void visit( StructInstType *aggregateUseType ) { status = aggregateUseType->get_baseStruct()->has_body(); }
-                virtual void visit( UnionInstType *aggregateUseType ) { status = aggregateUseType->get_baseUnion()->has_body(); }
-                // xxx - enum inst does not currently contain a pointer to base, this should be fixed.
-                virtual void visit( EnumInstType *aggregateUseType ) { /* status = aggregateUseType->get_baseEnum()->hasBody(); */ }
-                virtual void visit( TraitInstType *aggregateUseType ) { assert( false ); }
-                virtual void visit( TypeInstType *aggregateUseType ) { status = aggregateUseType->get_baseType()->isComplete(); }
-                virtual void visit( TupleType *tupleType ) {} // xxx - not sure if this is right, might need to recursively check complete-ness
-                virtual void visit( TypeofType *typeofType ) { assert( false ); }
-                virtual void visit( AttrType *attrType ) { assert( false ); } // xxx - not sure what to do here
-                virtual void visit( VarArgsType *varArgsType ){} // xxx - is this right?
-                virtual void visit( ZeroType *zeroType ) {}
-                virtual void visit( OneType *oneType ) {}
-                bool status = true;
-        };
-        bool isComplete( Type * type ) {
-                CompleteTypeChecker checker;
-                assert( type );
-                type->accept( checker );
-                return checker.status;
-        }
-
-        bool tyVarCompatible( const TypeDecl::Data & data, Type *type, const SymTab::Indexer &indexer ) {
-                switch ( data.kind ) {
+        bool tyVarCompatible( TypeDecl::Kind kind, Type *type, const SymTab::Indexer &indexer ) {
+                switch ( kind ) {
                   case TypeDecl::Any:
                   case TypeDecl::Dtype:
-                        // to bind to an object type variable, the type must not be a function type.
-                        // if the type variable is specified to be a complete type then the incoming
-                        // type must also be complete
-                        return ! isFtype( type, indexer ) && (! data.isComplete || isComplete( type ));
+                        return ! isFtype( type, indexer );
+
                   case TypeDecl::Ftype:
                         return isFtype( type, indexer );
@@ -165 +136 @@
         }
 
-        bool bindVar( TypeInstType *typeInst, Type *other, const TypeDecl::Data & data, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
+        bool bindVar( TypeInstType *typeInst, Type *other, TypeDecl::Kind kind, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
                 OpenVarSet::const_iterator tyvar = openVars.find( typeInst->get_name() );
                 assert( tyvar != openVars.end() );
@@ -204 +175 @@
                         newClass.type->get_qualifiers() = Type::Qualifiers();
                         newClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
-                        newClass.data = data;
+                        newClass.kind = kind;
                         env.add( newClass );
                 } // if
@@ -210 +181 @@
         }
 
-        bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, const TypeDecl::Data & data, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
+        bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, TypeDecl::Kind kind, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
                 bool result = true;
                 EqvClass class1, class2;
@@ -239 +210 @@
 
                 if ( type1 && type2 ) {
-//    std::cerr << "has type1 && type2" << std::endl;
+//    std::cout << "has type1 && type2" << std::endl;
                         WidenMode newWidenMode ( widen1, widen2 );
                         Type *common = 0;
@@ -277 +248 @@
                         newClass.vars.insert( var2->get_name() );
                         newClass.allowWidening = widen1 && widen2;
-                        newClass.data = data;
+                        newClass.kind = kind;
                         env.add( newClass );
                 } // if
@@ -340 +311 @@
                 } // if
 #ifdef DEBUG
-                std::cerr << "============ unifyExact" << std::endl;
-                std::cerr << "type1 is ";
-                type1->print( std::cerr );
-                std::cerr << std::endl << "type2 is ";
-                type2->print( std::cerr );
-                std::cerr << std::endl << "openVars are ";
-                printOpenVarSet( openVars, std::cerr, 8 );
-                std::cerr << std::endl << "input env is " << std::endl;
-                debugEnv.print( std::cerr, 8 );
-                std::cerr << std::endl << "result env is " << std::endl;
-                env.print( std::cerr, 8 );
-                std::cerr << "result is " << result << std::endl;
+                std::cout << "============ unifyExact" << std::endl;
+                std::cout << "type1 is ";
+                type1->print( std::cout );
+                std::cout << std::endl << "type2 is ";
+                type2->print( std::cout );
+                std::cout << std::endl << "openVars are ";
+                printOpenVarSet( openVars, std::cout, 8 );
+                std::cout << std::endl << "input env is " << std::endl;
+                debugEnv.print( std::cout, 8 );
+                std::cout << std::endl << "result env is " << std::endl;
+                env.print( std::cout, 8 );
+                std::cout << "result is " << result << std::endl;
 #endif
                 return result;
@@ -366 +337 @@
                 bool result;
 #ifdef DEBUG
-                std::cerr << "unifyInexact type 1 is ";
-                type1->print( std::cerr );
-                std::cerr << "type 2 is ";
-                type2->print( std::cerr );
-                std::cerr << std::endl;
+                std::cout << "unifyInexact type 1 is ";
+                type1->print( std::cout );
+                std::cout << "type 2 is ";
+                type2->print( std::cout );
+                std::cout << std::endl;
 #endif
                 if ( ! unifyExact( type1, type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer ) ) {
 #ifdef DEBUG
-                        std::cerr << "unifyInexact: no exact unification found" << std::endl;
+                        std::cout << "unifyInexact: no exact unification found" << std::endl;
 #endif
                         if ( ( common = commonType( type1, type2, widenMode.widenFirst, widenMode.widenSecond, indexer, env, openVars ) ) ) {
                                 common->get_qualifiers() = tq1 + tq2;
 #ifdef DEBUG
-                                std::cerr << "unifyInexact: common type is ";
-                                common->print( std::cerr );
-                                std::cerr << std::endl;
+                                std::cout << "unifyInexact: common type is ";
+                                common->print( std::cout );
+                                std::cout << std::endl;
 #endif
                                 result = true;
                         } else {
 #ifdef DEBUG
-                                std::cerr << "unifyInexact: no common type found" << std::endl;
+                                std::cout << "unifyInexact: no common type found" << std::endl;
 #endif
                                 result = false;
@@ -423 +394 @@
 
         void markAssertionSet( AssertionSet &assertions, DeclarationWithType *assert ) {
-///   std::cerr << "assertion set is" << std::endl;
-///   printAssertionSet( assertions, std::cerr, 8 );
-///   std::cerr << "looking for ";
-///   assert->print( std::cerr );
-///   std::cerr << std::endl;
+///   std::cout << "assertion set is" << std::endl;
+///   printAssertionSet( assertions, std::cout, 8 );
+///   std::cout << "looking for ";
+///   assert->print( std::cout );
+///   std::cout << std::endl;
                 AssertionSet::iterator i = assertions.find( assert );
                 if ( i != assertions.end() ) {
-///     std::cerr << "found it!" << std::endl;
+///     std::cout << "found it!" << std::endl;
                         i->second = true;
                 } // if

src/ResolvExpr/Unify.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Unify.h --
+// Unify.h -- 
 //
 // Author           : Richard C. Bilson
@@ -37 +37 @@
                 bool widenFirst : 1, widenSecond : 1;
         };
-
-        bool bindVar( TypeInstType *typeInst, Type *other, const TypeDecl::Data & data, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
+        
+        bool bindVar( TypeInstType *typeInst, Type *other, TypeDecl::Kind kind, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
         bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer );
         bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer, Type *&commonType );

src/SymTab/Autogen.cc

@@ -24 +24 @@
 #include "MakeLibCfa.h"
 #include "Autogen.h"
-#include "GenPoly/ScopedSet.h"
-#include "SymTab/Mangler.h"
-#include "GenPoly/DeclMutator.h"
 
 namespace SymTab {
@@ -32 +29 @@
 
         class AutogenerateRoutines : public Visitor {
-          public:
+                public:
                 std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
-
-                typedef Visitor Parent;
-                using Parent::visit;
 
                 virtual void visit( EnumDecl *enumDecl );
@@ -51 +45 @@
                 virtual void visit( SwitchStmt *switchStmt );
 
-          private:
+                AutogenerateRoutines() : functionNesting( 0 ) {}
+                private:
                 template< typename StmtClass > void visitStatement( StmtClass *stmt );
 
                 std::list< Declaration * > declsToAdd;
                 std::set< std::string > structsDone;
-                unsigned int functionNesting = 0;     // current level of nested functions
+                unsigned int functionNesting;     // current level of nested functions
         };
 
-        /// generates routines for tuple types.
-        /// Doesn't really need to be a mutator, but it's easier to reuse DeclMutator than it is to use AddVisit
-        /// or anything we currently have that supports adding new declarations for visitors
-        class AutogenTupleRoutines : public GenPoly::DeclMutator {
-          public:
-                typedef GenPoly::DeclMutator Parent;
-                using Parent::mutate;
-
-                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
-
-                virtual Type * mutate( TupleType *tupleType );
-
-                virtual CompoundStmt * mutate( CompoundStmt *compoundStmt );
-
-          private:
-                unsigned int functionNesting = 0;     // current level of nested functions
-                GenPoly::ScopedSet< std::string > seenTuples;
-        };
-
         void autogenerateRoutines( std::list< Declaration * > &translationUnit ) {
-                AutogenerateRoutines generator;
-                acceptAndAdd( translationUnit, generator, false );
-
-                // needs to be done separately because AutogenerateRoutines skips types that appear as function arguments, etc.
-                // AutogenTupleRoutines tupleGenerator;
-                // tupleGenerator.mutateDeclarationList( translationUnit );
+                AutogenerateRoutines visitor;
+                acceptAndAdd( translationUnit, visitor, false );
         }
 
@@ -91 +63 @@
         }
 
-        /// inserts a forward declaration for functionDecl into declsToAdd
-        void addForwardDecl( FunctionDecl * functionDecl, std::list< Declaration * > & declsToAdd ) {
-                FunctionDecl * decl = functionDecl->clone();
-                delete decl->get_statements();
-                decl->set_statements( NULL );
-                declsToAdd.push_back( decl );
-                decl->fixUniqueId();
-        }
-
-        /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *)
-        FunctionType * genDefaultType( Type * paramType ) {
-                FunctionType *ftype = new FunctionType( Type::Qualifiers(), false );
-                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), paramType->clone() ), nullptr );
-                ftype->get_parameters().push_back( dstParam );
-
-                return ftype;
-        }
-
-        /// given type T, generate type of copy ctor, i.e. function type void (*) (T *, T)
-        FunctionType * genCopyType( Type * paramType ) {
-                FunctionType *ftype = genDefaultType( paramType );
-                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
-                ftype->get_parameters().push_back( srcParam );
-                return ftype;
-        }
-
-        /// given type T, generate type of assignment, i.e. function type T (*) (T *, T)
-        FunctionType * genAssignType( Type * paramType ) {
-                FunctionType *ftype = genCopyType( paramType );
-                ObjectDecl *returnVal = new ObjectDecl( "_ret", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
-                ftype->get_returnVals().push_back( returnVal );
-                return ftype;
-        }
-
-        /// true if the aggregate's layout is dynamic
-        template< typename AggrDecl >
-        bool hasDynamicLayout( AggrDecl * aggregateDecl ) {
-                for ( TypeDecl * param : aggregateDecl->get_parameters() ) {
-                        if ( param->get_kind() == TypeDecl::Any ) return true;
-                }
-                return false;
-        }
-
-        /// generate a function decl from a name and type. Nesting depth determines whether
-        /// the declaration is static or not; optional paramter determines if declaration is intrinsic
-        FunctionDecl * genFunc( const std::string & fname, FunctionType * ftype, unsigned int functionNesting, bool isIntrinsic = false  ) {
-                // Routines at global scope marked "static" to prevent multiple definitions in separate translation units
+        template< typename OutputIterator >
+        void makeUnionFieldsAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, OutputIterator out ) {
+                UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
+                copy->get_args().push_back( new VariableExpr( dstParam ) );
+                copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
+                copy->get_args().push_back( new SizeofExpr( srcParam->get_type()->clone() ) );
+
+                *out++ = new ExprStmt( noLabels, copy );
+        }
+
+        //E ?=?(E volatile*, int),
+        //  ?=?(E _Atomic volatile*, int);
+        void makeEnumFunctions( EnumDecl *enumDecl, EnumInstType *refType, unsigned int functionNesting, std::list< Declaration * > &declsToAdd ) {
+                FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
+
+                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), refType ), 0 );
+                assignType->get_parameters().push_back( dstParam );
+
+                // void ?{}(E *); void ^?{}(E *);
+                FunctionType * ctorType = assignType->clone();
+                FunctionType * dtorType = assignType->clone();
+
+                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
+                assignType->get_parameters().push_back( srcParam );
+                // void ?{}(E *, E);
+                FunctionType *copyCtorType = assignType->clone();
+
+                // T ?=?(E *, E);
+                ObjectDecl *returnVal = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
+                assignType->get_returnVals().push_back( returnVal );
+
+                // xxx - should we also generate void ?{}(E *, int) and E ?{}(E *, E)?
+                // right now these cases work, but that might change.
+
+                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
                 // because each unit generates copies of the default routines for each aggregate.
-                DeclarationNode::StorageClass sc = functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static;
-                LinkageSpec::Spec spec = isIntrinsic ? LinkageSpec::Intrinsic : LinkageSpec::AutoGen;
-                FunctionDecl * decl = new FunctionDecl( fname, sc, spec, ftype, new CompoundStmt( noLabels ), true, false );
-                decl->fixUniqueId();
-                return decl;
-        }
-
-        /// generates a single enumeration assignment expression
-        ApplicationExpr * genEnumAssign( FunctionType * ftype, FunctionDecl * assignDecl ) {
+                // xxx - Temporary: make these functions intrinsic so they codegen as C assignment.
+                // Really they're something of a cross between instrinsic and autogen, so should
+                // probably make a new linkage type
+                FunctionDecl *assignDecl = new FunctionDecl( "?=?", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::Intrinsic, assignType, new CompoundStmt( noLabels ), true, false );
+                FunctionDecl *ctorDecl = new FunctionDecl( "?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::Intrinsic, ctorType, new CompoundStmt( noLabels ), true, false );
+                FunctionDecl *copyCtorDecl = new FunctionDecl( "?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::Intrinsic, copyCtorType, new CompoundStmt( noLabels ), true, false );
+                FunctionDecl *dtorDecl = new FunctionDecl( "^?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::Intrinsic, dtorType, new CompoundStmt( noLabels ), true, false );
+                assignDecl->fixUniqueId();
+                ctorDecl->fixUniqueId();
+                copyCtorDecl->fixUniqueId();
+                dtorDecl->fixUniqueId();
+
                 // enum copy construct and assignment is just C-style assignment.
                 // this looks like a bad recursive call, but code gen will turn it into
                 // a C-style assignment.
                 // This happens before function pointer type conversion, so need to do it manually here
-                // NOTE: ftype is not necessarily the functionType belonging to assignDecl - ftype is the
-                // type of the function that this expression is being generated for (so that the correct
-                // parameters) are using in the variable exprs
-                assert( ftype->get_parameters().size() == 2 );
-                ObjectDecl * dstParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
-                ObjectDecl * srcParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
-
                 VariableExpr * assignVarExpr = new VariableExpr( assignDecl );
                 Type * assignVarExprType = assignVarExpr->get_result();
@@ -166 +122 @@
                 assignExpr->get_args().push_back( new VariableExpr( dstParam ) );
                 assignExpr->get_args().push_back( new VariableExpr( srcParam ) );
-                return assignExpr;
-        }
-
-        // E ?=?(E volatile*, int),
-        //   ?=?(E _Atomic volatile*, int);
-        void makeEnumFunctions( EnumDecl *enumDecl, EnumInstType *refType, unsigned int functionNesting, std::list< Declaration * > &declsToAdd ) {
-
-                // T ?=?(E *, E);
-                FunctionType *assignType = genAssignType( refType );
-
-                // void ?{}(E *); void ^?{}(E *);
-                FunctionType * ctorType = genDefaultType( refType->clone() );
-                FunctionType * dtorType = genDefaultType( refType->clone() );
-
-                // void ?{}(E *, E);
-                FunctionType *copyCtorType = genCopyType( refType->clone() );
-
-                // xxx - should we also generate void ?{}(E *, int) and E ?{}(E *, E)?
-                // right now these cases work, but that might change.
-
-                // xxx - Temporary: make these functions intrinsic so they codegen as C assignment.
-                // Really they're something of a cross between instrinsic and autogen, so should
-                // probably make a new linkage type
-                FunctionDecl *assignDecl = genFunc( "?=?", assignType, functionNesting, true );
-                FunctionDecl *ctorDecl = genFunc( "?{}", ctorType, functionNesting, true );
-                FunctionDecl *copyCtorDecl = genFunc( "?{}", copyCtorType, functionNesting, true );
-                FunctionDecl *dtorDecl = genFunc( "^?{}", dtorType, functionNesting, true );
 
                 // body is either return stmt or expr stmt
-                assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, genEnumAssign( assignType, assignDecl ) ) );
-                copyCtorDecl->get_statements()->get_kids().push_back( new ExprStmt( noLabels, genEnumAssign( copyCtorType, assignDecl ) ) );
-
+                assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, assignExpr ) );
+                copyCtorDecl->get_statements()->get_kids().push_back( new ExprStmt( noLabels, assignExpr->clone() ) );
+
+                declsToAdd.push_back( assignDecl );
                 declsToAdd.push_back( ctorDecl );
                 declsToAdd.push_back( copyCtorDecl );
                 declsToAdd.push_back( dtorDecl );
-                declsToAdd.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return
-        }
-
-        /// generates a single struct member operation (constructor call, destructor call, assignment call)
-        void makeStructMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool isDynamicLayout, bool forward = true ) {
+        }
+
+        /// Clones a reference type, replacing any parameters it may have with a clone of the provided list
+        template< typename GenericInstType >
+        GenericInstType *cloneWithParams( GenericInstType *refType, const std::list< Expression* >& params ) {
+                GenericInstType *clone = refType->clone();
+                clone->get_parameters().clear();
+                cloneAll( params, clone->get_parameters() );
+                return clone;
+        }
+
+        /// Creates a new type decl that's the same as src, but renamed and with only the ?=?, ?{} (default and copy), and ^?{} assertions (for complete types only)
+        TypeDecl *cloneAndRename( TypeDecl *src, const std::string &name ) {
+                // TypeDecl *dst = new TypeDecl( name, src->get_storageClass(), 0, src->get_kind() );
+
+                // if ( src->get_kind() == TypeDecl::Any ) {
+                //      TypeInstType *opParamType = new TypeInstType( Type::Qualifiers(), name, dst );
+                //      FunctionType *opFunctionType = new FunctionType( Type::Qualifiers(), false );
+                //      opFunctionType->get_parameters().push_back(
+                //              new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), opParamType->clone() ), 0 ) );
+                //      FunctionDecl *ctorAssert = new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, opFunctionType->clone(), 0, false, false );
+                //      FunctionDecl *dtorAssert = new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, opFunctionType->clone(), 0, false, false );
+
+                //      opFunctionType->get_parameters().push_back(
+                //              new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, opParamType, 0 ) );
+                //      FunctionDecl *copyCtorAssert = new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, opFunctionType->clone(), 0, false, false );
+
+                //      opFunctionType->get_returnVals().push_back(
+                //              new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, opParamType->clone(), 0 ) );
+                //      FunctionDecl *assignAssert = new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, opFunctionType, 0, false, false );
+
+
+                //      dst->get_assertions().push_back( assignAssert );
+                //      dst->get_assertions().push_back( ctorAssert );
+                //      dst->get_assertions().push_back( dtorAssert );
+                //      dst->get_assertions().push_back( copyCtorAssert );
+                // }
+
+                TypeDecl *dst = new TypeDecl( src->get_name(), src->get_storageClass(), 0, src->get_kind() );
+                cloneAll(src->get_assertions(), dst->get_assertions());
+                return dst;
+        }
+
+        void makeStructMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, TypeSubstitution & genericSubs, bool isDynamicLayout, bool forward = true ) {
+//              if ( isDynamicLayout && src ) {
+//                      genericSubs.apply( src );
+//              }
+
                 ObjectDecl * returnVal = NULL;
                 if ( ! func->get_functionType()->get_returnVals().empty() ) {
@@ -214 +187 @@
 
                 // assign to destination (and return value if generic)
-                UntypedExpr *derefExpr = UntypedExpr::createDeref( new VariableExpr( dstParam ) );
+                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
+                derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
                 Expression *dstselect = new MemberExpr( field, derefExpr );
                 genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
 
                 if ( isDynamicLayout && returnVal ) {
-                        // xxx - there used to be a dereference on returnVal, but this seems to have been wrong?
-                        Expression *retselect = new MemberExpr( field, new VariableExpr( returnVal ) );
+                        UntypedExpr *derefRet = new UntypedExpr( new NameExpr( "*?" ) );
+                        derefRet->get_args().push_back( new VariableExpr( returnVal ) );
+                        Expression *retselect = new MemberExpr( field, derefRet );
                         genImplicitCall( srcParam, retselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
                 } // if
         }
 
-        /// generates the body of a struct function by iterating the struct members (via parameters) - generates default ctor, copy ctor, assignment, and dtor bodies, but NOT field ctor bodies
         template<typename Iterator>
-        void makeStructFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool isDynamicLayout, bool forward = true ) {
+        void makeStructFunctionBody( Iterator member, Iterator end, FunctionDecl * func, TypeSubstitution & genericSubs, bool isDynamicLayout, bool forward = true ) {
                 for ( ; member != end; ++member ) {
                         if ( DeclarationWithType *field = dynamic_cast< DeclarationWithType * >( *member ) ) { // otherwise some form of type declaration, e.g. Aggregate
@@ -263 +237 @@
 
                                 Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : NULL;
-                                makeStructMemberOp( dstParam, srcselect, field, func, isDynamicLayout, forward );
+                                makeStructMemberOp( dstParam, srcselect, field, func, genericSubs, isDynamicLayout, forward );
                         } // if
                 } // for
@@ -271 +245 @@
         /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields.
         template<typename Iterator>
-        void makeStructFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func, bool isDynamicLayout ) {
+        void makeStructFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func, TypeSubstitution & genericSubs, bool isDynamicLayout ) {
                 FunctionType * ftype = func->get_functionType();
                 std::list<DeclarationWithType*> & params = ftype->get_parameters();
@@ -297 +271 @@
                                         // matching parameter, initialize field with copy ctor
                                         Expression *srcselect = new VariableExpr(*parameter);
-                                        makeStructMemberOp( dstParam, srcselect, field, func, isDynamicLayout );
+                                        makeStructMemberOp( dstParam, srcselect, field, func, genericSubs, isDynamicLayout );
                                         ++parameter;
                                 } else {
                                         // no matching parameter, initialize field with default ctor
-                                        makeStructMemberOp( dstParam, NULL, field, func, isDynamicLayout );
+                                        makeStructMemberOp( dstParam, NULL, field, func, genericSubs, isDynamicLayout );
                                 }
                         }
@@ -307 +281 @@
         }
 
-        /// generates struct constructors, destructor, and assignment functions
+        void addForwardDecl( FunctionDecl * functionDecl, std::list< Declaration * > & declsToAdd ) {
+                FunctionDecl * decl = functionDecl->clone();
+                delete decl->get_statements();
+                decl->set_statements( NULL );
+                declsToAdd.push_back( decl );
+                decl->fixUniqueId();
+        }
+
         void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd ) {
+                FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
 
                 // Make function polymorphic in same parameters as generic struct, if applicable
-                const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
-                bool isDynamicLayout = hasDynamicLayout( aggregateDecl );  // NOTE this flag is an incredibly ugly kludge; we should fix the assignment signature instead (ditto for union)
+                bool isDynamicLayout = false;  // NOTE this flag is an incredibly ugly kludge; we should fix the assignment signature instead (ditto for union)
+                std::list< TypeDecl* >& genericParams = aggregateDecl->get_parameters();
+                std::list< Expression* > structParams;  // List of matching parameters to put on types
+                TypeSubstitution genericSubs; // Substitutions to make to member types of struct
+                for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) {
+                        if ( (*param)->get_kind() == TypeDecl::Any ) isDynamicLayout = true;
+                        TypeDecl *typeParam = cloneAndRename( *param, "_autoassign_" + aggregateDecl->get_name() + "_" + (*param)->get_name() );
+                        assignType->get_forall().push_back( typeParam );
+                        TypeInstType *newParamType = new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam );
+                        genericSubs.add( (*param)->get_name(), newParamType );
+                        structParams.push_back( new TypeExpr( newParamType ) );
+                }
+
+                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), cloneWithParams( refType, structParams ) ), 0 );
+                assignType->get_parameters().push_back( dstParam );
+
+                // void ?{}(T *); void ^?{}(T *);
+                FunctionType *ctorType = assignType->clone();
+                FunctionType *dtorType = assignType->clone();
+
+                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, structParams ), 0 );
+                assignType->get_parameters().push_back( srcParam );
+
+                // void ?{}(T *, T);
+                FunctionType *copyCtorType = assignType->clone();
 
                 // T ?=?(T *, T);
-                FunctionType *assignType = genAssignType( refType );
-                cloneAll( typeParams, assignType->get_forall() );
-
-                // void ?{}(T *); void ^?{}(T *);
-                FunctionType *ctorType = genDefaultType( refType );
-                cloneAll( typeParams, ctorType->get_forall() );
-                FunctionType *dtorType = genDefaultType( refType );
-                cloneAll( typeParams, dtorType->get_forall() );
-
-                // void ?{}(T *, T);
-                FunctionType *copyCtorType = genCopyType( refType );
-                cloneAll( typeParams, copyCtorType->get_forall() );
-
-                FunctionDecl *assignDecl = genFunc( "?=?", assignType, functionNesting );
-                FunctionDecl *ctorDecl = genFunc( "?{}", ctorType, functionNesting );
-                FunctionDecl *copyCtorDecl = genFunc( "?{}", copyCtorType, functionNesting );
-                FunctionDecl *dtorDecl = genFunc( "^?{}", dtorType, functionNesting );
+                ObjectDecl *returnVal = new ObjectDecl( "_ret", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, structParams ), 0 );
+                assignType->get_returnVals().push_back( returnVal );
+
+                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
+                // because each unit generates copies of the default routines for each aggregate.
+                FunctionDecl *assignDecl = new FunctionDecl( "?=?", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, assignType, new CompoundStmt( noLabels ), true, false );
+                FunctionDecl *ctorDecl = new FunctionDecl( "?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, ctorType, new CompoundStmt( noLabels ), true, false );
+                FunctionDecl *copyCtorDecl = new FunctionDecl( "?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, copyCtorType, new CompoundStmt( noLabels ), true, false );
+                FunctionDecl *dtorDecl = new FunctionDecl( "^?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, dtorType, new CompoundStmt( noLabels ), true, false );
+                assignDecl->fixUniqueId();
+                ctorDecl->fixUniqueId();
+                copyCtorDecl->fixUniqueId();
+                dtorDecl->fixUniqueId();
 
                 if ( functionNesting == 0 ) {
                         // forward declare if top-level struct, so that
                         // type is complete as soon as its body ends
-                        // Note: this is necessary if we want structs which contain
-                        // generic (otype) structs as members.
                         addForwardDecl( assignDecl, declsToAdd );
                         addForwardDecl( ctorDecl, declsToAdd );
@@ -366 +365 @@
                         }
                         memCtorType->get_parameters().push_back( new ObjectDecl( member->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, member->get_type()->clone(), 0 ) );
-                        FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting );
-                        makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor, isDynamicLayout );
+                        FunctionDecl * ctor = new FunctionDecl( "?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, memCtorType->clone(), new CompoundStmt( noLabels ), true, false );
+                        ctor->fixUniqueId();
+                        makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor, genericSubs, isDynamicLayout );
                         memCtors.push_back( ctor );
                 }
@@ -373 +373 @@
 
                 // generate appropriate calls to member ctor, assignment
-                makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), assignDecl, isDynamicLayout );
-                makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctorDecl, isDynamicLayout );
-                makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), copyCtorDecl, isDynamicLayout );
+                makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), assignDecl, genericSubs, isDynamicLayout );
+                makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctorDecl, genericSubs, isDynamicLayout );
+                makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), copyCtorDecl, genericSubs, isDynamicLayout );
                 // needs to do everything in reverse, so pass "forward" as false
-                makeStructFunctionBody( aggregateDecl->get_members().rbegin(), aggregateDecl->get_members().rend(), dtorDecl, isDynamicLayout, false );
-
-                assert( assignType->get_parameters().size() == 2 );
-                ObjectDecl * srcParam = safe_dynamic_cast< ObjectDecl * >( assignType->get_parameters().back() );
-                assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
-
+                makeStructFunctionBody( aggregateDecl->get_members().rbegin(), aggregateDecl->get_members().rend(), dtorDecl, genericSubs, isDynamicLayout, false );
+
+                if ( ! isDynamicLayout ) assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+
+                declsToAdd.push_back( assignDecl );
                 declsToAdd.push_back( ctorDecl );
                 declsToAdd.push_back( copyCtorDecl );
                 declsToAdd.push_back( dtorDecl );
-                declsToAdd.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return
                 declsToAdd.splice( declsToAdd.end(), memCtors );
         }
 
-        /// generate a single union assignment expression (using memcpy)
-        template< typename OutputIterator >
-        void makeUnionFieldsAssignment( ObjectDecl * srcParam, ObjectDecl * dstParam, OutputIterator out ) {
-                UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
-                copy->get_args().push_back( new VariableExpr( dstParam ) );
-                copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
-                copy->get_args().push_back( new SizeofExpr( srcParam->get_type()->clone() ) );
-                *out++ = new ExprStmt( noLabels, copy );
-        }
-
-        /// generates the body of a union assignment/copy constructor/field constructor
-        void makeUnionAssignBody( FunctionDecl * funcDecl, bool isDynamicLayout ) {
-                FunctionType * ftype = funcDecl->get_functionType();
-                assert( ftype->get_parameters().size() == 2 );
-                ObjectDecl * dstParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
-                ObjectDecl * srcParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
-                ObjectDecl * returnVal = nullptr;
-                if ( ! ftype->get_returnVals().empty() ) {
-                        returnVal = safe_dynamic_cast< ObjectDecl * >( ftype->get_returnVals().front() );
-                }
-
-                makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( funcDecl->get_statements()->get_kids() ) );
-                if ( returnVal ) {
-                        if ( isDynamicLayout ) makeUnionFieldsAssignment( srcParam, returnVal, back_inserter( funcDecl->get_statements()->get_kids() ) );
-                        else funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
-                }
-        }
-
-        /// generates union constructors, destructors, and assignment operator
         void makeUnionFunctions( UnionDecl *aggregateDecl, UnionInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd ) {
+                FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
+
                 // Make function polymorphic in same parameters as generic union, if applicable
-                const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
-                bool isDynamicLayout = hasDynamicLayout( aggregateDecl );  // NOTE this flag is an incredibly ugly kludge; we should fix the assignment signature instead (ditto for struct)
+                bool isDynamicLayout = false; // NOTE this flag is an incredibly ugly kludge; we should fix the assignment signature instead (ditto for struct)
+                std::list< TypeDecl* >& genericParams = aggregateDecl->get_parameters();
+                std::list< Expression* > unionParams;  // List of matching parameters to put on types
+                for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) {
+                        if ( (*param)->get_kind() == TypeDecl::Any ) isDynamicLayout = true;
+                        TypeDecl *typeParam = cloneAndRename( *param, "_autoassign_" + aggregateDecl->get_name() + "_" + (*param)->get_name() );
+                        assignType->get_forall().push_back( typeParam );
+                        unionParams.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ) ) );
+                }
+
+                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), cloneWithParams( refType, unionParams ) ), 0 );
+                assignType->get_parameters().push_back( dstParam );
 
                 // default ctor/dtor need only first parameter
-                // void ?{}(T *); void ^?{}(T *);
-                FunctionType *ctorType = genDefaultType( refType );
-                FunctionType *dtorType = genDefaultType( refType );
+                FunctionType * ctorType = assignType->clone();
+                FunctionType * dtorType = assignType->clone();
+
+                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, unionParams ), 0 );
+                assignType->get_parameters().push_back( srcParam );
 
                 // copy ctor needs both parameters
-                // void ?{}(T *, T);
-                FunctionType *copyCtorType = genCopyType( refType );
+                FunctionType * copyCtorType = assignType->clone();
 
                 // assignment needs both and return value
-                // T ?=?(T *, T);
-                FunctionType *assignType = genAssignType( refType );
-
-                cloneAll( typeParams, ctorType->get_forall() );
-                cloneAll( typeParams, dtorType->get_forall() );
-                cloneAll( typeParams, copyCtorType->get_forall() );
-                cloneAll( typeParams, assignType->get_forall() );
+                ObjectDecl *returnVal = new ObjectDecl( "_ret", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, unionParams ), 0 );
+                assignType->get_returnVals().push_back( returnVal );
 
                 // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
                 // because each unit generates copies of the default routines for each aggregate.
-                FunctionDecl *assignDecl = genFunc( "?=?", assignType, functionNesting );
-                FunctionDecl *ctorDecl = genFunc( "?{}",  ctorType, functionNesting );
-                FunctionDecl *copyCtorDecl = genFunc( "?{}", copyCtorType, functionNesting );
-                FunctionDecl *dtorDecl = genFunc( "^?{}", dtorType, functionNesting );
-
-                makeUnionAssignBody( assignDecl, isDynamicLayout );
+                FunctionDecl *assignDecl = new FunctionDecl( "?=?",  functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, assignType, new CompoundStmt( noLabels ), true, false );
+                FunctionDecl *ctorDecl = new FunctionDecl( "?{}",  functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, ctorType, new CompoundStmt( noLabels ), true, false );
+                FunctionDecl *copyCtorDecl = new FunctionDecl( "?{}",  functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, copyCtorType, NULL, true, false );
+                FunctionDecl *dtorDecl = new FunctionDecl( "^?{}",  functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, dtorType, new CompoundStmt( noLabels ), true, false );
+
+                assignDecl->fixUniqueId();
+                ctorDecl->fixUniqueId();
+                copyCtorDecl->fixUniqueId();
+                dtorDecl->fixUniqueId();
+
+                makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                if ( isDynamicLayout ) makeUnionFieldsAssignment( srcParam, returnVal, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                else assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
 
                 // body of assignment and copy ctor is the same
-                makeUnionAssignBody( copyCtorDecl, isDynamicLayout );
+                copyCtorDecl->set_statements( assignDecl->get_statements()->clone() );
 
                 // create a constructor which takes the first member type as a parameter.
@@ -465 +449 @@
                                 FunctionType * memCtorType = ctorType->clone();
                                 memCtorType->get_parameters().push_back( srcParam );
-                                FunctionDecl * ctor = genFunc( "?{}", memCtorType, functionNesting );
-
-                                makeUnionAssignBody( ctor, isDynamicLayout );
+                                FunctionDecl * ctor = new FunctionDecl( "?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, memCtorType, new CompoundStmt( noLabels ), true, false );
+                                ctor->fixUniqueId();
+
+                                makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( ctor->get_statements()->get_kids() ) );
                                 memCtors.push_back( ctor );
                                 // only generate a ctor for the first field
@@ -474 +459 @@
                 }
 
+                declsToAdd.push_back( assignDecl );
                 declsToAdd.push_back( ctorDecl );
                 declsToAdd.push_back( copyCtorDecl );
                 declsToAdd.push_back( dtorDecl );
-                declsToAdd.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return
                 declsToAdd.splice( declsToAdd.end(), memCtors );
         }
@@ -493 +478 @@
                 if ( ! structDecl->get_members().empty() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
                         StructInstType structInst( Type::Qualifiers(), structDecl->get_name() );
-                        for ( TypeDecl * typeDecl : structDecl->get_parameters() ) {
-                                structInst.get_parameters().push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), typeDecl ) ) );
-                        }
                         structInst.set_baseStruct( structDecl );
                         makeStructFunctions( structDecl, &structInst, functionNesting, declsToAdd );
@@ -506 +488 @@
                         UnionInstType unionInst( Type::Qualifiers(), unionDecl->get_name() );
                         unionInst.set_baseUnion( unionDecl );
-                        for ( TypeDecl * typeDecl : unionDecl->get_parameters() ) {
-                                unionInst.get_parameters().push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), typeDecl ) ) );
-                        }
                         makeUnionFunctions( unionDecl, &unionInst, functionNesting, declsToAdd );
                 } // if
@@ -514 +493 @@
 
         void AutogenerateRoutines::visit( TypeDecl *typeDecl ) {
+                CompoundStmt *stmts = 0;
                 TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false );
                 typeInst->set_baseType( typeDecl );
-                ObjectDecl *src = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, typeInst->clone(), nullptr );
-                ObjectDecl *dst = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), typeInst->clone() ), nullptr );
-
-                std::list< Statement * > stmts;
+                ObjectDecl *src = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, typeInst->clone(), 0 );
+                ObjectDecl *dst = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), typeInst->clone() ), 0 );
                 if ( typeDecl->get_base() ) {
                         // xxx - generate ctor/dtors for typedecls, e.g.
                         // otype T = int *;
+                        stmts = new CompoundStmt( std::list< Label >() );
                         UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
                         assign->get_args().push_back( new CastExpr( new VariableExpr( dst ), new PointerType( Type::Qualifiers(), typeDecl->get_base()->clone() ) ) );
                         assign->get_args().push_back( new CastExpr( new VariableExpr( src ), typeDecl->get_base()->clone() ) );
-                        stmts.push_back( new ReturnStmt( std::list< Label >(), assign ) );
+                        stmts->get_kids().push_back( new ReturnStmt( std::list< Label >(), assign ) );
                 } // if
                 FunctionType *type = new FunctionType( Type::Qualifiers(), false );
@@ -532 +511 @@
                 type->get_parameters().push_back( dst );
                 type->get_parameters().push_back( src );
-                FunctionDecl *func = genFunc( "?=?", type, functionNesting );
-                func->get_statements()->get_kids() = stmts;
+                FunctionDecl *func = new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::AutoGen, type, stmts, true, false );
                 declsToAdd.push_back( func );
         }
@@ -578 +556 @@
                 visitStatement( switchStmt );
         }
-
-        void makeTupleFunctionBody( FunctionDecl * function ) {
-                FunctionType * ftype = function->get_functionType();
-                assertf( ftype->get_parameters().size() == 1 || ftype->get_parameters().size() == 2, "too many parameters in generated tuple function" );
-
-                UntypedExpr * untyped = new UntypedExpr( new NameExpr( function->get_name() ) );
-
-                /// xxx - &* is used to make this easier for later passes to handle
-                untyped->get_args().push_back( new AddressExpr( UntypedExpr::createDeref( new VariableExpr( ftype->get_parameters().front() ) ) ) );
-                if ( ftype->get_parameters().size() == 2 ) {
-                        untyped->get_args().push_back( new VariableExpr( ftype->get_parameters().back() ) );
-                }
-                function->get_statements()->get_kids().push_back( new ExprStmt( noLabels, untyped ) );
-                function->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, UntypedExpr::createDeref( new VariableExpr( ftype->get_parameters().front() ) ) ) );
-        }
-
-        Type * AutogenTupleRoutines::mutate( TupleType * tupleType ) {
-                tupleType = safe_dynamic_cast< TupleType * >( Parent::mutate( tupleType ) );
-                std::string mangleName = SymTab::Mangler::mangleType( tupleType );
-                if ( seenTuples.find( mangleName ) != seenTuples.end() ) return tupleType;
-                seenTuples.insert( mangleName );
-
-                // T ?=?(T *, T);
-                FunctionType *assignType = genAssignType( tupleType );
-
-                // void ?{}(T *); void ^?{}(T *);
-                FunctionType *ctorType = genDefaultType( tupleType );
-                FunctionType *dtorType = genDefaultType( tupleType );
-
-                // void ?{}(T *, T);
-                FunctionType *copyCtorType = genCopyType( tupleType );
-
-                std::set< TypeDecl* > done;
-                std::list< TypeDecl * > typeParams;
-                for ( Type * t : *tupleType ) {
-                        if ( TypeInstType * ty = dynamic_cast< TypeInstType * >( t ) ) {
-                                if ( ! done.count( ty->get_baseType() ) ) {
-                                        TypeDecl * newDecl = new TypeDecl( ty->get_baseType()->get_name(), DeclarationNode::NoStorageClass, nullptr, TypeDecl::Any );
-                                        TypeInstType * inst = new TypeInstType( Type::Qualifiers(), newDecl->get_name(), newDecl );
-                                        newDecl->get_assertions().push_back( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genAssignType( inst ), nullptr, true, false ) );
-                                        newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genDefaultType( inst ), nullptr, true, false ) );
-                                        newDecl->get_assertions().push_back( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genCopyType( inst ), nullptr, true, false ) );
-                                        newDecl->get_assertions().push_back( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, genDefaultType( inst ), nullptr, true, false ) );
-                                        typeParams.push_back( newDecl );
-                                        done.insert( ty->get_baseType() );
-                                }
-                        }
-                }
-                cloneAll( typeParams, ctorType->get_forall() );
-                cloneAll( typeParams, dtorType->get_forall() );
-                cloneAll( typeParams, copyCtorType->get_forall() );
-                cloneAll( typeParams, assignType->get_forall() );
-
-                FunctionDecl *assignDecl = genFunc( "?=?", assignType, functionNesting );
-                FunctionDecl *ctorDecl = genFunc( "?{}", ctorType, functionNesting );
-                FunctionDecl *copyCtorDecl = genFunc( "?{}", copyCtorType, functionNesting );
-                FunctionDecl *dtorDecl = genFunc( "^?{}", dtorType, functionNesting );
-
-                makeTupleFunctionBody( assignDecl );
-                makeTupleFunctionBody( ctorDecl );
-                makeTupleFunctionBody( copyCtorDecl );
-                makeTupleFunctionBody( dtorDecl );
-
-                addDeclaration( ctorDecl );
-                addDeclaration( copyCtorDecl );
-                addDeclaration( dtorDecl );
-                addDeclaration( assignDecl ); // assignment should come last since it uses copy constructor in return
-
-                return tupleType;
-        }
-
-        DeclarationWithType * AutogenTupleRoutines::mutate( FunctionDecl *functionDecl ) {
-                functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
-                mutateAll( functionDecl->get_oldDecls(), *this );
-                functionNesting += 1;
-                functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
-                functionNesting -= 1;
-                return functionDecl;
-        }
-
-        CompoundStmt * AutogenTupleRoutines::mutate( CompoundStmt *compoundStmt ) {
-                seenTuples.beginScope();
-                compoundStmt = safe_dynamic_cast< CompoundStmt * >( Parent::mutate( compoundStmt ) );
-                seenTuples.endScope();
-                return compoundStmt;
-        }
 } // SymTab

src/SymTab/Indexer.cc

@@ -40 +40 @@
 
 namespace SymTab {
-        struct NewScope {
-                NewScope( SymTab::Indexer & indexer ) : indexer( indexer ) { indexer.enterScope(); }
-                ~NewScope() { indexer.leaveScope(); }
-                SymTab::Indexer & indexer;
-        };
-
         template< typename TreeType, typename VisitorType >
         inline void acceptNewScope( TreeType *tree, VisitorType &visitor ) {
@@ -460 +454 @@
         void Indexer::visit( TupleAssignExpr *tupleExpr ) {
                 acceptNewScope( tupleExpr->get_result(), *this );
-                maybeAccept( tupleExpr->get_stmtExpr(), *this );
+                enterScope();
+                acceptAll( tupleExpr->get_tempDecls(), *this );
+                acceptAll( tupleExpr->get_assigns(), *this );
+                leaveScope();
         }
 

src/SymTab/Indexer.h

@@ -25 +25 @@
         class Indexer : public Visitor {
           public:
-                explicit Indexer( bool useDebug = false );
+                Indexer( bool useDebug = false );
 
                 Indexer( const Indexer &that );

src/SymTab/Validate.cc

@@ -61 +61 @@
 #include <algorithm>
 #include "InitTweak/InitTweak.h"
-#include "CodeGen/CodeGenerator.h"
 
 #define debugPrint( x ) if ( doDebug ) { std::cout << x; }
 
 namespace SymTab {
-        class HoistStruct final : public Visitor {
+        class HoistStruct : public Visitor {
           public:
                 /// Flattens nested struct types
@@ -87 +86 @@
         };
 
-        /// Fix return types so that every function returns exactly one value
-        class ReturnTypeFixer final : public Visitor {
-          public:
-
-                typedef Visitor Parent;
-                using Parent::visit;
-
-                static void fix( std::list< Declaration * > &translationUnit );
-
-                virtual void visit( FunctionDecl * functionDecl );
-
-                virtual void visit( FunctionType * ftype );
-        };
-
         /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers.
-        class EnumAndPointerDecayPass final : public Visitor {
+        class EnumAndPointerDecayPass : public Visitor {
                 typedef Visitor Parent;
                 virtual void visit( EnumDecl *aggregateDecl );
@@ -109 +94 @@
 
         /// Associates forward declarations of aggregates with their definitions
-        class LinkReferenceToTypes final : public Indexer {
+        class Pass2 final : public Indexer {
                 typedef Indexer Parent;
           public:
-                LinkReferenceToTypes( bool doDebug, const Indexer *indexer );
+                Pass2( bool doDebug, const Indexer *indexer );
           private:
                 using Indexer::visit;
@@ -208 +193 @@
         void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
                 EnumAndPointerDecayPass epc;
-                LinkReferenceToTypes lrt( doDebug, 0 );
+                Pass2 pass2( doDebug, 0 );
                 Pass3 pass3( 0 );
                 CompoundLiteral compoundliteral;
@@ -214 +199 @@
                 EliminateTypedef::eliminateTypedef( translationUnit );
                 HoistStruct::hoistStruct( translationUnit );
-                ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
                 autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecayPass
                 acceptAll( translationUnit, epc );
-                acceptAll( translationUnit, lrt );
+                acceptAll( translationUnit, pass2 );
                 ReturnChecker::checkFunctionReturns( translationUnit );
                 compoundliteral.mutateDeclarationList( translationUnit );
@@ -226 +210 @@
         void validateType( Type *type, const Indexer *indexer ) {
                 EnumAndPointerDecayPass epc;
-                LinkReferenceToTypes lrt( false, indexer );
+                Pass2 pass2( false, indexer );
                 Pass3 pass3( indexer );
                 type->accept( epc );
-                type->accept( lrt );
+                type->accept( pass2 );
                 type->accept( pass3 );
         }
@@ -340 +324 @@
         }
 
-        LinkReferenceToTypes::LinkReferenceToTypes( bool doDebug, const Indexer *other_indexer ) : Indexer( doDebug ) {
+        Pass2::Pass2( bool doDebug, const Indexer *other_indexer ) : Indexer( doDebug ) {
                 if ( other_indexer ) {
                         indexer = other_indexer;
@@ -348 +332 @@
         }
 
-        void LinkReferenceToTypes::visit( StructInstType *structInst ) {
+        void Pass2::visit( StructInstType *structInst ) {
                 Parent::visit( structInst );
                 StructDecl *st = indexer->lookupStruct( structInst->get_name() );
@@ -362 +346 @@
         }
 
-        void LinkReferenceToTypes::visit( UnionInstType *unionInst ) {
+        void Pass2::visit( UnionInstType *unionInst ) {
                 Parent::visit( unionInst );
                 UnionDecl *un = indexer->lookupUnion( unionInst->get_name() );
@@ -375 +359 @@
         }
 
-        void LinkReferenceToTypes::visit( TraitInstType *contextInst ) {
+        void Pass2::visit( TraitInstType *contextInst ) {
                 Parent::visit( contextInst );
-                if ( contextInst->get_name() == "sized" ) {
-                        // "sized" is a special trait with no members - just flick the sized status on for the type variable
-                        if ( contextInst->get_parameters().size() != 1 ) {
-                                throw SemanticError( "incorrect number of context parameters: ", contextInst );
-                        }
-                        TypeExpr * param = safe_dynamic_cast< TypeExpr * > ( contextInst->get_parameters().front() );
-                        TypeInstType * inst = safe_dynamic_cast< TypeInstType * > ( param->get_type() );
-                        TypeDecl * decl = inst->get_baseType();
-                        decl->set_sized( true );
-                        // since "sized" is special, the next few steps don't apply
-                        return;
-                }
                 TraitDecl *ctx = indexer->lookupTrait( contextInst->get_name() );
                 if ( ! ctx ) {
@@ -414 +386 @@
         }
 
-        void LinkReferenceToTypes::visit( StructDecl *structDecl ) {
+        void Pass2::visit( StructDecl *structDecl ) {
                 // visit struct members first so that the types of self-referencing members are updated properly
                 Parent::visit( structDecl );
@@ -428 +400 @@
         }
 
-        void LinkReferenceToTypes::visit( UnionDecl *unionDecl ) {
+        void Pass2::visit( UnionDecl *unionDecl ) {
                 Parent::visit( unionDecl );
                 if ( ! unionDecl->get_members().empty() ) {
@@ -441 +413 @@
         }
 
-        void LinkReferenceToTypes::visit( TypeInstType *typeInst ) {
+        void Pass2::visit( TypeInstType *typeInst ) {
                 if ( NamedTypeDecl *namedTypeDecl = lookupType( typeInst->get_name() ) ) {
                         if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
@@ -612 +584 @@
 
                 typedeclNames[ typeDecl->get_name() ] = typeDecl;
-                return Mutator::mutate( typeDecl );
+                return typeDecl;
         }
 
@@ -763 +735 @@
                 return new VariableExpr( newtempvar );
         }
-
-        void ReturnTypeFixer::fix( std::list< Declaration * > &translationUnit ) {
-                ReturnTypeFixer fixer;
-                acceptAll( translationUnit, fixer );
-        }
-
-        void ReturnTypeFixer::visit( FunctionDecl * functionDecl ) {
-                Parent::visit( functionDecl );
-                FunctionType * ftype = functionDecl->get_functionType();
-                std::list< DeclarationWithType * > & retVals = ftype->get_returnVals();
-                assertf( retVals.size() == 0 || retVals.size() == 1, "Function %s has too many return values: %d", functionDecl->get_name().c_str(), retVals.size() );
-                if ( retVals.size() == 1 ) {
-                        // ensure all function return values have a name - use the name of the function to disambiguate (this also provides a nice bit of help for debugging)
-                        // ensure other return values have a name
-                        DeclarationWithType * ret = retVals.front();
-                        if ( ret->get_name() == "" ) {
-                                ret->set_name( toString( "_retval_", CodeGen::genName( functionDecl ) ) );
-                        }
-                }
-        }
-
-        void ReturnTypeFixer::visit( FunctionType * ftype ) {
-                // xxx - need to handle named return values - this information needs to be saved somehow
-                // so that resolution has access to the names.
-                // Note that this pass needs to happen early so that other passes which look for tuple types
-                // find them in all of the right places, including function return types.
-                std::list< DeclarationWithType * > & retVals = ftype->get_returnVals();
-                if ( retVals.size() > 1 ) {
-                        // generate a single return parameter which is the tuple of all of the return values
-                        TupleType * tupleType = safe_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
-                        // ensure return value is not destructed by explicitly creating an empty ListInit node wherein maybeConstruct is false.
-                        ObjectDecl * newRet = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
-                        deleteAll( retVals );
-                        retVals.clear();
-                        retVals.push_back( newRet );
-                }
-        }
 } // namespace SymTab
 

src/SynTree/ApplicationExpr.cc

@@ -30 +30 @@
         if ( &other == this ) return *this;
         decl = other.decl;
-        // xxx - this looks like a memory leak
         actualType = maybeClone( other.actualType );
         formalType = maybeClone( other.formalType );

src/SynTree/CompoundStmt.cc

@@ -49 +49 @@
                 Statement * origStmt = *origit++;
                 if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( s ) ) {
-                        DeclStmt * origDeclStmt = safe_dynamic_cast< DeclStmt * >( origStmt );
+                        DeclStmt * origDeclStmt = dynamic_cast< DeclStmt * >( origStmt );
+                        assert( origDeclStmt );
                         if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * > ( declStmt->get_decl() ) ) {
-                                DeclarationWithType * origdwt = safe_dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
+                                DeclarationWithType * origdwt = dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
+                                assert( origdwt );
                                 assert( dwt->get_name() == origdwt->get_name() );
                                 declMap[ origdwt ] = dwt;
-                        } else assert( ! dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() ) );
-                } else assert( ! dynamic_cast< DeclStmt * > ( s ) );
+                        }
+                }
         }
         if ( ! declMap.empty() ) {

src/SynTree/Declaration.h

@@ -180 +180 @@
   public:
         enum Kind { Any, Dtype, Ftype };
-        /// Data extracted from a type decl
-        struct Data {
-                TypeDecl::Kind kind;
-                bool isComplete;
-                Data() : kind( (TypeDecl::Kind)-1 ), isComplete( false ) {}
-                Data( TypeDecl * typeDecl ) : Data( typeDecl->get_kind(), typeDecl->isComplete() ) {}
-                Data( Kind kind, bool isComplete ) : kind( kind ), isComplete( isComplete ) {}
-                bool operator==(const Data & other) const { return kind == other.kind && isComplete == other.isComplete; }
-                bool operator!=(const Data & other) const { return !(*this == other);}
-        };
 
         TypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type, Kind kind );
@@ -196 +186 @@
         Kind get_kind() const { return kind; }
 
-        bool isComplete() const { return kind == Any || sized; }
-        bool get_sized() const { return sized; }
-        TypeDecl * set_sized( bool newValue ) { sized = newValue; return this; }
-
         virtual TypeDecl *clone() const { return new TypeDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
@@ -206 +192 @@
         virtual std::string typeString() const;
         Kind kind;
-        bool sized;
 };
 
@@ -299 +284 @@
 
 std::ostream & operator<<( std::ostream & out, const Declaration * decl );
-std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );
 
 #endif // DECLARATION_H

src/SynTree/Expression.cc

@@ -332 +332 @@
 }
 
-namespace {
-        TypeSubstitution makeSub( Type * t ) {
-                if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) {
-                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() );
-                } else if ( UnionInstType * aggInst = dynamic_cast< UnionInstType * >( t ) ) {
-                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() );
-                } else {
-                        assertf( false, "makeSub expects struct or union type for aggregate" );
-                }
-        }
-}
-
 
 MemberExpr::MemberExpr( DeclarationWithType *_member, Expression *_aggregate, Expression *_aname ) :
                 Expression( _aname ), member(_member), aggregate(_aggregate) {
-
-        TypeSubstitution sub( makeSub( aggregate->get_result() ) );
-        Type * res = member->get_type()->clone();
-        sub.apply( res );
-        set_result( res );
+        set_result( member->get_type()->clone() );
         get_result()->set_isLvalue( true );
 }
@@ -527 +511 @@
 
 ImplicitCopyCtorExpr::~ImplicitCopyCtorExpr() {
-        set_env( nullptr ); // ImplicitCopyCtorExpr does not take ownership of an environment
         delete callExpr;
         deleteAll( tempDecls );
@@ -537 +520 @@
         os <<  "Implicit Copy Constructor Expression: " << std::endl;
         assert( callExpr );
-        os << std::string( indent+2, ' ' );
         callExpr->print( os, indent + 2 );
         os << std::endl << std::string( indent, ' ' ) << "with temporaries:" << std::endl;
@@ -589 +571 @@
         os << std::string( indent+2, ' ' );
         initializer->print( os, indent + 2 );
-        Expression::print( os, indent );
 }
 
@@ -609 +590 @@
         os << " ... ";
         high->print( os, indent );
-        Expression::print( os, indent );
 }
 
@@ -621 +601 @@
         }
 }
-StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {
-        cloneAll( other.returnDecls, returnDecls );
-        cloneAll( other.dtors, dtors );
-}
+StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {}
 StmtExpr::~StmtExpr() {
         delete statements;
-        deleteAll( dtors );
-        deleteAll( returnDecls );
 }
 void StmtExpr::print( std::ostream &os, int indent ) const {
         os << "Statement Expression: " << std::endl << std::string( indent, ' ' );
         statements->print( os, indent+2 );
-        if ( ! returnDecls.empty() ) {
-                os << std::string( indent+2, ' ' ) << "with returnDecls: ";
-                printAll( returnDecls, os, indent+2 );
-        }
-        if ( ! dtors.empty() ) {
-                os << std::string( indent+2, ' ' ) << "with dtors: ";
-                printAll( dtors, os, indent+2 );
-        }
-        Expression::print( os, indent );
 }
 
@@ -665 +631 @@
         get_expr()->print( os, indent+2 );
         if ( get_object() ) {
-                os << std::string( indent+2, ' ' ) << "with decl: ";
+                os << " with decl: ";
                 get_object()->printShort( os, indent+2 );
         }
-        Expression::print( os, indent );
 }
 

src/SynTree/Expression.h

@@ -543 +543 @@
 
         std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
+        void set_tempDecls( std::list< ObjectDecl * > newValue ) { tempDecls = newValue; }
+
         std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
+        void set_returnDecls( std::list< ObjectDecl * > newValue ) { returnDecls = newValue; }
+
         std::list< Expression * > & get_dtors() { return dtors; }
+        void set_dtors( std::list< Expression * > newValue ) { dtors = newValue; }
 
         virtual ImplicitCopyCtorExpr *clone() const { return new ImplicitCopyCtorExpr( *this ); }
@@ -701 +706 @@
         virtual ~TupleAssignExpr();
 
-        TupleAssignExpr * set_stmtExpr( StmtExpr * newValue ) { stmtExpr = newValue; return this; }
-        StmtExpr * get_stmtExpr() const { return stmtExpr; }
+        std::list< Expression * > & get_assigns() { return assigns; }
+        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
 
         virtual TupleAssignExpr *clone() const { return new TupleAssignExpr( *this ); }
@@ -709 +714 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
-        StmtExpr * stmtExpr = nullptr;
+        std::list< Expression * > assigns; // assignment expressions that use tempDecls
+        std::list< ObjectDecl * > tempDecls; // temporaries for address of lhs exprs
 };
 
@@ -722 +728 @@
         StmtExpr * set_statements( CompoundStmt * newValue ) { statements = newValue; return this; }
 
-        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
-        std::list< Expression * > & get_dtors() { return dtors; }
-
         virtual StmtExpr *clone() const { return new StmtExpr( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
@@ -731 +734 @@
 private:
         CompoundStmt * statements;
-        std::list< ObjectDecl * > returnDecls; // return variable(s) for stmt expression
-        std::list< Expression * > dtors; // destructor(s) for return variable(s)
 };
 

src/SynTree/Initializer.cc

@@ -65 +65 @@
 }
 
-ListInit::ListInit( const ListInit & other ) : Initializer( other ) {
-        cloneAll( other.initializers, initializers );
-        cloneAll( other.designators, designators );
-}
-
-
 ListInit::~ListInit() {
         deleteAll( initializers );

src/SynTree/Initializer.h

@@ -88 +88 @@
         ListInit( const std::list<Initializer*> &initializers,
                           const std::list<Expression *> &designators = std::list< Expression * >(), bool maybeConstructed = false );
-        ListInit( const ListInit & other );
         virtual ~ListInit();
 

src/SynTree/Mutator.cc

@@ -325 +325 @@
         mutateAll( impCpCtorExpr->get_tempDecls(), *this );
         mutateAll( impCpCtorExpr->get_returnDecls(), *this );
-        mutateAll( impCpCtorExpr->get_dtors(), *this );
         return impCpCtorExpr;
 }
@@ -374 +373 @@
 Expression *Mutator::mutate( TupleAssignExpr *assignExpr ) {
         assignExpr->set_result( maybeMutate( assignExpr->get_result(), *this ) );
-        assignExpr->set_stmtExpr( maybeMutate( assignExpr->get_stmtExpr(), *this ) );
+        mutateAll( assignExpr->get_tempDecls(), *this );
+        mutateAll( assignExpr->get_assigns(), *this );
         return assignExpr;
 }
@@ -381 +381 @@
         stmtExpr->set_result( maybeMutate( stmtExpr->get_result(), *this ) );
         stmtExpr->set_statements( maybeMutate( stmtExpr->get_statements(), *this ) );
-        mutateAll( stmtExpr->get_returnDecls(), *this );
-        mutateAll( stmtExpr->get_dtors(), *this );
         return stmtExpr;
 }
@@ -505 +503 @@
 Initializer *Mutator::mutate( ConstructorInit *ctorInit ) {
         ctorInit->set_ctor( maybeMutate( ctorInit->get_ctor(), *this ) );
-        ctorInit->set_dtor( maybeMutate( ctorInit->get_dtor(), *this ) );
         ctorInit->set_init( maybeMutate( ctorInit->get_init(), *this ) );
         return ctorInit;

src/SynTree/ReferenceToType.cc

@@ -46 +46 @@
 
 namespace {
-        void doLookup( const std::list< Declaration* > &members, const std::string &name, std::list< Declaration* > &foundDecls ) {
+        void doLookup( const std::list< Declaration* > &members, const std::list< TypeDecl* > &parms, const std::list< Expression* > &args, const std::string &name, std::list< Declaration* > &foundDecls ) {
+                std::list< Declaration* > found;
                 for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) {
                         if ( (*i)->get_name() == name ) {
-                                foundDecls.push_back( *i );
+                                found.push_back( *i );
                         } // if
                 } // for
+                applySubstitution( parms.begin(), parms.end(), args.begin(), found.begin(), found.end(), back_inserter( foundDecls ) );
         }
 } // namespace
@@ -66 +68 @@
 void StructInstType::lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const {
         assert( baseStruct );
-        doLookup( baseStruct->get_members(), name, foundDecls );
+        doLookup( baseStruct->get_members(), baseStruct->get_parameters(), parameters, name, foundDecls );
 }
 
@@ -92 +94 @@
 void UnionInstType::lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const {
         assert( baseUnion );
-        doLookup( baseUnion->get_members(), name, foundDecls );
+        doLookup( baseUnion->get_members(), baseUnion->get_parameters(), parameters, name, foundDecls );
 }
 
@@ -128 +130 @@
 }
 
-TypeInstType::TypeInstType( const TypeInstType &other ) : Parent( other ), baseType( other.baseType ), isFtype( other.isFtype ) {
-}
-
-
 TypeInstType::~TypeInstType() {
         // delete baseType; //This is shared and should not be deleted

src/SynTree/TupleExpr.cc

@@ -87 +87 @@
 }
 
-TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname ) : Expression( _aname ) {
-        // convert internally into a StmtExpr which contains the declarations and produces the tuple of the assignments
+
+TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname ) : Expression( _aname ), assigns( assigns ), tempDecls( tempDecls ) {
         set_result( Tuples::makeTupleType( assigns ) );
-        CompoundStmt * compoundStmt = new CompoundStmt( noLabels );
-        std::list< Statement * > & stmts = compoundStmt->get_kids();
-        for ( ObjectDecl * obj : tempDecls ) {
-                stmts.push_back( new DeclStmt( noLabels, obj ) );
-        }
-        TupleExpr * tupleExpr = new TupleExpr( assigns );
-        assert( tupleExpr->get_result() );
-        stmts.push_back( new ExprStmt( noLabels, tupleExpr ) );
-        stmtExpr = new StmtExpr( compoundStmt );
 }
 
 TupleAssignExpr::TupleAssignExpr( const TupleAssignExpr &other ) : Expression( other ) {
-        assert( other.stmtExpr );
-        stmtExpr = other.stmtExpr->clone();
+        cloneAll( other.assigns, assigns );
+        cloneAll( other.tempDecls, tempDecls );
+
+        // clone needs to go into assigns and replace tempDecls
+        VarExprReplacer::DeclMap declMap;
+        std::list< ObjectDecl * >::const_iterator origit = other.tempDecls.begin();
+        for ( ObjectDecl * temp : tempDecls ) {
+                assert( origit != other.tempDecls.end() );
+                ObjectDecl * origTemp = *origit++;
+                assert( origTemp );
+                assert( temp->get_name() == origTemp->get_name() );
+                declMap[ origTemp ] = temp;
+        }
+        if ( ! declMap.empty() ) {
+                VarExprReplacer replacer( declMap );
+                for ( Expression * assn : assigns ) {
+                        assn->accept( replacer );
+                }
+        }
 }
 
 TupleAssignExpr::~TupleAssignExpr() {
-        delete stmtExpr;
+        deleteAll( assigns );
+        // deleteAll( tempDecls );
 }
 
 void TupleAssignExpr::print( std::ostream &os, int indent ) const {
-        os << "Tuple Assignment Expression, with stmt expr:" << std::endl;
-        os << std::string( indent+2, ' ' );
-        stmtExpr->print( os, indent+4 );
+        os << "Tuple Assignment Expression, with temporaries:" << std::endl;
+        printAll( tempDecls, os, indent+4 );
+        os << std::string( indent+2, ' ' ) << "with assignments: " << std::endl;
+        printAll( assigns, os, indent+4 );
         Expression::print( os, indent );
 }

src/SynTree/Type.h

@@ -72 +72 @@
         virtual unsigned size() const { return 1; };
         virtual bool isVoid() const { return size() == 0; }
-        virtual Type * getComponent( unsigned i ) { assertf( size() == 1 && i == 0, "Type::getComponent was called with size %d and index %d\n", size(), i ); return this; }
 
         virtual Type *clone() const = 0;
@@ -340 +339 @@
         TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType );
         TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype );
-        TypeInstType( const TypeInstType &other );
+        TypeInstType( const TypeInstType &other ) : Parent( other ), baseType( other.baseType ), isFtype( other.isFtype ) {}
         ~TypeInstType();
 
@@ -374 +373 @@
         iterator begin() { return types.begin(); }
         iterator end() { return types.end(); }
-
-        virtual Type * getComponent( unsigned i ) {
-                assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
-                return *(begin()+i);
-        }
 
         virtual TupleType *clone() const { return new TupleType( *this ); }

src/SynTree/TypeDecl.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// TypeDecl.cc --
+// TypeDecl.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -18 +18 @@
 #include "Common/utility.h"
 
-TypeDecl::TypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type, Kind kind ) : Parent( name, sc, type ), kind( kind ), sized( kind == Any ) {
+TypeDecl::TypeDecl( const std::string &name, DeclarationNode::StorageClass sc, Type *type, Kind kind ) : Parent( name, sc, type ), kind( kind ) {
 }
 
-TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), kind( other.kind ), sized( other.sized ) {
+TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), kind( other.kind ) {
 }
 
@@ -29 +29 @@
 }
 
-std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data ) {
-  return os << data.kind << ", " << data.isComplete;
-}
-
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/VarExprReplacer.cc

@@ -21 +21 @@
 // replace variable with new node from decl map
 void VarExprReplacer::visit( VariableExpr * varExpr ) {
-  // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
   if ( declMap.count( varExpr->get_var() ) ) {
     varExpr->set_var( declMap.at( varExpr->get_var() ) );

src/SynTree/Visitor.cc

@@ -276 +276 @@
         acceptAll( impCpCtorExpr->get_tempDecls(), *this );
         acceptAll( impCpCtorExpr->get_returnDecls(), *this );
-        acceptAll( impCpCtorExpr->get_dtors(), *this );
 }
 
@@ -318 +317 @@
 void Visitor::visit( TupleAssignExpr *assignExpr ) {
         maybeAccept( assignExpr->get_result(), *this );
-        maybeAccept( assignExpr->get_stmtExpr(), *this );
+        acceptAll( assignExpr->get_tempDecls(), *this );
+        acceptAll( assignExpr->get_assigns(), *this );
 }
 
@@ -324 +324 @@
         maybeAccept( stmtExpr->get_result(), *this );
         maybeAccept( stmtExpr->get_statements(), *this );
-        acceptAll( stmtExpr->get_returnDecls(), *this );
-        acceptAll( stmtExpr->get_dtors(), *this );
 }
 
@@ -427 +425 @@
 void Visitor::visit( ConstructorInit *ctorInit ) {
         maybeAccept( ctorInit->get_ctor(), *this );
-        maybeAccept( ctorInit->get_dtor(), *this );
         maybeAccept( ctorInit->get_init(), *this );
 }

src/Tuples/Explode.cc

@@ -23 +23 @@
                         Expression * applyAddr( Expression * expr, bool first = true ) {
                                 if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( expr ) ){
-                                        foundUniqueExpr = true;
                                         std::list< Expression * > exprs;
                                         for ( Expression *& expr : tupleExpr->get_exprs() ) {
@@ -47 +46 @@
                                 // should now be a tuple of addresses rather than the address of a tuple.
                                 // Still, this code is a bit awkward, and could use some improvement.
-                                if ( dynamic_cast< AddressExpr * > ( uniqueExpr->get_expr() ) ) {
-                                        // this unique expression has already been mutated or otherwise shouldn't be (can't take the address-of an address-of expression)
-                                        return uniqueExpr;
-                                }
+                                foundUniqueExpr = true;
                                 UniqueExpr * newUniqueExpr = new UniqueExpr( applyAddr( uniqueExpr->get_expr() ), uniqueExpr->get_id() );
                                 delete uniqueExpr;

src/Tuples/TupleAssignment.cc

@@ -23 +23 @@
 #include "Common/SemanticError.h"
 #include "InitTweak/InitTweak.h"
-#include "InitTweak/GenInit.h"
 
 #include <functional>
@@ -48 +47 @@
                         virtual ~Matcher() {}
                         virtual void match( std::list< Expression * > &out ) = 0;
-                        ObjectDecl * newObject( UniqueName & namer, Expression * expr );
                         ResolvExpr::AltList lhs, rhs;
                         TupleAssignSpotter &spotter;
-                        ResolvExpr::Cost baseCost;
                         std::list< ObjectDecl * > tmpDecls;
-                        ResolvExpr::TypeEnvironment compositeEnv;
                 };
 
@@ -150 +146 @@
                                 finder.findWithAdjustment(*i);
                         } catch (...) {
-                                return; // no match should not mean failure, it just means this particular tuple assignment isn't valid
+                                return; // xxx - no match should not mean failure, it just means this particular tuple assignment isn't valid
                         }
                         // prune expressions that don't coincide with
@@ -165 +161 @@
                         solved_assigns.push_back( alt.expr->clone() );
                 }
-                // combine assignment environments into combined expression environment
-                simpleCombineEnvironments( current.begin(), current.end(), matcher->compositeEnv );
-                currentFinder.get_alternatives().push_front( ResolvExpr::Alternative(new TupleAssignExpr(solved_assigns, matcher->tmpDecls), matcher->compositeEnv, ResolvExpr::sumCost( current  ) + matcher->baseCost ) );
-        }
-
-        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList &alts ) : spotter(spotter), baseCost( ResolvExpr::sumCost( alts ) ) {
+                // xxx - need to do this??
+                ResolvExpr::TypeEnvironment compositeEnv;
+                simpleCombineEnvironments( current.begin(), current.end(), compositeEnv );
+                currentFinder.get_alternatives().push_front( ResolvExpr::Alternative(new TupleAssignExpr(solved_assigns, matcher->tmpDecls), compositeEnv, ResolvExpr::sumCost( current ) ) );
+        }
+
+        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList &alts ) : spotter(spotter) {
                 assert( ! alts.empty() );
-                // combine argument environments into combined expression environment
-                simpleCombineEnvironments( alts.begin(), alts.end(), compositeEnv );
-
                 ResolvExpr::Alternative lhsAlt = alts.front();
                 // peel off the cast that exists on ctor/dtor expressions
@@ -223 +217 @@
         }
 
-        // removes environments from subexpressions within statement exprs, which could throw off later passes like those in Box which rely on PolyMutator.
-        // xxx - maybe this should happen in alternative finder for every StmtExpr?
-        // xxx - it's possible that these environments could contain some useful information. Maybe the right thing to do is aggregate the environments and pass the aggregate back to be added into the compositeEnv
-        struct EnvRemover : public Visitor {
-                virtual void visit( ExprStmt * stmt ) {
-                        delete stmt->get_expr()->get_env();
-                        stmt->get_expr()->set_env( nullptr );
-                        Visitor::visit( stmt );
-                }
-        };
-
-        ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) {
+        ObjectDecl * newObject( UniqueName & namer, Expression * expr ) {
                 assert( expr->has_result() && ! expr->get_result()->isVoid() );
-                ObjectDecl * ret = new ObjectDecl( namer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
-                ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
-                ret->set_init( ctorInit );
-                ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
-                EnvRemover rm; // remove environments from subexpressions of StmtExprs
-                ctorInit->accept( rm );
-                return ret;
+                return new ObjectDecl( namer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
         }
 
@@ -267 +244 @@
                         std::list< ObjectDecl * > ltmp;
                         std::list< ObjectDecl * > rtmp;
-                        std::transform( lhs.begin(), lhs.end(), back_inserter( ltmp ), [&]( ResolvExpr::Alternative & alt ){
+                        std::transform( lhs.begin(), lhs.end(), back_inserter( ltmp ), []( ResolvExpr::Alternative & alt ){
                                 return newObject( lhsNamer, alt.expr );
                         });
-                        std::transform( rhs.begin(), rhs.end(), back_inserter( rtmp ), [&]( ResolvExpr::Alternative & alt ){
+                        std::transform( rhs.begin(), rhs.end(), back_inserter( rtmp ), []( ResolvExpr::Alternative & alt ){
                                 return newObject( rhsNamer, alt.expr );
                         });

src/Tuples/TupleExpansion.cc

@@ -93 +93 @@
                         typedef Mutator Parent;
                         using Parent::mutate;
-
+                        
                         virtual Expression * mutate( TupleExpr * tupleExpr ) override;
                 };
@@ -194 +194 @@
                                 new CommaExpr( new CommaExpr( assignUnq, assignFinished ), var->clone() ) );
                         condExpr->set_result( var->get_result()->clone() );
-                        condExpr->set_env( maybeClone( unqExpr->get_env() ) );
                         decls[id] = condExpr;
                 }
@@ -203 +202 @@
         Expression * TupleAssignExpander::mutate( TupleAssignExpr * assnExpr ) {
                 assnExpr = safe_dynamic_cast< TupleAssignExpr * >( Parent::mutate( assnExpr ) );
-                StmtExpr * ret = assnExpr->get_stmtExpr();
-                assnExpr->set_stmtExpr( nullptr );
-                // move env to StmtExpr
-                ret->set_env( assnExpr->get_env() );
-                assnExpr->set_env( nullptr );
+                CompoundStmt * compoundStmt = new CompoundStmt( noLabels );
+                std::list< Statement * > & stmts = compoundStmt->get_kids();
+                for ( ObjectDecl * obj : assnExpr->get_tempDecls() ) {
+                        stmts.push_back( new DeclStmt( noLabels, obj ) );
+                }
+                TupleExpr * tupleExpr = new TupleExpr( assnExpr->get_assigns() );
+                assert( tupleExpr->get_result() );
+                stmts.push_back( new ExprStmt( noLabels, tupleExpr ) );
+                assnExpr->get_tempDecls().clear();
+                assnExpr->get_assigns().clear();
                 delete assnExpr;
-                return ret;
+                return new StmtExpr( compoundStmt );
         }
 
         Type * TupleTypeReplacer::mutate( TupleType * tupleType ) {
                 std::string mangleName = SymTab::Mangler::mangleType( tupleType );
-                tupleType = safe_dynamic_cast< TupleType * > ( Parent::mutate( tupleType ) );
+                TupleType * newType = safe_dynamic_cast< TupleType * > ( Parent::mutate( tupleType ) );
                 if ( ! typeMap.count( mangleName ) ) {
                         // generate struct type to replace tuple type
-                        // xxx - should fix this to only generate one tuple struct for each number of type parameters
                         StructDecl * decl = new StructDecl( "_tuple_type_" + mangleName );
                         decl->set_body( true );
-                        for ( size_t i = 0; i < tupleType->size(); ++i ) {
-                                TypeDecl * tyParam = new TypeDecl( toString("tuple_param_", i), DeclarationNode::NoStorageClass, nullptr, TypeDecl::Any );
-                                decl->get_members().push_back( new ObjectDecl( toString("field_", i), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, new TypeInstType( Type::Qualifiers(), tyParam->get_name(), tyParam ), nullptr ) );
-                                decl->get_parameters().push_back( tyParam );
+                        int cnt = 0;
+                        for ( Type * t : *newType ) {
+                                decl->get_members().push_back( new ObjectDecl( toString("field_", cnt++), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, t->clone(), nullptr ) );
                         }
                         typeMap[mangleName] = decl;
                         addDeclaration( decl );
                 }
-                Type::Qualifiers qualifiers = tupleType->get_qualifiers();
-
-                StructDecl * decl = typeMap[mangleName];
-                StructInstType * newType = new StructInstType( qualifiers, decl );
-                for ( Type * t : *tupleType ) {
-                        newType->get_parameters().push_back( new TypeExpr( t->clone() ) );
-                }
-                delete tupleType;
-                return newType;
+                Type::Qualifiers qualifiers = newType->get_qualifiers();
+                delete newType;
+                return new StructInstType( qualifiers, typeMap[mangleName] );
         }
 
@@ -244 +240 @@
                 tupleExpr->set_tuple( nullptr );
                 unsigned int idx = tupleExpr->get_index();
-                TypeSubstitution * env = tupleExpr->get_env();
-                tupleExpr->set_env( nullptr );
                 delete tupleExpr;
 
@@ -252 +246 @@
                 assert( structDecl->get_members().size() > idx );
                 Declaration * member = *std::next(structDecl->get_members().begin(), idx);
-                MemberExpr * memExpr = new MemberExpr( safe_dynamic_cast< DeclarationWithType * >( member ), tuple );
-                memExpr->set_env( env );
-                return memExpr;
-        }
-
-        Expression * replaceTupleExpr( Type * result, const std::list< Expression * > & exprs, TypeSubstitution * env ) {
+                return new MemberExpr( safe_dynamic_cast< DeclarationWithType * >( member ), tuple );
+        }
+
+        Expression * replaceTupleExpr( Type * result, const std::list< Expression * > & exprs ) {
                 if ( result->isVoid() ) {
                         // void result - don't need to produce a value for cascading - just output a chain of comma exprs
                         assert( ! exprs.empty() );
                         std::list< Expression * >::const_iterator iter = exprs.begin();
-                        Expression * expr = new CastExpr( *iter++ );
+                        Expression * expr = *iter++;
                         for ( ; iter != exprs.end(); ++iter ) {
-                                expr = new CommaExpr( expr, new CastExpr( *iter ) );
-                        }
-                        expr->set_env( env );
+                                expr = new CommaExpr( expr, *iter );
+                        }
                         return expr;
                 } else {
@@ -276 +267 @@
                                 inits.push_back( new SingleInit( expr ) );
                         }
-                        Expression * expr = new CompoundLiteralExpr( result, new ListInit( inits ) );
-                        expr->set_env( env );
-                        return expr;
+                        return new CompoundLiteralExpr( result, new ListInit( inits ) );
                 }
         }
@@ -288 +277 @@
                 std::list< Expression * > exprs = tupleExpr->get_exprs();
                 assert( result );
-                TypeSubstitution * env = tupleExpr->get_env();
 
                 // remove data from shell and delete it
                 tupleExpr->set_result( nullptr );
                 tupleExpr->get_exprs().clear();
-                tupleExpr->set_env( nullptr );
                 delete tupleExpr;
 
-                return replaceTupleExpr( result, exprs, env );
+                return replaceTupleExpr( result, exprs );
         }
 

src/main.cc

@@ -266 +266 @@
                 OPTPRINT( "expandUniqueExpr" ); // xxx - is this the right place for this? want to expand ASAP so that subsequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
                 Tuples::expandUniqueExpr( translationUnit );
-                OPTPRINT( "expandTuples" ); // xxx - is this the right place for this?
-                Tuples::expandTuples( translationUnit );
 
                 OPTPRINT("instantiateGenerics")
@@ -284 +282 @@
                 OPTPRINT( "box" )
                 GenPoly::box( translationUnit );
+                OPTPRINT( "expandTuples" ); // xxx - is this the right place for this?
+                Tuples::expandTuples( translationUnit );
 
                 // print tree right before code generation

src/prelude/prelude.cf

@@ -105 +105 @@
 forall( otype T ) const volatile T *     --?( const volatile T ** );
 
-forall( dtype T | sized(T) ) lvalue T            *?(                 T * );
-forall( dtype T | sized(T) ) const lvalue T              *?( const           T * );
-forall( dtype T | sized(T) ) volatile lvalue T   *?(       volatile  T * );
-forall( dtype T | sized(T) ) const volatile lvalue T *?( const volatile  T * );
+forall( otype T ) lvalue T               *?(                 T * );
+forall( otype T ) const lvalue T                 *?( const           T * );
+forall( otype T ) volatile lvalue T      *?(       volatile  T * );
+forall( otype T ) const volatile lvalue T *?( const volatile  T * );
 forall( ftype FT ) lvalue FT             *?( FT * );
 

src/tests/.expect/32/declarationSpecifier.txt

@@ -20 +20 @@
 static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
 static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1);
-static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))=___src__13s__anonymous0_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     ((void)((*___dst__P13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
     return ((struct __anonymous0 )___src__13s__anonymous0_1);
+}
+static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))=___src__13s__anonymous0_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, int __i__i_1){
@@ -44 +44 @@
 static inline void ___constructor__F_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
 static inline void ___destructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1);
-static inline void ___constructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))=___src__13s__anonymous1_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
     ((void)((*___dst__P13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
     return ((struct __anonymous1 )___src__13s__anonymous1_1);
+}
+static inline void ___constructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))=___src__13s__anonymous1_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, int __i__i_1){
@@ -68 +68 @@
 static inline void ___constructor__F_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
 static inline void ___destructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1);
-static inline void ___constructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))=___src__13s__anonymous2_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     ((void)((*___dst__P13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
     return ((struct __anonymous2 )___src__13s__anonymous2_1);
+}
+static inline void ___constructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))=___src__13s__anonymous2_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, int __i__i_1){
@@ -92 +92 @@
 static inline void ___constructor__F_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
 static inline void ___destructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1);
-static inline void ___constructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))=___src__13s__anonymous3_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
     ((void)((*___dst__P13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
     return ((struct __anonymous3 )___src__13s__anonymous3_1);
+}
+static inline void ___constructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))=___src__13s__anonymous3_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, int __i__i_1){
@@ -116 +116 @@
 static inline void ___constructor__F_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
 static inline void ___destructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1);
-static inline void ___constructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))=___src__13s__anonymous4_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
     ((void)((*___dst__P13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
     return ((struct __anonymous4 )___src__13s__anonymous4_1);
+}
+static inline void ___constructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))=___src__13s__anonymous4_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, int __i__i_1){
@@ -140 +140 @@
 static inline void ___constructor__F_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
 static inline void ___destructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1);
-static inline void ___constructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))=___src__13s__anonymous5_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
     ((void)((*___dst__P13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
     return ((struct __anonymous5 )___src__13s__anonymous5_1);
+}
+static inline void ___constructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))=___src__13s__anonymous5_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, int __i__i_1){
@@ -164 +164 @@
 static inline void ___constructor__F_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
 static inline void ___destructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1);
-static inline void ___constructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))=___src__13s__anonymous6_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
     ((void)((*___dst__P13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
     return ((struct __anonymous6 )___src__13s__anonymous6_1);
+}
+static inline void ___constructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))=___src__13s__anonymous6_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, int __i__i_1){
@@ -188 +188 @@
 static inline void ___constructor__F_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
 static inline void ___destructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1);
-static inline void ___constructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))=___src__13s__anonymous7_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
     ((void)((*___dst__P13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
     return ((struct __anonymous7 )___src__13s__anonymous7_1);
+}
+static inline void ___constructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))=___src__13s__anonymous7_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, int __i__i_1){
@@ -220 +220 @@
 static inline void ___constructor__F_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
 static inline void ___destructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1);
-static inline void ___constructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1){
-    ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
-    ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))=___src__13s__anonymous8_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1){
-    ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
     ((void)((*___dst__P13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
     return ((struct __anonymous8 )___src__13s__anonymous8_1);
+}
+static inline void ___constructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1){
+    ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
+    ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))=___src__13s__anonymous8_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1){
+    ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, short __i__s_1){
@@ -244 +244 @@
 static inline void ___constructor__F_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
 static inline void ___destructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1);
-static inline void ___constructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1){
-    ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
-    ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))=___src__13s__anonymous9_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1){
-    ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
     ((void)((*___dst__P13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
     return ((struct __anonymous9 )___src__13s__anonymous9_1);
+}
+static inline void ___constructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1){
+    ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
+    ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))=___src__13s__anonymous9_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1){
+    ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, short __i__s_1){
@@ -268 +268 @@
 static inline void ___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
 static inline void ___destructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1);
-static inline void ___constructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))=___src__14s__anonymous10_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
     ((void)((*___dst__P14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
     return ((struct __anonymous10 )___src__14s__anonymous10_1);
+}
+static inline void ___constructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))=___src__14s__anonymous10_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, short __i__s_1){
@@ -292 +292 @@
 static inline void ___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
 static inline void ___destructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1);
-static inline void ___constructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))=___src__14s__anonymous11_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
     ((void)((*___dst__P14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
     return ((struct __anonymous11 )___src__14s__anonymous11_1);
+}
+static inline void ___constructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))=___src__14s__anonymous11_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, short __i__s_1){
@@ -316 +316 @@
 static inline void ___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
 static inline void ___destructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1);
-static inline void ___constructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))=___src__14s__anonymous12_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
     ((void)((*___dst__P14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
     return ((struct __anonymous12 )___src__14s__anonymous12_1);
+}
+static inline void ___constructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))=___src__14s__anonymous12_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, short __i__s_1){
@@ -340 +340 @@
 static inline void ___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
 static inline void ___destructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1);
-static inline void ___constructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))=___src__14s__anonymous13_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
     ((void)((*___dst__P14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
     return ((struct __anonymous13 )___src__14s__anonymous13_1);
+}
+static inline void ___constructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))=___src__14s__anonymous13_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, short __i__s_1){
@@ -364 +364 @@
 static inline void ___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
 static inline void ___destructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1);
-static inline void ___constructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))=___src__14s__anonymous14_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
     ((void)((*___dst__P14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
     return ((struct __anonymous14 )___src__14s__anonymous14_1);
+}
+static inline void ___constructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))=___src__14s__anonymous14_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, short __i__s_1){
@@ -388 +388 @@
 static inline void ___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
 static inline void ___destructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1);
-static inline void ___constructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))=___src__14s__anonymous15_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
     ((void)((*___dst__P14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
     return ((struct __anonymous15 )___src__14s__anonymous15_1);
+}
+static inline void ___constructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))=___src__14s__anonymous15_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, short __i__s_1){
@@ -428 +428 @@
 static inline void ___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
 static inline void ___destructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1);
-static inline void ___constructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))=___src__14s__anonymous16_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
     ((void)((*___dst__P14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
     return ((struct __anonymous16 )___src__14s__anonymous16_1);
+}
+static inline void ___constructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))=___src__14s__anonymous16_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, int __i__i_1){
@@ -452 +452 @@
 static inline void ___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
 static inline void ___destructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1);
-static inline void ___constructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))=___src__14s__anonymous17_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
     ((void)((*___dst__P14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
     return ((struct __anonymous17 )___src__14s__anonymous17_1);
+}
+static inline void ___constructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))=___src__14s__anonymous17_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, int __i__i_1){
@@ -476 +476 @@
 static inline void ___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
 static inline void ___destructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1);
-static inline void ___constructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))=___src__14s__anonymous18_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
     ((void)((*___dst__P14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
     return ((struct __anonymous18 )___src__14s__anonymous18_1);
+}
+static inline void ___constructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))=___src__14s__anonymous18_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, int __i__i_1){
@@ -500 +500 @@
 static inline void ___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
 static inline void ___destructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1);
-static inline void ___constructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))=___src__14s__anonymous19_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
     ((void)((*___dst__P14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
     return ((struct __anonymous19 )___src__14s__anonymous19_1);
+}
+static inline void ___constructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))=___src__14s__anonymous19_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, int __i__i_1){
@@ -524 +524 @@
 static inline void ___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
 static inline void ___destructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1);
-static inline void ___constructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))=___src__14s__anonymous20_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
     ((void)((*___dst__P14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
     return ((struct __anonymous20 )___src__14s__anonymous20_1);
+}
+static inline void ___constructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))=___src__14s__anonymous20_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, int __i__i_1){
@@ -548 +548 @@
 static inline void ___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
 static inline void ___destructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1);
-static inline void ___constructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))=___src__14s__anonymous21_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
     ((void)((*___dst__P14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
     return ((struct __anonymous21 )___src__14s__anonymous21_1);
+}
+static inline void ___constructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))=___src__14s__anonymous21_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, int __i__i_1){
@@ -572 +572 @@
 static inline void ___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
 static inline void ___destructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1);
-static inline void ___constructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))=___src__14s__anonymous22_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
     ((void)((*___dst__P14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
     return ((struct __anonymous22 )___src__14s__anonymous22_1);
+}
+static inline void ___constructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))=___src__14s__anonymous22_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, int __i__i_1){
@@ -596 +596 @@
 static inline void ___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
 static inline void ___destructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1);
-static inline void ___constructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))=___src__14s__anonymous23_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
     ((void)((*___dst__P14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
     return ((struct __anonymous23 )___src__14s__anonymous23_1);
+}
+static inline void ___constructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))=___src__14s__anonymous23_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, int __i__i_1){
@@ -622 +622 @@
 static inline volatile const short __f48__FCVs___1();
 int main(int __argc__i_1, const char **__argv__PPCc_1){
-    int ___retval_main__i_1;
-    ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
-    return ((int )___retval_main__i_1);
-}
+    int _retVal0 = { 0 };
+    ((void)(_retVal0=((int )0)) /* ?{} */);
+    return ((int )_retVal0);
+}

src/tests/.expect/32/extension.txt

@@ -17 +17 @@
 static inline void ___constructor__F_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1);
 static inline void ___destructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1);
+static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
+    ((void)((*___dst__P2sS_1).__a__i_1=___src__2sS_1.__a__i_1));
+    ((void)((*___dst__P2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
+    ((void)((*___dst__P2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
+    return ((struct S )___src__2sS_1);
+}
 static inline void ___constructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))) /* ?{} */);
@@ -31 +37 @@
     ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))) /* ^?{} */);
-}
-static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
-    ((void)((*___dst__P2sS_1).__a__i_1=___src__2sS_1.__a__i_1));
-    ((void)((*___dst__P2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
-    ((void)((*___dst__P2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
-    return ((struct S )___src__2sS_1);
 }
 static inline void ___constructor__F_P2sSi_autogen___1(struct S *___dst__P2sS_1, int __a__i_1){
@@ -58 +58 @@
     __extension__ int __c__i_1;
 };
+static inline union U ___operator_assign__F2uU_P2uU2uU_autogen___1(union U *___dst__P2uU_1, union U ___src__2uU_1){
+    ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+    return ((union U )___src__2uU_1);
+}
 static inline void ___constructor__F_P2uU_autogen___1(union U *___dst__P2uU_1){
 }
 static inline void ___constructor__F_P2uU2uU_autogen___1(union U *___dst__P2uU_1, union U ___src__2uU_1){
     ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+    return ((void)___src__2uU_1);
 }
 static inline void ___destructor__F_P2uU_autogen___1(union U *___dst__P2uU_1){
-}
-static inline union U ___operator_assign__F2uU_P2uU2uU_autogen___1(union U *___dst__P2uU_1, union U ___src__2uU_1){
-    ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
-    return ((union U )___src__2uU_1);
 }
 static inline void ___constructor__F_P2uUi_autogen___1(union U *___dst__P2uU_1, int __src__i_1){
@@ -78 +79 @@
 };
 __extension__ int __fred__Fi_i__1(int __p__i_1){
-    int ___retval_fred__i_1;
     __extension__ struct S {
         __extension__ int __a__i_2;

src/tests/.expect/32/gccExtensions.txt

@@ -7 +7 @@
 extern int __x__i_1 asm ( "xx" );
 int main(int __argc__i_1, const char **__argv__PPCc_1){
-    int ___retval_main__i_1;
     asm ( "nop" :  :  :  );
     asm ( "nop" :  :  :  );
@@ -26 +25 @@
     const int __i3__Ci_2;
     inline int __f1__Fi___2(){
-        int ___retval_f1__i_2;
     }
     inline int __f2__Fi___2(){
-        int ___retval_f2__i_2;
     }
     int __s1__i_2;
@@ -43 +40 @@
         __extension__ int __c__i_2;
     };
+    inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___2(struct S *___dst__P2sS_2, struct S ___src__2sS_2){
+        ((void)((*___dst__P2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
+        ((void)((*___dst__P2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
+        ((void)((*___dst__P2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
+        return ((struct S )___src__2sS_2);
+    }
     inline void ___constructor__F_P2sS_autogen___2(struct S *___dst__P2sS_2){
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))) /* ?{} */);
@@ -57 +60 @@
         ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))) /* ^?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))) /* ^?{} */);
-    }
-    inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___2(struct S *___dst__P2sS_2, struct S ___src__2sS_2){
-        ((void)((*___dst__P2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
-        ((void)((*___dst__P2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
-        ((void)((*___dst__P2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
-        return ((struct S )___src__2sS_2);
     }
     inline void ___constructor__F_P2sSi_autogen___2(struct S *___dst__P2sS_2, int __a__i_2){
@@ -99 +96 @@
         int __i__i_2;
     };
+    inline struct s2 ___operator_assign__F3ss2_P3ss23ss2_autogen___2(struct s2 *___dst__P3ss2_2, struct s2 ___src__3ss2_2){
+        ((void)((*___dst__P3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
+        return ((struct s2 )___src__3ss2_2);
+    }
     inline void ___constructor__F_P3ss2_autogen___2(struct s2 *___dst__P3ss2_2){
         ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))) /* ?{} */);
@@ -108 +109 @@
         ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))) /* ^?{} */);
     }
-    inline struct s2 ___operator_assign__F3ss2_P3ss23ss2_autogen___2(struct s2 *___dst__P3ss2_2, struct s2 ___src__3ss2_2){
-        ((void)((*___dst__P3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
-        return ((struct s2 )___src__3ss2_2);
-    }
     inline void ___constructor__F_P3ss2i_autogen___2(struct s2 *___dst__P3ss2_2, int __i__i_2){
         ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))=__i__i_2) /* ?{} */);
@@ -118 +115 @@
         int __i__i_2;
     };
+    inline struct s3 ___operator_assign__F3ss3_P3ss33ss3_autogen___2(struct s3 *___dst__P3ss3_2, struct s3 ___src__3ss3_2){
+        ((void)((*___dst__P3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
+        return ((struct s3 )___src__3ss3_2);
+    }
     inline void ___constructor__F_P3ss3_autogen___2(struct s3 *___dst__P3ss3_2){
         ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))) /* ?{} */);
@@ -127 +128 @@
         ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))) /* ^?{} */);
     }
-    inline struct s3 ___operator_assign__F3ss3_P3ss33ss3_autogen___2(struct s3 *___dst__P3ss3_2, struct s3 ___src__3ss3_2){
-        ((void)((*___dst__P3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
-        return ((struct s3 )___src__3ss3_2);
-    }
     inline void ___constructor__F_P3ss3i_autogen___2(struct s3 *___dst__P3ss3_2, int __i__i_2){
         ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))=__i__i_2) /* ?{} */);
@@ -139 +136 @@
         int __i__i_2;
     };
+    inline struct s4 ___operator_assign__F3ss4_P3ss43ss4_autogen___2(struct s4 *___dst__P3ss4_2, struct s4 ___src__3ss4_2){
+        ((void)((*___dst__P3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
+        return ((struct s4 )___src__3ss4_2);
+    }
     inline void ___constructor__F_P3ss4_autogen___2(struct s4 *___dst__P3ss4_2){
         ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))) /* ?{} */);
@@ -148 +149 @@
         ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))) /* ^?{} */);
     }
-    inline struct s4 ___operator_assign__F3ss4_P3ss43ss4_autogen___2(struct s4 *___dst__P3ss4_2, struct s4 ___src__3ss4_2){
-        ((void)((*___dst__P3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
-        return ((struct s4 )___src__3ss4_2);
-    }
     inline void ___constructor__F_P3ss4i_autogen___2(struct s4 *___dst__P3ss4_2, int __i__i_2){
         ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))=__i__i_2) /* ?{} */);
@@ -160 +157 @@
     int __m2__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
     int __m3__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
-    ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
-    return ((int )___retval_main__i_1);
+    int _retVal0 = { 0 };
+    ((void)(_retVal0=((int )0)) /* ?{} */);
+    return ((int )_retVal0);
 }

src/tests/.expect/64/declarationSpecifier.txt

@@ -20 +20 @@
 static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
 static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1);
-static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))=___src__13s__anonymous0_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     ((void)((*___dst__P13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
     return ((struct __anonymous0 )___src__13s__anonymous0_1);
+}
+static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))=___src__13s__anonymous0_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, int __i__i_1){
@@ -44 +44 @@
 static inline void ___constructor__F_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
 static inline void ___destructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1);
-static inline void ___constructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))=___src__13s__anonymous1_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
     ((void)((*___dst__P13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
     return ((struct __anonymous1 )___src__13s__anonymous1_1);
+}
+static inline void ___constructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))=___src__13s__anonymous1_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, int __i__i_1){
@@ -68 +68 @@
 static inline void ___constructor__F_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
 static inline void ___destructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1);
-static inline void ___constructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))=___src__13s__anonymous2_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     ((void)((*___dst__P13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
     return ((struct __anonymous2 )___src__13s__anonymous2_1);
+}
+static inline void ___constructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))=___src__13s__anonymous2_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, int __i__i_1){
@@ -92 +92 @@
 static inline void ___constructor__F_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
 static inline void ___destructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1);
-static inline void ___constructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))=___src__13s__anonymous3_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
     ((void)((*___dst__P13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
     return ((struct __anonymous3 )___src__13s__anonymous3_1);
+}
+static inline void ___constructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))=___src__13s__anonymous3_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, int __i__i_1){
@@ -116 +116 @@
 static inline void ___constructor__F_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
 static inline void ___destructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1);
-static inline void ___constructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))=___src__13s__anonymous4_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
     ((void)((*___dst__P13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
     return ((struct __anonymous4 )___src__13s__anonymous4_1);
+}
+static inline void ___constructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))=___src__13s__anonymous4_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, int __i__i_1){
@@ -140 +140 @@
 static inline void ___constructor__F_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
 static inline void ___destructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1);
-static inline void ___constructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))=___src__13s__anonymous5_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
     ((void)((*___dst__P13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
     return ((struct __anonymous5 )___src__13s__anonymous5_1);
+}
+static inline void ___constructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))=___src__13s__anonymous5_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, int __i__i_1){
@@ -164 +164 @@
 static inline void ___constructor__F_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
 static inline void ___destructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1);
-static inline void ___constructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))=___src__13s__anonymous6_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
     ((void)((*___dst__P13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
     return ((struct __anonymous6 )___src__13s__anonymous6_1);
+}
+static inline void ___constructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))=___src__13s__anonymous6_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, int __i__i_1){
@@ -188 +188 @@
 static inline void ___constructor__F_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
 static inline void ___destructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1);
-static inline void ___constructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))=___src__13s__anonymous7_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1){
-    ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
     ((void)((*___dst__P13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
     return ((struct __anonymous7 )___src__13s__anonymous7_1);
+}
+static inline void ___constructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))=___src__13s__anonymous7_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1){
+    ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, int __i__i_1){
@@ -220 +220 @@
 static inline void ___constructor__F_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
 static inline void ___destructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1);
-static inline void ___constructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1){
-    ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
-    ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))=___src__13s__anonymous8_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1){
-    ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
     ((void)((*___dst__P13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
     return ((struct __anonymous8 )___src__13s__anonymous8_1);
+}
+static inline void ___constructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1){
+    ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
+    ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))=___src__13s__anonymous8_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1){
+    ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, short __i__s_1){
@@ -244 +244 @@
 static inline void ___constructor__F_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
 static inline void ___destructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1);
-static inline void ___constructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1){
-    ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
-    ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))=___src__13s__anonymous9_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1){
-    ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
     ((void)((*___dst__P13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
     return ((struct __anonymous9 )___src__13s__anonymous9_1);
+}
+static inline void ___constructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1){
+    ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
+    ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))=___src__13s__anonymous9_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1){
+    ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, short __i__s_1){
@@ -268 +268 @@
 static inline void ___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
 static inline void ___destructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1);
-static inline void ___constructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))=___src__14s__anonymous10_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
     ((void)((*___dst__P14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
     return ((struct __anonymous10 )___src__14s__anonymous10_1);
+}
+static inline void ___constructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))=___src__14s__anonymous10_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, short __i__s_1){
@@ -292 +292 @@
 static inline void ___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
 static inline void ___destructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1);
-static inline void ___constructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))=___src__14s__anonymous11_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
     ((void)((*___dst__P14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
     return ((struct __anonymous11 )___src__14s__anonymous11_1);
+}
+static inline void ___constructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))=___src__14s__anonymous11_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, short __i__s_1){
@@ -316 +316 @@
 static inline void ___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
 static inline void ___destructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1);
-static inline void ___constructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))=___src__14s__anonymous12_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
     ((void)((*___dst__P14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
     return ((struct __anonymous12 )___src__14s__anonymous12_1);
+}
+static inline void ___constructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))=___src__14s__anonymous12_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, short __i__s_1){
@@ -340 +340 @@
 static inline void ___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
 static inline void ___destructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1);
-static inline void ___constructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))=___src__14s__anonymous13_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
     ((void)((*___dst__P14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
     return ((struct __anonymous13 )___src__14s__anonymous13_1);
+}
+static inline void ___constructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))=___src__14s__anonymous13_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, short __i__s_1){
@@ -364 +364 @@
 static inline void ___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
 static inline void ___destructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1);
-static inline void ___constructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))=___src__14s__anonymous14_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
     ((void)((*___dst__P14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
     return ((struct __anonymous14 )___src__14s__anonymous14_1);
+}
+static inline void ___constructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))=___src__14s__anonymous14_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, short __i__s_1){
@@ -388 +388 @@
 static inline void ___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
 static inline void ___destructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1);
-static inline void ___constructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))=___src__14s__anonymous15_1.__i__s_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1){
-    ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))) /* ^?{} */);
-}
 static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
     ((void)((*___dst__P14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
     return ((struct __anonymous15 )___src__14s__anonymous15_1);
+}
+static inline void ___constructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))=___src__14s__anonymous15_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1){
+    ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, short __i__s_1){
@@ -428 +428 @@
 static inline void ___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
 static inline void ___destructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1);
-static inline void ___constructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))=___src__14s__anonymous16_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
     ((void)((*___dst__P14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
     return ((struct __anonymous16 )___src__14s__anonymous16_1);
+}
+static inline void ___constructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))=___src__14s__anonymous16_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, int __i__i_1){
@@ -452 +452 @@
 static inline void ___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
 static inline void ___destructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1);
-static inline void ___constructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))=___src__14s__anonymous17_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
     ((void)((*___dst__P14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
     return ((struct __anonymous17 )___src__14s__anonymous17_1);
+}
+static inline void ___constructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))=___src__14s__anonymous17_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, int __i__i_1){
@@ -476 +476 @@
 static inline void ___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
 static inline void ___destructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1);
-static inline void ___constructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))=___src__14s__anonymous18_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
     ((void)((*___dst__P14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
     return ((struct __anonymous18 )___src__14s__anonymous18_1);
+}
+static inline void ___constructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))=___src__14s__anonymous18_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, int __i__i_1){
@@ -500 +500 @@
 static inline void ___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
 static inline void ___destructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1);
-static inline void ___constructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))=___src__14s__anonymous19_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
     ((void)((*___dst__P14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
     return ((struct __anonymous19 )___src__14s__anonymous19_1);
+}
+static inline void ___constructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))=___src__14s__anonymous19_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, int __i__i_1){
@@ -524 +524 @@
 static inline void ___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
 static inline void ___destructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1);
-static inline void ___constructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))=___src__14s__anonymous20_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
     ((void)((*___dst__P14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
     return ((struct __anonymous20 )___src__14s__anonymous20_1);
+}
+static inline void ___constructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))=___src__14s__anonymous20_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, int __i__i_1){
@@ -548 +548 @@
 static inline void ___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
 static inline void ___destructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1);
-static inline void ___constructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))=___src__14s__anonymous21_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
     ((void)((*___dst__P14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
     return ((struct __anonymous21 )___src__14s__anonymous21_1);
+}
+static inline void ___constructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))=___src__14s__anonymous21_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, int __i__i_1){
@@ -572 +572 @@
 static inline void ___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
 static inline void ___destructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1);
-static inline void ___constructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))=___src__14s__anonymous22_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
     ((void)((*___dst__P14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
     return ((struct __anonymous22 )___src__14s__anonymous22_1);
+}
+static inline void ___constructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))=___src__14s__anonymous22_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, int __i__i_1){
@@ -596 +596 @@
 static inline void ___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
 static inline void ___destructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1);
-static inline void ___constructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))) /* ?{} */);
-}
-static inline void ___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))=___src__14s__anonymous23_1.__i__i_1) /* ?{} */);
-}
-static inline void ___destructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1){
-    ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))) /* ^?{} */);
-}
 static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
     ((void)((*___dst__P14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
     return ((struct __anonymous23 )___src__14s__anonymous23_1);
+}
+static inline void ___constructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))) /* ?{} */);
+}
+static inline void ___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))=___src__14s__anonymous23_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1){
+    ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))) /* ^?{} */);
 }
 static inline void ___constructor__F_P14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, int __i__i_1){
@@ -622 +622 @@
 static inline volatile const short __f48__FCVs___1();
 int main(int __argc__i_1, const char **__argv__PPCc_1){
-    int ___retval_main__i_1;
-    ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
-    return ((int )___retval_main__i_1);
-}
+    int _retVal0 = { 0 };
+    ((void)(_retVal0=((int )0)) /* ?{} */);
+    return ((int )_retVal0);
+}

src/tests/.expect/64/extension.txt

@@ -17 +17 @@
 static inline void ___constructor__F_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1);
 static inline void ___destructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1);
+static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
+    ((void)((*___dst__P2sS_1).__a__i_1=___src__2sS_1.__a__i_1));
+    ((void)((*___dst__P2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
+    ((void)((*___dst__P2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
+    return ((struct S )___src__2sS_1);
+}
 static inline void ___constructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))) /* ?{} */);
@@ -31 +37 @@
     ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))) /* ^?{} */);
-}
-static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
-    ((void)((*___dst__P2sS_1).__a__i_1=___src__2sS_1.__a__i_1));
-    ((void)((*___dst__P2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
-    ((void)((*___dst__P2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
-    return ((struct S )___src__2sS_1);
 }
 static inline void ___constructor__F_P2sSi_autogen___1(struct S *___dst__P2sS_1, int __a__i_1){
@@ -58 +58 @@
     __extension__ int __c__i_1;
 };
+static inline union U ___operator_assign__F2uU_P2uU2uU_autogen___1(union U *___dst__P2uU_1, union U ___src__2uU_1){
+    ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+    return ((union U )___src__2uU_1);
+}
 static inline void ___constructor__F_P2uU_autogen___1(union U *___dst__P2uU_1){
 }
 static inline void ___constructor__F_P2uU2uU_autogen___1(union U *___dst__P2uU_1, union U ___src__2uU_1){
     ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+    return ((void)___src__2uU_1);
 }
 static inline void ___destructor__F_P2uU_autogen___1(union U *___dst__P2uU_1){
-}
-static inline union U ___operator_assign__F2uU_P2uU2uU_autogen___1(union U *___dst__P2uU_1, union U ___src__2uU_1){
-    ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
-    return ((union U )___src__2uU_1);
 }
 static inline void ___constructor__F_P2uUi_autogen___1(union U *___dst__P2uU_1, int __src__i_1){
@@ -78 +79 @@
 };
 __extension__ int __fred__Fi_i__1(int __p__i_1){
-    int ___retval_fred__i_1;
     __extension__ struct S {
         __extension__ int __a__i_2;

src/tests/.expect/64/gccExtensions.txt

@@ -7 +7 @@
 extern int __x__i_1 asm ( "xx" );
 int main(int __argc__i_1, const char **__argv__PPCc_1){
-    int ___retval_main__i_1;
     asm ( "nop" :  :  :  );
     asm ( "nop" :  :  :  );
@@ -26 +25 @@
     const int __i3__Ci_2;
     inline int __f1__Fi___2(){
-        int ___retval_f1__i_2;
     }
     inline int __f2__Fi___2(){
-        int ___retval_f2__i_2;
     }
     int __s1__i_2;
@@ -43 +40 @@
         __extension__ int __c__i_2;
     };
+    inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___2(struct S *___dst__P2sS_2, struct S ___src__2sS_2){
+        ((void)((*___dst__P2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
+        ((void)((*___dst__P2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
+        ((void)((*___dst__P2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
+        return ((struct S )___src__2sS_2);
+    }
     inline void ___constructor__F_P2sS_autogen___2(struct S *___dst__P2sS_2){
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))) /* ?{} */);
@@ -57 +60 @@
         ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))) /* ^?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))) /* ^?{} */);
-    }
-    inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___2(struct S *___dst__P2sS_2, struct S ___src__2sS_2){
-        ((void)((*___dst__P2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
-        ((void)((*___dst__P2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
-        ((void)((*___dst__P2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
-        return ((struct S )___src__2sS_2);
     }
     inline void ___constructor__F_P2sSi_autogen___2(struct S *___dst__P2sS_2, int __a__i_2){
@@ -99 +96 @@
         int __i__i_2;
     };
+    inline struct s2 ___operator_assign__F3ss2_P3ss23ss2_autogen___2(struct s2 *___dst__P3ss2_2, struct s2 ___src__3ss2_2){
+        ((void)((*___dst__P3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
+        return ((struct s2 )___src__3ss2_2);
+    }
     inline void ___constructor__F_P3ss2_autogen___2(struct s2 *___dst__P3ss2_2){
         ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))) /* ?{} */);
@@ -108 +109 @@
         ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))) /* ^?{} */);
     }
-    inline struct s2 ___operator_assign__F3ss2_P3ss23ss2_autogen___2(struct s2 *___dst__P3ss2_2, struct s2 ___src__3ss2_2){
-        ((void)((*___dst__P3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
-        return ((struct s2 )___src__3ss2_2);
-    }
     inline void ___constructor__F_P3ss2i_autogen___2(struct s2 *___dst__P3ss2_2, int __i__i_2){
         ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))=__i__i_2) /* ?{} */);
@@ -118 +115 @@
         int __i__i_2;
     };
+    inline struct s3 ___operator_assign__F3ss3_P3ss33ss3_autogen___2(struct s3 *___dst__P3ss3_2, struct s3 ___src__3ss3_2){
+        ((void)((*___dst__P3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
+        return ((struct s3 )___src__3ss3_2);
+    }
     inline void ___constructor__F_P3ss3_autogen___2(struct s3 *___dst__P3ss3_2){
         ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))) /* ?{} */);
@@ -127 +128 @@
         ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))) /* ^?{} */);
     }
-    inline struct s3 ___operator_assign__F3ss3_P3ss33ss3_autogen___2(struct s3 *___dst__P3ss3_2, struct s3 ___src__3ss3_2){
-        ((void)((*___dst__P3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
-        return ((struct s3 )___src__3ss3_2);
-    }
     inline void ___constructor__F_P3ss3i_autogen___2(struct s3 *___dst__P3ss3_2, int __i__i_2){
         ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))=__i__i_2) /* ?{} */);
@@ -139 +136 @@
         int __i__i_2;
     };
+    inline struct s4 ___operator_assign__F3ss4_P3ss43ss4_autogen___2(struct s4 *___dst__P3ss4_2, struct s4 ___src__3ss4_2){
+        ((void)((*___dst__P3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
+        return ((struct s4 )___src__3ss4_2);
+    }
     inline void ___constructor__F_P3ss4_autogen___2(struct s4 *___dst__P3ss4_2){
         ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))) /* ?{} */);
@@ -148 +149 @@
         ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))) /* ^?{} */);
     }
-    inline struct s4 ___operator_assign__F3ss4_P3ss43ss4_autogen___2(struct s4 *___dst__P3ss4_2, struct s4 ___src__3ss4_2){
-        ((void)((*___dst__P3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
-        return ((struct s4 )___src__3ss4_2);
-    }
     inline void ___constructor__F_P3ss4i_autogen___2(struct s4 *___dst__P3ss4_2, int __i__i_2){
         ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))=__i__i_2) /* ?{} */);
@@ -160 +157 @@
     int __m2__A0A0i_2[((long unsigned int )10)][((long unsigned int )10)];
     int __m3__A0A0i_2[((long unsigned int )10)][((long unsigned int )10)];
-    ((void)(___retval_main__i_1=((int )0)) /* ?{} */);
-    return ((int )___retval_main__i_1);
+    int _retVal0 = { 0 };
+    ((void)(_retVal0=((int )0)) /* ?{} */);
+    return ((int )_retVal0);
 }

src/tests/.expect/castError.txt

@@ -1 @@
-Error: Can't choose between 3 alternatives for expression Cast of:
+Error: Can't choose between alternatives for expression Cast of:
   Name: f
 

src/tests/.expect/memberCtors.txt

@@ -6 +6 @@
 constructing int
 constructing int
-begin construct B
-assign b->a2
 constructing int
 constructing int
-begin construct A
-construct a->x
 constructing int: 1001
-assign a->y
 assigning int: 0 0
-end construct A
-construct b->a1
 constructing int
 constructing int
-begin construct A
-construct a->x
 constructing int: 1000
-assign a->y
 assigning int: 0 0
-end construct A
-end construct B
 destructing int: 0
 destructing int: 0
@@ -32 +20 @@
 copy constructing int: 0
 copy constructing int: 0
-begin copy construct A
-copy construct this->x
 copy constructing int: 1000
-assign this->y
-end copy construct A
 copy constructing int: 0
 copy constructing int: 0
-begin copy construct A
-copy construct this->x
 copy constructing int: 1001
-assign this->y
-end copy construct A
 copy constructing int: 0
 copy constructing int: 0
-begin copy construct A
-copy construct this->x
 copy constructing int: 0
-assign this->y
-end copy construct A
 End of main
 constructing int
 constructing int
-begin construct A
-construct a->x
 constructing int: 999
-assign a->y
 assigning int: 0 0
-end construct A
 destructing int: 0
 destructing int: 0
@@ -74 +46 @@
 constructing int
 constructing int
-begin construct A
-construct a->x
 constructing int: 999
-assign a->y
 assigning int: 0 0
-end construct A
 destructing int: 0
 destructing int: 0

src/tests/.expect/scopeErrors.txt

@@ -4 +4 @@
     double
   returning 
-    _retval_butThisIsAnError: double
+    double
   with body 
     CompoundStmt

src/tests/Makefile.am

@@ -67 +67 @@
 memberCtors-ERR1: memberCtors.c
         ${CC} ${CFLAGS} -DERR1 ${<} -o ${@}
-
-completeTypeError : completeTypeError.c
-        ${CC} ${CFLAGS} -DERR1 ${<} -o ${@}

src/tests/Makefile.in

@@ -689 +689 @@
         ${CC} ${CFLAGS} -DERR1 ${<} -o ${@}
 
-completeTypeError : completeTypeError.c
-        ${CC} ${CFLAGS} -DERR1 ${<} -o ${@}
-
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.

src/tests/memberCtors.c

@@ -32 +32 @@
 
 void ?{}(A * a, int x) {
-  printf("begin construct A\n");
-  printf("construct a->x\n");
   (&a->x){ x+999 };
-  printf("assign a->y\n");
   a->y = 0; // not a constructor - default constructor will be inserted
-  printf("end construct A\n");
 } // z never constructed - will be automatically default constructed
 
 void ?{}(A * this, A other) {
-  printf("begin copy construct A\n");
-  printf("copy construct this->x\n");
   (&this->x){ other.x };
-  printf("assign this->y\n");
   this->y = other.y; // not a constructor - copy constructor will be inserted
-  printf("end copy construct A\n");
 } // z never constructed - will be automatically copy constructed
 
@@ -54 +46 @@
 
 void ?{}(B * b) {
-  printf("begin construct B\n");
-  printf("assign b->a2\n");
   b->a2 = (A) { 2 };
-  printf("construct b->a1\n");
   (&b->a1){ 1 };
 #ifdef ERR1
   (&b->a2){ b->a3 }; // error, b->a2 was used previously but is explicitly constructed
 #endif
-  printf("end construct B\n");
 } // a2, a3 never constructed - will be automatically default constructed
 

src/tests/shortCircuit.c

@@ -11 +11 @@
 
 void g() {
-        int a;
-        struct { int b; } a;
-        if ( a ) {
+    int a;
+    struct { int b; } a;
+    if ( a ) {
                 while ( a ) {
                         int *b;
@@ -19 +19 @@
                         }
                 }
-        }
+    }
 }
 

src/tests/tupleAssign.c

@@ -1 @@
-//
-// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// tupleAssign.c --
-//
-// Author           : Rob Schluntz
-// Created On       : Tue Nov 15 17:24:32 2016
-// Last Modified By : Rob Schluntz
-// Last Modified On : Tue Nov 15 17:27:28 2016
-// Update Count     : 3
-//
-
 int main() {
         {
@@ -54 +39 @@
         }
 }
-
-// Local Variables: //
-// tab-width: 4 //
-// End: //

src/tests/tupleFunction.c

@@ -1 @@
-//
-// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// tupleFunction.c --
-//
-// Author           : Rob Schluntz
-// Created On       : Tue Nov 15 17:24:32 2016
-// Last Modified By : Rob Schluntz
-// Last Modified On : Tue Nov 15 17:27:28 2016
-// Update Count     : 3
-//
-
 struct S {
         int f1, f2;
@@ -51 +36 @@
 }
 
+// forall(otype T | { T ?+?(T, T); })
+// [T, T, T] ?+?([T, T, T] x, [T, T, T] y) {
+//      T x1, x2, x3, y1, y2, y3;
+//      [x1, x2, x3] = x;
+//      [y1, y2, y3] = y;
+//      return [x1+y1, x2+y2, x3+y3];
+// }
+
 int main() {
-        [int, double, int] x = [777, 2.76, 8675];
-        int x1 = 123, x3 = 456;
-        double x2 = 999.123;
+  [int, double, int] x = [777, 2.76, 8675];
+  int x1 = 123, x3 = 456;
+  double x2 = 999.123;
 
-        printf("foo(...)=%d\n", foo(x1, x3, x2, (S){ 321, 654, 'Q', 3.14 }));
+  printf("foo(...)=%d\n", foo(x1, x3, x2, (S){ 321, 654, 'Q', 3.14 }));
 
         // call function with tuple parameter using tuple variable arg
@@ -83 +76 @@
         [x1, x2, x3] = quux();
         printf("x1=%d x2=%lg x3=%d\n", x1, x2, x3);
-
-        // xxx - tuples of type parameters should come out as generic types?
-        // [x1, x2, x3] = ([(int)x1, (int)x2, (int)x3]) + ([(int)1, (int)2, (int)3]);
-        // ([(int)x1, (int)x2, (int)x3]) + ([(int)1, (int)2, (int)3]);
-        // printf("%d %g %d\n", x1, x2, x3);
-
-        // xxx - comes out the back as a cast, but should come out as a tuple expression of the first n fields cast to each of the result types
-        // ([int, double])x;
 }
-
-// Local Variables: //
-// tab-width: 4 //
-// End: //
-

src/tests/tupleMember.c

@@ -1 @@
-//
-// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// tupleFunction.c --
-//
-// Author           : Rob Schluntz
-// Created On       : Tue Nov 15 17:24:32 2016
-// Last Modified By : Rob Schluntz
-// Last Modified On : Tue Nov 15 17:27:28 2016
-// Update Count     : 3
-//
-
 void f() {
         printf("called f!\n");
@@ -56 +41 @@
         printf("v.[f1, i.[f2, f3], f4]=[%d, [%d, %d], %lg]\n", h().[f1, i.[f2, f3], f4]);
 }
-
-// Local Variables: //
-// tab-width: 4 //
-// End: //