Changeset b1e63ac5 for src/SymTab

Timestamp:

Jul 4, 2017, 9:40:16 AM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

208e5be

Parents:

9c951e3 (diff), f7cb0bc (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into references

Location:

src/SymTab

Files:

• Autogen.cc (modified) (8 diffs)
• Autogen.h (modified) (4 diffs)
• FixFunction.cc (modified) (1 diff)
• ImplementationType.cc (modified) (4 diffs)
• Indexer.cc (modified) (6 diffs)
• Indexer.h (modified) (1 diff)
• Mangler.cc (modified) (3 diffs)
• Validate.cc (modified) (23 diffs)

src/SymTab/Autogen.cc

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Thu Mar 03 15:45:56 2016
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 17 09:41:08 2017
-// Update Count     : 60
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 28 15:30:00 2017
+// Update Count     : 61
 //
 
@@ -263 +263 @@
         // E ?=?(E volatile*, int),
         //   ?=?(E _Atomic volatile*, int);
-        void makeEnumFunctions( EnumDecl *enumDecl, EnumInstType *refType, unsigned int functionNesting, std::list< Declaration * > &declsToAdd ) {
+        void makeEnumFunctions( EnumInstType *refType, unsigned int functionNesting, std::list< Declaration * > &declsToAdd ) {
 
                 // T ?=?(E *, E);
@@ -401 +401 @@
         /// generates struct constructors, destructor, and assignment functions
         void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) {
+                // Builtins do not use autogeneration.
+                if ( aggregateDecl->get_linkage() == LinkageSpec::Builtin ||
+                         aggregateDecl->get_linkage() == LinkageSpec::BuiltinC ) {
+                        return;
+                }
+
                 // 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
@@ -487 +493 @@
 
         /// generates the body of a union assignment/copy constructor/field constructor
-        void makeUnionAssignBody( FunctionDecl * funcDecl, bool isDynamicLayout ) {
+        void makeUnionAssignBody( FunctionDecl * funcDecl ) {
                 FunctionType * ftype = funcDecl->get_functionType();
                 assert( ftype->get_parameters().size() == 2 );
@@ -507 +513 @@
                 // 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)
-
+                
                 // default ctor/dtor need only first parameter
                 // void ?{}(T *); void ^?{}(T *);
@@ -534 +539 @@
                 FunctionDecl *dtorDecl = genFunc( "^?{}", dtorType, functionNesting );
 
-                makeUnionAssignBody( assignDecl, isDynamicLayout );
+                makeUnionAssignBody( assignDecl );
 
                 // body of assignment and copy ctor is the same
-                makeUnionAssignBody( copyCtorDecl, isDynamicLayout );
+                makeUnionAssignBody( copyCtorDecl );
 
                 // create a constructor which takes the first member type as a parameter.
@@ -552 +557 @@
                                 FunctionDecl * ctor = genFunc( "?{}", memCtorType, functionNesting );
 
-                                makeUnionAssignBody( ctor, isDynamicLayout );
+                                makeUnionAssignBody( ctor );
                                 memCtors.push_back( ctor );
                                 // only generate a ctor for the first field
@@ -579 +584 @@
                         EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() );
                         // enumInst->set_baseEnum( enumDecl );
-                        makeEnumFunctions( enumDecl, enumInst, functionNesting, declsToAddAfter );
+                        makeEnumFunctions( enumInst, functionNesting, declsToAddAfter );
                 }
         }

src/SymTab/Autogen.h

@@ -10 +10 @@
 // Created On       : Sun May 17 21:53:34 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 17 09:10:41 2017
-// Update Count     : 9
+// Last Modified On : Wed Jun 21 17:25:26 2017
+// Update Count     : 14
 //
 
@@ -43 +43 @@
         template< typename OutputIterator >
         Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) {
-                // want to be able to generate assignment, ctor, and dtor generically,
-                // so fname is either ?=?, ?{}, or ^?{}
-                UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) );
+        // want to be able to generate assignment, ctor, and dtor generically,
+        // so fname is either ?=?, ?{}, or ^?{}
+        UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) );
 
