[clang-tidy] Add new check 'shared-ptr-array-mismatch'.

[Eugene.Zelenko]

I think this check belongs to bugprone module. How about std::unique_ptr?

clang-tools-extra/clang-tidy/misc/SharedPtrArrayMismatchCheck.cpp

1 ↗

(On Diff #399970)

Please make it same length and single line as closing comment.

clang-tools-extra/docs/clang-tidy/checks/misc-shared-ptr-array-mismatch.rst

6 ↗

(On Diff #399970)

Please make first statement same as in Release Notes.

[njames93]

How does this check play with the modernize-make-shared check?

[LegalizeAdulthood]

clang-tools-extra/clang-tidy/misc/SharedPtrArrayMismatchCheck.cpp

21–26 ↗

(On Diff #399970)

If you're not doing anything different in the c'tor I think you can
eliminate this definition and just lift the visibility of the base class
c'tor in the class declaration:

using ClangTidyCheck::ClangTidyCheck;

39 ↗

(On Diff #399970)

What about the other constructor overloads?
Creating a shared_ptr with a deleter is quite common.

104 ↗

(On Diff #399970)

I'm not sure what this is doing?

106 ↗

(On Diff #399970)

Is this to guard against multiple variables being declared at once?

[LegalizeAdulthood]

In D117306#3245915, @njames93 wrote:

How does this check play with the modernize-make-shared check?

Wouldn't it be orthogonal?

This check looks for existing make_shared usages, whereas
modernize-make-shared adds new make_shared usages from
new shared_ptr usages. I wouldn't expect modernize-make-shared
to generate mismatched scalar/array shared_ptr instances.

[balazske]

I am not sure if it is correct to have replacement (fixit) for a part of the cases only. It is not possible to make a fixit for every use. In a case like shared_ptr<int> p1{new int}, p2{new int[10]}; the type can not be changed without other changes. For this reason the replacement is offered only for single-variable declarations.

[balazske]

Is there a fast way to find single-variable field declaration?

class A {
  shared_ptr<int> F1{new int}, F2{new int[10]};
};

The FieldDecl does not contain information like DeclStmt::isSingleDecl. The only way looks like to check the source locations.

[njames93]

In D117306#3247417, @LegalizeAdulthood wrote:

In D117306#3245915, @njames93 wrote:

How does this check play with the modernize-make-shared check?

Wouldn't it be orthogonal?

This check looks for existing make_shared usages, whereas
modernize-make-shared adds new make_shared usages from
new shared_ptr usages. I wouldn't expect modernize-make-shared
to generate mismatched scalar/array shared_ptr instances.

This check looks for constructions of shared_ptr types from an array new expression. modernize-make-shared looks for constructions of shared_ptr types using the new expression, However I'm not sure how it handles the array version.

[balazske]

In D117306#3247859, @njames93 wrote:

In D117306#3247417, @LegalizeAdulthood wrote:

In D117306#3245915, @njames93 wrote:

How does this check play with the modernize-make-shared check?

Wouldn't it be orthogonal?

This check looks for existing make_shared usages, whereas
modernize-make-shared adds new make_shared usages from
new shared_ptr usages. I wouldn't expect modernize-make-shared
to generate mismatched scalar/array shared_ptr instances.

This check looks for constructions of shared_ptr types from an array new expression. modernize-make-shared looks for constructions of shared_ptr types using the new expression, However I'm not sure how it handles the array version.

I found out that make_shared can not handle array at all (until C++20, but I do not plan to handle such new features). modernize-make-shared should not transform into make_shared if an array is created (if it works correct) but I do not see test cases for this.

clang-tools-extra/clang-tidy/misc/SharedPtrArrayMismatchCheck.cpp

39 ↗

(On Diff #399970)

The intent is to find cases where no deleter is specified. If a deleter is used we can not tell in reliable way if it is correct for an array. The check assumes that a deleter is correct and needs no check.

104 ↗

(On Diff #399970)

I think that this adds the additional range to the bug report. It is shown in the output (but I did not find a way how to check it in the test).

106 ↗

(On Diff #399970)

Yes, this is to check for "single variable declaration". But works only for variables (not fields).

[LegalizeAdulthood]

LGTM, but there are still some outstanding review comments.

[balazske]

• Moved to bugprone module.
• Introduced a common base class, it is possible to add similar check for unique_ptr.
• Documentation changes.

[balazske]

Possible improvement: Add the check for reset too.

clang-tools-extra/test/clang-tidy/checkers/modernize-make-shared.cpp

48 ↗

(On Diff #400791)

This change was not intentional (should be removed).

[steakhal]

clang-tools-extra/docs/clang-tidy/checks/bugprone-shared-ptr-array-mismatch.rst

23

typo

[balazske]

Fixed small issues.

[LegalizeAdulthood]

clang-tools-extra/clang-tidy/bugprone/SmartPtrArrayMismatchCheck.h

41

There's only one implementation of this abstract method declared here.

Why the extra level in the class hierarchy if there's only one implementation?

[njames93]

clang-tools-extra/clang-tidy/bugprone/SmartPtrArrayMismatchCheck.cpp

42–48

clang-tools-extra/clang-tidy/bugprone/SmartPtrArrayMismatchCheck.h

41

The idea I think is so that this can be used to make a similar check for unique_ptr. However I almost don't see the need for this, and I'd argue that they should both be implemented in one check. So this will detect

std::shared_ptr<int> X = new int[5];
std::unique_ptr<int> Y = new int[5];

[balazske]

clang-tools-extra/clang-tidy/bugprone/SmartPtrArrayMismatchCheck.h

41

If I remember correctly the idea was to make the possible check for unique_ptr. Putting it into a separate check allows to independently turn the checks for shared or unique pointer on or off (like MakeSmartPtrCheck).

[balazske]

Code simplification.

[LegalizeAdulthood]

LGTM

clang-tools-extra/clang-tidy/bugprone/BugproneTidyModule.cpp

 #include "MoveForwardingReferenceCheck.h"
 #include "MultipleStatementMacroCheck.h"
 #include "NoEscapeCheck.h"
 #include "NotNullTerminatedResultCheck.h"
 #include "ParentVirtualCallCheck.h"
 #include "PosixReturnCheck.h"
 #include "RedundantBranchConditionCheck.h"
 #include "ReservedIdentifierCheck.h"
+#include "SharedPtrArrayMismatchCheck.h"
 #include "SignalHandlerCheck.h"
 #include "SignedCharMisuseCheck.h"
 #include "SizeofContainerCheck.h"
 #include "SizeofExpressionCheck.h"
 #include "SpuriouslyWakeUpFunctionsCheck.h"
 #include "StringConstructorCheck.h"
 #include "StringIntegerAssignmentCheck.h"
 #include "StringLiteralWithEmbeddedNulCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<NotNullTerminatedResultCheck>(
         "bugprone-not-null-terminated-result");
     CheckFactories.registerCheck<ParentVirtualCallCheck>(
         "bugprone-parent-virtual-call");
     CheckFactories.registerCheck<PosixReturnCheck>(
         "bugprone-posix-return");
     CheckFactories.registerCheck<ReservedIdentifierCheck>(
         "bugprone-reserved-identifier");
+    CheckFactories.registerCheck<SharedPtrArrayMismatchCheck>(
+        "bugprone-shared-ptr-array-mismatch");
     CheckFactories.registerCheck<SignalHandlerCheck>("bugprone-signal-handler");
     CheckFactories.registerCheck<SignedCharMisuseCheck>(
         "bugprone-signed-char-misuse");
     CheckFactories.registerCheck<SizeofContainerCheck>(
         "bugprone-sizeof-container");
     CheckFactories.registerCheck<SizeofExpressionCheck>(
         "bugprone-sizeof-expression");
     CheckFactories.registerCheck<SpuriouslyWakeUpFunctionsCheck>(

clang-tools-extra/clang-tidy/bugprone/CMakeLists.txt

add_clang_library(clangTidyBugproneModule
   MoveForwardingReferenceCheck.cpp
   MultipleStatementMacroCheck.cpp
   NoEscapeCheck.cpp
   NotNullTerminatedResultCheck.cpp
   ParentVirtualCallCheck.cpp
   PosixReturnCheck.cpp
   RedundantBranchConditionCheck.cpp
   ReservedIdentifierCheck.cpp
+  SharedPtrArrayMismatchCheck.cpp
+  SmartPtrArrayMismatchCheck.cpp
   SignalHandlerCheck.cpp
   SignedCharMisuseCheck.cpp
   SizeofContainerCheck.cpp
   SizeofExpressionCheck.cpp
   SpuriouslyWakeUpFunctionsCheck.cpp
   StringConstructorCheck.cpp
   StringIntegerAssignmentCheck.cpp
   StringLiteralWithEmbeddedNulCheck.cpp

clang-tools-extra/clang-tidy/bugprone/SharedPtrArrayMismatchCheck.h

+//===--- SharedPtrArrayMismatchCheck.h - clang-tidy -------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SHAREDPTRARRAYMISMATCHCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SHAREDPTRARRAYMISMATCHCHECK_H
+
+#include "SmartPtrArrayMismatchCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+/// Find `std::shared_ptr<T>(new T[...])`, replace it (if applicable) with
+/// `std::shared_ptr<T[]>(new T[...])`.
+///
+/// Example:
+///
+/// \code
+///   std::shared_ptr<int> PtrArr{new int[10]};
+/// \endcode
+class SharedPtrArrayMismatchCheck : public SmartPtrArrayMismatchCheck {
+public:
+  SharedPtrArrayMismatchCheck(StringRef Name, ClangTidyContext *Context);
+
+protected:
+  virtual SmartPtrClassMatcher getSmartPointerClassMatcher() const;
+};
+
+} // namespace bugprone
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SHAREDPTRARRAYMISMATCHCHECK_H

clang-tools-extra/clang-tidy/bugprone/SharedPtrArrayMismatchCheck.cpp

+//===--- SharedPtrArrayMismatchCheck.cpp - clang-tidy ---------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "SharedPtrArrayMismatchCheck.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+SharedPtrArrayMismatchCheck::SharedPtrArrayMismatchCheck(
+    StringRef Name, ClangTidyContext *Context)
+    : SmartPtrArrayMismatchCheck(Name, Context, "shared") {}
+
+SharedPtrArrayMismatchCheck::SmartPtrClassMatcher
+SharedPtrArrayMismatchCheck::getSmartPointerClassMatcher() const {
+  return classTemplateSpecializationDecl(
+      hasName("::std::shared_ptr"), templateArgumentCountIs(1),
+      hasTemplateArgument(
+          0, templateArgument(refersToType(qualType().bind(PointerTypeN)))));
+}
+
+} // namespace bugprone
+} // namespace tidy
+} // namespace clang

clang-tools-extra/clang-tidy/bugprone/SmartPtrArrayMismatchCheck.h

+//===--- SharedPtrArrayMismatchCheck.h - clang-tidy -------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SMARTPTRARRAYMISMATCHCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SMARTPTRARRAYMISMATCHCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+/// Find constructions of smart (unique or shared) pointers where the pointer
+/// is declared with non-array target type and an array (created with a
+/// new-expression) is passed to it.
+class SmartPtrArrayMismatchCheck : public ClangTidyCheck {
+public:
+  SmartPtrArrayMismatchCheck(StringRef Name, ClangTidyContext *Context,
+                             StringRef SmartPointerName);
+
+  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
+    return LangOpts.CPlusPlus11;
+  }
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
+protected:
+  using SmartPtrClassMatcher = ast_matchers::internal::BindableMatcher<Decl>;
+
+  /// Returns matcher that match with different smart pointer classes.
+  ///
+  /// Requires to bind pointer type (qualType) with PointerTypeN string declared
+  /// in this class.
+  virtual SmartPtrClassMatcher getSmartPointerClassMatcher() const = 0;
+
+  static const char PointerTypeN[];
+
+private:
+  StringRef const SmartPointerName;
+};
+
+} // namespace bugprone
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SMARTPTRARRAYMISMATCHCHECK_H

clang-tools-extra/clang-tidy/bugprone/SmartPtrArrayMismatchCheck.cpp

+//===--- SmartPtrArrayMismatchCheck.cpp - clang-tidy ----------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "SmartPtrArrayMismatchCheck.h"
+#include "../utils/ASTUtils.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+namespace {
+
+constexpr char ConstructExprN[] = "found_construct_expr";
+constexpr char NewExprN[] = "found_new_expr";
+constexpr char ConstructorN[] = "found_constructor";
+
+bool isInSingleDeclStmt(const DeclaratorDecl *D) {
+  const DynTypedNodeList Parents =
+      D->getASTContext().getParentMapContext().getParents(*D);
+  for (const DynTypedNode &PNode : Parents)
+    if (const auto *PDecl = PNode.get<DeclStmt>())
+      return PDecl->isSingleDecl();
+  return false;
+}
+
+const DeclaratorDecl *getConstructedVarOrField(const Expr *FoundConstructExpr,
+                                               ASTContext &Ctx) {
+  const DynTypedNodeList ConstructParents =
+      Ctx.getParentMapContext().getParents(*FoundConstructExpr);
+  if (ConstructParents.size() != 1)
+    return nullptr;
+  const auto *ParentDecl = ConstructParents.begin()->get<DeclaratorDecl>();
+  if (isa_and_nonnull<VarDecl, FieldDecl>(ParentDecl))
+    return ParentDecl;
+
+  return nullptr;
+}
+
+} // namespace
+
+const char SmartPtrArrayMismatchCheck::PointerTypeN[] = "pointer_type";
+
+SmartPtrArrayMismatchCheck::SmartPtrArrayMismatchCheck(
+    StringRef Name, ClangTidyContext *Context, StringRef SmartPointerName)
+    : ClangTidyCheck(Name, Context), SmartPointerName(SmartPointerName) {}
+
+void SmartPtrArrayMismatchCheck::storeOptions(
+    ClangTidyOptions::OptionMap &Opts) {}
+
+void SmartPtrArrayMismatchCheck::registerMatchers(MatchFinder *Finder) {
+  // For both shared and unique pointers, we need to find constructor with
+  // exactly one parameter that has the pointer type. Other constructors are
+  // not applicable for this check.
+  auto FindConstructor =
+      cxxConstructorDecl(ofClass(getSmartPointerClassMatcher()),
+                         parameterCountIs(1), isExplicit())
+          .bind(ConstructorN);
+  auto FindConstructExpr =
+      cxxConstructExpr(
+          hasDeclaration(FindConstructor), argumentCountIs(1),
+          hasArgument(
+              0, cxxNewExpr(isArray(), hasType(pointerType(pointee(
+                                           equalsBoundNode(PointerTypeN)))))
+                     .bind(NewExprN)))
+          .bind(ConstructExprN);
+  Finder->addMatcher(FindConstructExpr, this);
+}
+
+void SmartPtrArrayMismatchCheck::check(const MatchFinder::MatchResult &Result) {
+  const auto *FoundNewExpr = Result.Nodes.getNodeAs<CXXNewExpr>(NewExprN);
+  const auto *FoundConstructExpr =
+      Result.Nodes.getNodeAs<CXXConstructExpr>(ConstructExprN);
+  const auto *FoundConstructorDecl =
+      Result.Nodes.getNodeAs<CXXConstructorDecl>(ConstructorN);
+
+  ASTContext &Ctx = FoundConstructorDecl->getASTContext();
+  const DeclaratorDecl *VarOrField =
+      getConstructedVarOrField(FoundConstructExpr, Ctx);
+
+  auto D = diag(FoundNewExpr->getBeginLoc(),
+                "%0 pointer to non-array is initialized with array")
+           << SmartPointerName;
+  D << FoundNewExpr->getSourceRange();
+
+  if (VarOrField) {
+    auto TSTypeLoc = VarOrField->getTypeSourceInfo()
+                         ->getTypeLoc()
+                         .getAsAdjusted<clang::TemplateSpecializationTypeLoc>();
+    assert(TSTypeLoc.getNumArgs() >= 1 &&
+           "Matched type should have at least 1 template argument.");
+
+    SourceRange TemplateArgumentRange = TSTypeLoc.getArgLoc(0)
+                                            .getTypeSourceInfo()
+                                            ->getTypeLoc()
+                                            .getLocalSourceRange();
+    D << TemplateArgumentRange;
+
+    if (isInSingleDeclStmt(VarOrField)) {
+      const SourceManager &SM = Ctx.getSourceManager();
+      if (!utils::rangeCanBeFixed(TemplateArgumentRange, &SM))
+        return;
+
+      SourceLocation InsertLoc = Lexer::getLocForEndOfToken(
+          TemplateArgumentRange.getEnd(), 0, SM, Ctx.getLangOpts());
+      D << FixItHint::CreateInsertion(InsertLoc, "[]");
+    }
+  }
+}
+
+} // namespace bugprone
+} // namespace tidy
+} // namespace clang

