[AST] default implementation is possible for non-member functions in C++2a.

[hokein]

Summary

Make RAV not visit the default function decl by default.
Also update some stale comments on FunctionDecl::isDefault.

[rsmith]

Looks good subject to some comment tweaks.

clang/include/clang/AST/Decl.h

2128–2129

In passing, please remove the "per C++0x" here and below. This isn't a new thing whose existence we need to remind readers of any more! Also, replace "C++2a" with "C++20" or remove that too; C++20 is complete so we shouldn't be using its pre-release codename any more.

The term is "defaulted comparisons", not "default comparisons". (I'd also remove the "friend" since that's at best incidental, especially after http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2085r0.html).

[hokein]

Address comments.

clang/include/clang/AST/Decl.h

public:
   /// copy assignment operators, and destructors.  Not meaningful until
   /// the class has been fully built by Sema.
   bool isTrivial() const { return FunctionDeclBits.IsTrivial; }
   void setTrivial(bool IT) { FunctionDeclBits.IsTrivial = IT; }
 
   bool isTrivialForCall() const { return FunctionDeclBits.IsTrivialForCall; }
   void setTrivialForCall(bool IT) { FunctionDeclBits.IsTrivialForCall = IT; }
 
-  /// Whether this function is defaulted per C++0x. Only valid for
-  /// special member functions.
+  /// Whether this function is defaulted. Valid for e.g.
+  /// special member functions, defaulted comparisions (not methods!).
   bool isDefaulted() const { return FunctionDeclBits.IsDefaulted; }
   void setDefaulted(bool D = true) { FunctionDeclBits.IsDefaulted = D; }
 
-  /// Whether this function is explicitly defaulted per C++0x. Only valid
-  /// for special member functions.
+  /// Whether this function is explicitly defaulted.
   bool isExplicitlyDefaulted() const {
     return FunctionDeclBits.IsExplicitlyDefaulted;
   }
 
-  /// State that this function is explicitly defaulted per C++0x. Only valid
-  /// for special member functions.
+  /// State that this function is explicitly defaulted.
   void setExplicitlyDefaulted(bool ED = true) {
     FunctionDeclBits.IsExplicitlyDefaulted = ED;
   }
 
   /// True if this method is user-declared and was not
   /// deleted or defaulted on its first declaration.
   bool isUserProvided() const {
     auto *DeclAsWritten = this;

clang/include/clang/AST/RecursiveASTVisitor.h

bool RecursiveASTVisitor<Derived>::TraverseFunctionHelper(FunctionDecl *D) {
   if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D)) {
     // Constructor initializers.
     for (auto *I : Ctor->inits()) {
       if (I->isWritten() || getDerived().shouldVisitImplicitCode())
         TRY_TO(TraverseConstructorInitializer(I));
     }
   }
 
-  bool VisitBody = D->isThisDeclarationADefinition();
-  // If a method is set to default outside the class definition the compiler
-  // generates the method body and adds it to the AST.
-  if (const auto *MD = dyn_cast<CXXMethodDecl>(D))
-    VisitBody &= !MD->isDefaulted() || getDerived().shouldVisitImplicitCode();
+  bool VisitBody =
+      D->isThisDeclarationADefinition() &&
+      // Don't visit the function body if the function definition is generated
+      // by clang.
+      (!D->isDefaulted() || getDerived().shouldVisitImplicitCode());
 
   if (VisitBody) {
     TRY_TO(TraverseStmt(D->getBody())); // Function body.
   }
   return true;
 }
 
 DEF_TRAVERSE_DECL(FunctionDecl, {

clang/unittests/Tooling/RecursiveASTVisitorTests/CXXMethodDecl.cpp

llvm::StringRef Code = R"cpp(
         A &operator=(A &&O);
       };
 
       A &A::operator=(A &&O) = default;
     )cpp";
     EXPECT_TRUE(Visitor.runOver(Code, CXXMethodDeclVisitor::Lang_CXX11));
   }
 }
+
+TEST(RecursiveASTVisitor, FunctionDeclNoDefaultBodyVisited) {
+  for (bool VisitImplCode : {false, true}) {
+    CXXMethodDeclVisitor Visitor(VisitImplCode);
+    if (VisitImplCode)
+      Visitor.ExpectMatch("declref", 4, 58, /*Times=*/2);
+    else
+      Visitor.DisallowMatch("declref", 4, 58);
+    llvm::StringRef Code = R"cpp(
+      struct s {
+        int x;
+        friend auto operator==(s a, s b) -> bool = default;
+      };
+      bool k = s() == s(); // make sure clang generates the "==" definition.
+    )cpp";
+    EXPECT_TRUE(Visitor.runOver(Code, CXXMethodDeclVisitor::Lang_CXX2a));
+  }
+}
 } // end anonymous namespace