Index: src/ControlStruct/LabelFixer.h
===================================================================
--- src/ControlStruct/LabelFixer.h	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/ControlStruct/LabelFixer.h	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -26,5 +26,5 @@
 namespace ControlStruct {
 	/// normalizes label definitions and generates multi-level exit labels
-	class LabelFixer : public Visitor {
+	class LabelFixer final : public Visitor {
 		typedef Visitor Parent;
 	  public:
@@ -33,24 +33,26 @@
 		std::map < Label, Statement * > *resolveJumps() throw ( SemanticError );
 
+		using Visitor::visit;
+
 		// Declarations
-		virtual void visit( FunctionDecl *functionDecl );
+		virtual void visit( FunctionDecl *functionDecl ) override;
 
 		// Statements
 		void visit( Statement *stmt );
 
-		virtual void visit( CompoundStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( NullStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( ExprStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( IfStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( WhileStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( ForStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( SwitchStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( CaseStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( ReturnStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( TryStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( CatchStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( DeclStmt *stmt ) { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( BranchStmt *branchStmt );
-		virtual void visit( UntypedExpr *untyped );
+		virtual void visit( CompoundStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+		virtual void visit( NullStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+		virtual void visit( ExprStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+		virtual void visit( IfStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+		virtual void visit( WhileStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+		virtual void visit( ForStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+		virtual void visit( SwitchStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+		virtual void visit( CaseStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+		virtual void visit( ReturnStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+		virtual void visit( TryStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+		virtual void visit( CatchStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+		virtual void visit( DeclStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+		virtual void visit( BranchStmt *branchStmt ) override;
+		virtual void visit( UntypedExpr *untyped ) override;
 
 		Label setLabelsDef( std::list< Label > &, Statement *definition );
Index: src/ControlStruct/LabelTypeChecker.cc
===================================================================
--- src/ControlStruct/LabelTypeChecker.cc	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/ControlStruct/LabelTypeChecker.cc	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// LabelTypeChecker.cc -- 
+// LabelTypeChecker.cc --
 //
 // Author           : Rodolfo G. Esteves
@@ -28,5 +28,5 @@
 		assert( untypedExpr != 0 );
 		NameExpr *fname;
-		if ( ((fname = dynamic_cast<NameExpr *>(untypedExpr->get_function())) != 0) 
+		if ( ((fname = dynamic_cast<NameExpr *>(untypedExpr->get_function())) != 0)
 			 && fname->get_name() == std::string("&&") )
 			std::cerr << "Taking the label of an address." << std::endl;
@@ -58,7 +58,7 @@
 
 		NameExpr *name;
-		if ( ((name = dynamic_cast<NameExpr *>(target)) == 0) )
+		if ( (name = dynamic_cast<NameExpr *>(target)) == 0 )
 			return; // Not a name expression
-	
+
 		std::list< DeclarationWithType * > interps;
 		index.lookupId(name->get_name(), interps);
Index: src/GenPoly/Box.cc
===================================================================
--- src/GenPoly/Box.cc	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/GenPoly/Box.cc	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -64,31 +64,34 @@
 
 		/// Adds layout-generation functions to polymorphic types
-		class LayoutFunctionBuilder : public DeclMutator {
+		class LayoutFunctionBuilder final : public DeclMutator {
 			unsigned int functionNesting;  // current level of nested functions
 		public:
 			LayoutFunctionBuilder() : functionNesting( 0 ) {}
 
-			virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
-			virtual Declaration *mutate( StructDecl *structDecl );
-			virtual Declaration *mutate( UnionDecl *unionDecl );
+			using DeclMutator::mutate;
+			virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+			virtual Declaration *mutate( StructDecl *structDecl ) override;
+			virtual Declaration *mutate( UnionDecl *unionDecl ) override;
 		};
 
 		/// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
-		class Pass1 : public PolyMutator {
+		class Pass1 final : public PolyMutator {
 		  public:
 			Pass1();
-			virtual Expression *mutate( ApplicationExpr *appExpr );
-			virtual Expression *mutate( AddressExpr *addrExpr );
-			virtual Expression *mutate( UntypedExpr *expr );
-			virtual DeclarationWithType* mutate( FunctionDecl *functionDecl );
-			virtual TypeDecl *mutate( TypeDecl *typeDecl );
-			virtual Expression *mutate( CommaExpr *commaExpr );
-			virtual Expression *mutate( ConditionalExpr *condExpr );
-			virtual Statement * mutate( ReturnStmt *returnStmt );
-			virtual Type *mutate( PointerType *pointerType );
-			virtual Type * mutate( FunctionType *functionType );
-
-			virtual void doBeginScope();
-			virtual void doEndScope();
+
+			using PolyMutator::mutate;
+			virtual Expression *mutate( ApplicationExpr *appExpr ) override;
+			virtual Expression *mutate( AddressExpr *addrExpr ) override;
+			virtual Expression *mutate( UntypedExpr *expr ) override;
+			virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override;
+			virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
+			virtual Expression *mutate( CommaExpr *commaExpr ) override;
+			virtual Expression *mutate( ConditionalExpr *condExpr ) override;
+			virtual Statement * mutate( ReturnStmt *returnStmt ) override;
+			virtual Type *mutate( PointerType *pointerType ) override;
+			virtual Type * mutate( FunctionType *functionType ) override;
+
+			virtual void doBeginScope() override;
+			virtual void doEndScope() override;
 		  private:
 			/// Pass the extra type parameters from polymorphic generic arguments or return types into a function application
@@ -135,14 +138,16 @@
 		/// * Moves polymorphic returns in function types to pointer-type parameters
 		/// * adds type size and assertion parameters to parameter lists
-		class Pass2 : public PolyMutator {
+		class Pass2 final : public PolyMutator {
 		  public:
 			template< typename DeclClass >
 			DeclClass *handleDecl( DeclClass *decl, Type *type );
-			virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
-			virtual ObjectDecl *mutate( ObjectDecl *objectDecl );
-			virtual TypeDecl *mutate( TypeDecl *typeDecl );
-			virtual TypedefDecl *mutate( TypedefDecl *typedefDecl );
-			virtual Type *mutate( PointerType *pointerType );
-			virtual Type *mutate( FunctionType *funcType );
+
+			using PolyMutator::mutate;
+			virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+			virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
+			virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
+			virtual TypedefDecl *mutate( TypedefDecl *typedefDecl ) override;
+			virtual Type *mutate( PointerType *pointerType ) override;
+			virtual Type *mutate( FunctionType *funcType ) override;
 
 		  private:
@@ -156,5 +161,5 @@
 		/// * Calculates polymorphic offsetof expressions from offset array
 		/// * Inserts dynamic calculation of polymorphic type layouts where needed
-		class PolyGenericCalculator : public PolyMutator {
+		class PolyGenericCalculator final : public PolyMutator {
 		public:
 			typedef PolyMutator Parent;
@@ -163,19 +168,19 @@
 			template< typename DeclClass >
 			DeclClass *handleDecl( DeclClass *decl, Type *type );
-			virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
-			virtual ObjectDecl *mutate( ObjectDecl *objectDecl );
-			virtual TypedefDecl *mutate( TypedefDecl *objectDecl );
-			virtual TypeDecl *mutate( TypeDecl *objectDecl );
-			virtual Statement *mutate( DeclStmt *declStmt );
-			virtual Type *mutate( PointerType *pointerType );
-			virtual Type *mutate( FunctionType *funcType );
-			virtual Expression *mutate( MemberExpr *memberExpr );
-			virtual Expression *mutate( SizeofExpr *sizeofExpr );
-			virtual Expression *mutate( AlignofExpr *alignofExpr );
-			virtual Expression *mutate( OffsetofExpr *offsetofExpr );
-			virtual Expression *mutate( OffsetPackExpr *offsetPackExpr );
-
-			virtual void doBeginScope();
-			virtual void doEndScope();
+			virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+			virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
+			virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
+			virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
+			virtual Statement *mutate( DeclStmt *declStmt ) override;
+			virtual Type *mutate( PointerType *pointerType ) override;
+			virtual Type *mutate( FunctionType *funcType ) override;
+			virtual Expression *mutate( MemberExpr *memberExpr ) override;
+			virtual Expression *mutate( SizeofExpr *sizeofExpr ) override;
+			virtual Expression *mutate( AlignofExpr *alignofExpr ) override;
+			virtual Expression *mutate( OffsetofExpr *offsetofExpr ) override;
+			virtual Expression *mutate( OffsetPackExpr *offsetPackExpr ) override;
+
+			virtual void doBeginScope() override;
+			virtual void doEndScope() override;
 
 		private:
@@ -197,14 +202,16 @@
 
 		/// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, and sizeof expressions of polymorphic types with the proper variable
-		class Pass3 : public PolyMutator {
+		class Pass3 final : public PolyMutator {
 		  public:
 			template< typename DeclClass >
 			DeclClass *handleDecl( DeclClass *decl, Type *type );
-			virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
-			virtual ObjectDecl *mutate( ObjectDecl *objectDecl );
-			virtual TypedefDecl *mutate( TypedefDecl *objectDecl );
-			virtual TypeDecl *mutate( TypeDecl *objectDecl );
-			virtual Type *mutate( PointerType *pointerType );
-			virtual Type *mutate( FunctionType *funcType );
+
+			using PolyMutator::mutate;
+			virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+			virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
+			virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
+			virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
+			virtual Type *mutate( PointerType *pointerType ) override;
+			virtual Type *mutate( FunctionType *funcType ) override;
 		  private:
 		};
Index: src/GenPoly/InstantiateGeneric.cc
===================================================================
--- src/GenPoly/InstantiateGeneric.cc	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/GenPoly/InstantiateGeneric.cc	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -147,5 +147,5 @@
 
 	/// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
-	class GenericInstantiator : public DeclMutator {
+	class GenericInstantiator final : public DeclMutator {
 		/// Map of (generic type, parameter list) pairs to concrete type instantiations
 		InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
@@ -158,9 +158,10 @@
 		GenericInstantiator() : DeclMutator(), instantiations(), dtypeStatics(), typeNamer("_conc_") {}
 
-		virtual Type* mutate( StructInstType *inst );
-		virtual Type* mutate( UnionInstType *inst );
-
-		virtual void doBeginScope();
-		virtual void doEndScope();
+		using DeclMutator::mutate;
+		virtual Type* mutate( StructInstType *inst ) override;
+		virtual Type* mutate( UnionInstType *inst ) override;
+
+		virtual void doBeginScope() override;
+		virtual void doEndScope() override;
 	private:
 		/// Wrap instantiation lookup for structs
Index: src/GenPoly/Specialize.cc
===================================================================
--- src/GenPoly/Specialize.cc	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/GenPoly/Specialize.cc	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -36,11 +36,12 @@
 	const std::list<Label> noLabels;
 
-	class Specialize : public PolyMutator {
+	class Specialize final : public PolyMutator {
 	  public:
 		Specialize( std::string paramPrefix = "_p" );
 
-		virtual Expression * mutate( ApplicationExpr *applicationExpr );
-		virtual Expression * mutate( AddressExpr *castExpr );
-		virtual Expression * mutate( CastExpr *castExpr );
+		using PolyMutator::mutate;
+		virtual Expression * mutate( ApplicationExpr *applicationExpr ) override;
+		virtual Expression * mutate( AddressExpr *castExpr ) override;
+		virtual Expression * mutate( CastExpr *castExpr ) override;
 		// virtual Expression * mutate( LogicalExpr *logicalExpr );
 		// virtual Expression * mutate( ConditionalExpr *conditionalExpr );
Index: src/InitTweak/FixInit.cc
===================================================================
--- src/InitTweak/FixInit.cc	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/InitTweak/FixInit.cc	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -50,5 +50,5 @@
 		const std::list<Expression*> noDesignators;
 
-		class InsertImplicitCalls : public GenPoly::PolyMutator {
+		class InsertImplicitCalls final : public GenPoly::PolyMutator {
 		public:
 			/// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
@@ -56,8 +56,9 @@
 			static void insert( std::list< Declaration * > & translationUnit );
 
-			virtual Expression * mutate( ApplicationExpr * appExpr );
-		};
-
-		class ResolveCopyCtors : public SymTab::Indexer {
+			using GenPoly::PolyMutator::mutate;
+			virtual Expression * mutate( ApplicationExpr * appExpr ) override;
+		};
+
+		class ResolveCopyCtors final : public SymTab::Indexer {
 		public:
 			/// generate temporary ObjectDecls for each argument and return value of each ImplicitCopyCtorExpr,
@@ -66,5 +67,6 @@
 			static void resolveImplicitCalls( std::list< Declaration * > & translationUnit );
 
-			virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
+			using SymTab::Indexer::visit;
+			virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
 
 			/// create and resolve ctor/dtor expression: fname(var, [cpArg])
@@ -82,6 +84,6 @@
 			using Parent::visit;
 			typedef std::set< ObjectDecl * > ObjectSet;
-			virtual void visit( CompoundStmt *compoundStmt );
-			virtual void visit( DeclStmt *stmt );
+			virtual void visit( CompoundStmt *compoundStmt ) override;
+			virtual void visit( DeclStmt *stmt ) override;
 		  protected:
 			ObjectSet curVars;
@@ -103,5 +105,5 @@
 		}
 
-		class LabelFinder : public ObjDeclCollector {
+		class LabelFinder final : public ObjDeclCollector {
 		  public:
 			typedef ObjDeclCollector Parent;
@@ -117,23 +119,24 @@
 			// subclasses are added, there is only one place that the code has to be updated, rather than ensure that
 			// every specialized class knows about every new kind of statement that might be added.
-			virtual void visit( CompoundStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-			virtual void visit( ExprStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-			virtual void visit( AsmStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-			virtual void visit( IfStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-			virtual void visit( WhileStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-			virtual void visit( ForStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-			virtual void visit( SwitchStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-			virtual void visit( CaseStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-			virtual void visit( BranchStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-			virtual void visit( ReturnStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-			virtual void visit( TryStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-			virtual void visit( CatchStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-			virtual void visit( FinallyStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-			virtual void visit( NullStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-			virtual void visit( DeclStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-			virtual void visit( ImplicitCtorDtorStmt *stmt ) { handleStmt( stmt ); return Parent::visit( stmt ); }
-		};
-
-		class InsertDtors : public ObjDeclCollector {
+			using Parent::visit;
+			virtual void visit( CompoundStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+			virtual void visit( ExprStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+			virtual void visit( AsmStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+			virtual void visit( IfStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+			virtual void visit( WhileStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+			virtual void visit( ForStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+			virtual void visit( SwitchStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+			virtual void visit( CaseStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+			virtual void visit( BranchStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+			virtual void visit( ReturnStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+			virtual void visit( TryStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+			virtual void visit( CatchStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+			virtual void visit( FinallyStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+			virtual void visit( NullStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+			virtual void visit( DeclStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+			virtual void visit( ImplicitCtorDtorStmt *stmt ) override { handleStmt( stmt ); return Parent::visit( stmt ); }
+		};
+
+		class InsertDtors final : public ObjDeclCollector {
 		public:
 			/// insert destructor calls at the appropriate places.  must happen before CtorInit nodes are removed
@@ -147,9 +150,11 @@
 			InsertDtors( LabelFinder & finder ) : labelVars( finder.vars ) {}
 
-			virtual void visit( ObjectDecl * objDecl );
-
-			virtual void visit( CompoundStmt * compoundStmt );
-			virtual void visit( ReturnStmt * returnStmt );
-			virtual void visit( BranchStmt * stmt );
+			using Parent::visit;
+
+			virtual void visit( ObjectDecl * objDecl ) override;
+
+			virtual void visit( CompoundStmt * compoundStmt ) override;
+			virtual void visit( ReturnStmt * returnStmt ) override;
+			virtual void visit( BranchStmt * stmt ) override;
 		private:
 			void handleGoto( BranchStmt * stmt );
@@ -159,15 +164,16 @@
 		};
 
-		class FixInit : public GenPoly::PolyMutator {
+		class FixInit final : public GenPoly::PolyMutator {
 		  public:
 			/// expand each object declaration to use its constructor after it is declared.
 			static void fixInitializers( std::list< Declaration * > &translationUnit );
 
-			virtual DeclarationWithType * mutate( ObjectDecl *objDecl );
+			using GenPoly::PolyMutator::mutate;
+			virtual DeclarationWithType * mutate( ObjectDecl *objDecl ) override;
 
 			std::list< Declaration * > staticDtorDecls;
 		};
 
-		class FixCopyCtors : public GenPoly::PolyMutator {
+		class FixCopyCtors final : public GenPoly::PolyMutator {
 		  public:
 			/// expand ImplicitCopyCtorExpr nodes into the temporary declarations, copy constructors, call expression,
@@ -175,8 +181,9 @@
 			static void fixCopyCtors( std::list< Declaration * > &translationUnit );
 
-			virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr );
-		};
-
-		class GenStructMemberCalls : public SymTab::Indexer {
+			using GenPoly::PolyMutator::mutate;
+			virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
+		};
+
+		class GenStructMemberCalls final : public SymTab::Indexer {
 		  public:
 			typedef Indexer Parent;
@@ -186,8 +193,10 @@
 			static void generate( std::list< Declaration * > & translationUnit );
 
-			virtual void visit( FunctionDecl * funcDecl );
-
-			virtual void visit( MemberExpr * memberExpr );
-			virtual void visit( ApplicationExpr * appExpr );
+			using Parent::visit;
+
+			virtual void visit( FunctionDecl * funcDecl ) override;
+
+			virtual void visit( MemberExpr * memberExpr ) override;
+			virtual void visit( ApplicationExpr * appExpr ) override;
 
 			SemanticError errors;
@@ -207,21 +216,23 @@
 		// resolve UntypedExprs that are found within newly
 		// generated constructor/destructor calls
-		class MutatingResolver : public Mutator {
+		class MutatingResolver final : public Mutator {
 		  public:
 			MutatingResolver( SymTab::Indexer & indexer ) : indexer( indexer ) {}
 
-			virtual DeclarationWithType* mutate( ObjectDecl *objectDecl );
-
-			virtual Expression* mutate( UntypedExpr *untypedExpr );
-			private:
+			using Mutator::mutate;
+			virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ) override;
+			virtual Expression* mutate( UntypedExpr *untypedExpr ) override;
+
+		  private:
 			SymTab::Indexer & indexer;
 		};
 
-		class FixCtorExprs : public GenPoly::DeclMutator {
+		class FixCtorExprs final : public GenPoly::DeclMutator {
 		  public:
 			/// expands ConstructorExpr nodes into comma expressions, using a temporary for the first argument
 			static void fix( std::list< Declaration * > & translationUnit );
 
-			virtual Expression * mutate( ConstructorExpr * ctorExpr );
+			using GenPoly::DeclMutator::mutate;
+			virtual Expression * mutate( ConstructorExpr * ctorExpr ) override;
 		};
 	} // namespace
Index: src/InitTweak/GenInit.cc
===================================================================
--- src/InitTweak/GenInit.cc	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/InitTweak/GenInit.cc	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -36,5 +36,5 @@
 	}
 
-	class ReturnFixer : public GenPoly::PolyMutator {
+	class ReturnFixer final : public GenPoly::PolyMutator {
 	  public:
 		/// consistently allocates a temporary variable for the return value
@@ -45,7 +45,7 @@
 		ReturnFixer();
 
-		virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
-
-		virtual Statement * mutate( ReturnStmt * returnStmt );
+		using GenPoly::PolyMutator::mutate;
+		virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
+		virtual Statement * mutate( ReturnStmt * returnStmt ) override;
 
 	  protected:
@@ -55,5 +55,5 @@
 	};
 
-	class CtorDtor : public GenPoly::PolyMutator {
+	class CtorDtor final : public GenPoly::PolyMutator {
 	  public:
 		typedef GenPoly::PolyMutator Parent;
@@ -65,18 +65,18 @@
 		static void generateCtorDtor( std::list< Declaration * > &translationUnit );
 
-		virtual DeclarationWithType * mutate( ObjectDecl * );
-		virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
+		virtual DeclarationWithType * mutate( ObjectDecl * ) override;
+		virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
 		// should not traverse into any of these declarations to find objects
 		// that need to be constructed or destructed
-		virtual Declaration* mutate( StructDecl *aggregateDecl );
-		virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
-		virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
-		virtual Declaration* mutate( TraitDecl *aggregateDecl ) { return aggregateDecl; }
-		virtual TypeDecl* mutate( TypeDecl *typeDecl ) { return typeDecl; }
-		virtual Declaration* mutate( TypedefDecl *typeDecl ) { return typeDecl; }
-
-		virtual Type * mutate( FunctionType *funcType ) { return funcType; }
-
-		virtual CompoundStmt * mutate( CompoundStmt * compoundStmt );
+		virtual Declaration* mutate( StructDecl *aggregateDecl ) override;
+		virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; }
+		virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; }
+		virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; }
+		virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; }
+		virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; }
+
+		virtual Type * mutate( FunctionType *funcType ) override { return funcType; }
+
+		virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override;
 
 	  private:
@@ -91,5 +91,5 @@
 	};
 
-	class HoistArrayDimension : public GenPoly::DeclMutator {
+	class HoistArrayDimension final : public GenPoly::DeclMutator {
 	  public:
 		typedef GenPoly::DeclMutator Parent;
@@ -101,16 +101,18 @@
 
 	  private:
-		virtual DeclarationWithType * mutate( ObjectDecl * objectDecl );
-		virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
+		using Parent::mutate;
+
+		virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override;
+		virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
 		// should not traverse into any of these declarations to find objects
 		// that need to be constructed or destructed
-		virtual Declaration* mutate( StructDecl *aggregateDecl ) { return aggregateDecl; }
-		virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
-		virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
-		virtual Declaration* mutate( TraitDecl *aggregateDecl ) { return aggregateDecl; }
-		virtual TypeDecl* mutate( TypeDecl *typeDecl ) { return typeDecl; }
-		virtual Declaration* mutate( TypedefDecl *typeDecl ) { return typeDecl; }
-
-		virtual Type* mutate( FunctionType *funcType ) { return funcType; }
+		virtual Declaration* mutate( StructDecl *aggregateDecl ) override { return aggregateDecl; }
+		virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; }
+		virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; }
+		virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; }
+		virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; }
+		virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; }
+
+		virtual Type* mutate( FunctionType *funcType ) override { return funcType; }
 
 		void hoist( Type * type );
Index: src/InitTweak/InitTweak.h
===================================================================
--- src/InitTweak/InitTweak.h	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/InitTweak/InitTweak.h	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -100,4 +100,5 @@
 
 		class ExpanderImpl;
+		typedef std::list< Expression * > IndexList;
 	private:
 		std::shared_ptr< ExpanderImpl > expander;
@@ -105,5 +106,4 @@
 
 		// invariant: list of size 2N (elements come in pairs [index, dimension])
-		typedef std::list< Expression * > IndexList;
 		IndexList indices;
 	};
Index: src/Parser/ParseNode.h
===================================================================
--- src/Parser/ParseNode.h	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/Parser/ParseNode.h	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -109,5 +109,5 @@
 	ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
 
-	void print( std::ostream &os, int indent = 0 ) const {}
+	virtual void print( std::ostream &os, int indent = 0 ) const override {}
 	void printOneLine( std::ostream &os, int indent = 0 ) const {}
 
@@ -187,5 +187,5 @@
 //##############################################################################
 
-class TypeData;
+struct TypeData;
 
 class DeclarationNode : public ParseNode {
@@ -271,6 +271,6 @@
 	}
 
-	void print( std::ostream &os, int indent = 0 ) const;
-	void printList( std::ostream &os, int indent = 0 ) const;
+	virtual void print( std::ostream &os, int indent = 0 ) const override;
+	virtual void printList( std::ostream &os, int indent = 0 ) const override;
 
 	Declaration * build() const;
@@ -345,6 +345,6 @@
 	virtual StatementNode * append_last_case( StatementNode * );
 
-	virtual void print( std::ostream &os, int indent = 0 ) {}
-	virtual void printList( std::ostream &os, int indent = 0 ) {}
+	virtual void print( std::ostream &os, int indent = 0 ) const override {}
+	virtual void printList( std::ostream &os, int indent = 0 ) const override {}
   private:
 	std::unique_ptr<Statement> stmt;
Index: src/ResolvExpr/AlternativePrinter.h
===================================================================
--- src/ResolvExpr/AlternativePrinter.h	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/ResolvExpr/AlternativePrinter.h	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// AlternativePrinter.h -- 
+// AlternativePrinter.h --
 //
 // Author           : Richard C. Bilson
@@ -23,8 +23,10 @@
 
 namespace ResolvExpr {
-	class AlternativePrinter : public SymTab::Indexer {
+	class AlternativePrinter final : public SymTab::Indexer {
 	  public:
 		AlternativePrinter( std::ostream &os );
-		virtual void visit( ExprStmt *exprStmt );
+
+		using SymTab::Indexer::visit;
+		virtual void visit( ExprStmt *exprStmt ) override;
 	  private:
 		std::ostream &os;
Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/ResolvExpr/Resolver.cc	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -32,30 +32,31 @@
 
 namespace ResolvExpr {
-	class Resolver : public SymTab::Indexer {
+	class Resolver final : public SymTab::Indexer {
 	  public:
-		Resolver() : SymTab::Indexer( false ), switchType( 0 ) {}
-
-		virtual void visit( FunctionDecl *functionDecl );
-		virtual void visit( ObjectDecl *functionDecl );
-		virtual void visit( TypeDecl *typeDecl );
-		virtual void visit( EnumDecl * enumDecl );
-
-		virtual void visit( ArrayType * at );
-		virtual void visit( PointerType * at );
-
-		virtual void visit( ExprStmt *exprStmt );
-		virtual void visit( AsmExpr *asmExpr );
-		virtual void visit( AsmStmt *asmStmt );
-		virtual void visit( IfStmt *ifStmt );
-		virtual void visit( WhileStmt *whileStmt );
-		virtual void visit( ForStmt *forStmt );
-		virtual void visit( SwitchStmt *switchStmt );
-		virtual void visit( CaseStmt *caseStmt );
-		virtual void visit( BranchStmt *branchStmt );
-		virtual void visit( ReturnStmt *returnStmt );
-
-		virtual void visit( SingleInit *singleInit );
-		virtual void visit( ListInit *listInit );
-		virtual void visit( ConstructorInit *ctorInit );
+		Resolver() : SymTab::Indexer( false ) {}
+
+		using SymTab::Indexer::visit;
+		virtual void visit( FunctionDecl *functionDecl ) override;
+		virtual void visit( ObjectDecl *functionDecl ) override;
+		virtual void visit( TypeDecl *typeDecl ) override;
+		virtual void visit( EnumDecl * enumDecl ) override;
+
+		virtual void visit( ArrayType * at ) override;
+		virtual void visit( PointerType * at ) override;
+
+		virtual void visit( ExprStmt *exprStmt ) override;
+		virtual void visit( AsmExpr *asmExpr ) override;
+		virtual void visit( AsmStmt *asmStmt ) override;
+		virtual void visit( IfStmt *ifStmt ) override;
+		virtual void visit( WhileStmt *whileStmt ) override;
+		virtual void visit( ForStmt *forStmt ) override;
+		virtual void visit( SwitchStmt *switchStmt ) override;
+		virtual void visit( CaseStmt *caseStmt ) override;
+		virtual void visit( BranchStmt *branchStmt ) override;
+		virtual void visit( ReturnStmt *returnStmt ) override;
+
+		virtual void visit( SingleInit *singleInit ) override;
+		virtual void visit( ListInit *listInit ) override;
+		virtual void visit( ConstructorInit *ctorInit ) override;
 	  private:
   	typedef std::list< Initializer * >::iterator InitIterator;
@@ -69,5 +70,4 @@
 		std::list< Type * > functionReturn;
 		Type *initContext;
-		Type *switchType;
 		bool inEnumDecl = false;
 	};
Index: src/ResolvExpr/TypeMap.h
===================================================================
--- src/ResolvExpr/TypeMap.h	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/ResolvExpr/TypeMap.h	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -38,5 +38,5 @@
 		typedef typename std::map< std::string, Value* > ValueMap;
 		typedef typename ValueMap::iterator ValueMapIterator;
-		
+
 		Value *voidValue;                                     ///< Value for void type
 		Value *basicValue[BasicType::NUMBER_OF_BASIC_TYPES];  ///< Values for basic types
@@ -54,5 +54,5 @@
 			/// One scope of map rollbacks
 			typedef std::vector< std::pair< ValueMapIterator, Value* > > MapScope;
-			
+
 			PointerScope pointers;  ///< Value pointers to roll back to their previous state
 			MapScope mapNodes;      ///< Value map iterators to roll back to their previous state
@@ -68,5 +68,5 @@
 
 		std::vector< Rollback > scopes;  ///< Scope rollback information
-		
+
 		struct Lookup : public Visitor {
 			Lookup( TypeMap<Value> &typeMap ) : typeMap( typeMap ), found( 0 ), toInsert( 0 ) {}
@@ -87,5 +87,5 @@
 				return found;
 			}
-			
+
 			void findAndReplace( Value *&loc ) {
 				found = loc;
@@ -109,13 +109,13 @@
 				}
 			}
-			
+
 			virtual void visit( VoidType *voidType ) {
 				findAndReplace( typeMap.voidValue );
 			}
-			
+
 			virtual void visit( BasicType *basicType ) {
 				findAndReplace( typeMap.basicValue[basicType->get_kind()] );
 			}
-			
+
 			virtual void visit( PointerType *pointerType ) {
 				// NOTE This is one of the places where the apporoximation of the resolver is (deliberately) poor;
@@ -129,5 +129,5 @@
 				}
 			}
-			
+
 			virtual void visit( ArrayType *arrayType ) {
 				if ( dynamic_cast< FunctionType* >( arrayType->get_base() ) ) {
@@ -137,17 +137,17 @@
 				}
 			}
-			
+
 			virtual void visit( FunctionType *functionType ) {
 				findAndReplace( typeMap.functionPointerValue );
 			}
-			
+
 			virtual void visit( StructInstType *structType ) {
 				findAndReplace( typeMap.structValue, structType->get_name() );
 			}
-			
+
 			virtual void visit( UnionInstType *unionType ) {
 				findAndReplace( typeMap.unionValue, unionType->get_name() );
 			}
-			
+
 			virtual void visit( EnumInstType *enumType ) {
 				findAndReplace( typeMap.enumValue, enumType->get_name() );
@@ -157,7 +157,7 @@
 			Value *found;             ///< Value found (NULL if none yet)
 			Value *toInsert;          ///< Value to insert (NULL if a lookup)
-		};  // class Lookup
-		friend class Lookup;
-		
+		};  // struct Lookup
+		friend struct Lookup;
+
 	public:
 		/// Starts a new scope
@@ -180,5 +180,5 @@
 			scopes.pop_back();
 		}
-		
+
 		TypeMap() : voidValue( 0 ), pointerValue( 0 ), voidPointerValue( 0 ), functionPointerValue( 0 ), structValue(), unionValue(), enumValue(), scopes() {
 			beginScope();
@@ -199,5 +199,5 @@
 			return searcher.find( key );
 		}
-		
+
 	}; // class TypeMap
 
Index: src/ResolvExpr/Unify.cc
===================================================================
--- src/ResolvExpr/Unify.cc	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/ResolvExpr/Unify.cc	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -73,5 +73,4 @@
 		const OpenVarSet &openVars;
 		WidenMode widenMode;
-		Type *commonType;
 		const SymTab::Indexer &indexer;
 	};
Index: src/SymTab/Validate.cc
===================================================================
--- src/SymTab/Validate.cc	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/SymTab/Validate.cc	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -94,15 +94,16 @@
 
 	/// Associates forward declarations of aggregates with their definitions
-	class Pass2 : public Indexer {
+	class Pass2 final : public Indexer {
 		typedef Indexer Parent;
 	  public:
 		Pass2( bool doDebug, const Indexer *indexer );
 	  private:
-		virtual void visit( StructInstType *structInst );
-		virtual void visit( UnionInstType *unionInst );
-		virtual void visit( TraitInstType *contextInst );
-		virtual void visit( StructDecl *structDecl );
-		virtual void visit( UnionDecl *unionDecl );
-		virtual void visit( TypeInstType *typeInst );
+  		using Indexer::visit;
+		void visit( StructInstType *structInst ) final;
+		void visit( UnionInstType *unionInst ) final;
+		void visit( TraitInstType *contextInst ) final;
+		void visit( StructDecl *structDecl ) final;
+		void visit( UnionDecl *unionDecl ) final;
+		void visit( TypeInstType *typeInst ) final;
 
 		const Indexer *indexer;
@@ -182,9 +183,10 @@
 	};
 
-	class CompoundLiteral : public GenPoly::DeclMutator {
+	class CompoundLiteral final : public GenPoly::DeclMutator {
 		DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;
 
-		virtual DeclarationWithType * mutate( ObjectDecl *objectDecl );
-		virtual Expression *mutate( CompoundLiteralExpr *compLitExpr );
+		using GenPoly::DeclMutator::mutate;
+		DeclarationWithType * mutate( ObjectDecl *objectDecl ) final;
+		Expression *mutate( CompoundLiteralExpr *compLitExpr ) final;
 	};
 
@@ -652,5 +654,5 @@
 	void EliminateTypedef::addImplicitTypedef( AggDecl * aggDecl ) {
 		if ( typedefNames.count( aggDecl->get_name() ) == 0 ) {
-			Type *type;
+			Type *type = nullptr;
 			if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( aggDecl ) ) {
 				type = new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() );
Index: src/Tuples/TupleAssignment.cc
===================================================================
--- src/Tuples/TupleAssignment.cc	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/Tuples/TupleAssignment.cc	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// TupleAssignment.cc -- 
+// TupleAssignment.cc --
 //
 // Author           : Rodolfo G. Esteves
@@ -29,5 +29,5 @@
 
 namespace Tuples {
-	TupleAssignSpotter::TupleAssignSpotter( ResolvExpr::AlternativeFinder *f = 0 )
+	TupleAssignSpotter::TupleAssignSpotter( ResolvExpr::AlternativeFinder *f )
 		: currentFinder(f), matcher(0), hasMatched( false ) {}
 
Index: src/Tuples/TupleAssignment.h
===================================================================
--- src/Tuples/TupleAssignment.h	(revision d93d9807efa68872082bfab3e69e2e1b68b3e3f8)
+++ src/Tuples/TupleAssignment.h	(revision 62e5546cd62ceedcb0b33b24775b308bc35ad734)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// TupleAssignment.h -- 
+// TupleAssignment.h --
 //
 // Author           : Rodolfo G. Esteves
@@ -29,5 +29,5 @@
 	  public:
 		// dispatcher for Tuple (multiple and mass) assignment operations
-		TupleAssignSpotter( ResolvExpr::AlternativeFinder * );
+		TupleAssignSpotter( ResolvExpr::AlternativeFinder * = 0 );
 		~TupleAssignSpotter() { delete matcher; matcher = 0; }
 
@@ -97,5 +97,5 @@
 		ResolvExpr::AlternativeFinder *currentFinder;
 		//std::list<Expression *> rhs, lhs;
-		Expression *rhs, *lhs;
+		// Expression *rhs, *lhs;
 		Matcher *matcher;
 		bool hasMatched;