Changeset b1e63ac5 for src/InitTweak

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/InitTweak

Files:

• FixGlobalInit.cc (modified) (2 diffs)
• FixInit.cc (modified) (21 diffs)
• GenInit.cc (modified) (11 diffs)
• InitTweak.cc (modified) (6 diffs)

src/InitTweak/FixGlobalInit.cc

@@ -26 +26 @@
 
 namespace InitTweak {
-        namespace {
-                const std::list<Label> noLabels;
-        }
-
         class GlobalFixer : public Visitor {
           public:
@@ -129 +125 @@
 
         // only modify global variables
-        void GlobalFixer::visit( FunctionDecl *functionDecl ) {}
-        void GlobalFixer::visit( StructDecl *aggregateDecl ) {}
-        void GlobalFixer::visit( UnionDecl *aggregateDecl ) {}
-        void GlobalFixer::visit( EnumDecl *aggregateDecl ) {}
-        void GlobalFixer::visit( TraitDecl *aggregateDecl ) {}
-        void GlobalFixer::visit( TypeDecl *typeDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) FunctionDecl *functionDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) StructDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) UnionDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) EnumDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) TraitDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) TypeDecl *typeDecl ) {}
 
 } // namespace InitTweak

src/InitTweak/FixInit.cc

@@ -10 +10 @@
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 17 09:13:47 2017
-// Update Count     : 71
+// Last Modified On : Wed Jun 21 17:35:05 2017
+// Update Count     : 74
 //
 
@@ -20 +20 @@
 #include <unordered_map>
 #include <unordered_set>
+
 #include "InitTweak.h"
 #include "GenInit.h"
 #include "FixInit.h"
 #include "FixGlobalInit.h"
+#include "CodeGen/GenType.h"  // for warning/error messages
+#include "Common/PassVisitor.h"
+#include "GenPoly/DeclMutator.h"
+#include "GenPoly/PolyMutator.h"
 #include "ResolvExpr/Resolver.h"
 #include "ResolvExpr/typeops.h"
+#include "SymTab/Autogen.h"
+#include "SymTab/Indexer.h"
+#include "SynTree/AddStmtVisitor.h"
+#include "SynTree/Attribute.h"
 #include "SynTree/Declaration.h"
-#include "SynTree/Type.h"
 #include "SynTree/Expression.h"
-#include "SynTree/Attribute.h"
-#include "SynTree/Statement.h"
 #include "SynTree/Initializer.h"
 #include "SynTree/Mutator.h"
-#include "SymTab/Indexer.h"
-#include "SymTab/Autogen.h"
-#include "GenPoly/PolyMutator.h"
-#include "GenPoly/DeclMutator.h"
-#include "SynTree/AddStmtVisitor.h"
-#include "CodeGen/GenType.h"  // for warning/error messages
+#include "SynTree/Statement.h"
+#include "SynTree/Type.h"
 #include "Tuples/Tuples.h"
 
@@ -54 +56 @@
                 typedef std::unordered_map< int, int > UnqCount;
 
