[clang-tidy] A follow-up fix of braced-init-list constructors in make-unique check.

[alexfh]

clang-tidy/modernize/MakeSmartPtrCheck.cpp

279 ↗

(On Diff #112378)

I wonder whether this exception can be too broad, e.g. if the initializer list is a part of a more deeply nested expression inside the CXXConstructExpr?

[hokein]

restrict to implicit conversion from std::initializer_list.

[hokein]

clang-tidy/modernize/MakeSmartPtrCheck.cpp

279 ↗

(On Diff #112378)

Done. I overthought the cases here. The case we need to ignore is the implicit conversion from std::initailizer_list.

[alexfh]

LG. Thanks!

clang-tools-extra/trunk/clang-tidy/modernize/MakeSmartPtrCheck.cpp

if (ArraySizeExpr.empty()) {
       // New array expression without written initializer:
       //   smart_ptr<Foo[]>(new Foo[5]);
       Diag << FixItHint::CreateReplacement(SourceRange(NewStart, NewEnd),
                                            ArraySizeExpr);
     }
     break;
   }
   case CXXNewExpr::CallInit: {
-    // FIXME: Add fixes for constructors with initializer-list parameters.
+    // FIXME: Add fixes for constructors with parameters that can be created
+    // with a C++11 braced-init-list (e.g. std::vector, std::map).
     // Unlike ordinal cases, braced list can not be deduced in
     // std::make_smart_ptr, we need to specify the type explicitly in the fixes:
     //   struct S { S(std::initializer_list<int>, int); };
+    //   struct S2 { S2(std::vector<int>); };
     //   smart_ptr<S>(new S({1, 2, 3}, 1));  // C++98 call-style initialization
     //   smart_ptr<S>(new S({}, 1));
+    //   smart_ptr<S2>(new S2({1})); // implicit conversion:
+    //                               //   std::initializer_list => std::vector
     // The above samples have to be replaced with:
     //   std::make_smart_ptr<S>(std::initializer_list<int>({1, 2, 3}), 1);
     //   std::make_smart_ptr<S>(std::initializer_list<int>({}), 1);
+    //   std::make_smart_ptr<S2>(std::vector<int>({1}));
     if (const auto *CE = New->getConstructExpr()) {
       for (const auto *Arg : CE->arguments()) {
-        if (llvm::isa<CXXStdInitializerListExpr>(Arg)) {
+        if (isa<CXXStdInitializerListExpr>(Arg)) {
           return false;
         }
+        // Check the implicit conversion from the std::initializer_list type to
+        // a class type.
+        if (const auto *ImplicitCE = dyn_cast<CXXConstructExpr>(Arg)) {
+          if (ImplicitCE->isStdInitListInitialization()) {
+            return false;
+          }
+        }
       }
     }
     if (ArraySizeExpr.empty()) {
       SourceRange InitRange = New->getDirectInitRange();
       Diag << FixItHint::CreateRemoval(
           SourceRange(NewStart, InitRange.getBegin()));
       Diag << FixItHint::CreateRemoval(SourceRange(InitRange.getEnd(), NewEnd));
     }

clang-tools-extra/trunk/test/clang-tidy/Inputs/modernize-smart-ptr/initializer_list.h

public:
   typedef const _E *const_iterator;
 
   initializer_list() : __begin_(nullptr), __size_(0) {}
 
   size_t size() const { return __size_; }
   const _E *begin() const { return __begin_; }
   const _E *end() const { return __begin_ + __size_; }
 };
+
+template <class _E>
+class vector {
+ public:
+  vector(initializer_list<_E> init);
+};
 } // namespace std

clang-tools-extra/trunk/test/clang-tidy/modernize-make-unique.cpp

struct F {
   int a;
 };
 
 struct G {
   G(std::initializer_list<int>);
   G(int);
 };
 
+struct H {
+  H(std::vector<int>);
+};
+
+struct I {
+  I(G);
+};
+
 namespace {
 class Foo {};
 } // namespace
 
 namespace bar {
 class Bar {};
 } // namespace bar
 
void initialization(int T, Base b) {
   // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: use std::make_unique instead
   // CHECK-FIXES: std::unique_ptr<G> PG2 = std::unique_ptr<G>(new G{1});
 
   // Initialization with the initializer-list constructor.
   std::unique_ptr<G> PG3 = std::unique_ptr<G>(new G{1, 2});
   // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: use std::make_unique instead
   // CHECK-FIXES: std::unique_ptr<G> PG3 = std::unique_ptr<G>(new G{1, 2});
 
+  std::unique_ptr<H> PH1 = std::unique_ptr<H>(new H({1, 2, 3}));
+  // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: use std::make_unique instead
+  // CHECK-FIXES: std::unique_ptr<H> PH1 = std::unique_ptr<H>(new H({1, 2, 3}));
+  PH1.reset(new H({1, 2, 3}));
+  // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: use std::make_unique instead
+  // CHECK-FIXES: PH1.reset(new H({1, 2, 3}));
+
+  std::unique_ptr<I> PI1 = std::unique_ptr<I>(new I(G({1, 2, 3})));
+  // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: use std::make_unique instead
+  // CHECK-FIXES: std::unique_ptr<I> PI1 = std::make_unique<I>(G({1, 2, 3}));
+  PI1.reset(new I(G({1, 2, 3})));
+  // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: use std::make_unique instead
+  // CHECK-FIXES: PI1 = std::make_unique<I>(G({1, 2, 3}));
+
   std::unique_ptr<Foo> FF = std::unique_ptr<Foo>(new Foo());
   // CHECK-MESSAGES: :[[@LINE-1]]:29: warning:
   // CHECK-FIXES: std::unique_ptr<Foo> FF = std::make_unique<Foo>();
   FF.reset(new Foo());
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning:
   // CHECK-FIXES: FF = std::make_unique<Foo>();
 
   std::unique_ptr<bar::Bar> BB = std::unique_ptr<bar::Bar>(new bar::Bar());