Changeset d24d4e1

Timestamp:

Jun 23, 2017, 12:12:46 PM (7 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:

2a7b3ca

Parents:

ba915fb5

Message:

convert more passes to PassVisitor?, fix PassVisitor? constructor bug, add WithDeclsToAdd? parent class

Location:

src

Files:

• Common/PassVisitor.h (modified) (7 diffs)
• Common/PassVisitor.impl.h (modified) (4 diffs)
• InitTweak/GenInit.cc (modified) (8 diffs)
• SymTab/Validate.cc (modified) (9 diffs)

src/Common/PassVisitor.h

@@ -26 +26 @@
 //                          stmtsToAddBefore or stmtsToAddAfter respectively.
 // | WithShortCircuiting  - provides the ability to skip visiting child nodes; set visit_children to false in pre{visit,mutate} to skip visiting children
-// | WithScopes           - provides the ability to save/restore data like a LIFO stack; to save, call GuardValue with the variable to save, the variable
+// | WithGuards           - provides the ability to save/restore data like a LIFO stack; to save, call GuardValue with the variable to save, the variable
 //                          will automatically be restored to its previous value after the corresponding postvisit/postmutate teminates.
 //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -32 +32 @@
 class PassVisitor final : public Visitor, public Mutator {
 public:
-        PassVisitor() = default;
 
         template< typename... Args >
@@ -283 +282 @@
 
 public:
-        TypeSubstitution * env;
+        TypeSubstitution * env = nullptr;
 };
 
@@ -295 +294 @@
         std::list< Statement* > stmtsToAddAfter;
 };
+
+class WithDeclsToAdd {
+protected:
+        WithDeclsToAdd() = default;
+        ~WithDeclsToAdd() = default;
+
+public:
+        std::list< Declaration* > declsToAddBefore;
+        std::list< Declaration* > declsToAddAfter;
+};
+
 class WithShortCircuiting {
 protected:
@@ -304 +314 @@
 };
 
-class WithScopes {
-protected:
-        WithScopes() = default;
-        ~WithScopes() = default;
+class WithGuards {
+protected:
+        WithGuards() = default;
+        ~WithGuards() = default;
 
 public:
@@ -319 +329 @@
         }
 
+        template< typename T >
+        void GuardScope( T& val ) {
+                val.beginScope();
+                at_cleanup( []( void * val ) {
+                        static_cast< T * >( val )->endScope();
+                }, static_cast< void * >( & val ) );
+        }
+
         template< typename Func >
-        void GuardAction( Func&& func ) {
-                at_cleanup( std::forward<Func>( func ) );
+        void GuardAction( Func func ) {
+                at_cleanup( [func](__attribute__((unused)) void *) { func(); }, nullptr );
         }
 };
@@ -328 +346 @@
 class WithVisitorRef {
 protected:
-        WithVisitorRef() = default;
-        ~WithVisitorRef() = default;
-
-public:
-        PassVisitor<pass_type> * const visitor;
+        WithVisitorRef() {}
+        ~WithVisitorRef() {}
+
+public:
+        PassVisitor<pass_type> * const visitor = nullptr;
 };
 

src/Common/PassVisitor.impl.h

@@ -68 +68 @@
         for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
                 // splice in new declarations after previous decl
-                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); } 
+                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
 
                 if ( i == decls.end() ) break;
@@ -88 +88 @@
         for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
                 // splice in new declarations after previous decl
-                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); } 
+                if ( !empty( afterDecls ) ) { decls.splice( i, *afterDecls ); }
 
                 if ( i == decls.end() ) break;
@@ -181 +181 @@
 Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
         return handleStatement( stmt, [this]( Statement * stmt ) {
-                maybeAccept( stmt, *this ); 
+                maybeAccept( stmt, *this );
                 return stmt;
         });
@@ -212 +212 @@
                 expr->accept( *this );
                 return expr;
-        });             
+        });
 }
 

src/InitTweak/GenInit.cc

@@ -44 +44 @@
         }
 
-        class ReturnFixer : public WithStmtsToAdd, public WithScopes {
-          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
@@ -59 +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
@@ -69 +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:
@@ -211 +208 @@
 
         void CtorDtor::generateCtorDtor( std::list< Declaration * > & translationUnit ) {
-                CtorDtor ctordtor;
-                mutateAll( translationUnit, ctordtor );
+                PassVisitor<CtorDtor> ctordtor;
+                acceptAll( translationUnit, ctordtor );
         }
 
@@ -289 +286 @@
         }
 
-        DeclarationWithType * CtorDtor::mutate( ObjectDecl * objDecl ) {
+        void CtorDtor::previsit( ObjectDecl * objDecl ) {
                 handleDWT( objDecl );
                 // hands off if @=, extern, builtin, etc.
@@ -301 +298 @@
                         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() ) {
@@ -317 +313 @@
                         }
                 }
