Changeset 5363fdf for src/InitTweak

Timestamp:

Sep 27, 2017, 4:25:28 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:

fa16264

Parents:

1189946

git-author:

Rob Schluntz <rschlunt@…> (09/27/17 16:11:50)

git-committer:

Rob Schluntz <rschlunt@…> (09/27/17 16:25:28)

Message:

Cleanup FixInit? code

File:

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

src/InitTweak/FixInit.cc

@@ -214 +214 @@
                         void emit( CodeLocation, const Params &... params );
 
-                        FunctionDecl * function = 0;
+                        FunctionDecl * function = nullptr;
                         std::set< DeclarationWithType * > unhandled;
                         std::map< DeclarationWithType *, CodeLocation > usedUninit;
-                        ObjectDecl * thisParam = 0;
+                        ObjectDecl * thisParam = nullptr;
                         bool isCtor = false; // true if current function is a constructor
-                        StructDecl * structDecl = 0;
+                        StructDecl * structDecl = nullptr;
                 };
 
@@ -624 +624 @@
                 }
 
-                DeclarationWithType *FixInit::postmutate( ObjectDecl *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() ) ) {
@@ -722 +722 @@
                                         } else {
                                                 ImplicitCtorDtorStmt * implicit = strict_dynamic_cast< ImplicitCtorDtorStmt * > ( ctor );
-                                                ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->get_callStmt() );
+                                                ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->callStmt );
                                                 ApplicationExpr * ctorCall = nullptr;
-                                                if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->get_expr() )) && ctorCall->get_args().size() == 2 ) {
+                                                if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->expr )) && ctorCall->get_args().size() == 2 ) {
                                                         // clean up intrinsic copy constructor calls by making them into SingleInits
-                                                        objDecl->set_init( new SingleInit( ctorCall->get_args().back() ) );
-                                                        ctorCall->get_args().pop_back();
+                                                        objDecl->init = new SingleInit( ctorCall->args.back() );
+                                                        ctorCall->args.pop_back();
                                                 } else {
                                                         stmtsToAddAfter.push_back( ctor );
-                                                        objDecl->set_init( nullptr );
-                                                        ctorInit->set_ctor( nullptr );
+                                                        objDecl->init = nullptr;
+                                                        ctorInit->ctor = nullptr;
                                                 }
                                         } // if
-                                } else if ( Initializer * init = ctorInit->get_init() ) {
-                                        objDecl->set_init( init );
-                                        ctorInit->set_init( nullptr );
+                                } else if ( Initializer * init = ctorInit->init ) {
+                                        objDecl->init = init;
+                                        ctorInit->init = nullptr;
                                 } else {
                                         // no constructor and no initializer, which is okay
-                                        objDecl->set_init( nullptr );
+                                        objDecl->init = nullptr;
                                 } // if
                                 delete ctorInit;
@@ -912 +912 @@
                 }
 
+                void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) {
+                        for ( auto d : decls ) {
+                                indexer.addId( d );
+                        }
+                }
+
+                void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) {
+                        for ( auto td : tds ) {
+                                indexer.addType( td );
+                                addIds( indexer, td->assertions );
+                        }
+                }
+
                 void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) {
-                        GuardValue( funcDecl );
+                        GuardValue( function );
                         GuardValue( unhandled );
                         GuardValue( usedUninit );
@@ -946 +959 @@
                 }
 
-                void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) {
-                        for ( auto d : decls ) {
-                                indexer.addId( d );
-                        }
-                }
-
-                void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) {
-                        for ( auto td : tds ) {
-                                indexer.addType( td );
-                                addIds( indexer, td->assertions );
-                        }
-                }
-
                 void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) {
                         // remove the unhandled objects from usedUninit, because a call is inserted