-                // do something special for unnamed members
-                dstParam = new AddressExpr( dstParam );
-                if ( addCast ) {
-                        // cast to T* with qualifiers removed, so that qualified objects can be constructed
-                        // and destructed with the same functions as non-qualified objects.
-                        // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
-                        // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
-                        // remove lvalue as a qualifier, this can change to
-                        //   type->get_qualifiers() = Type::Qualifiers();
-                        assert( type );
-                        Type * castType = type->clone();
-//                      castType->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, false);
-                        castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
-                        castType->set_lvalue( true ); // xxx - might not need this
-                        dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
-                }
-                fExpr->get_args().push_back( dstParam );
+        // do something special for unnamed members
+        dstParam = new AddressExpr( dstParam );
+        if ( addCast ) {
+                // cast to T* with qualifiers removed, so that qualified objects can be constructed
+                // and destructed with the same functions as non-qualified objects.
+                // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
+                // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
+                // remove lvalue as a qualifier, this can change to
+                //   type->get_qualifiers() = Type::Qualifiers();
+                assert( type );
+                Type * castType = type->clone();
+                castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                castType->set_lvalue( true ); // xxx - might not need this
+                dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
+        }
+        fExpr->get_args().push_back( dstParam );
 
-                Statement * listInit = srcParam.buildListInit( fExpr );
+        Statement * listInit = srcParam.buildListInit( fExpr );
 
-                std::list< Expression * > args = *++srcParam;
-                fExpr->get_args().splice( fExpr->get_args().end(), args );
+        std::list< Expression * > args = *++srcParam;
+        fExpr->get_args().splice( fExpr->get_args().end(), args );
 
-                *out++ = new ExprStmt( noLabels, fExpr );
+        *out++ = new ExprStmt( noLabels, fExpr );
 
-                srcParam.clearArrayIndices();
+        srcParam.clearArrayIndices();
 
-                return listInit;
+        return listInit;
         }
 
@@ -88 +87 @@
                 Expression * begin, * end, * update, * cmp;
                 if ( forward ) {
-                        // generate: for ( int i = 0; i < 0; ++i )
-                        begin = new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0" ) );
+                        // generate: for ( int i = 0; i < N; ++i )
+                        begin = new ConstantExpr( Constant::from_int( 0 ) );
                         end = array->get_dimension()->clone();
                         cmp = new NameExpr( "?<?" );
@@ -97 +96 @@
                         begin = new UntypedExpr( new NameExpr( "?-?" ) );
                         ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() );
-                        ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant( new OneType( emptyQualifiers ), "1" ) ) );
-                        end = new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0" ) );
+                        ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
+                        end = new ConstantExpr( Constant::from_int( 0 ) );
                         cmp = new NameExpr( "?>=?" );
                         update = new NameExpr( "--?" );
                 }
 
-                ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
+                ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin ) );
 
                 UntypedExpr *cond = new UntypedExpr( cmp );

src/SymTab/FixFunction.cc

@@ -24 +24 @@
 
         DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) {
-                ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0, functionDecl->get_attributes() );
+                ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type() ), 0, functionDecl->get_attributes() );
                 functionDecl->get_attributes().clear();
+                // can't delete function type because it may contain assertions, but can't transfer ownership without a clone since set_type checks for nullptr
+                functionDecl->set_type( functionDecl->get_type()->clone() );
                 delete functionDecl;
                 return pointer;

src/SymTab/ImplementationType.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ImplementationType.cc -- 
+// ImplementationType.cc --
 //
 // Author           : Richard C. Bilson
@@ -61 +61 @@
         }
 
-        void ImplementationType::visit(VoidType *voidType) {
-        }
-
-        void ImplementationType::visit(BasicType *basicType) {
-        }
+        void ImplementationType::visit( __attribute__((unused)) VoidType *voidType ) {}
+        void ImplementationType::visit( __attribute__((unused)) BasicType *basicType ) {}
 
         void ImplementationType::visit(PointerType *pointerType) {
@@ -79 +76 @@
         }
 
