Changes in src/SymTab/Validate.cc [74d1804:b644d6f]

File:

• src/SymTab/Validate.cc (modified) (16 diffs)

src/SymTab/Validate.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:50:04 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Wed May 11 13:17:52 2016
-// Update Count     : 297
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Apr 13 16:39:30 2016
+// Update Count     : 251
 //
 
@@ -56 +56 @@
 #include "MakeLibCfa.h"
 #include "TypeEquality.h"
-#include "Autogen.h"
 #include "ResolvExpr/typeops.h"
 
@@ -123 +122 @@
 
                 const Indexer *indexer;
+        };
+
+        class AutogenerateRoutines : public Visitor {
+          public:
+                /// Generates assignment operators for aggregate types as required
+                static void autogenerateRoutines( std::list< Declaration * > &translationUnit );
+
+                std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
+
+                virtual void visit( EnumDecl *enumDecl );
+                virtual void visit( StructDecl *structDecl );
+                virtual void visit( UnionDecl *structDecl );
+                virtual void visit( TypeDecl *typeDecl );
+                virtual void visit( TraitDecl *ctxDecl );
+                virtual void visit( FunctionDecl *functionDecl );
+
+                virtual void visit( FunctionType *ftype );
+                virtual void visit( PointerType *ftype );
+
+                virtual void visit( CompoundStmt *compoundStmt );
+                virtual void visit( SwitchStmt *switchStmt );
+                virtual void visit( ChooseStmt *chooseStmt );
+                // virtual void visit( CaseStmt *caseStmt );
+
+                AutogenerateRoutines() : functionNesting( 0 ) {}
+          private:
+                template< typename StmtClass > void visitStatement( StmtClass *stmt );
+
+                std::list< Declaration * > declsToAdd;
+                std::set< std::string > structsDone;
+                unsigned int functionNesting;                   // current level of nested functions
         };
 
@@ -162 +192 @@
                 template<typename AggDecl>
                 void addImplicitTypedef( AggDecl * aggDecl );
-
+                
                 typedef std::map< std::string, std::pair< TypedefDecl *, int > > TypedefMap;
                 TypedefMap typedefNames;
                 int scopeLevel;
         };
-
-        class VerifyCtorDtor : public Visitor {
-        public:
-                /// ensure that constructors and destructors have at least one
-                /// parameter, the first of which must be a pointer, and no
-                /// return values.
-                static void verify( std::list< Declaration * > &translationUnit );
-
-                virtual void visit( FunctionDecl *funcDecl );
-};
 
         class CompoundLiteral : public GenPoly::DeclMutator {
@@ -197 +217 @@
                 ReturnChecker::checkFunctionReturns( translationUnit );
                 mutateAll( translationUnit, compoundliteral );
-                autogenerateRoutines( translationUnit );
+                AutogenerateRoutines::autogenerateRoutines( translationUnit );
                 acceptAll( translationUnit, pass3 );
-                VerifyCtorDtor::verify( translationUnit );
         }
 
@@ -209 +228 @@
                 type->accept( pass2 );
                 type->accept( pass3 );
+        }
+
+        template< typename Visitor >
+        void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor, bool addBefore ) {
+                std::list< Declaration * >::iterator i = translationUnit.begin();
+                while ( i != translationUnit.end() ) {
+                        (*i)->accept( visitor );
+                        std::list< Declaration * >::iterator next = i;
+                        next++;
+                        if ( ! visitor.get_declsToAdd().empty() ) {
+                                translationUnit.splice( addBefore ? i : next, visitor.get_declsToAdd() );
+                        } // if
+                        i = next;
+                } // while
         }
 
@@ -279 +312 @@
         void Pass1::visit( EnumDecl *enumDecl ) {
                 // Set the type of each member of the enumeration to be EnumConstant
+
                 for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) {
                         ObjectDecl * obj = dynamic_cast< ObjectDecl * >( *i );
                         assert( obj );
-                        obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false, false ), enumDecl->get_name() ) );
+                        // obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false, false ), enumDecl->get_name() ) );
+                        BasicType * enumType = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
+                        obj->set_type( enumType ) ;
                 } // for
                 Parent::visit( enumDecl );
