Changes in src/SymTab/Validate.cc [679864e1:40e636a]

File:

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

src/SymTab/Validate.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Validate.cc -- 
+// Validate.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:50:04 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Tue Oct 06 15:40:35 2015
-// Update Count     : 219
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Jul 12 17:49:21 2016
+// Update Count     : 298
 //
 
@@ -40 +40 @@
 #include <list>
 #include <iterator>
+#include "Common/utility.h"
+#include "Common/UniqueName.h"
 #include "Validate.h"
 #include "SynTree/Visitor.h"
 #include "SynTree/Mutator.h"
 #include "SynTree/Type.h"
+#include "SynTree/Expression.h"
 #include "SynTree/Statement.h"
 #include "SynTree/TypeSubstitution.h"
@@ -49 +52 @@
 #include "FixFunction.h"
 // #include "ImplementationType.h"
-#include "utility.h"
-#include "UniqueName.h"
+#include "GenPoly/DeclMutator.h"
 #include "AddVisit.h"
 #include "MakeLibCfa.h"
 #include "TypeEquality.h"
+#include "Autogen.h"
+#include "ResolvExpr/typeops.h"
 
 #define debugPrint( x ) if ( doDebug ) { std::cout << x; }
@@ -62 +66 @@
                 /// Flattens nested struct types
                 static void hoistStruct( std::list< Declaration * > &translationUnit );
-  
+
                 std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
-  
+
                 virtual void visit( StructDecl *aggregateDecl );
                 virtual void visit( UnionDecl *aggregateDecl );
 
                 virtual void visit( CompoundStmt *compoundStmt );
-                virtual void visit( IfStmt *ifStmt );
-                virtual void visit( WhileStmt *whileStmt );
-                virtual void visit( ForStmt *forStmt );
                 virtual void visit( SwitchStmt *switchStmt );
-                virtual void visit( ChooseStmt *chooseStmt );
-                virtual void visit( CaseStmt *caseStmt );
-                virtual void visit( CatchStmt *catchStmt );
           private:
                 HoistStruct();
@@ -85 +83 @@
         };
 
-        /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers
+        /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers.
         class Pass1 : public Visitor {
                 typedef Visitor Parent;
@@ -100 +98 @@
                 virtual void visit( StructInstType *structInst );
                 virtual void visit( UnionInstType *unionInst );
-                virtual void visit( ContextInstType *contextInst );
+                virtual void visit( TraitInstType *contextInst );
                 virtual void visit( StructDecl *structDecl );
                 virtual void visit( UnionDecl *unionDecl );
@@ -106 +104 @@
 
                 const Indexer *indexer;
-  
+
                 typedef std::map< std::string, std::list< StructInstType * > > ForwardStructsType;
                 typedef std::map< std::string, std::list< UnionInstType * > > ForwardUnionsType;
@@ -125 +123 @@
         };
 