-        void ImplementationType::visit(FunctionType *functionType) {
-///   FunctionType *newType = functionType->clone();
-///   for ( std::list< DeclarationWithType* >::iterator i = newType->get_parameters().begin(); i != newType->get_parameters().end(); ++i ) {
-///     i->set_type( implementationType( i->get_type(), indexer ) );
-///   }
-///   for ( std::list< DeclarationWithType* >::iterator i = newType->get_parameters().begin(); i != newType->get_parameters().end(); ++i ) {
-///     i->set_type( implementationType( i->get_type(), indexer ) );
-///   }
-        }
-
-        void ImplementationType::visit(StructInstType *aggregateUseType) {
-        }
-
-        void ImplementationType::visit(UnionInstType *aggregateUseType) {
-        }
-
-        void ImplementationType::visit(EnumInstType *aggregateUseType) {
-        }
-
-        void ImplementationType::visit(TraitInstType *aggregateUseType) {
-        }
+        void ImplementationType::visit( __attribute__((unused)) FunctionType *functionType ) {}
+        void ImplementationType::visit( __attribute__((unused)) StructInstType * aggregateUseType ) {}
+        void ImplementationType::visit( __attribute__((unused)) UnionInstType * aggregateUseType ) {}
+        void ImplementationType::visit( __attribute__((unused)) EnumInstType * aggregateUseType ) {}
+        void ImplementationType::visit( __attribute__((unused)) TraitInstType * aggregateUseType ) {}
 
         void ImplementationType::visit(TypeInstType *inst) {
@@ -111 +92 @@
 
         void ImplementationType::visit(TupleType *tupleType) {
-                TupleType *newType = new TupleType( Type::Qualifiers() );
+                std::list< Type * > types;
                 for ( std::list< Type* >::iterator i = tupleType->get_types().begin(); i != tupleType->get_types().end(); ++i ) {
                         Type *implType = implementationType( *i, indexer );
                         implType->get_qualifiers() |= tupleType->get_qualifiers();
-                        newType->get_types().push_back( implType );
+                        types.push_back( implType );
                 } // for
-                result = newType;
+                result = new TupleType( Type::Qualifiers(), types );
         }
 
-        void ImplementationType::visit(VarArgsType *varArgsType) {
-        }
-
-        void ImplementationType::visit(ZeroType *zeroType) {
-        }
-
-        void ImplementationType::visit(OneType *oneType) {
-        }
+        void ImplementationType::visit( __attribute__((unused)) VarArgsType *varArgsType ) {}
+        void ImplementationType::visit( __attribute__((unused)) ZeroType *zeroType ) {}
+        void ImplementationType::visit( __attribute__((unused)) OneType *oneType ) {}
 } // namespace SymTab
 

src/SymTab/Indexer.cc

@@ -124 +124 @@
                         };
                         // properties for this type
-                        bool userDefinedFunc = false; // any user-defined function found
-                        bool userDefinedCtor = false; // any user-defined constructor found
-                        bool userDefinedDtor = false; // any user-defined destructor found
-                        bool userDefinedCopyFunc = false; // user-defined copy ctor found
+                        bool existsUserDefinedFunc = false;    // any user-defined function found
+                        bool existsUserDefinedCtor = false;    // any user-defined constructor found
+                        bool existsUserDefinedDtor = false;    // any user-defined destructor found
+                        bool existsUserDefinedCopyFunc = false;    // user-defined copy ctor found
+                        bool existsUserDefinedDefaultCtor = false; // user-defined default ctor found
                         std::list< DeclBall > decls;
 
@@ -138 +139 @@
                                 bool isCopyFunc = InitTweak::isCopyFunction( function, function->get_name() );
                                 decls.push_back( DeclBall{ function, isUserDefinedFunc, isDefaultCtor, isDtor, isCopyFunc } );
-                                userDefinedFunc = userDefinedFunc || isUserDefinedFunc;
-                                userDefinedCtor = userDefinedCtor || (isUserDefinedFunc && InitTweak::isConstructor( function->get_name() ) );
-                                userDefinedDtor = userDefinedDtor || (isUserDefinedFunc && isDtor);
-                                userDefinedCopyFunc = userDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc);
+                                existsUserDefinedFunc = existsUserDefinedFunc || isUserDefinedFunc;
+                                existsUserDefinedCtor = existsUserDefinedCtor || (isUserDefinedFunc && InitTweak::isConstructor( function->get_name() ) );
+                                existsUserDefinedDtor = existsUserDefinedDtor || (isUserDefinedFunc && isDtor);
+                                existsUserDefinedCopyFunc = existsUserDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc);
+                                existsUserDefinedDefaultCtor = existsUserDefinedDefaultCtor || (isUserDefinedFunc && isDefaultCtor);
                                 return *this;
                         }