-                // 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
@@ -336 +334 @@
                         }
                 }
-                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/SymTab/Validate.cc

@@ -106 +106 @@
 
         /// Fix return types so that every function returns exactly one value
-        class ReturnTypeFixer {
-          public:
+        struct ReturnTypeFixer {
                 static void fix( std::list< Declaration * > &translationUnit );
 
@@ -115 +114 @@
 
         /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers.
-        class EnumAndPointerDecay {
-        public:
+        struct EnumAndPointerDecay {
                 void previsit( EnumDecl *aggregateDecl );
                 void previsit( FunctionType *func );
@@ -159 +157 @@
         };
 
-        class ReturnChecker : public WithScopes {
-          public:
+        struct ReturnChecker : public WithGuards {
                 /// Checks that return statements return nothing if their return type is void
                 /// and return something if the return type is non-void.
                 static void checkFunctionReturns( std::list< Declaration * > & translationUnit );
-          private:
+
                 void previsit( FunctionDecl * functionDecl );
                 void previsit( ReturnStmt * returnStmt );
@@ -205 +202 @@
         };
 
-        class VerifyCtorDtorAssign {
-        public:
+        struct VerifyCtorDtorAssign {
                 /// ensure that constructors, destructors, and assignment have at least one
                 /// parameter, the first of which must be a pointer, and that ctor/dtors have no
@@ -216 +212 @@
 
         /// ensure that generic types have the correct number of type arguments
-        class ValidateGenericParameters {
-        public:
+        struct ValidateGenericParameters {
                 void previsit( StructInstType * inst );
                 void previsit( UnionInstType * inst );
         };
 
-        class ArrayLength {
-        public:
+        struct ArrayLength {
                 /// for array types without an explicit length, compute the length and store it so that it
                 /// is known to the rest of the phases. For example,
@@ -236 +230 @@
         };
 
-        class CompoundLiteral final : public GenPoly::DeclMutator {
+        struct CompoundLiteral final : public WithDeclsToAdd, public WithVisitorRef<CompoundLiteral> {
                 Type::StorageClasses storageClasses;
 
-                using GenPoly::DeclMutator::mutate;
-                DeclarationWithType * mutate( ObjectDecl *objectDecl ) final;
-                Expression *mutate( CompoundLiteralExpr *compLitExpr ) final;
+                void premutate( ObjectDecl *objectDecl );
+                Expression * postmutate( CompoundLiteralExpr *compLitExpr );
         };
 
@@ -248 +241 @@
                 LinkReferenceToTypes lrt( doDebug, 0 );
                 ForallPointerDecay fpd( 0 );
-                CompoundLiteral compoundliteral;
+                PassVisitor<CompoundLiteral> compoundliteral;
                 PassVisitor<ValidateGenericParameters> genericParams;
 
@@ -263 +256 @@
                 Concurrency::implementThreadStarter( translationUnit );
                 ReturnChecker::checkFunctionReturns( translationUnit );
-                compoundliteral.mutateDeclarationList( translationUnit );
+                mutateAll( translationUnit, compoundliteral );
                 acceptAll( translationUnit, fpd );
                 ArrayLength::computeLength( translationUnit );
@@ -883 +876 @@
         }
 
-        DeclarationWithType * CompoundLiteral::mutate( ObjectDecl *objectDecl ) {
+        void CompoundLiteral::premutate( ObjectDecl *objectDecl ) {
                 storageClasses = objectDecl->get_storageClasses();
-                DeclarationWithType * temp = Mutator::mutate( objectDecl );
-                return temp;
-        }
-
-        Expression *CompoundLiteral::mutate( CompoundLiteralExpr *compLitExpr ) {
+        }
+
+        Expression *CompoundLiteral::postmutate( CompoundLiteralExpr *compLitExpr ) {
                 // transform [storage_class] ... (struct S){ 3, ... };
                 // into [storage_class] struct S temp =  { 3, ... };
                 static UniqueName indexName( "_compLit" );
 
-                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, 0, compLitExpr->get_result(), compLitExpr->get_initializer() );
-                compLitExpr->set_result( 0 );
-                compLitExpr->set_initializer( 0 );
+                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, nullptr, compLitExpr->get_result(), compLitExpr->get_initializer() );
+                compLitExpr->set_result( nullptr );
+                compLitExpr->set_initializer( nullptr );
                 delete compLitExpr;
-                DeclarationWithType * newtempvar = mutate( tempvar );
-                addDeclaration( newtempvar );                                   // add modified temporary to current block
-                return new VariableExpr( newtempvar );
+                declsToAddBefore.push_back( tempvar );                                  // add modified temporary to current block
+                return new VariableExpr( tempvar );
         }