Changes in src/SymTab/Validate.cc [a506df4:5809461]

File:

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

src/SymTab/Validate.cc

@@ -176 +176 @@
         };
 
-        struct EliminateTypedef final : public WithVisitorRef<EliminateTypedef>, public WithGuards {
+        class EliminateTypedef : public Mutator {
+          public:
                 EliminateTypedef() : scopeLevel( 0 ) {}
                 /// Replaces typedefs by forward declarations
                 static void eliminateTypedef( std::list< Declaration * > &translationUnit );
-
-                Type * postmutate( TypeInstType * aggregateUseType );
-                Declaration * postmutate( TypedefDecl * typeDecl );
-                void premutate( TypeDecl * typeDecl );
-                void premutate( FunctionDecl * funcDecl );
-                void premutate( ObjectDecl * objDecl );
-                DeclarationWithType * postmutate( ObjectDecl * objDecl );
-
-                void premutate( CastExpr * castExpr );
-
-                void premutate( CompoundStmt * compoundStmt );
-                CompoundStmt * postmutate( CompoundStmt * compoundStmt );
-
-                void premutate( StructDecl * structDecl );
-                Declaration * postmutate( StructDecl * structDecl );
-                void premutate( UnionDecl * unionDecl );
-                Declaration * postmutate( UnionDecl * unionDecl );
-                void premutate( EnumDecl * enumDecl );
-                Declaration * postmutate( EnumDecl * enumDecl );
-                Declaration * postmutate( TraitDecl * contextDecl );
-
           private:
+                virtual Declaration *mutate( TypedefDecl *typeDecl );
+                virtual TypeDecl *mutate( TypeDecl *typeDecl );
+                virtual DeclarationWithType *mutate( FunctionDecl *funcDecl );
+                virtual DeclarationWithType *mutate( ObjectDecl *objDecl );
+                virtual CompoundStmt *mutate( CompoundStmt *compoundStmt );
+                virtual Type *mutate( TypeInstType *aggregateUseType );
+                virtual Expression *mutate( CastExpr *castExpr );
+
+                virtual Declaration *mutate( StructDecl * structDecl );
+                virtual Declaration *mutate( UnionDecl * unionDecl );
+                virtual Declaration *mutate( EnumDecl * enumDecl );
+                virtual Declaration *mutate( TraitDecl * contextDecl );
+
                 template<typename AggDecl>
                 AggDecl *handleAggregate( AggDecl * aggDecl );
@@ -674 +667 @@
 
         void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
-                PassVisitor<EliminateTypedef> eliminator;
+                EliminateTypedef eliminator;
                 mutateAll( translationUnit, eliminator );
-                if ( eliminator.pass.typedefNames.count( "size_t" ) ) {
+                if ( eliminator.typedefNames.count( "size_t" ) ) {
                         // grab and remember declaration of size_t
-                        SizeType = eliminator.pass.typedefNames["size_t"].first->get_base()->clone();
+                        SizeType = eliminator.typedefNames["size_t"].first->get_base()->clone();
                 } else {
                         // xxx - missing global typedef for size_t - default to long unsigned int, even though that may be wrong
@@ -688 +681 @@
         }
 
-        Type * EliminateTypedef::postmutate( TypeInstType * typeInst ) {
+        Type *EliminateTypedef::mutate( TypeInstType * typeInst ) {
                 // instances of typedef types will come here. If it is an instance
                 // of a typdef type, link the instance to its actual type.
@@ -703 +696 @@
                                 rtt->get_parameters().clear();
                                 cloneAll( typeInst->get_parameters(), rtt->get_parameters() );
-                                mutateAll( rtt->get_parameters(), *visitor );  // recursively fix typedefs on parameters
+                                mutateAll( rtt->get_parameters(), *this );  // recursively fix typedefs on parameters
                         } // if
                         delete typeInst;
@@ -715 +708 @@
         }
 
-        Declaration *EliminateTypedef::postmutate( TypedefDecl * tyDecl ) {
+        Declaration *EliminateTypedef::mutate( TypedefDecl * tyDecl ) {
+                Declaration *ret = Mutator::mutate( tyDecl );
+
                 if ( typedefNames.count( tyDecl->get_name() ) == 1 && typedefNames[ tyDecl->get_name() ].second == scopeLevel ) {
                         // typedef to the same name from the same scope
@@ -746 +741 @@
                         return new EnumDecl( enumDecl->get_name(), noAttributes, tyDecl->get_linkage() );
                 } else {
-                        return tyDecl->clone();
-                } // if
-        }
-
-        void EliminateTypedef::premutate( TypeDecl * typeDecl ) {
+                        return ret->clone();
+                } // if
+        }
+
+        TypeDecl *EliminateTypedef::mutate( TypeDecl * typeDecl ) {
                 TypedefMap::iterator i = typedefNames.find( typeDecl->get_name() );
                 if ( i != typedefNames.end() ) {
@@ -757 +752 @@
 
                 typedeclNames[ typeDecl->get_name() ] = typeDecl;
-        }
-
-        void EliminateTypedef::premutate( FunctionDecl * ) {
-                GuardScope( typedefNames );
-        }
-
-        void EliminateTypedef::premutate( ObjectDecl * ) {
-                GuardScope( typedefNames );
-        }
-
-        DeclarationWithType *EliminateTypedef::postmutate( ObjectDecl * objDecl ) {
-                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( objDecl->get_type() ) ) { // function type?
+                return Mutator::mutate( typeDecl );
+        }
+
+        DeclarationWithType *EliminateTypedef::mutate( FunctionDecl * funcDecl ) {
+                typedefNames.beginScope();
+                DeclarationWithType *ret = Mutator::mutate( funcDecl );
+                typedefNames.endScope();
+                return ret;
+        }
+
+        DeclarationWithType *EliminateTypedef::mutate( ObjectDecl * objDecl ) {
+                typedefNames.beginScope();
+                DeclarationWithType *ret = Mutator::mutate( objDecl );
+                typedefNames.endScope();
+
+                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( ret->get_type() ) ) { // function type?
                         // replace the current object declaration with a function declaration
-                        FunctionDecl * newDecl = new FunctionDecl( objDecl->get_name(), objDecl->get_storageClasses(), objDecl->get_linkage(), funtype, 0, objDecl->get_attributes(), objDecl->get_funcSpec() );
+                        FunctionDecl * newDecl = new FunctionDecl( ret->get_name(), ret->get_storageClasses(), ret->get_linkage(), funtype, 0, objDecl->get_attributes(), ret->get_funcSpec() );
                         objDecl->get_attributes().clear();
                         objDecl->set_type( nullptr );
@@ -776 +775 @@
                         return newDecl;
                 } // if
-                return objDecl;
-        }
-
-        void EliminateTypedef::premutate( CastExpr * ) {
-                GuardScope( typedefNames );
-        }
-
-        void EliminateTypedef::premutate( CompoundStmt * ) {
-                GuardScope( typedefNames );
+                return ret;
+        }
+
+        Expression *EliminateTypedef::mutate( CastExpr * castExpr ) {
+                typedefNames.beginScope();
+                Expression *ret = Mutator::mutate( castExpr );
+                typedefNames.endScope();
+                return ret;
+        }
+
+        CompoundStmt *EliminateTypedef::mutate( CompoundStmt * compoundStmt ) {
+                typedefNames.beginScope();
                 scopeLevel += 1;
-                GuardAction( [this](){ scopeLevel -= 1; } );
-        }
-
-        CompoundStmt *EliminateTypedef::postmutate( CompoundStmt * compoundStmt ) {
+                CompoundStmt *ret = Mutator::mutate( compoundStmt );
+                scopeLevel -= 1;
                 // remove and delete decl stmts
                 filter( compoundStmt->kids, [](Statement * stmt) {
@@ -799 +799 @@
                         return false;
                 }, true);
-                return compoundStmt;
+                typedefNames.endScope();
+                return ret;
         }
 
@@ -826 +827 @@
         }
 
-        void EliminateTypedef::premutate( StructDecl * structDecl ) {
+        Declaration *EliminateTypedef::mutate( StructDecl * structDecl ) {
                 addImplicitTypedef( structDecl );
-        }
-
-
-        Declaration *EliminateTypedef::postmutate( StructDecl * structDecl ) {
+                Mutator::mutate( structDecl );
                 return handleAggregate( structDecl );
         }
 
-        void EliminateTypedef::premutate( UnionDecl * unionDecl ) {
+        Declaration *EliminateTypedef::mutate( UnionDecl * unionDecl ) {
                 addImplicitTypedef( unionDecl );
-        }
-
-        Declaration *EliminateTypedef::postmutate( UnionDecl * unionDecl ) {
+                Mutator::mutate( unionDecl );
                 return handleAggregate( unionDecl );
         }
 
-        void EliminateTypedef::premutate( EnumDecl * enumDecl ) {
+        Declaration *EliminateTypedef::mutate( EnumDecl * enumDecl ) {
                 addImplicitTypedef( enumDecl );
-        }
-
-        Declaration *EliminateTypedef::postmutate( EnumDecl * enumDecl ) {
+                Mutator::mutate( enumDecl );
                 return handleAggregate( enumDecl );
         }
 
-        Declaration *EliminateTypedef::postmutate( TraitDecl * traitDecl ) {
-                return handleAggregate( traitDecl );
+        Declaration *EliminateTypedef::mutate( TraitDecl * contextDecl ) {
+                Mutator::mutate( contextDecl );
+                return handleAggregate( contextDecl );
         }