Changes in src/InitTweak/FixInit.cc [64ac636:233e4d9]

File:

• src/InitTweak/FixInit.cc (modified) (7 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 : Thu Mar 16 08:08:04 2017
-// Update Count     : 67
+// Last Modified On : Fri Mar 17 09:13:47 2017
+// Update Count     : 71
 //
 
@@ -434 +434 @@
                         env->apply( result );
                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
-                        tmp->get_type()->set_isConst( false );
+                        tmp->get_type()->set_const( false );
 
                         // create and resolve copy constructor
@@ -480 +480 @@
                                 env->apply( result );
                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
-                                ret->get_type()->set_isConst( false );
+                                ret->get_type()->set_const( false );
                                 impCpCtorExpr->get_returnDecls().push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
-                                if ( ! result->get_isLvalue() ) {
+                                if ( ! result->get_lvalue() ) {
                                         // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
                                         destructRet( ret, impCpCtorExpr );
@@ -503 +503 @@
                                 env->apply( result );
                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
-                                ret->get_type()->set_isConst( false );
+                                ret->get_type()->set_const( false );
                                 stmtExpr->get_returnDecls().push_front( ret );
 
@@ -534 +534 @@
                         } else {
                                 // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
-                                unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), Type::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
+                                unqExpr->set_object( new ObjectDecl( toString("_unq", unqExpr->get_id()), Type::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
                                 unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
                         }
@@ -584 +584 @@
 
                                 Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
-                                if ( callExpr->get_result()->get_isLvalue() ) {
+                                if ( callExpr->get_result()->get_lvalue() ) {
                                         // lvalue returning functions are funny. Lvalue.cc inserts a *? in front of any lvalue returning
                                         // non-intrinsic function. Add an AddressExpr to the call to negate the derefence and change the
@@ -764 +764 @@
                                                 }
                                         } else {
-                                                stmtsToAddAfter.push_back( ctor );
+                                                ImplicitCtorDtorStmt * implicit = safe_dynamic_cast< ImplicitCtorDtorStmt * > ( ctor );
+                                                ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->get_callStmt() );
+                                                ApplicationExpr * ctorCall = nullptr;
+                                                if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->get_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();
+                                                } else {
+                                                        stmtsToAddAfter.push_back( ctor );
+                                                        objDecl->set_init( NULL );
+                                                        ctorInit->set_ctor( NULL );
+                                                }
                                         } // if
-                                        objDecl->set_init( NULL );
-                                        ctorInit->set_ctor( NULL );
                                 } else if ( Initializer * init = ctorInit->get_init() ) {
                                         objDecl->set_init( init );