[ASTMatchers] Fix crash with HasName and HasAnyName

[njames93]

Summary

Fixes crashes caused by matching fully qualified RecordDecls inside Function bodies.
See https://bugs.llvm.org/show_bug.cgi?id=43639.
I'm still unsure if this is the desired behaviour though.

[njames93]

Fix clang-format error.

clang/include/clang/AST/PrettyPrinter.h

PrintingPolicy(const LangOptions &LO)
         SuppressTemplateArgsInCXXConstructors(false), Bool(LO.Bool),
         Restrict(LO.C99), Alignof(LO.CPlusPlus11), UnderscoreAlignof(LO.C11),
         UseVoidForZeroParams(!LO.CPlusPlus),
         SplitTemplateClosers(!LO.CPlusPlus11), TerseOutput(false),
         PolishForDeclaration(false), Half(LO.Half),
         MSWChar(LO.MicrosoftExt && !LO.WChar), IncludeNewlines(true),
         MSVCFormatting(false), ConstantsAsWritten(false),
         SuppressImplicitBase(false), FullyQualifiedName(false),
-        PrintCanonicalTypes(false), PrintInjectedClassNameWithArguments(true) {}
+        PrintCanonicalTypes(false), PrintInjectedClassNameWithArguments(true),
+        PrintFunctionQualifiedRecords(false) {}
 
   /// Adjust this printing policy for cases where it's known that we're
   /// printing C++ code (for instance, if AST dumping reaches a C++-only
   /// construct). This should not be used if a real LangOptions object is
   /// available.
   void adjustForCPlusPlus() {
     SuppressTagKeyword = true;
     Bool = true;
struct PrintingPolicy {
   /// Whether to print types as written or canonically.
   unsigned PrintCanonicalTypes : 1;
 
   /// Whether to print an InjectedClassNameType with template arguments or as
   /// written. When a template argument is unnamed, printing it results in
   /// invalid C++ code.
   unsigned PrintInjectedClassNameWithArguments : 1;
 
+  /// Whether to print FunctionDecl surrounding a RecordDecl.
+  ///
+  /// \code
+  /// void Foo(int Bar) {
+  ///   struct Baz;
+  /// }
+  /// \endcode
+  ///
+  /// When true, Bar will be printed as:
+  /// Foo(int)::Baz
+  unsigned PrintFunctionQualifiedRecords : 1;
+
   /// Callbacks to use to allow the behavior of printing to be customized.
   const PrintingCallbacks *Callbacks = nullptr;
 };
 
 } // end namespace clang
 
 #endif