clang-tools-extra/docs/ReleaseNotes.rst

 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
 New checks
 ^^^^^^^^^^
 
+- New :doc:`bugprone-shared-ptr-array-mismatch <clang-tidy/checks/bugprone-shared-ptr-array-mismatch>` check.
+
+  Finds initializations of C++ shared pointers to non-array type that are initialized with an array.
+
 New check aliases
 ^^^^^^^^^^^^^^^^^
 
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Removed checks
 ^^^^^^^^^^^^^^

clang-tools-extra/docs/clang-tidy/checks/bugprone-shared-ptr-array-mismatch.rst

+.. title:: clang-tidy - bugprone-shared-ptr-array-mismatch
+
+bugprone-shared-ptr-array-mismatch
+==================================
+
+Finds initializations of C++ shared pointers to non-array type that are
+initialized with an array.
+
+If a shared pointer ``std::shared_ptr<T>`` is initialized with a new-expression
+``new T[]`` the memory is not deallocated correctly. The pointer uses plain
+``delete`` in this case to deallocate the target memory. Instead a ``delete[]``
+call is needed. A ``std::shared_ptr<T[]>`` calls the correct delete operator.
+
+The check offers replacement of ``shared_ptr<T>`` to ``shared_ptr<T[]>`` if it
+is used at a single variable declaration (one variable in one statement).
+
+Example:
+
+.. code-block:: c++
+
+  std::shared_ptr<Foo> x(new Foo[10]); // -> std::shared_ptr<Foo[]> x(new Foo[10]);
+  //                     ^ warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+  std::shared_ptr<Foo> x1(new Foo), x2(new Foo[10]); // no replacement
+  //                                   ^ warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+
+  std::shared_ptr<Foo> x3(new Foo[10], [](const Foo *ptr) { delete[] ptr; }); // no warning
+
+  struct S {
+    std::shared_ptr<Foo> x(new Foo[10]); // no replacement in this case
+    //                     ^ warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+  };

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. csv-table::
    `bugprone-move-forwarding-reference <bugprone-move-forwarding-reference.html>`_, "Yes"
    `bugprone-multiple-statement-macro <bugprone-multiple-statement-macro.html>`_,
    `bugprone-no-escape <bugprone-no-escape.html>`_,
    `bugprone-not-null-terminated-result <bugprone-not-null-terminated-result.html>`_, "Yes"
    `bugprone-parent-virtual-call <bugprone-parent-virtual-call.html>`_, "Yes"
    `bugprone-posix-return <bugprone-posix-return.html>`_, "Yes"
    `bugprone-redundant-branch-condition <bugprone-redundant-branch-condition.html>`_, "Yes"
    `bugprone-reserved-identifier <bugprone-reserved-identifier.html>`_, "Yes"
+   `bugprone-shared-ptr-array-mismatch <bugprone-shared-ptr-array-mismatch.html>`_, "Yes"
    `bugprone-signal-handler <bugprone-signal-handler.html>`_,
    `bugprone-signed-char-misuse <bugprone-signed-char-misuse.html>`_,
    `bugprone-sizeof-container <bugprone-sizeof-container.html>`_,
    `bugprone-sizeof-expression <bugprone-sizeof-expression.html>`_,
    `bugprone-spuriously-wake-up-functions <bugprone-spuriously-wake-up-functions.html>`_,
    `bugprone-string-constructor <bugprone-string-constructor.html>`_, "Yes"
    `bugprone-string-integer-assignment <bugprone-string-integer-assignment.html>`_, "Yes"
    `bugprone-string-literal-with-embedded-nul <bugprone-string-literal-with-embedded-nul.html>`_,

clang-tools-extra/test/clang-tidy/checkers/bugprone-shared-ptr-array-mismatch.cpp

+// RUN: %check_clang_tidy %s bugprone-shared-ptr-array-mismatch %t
+
+namespace std {
+
+template <typename T>
+struct shared_ptr {
+  template <class Y>
+  explicit shared_ptr(Y *) {}
+  template <class Y, class Deleter>
+  shared_ptr(Y *, Deleter) {}
+};
+
+} // namespace std
+
+struct A {};
+
+void f1() {
+  std::shared_ptr<int> P1{new int};
+  std::shared_ptr<int> P2{new int[10]};
+  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+  // CHECK-FIXES: std::shared_ptr<int[]> P2{new int[10]};
+  // clang-format off
+  std::shared_ptr<  int  > P3{new int[10]};
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+  // CHECK-FIXES: std::shared_ptr<  int[]  > P3{new int[10]};
+  // clang-format on
+  std::shared_ptr<int> P4(new int[10]);
+  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+  // CHECK-FIXES: std::shared_ptr<int[]> P4(new int[10]);
+  new std::shared_ptr<int>(new int[10]);
+  // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+  std::shared_ptr<int[]> P5(new int[10]);
+  std::shared_ptr<int> P6(new int[10], [](const int *Ptr) {});
+}
+
+void f2() {
+  std::shared_ptr<A> P1(new A);
+  std::shared_ptr<A> P2(new A[10]);
+  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+  // CHECK-FIXES: std::shared_ptr<A[]> P2(new A[10]);
+  std::shared_ptr<A[]> P3(new A[10]);
+}
+
+void f3() {
+  std::shared_ptr<int> P1{new int}, P2{new int[10]}, P3{new int[10]};
+  // CHECK-MESSAGES: :[[@LINE-1]]:40: warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+  // CHECK-MESSAGES: :[[@LINE-2]]:57: warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+}
+
+struct S {
+  std::shared_ptr<int> P1;
+  std::shared_ptr<int> P2{new int[10]};
+  // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+  std::shared_ptr<int> P3{new int}, P4{new int[10]};
+  // CHECK-MESSAGES: :[[@LINE-1]]:40: warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+  S() : P1{new int[10]} {}
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+};
+
+void f_parm(std::shared_ptr<int>);
+
+void f4() {
+  f_parm(std::shared_ptr<int>{new int[10]});
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+}
+
+std::shared_ptr<int> f_ret() {
+  return std::shared_ptr<int>(new int[10]);
+  // CHECK-MESSAGES: :[[@LINE-1]]:31: warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+}
+
+template <class T>
+void f_tmpl() {
+  std::shared_ptr<T> P1{new T[10]};
+}
+
+void f5() {
+  f_tmpl<char>();
+}
+
+#define CHAR_PTR_TYPE std::shared_ptr<char>
+#define CHAR_PTR_VAR(X) \
+  X { new char[10] }
+#define CHAR_PTR_INIT(X, Y) \
+  std::shared_ptr<char> X { Y }
+
+void f6() {
+  CHAR_PTR_TYPE P1{new char[10]};
+  // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+  std::shared_ptr<char> CHAR_PTR_VAR(P2);
+  // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+  // CHECK-FIXES: std::shared_ptr<char[]> CHAR_PTR_VAR(P2);
+  CHAR_PTR_INIT(P3, new char[10]);
+  // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: shared pointer to non-array is initialized with array [bugprone-shared-ptr-array-mismatch]
+}