Changes in src/InitTweak/FixInit.cc [ce8c12f:62423350]

File:

• src/InitTweak/FixInit.cc (modified) (21 diffs)

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 );
                 }
 
                 bool ResolveCopyCtors::skipCopyConstruct( Type * type ) {
-                        return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
+                        return dynamic_cast< VarArgsType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
                 }
 
@@ -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 ) );