@@ -164 +166 @@
                 }
 
-                // if a type contains user defined ctor/dtors, then special rules trigger, which determine
-                // the set of ctor/dtors that are seen by the requester. In particular, if the user defines
+                // if a type contains user defined ctor/dtor/assign, then special rules trigger, which determine
+                // the set of ctor/dtor/assign that are seen by the requester. In particular, if the user defines
                 // a default ctor, then the generated default ctor should never be seen, likewise for copy ctor
                 // and dtor. If the user defines any ctor/dtor, then no generated field ctors should be seen.
-                // If the user defines any ctor then the generated default ctor should not be seen.
+                // If the user defines any ctor then the generated default ctor should not be seen (intrinsic default
+                // ctor must be overridden exactly).
                 for ( std::pair< const std::string, ValueType > & pair : funcMap ) {
                         ValueType & val = pair.second;
                         for ( ValueType::DeclBall ball : val.decls ) {
-                                if ( ! val.userDefinedFunc || ball.isUserDefinedFunc || (! val.userDefinedCtor && ball.isDefaultCtor) || (! val.userDefinedCopyFunc && ball.isCopyFunc) || (! val.userDefinedDtor && ball.isDtor) ) {
+                                bool noUserDefinedFunc = ! val.existsUserDefinedFunc;
+                                bool isUserDefinedFunc = ball.isUserDefinedFunc;
+                                bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl->get_linkage() == LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides
+                                bool isAcceptableCopyFunc = ! val.existsUserDefinedCopyFunc && ball.isCopyFunc; // handles copy ctor and assignment operator
+                                bool isAcceptableDtor = ! val.existsUserDefinedDtor && ball.isDtor;
+                                if ( noUserDefinedFunc || isUserDefinedFunc || isAcceptableDefaultCtor || isAcceptableCopyFunc || isAcceptableDtor ) {
                                         // decl conforms to the rules described above, so it should be seen by the requester
                                         out.push_back( ball.decl );
@@ -278 +286 @@
                 addType( typeDecl );
                 acceptAll( typeDecl->get_assertions(), *this );
+                acceptNewScope( typeDecl->get_init(), *this );
         }
 
@@ -487 +496 @@
         }
 
-        void Indexer::visit( UntypedValofExpr *valofExpr ) {
-                acceptNewScope( valofExpr->get_result(), *this );
-                maybeAccept( valofExpr->get_body(), *this );
-        }
-
         void Indexer::visit( RangeExpr *rangeExpr ) {
                 maybeAccept( rangeExpr->get_low(), *this );
@@ -510 +514 @@
                 acceptNewScope( tupleExpr->get_result(), *this );
                 maybeAccept( tupleExpr->get_tuple(), *this );
-        }
-
-        void Indexer::visit( MemberTupleExpr *tupleExpr ) {
-                acceptNewScope( tupleExpr->get_result(), *this );
-                maybeAccept( tupleExpr->get_member(), *this );
-                maybeAccept( tupleExpr->get_aggregate(), *this );
         }
 

src/SymTab/Indexer.h

@@ -69 +69 @@
                 virtual void visit( ConstructorExpr * ctorExpr );
                 virtual void visit( CompoundLiteralExpr *compLitExpr );
-                virtual void visit( UntypedValofExpr *valofExpr );
                 virtual void visit( RangeExpr *rangeExpr );
                 virtual void visit( UntypedTupleExpr *tupleExpr );
                 virtual void visit( TupleExpr *tupleExpr );
                 virtual void visit( TupleIndexExpr *tupleExpr );
-                virtual void visit( MemberTupleExpr *tupleExpr );
                 virtual void visit( TupleAssignExpr *tupleExpr );
                 virtual void visit( StmtExpr * stmtExpr );

src/SymTab/Mangler.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:40:29 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 17 09:40:01 2017
-// Update Count     : 20
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 28 15:31:00 2017
+// Update Count     : 21
 //
 
@@ -72 +72 @@
                         } else {
                                 // if we add another kind of overridable function, this has to change
-                                assert( false );
+                                assert( false && "unknown overrideable linkage" );
                         } // if
                 }