@@ -288 +324 @@
 
         namespace {
-                template< typename DWTList >
-                void fixFunctionList( DWTList & dwts, FunctionType * func ) {
+                template< typename DWTIterator >
+                void fixFunctionList( DWTIterator begin, DWTIterator end, FunctionType *func ) {
                         // the only case in which "void" is valid is where it is the only one in the list; then it should be removed
                         // entirely other fix ups are handled by the FixFunction class
-                        typedef typename DWTList::iterator DWTIterator;
-                        DWTIterator begin( dwts.begin() ), end( dwts.end() );
                         if ( begin == end ) return;
                         FixFunction fixer;
                         DWTIterator i = begin;
-                        *i = (*i)->acceptMutator( fixer );
+                        *i = (*i )->acceptMutator( fixer );
                         if ( fixer.get_isVoid() ) {
                                 DWTIterator j = i;
                                 ++i;
-                                dwts.erase( j );
+                                func->get_parameters().erase( j );
                                 if ( i != end ) {
                                         throw SemanticError( "invalid type void in function type ", func );
@@ -320 +354 @@
         void Pass1::visit( FunctionType *func ) {
                 // Fix up parameters and return types
-                fixFunctionList( func->get_parameters(), func );
-                fixFunctionList( func->get_returnVals(), func );
+                fixFunctionList( func->get_parameters().begin(), func->get_parameters().end(), func );
+                fixFunctionList( func->get_returnVals().begin(), func->get_returnVals().end(), func );
                 Visitor::visit( func );
         }
@@ -384 +418 @@
 
         void Pass2::visit( StructDecl *structDecl ) {
-                // visit struct members first so that the types of self-referencing members are updated properly
-                Parent::visit( structDecl );
                 if ( ! structDecl->get_members().empty() ) {
                         ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->get_name() );
@@ -395 +427 @@
                         } // if
                 } // if
+                Indexer::visit( structDecl );
         }
 
         void Pass2::visit( UnionDecl *unionDecl ) {
-                Parent::visit( unionDecl );
                 if ( ! unionDecl->get_members().empty() ) {
                         ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->get_name() );
@@ -408 +440 @@
                         } // if
                 } // if
+                Indexer::visit( unionDecl );
         }
 
@@ -470 +503 @@
         }
 
