Changeset a506df4

Timestamp:

Sep 12, 2017, 5:49:32 PM (6 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:

b3c7963

Parents:

70d826cd

Message:

Convert EliminateTypedef? to PassVisitor?

File:

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

src/SymTab/Validate.cc

@@ -176 +176 @@
         };
 
-        class EliminateTypedef : public Mutator {
-          public:
+        struct EliminateTypedef final : public WithVisitorRef<EliminateTypedef>, public WithGuards {
                 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 );
@@ -667 +674 @@
 
         void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
-                EliminateTypedef eliminator;
+                PassVisitor<EliminateTypedef> eliminator;
                 mutateAll( translationUnit, eliminator );
-                if ( eliminator.typedefNames.count( "size_t" ) ) {
+                if ( eliminator.pass.typedefNames.count( "size_t" ) ) {
                         // grab and remember declaration of size_t
-                        SizeType = eliminator.typedefNames["size_t"].first->get_base()->clone();
+                        SizeType = eliminator.pass.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
@@ -681 +688 @@
         }
 
-        Type *EliminateTypedef::mutate( TypeInstType * typeInst ) {
+        Type * EliminateTypedef::postmutate( 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.
@@ -696 +703 @@
                                 rtt->get_parameters().clear();
                                 cloneAll( typeInst->get_parameters(), rtt->get_parameters() );
-                                mutateAll( rtt->get_parameters(), *this );  // recursively fix typedefs on parameters
+                                mutateAll( rtt->get_parameters(), *visitor );  // recursively fix typedefs on parameters
                         } // if
                         delete typeInst;
@@ -708 +715 @@
         }
 
-        Declaration *EliminateTypedef::mutate( TypedefDecl * tyDecl ) {
-                Declaration *ret = Mutator::mutate( tyDecl );
-
+        Declaration *EliminateTypedef::postmutate( TypedefDecl * tyDecl ) {
                 if ( typedefNames.count( tyDecl->get_name() ) == 1 && typedefNames[ tyDecl->get_name() ].second == scopeLevel ) {
                         // typedef to the same name from the same scope
@@ -741 +746 @@
                         return new EnumDecl( enumDecl->get_name(), noAttributes, tyDecl->get_linkage() );
                 } else {
-                        return ret->clone();
-                } // if
-        }
-
-        TypeDecl *EliminateTypedef::mutate( TypeDecl * typeDecl ) {
+                        return tyDecl->clone();
+                } // if
+        }
+
+        void EliminateTypedef::premutate( TypeDecl * typeDecl ) {
                 TypedefMap::iterator i = typedefNames.find( typeDecl->get_name() );
                 if ( i != typedefNames.end() ) {
@@ -752 +757 @@
 
                 typedeclNames[ typeDecl->get_name() ] = typeDecl;
-                return dynamic_cast<TypeDecl *>( 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?
+        }
+
+        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?
                         // replace the current object declaration with a function declaration
-                        FunctionDecl * newDecl = new FunctionDecl( ret->get_name(), ret->get_storageClasses(), ret->get_linkage(), funtype, 0, objDecl->get_attributes(), ret->get_funcSpec() );
+                        FunctionDecl * newDecl = new FunctionDecl( objDecl->get_name(), objDecl->get_storageClasses(), objDecl->get_linkage(), funtype, 0, objDecl->get_attributes(), objDecl->get_funcSpec() );
                         objDecl->get_attributes().clear();
                         objDecl->set_type( nullptr );
@@ -775 +776 @@
                         return newDecl;
                 } // if
-                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();
+                return objDecl;
+        }
+
+        void EliminateTypedef::premutate( CastExpr * ) {
+                GuardScope( typedefNames );
+        }
+
+        void EliminateTypedef::premutate( CompoundStmt * ) {
+                GuardScope( typedefNames );
                 scopeLevel += 1;
-                CompoundStmt *ret = Mutator::mutate( compoundStmt );
-                scopeLevel -= 1;
+                GuardAction( [this](){ scopeLevel -= 1; } );
+        }
+
+        CompoundStmt *EliminateTypedef::postmutate( CompoundStmt * compoundStmt ) {
                 // remove and delete decl stmts
                 filter( compoundStmt->kids, [](Statement * stmt) {
@@ -799 +799 @@
                         return false;
                 }, true);
-                typedefNames.endScope();
-                return ret;
+                return compoundStmt;
         }
 
@@ -827 +826 @@
         }
 
-        Declaration *EliminateTypedef::mutate( StructDecl * structDecl ) {
+        void EliminateTypedef::premutate( StructDecl * structDecl ) {
                 addImplicitTypedef( structDecl );
-                Mutator::mutate( structDecl );
+        }
+
+
+        Declaration *EliminateTypedef::postmutate( StructDecl * structDecl ) {
                 return handleAggregate( structDecl );
         }
 
-        Declaration *EliminateTypedef::mutate( UnionDecl * unionDecl ) {
+        void EliminateTypedef::premutate( UnionDecl * unionDecl ) {
                 addImplicitTypedef( unionDecl );
-                Mutator::mutate( unionDecl );
+        }
+
+        Declaration *EliminateTypedef::postmutate( UnionDecl * unionDecl ) {
                 return handleAggregate( unionDecl );
         }
 
-        Declaration *EliminateTypedef::mutate( EnumDecl * enumDecl ) {
+        void EliminateTypedef::premutate( EnumDecl * enumDecl ) {
                 addImplicitTypedef( enumDecl );
-                Mutator::mutate( enumDecl );
+        }
+
+        Declaration *EliminateTypedef::postmutate( EnumDecl * enumDecl ) {
                 return handleAggregate( enumDecl );
         }
 
-        Declaration *EliminateTypedef::mutate( TraitDecl * contextDecl ) {
-                Mutator::mutate( contextDecl );
-                return handleAggregate( contextDecl );
+        Declaration *EliminateTypedef::postmutate( TraitDecl * traitDecl ) {
+                return handleAggregate( traitDecl );
         }