-        class AddStructAssignment : public Visitor {
+        class ReturnChecker : public Visitor {
           public:
-                /// Generates assignment operators for aggregate types as required
-                static void addStructAssignment( 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( ContextDecl *ctxDecl );
-                virtual void visit( FunctionDecl *functionDecl );
-
-                virtual void visit( FunctionType *ftype );
-                virtual void visit( PointerType *ftype );
-  
-                virtual void visit( CompoundStmt *compoundStmt );
-                virtual void visit( IfStmt *ifStmt );
-                virtual void visit( WhileStmt *whileStmt );
-                virtual void visit( ForStmt *forStmt );
-                virtual void visit( SwitchStmt *switchStmt );
-                virtual void visit( ChooseStmt *chooseStmt );
-                virtual void visit( CaseStmt *caseStmt );
-                virtual void visit( CatchStmt *catchStmt );
-
-                AddStructAssignment() : functionNesting( 0 ) {}
+                /// Checks that return statements return nothing if their return type is void
+                /// and return something if the return type is non-void.
+                static void checkFunctionReturns( std::list< Declaration * > & translationUnit );
           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
+                virtual void visit( FunctionDecl * functionDecl );
+
+                virtual void visit( ReturnStmt * returnStmt );
+
+                std::list< DeclarationWithType * > returnVals;
         };
 
         class EliminateTypedef : public Mutator {
           public:
-          EliminateTypedef() : scopeLevel( 0 ) {}
-            /// Replaces typedefs by forward declarations
+                EliminateTypedef() : scopeLevel( 0 ) {}
+                /// Replaces typedefs by forward declarations
                 static void eliminateTypedef( std::list< Declaration * > &translationUnit );
           private:
@@ -177 +153 @@
                 virtual Declaration *mutate( UnionDecl * unionDecl );
                 virtual Declaration *mutate( EnumDecl * enumDecl );
-                virtual Declaration *mutate( ContextDecl * contextDecl );
+                virtual Declaration *mutate( TraitDecl * contextDecl );
 
                 template<typename AggDecl>
                 AggDecl *handleAggregate( AggDecl * aggDecl );
 
+                template<typename AggDecl>
+                void addImplicitTypedef( AggDecl * aggDecl );
+
                 typedef std::map< std::string, std::pair< TypedefDecl *, int > > TypedefMap;
-                typedef std::map< std::string, TypeDecl * > TypeDeclMap;
                 TypedefMap typedefNames;
-                TypeDeclMap typedeclNames;
                 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 {
+                DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;
+
+                virtual DeclarationWithType * mutate( ObjectDecl *objectDecl );
+                virtual Expression *mutate( CompoundLiteralExpr *compLitExpr );
         };
 
@@ -193 +187 @@
                 Pass2 pass2( doDebug, 0 );
                 Pass3 pass3( 0 );
+                CompoundLiteral compoundliteral;
+
                 EliminateTypedef::eliminateTypedef( translationUnit );
                 HoistStruct::hoistStruct( translationUnit );
+                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs Pass1
                 acceptAll( translationUnit, pass1 );
                 acceptAll( translationUnit, pass2 );
-                // need to collect all of the assignment operators prior to
-                // this point and only generate assignment operators if one doesn't exist
-                AddStructAssignment::addStructAssignment( translationUnit );
+                ReturnChecker::checkFunctionReturns( translationUnit );
+                compoundliteral.mutateDeclarationList( translationUnit );
                 acceptAll( translationUnit, pass3 );
-        }
-        
+                VerifyCtorDtor::verify( translationUnit );
+        }
+
         void validateType( Type *type, const Indexer *indexer ) {
                 Pass1 pass1;
@@ -210 +207 @@
                 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
         }
 
@@ -280 +263 @@
         }
 
-        void HoistStruct::visit( IfStmt *ifStmt ) {
-                addVisit( ifStmt, *this );
-        }
-
-        void HoistStruct::visit( WhileStmt *whileStmt ) {
-                addVisit( whileStmt, *this );
-        }
-
-        void HoistStruct::visit( ForStmt *forStmt ) {
-                addVisit( forStmt, *this );
-        }
-
         void HoistStruct::visit( SwitchStmt *switchStmt ) {
                 addVisit( switchStmt, *this );
         }
 
-        void HoistStruct::visit( ChooseStmt *switchStmt ) {
-                addVisit( switchStmt, *this );
-        }
-
-        void HoistStruct::visit( CaseStmt *caseStmt ) {
-                addVisit( caseStmt, *this );
-        }
-
-        void HoistStruct::visit( CatchStmt *cathStmt ) {
-                addVisit( cathStmt, *this );
-        }
-
         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() ) );
-                        BasicType * enumType = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
-                        obj->set_type( enumType ) ;
+                        obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false, false ), enumDecl->get_name() ) );
                 } // for
                 Parent::visit( enumDecl );
