Changeset ea156ae for src/InitTweak

Timestamp:

Sep 27, 2017, 5:31:02 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

549c006

Parents:

12914e9 (diff), fa16264 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/InitTweak

Files:

• FixInit.cc (modified) (5 diffs)
• InitTweak.cc (modified) (1 diff)
• InitTweak.h (modified) (1 diff)

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

src/InitTweak/InitTweak.cc

@@ -270 +270 @@
         }
 
+        Type * getThisType( FunctionType * ftype ) {
+                assertf( ftype, "getThisType: nullptr ftype" );
+                ObjectDecl * thisParam = getThisParam( ftype );
+                ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( thisParam->type );
+                return refType->base;
+        }
+
+        ObjectDecl * getThisParam( FunctionType * ftype ) {
+                assertf( ftype, "getThisParam: nullptr ftype" );
+                auto & params = ftype->parameters;
+                assertf( ! params.empty(), "getThisParam: ftype with 0 parameters: %s", toString( ftype ).c_str() );
+                return strict_dynamic_cast< ObjectDecl * >( params.front() );
+        }
+
         bool tryConstruct( DeclarationWithType * dwt ) {
                 ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt );

src/InitTweak/InitTweak.h

@@ -29 +29 @@
         FunctionDecl * isCopyConstructor( Declaration * decl );
         FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname );
+
+        /// returns the base type of the first parameter to a constructor/destructor/assignment function
+        Type * getThisType( FunctionType * ftype );
+
+        /// returns the first parameter of a constructor/destructor/assignment function
+        ObjectDecl * getThisParam( FunctionType * ftype );
 
         /// transform Initializer into an argument list that can be passed to a call expression