-                class InsertImplicitCalls final : public GenPoly::PolyMutator {
+                class InsertImplicitCalls : public WithTypeSubstitution {
                 public:
                         /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
@@ -61 +63 @@
 
                         InsertImplicitCalls( EnvMap & envMap ) : envMap( envMap ) {}
-                        typedef GenPoly::PolyMutator Parent;
-                        using Parent::mutate;
-                        virtual Expression * mutate( ApplicationExpr * appExpr ) override;
-                        virtual Expression * mutate( StmtExpr * stmtExpr ) override;
+
+                        Expression * postmutate( ApplicationExpr * appExpr );
+                        void premutate( StmtExpr * stmtExpr );
 
                         // collects environments for relevant nodes
@@ -103 +104 @@
                         typedef AddStmtVisitor Parent;
                         using Parent::visit;
-                        typedef std::set< ObjectDecl * > ObjectSet;
+                        // use ordered data structure to maintain ordering for set_difference and for consistent error messages
+                        typedef std::list< ObjectDecl * > ObjectSet;
                         virtual void visit( CompoundStmt *compoundStmt ) override;
                         virtual void visit( DeclStmt *stmt ) override;
 
                         // don't go into other functions
-                        virtual void visit( FunctionDecl *decl ) override {}
+                        virtual void visit( __attribute__((unused)) FunctionDecl *decl ) override {}
 
                   protected:
@@ -115 +117 @@
 
                 // debug
-                struct printSet {
-                        typedef ObjDeclCollector::ObjectSet ObjectSet;
-                        printSet( const ObjectSet & objs ) : objs( objs ) {}
+                template<typename ObjectSet>
+                struct PrintSet {
+                        PrintSet( const ObjectSet & objs ) : objs( objs ) {}
                         const ObjectSet & objs;
                 };
-                std::ostream & operator<<( std::ostream & out, const printSet & set) {
+                template<typename ObjectSet>
+                PrintSet<ObjectSet> printSet( const ObjectSet & objs ) { return PrintSet<ObjectSet>( objs ); }
+                template<typename ObjectSet>
+                std::ostream & operator<<( std::ostream & out, const PrintSet<ObjectSet> & set) {
                         out << "{ ";
                         for ( ObjectDecl * obj : set.objs ) {
@@ -190 +195 @@
                 };
 
-                class FixInit final : public GenPoly::PolyMutator {
+                class FixInit : public WithStmtsToAdd {
                   public:
                         /// expand each object declaration to use its constructor after it is declared.
                         static void fixInitializers( std::list< Declaration * > &translationUnit );
 
-                        typedef GenPoly::PolyMutator Parent;
-                        using Parent::mutate;
-                        virtual DeclarationWithType * mutate( ObjectDecl *objDecl ) override;
+                        DeclarationWithType * postmutate( ObjectDecl *objDecl );
 
                         std::list< Declaration * > staticDtorDecls;
@@ -300 +303 @@
         namespace {
                 void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit, EnvMap & envMap ) {
-                        InsertImplicitCalls inserter( envMap );
+                        PassVisitor<InsertImplicitCalls> inserter( envMap );
                         mutateAll( translationUnit, inserter );
                 }
@@ -310 +313 @@
 
                 void FixInit::fixInitializers( std::list< Declaration * > & translationUnit ) {
-                        FixInit fixer;
+                        PassVisitor<FixInit> fixer;
 
                         // can't use mutateAll, because need to insert declarations at top-level
@@ -318 +321 @@
                                 try {
                                         *i = maybeMutate( *i, fixer );
-                                        translationUnit.splice( i, fixer.staticDtorDecls );
+                                        translationUnit.splice( i, fixer.pass.staticDtorDecls );
                                 } catch( SemanticError &e ) {
                                         e.set_location( (*i)->location );
@@ -350 +353 @@
                 }
 
-                Expression * InsertImplicitCalls::mutate( ApplicationExpr * appExpr ) {
-                        appExpr = dynamic_cast< ApplicationExpr * >( Parent::mutate( appExpr ) );
+                Expression * InsertImplicitCalls::postmutate( ApplicationExpr * appExpr ) {
                         assert( appExpr );
 
@@ -393 +395 @@
                 }
 
-                Expression * InsertImplicitCalls::mutate( StmtExpr * stmtExpr ) {
+                void InsertImplicitCalls::premutate( StmtExpr * stmtExpr ) {
                         assert( env );
                         envMap[stmtExpr] = env;
-                        return Parent::mutate( stmtExpr );
                 }
 
@@ -696 +697 @@
                 }
 
-                DeclarationWithType *FixInit::mutate( ObjectDecl *objDecl ) {
-                        // first recursively handle pieces of ObjectDecl so that they aren't missed by other visitors when the init
-                        // is removed from the ObjectDecl
-                        objDecl = dynamic_cast< ObjectDecl * >( Parent::mutate( objDecl ) );
+                DeclarationWithType *FixInit::postmutate( ObjectDecl *objDecl ) {
+                        // since this removes the init field from objDecl, it must occur after children are mutated (i.e. postmutate)
                         if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {
                                 // a decision should have been made by the resolver, so ctor and init are not both non-NULL
@@ -729 +728 @@
                                                 // static bool __objName_uninitialized = true
                                                 BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
-                                                SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators );
+                                                SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant::from_int( 1 ) ) );
                                                 ObjectDecl * isUninitializedVar = new ObjectDecl( objDecl->get_mangleName() + "_uninitialized", Type::StorageClasses( Type::Static ), LinkageSpec::Cforall, 0, boolType, boolInitExpr );
                                                 isUninitializedVar->fixUniqueId();
@@ -736 +735 @@
                                                 UntypedExpr * setTrue = new UntypedExpr( new NameExpr( "?=?" ) );
                                                 setTrue->get_args().push_back( new VariableExpr( isUninitializedVar ) );
-                                                setTrue->get_args().push_back( new ConstantExpr( Constant( boolType->clone(), "0" ) ) );
+                                                setTrue->get_args().push_back( new ConstantExpr( Constant::from_int( 0 ) ) );
 
                                                 // generate body of if
@@ -750 +749 @@
 
                                                 Statement * dtor = ctorInit->get_dtor();
-                                                objDecl->set_init( NULL );
-                                                ctorInit->set_ctor( NULL );
+                                                objDecl->set_init( nullptr );
+                                                ctorInit->set_ctor( nullptr );
                                                 ctorInit->set_dtor( nullptr );
                                                 if ( dtor ) {
@@ -804 +803 @@
                                                 } else {
                                                         stmtsToAddAfter.push_back( ctor );
-                                                        objDecl->set_init( NULL );
-                                                        ctorInit->set_ctor( NULL );
+                                                        objDecl->set_init( nullptr );
+                                                        ctorInit->set_ctor( nullptr );
                                                 }
                                         } // if
                                 } else if ( Initializer * init = ctorInit->get_init() ) {
                                         objDecl->set_init( init );
-                                        ctorInit->set_init( NULL );
+                                        ctorInit->set_init( nullptr );
                                 } else {
                                         // no constructor and no initializer, which is okay
-                                        objDecl->set_init( NULL );
+                                        objDecl->set_init( nullptr );
                                 } // if
                                 delete ctorInit;
@@ -821 +820 @@
 
                 void ObjDeclCollector::visit( CompoundStmt * compoundStmt ) {
-                        std::set< ObjectDecl * > prevVars = curVars;
+                        ObjectSet prevVars = curVars;
                         Parent::visit( compoundStmt );
                         curVars = prevVars;
@@ -829 +828 @@
                         // keep track of all variables currently in scope
                         if ( ObjectDecl * objDecl = dynamic_cast< ObjectDecl * > ( stmt->get_decl() ) ) {
-                                curVars.insert( objDecl );
+                                curVars.push_back( objDecl );
                         } // if
                         Parent::visit( stmt );
@@ -896 +895 @@
                         Parent::visit( compoundStmt );
 
-                        // add destructors for the current scope that we're exiting
+                        // add destructors for the current scope that we're exiting, unless the last statement is a return, which
+                        // causes unreachable code warnings
                         std::list< Statement * > & statements = compoundStmt->get_kids();
-                        insertDtors( reverseDeclOrder.front().begin(), reverseDeclOrder.front().end(), back_inserter( statements ) );
+                        if ( ! statements.empty() && ! dynamic_cast< ReturnStmt * >( statements.back() ) ) {
+                                insertDtors( reverseDeclOrder.front().begin(), reverseDeclOrder.front().end(), back_inserter( statements ) );
+                        }
                         reverseDeclOrder.pop_front();
                 }
 
-                void InsertDtors::visit( ReturnStmt * returnStmt ) {
+                void InsertDtors::visit( __attribute((unused)) ReturnStmt * returnStmt ) {
                         // return exits all scopes, so dump destructors for all scopes
                         for ( OrderedDecls & od : reverseDeclOrder ) {
@@ -941 +943 @@
                         )
                         if ( ! diff.empty() ) {
+                                // create an auxilliary set for fast lookup -- can't make diff a set, because diff ordering should be consistent for error messages.
+                                std::unordered_set<ObjectDecl *> needsDestructor( diff.begin(), diff.end() );
+
                                 // go through decl ordered list of objectdecl. for each element that occurs in diff, output destructor
                                 OrderedDecls ordered;
                                 for ( OrderedDecls & rdo : reverseDeclOrder ) {
                                         // add elements from reverseDeclOrder into ordered if they occur in diff - it is key that this happens in reverse declaration order.
-                                        copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return diff.count( objDecl ); } );
+                                        copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return needsDestructor.count( objDecl ); } );
                                 } // for
                                 insertDtors( ordered.begin(), ordered.end(), back_inserter( stmtsToAdd ) );

src/InitTweak/GenInit.cc

@@ -16 +16 @@
 #include <stack>
 #include <list>
+
+#include "InitTweak.h"
 #include "GenInit.h"
-#include "InitTweak.h"
+
+#include "Common/PassVisitor.h"
+
+#include "GenPoly/DeclMutator.h"
+#include "GenPoly/PolyMutator.h"
+#include "GenPoly/ScopedSet.h"
+
+#include "ResolvExpr/typeops.h"
+
 #include "SynTree/Declaration.h"
-#include "SynTree/Type.h"
 #include "SynTree/Expression.h"
-#include "SynTree/Statement.h"
 #include "SynTree/Initializer.h"
 #include "SynTree/Mutator.h"
+#include "SynTree/Statement.h"
+#include "SynTree/Type.h"
+
 #include "SymTab/Autogen.h"
 #include "SymTab/Mangler.h"
-#include "GenPoly/PolyMutator.h"
-#include "GenPoly/DeclMutator.h"
-#include "GenPoly/ScopedSet.h"
-#include "ResolvExpr/typeops.h"
 
 namespace InitTweak {
@@ -37 +44 @@
         }
 
-        class ReturnFixer final : public GenPoly::PolyMutator {
-          public:
+        struct ReturnFixer : public WithStmtsToAdd, public WithGuards {
                 /// consistently allocates a temporary variable for the return value
                 /// of a function so that anything which the resolver decides can be constructed
@@ -44 +50 @@
                 static void makeReturnTemp( std::list< Declaration * > &translationUnit );
 
-                ReturnFixer();
-
-                typedef GenPoly::PolyMutator Parent;
-                using Parent::mutate;
-                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
-                virtual Statement * mutate( ReturnStmt * returnStmt ) override;
+                void premutate( FunctionDecl *functionDecl );
+                void premutate( ReturnStmt * returnStmt );
 
           protected:
@@ -56 +58 @@
         };
 
-        class CtorDtor final : public GenPoly::PolyMutator {
-          public:
-                typedef GenPoly::PolyMutator Parent;
-                using Parent::mutate;
+        struct CtorDtor : public WithGuards, public WithShortCircuiting  {
                 /// create constructor and destructor statements for object declarations.
                 /// the actual call statements will be added in after the resolver has run
@@ -66 +65 @@
                 static void generateCtorDtor( std::list< Declaration * > &translationUnit );
 
-                virtual DeclarationWithType * mutate( ObjectDecl * ) override;
-                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
+                void previsit( ObjectDecl * );
+                void previsit( FunctionDecl *functionDecl );
+
                 // should not traverse into any of these declarations to find objects
                 // that need to be constructed or destructed
-                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;
+                void previsit( StructDecl *aggregateDecl );
+                void previsit( UnionDecl *aggregateDecl ) { visit_children = false; }
+                void previsit( EnumDecl *aggregateDecl ) { visit_children = false; }
+                void previsit( TraitDecl *aggregateDecl ) { visit_children = false; }
+                void previsit( TypeDecl *typeDecl ) { visit_children = false; }
+                void previsit( TypedefDecl *typeDecl ) { visit_children = false; }
+
+                void previsit( FunctionType *funcType ) { visit_children = false; }
+
+                void previsit( CompoundStmt * compoundStmt );
 
           private:
@@ -131 +131 @@
 
         void ReturnFixer::makeReturnTemp( std::list< Declaration * > & translationUnit ) {
-                ReturnFixer fixer;
+                PassVisitor<ReturnFixer> fixer;
                 mutateAll( translationUnit, fixer );
         }
 
-        ReturnFixer::ReturnFixer() {}
-
-        Statement *ReturnFixer::mutate( ReturnStmt *returnStmt ) {
+        void ReturnFixer::premutate( ReturnStmt *returnStmt ) {
                 std::list< DeclarationWithType * > & returnVals = ftype->get_returnVals();
                 assert( returnVals.size() == 0 || returnVals.size() == 1 );
@@ -148 +146 @@
                         construct->get_args().push_back( new AddressExpr( new VariableExpr( returnVals.front() ) ) );
                         construct->get_args().push_back( returnStmt->get_expr() );
-                        stmtsToAdd.push_back(new ExprStmt(noLabels, construct));
+                        stmtsToAddBefore.push_back(new ExprStmt(noLabels, construct));
 
                         // return the retVal object
                         returnStmt->set_expr( new VariableExpr( returnVals.front() ) );
                 } // if
-                return returnStmt;
-        }
-
-        DeclarationWithType* ReturnFixer::mutate( FunctionDecl *functionDecl ) {
-                ValueGuard< FunctionType * > oldFtype( ftype );
-                ValueGuard< std::string > oldFuncName( funcName );
+        }
+
+        void ReturnFixer::premutate( FunctionDecl *functionDecl ) {
+                GuardValue( ftype );
+                GuardValue( funcName );
 
                 ftype = functionDecl->get_functionType();
                 funcName = functionDecl->get_name();
-                return Parent::mutate( functionDecl );
         }
 
@@ -212 +208 @@
 
         void CtorDtor::generateCtorDtor( std::list< Declaration * > & translationUnit ) {
-                CtorDtor ctordtor;
-                mutateAll( translationUnit, ctordtor );
+                PassVisitor<CtorDtor> ctordtor;
+                acceptAll( translationUnit, ctordtor );
         }
 
@@ -291 +287 @@
         }
 
-        DeclarationWithType * CtorDtor::mutate( ObjectDecl * objDecl ) {
+        void CtorDtor::previsit( ObjectDecl * objDecl ) {
                 handleDWT( objDecl );
                 // hands off if @=, extern, builtin, etc.
@@ -303 +299 @@
                         objDecl->set_init( genCtorInit( objDecl ) );
                 }
-                return Parent::mutate( objDecl );
-        }
-
-        DeclarationWithType * CtorDtor::mutate( FunctionDecl *functionDecl ) {
-                ValueGuard< bool > oldInFunc = inFunction;
+        }
+
+        void CtorDtor::previsit( FunctionDecl *functionDecl ) {
+                GuardValue( inFunction );
                 inFunction = true;
 
                 handleDWT( functionDecl );
 
-                managedTypes.beginScope();
+                GuardScope( managedTypes );
                 // go through assertions and recursively add seen ctor/dtors
                 for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) {
                         for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
-                                assertion = assertion->acceptMutator( *this );
+                                handleDWT( assertion );
                         }
                 }
-                // parameters should not be constructed and destructed, so don't mutate FunctionType
-                functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
-
-                managedTypes.endScope();
-                return functionDecl;
-        }
-
-        Declaration* CtorDtor::mutate( StructDecl *aggregateDecl ) {
+
+                PassVisitor<CtorDtor> newCtorDtor;
+                newCtorDtor.pass = *this;
+                maybeAccept( functionDecl->get_statements(), newCtorDtor );
+                visit_children = false;  // do not try and construct parameters or forall parameters - must happen after maybeAccept
+        }
+
+        void CtorDtor::previsit( StructDecl *aggregateDecl ) {
+                visit_children = false; // do not try to construct and destruct aggregate members
+
                 // don't construct members, but need to take note if there is a managed member,
                 // because that means that this type is also managed
@@ -338 +335 @@
                         }
                 }
-                return aggregateDecl;
-        }
-
-        CompoundStmt * CtorDtor::mutate( CompoundStmt * compoundStmt ) {
-                managedTypes.beginScope();
-                CompoundStmt * stmt = Parent::mutate( compoundStmt );
-                managedTypes.endScope();
-                return stmt;
-        }
-
+        }
+
+        void CtorDtor::previsit( CompoundStmt * compoundStmt ) {
+                GuardScope( managedTypes );
+        }
 } // namespace InitTweak
 

src/InitTweak/InitTweak.cc

@@ -14 +14 @@
                 public:
                         bool hasDesignations = false;
-                        template<typename Init>
-                        void handleInit( Init * init ) {
-                                if ( ! init->get_designators().empty() ) hasDesignations = true;
-                                else Visitor::visit( init );
-                        }
-                        virtual void visit( SingleInit * singleInit ) { handleInit( singleInit); }
-                        virtual void visit( ListInit * listInit ) { handleInit( listInit); }
+                        virtual void visit( Designation * des ) {
+                                if ( ! des->get_designators().empty() ) hasDesignations = true;
+                                else Visitor::visit( des );
+                        }
                 };
 
@@ -92 +89 @@
                 InitImpl( Initializer * init ) : init( init ) {}
 
-                virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
+                virtual std::list< Expression * > next( __attribute((unused)) std::list< Expression * > & indices ) {
                         // this is wrong, but just a placeholder for now
                         // if ( ! flattened ) flatten( indices );
@@ -248 +245 @@
         }
 
-        Statement * ExprImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
+        Statement * ExprImpl::buildListInit( __attribute((unused)) UntypedExpr * dst, __attribute((unused)) std::list< Expression * > & indices ) {
                 return NULL;
         }
@@ -477 +474 @@
                 ConstExprChecker() : isConstExpr( true ) {}
 
-                virtual void visit( ApplicationExpr *applicationExpr ) { isConstExpr = false; }
-                virtual void visit( UntypedExpr *untypedExpr ) { isConstExpr = false; }
+                using Visitor::visit;
+
+                virtual void visit( __attribute((unused)) ApplicationExpr *applicationExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) UntypedExpr *untypedExpr ) { isConstExpr = false; }
                 virtual void visit( NameExpr *nameExpr ) {
                         // xxx - temporary hack, because 0 and 1 really should be constexprs, even though they technically aren't in Cforall today
@@ -489 +488 @@
                         if ( ! dynamic_cast< NameExpr * >( arg) && ! dynamic_cast< VariableExpr * >( arg ) && ! dynamic_cast< MemberExpr * >( arg ) && ! dynamic_cast< UntypedMemberExpr * >( arg ) ) isConstExpr = false;
                 }