clang/lib/AST/Decl.cpp

 }
 
 void NamedDecl::printQualifiedName(raw_ostream &OS) const {
   printQualifiedName(OS, getASTContext().getPrintingPolicy());
 }
 
 void NamedDecl::printQualifiedName(raw_ostream &OS,
                                    const PrintingPolicy &P) const {
-  if (getDeclContext()->isFunctionOrMethod()) {
+  if (getDeclContext()->isFunctionOrMethod() &&
+      !(P.PrintFunctionQualifiedRecords && isa<RecordDecl>(this))) {
     // We do not print '(anonymous)' for function parameters without name.
     printName(OS);
     return;
   }
   printNestedNameSpecifier(OS, P);
   if (getDeclName())
     OS << *this;
   else {
if (auto *MD = dyn_cast<ObjCMethodDecl>(this)) {
     if (auto *MD = PD->getGetterMethodDecl())
       if (auto *ID = MD->getClassInterface())
         Ctx = ID;
   } else if (auto *ID = dyn_cast<ObjCIvarDecl>(this)) {
     if (auto *CI = ID->getContainingInterface())
       Ctx = CI;
   }
 
-  if (Ctx->isFunctionOrMethod())
+  if (Ctx->isFunctionOrMethod() &&
+      !(P.PrintFunctionQualifiedRecords && isa<RecordDecl>(this)))
     return;
 
   using ContextsTy = SmallVector<const DeclContext *, 8>;
   ContextsTy Contexts;
 
   // Collect named contexts.
   while (Ctx) {
     if (isa<NamedDecl>(Ctx))

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

bool HasNameMatcher::matchesNodeFullFast(const NamedDecl &Node) const {
   if (!Patterns.consumeNameSuffix(getNodeName(Node, Scratch),
                                   /*CanSkip=*/false))
     return false;
 
   // Try to match each declaration context.
   // We are allowed to skip anonymous and inline namespaces if they don't match.
   const DeclContext *Ctx = Node.getDeclContext();
 
-  if (Ctx->isFunctionOrMethod())
+  if (Ctx->isFunctionOrMethod() && !isa<RecordDecl>(Node))
     return Patterns.foundMatch(/*AllowFullyQualified=*/false);
 
   for (; Ctx; Ctx = Ctx->getParent()) {
     // Linkage Spec can just be ignored
     // FIXME: Any other DeclContext kinds that can be safely disregarded
     if (isa<LinkageSpecDecl>(Ctx))
       continue;
     if (!isa<NamedDecl>(Ctx))

 }
 
 bool HasNameMatcher::matchesNodeFullSlow(const NamedDecl &Node) const {
   const bool SkipUnwrittenCases[] = {false, true};
   for (bool SkipUnwritten : SkipUnwrittenCases) {
     llvm::SmallString<128> NodeName = StringRef("::");
     llvm::raw_svector_ostream OS(NodeName);
 
-    if (SkipUnwritten) {
-      PrintingPolicy Policy = Node.getASTContext().getPrintingPolicy();
-      Policy.SuppressUnwrittenScope = true;
-      Node.printQualifiedName(OS, Policy);
-    } else {
-      Node.printQualifiedName(OS);
-    }
+    Policy.PrintFunctionQualifiedRecords = true;
+    Policy.SuppressUnwrittenScope = SkipUnwritten;
 
     const StringRef FullName = OS.str();
 
     for (const StringRef Pattern : Names) {
       if (Pattern.startswith("::")) {
         if (FullName == Pattern)
           return true;
       } else if (FullName.endswith(Pattern) &&

clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

TEST(Matcher, HasNameSupportsAnonymousOuterClasses) {
   EXPECT_FALSE(matches("class A { struct { class C; } x; };",
                        recordDecl(hasName("::A::C"))));
 }
 
 TEST(Matcher, HasNameSupportsFunctionScope) {
   StringRef code =
       "namespace a { void F(int a) { struct S { int m; }; int i; } }";
   EXPECT_TRUE(matches(code, varDecl(hasName("i"))));
-  EXPECT_FALSE(matches(code, varDecl(hasName("F()::i"))));
+  EXPECT_FALSE(matches(code, varDecl(hasName("F(int)::i"))));
 
   EXPECT_TRUE(matches(code, fieldDecl(hasName("m"))));
   EXPECT_TRUE(matches(code, fieldDecl(hasName("S::m"))));
   EXPECT_TRUE(matches(code, fieldDecl(hasName("F(int)::S::m"))));
   EXPECT_TRUE(matches(code, fieldDecl(hasName("a::F(int)::S::m"))));
   EXPECT_TRUE(matches(code, fieldDecl(hasName("::a::F(int)::S::m"))));
 }
 
+TEST(Matcher, HasNameSupportsFunctionScopeRecordDecl) {
+  StringRef FuncCode = R"cc(
+    void A() {
+      struct B {};
+    })cc";
+  EXPECT_TRUE(matches(FuncCode, cxxRecordDecl(hasName("B"))));
+  EXPECT_TRUE(matches(FuncCode, cxxRecordDecl(hasName("A()::B"))));
+  EXPECT_TRUE(matches(FuncCode, cxxRecordDecl(hasName("::A()::B"))));
+  EXPECT_TRUE(notMatches(FuncCode, cxxRecordDecl(hasName("::B"))));
+
+  StringRef MethodCode = R"cc(
+    struct A {
+      void B() {
+        struct C {};
+      }
+    };)cc";
+
+  EXPECT_TRUE(matches(MethodCode, cxxRecordDecl(hasName("C"))));
+  EXPECT_TRUE(matches(MethodCode, cxxRecordDecl(hasName("B()::C"))));
+  EXPECT_TRUE(
+      matches(MethodCode, cxxRecordDecl(hasName("A::B()::C"))));
+  EXPECT_TRUE(
+      matches(MethodCode, cxxRecordDecl(hasName("::A::B()::C"))));
+  EXPECT_TRUE(notMatches(MethodCode, cxxRecordDecl(hasName("::C"))));
+  EXPECT_TRUE(
+      notMatches(MethodCode, cxxRecordDecl(hasName("::B()::C"))));
+}
+
 TEST(Matcher, HasNameQualifiedSupportsLinkage) {
   // https://bugs.llvm.org/show_bug.cgi?id=42193
   StringRef code = R"cpp(namespace foo { extern "C" void test(); })cpp";
   EXPECT_TRUE(matches(code, functionDecl(hasName("test"))));
   EXPECT_TRUE(matches(code, functionDecl(hasName("foo::test"))));
   EXPECT_TRUE(matches(code, functionDecl(hasName("::foo::test"))));
   EXPECT_TRUE(notMatches(code, functionDecl(hasName("::test"))));