@@ -322 +278 @@
 
         namespace {
-                template< typename DWTIterator >
-                void fixFunctionList( DWTIterator begin, DWTIterator end, FunctionType *func ) {
+                template< typename DWTList >
+                void fixFunctionList( DWTList & dwts, 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;
-                                func->get_parameters().erase( j );
-                                if ( i != end ) { 
+                                dwts.erase( j );
+                                if ( i != end ) {
                                         throw SemanticError( "invalid type void in function type ", func );
                                 } // if
@@ -352 +310 @@
         void Pass1::visit( FunctionType *func ) {
                 // Fix up parameters and return types
-                fixFunctionList( func->get_parameters().begin(), func->get_parameters().end(), func );
-                fixFunctionList( func->get_returnVals().begin(), func->get_returnVals().end(), func );
+                fixFunctionList( func->get_parameters(), func );
+                fixFunctionList( func->get_returnVals(), func );
                 Visitor::visit( func );
         }
@@ -370 +328 @@
                 // it's not a semantic error if the struct is not found, just an implicit forward declaration
                 if ( st ) {
-                        assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
+                        //assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
                         structInst->set_baseStruct( st );
                 } // if
@@ -392 +350 @@
         }
 
-        void Pass2::visit( ContextInstType *contextInst ) {
+        void Pass2::visit( TraitInstType *contextInst ) {
                 Parent::visit( contextInst );
-                ContextDecl *ctx = indexer->lookupContext( contextInst->get_name() );
+                TraitDecl *ctx = indexer->lookupTrait( contextInst->get_name() );
                 if ( ! ctx ) {
                         throw SemanticError( "use of undeclared context " + contextInst->get_name() );
@@ -400 +358 @@
                 for ( std::list< TypeDecl * >::const_iterator i = ctx->get_parameters().begin(); i != ctx->get_parameters().end(); ++i ) {
                         for ( std::list< DeclarationWithType * >::const_iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
-                                if ( ContextInstType *otherCtx = dynamic_cast< ContextInstType * >(*assert ) ) {
+                                if ( TraitInstType *otherCtx = dynamic_cast< TraitInstType * >(*assert ) ) {
                                         cloneAll( otherCtx->get_members(), contextInst->get_members() );
                                 } else {
@@ -416 +374 @@
 
         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() );
@@ -425 +385 @@
                         } // 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() );
@@ -438 +398 @@
                         } // if
                 } // if
-                Indexer::visit( unionDecl );
         }
 
@@ -464 +423 @@
                         while ( ! toBeDone.empty() ) {
                                 for ( std::list< DeclarationWithType * >::iterator assertion = toBeDone.begin(); assertion != toBeDone.end(); ++assertion ) {
-                                        if ( ContextInstType *ctx = dynamic_cast< ContextInstType * >( (*assertion )->get_type() ) ) {
+                                        if ( TraitInstType *ctx = dynamic_cast< TraitInstType * >( (*assertion )->get_type() ) ) {
                                                 for ( std::list< Declaration * >::const_iterator i = ctx->get_members().begin(); i != ctx->get_members().end(); ++i ) {
                                                         DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *i );
@@ -501 +460 @@
         }
 
-        static const std::list< std::string > noLabels;
-
-        void AddStructAssignment::addStructAssignment( std::list< Declaration * > &translationUnit ) {
-                AddStructAssignment 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 ) );
-        }
-
-        //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() );
-        }
-
-
-        Declaration *makeStructAssignment( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting ) {
-                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 );
-  
-                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), refType->clone() ), 0 );
-                assignType->get_parameters().push_back( dstParam );
-  
-                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, refType, 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 ( 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
-                } // for
-                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 );
-  
-                ObjectDecl *returnVal = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
-                assignType->get_returnVals().push_back( returnVal );
-  
-                ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), refType->clone() ), 0 );
-                assignType->get_parameters().push_back( dstParam );
-  
-                ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, refType, 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();
-  
-                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( refType->clone() ) );
-
-                assignDecl->get_statements()->get_kids().push_back( new ExprStmt( noLabels, copy ) );
-                assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
-  
-                return assignDecl;
-        }
-
-        void AddStructAssignment::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 ReturnChecker::checkFunctionReturns( std::list< Declaration * > & translationUnit ) {
+                ReturnChecker checker;
+                acceptAll( translationUnit, checker );
+        }
+
+        void ReturnChecker::visit( FunctionDecl * functionDecl ) {
+                std::list< DeclarationWithType * > oldReturnVals = returnVals;
+                returnVals = functionDecl->get_functionType()->get_returnVals();
+                Visitor::visit( functionDecl );
+                returnVals = oldReturnVals;
+        }
+
+        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 );
                 }
         }
 
