Add a readability-deleted-default clang-tidy check.

[pilki]

Summary

Checks if constructors and assignment operators that are marked '= default' are actually deleted by the compiler.

[alexfh]

clang-tidy/readability/DeletedDefaultCheck.cpp

26 ↗

(On Diff #53229)

unless(isInTemplateInstantiation()) is the canonical way to do this.

30 ↗

(On Diff #53229)

I think, we need at most two matchers here: one for constructors and one for assignment operators. We could also cram these into a single matcher. I also suggest to combine the diag() calls to a single one using %N or %select{}N format to parametrize the message. Something along the lines of:

Finder->addMatcher(cxxMethodDecl(isDefaulted(), isDeleted(), unless(isImplicit()), unless(isInTemplateInstantiation()),
    anyOf(isCopyAssignmentOperator(), isMoveAssignmentOperator(), cxxConstructorDecl().bind("ctor"))).bind("method"));

...
const auto *Method = Result.Nodes.getNodeAs<CXXMethodDecl>("method");
assert(Method != nullptr);
diag(Method->getLocStart(),
       "this %select{method|constructor}0 is marked '= default' but is actually "
       "implicitly deleted, probably because an instance variable or a base "
       "class is not copyable nor movable; this definition should either be removed "
       "or explicitly marked as '= delete'") << (Result.Nodes.getNodeAs<Decl>("ctor") ? 1 : 0);

If you think that adding "copy", "move" or "default" makes the message any better, this could also be accommodated in this approach.

31 ↗

(On Diff #53229)

Alternatively, you can use isDefaulted(), unless(isImplicit()).

test/clang-tidy/readability-deleted-default.cpp

13 ↗

(On Diff #53229)

Please specify the message completely once.

[alexfh]

clang-tidy/readability/DeletedDefaultCheck.cpp

82 ↗

(On Diff #53229)

nit: CopyAssignment

[pilki]

clang-tidy/readability/DeletedDefaultCheck.cpp

30 ↗

(On Diff #53229)

I reduced to two matchers and used a common template for the error message. Tell me if it's ok.

31 ↗

(On Diff #53229)

What is the advantage? Not writing my own matcher?

[dblaikie]

I'd consider just making this a compiler warning, perhaps?

[alexfh]

In D18961#397163, @dblaikie wrote:

I'd consider just making this a compiler warning, perhaps?

I agree that it might be a good idea. However, it doesn't hurt to have this in clang-tidy (at least as a prototype - to figure out details and see how it works on real code) until we have it in Clang. Also, making it a Clang diagnostic might be more difficult, especially without a prior experience.

[pilki]

In D18961#397163, @dblaikie wrote:

I'd consider just making this a compiler warning, perhaps?

I honestly don't feel competent right now to write compiler warnings: clang-tidy has a nice, well defined interface. A compiler warning would force me to dig in the internals of clang. But if you feel strongly about it and give me a couple of pointers (like a diff that adds a similar warning, and maybe a pointer to the general area in the code where I would add it), I can maybe give it a try in the next few days/weeks.

[alexfh]

Thank you for addressing the comments!

clang-tidy/readability/DeletedDefaultCheck.cpp

27 ↗

(On Diff #53257)

What about this comment?

32 ↗

(On Diff #53257)

Yes, using standard tools instead of introducing a new one.

44 ↗

(On Diff #53257)

A few suggestions to improve the wording:

• remove "this"
• replace the period in the end of the first sentence with a semicolon and use a lower-case letter to start the second part.
• "You should do X" doesn't sound right in warning messages. I'd use a softer option, for example in passive voice: "this definition should either be removed or explicitly marked as '= delete'"

49 ↗

(On Diff #53257)

If the check() method issues a diagnostic in any case, I'd prefer a slightly different pattern to reduce code duplication a bit more:

auto Diag = diag(Constructor->getLocStart(), ".....");
if (x) {
  Diag << "qqq" << "eee";
}
...

70 ↗

(On Diff #53257)

nit: No need for this variable.

72 ↗

(On Diff #53257)

"marked 'const'" sounds better to me than "marked as const".

[dblaikie]

I don't feel sufficiently strongly to insist - clang-tidy's mostly outside
my wheelhouse anyway.

As for how to go about it - my rough approach would be to write a small
test case that calls an implicitly-deleted-but-explicitly-defaulted move
op, run it, check the diagnostic text, find that in DiagnosticSemaKinds,
find where the diagnostic identifier is used in the code, set a breakpoint,
break there - then trace back to when/where it got marked as deleted (find
the member function of the AST node in question that is used to mark it as
deleted - break in there, with the condition that 'this ==' the specific
instance you're looking at, etc). Then see if, at the point at which the
thing is marked as deleted, you can check that it's not dependent (not a
template, etc) and emit the appropriate warning.

• Dave

[Eugene.Zelenko]

Please mention this check in docs/ReleaseNotes.rst (in alphabetical order).

[pilki]

I hope I answered all comments (sorry if I missed some, I'm not yet used to this UI).

I have an open question about isInTemplateInstantiation, and added a test (since I missed templated function)

clang-tidy/readability/DeletedDefaultCheck.cpp

27 ↗

(On Diff #53257)

isInTemplateInstantiation() is a matcher on Stmt only (when hasAncestor is a polymorphic matcher). When using it, it does not compile. So I copied the body here. I don't know how bad that is.

[alexfh]

clang-tidy/readability/DeletedDefaultCheck.cpp

28 ↗

(On Diff #53289)

For decls there is isInstantiated(), which is defined as:

auto IsInstantiation = decl(anyOf(cxxRecordDecl(isTemplateInstantiation()),
                                  functionDecl(isTemplateInstantiation())));
return decl(anyOf(IsInstantiation, hasAncestor(IsInstantiation)));

and should be just what you need.

35 ↗

(On Diff #53289)

It's not overly important, but you can further reduce the code by folding the first matcher into the second one (move cxxConstructorDecl() inside anyOf here, since CXXConstructorDecl is a CXXMethodDecl). You can also use just a single id to bind the node and distinguish the constructor using dyn_cast. Then you'll be able to use a single diag() call below and remove the unneeded variables Message and isBadlyDefaulted.

[pilki]

clang-tidy/readability/DeletedDefaultCheck.cpp

35 ↗

(On Diff #53289)

Mmh, I'm not convinced it really helps with readability here. I can do it if you insist though.

[alexfh]

Looks good. A couple of comments.

I'm happy to commit the patch for you once you answer the comments.

Thank you for the work!

clang-tidy/readability/DeletedDefaultCheck.cpp

36 ↗

(On Diff #53371)

I would at least join matchers, since, I believe, it might be more effective that way.

cxxMethodDecl(anyOf(cxxConstructorDecl().bind("constructor"),
                                     isCopyAssignmentOperator(),
                                     isMoveAssignmentOperator()),
                               isBadlyDefaulted)
                     .bind("assignment")

Optionally, you might want to inline the isBadlyDefaulted matcher (without the external allOf matcher).

As for restructuring the check() method, I don't insist.

49 ↗

(On Diff #53371)

If you don't feel strongly, I'd mildly suggest to turn if { ... return } to a chain of if/else (also the top-level ones). The code will become denser, but it will be easier to see the whole logic in a glance.

[pilki]

clang-tidy/readability/DeletedDefaultCheck.cpp

36 ↗

(On Diff #53371)

I'm a bit confused by this suggestion. It will bind to "assignment" even when it is a constructor. It works because we get "constructor" first in check(), but I find the resulting contract between the check() and registerMatchers awkward.

49 ↗

(On Diff #53371)

I thought that in the clang codebase, return were preferred to 'else'. Done.

[aaron.ballman]

I share David's consideration for making this a compiler warning instead of a clang-tidy check. Perhaps it would make sense to gather some data using this check over some large code bases to see how often it triggers. If it's overly chatty (or we discover interesting usage scenarios), then leaving it as a clang-tidy check may make more sense.

clang-tidy/readability/DeletedDefaultCheck.cpp

38 ↗

(On Diff #53381)

This is a bit verbose. How about:

"%0 is explicitly defaulted but implicitly deleted, probably because %1; definition can either be removed or explicitly deleted"

?

47 ↗

(On Diff #53381)

"non-static data member" instead of "instance variable"

55 ↗

(On Diff #53381)

s/not/neither

[pilki]

Fixed all the comment but the one about merging the two matchers.

[alexfh]

clang-tidy/readability/DeletedDefaultCheck.cpp

37 ↗

(On Diff #53404)

Will it be less confusing to you, if you change "assignment" to something more generic, e.g. "method" or "decl"?

Also, if you find it less readable that way, we can leave it as is for now.

50 ↗

(On Diff #53404)

I usually prefer early returns, however, in this case I find it better to make the code compact. This way it's also immediately clear that the code does nothing but mapping certain properties of matched objects to a message.

[pilki]

clang-tidy/readability/DeletedDefaultCheck.cpp

37 ↗

(On Diff #53404)

I implemented the requested changes

[alexfh]

Thank you for addressing the comments!

I'll commit the patch for you.

[alexfh]

The patch doesn't apply cleanly. Please rebase it against current HEAD.

[pilki]

I did svn up and reuploaded the diff. I did not see any changes on files I touched, so I'm not sure it worked.

[alexfh]

Something is weird with your patch: it has names starting with a space (note two spaces between "Index:" and "clang-tidy/..."):

Index:  clang-tidy/readability/CMakeLists.txt
===================================================================
---  clang-tidy/readability/CMakeLists.txt
+++  clang-tidy/readability/CMakeLists.txt
@@ -4,6 +4,7 @@
   AvoidConstParamsInDecls.cpp
   BracesAroundStatementsCheck.cpp
   ContainerSizeEmptyCheck.cpp
+  DeletedDefaultCheck.cpp
   ElseAfterReturnCheck.cpp
   FunctionSizeCheck.cpp
   IdentifierNamingCheck.cpp
Index:  clang-tidy/readability/DeletedDefaultCheck.h
===================================================================

For comparison, a normal diff:
http://reviews.llvm.org/file/data/ldmp5jqxuvect5cwpyer/PHID-FILE-3rnivuajuco4mxhb6nzh/D18962.diff

Index: llvm/trunk/lib/Target/SystemZ/README.txt
===================================================================
--- llvm/trunk/lib/Target/SystemZ/README.txt
+++ llvm/trunk/lib/Target/SystemZ/README.txt
@@ -43,11 +43,6 @@

[pilki]

Sorry, both my 'diff' and my 'svn' command added some magical coloring... It should be good now.

[njames93]

Now that there is a stable warning in clang for this check that is enabled without specifying any warning flags, Is there reason to think about retiring this check?

[aaron.ballman]

In D18961#2549303, @njames93 wrote:

Now that there is a stable warning in clang for this check that is enabled without specifying any warning flags, Is there reason to think about retiring this check?

I'd be fine with that. We may even have the time to get a deprecation note into Clang 12 so that we can remove this code in Clang 13 if we felt so inclined.

clang-tools-extra/trunk/clang-tidy/readability/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyReadabilityModule
   AvoidConstParamsInDecls.cpp
   BracesAroundStatementsCheck.cpp
   ContainerSizeEmptyCheck.cpp
+  DeletedDefaultCheck.cpp
   ElseAfterReturnCheck.cpp
   FunctionSizeCheck.cpp
   IdentifierNamingCheck.cpp
   ImplicitBoolCastCheck.cpp
   InconsistentDeclarationParameterNameCheck.cpp
   NamedParameterCheck.cpp
   NamespaceCommentCheck.cpp
   ReadabilityTidyModule.cpp

clang-tools-extra/trunk/clang-tidy/readability/DeletedDefaultCheck.h

+//===--- DeletedDefaultCheck.h - clang-tidy----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_DELETED_DEFAULT_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_DELETED_DEFAULT_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+/// Checks when a constructor or an assignment operator is marked as '= default'
+/// but is actually deleted by the compiler.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/readability-deleted-default.html
+class DeletedDefaultCheck : public ClangTidyCheck {
+public:
+  DeletedDefaultCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_DELETED_DEFAULT_H

clang-tools-extra/trunk/clang-tidy/readability/DeletedDefaultCheck.cpp

+//===--- DeletedDefaultCheck.cpp - clang-tidy------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "DeletedDefaultCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace readability {
+
+void DeletedDefaultCheck::registerMatchers(MatchFinder *Finder) {
+  // We match constructors/assignment operators that are:
+  //   - explicitly marked '= default'
+  //   - actually deleted
+  //   - not in template instantiation.
+  // We bind the declaration to "method-decl" and also to "constructor" when
+  // it is a constructor.
+
+  Finder->addMatcher(
+      cxxMethodDecl(anyOf(cxxConstructorDecl().bind("constructor"),
+                          isCopyAssignmentOperator(),
+                          isMoveAssignmentOperator()),
+                    isDefaulted(), unless(isImplicit()), isDeleted(),
+                    unless(isInstantiated()))
+          .bind("method-decl"),
+      this);
+}
+
+void DeletedDefaultCheck::check(const MatchFinder::MatchResult &Result) {
+  const StringRef Message = "%0 is explicitly defaulted but implicitly "
+                            "deleted, probably because %1; definition can "
+                            "either be removed or explicitly deleted";
+  if (const auto *Constructor =
+          Result.Nodes.getNodeAs<CXXConstructorDecl>("constructor")) {
+    auto Diag = diag(Constructor->getLocStart(), Message);
+    if (Constructor->isDefaultConstructor()) {
+      Diag << "default constructor"
+           << "a non-static data member or a base class is lacking a default "
+              "constructor";
+    } else if (Constructor->isCopyConstructor()) {
+      Diag << "copy constructor"
+           << "a non-static data member or a base class is not copyable";
+    } else if (Constructor->isMoveConstructor()) {
+      Diag << "move constructor"
+           << "a non-static data member or a base class is neither copyable "
+              "nor movable";
+    }
+  } else if (const auto *Assignment =
+                 Result.Nodes.getNodeAs<CXXMethodDecl>("method-decl")) {
+    diag(Assignment->getLocStart(), Message)
+        << (Assignment->isCopyAssignmentOperator() ? "copy assignment operator"
+                                                   : "move assignment operator")
+        << "a base class or a non-static data member is not assignable, e.g. "
+           "because the latter is marked 'const'";
+  }
+}
+
+} // namespace readability
+} // namespace tidy
+} // namespace clang

clang-tools-extra/trunk/clang-tidy/readability/ReadabilityTidyModule.cpp

 //===--- ReadabilityTidyModule.cpp - clang-tidy ---------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "AvoidConstParamsInDecls.h"
 #include "BracesAroundStatementsCheck.h"
 #include "ContainerSizeEmptyCheck.h"
+#include "DeletedDefaultCheck.h"
 #include "ElseAfterReturnCheck.h"
 #include "FunctionSizeCheck.h"
 #include "IdentifierNamingCheck.h"
 #include "ImplicitBoolCastCheck.h"
 #include "InconsistentDeclarationParameterNameCheck.h"
 #include "NamedParameterCheck.h"
 #include "RedundantControlFlowCheck.h"
 #include "RedundantSmartptrGetCheck.h"

 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<AvoidConstParamsInDecls>(
         "readability-avoid-const-params-in-decls");
     CheckFactories.registerCheck<BracesAroundStatementsCheck>(
         "readability-braces-around-statements");
     CheckFactories.registerCheck<ContainerSizeEmptyCheck>(
         "readability-container-size-empty");
+    CheckFactories.registerCheck<DeletedDefaultCheck>(
+        "readability-deleted-default");
     CheckFactories.registerCheck<ElseAfterReturnCheck>(
         "readability-else-after-return");
     CheckFactories.registerCheck<FunctionSizeCheck>(
         "readability-function-size");
     CheckFactories.registerCheck<IdentifierNamingCheck>(
         "readability-identifier-naming");
     CheckFactories.registerCheck<ImplicitBoolCastCheck>(
         "readability-implicit-bool-cast");

clang-tools-extra/trunk/docs/ReleaseNotes.rst

- New `performance-unnecessary-value-param
   Flags value parameter declarations of expensive to copy types that are copied
   for each invocation but it would suffice to pass them by const reference.
 
 - New `readability-avoid-const-params-in-decls
   <http://clang.llvm.org/extra/clang-tidy/checks/readability-avoid-const-params-in-decls.html>`_ check
 
   Warns about top-level const parameters in function declarations.
 
+- New `readability-deleted-default
+  <http://clang.llvm.org/extra/clang-tidy/checks/readability-deleted-default.html>`_ check
+
+  Warns about defaulted constructors and assignment operators that are actually
+  deleted.
+
 - New `readability-redundant-control-flow
   <http://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-control-flow.html>`_ check
 
   Looks for procedures (functions returning no value) with ``return`` statements
   at the end of the function.  Such `return` statements are redundant.
 
 - New `readability-redundant-string-init
   <http://clang.llvm.org/extra/clang-tidy/checks/readability-redundant-string-init.html>`_ check

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

.. toctree::
    performance-faster-string-find
    performance-for-range-copy
    performance-implicit-cast-in-loop
    performance-unnecessary-copy-initialization
    performance-unnecessary-value-param
    readability-avoid-const-params-in-decls
    readability-braces-around-statements
    readability-container-size-empty
+   readability-deleted-default
    readability-else-after-return
    readability-function-size
    readability-identifier-naming
    readability-implicit-bool-cast
    readability-inconsistent-declaration-parameter-name
    readability-named-parameter
    readability-redundant-control-flow
    readability-redundant-smartptr-get
    readability-redundant-string-cstr
    readability-redundant-string-init
    readability-simplify-boolean-expr
    readability-static-definition-in-anonymous-namespace
    readability-uniqueptr-delete-release

clang-tools-extra/trunk/docs/clang-tidy/checks/readability-deleted-default.rst

+.. title:: clang-tidy - readability-deleted-default
+
+readability-deleted-default
+===========================
+
+Checks that constructors and assignment operators marked as ``= default`` are
+not actually deleted by the compiler.
+
+.. code:: c++
+  class Example {
+  public:
+    // This constructor is deleted because I is missing a default value.
+    Example() = default;
+    // This is fine.
+    Example(const Example& Other) = default;
+    // This operator is deleted because I cannot be assigned (it is const).
+    Example& operator=(const Example& Other) = default;
+  private:
+    const int I;
+  };
+

clang-tools-extra/trunk/test/clang-tidy/readability-deleted-default.cpp

+// RUN: %check_clang_tidy %s readability-deleted-default %t
+
+class NoDefault {
+public:
+  NoDefault() = delete;
+  NoDefault(NoDefault &&Other) = delete;
+  NoDefault(const NoDefault &Other) = delete;
+};
+
+class MissingEverything {
+public:
+  MissingEverything() = default;
+  // CHECK-MESSAGES: warning: default constructor is explicitly defaulted but implicitly deleted, probably because a non-static data member or a base class is lacking a default constructor; definition can either be removed or explicitly deleted [readability-deleted-default]
+  MissingEverything(MissingEverything &&Other) = default;
+  // CHECK-MESSAGES: warning: move constructor is explicitly defaulted but implicitly deleted, probably because a non-static data member or a base class is neither copyable nor movable; definition can either be removed or explicitly deleted [readability-deleted-default]
+  MissingEverything(const MissingEverything &Other) = default;
+  // CHECK-MESSAGES: warning: copy constructor is explicitly defaulted but implicitly deleted, probably because a non-static data member or a base class is not copyable; definition can either be removed or explicitly deleted [readability-deleted-default]
+  MissingEverything &operator=(MissingEverything &&Other) = default;
+  // CHECK-MESSAGES: warning: move assignment operator is explicitly defaulted but implicitly deleted, probably because a base class or a non-static data member is not assignable, e.g. because the latter is marked 'const'; definition can either be removed or explicitly deleted [readability-deleted-default]
+  MissingEverything &operator=(const MissingEverything &Other) = default;
+  // CHECK-MESSAGES: warning: copy assignment operator is explicitly defaulted but implicitly deleted, probably because a base class or a non-static data member is not assignable, e.g. because the latter is marked 'const'; definition can either be removed or explicitly deleted [readability-deleted-default]
+
+private:
+  NoDefault ND;
+};
+
+class NotAssignable {
+public:
+  NotAssignable(NotAssignable &&Other) = default;
+  NotAssignable(const NotAssignable &Other) = default;
+  NotAssignable &operator=(NotAssignable &&Other) = default;
+  // CHECK-MESSAGES: warning: move assignment operator is explicitly defaulted but implicitly deleted
+  NotAssignable &operator=(const NotAssignable &Other) = default;
+  // CHECK-MESSAGES: warning: copy assignment operator is explicitly defaulted but implicitly deleted
+
+private:
+  const int I = 0;
+};
+
+class Movable {
+public:
+  Movable() = default;
+  Movable(Movable &&Other) = default;
+  Movable(const Movable &Other) = delete;
+  Movable &operator=(Movable &&Other) = default;
+  Movable &operator=(const Movable &Other) = delete;
+};
+
+class NotCopyable {
+public:
+  NotCopyable(NotCopyable &&Other) = default;
+  NotCopyable(const NotCopyable &Other) = default;
+  // CHECK-MESSAGES: warning: copy constructor is explicitly defaulted but implicitly deleted
+  NotCopyable &operator=(NotCopyable &&Other) = default;
+  NotCopyable &operator=(const NotCopyable &Other) = default;
+  // CHECK-MESSAGES: warning: copy assignment operator is explicitly defaulted but implicitly deleted
+private:
+  Movable M;
+};
+
+template <typename T> class Templated {
+public:
+  // No warning here, it is a templated class.
+  Templated() = default;
+  Templated(Templated &&Other) = default;
+  Templated(const Templated &Other) = default;
+  Templated &operator=(Templated &&Other) = default;
+  Templated &operator=(const Templated &Other) = default;
+
+  class InnerTemplated {
+  public:
+    // This class is not in itself templated, but we still don't have warning.
+    InnerTemplated() = default;
+    InnerTemplated(InnerTemplated &&Other) = default;
+    InnerTemplated(const InnerTemplated &Other) = default;
+    InnerTemplated &operator=(InnerTemplated &&Other) = default;
+    InnerTemplated &operator=(const InnerTemplated &Other) = default;
+
+  private:
+    T TVar;
+  };
+
+  class InnerNotTemplated {
+  public:
+    // This one could technically have warnings, but currently doesn't.
+    InnerNotTemplated() = default;
+    InnerNotTemplated(InnerNotTemplated &&Other) = default;
+    InnerNotTemplated(const InnerNotTemplated &Other) = default;
+    InnerNotTemplated &operator=(InnerNotTemplated &&Other) = default;
+    InnerNotTemplated &operator=(const InnerNotTemplated &Other) = default;
+
+  private:
+    int I;
+  };
+
+private:
+  const T TVar{};
+};
+
+int FunctionWithInnerClass() {
+  class InnerNotAssignable {
+  public:
+    InnerNotAssignable &operator=(InnerNotAssignable &&Other) = default;
+    // CHECK-MESSAGES: warning: move assignment operator is explicitly defaulted but implicitly deleted
+  private:
+    const int I = 0;
+  };
+  return 1;
+};
+
+template <typename T>
+int TemplateFunctionWithInnerClass() {
+  class InnerNotAssignable {
+  public:
+    InnerNotAssignable &operator=(InnerNotAssignable &&Other) = default;
+  private:
+    const T TVar{};
+  };
+  return 1;
+};
+
+void Foo() {
+  Templated<const int> V1;
+  Templated<int>::InnerTemplated V2;
+  Templated<float>::InnerNotTemplated V3;
+  TemplateFunctionWithInnerClass<int>();
+}