Changes in src/InitTweak/GenInit.cc [ac74057:e3e16bc]

File:

• src/InitTweak/GenInit.cc (modified) (16 diffs)

src/InitTweak/GenInit.cc

@@ -26 +26 @@
 #include "Common/UniqueName.h"     // for UniqueName
 #include "Common/utility.h"        // for ValueGuard, maybeClone
+#include "GenPoly/DeclMutator.h"   // for DeclMutator
 #include "GenPoly/GenPoly.h"       // for getFunctionType, isPolyType
 #include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::const_iter...
@@ -61 +62 @@
         };
 
-        struct CtorDtor : public WithGuards, public WithShortCircuiting, public WithVisitorRef<CtorDtor>  {
+        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
@@ -74 +75 @@
                 // that need to be constructed or destructed
                 void previsit( StructDecl *aggregateDecl );
-                void previsit( AggregateDecl * ) { visit_children = false; }
-                void previsit( NamedTypeDecl * ) { visit_children = false; }
-                void previsit( FunctionType * ) { visit_children = false; }
+                void previsit( __attribute__((unused)) UnionDecl    * aggregateDecl ) { visit_children = false; }
+                void previsit( __attribute__((unused)) EnumDecl     * aggregateDecl ) { visit_children = false; }
+                void previsit( __attribute__((unused)) TraitDecl    * aggregateDecl ) { visit_children = false; }
+                void previsit( __attribute__((unused)) TypeDecl     * typeDecl )      { visit_children = false; }
+                void previsit( __attribute__((unused)) TypedefDecl  * typeDecl )      { visit_children = false; }
+                void previsit( __attribute__((unused)) FunctionType * funcType )      { visit_children = false; }
 
                 void previsit( CompoundStmt * compoundStmt );
@@ -92 +96 @@
         };
 
-        struct HoistArrayDimension final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards {
+        class HoistArrayDimension final : public GenPoly::DeclMutator {
+          public:
+                typedef GenPoly::DeclMutator Parent;
+
                 /// hoist dimension from array types in object declaration so that it uses a single
                 /// const variable of type size_t, so that side effecting array dimensions are only
@@ -98 +105 @@
                 static void hoistArrayDimension( std::list< Declaration * > & translationUnit );
 
-                void premutate( ObjectDecl * objectDecl );
-                DeclarationWithType * postmutate( ObjectDecl * objectDecl );
-                void premutate( FunctionDecl *functionDecl );
+          private:
+                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
-                void premutate( AggregateDecl * ) { visit_children = false; }
-                void premutate( NamedTypeDecl * ) { visit_children = false; }
-                void premutate( FunctionType * ) { visit_children = false; }
+                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 );
@@ -114 +128 @@
 
         void genInit( std::list< Declaration * > & translationUnit ) {
-                fixReturnStatements( translationUnit );
+                ReturnFixer::makeReturnTemp( translationUnit );
                 HoistArrayDimension::hoistArrayDimension( translationUnit );
                 CtorDtor::generateCtorDtor( translationUnit );
         }
 
-        void fixReturnStatements( std::list< Declaration * > & translationUnit ) {
+        void ReturnFixer::makeReturnTemp( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<ReturnFixer> fixer;
                 mutateAll( translationUnit, fixer );
@@ -129 +143 @@
                 // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address
                 // is being returned
-                if ( returnStmt->get_expr() && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) {
+                if ( returnStmt->get_expr() && returnVals.size() == 1 && ! dynamic_cast< ReferenceType * >( returnVals.front()->get_type() ) ) {
                         // explicitly construct the return value using the return expression and the retVal object
                         assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() );
@@ -144 +158 @@
                 GuardValue( funcName );
 
-                ftype = functionDecl->type;
-                funcName = functionDecl->name;
+                ftype = functionDecl->get_functionType();
+                funcName = functionDecl->get_name();
         }
 
@@ -151 +165 @@
         // which would be incorrect if it is a side-effecting computation.
         void HoistArrayDimension::hoistArrayDimension( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<HoistArrayDimension> hoister;
-                mutateAll( translationUnit, hoister );
-        }
-
-        void HoistArrayDimension::premutate( ObjectDecl * objectDecl ) {
-                GuardValue( storageClasses );
+                HoistArrayDimension hoister;
+                hoister.mutateDeclarationList( translationUnit );
+        }
+
+        DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) {
                 storageClasses = objectDecl->get_storageClasses();
-        }
-
-        DeclarationWithType * HoistArrayDimension::postmutate( ObjectDecl * objectDecl ) {
+                DeclarationWithType * temp = Parent::mutate( objectDecl );
                 hoist( objectDecl->get_type() );
-                return objectDecl;
+                return temp;
         }
 
@@ -183 +194 @@
 
                         arrayType->set_dimension( new VariableExpr( arrayDimension ) );
-                        declsToAddBefore.push_back( arrayDimension );
+                        addDeclaration( arrayDimension );
 
                         hoist( arrayType->get_base() );
@@ -190 +201 @@
         }
 
-        void HoistArrayDimension::premutate( FunctionDecl * ) {
-                GuardValue( inFunction );
+        DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) {
+                ValueGuard< bool > oldInFunc( inFunction );
+                inFunction = true;
+                DeclarationWithType * decl = Parent::mutate( functionDecl );
+                return decl;
         }
 
@@ -200 +214 @@
 
         bool CtorDtor::isManaged( Type * type ) const {
-                // references are never constructed
+                // at least for now, references are never constructed
                 if ( dynamic_cast< ReferenceType * >( type ) ) return false;
                 // need to clear and reset qualifiers when determining if a type is managed
@@ -207 +221 @@
                 if ( TupleType * tupleType = dynamic_cast< TupleType * > ( type ) ) {
                         // tuple is also managed if any of its components are managed
-                        if ( std::any_of( tupleType->types.begin(), tupleType->types.end(), [&](Type * type) { return isManaged( type ); }) ) {
+                        if ( std::any_of( tupleType->get_types().begin(), tupleType->get_types().end(), [&](Type * type) { return isManaged( type ); }) ) {
                                 return true;
                         }
@@ -291 +305 @@
 
         void CtorDtor::previsit( FunctionDecl *functionDecl ) {
-                visit_children = false;  // do not try and construct parameters or forall parameters
                 GuardValue( inFunction );
                 inFunction = true;
@@ -305 +318 @@
                 }
 
-                maybeAccept( functionDecl->get_statements(), *visitor );
+                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
         }
 
@@ -324 +340 @@
         }
 
-        void CtorDtor::previsit( CompoundStmt * ) {
+        void CtorDtor::previsit( __attribute__((unused)) CompoundStmt * compoundStmt ) {
                 GuardScope( managedTypes );
         }