-        void AddStructAssignment::visit( StructDecl *structDecl ) {
-                if ( ! structDecl->get_members().empty() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
-                        StructInstType *structInst = new StructInstType( Type::Qualifiers(), structDecl->get_name() );
-                        structInst->set_baseStruct( structDecl );
-                        declsToAdd.push_back( makeStructAssignment( structDecl, structInst, functionNesting ) );
-                        structsDone.insert( structDecl->get_name() );
-                } // if
-        }
-
-        void AddStructAssignment::visit( UnionDecl *unionDecl ) {
-                if ( ! unionDecl->get_members().empty() ) {
-                        UnionInstType *unionInst = new UnionInstType( Type::Qualifiers(), unionDecl->get_name() );
-                        unionInst->set_baseUnion( unionDecl );
-                        declsToAdd.push_back( makeUnionAssignment( unionDecl, unionInst, functionNesting ) );
-                } // if
-        }
-
-        void AddStructAssignment::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 AddStructAssignment::visit( FunctionType *) {
-                // ensure that we don't add assignment ops for types defined as part of the function
-        }
-
-        void AddStructAssignment::visit( PointerType *) {
-                // ensure that we don't add assignment ops for types defined as part of the pointer
-        }
-
-        void AddStructAssignment::visit( ContextDecl *) {
-                // ensure that we don't add assignment ops for types defined as part of the context
-        }
-
-        template< typename StmtClass >
-        inline void AddStructAssignment::visitStatement( StmtClass *stmt ) {
-                std::set< std::string > oldStructs = structsDone;
-                addVisit( stmt, *this );
-                structsDone = oldStructs;
-        }
-
-        void AddStructAssignment::visit( FunctionDecl *functionDecl ) {
-                maybeAccept( functionDecl->get_functionType(), *this );
-                acceptAll( functionDecl->get_oldDecls(), *this );
-                functionNesting += 1;
-                maybeAccept( functionDecl->get_statements(), *this );
-                functionNesting -= 1;
-        }
-
-        void AddStructAssignment::visit( CompoundStmt *compoundStmt ) {
-                visitStatement( compoundStmt );
-        }
-
-        void AddStructAssignment::visit( IfStmt *ifStmt ) {
-                visitStatement( ifStmt );
-        }
-
-        void AddStructAssignment::visit( WhileStmt *whileStmt ) {
-                visitStatement( whileStmt );
-        }
-
-        void AddStructAssignment::visit( ForStmt *forStmt ) {
-                visitStatement( forStmt );
-        }
-
-        void AddStructAssignment::visit( SwitchStmt *switchStmt ) {
-                visitStatement( switchStmt );
-        }
-
-        void AddStructAssignment::visit( ChooseStmt *switchStmt ) {
-                visitStatement( switchStmt );
-        }
-
-        void AddStructAssignment::visit( CaseStmt *caseStmt ) {
-                visitStatement( caseStmt );
-        }
-
-        void AddStructAssignment::visit( CatchStmt *cathStmt ) {
-                visitStatement( cathStmt );
-        }
 
         bool isTypedef( Declaration *decl ) {
@@ -820 +490 @@
                 EliminateTypedef eliminator;
                 mutateAll( translationUnit, eliminator );
+                if ( eliminator.typedefNames.count( "size_t" ) ) {
+                        // grab and remember declaration of size_t
+                        SizeType = eliminator.typedefNames["size_t"].first->get_base()->clone();
+                } else {
+                        // xxx - missing global typedef for size_t - default to long unsigned int, even though that may be wrong
+                        // eventually should have a warning for this case.
+                        SizeType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+                }
                 filter( translationUnit, isTypedef, true );
+
         }
 
         Type *EliminateTypedef::mutate( TypeInstType * typeInst ) {
-                // instances of typedef types will come here. If it is an instance 
+                // instances of typedef types will come here. If it is an instance
                 // of a typdef type, link the instance to its actual type.
                 TypedefMap::const_iterator def = typedefNames.find( typeInst->get_name() );
@@ -837 +516 @@
                                 }
                                 rtt->get_parameters().clear();
-                                cloneAll(typeInst->get_parameters(), rtt->get_parameters());
+                                cloneAll( typeInst->get_parameters(), rtt->get_parameters() );
+                                mutateAll( rtt->get_parameters(), *this );  // recursively fix typedefs on parameters
                         } // if
                         delete typeInst;
                         return ret;
-                } else {
-                        TypeDeclMap::const_iterator base = typedeclNames.find( typeInst->get_name() );
-                        assert( base != typedeclNames.end() );
-                        typeInst->set_baseType( base->second->clone() );
                 } // if
                 return typeInst;
@@ -851 +527 @@
         Declaration *EliminateTypedef::mutate( TypedefDecl * tyDecl ) {
                 Declaration *ret = Mutator::mutate( tyDecl );
+
                 if ( typedefNames.count( tyDecl->get_name() ) == 1 && typedefNames[ tyDecl->get_name() ].second == scopeLevel ) {
-                        // typedef to the same name from the same scope 
+                        // typedef to the same name from the same scope
                         // must be from the same type
 
                         Type * t1 = tyDecl->get_base();
                         Type * t2 = typedefNames[ tyDecl->get_name() ].first->get_base();
-                        if ( ! typeEquals( t1, t2, true ) ) {
+                        if ( ! ResolvExpr::typesCompatible( t1, t2, Indexer() ) ) {
                                 throw SemanticError( "cannot redefine typedef: " + tyDecl->get_name() );
                         }
@@ -876 +553 @@
                 } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( tyDecl->get_base() ) ) {
                         return new UnionDecl( aggDecl->get_name() );
+                } else if ( EnumInstType *enumDecl = dynamic_cast< EnumInstType * >( tyDecl->get_base() ) ) {
+                        return new EnumDecl( enumDecl->get_name() );
                 } else {
                         return ret;
@@ -886 +565 @@
                         typedefNames.erase( i ) ;
                 } // if
-
-                typedeclNames[ typeDecl->get_name() ] = typeDecl;
                 return typeDecl;
         }