+        static const std::list< std::string > noLabels;
+
+        void AutogenerateRoutines::autogenerateRoutines( std::list< Declaration * > &translationUnit ) {
+                AutogenerateRoutines visitor;
+                acceptAndAdd( translationUnit, visitor, false );
+        }
+
+        template< typename OutputIterator >
+        void makeScalarAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, OutputIterator out ) {
+                ObjectDecl *obj = dynamic_cast<ObjectDecl *>( member );
+                // unnamed bit fields are not copied as they cannot be accessed
+                if ( obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL ) return;
+
+                UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
+
+                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
+                derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
+
+                // do something special for unnamed members
+                Expression *dstselect = new AddressExpr( new MemberExpr( member, derefExpr ) );
+                assignExpr->get_args().push_back( dstselect );
+
+                Expression *srcselect = new MemberExpr( member, new VariableExpr( srcParam ) );
+                assignExpr->get_args().push_back( srcselect );
+
+                *out++ = new ExprStmt( noLabels, assignExpr );
+        }
+
+        template< typename OutputIterator >
+        void makeArrayAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, ArrayType *array, OutputIterator out ) {
+                static UniqueName indexName( "_index" );
+
+                // for a flexible array member nothing is done -- user must define own assignment
+                if ( ! array->get_dimension() ) return;
+
+                ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 );
+                *out++ = new DeclStmt( noLabels, index );
+
+                UntypedExpr *init = new UntypedExpr( new NameExpr( "?=?" ) );
+                init->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
+                init->get_args().push_back( new NameExpr( "0" ) );
+                Statement *initStmt = new ExprStmt( noLabels, init );
+                std::list<Statement *> initList;
+                initList.push_back( initStmt );
+
+                UntypedExpr *cond = new UntypedExpr( new NameExpr( "?<?" ) );
+                cond->get_args().push_back( new VariableExpr( index ) );
+                cond->get_args().push_back( array->get_dimension()->clone() );
+
+                UntypedExpr *inc = new UntypedExpr( new NameExpr( "++?" ) );
+                inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
+
+                UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
+
+                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
+                derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
+
+                Expression *dstselect = new MemberExpr( member, derefExpr );
+                UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?+?" ) );
+                dstIndex->get_args().push_back( dstselect );
+                dstIndex->get_args().push_back( new VariableExpr( index ) );
+                assignExpr->get_args().push_back( dstIndex );
+
+                Expression *srcselect = new MemberExpr( member, new VariableExpr( srcParam ) );
+                UntypedExpr *srcIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
+                srcIndex->get_args().push_back( srcselect );
+                srcIndex->get_args().push_back( new VariableExpr( index ) );
+                assignExpr->get_args().push_back( srcIndex );
+
+                *out++ = new ForStmt( noLabels, initList, cond, inc, new ExprStmt( noLabels, assignExpr ) );
+        }
+
+        template< typename OutputIterator >
+        void makeUnionFieldsAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, UnionInstType *unionType, 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( unionType ) );
+
+                *out++ = new ExprStmt( noLabels, copy );
+        }
+
+        //E ?=?(E volatile*, int),
+        //  ?=?(E _Atomic volatile*, int);
+        void makeEnumAssignment( EnumDecl *enumDecl, EnumInstType *refType, unsigned int functionNesting, std::list< Declaration * > &declsToAdd ) {
+                FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
+
+                ObjectDecl *returnVal = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
+                assignType->get_returnVals().push_back( returnVal );
+
+                // need two assignment operators with different types
+                FunctionType * assignType2 = assignType->clone();
+
+                // E ?=?(E volatile *, E)
+                Type *etype = refType->clone();
+                // etype->get_qualifiers() += Type::Qualifiers(false, true, false, false, false, false);
+
+                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), etype ), 0 );
+                assignType->get_parameters().push_back( dstParam );
+
+                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, etype->clone(), 0 );
+                assignType->get_parameters().push_back( srcParam );
+
+                // E ?=?(E volatile *, int)
+                assignType2->get_parameters().push_back( dstParam->clone() );
+                BasicType * paramType = new BasicType(Type::Qualifiers(), BasicType::SignedInt);
+                ObjectDecl *srcParam2 = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, paramType, 0 );
+                assignType2->get_parameters().push_back( srcParam2 );
+
+                // 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.
+
+                // since there is no definition, these should not be inline
+                // make these intrinsic so that the code generator does not make use of them
+                FunctionDecl *assignDecl = new FunctionDecl( "?=?", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::Intrinsic, assignType, 0, false, false );
+                assignDecl->fixUniqueId();
+                FunctionDecl *assignDecl2 = new FunctionDecl( "?=?", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::Intrinsic, assignType2, 0, false, false );
+                assignDecl2->fixUniqueId();
+
+                // these should be built in the same way that the prelude
+                // functions are, so build a list containing the prototypes
+                // and allow MakeLibCfa to autogenerate the bodies.
+                std::list< Declaration * > assigns;
+                assigns.push_back( assignDecl );
+                assigns.push_back( assignDecl2 );
+
+                LibCfa::makeLibCfa( assigns );
+
+                // need to remove the prototypes, since this may be nested in a routine
+                for (int start = 0, end = assigns.size()/2; start < end; start++) {
+                        delete assigns.front();
+                        assigns.pop_front();
+                } // for
+
+                declsToAdd.insert( declsToAdd.begin(), assigns.begin(), assigns.end() );
+        }
+
+        /// 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 ?=? assertion (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 ) {
+                        // just include assignment operator assertion
+                        TypeInstType *assignParamType = new TypeInstType( Type::Qualifiers(), name, dst );
+                        FunctionType *assignFunctionType = new FunctionType( Type::Qualifiers(), false );
+                        assignFunctionType->get_returnVals().push_back(
+                                new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, assignParamType->clone(), 0 ) );
+                        assignFunctionType->get_parameters().push_back(
+                                new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), assignParamType->clone() ), 0 ) );
+                        assignFunctionType->get_parameters().push_back(
+                                new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, assignParamType, 0 ) );
+                        FunctionDecl *assignAssert = new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignFunctionType, 0, false, false );
+                        dst->get_assertions().push_back( assignAssert );
+                }
+
+                return dst;
+        }
+
+        Declaration *makeStructAssignment( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting ) {
+                FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
+
+                // Make function polymorphic in same parameters as generic struct, if applicable
+                bool isGeneric = 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 ) {
+                        isGeneric = 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 *returnVal = new ObjectDecl( "_ret", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, structParams ), 0 );
+                assignType->get_returnVals().push_back( returnVal );
+
+                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), cloneWithParams( refType, structParams ) ), 0 );
+                assignType->get_parameters().push_back( dstParam );
+
+                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, structParams ), 0 );
+                assignType->get_parameters().push_back( srcParam );
+
+                // 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 );
+                assignDecl->fixUniqueId();
+
+                for ( std::list< Declaration * >::const_iterator member = aggregateDecl->get_members().begin(); member != aggregateDecl->get_members().end(); ++member ) {
+                        if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member ) ) {
+                                // query the type qualifiers of this field and skip assigning it if it is marked const.
+                                // If it is an array type, we need to strip off the array layers to find its qualifiers.
+                                Type * type = dwt->get_type();
+                                while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
+                                        type = at->get_base();
+                                }
+
+                                if ( type->get_qualifiers().isConst ) {
+                                        // don't assign const members
+                                        continue;
+                                }
+
+                                if ( isGeneric ) {
+                                        // rewrite member type in terms of the type variables on this operator
+                                        DeclarationWithType *fixedMember = dwt->clone();
+                                        genericSubs.apply( fixedMember );
+
+                                        // assign to both destination and return value
+                                        if ( ArrayType *array = dynamic_cast< ArrayType * >( fixedMember->get_type() ) ) {
+                                                makeArrayAssignment( srcParam, dstParam, fixedMember, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                                                makeArrayAssignment( srcParam, returnVal, fixedMember, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                                        } else {
+                                                makeScalarAssignment( srcParam, dstParam, fixedMember, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                                                makeScalarAssignment( srcParam, returnVal, fixedMember, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                                        } // if
+                                } else {
+                                        // assign to destination
+                                        if ( ArrayType *array = dynamic_cast< ArrayType * >( dwt->get_type() ) ) {
+                                                makeArrayAssignment( srcParam, dstParam, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                                        } else {
+                                                makeScalarAssignment( srcParam, dstParam, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                                        } // if
+                                } // if
+                        } // if
+                } // for
+                if ( ! isGeneric ) assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+
+                return assignDecl;
+        }
+
+        Declaration *makeUnionAssignment( UnionDecl *aggregateDecl, UnionInstType *refType, unsigned int functionNesting ) {
+                FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
+
+                // Make function polymorphic in same parameters as generic union, if applicable
+                bool isGeneric = 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 ) {
+                        isGeneric = 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 *returnVal = new ObjectDecl( "_ret", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, unionParams ), 0 );
+                assignType->get_returnVals().push_back( returnVal );
+
+                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), cloneWithParams( refType, unionParams ) ), 0 );
+                assignType->get_parameters().push_back( dstParam );
+
+                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, unionParams ), 0 );
+                assignType->get_parameters().push_back( srcParam );
+
+                // 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 );
+                assignDecl->fixUniqueId();
+
+                makeUnionFieldsAssignment( srcParam, dstParam, cloneWithParams( refType, unionParams ), back_inserter( assignDecl->get_statements()->get_kids() ) );
+                if ( isGeneric ) makeUnionFieldsAssignment( srcParam, returnVal, cloneWithParams( refType, unionParams ), back_inserter( assignDecl->get_statements()->get_kids() ) );
+                
+                if ( ! isGeneric ) assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+
+                return assignDecl;
+        }
+
+        void AutogenerateRoutines::visit( EnumDecl *enumDecl ) {
+                if ( ! enumDecl->get_members().empty() ) {
+                        EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() );
+                        // enumInst->set_baseEnum( enumDecl );
+                        // declsToAdd.push_back(
+                        makeEnumAssignment( enumDecl, enumInst, functionNesting, declsToAdd );
+                }
+        }
+
+        void AutogenerateRoutines::visit( StructDecl *structDecl ) {
+                if ( ! structDecl->get_members().empty() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
+                        StructInstType structInst( Type::Qualifiers(), structDecl->get_name() );
+                        structInst.set_baseStruct( structDecl );
+                        declsToAdd.push_back( makeStructAssignment( structDecl, &structInst, functionNesting ) );
+                        structsDone.insert( structDecl->get_name() );
+                } // if
+        }
+
+        void AutogenerateRoutines::visit( UnionDecl *unionDecl ) {
+                if ( ! unionDecl->get_members().empty() ) {
+                        UnionInstType unionInst( Type::Qualifiers(), unionDecl->get_name() );
+                        unionInst.set_baseUnion( unionDecl );
+                        declsToAdd.push_back( makeUnionAssignment( unionDecl, &unionInst, functionNesting ) );
+                } // if
+        }
+
+        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, 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() ) {
+                        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->get_kids().push_back( new ReturnStmt( std::list< Label >(), assign ) );
+                } // if
+                FunctionType *type = new FunctionType( Type::Qualifiers(), false );
+                type->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, typeInst, 0 ) );
+                type->get_parameters().push_back( dst );
+                type->get_parameters().push_back( src );
+                FunctionDecl *func = new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::AutoGen, type, stmts, false, false );
+                declsToAdd.push_back( func );
+        }
+
+        void addDecls( std::list< Declaration * > &declsToAdd, std::list< Statement * > &statements, std::list< Statement * >::iterator i ) {
+                for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) {
+                        statements.insert( i, new DeclStmt( noLabels, *decl ) );
+                } // for
+                declsToAdd.clear();
+        }
+
+        void AutogenerateRoutines::visit( FunctionType *) {
+                // ensure that we don't add assignment ops for types defined as part of the function
+        }
+
+        void AutogenerateRoutines::visit( PointerType *) {
+                // ensure that we don't add assignment ops for types defined as part of the pointer
+        }
+
+        void AutogenerateRoutines::visit( TraitDecl *) {
+                // ensure that we don't add assignment ops for types defined as part of the context
+        }
+
+        template< typename StmtClass >
+        inline void AutogenerateRoutines::visitStatement( StmtClass *stmt ) {
+                std::set< std::string > oldStructs = structsDone;
+                addVisit( stmt, *this );
+                structsDone = oldStructs;
+        }
+
+        void AutogenerateRoutines::visit( FunctionDecl *functionDecl ) {
+                maybeAccept( functionDecl->get_functionType(), *this );
+                acceptAll( functionDecl->get_oldDecls(), *this );
+                functionNesting += 1;
+                maybeAccept( functionDecl->get_statements(), *this );
+                functionNesting -= 1;
+        }
+
+        void AutogenerateRoutines::visit( CompoundStmt *compoundStmt ) {
+                visitStatement( compoundStmt );
+        }
+
+        void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) {
+                visitStatement( switchStmt );
+        }
+
+        void AutogenerateRoutines::visit( ChooseStmt *switchStmt ) {
+                visitStatement( switchStmt );
+        }
+
+        // void AutogenerateRoutines::visit( CaseStmt *caseStmt ) {
+        //      visitStatement( caseStmt );
+        // }
+
         void ReturnChecker::checkFunctionReturns( std::list< Declaration * > & translationUnit ) {
                 ReturnChecker checker;
@@ -483 +889 @@
 
         void ReturnChecker::visit( ReturnStmt * returnStmt ) {
-                // Previously this also checked for the existence of an expr paired with no return values on
-                // the  function return type. This is incorrect, since you can have an expression attached to
-                // a return statement in a void-returning function in C. The expression is treated as if it
-                // were cast to void.
                 if ( returnStmt->get_expr() == NULL && returnVals.size() != 0 ) {
                         throw SemanticError( "Non-void function returns no values: " , returnStmt );
+                } else if ( returnStmt->get_expr() != NULL && returnVals.size() == 0 ) {
+                        throw SemanticError( "void function returns values: " , returnStmt );
                 }
         }
@@ -629 +1033 @@
                 return aggDecl;
         }