@@ -236 +236 @@
         }
 
-        void Mangler::visit( ZeroType *zeroType ) {
+        void Mangler::visit( __attribute__((unused)) ZeroType *zeroType ) {
                 mangleName << "Z";
         }
 
-        void Mangler::visit( OneType *oneType ) {
+        void Mangler::visit( __attribute__((unused)) OneType *oneType ) {
                 mangleName << "O";
         }

src/SymTab/Validate.cc

@@ -38 +38 @@
 //   definition occurs later in the input.
 
+#include <algorithm>
+#include <iterator>
 #include <list>
-#include <iterator>
+
+#include "CodeGen/CodeGenerator.h"
+
+#include "Common/PassVisitor.h"
 #include "Common/ScopedMap.h"
+#include "Common/UniqueName.h"
 #include "Common/utility.h"
-#include "Common/UniqueName.h"
+
 #include "Concurrency/Keywords.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"
-#include "Indexer.h"
+
+#include "GenPoly/DeclMutator.h"
+
+#include "InitTweak/InitTweak.h"
+
+#include "AddVisit.h"
+#include "Autogen.h"
 #include "FixFunction.h"
 // #include "ImplementationType.h"
-#include "GenPoly/DeclMutator.h"
-#include "AddVisit.h"
+#include "Indexer.h"
 #include "MakeLibCfa.h"
 #include "TypeEquality.h"
-#include "Autogen.h"
+#include "Validate.h"
+
 #include "ResolvExpr/typeops.h"
-#include <algorithm>
-#include "InitTweak/InitTweak.h"
-#include "CodeGen/CodeGenerator.h"
+
+#include "SynTree/Attribute.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Mutator.h"
+#include "SynTree/Statement.h"
+#include "SynTree/Type.h"
+#include "SynTree/TypeSubstitution.h"
+#include "SynTree/Visitor.h"
 
 #define debugPrint( x ) if ( doDebug ) { std::cout << x; }
@@ -96 +106 @@
 
         /// Fix return types so that every function returns exactly one value
-        class ReturnTypeFixer final : public Visitor {
-          public:
-                typedef Visitor Parent;
-                using Parent::visit;
-
+        struct ReturnTypeFixer {
                 static void fix( std::list< Declaration * > &translationUnit );
 
-                virtual void visit( FunctionDecl * functionDecl );
-                virtual void visit( FunctionType * ftype );
+                void postvisit( FunctionDecl * functionDecl );
+                void postvisit( 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 {
-                typedef Visitor Parent;
-                virtual void visit( EnumDecl *aggregateDecl );
-                virtual void visit( FunctionType *func );
+        struct EnumAndPointerDecay {
+                void previsit( EnumDecl *aggregateDecl );
+                void previsit( FunctionType *func );
         };
 
@@ -119 +124 @@
           public:
                 LinkReferenceToTypes( bool doDebug, const Indexer *indexer );
-          private:
                 using Parent::visit;
                 void visit( EnumInstType *enumInst ) final;
@@ -129 +133 @@
                 void visit( UnionDecl *unionDecl ) final;
                 void visit( TypeInstType *typeInst ) final;
-
+          private:
                 const Indexer *indexer;
 
@@ -140 +144 @@
         };
 
-        /// Replaces array and function types in forall lists by appropriate pointer type
-        class Pass3 final : public Indexer {
+        /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID.
+        class ForallPointerDecay final : public Indexer {
                 typedef Indexer Parent;
           public:
                 using Parent::visit;
-                Pass3( const Indexer *indexer );
-          private:
+                ForallPointerDecay( const Indexer *indexer );
+
                 virtual void visit( ObjectDecl *object ) override;
                 virtual void visit( FunctionDecl *func ) override;
@@ -153 +157 @@
         };
 
-        class ReturnChecker : public Visitor {
-          public:
+        struct ReturnChecker : public WithGuards {
                 /// 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:
-                virtual void visit( FunctionDecl * functionDecl );
-                virtual void visit( ReturnStmt * returnStmt );
-
-                std::list< DeclarationWithType * > returnVals;
+
+                void previsit( FunctionDecl * functionDecl );
+                void previsit( ReturnStmt * returnStmt );
+
+                typedef std::list< DeclarationWithType * > ReturnVals;
+                ReturnVals returnVals;
         };
 
@@ -198 +202 @@
         };
 
-        class VerifyCtorDtorAssign : public Visitor {
-        public:
+        struct VerifyCtorDtorAssign {
                 /// ensure that constructors, destructors, and assignment have at least one
                 /// parameter, the first of which must be a pointer, and that ctor/dtors have no
@@ -205 +208 @@
                 static void verify( std::list< Declaration * > &translationUnit );
 
-                virtual void visit( FunctionDecl *funcDecl );
-        };
-
-        class ArrayLength : public Visitor {
-        public:
+                void previsit( FunctionDecl *funcDecl );
+        };
+
+        /// ensure that generic types have the correct number of type arguments
+        struct ValidateGenericParameters {
+                void previsit( StructInstType * inst );
+                void previsit( UnionInstType * inst );
+        };
+
+        struct ArrayLength {
                 /// for array types without an explicit length, compute the length and store it so that it
                 /// is known to the rest of the phases. For example,
@@ -219 +227 @@
                 static void computeLength( std::list< Declaration * > & translationUnit );
 
-                virtual void visit( ObjectDecl * objDecl );
-        };
-
-        class CompoundLiteral final : public GenPoly::DeclMutator {
+                void previsit( ObjectDecl * objDecl );
+        };
+
+        struct CompoundLiteral final : public WithDeclsToAdd, public WithVisitorRef<CompoundLiteral> {
                 Type::StorageClasses storageClasses;
 
-                using GenPoly::DeclMutator::mutate;
-                DeclarationWithType * mutate( ObjectDecl *objectDecl ) final;
-                Expression *mutate( CompoundLiteralExpr *compLitExpr ) final;
+                void premutate( ObjectDecl *objectDecl );
+                Expression * postmutate( CompoundLiteralExpr *compLitExpr );
         };
 
         void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
-                EnumAndPointerDecayPass epc;
+                PassVisitor<EnumAndPointerDecay> epc;
                 LinkReferenceToTypes lrt( doDebug, 0 );
-                Pass3 pass3( 0 );
-                CompoundLiteral compoundliteral;
-
-                HoistStruct::hoistStruct( translationUnit );
+                ForallPointerDecay fpd( 0 );
+                PassVisitor<CompoundLiteral> compoundliteral;
+                PassVisitor<ValidateGenericParameters> genericParams;
+
                 EliminateTypedef::eliminateTypedef( translationUnit );
+                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
                 ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
                 acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
+                acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
                 acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist
                 VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
                 Concurrency::applyKeywords( translationUnit );
-                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecayPass
+                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay
                 Concurrency::implementMutexFuncs( translationUnit );
                 Concurrency::implementThreadStarter( translationUnit );
                 ReturnChecker::checkFunctionReturns( translationUnit );
-                compoundliteral.mutateDeclarationList( translationUnit );
-                acceptAll( translationUnit, pass3 );
+                mutateAll( translationUnit, compoundliteral );
+                acceptAll( translationUnit, fpd );
                 ArrayLength::computeLength( translationUnit );
         }
 
         void validateType( Type *type, const Indexer *indexer ) {
-                EnumAndPointerDecayPass epc;
+                PassVisitor<EnumAndPointerDecay> epc;
                 LinkReferenceToTypes lrt( false, indexer );
-                Pass3 pass3( indexer );
+                ForallPointerDecay fpd( indexer );
                 type->accept( epc );
                 type->accept( lrt );
-                type->accept( pass3 );
+                type->accept( fpd );
         }
 
@@ -337 +346 @@
         }
 
-        void EnumAndPointerDecayPass::visit( EnumDecl *enumDecl ) {
+        void EnumAndPointerDecay::previsit( 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 ) {
@@ -344 +353 @@
                         obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->get_name() ) );
                 } // for
-                Parent::visit( enumDecl );
         }
 
@@ -351 +359 @@
                 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
+                        // entirely. other fix ups are handled by the FixFunction class
                         typedef typename DWTList::iterator DWTIterator;
                         DWTIterator begin( dwts.begin() ), end( dwts.end() );
@@ -370 +378 @@
                                 for ( ; i != end; ++i ) {
                                         FixFunction fixer;
-                                        *i = (*i )->acceptMutator( fixer );
+                                        *i = (*i)->acceptMutator( fixer );
                                         if ( fixer.get_isVoid() ) {
                                                 throw SemanticError( "invalid type void in function type ", func );
@@ -379 +387 @@
         }
 
-        void EnumAndPointerDecayPass::visit( FunctionType *func ) {
+        void EnumAndPointerDecay::previsit( FunctionType *func ) {
                 // Fix up parameters and return types
                 fixFunctionList( func->get_parameters(), func );
                 fixFunctionList( func->get_returnVals(), func );
-                Visitor::visit( func );
         }
 
@@ -496 +503 @@
         void LinkReferenceToTypes::visit( StructDecl *structDecl ) {
                 // visit struct members first so that the types of self-referencing members are updated properly
+                // xxx - need to ensure that type parameters match up between forward declarations and definition (most importantly, number of type parameters and and their defaults)
                 Parent::visit( structDecl );
                 if ( ! structDecl->get_members().empty() ) {
@@ -529 +537 @@
         }
 
-        Pass3::Pass3( const Indexer *other_indexer ) :  Indexer( false ) {
+        ForallPointerDecay::ForallPointerDecay( const Indexer *other_indexer ) :  Indexer( false ) {
                 if ( other_indexer ) {
                         indexer = other_indexer;
@@ -567 +575 @@
         }
 
-        void Pass3::visit( ObjectDecl *object ) {
+        void ForallPointerDecay::visit( ObjectDecl *object ) {
                 forallFixer( object->get_type() );
                 if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
@@ -576 +584 @@
         }
 
-        void Pass3::visit( FunctionDecl *func ) {
+        void ForallPointerDecay::visit( FunctionDecl *func ) {
                 forallFixer( func->get_type() );
                 Parent::visit( func );
@@ -583 +591 @@
 
         void ReturnChecker::checkFunctionReturns( std::list< Declaration * > & translationUnit ) {
-                ReturnChecker checker;
+                PassVisitor<ReturnChecker> checker;
                 acceptAll( translationUnit, checker );
         }
 
-        void ReturnChecker::visit( FunctionDecl * functionDecl ) {
-                std::list< DeclarationWithType * > oldReturnVals = returnVals;
+        void ReturnChecker::previsit( FunctionDecl * functionDecl ) {
+                GuardValue( returnVals );
                 returnVals = functionDecl->get_functionType()->get_returnVals();
-                Visitor::visit( functionDecl );
-                returnVals = oldReturnVals;
-        }
-
-        void ReturnChecker::visit( ReturnStmt * returnStmt ) {
+        }
+
+        void ReturnChecker::previsit( 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
@@ -804 +810 @@
 
         void VerifyCtorDtorAssign::verify( std::list< Declaration * > & translationUnit ) {
-                VerifyCtorDtorAssign verifier;
+                PassVisitor<VerifyCtorDtorAssign> verifier;
                 acceptAll( translationUnit, verifier );
         }
 
-        void VerifyCtorDtorAssign::visit( FunctionDecl * funcDecl ) {
+        void VerifyCtorDtorAssign::previsit( FunctionDecl * funcDecl ) {
                 FunctionType * funcType = funcDecl->get_functionType();
                 std::list< DeclarationWithType * > &returnVals = funcType->get_returnVals();
@@ -826 +832 @@
                         }
                 }
-
-                Visitor::visit( funcDecl );
-        }
-
-        DeclarationWithType * CompoundLiteral::mutate( ObjectDecl *objectDecl ) {
+        }
+
+        template< typename Aggr >
+        void validateGeneric( Aggr * inst ) {
+                std::list< TypeDecl * > * params = inst->get_baseParameters();
+                if ( params != NULL ) {
+                        std::list< Expression * > & args = inst->get_parameters();
+
+                        // insert defaults arguments when a type argument is missing (currently only supports missing arguments at the end of the list).
+                        // A substitution is used to ensure that defaults are replaced correctly, e.g.,
+                        //   forall(otype T, otype alloc = heap_allocator(T)) struct vector;
+                        //   vector(int) v;
+                        // after insertion of default values becomes
+                        //   vector(int, heap_allocator(T))
+                        // and the substitution is built with T=int so that after substitution, the result is
+                        //   vector(int, heap_allocator(int))
+                        TypeSubstitution sub;
+                        auto paramIter = params->begin();
+                        for ( size_t i = 0; paramIter != params->end(); ++paramIter, ++i ) {
+                                if ( i < args.size() ) {
+                                        TypeExpr * expr = safe_dynamic_cast< TypeExpr * >( *std::next( args.begin(), i ) );
+                                        sub.add( (*paramIter)->get_name(), expr->get_type()->clone() );
+                                } else if ( i == args.size() ) {
+                                        Type * defaultType = (*paramIter)->get_init();
+                                        if ( defaultType ) {
+                                                args.push_back( new TypeExpr( defaultType->clone() ) );
+                                                sub.add( (*paramIter)->get_name(), defaultType->clone() );
+                                        }
+                                }
+                        }
+
+                        sub.apply( inst );
+                        if ( args.size() < params->size() ) throw SemanticError( "Too few type arguments in generic type ", inst );
+                        if ( args.size() > params->size() ) throw SemanticError( "Too many type arguments in generic type ", inst );
+                }
+        }
+
+        void ValidateGenericParameters::previsit( StructInstType * inst ) {
+                validateGeneric( inst );
+        }
+
+        void ValidateGenericParameters::previsit( UnionInstType * inst ) {
+                validateGeneric( inst );
+        }
+
+        void CompoundLiteral::premutate( ObjectDecl *objectDecl ) {
                 storageClasses = objectDecl->get_storageClasses();
-                DeclarationWithType * temp = Mutator::mutate( objectDecl );
-                return temp;
-        }
-
-        Expression *CompoundLiteral::mutate( CompoundLiteralExpr *compLitExpr ) {
+        }
+
+        Expression *CompoundLiteral::postmutate( 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(), storageClasses, LinkageSpec::C, 0, compLitExpr->get_result(), compLitExpr->get_initializer() );
-                compLitExpr->set_result( 0 );
-                compLitExpr->set_initializer( 0 );
+                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, nullptr, compLitExpr->get_result(), compLitExpr->get_initializer() );
+                compLitExpr->set_result( nullptr );
+                compLitExpr->set_initializer( nullptr );
                 delete compLitExpr;
-                DeclarationWithType * newtempvar = mutate( tempvar );
-                addDeclaration( newtempvar );                                   // add modified temporary to current block
-                return new VariableExpr( newtempvar );
+                declsToAddBefore.push_back( tempvar );                                  // add modified temporary to current block
+                return new VariableExpr( tempvar );
         }
 
         void ReturnTypeFixer::fix( std::list< Declaration * > &translationUnit ) {
-                ReturnTypeFixer fixer;
+                PassVisitor<ReturnTypeFixer> fixer;
                 acceptAll( translationUnit, fixer );
         }
 
-        void ReturnTypeFixer::visit( FunctionDecl * functionDecl ) {
-                Parent::visit( functionDecl );
+        void ReturnTypeFixer::postvisit( FunctionDecl * functionDecl ) {
                 FunctionType * ftype = functionDecl->get_functionType();
                 std::list< DeclarationWithType * > & retVals = ftype->get_returnVals();
@@ -867 +910 @@
                                 ret->set_name( toString( "_retval_", CodeGen::genName( functionDecl ) ) );
                         }
-                }
-        }
-
-        void ReturnTypeFixer::visit( FunctionType * ftype ) {
+                        ret->get_attributes().push_back( new Attribute( "unused" ) );
+                }
+        }
+
+        void ReturnTypeFixer::postvisit( FunctionType * ftype ) {
                 // xxx - need to handle named return values - this information needs to be saved somehow
                 // so that resolution has access to the names.
@@ -888 +932 @@
 
         void ArrayLength::computeLength( std::list< Declaration * > & translationUnit ) {
-                ArrayLength len;
+                PassVisitor<ArrayLength> len;
                 acceptAll( translationUnit, len );
         }
 
-        void ArrayLength::visit( ObjectDecl * objDecl ) {
+        void ArrayLength::previsit( ObjectDecl * objDecl ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) {
                         if ( at->get_dimension() != nullptr ) return;