-                virtual void visit( LabelAddressExpr *labAddressExpr ) { isConstExpr = false; }
-                virtual void visit( UntypedMemberExpr *memberExpr ) { isConstExpr = false; }
-                virtual void visit( MemberExpr *memberExpr ) { isConstExpr = false; }
-                virtual void visit( VariableExpr *variableExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) LabelAddressExpr *labAddressExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) UntypedMemberExpr *memberExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) MemberExpr *memberExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) VariableExpr *variableExpr ) { isConstExpr = false; }
                 // these might be okay?
                 // virtual void visit( SizeofExpr *sizeofExpr );
@@ -503 +502 @@
                 // virtual void visit( LogicalExpr *logicalExpr );
                 // virtual void visit( ConditionalExpr *conditionalExpr );
-                virtual void visit( TypeExpr *typeExpr ) { isConstExpr = false; }
-                virtual void visit( AsmExpr *asmExpr ) { isConstExpr = false; }
-                virtual void visit( UntypedValofExpr *valofExpr ) { isConstExpr = false; }
-                virtual void visit( CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
-                virtual void visit( UntypedTupleExpr *tupleExpr ) { isConstExpr = false; }
-                virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
-                virtual void visit( TupleAssignExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) TypeExpr *typeExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) AsmExpr *asmExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) UntypedValofExpr *valofExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) UntypedTupleExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) TupleExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( __attribute((unused)) TupleAssignExpr *tupleExpr ) { isConstExpr = false; }
 
                 bool isConstExpr;