-
+        
         template<typename AggDecl>
         void EliminateTypedef::addImplicitTypedef( AggDecl * aggDecl ) {
@@ -668 +1072 @@
         }
 
-        void VerifyCtorDtor::verify( std::list< Declaration * > & translationUnit ) {
-                VerifyCtorDtor verifier;
-                acceptAll( translationUnit, verifier );
-        }
-
-        void VerifyCtorDtor::visit( FunctionDecl * funcDecl ) {
-                FunctionType * funcType = funcDecl->get_functionType();
-                std::list< DeclarationWithType * > &returnVals = funcType->get_returnVals();
-                std::list< DeclarationWithType * > &params = funcType->get_parameters();
-
-                if ( funcDecl->get_name() == "?{}" || funcDecl->get_name() == "^?{}" ) {
-                        if ( params.size() == 0 ) {
-                                throw SemanticError( "Constructors and destructors require at least one parameter ", funcDecl );
-                        }
-                        if ( ! dynamic_cast< PointerType * >( params.front()->get_type() ) ) {
-                                throw SemanticError( "First parameter of a constructor or destructor must be a pointer ", funcDecl );
-                        }
-                        if ( returnVals.size() != 0 ) {
-                                throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl );
-                        }
-                }
-
-                Visitor::visit( funcDecl );
-                // original idea: modify signature of ctor/dtors and insert appropriate return statements
-                // to cause desired behaviour
-                // new idea: add comma exprs to every ctor call to produce first parameter.
-                // this requires some memoization of the first parameter, because it can be a
-                // complicated expression with side effects (see: malloc). idea: add temporary variable
-                // that is assigned address of constructed object in ctor argument position and
-                // return the temporary. It should also be done after all implicit ctors are
-                // added, so not in this pass!
-        }
-
         DeclarationWithType * CompoundLiteral::mutate( ObjectDecl *objectDecl ) {
                 storageclass = objectDecl->get_storageClass();