@@ -902 +579 @@
                 DeclarationWithType *ret = Mutator::mutate( objDecl );
                 typedefNames = oldNames;
+                // is the type a function?
                 if ( FunctionType *funtype = dynamic_cast<FunctionType *>( ret->get_type() ) ) {
+                        // replace the current object declaration with a function declaration
                         return new FunctionDecl( ret->get_name(), ret->get_storageClass(), ret->get_linkage(), funtype, 0, ret->get_isInline(), ret->get_isNoreturn() );
                 } else if ( objDecl->get_isInline() || objDecl->get_isNoreturn() ) {
@@ -937 +616 @@
         }
 
-        // there may be typedefs nested within aggregates
-        // in order for everything to work properly, these
-        // should be removed as well
+        // there may be typedefs nested within aggregates in order for everything to work properly, these should be removed
+        // as well
         template<typename AggDecl>
         AggDecl *EliminateTypedef::handleAggregate( AggDecl * aggDecl ) {
@@ -954 +632 @@
         }
 
+        template<typename AggDecl>
+        void EliminateTypedef::addImplicitTypedef( AggDecl * aggDecl ) {
+                if ( typedefNames.count( aggDecl->get_name() ) == 0 ) {
+                        Type *type;
+                        if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( aggDecl ) ) {
+                                type = new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() );
+                        } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( aggDecl ) ) {
+                                type = new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() );
+                        } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( aggDecl )  ) {
+                                type = new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() );
+                        } // if
+                        TypedefDecl * tyDecl = new TypedefDecl( aggDecl->get_name(), DeclarationNode::NoStorageClass, type );
+                        typedefNames[ aggDecl->get_name() ] = std::make_pair( tyDecl, scopeLevel );
+                } // if
+        }
+
         Declaration *EliminateTypedef::mutate( StructDecl * structDecl ) {
+                addImplicitTypedef( structDecl );
                 Mutator::mutate( structDecl );
                 return handleAggregate( structDecl );
@@ -960 +655 @@
 
         Declaration *EliminateTypedef::mutate( UnionDecl * unionDecl ) {
+                addImplicitTypedef( unionDecl );
                 Mutator::mutate( unionDecl );
                 return handleAggregate( unionDecl );
@@ -965 +661 @@
 
         Declaration *EliminateTypedef::mutate( EnumDecl * enumDecl ) {
+                addImplicitTypedef( enumDecl );
                 Mutator::mutate( enumDecl );
                 return handleAggregate( enumDecl );
         }
 
-                Declaration *EliminateTypedef::mutate( ContextDecl * contextDecl ) {
+        Declaration *EliminateTypedef::mutate( TraitDecl * contextDecl ) {
                 Mutator::mutate( contextDecl );
                 return handleAggregate( contextDecl );
         }
 
+        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 );
+        }
+
+        DeclarationWithType * CompoundLiteral::mutate( ObjectDecl *objectDecl ) {
+                storageclass = objectDecl->get_storageClass();
+                DeclarationWithType * temp = Mutator::mutate( objectDecl );
+                storageclass = DeclarationNode::NoStorageClass;
+                return temp;
+        }
+
+        Expression *CompoundLiteral::mutate( CompoundLiteralExpr *compLitExpr ) {
+                // transform [storage_class] ... (struct S){ 3, ... };
+                // into [storage_class] struct S temp =  { 3, ... };
+                static UniqueName indexName( "_compLit" );
+
+                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageclass, LinkageSpec::C, 0, compLitExpr->get_type(), compLitExpr->get_initializer() );
+                compLitExpr->set_type( 0 );
+                compLitExpr->set_initializer( 0 );
+                delete compLitExpr;
+                DeclarationWithType * newtempvar = mutate( tempvar );
+                addDeclaration( newtempvar );                                   // add modified temporary to current block
+                return new VariableExpr( newtempvar );
+        }
 } // namespace SymTab