Adds AST Matcher for ObjCStringLiteral

[NoQ]

Matcher tests are written as unittests in unittests/ASTMatchers, I don't think you need to make an entire new check for that hmmm.

[t-rasmud]

Documentation edits and other fixes, thanks to suggestions from @ziqingluo-90

[NoQ]

Looks great, thanks!

clang/docs/LibASTMatchersReference.html

2041 ↗

(On Diff #440443)

I think it's more appropriate for this documentation to mention the entire literal so that the reader didn't assume that @ is a different AST node that needs to be captured separately.

[aaron.ballman]

We typically don't add AST matchers until we have a need for them to be used in-tree (ASTMatchers.h is already really expensive to parse; adding matchers for everything possible with AST nodes would be prohibitively expensive). However, this is a case that really seems like it doesn't need to wait for an in-tree use because of how foundational the matcher is, so I think it's fine to add as-is.

clang/docs/LibASTMatchersReference.html

2038 ↗

(On Diff #440450)

It looks like this documentation was added manually -- it should actually live in the ASTMatchers.h header file, and then you run clang/docs/tools/dump_ast_matchers.py to generate this HTML file automatically.

clang/include/clang/ASTMatchers/ASTMatchers.h

1518–1519

You should add your documentation comments above this declaration.

[t-rasmud]

Removes manually added documentation and adds it in the header file.

[NoQ]

Yes the use case is coming up in D126097; it's not used yet because hasDescendant(StringLiteral) is used to skip it but this matchert would be a more precise solution (yes there's an actual StringLiteral inside ObjCStringLiteral).

[aaron.ballman]

The only things left to do are: regenerate the documentation by running clang/docs/tools/dump_ast_matchers.py and add a release note for the new matcher, but otherwise this looks good to me.

In D128103#3617156, @NoQ wrote:

Yes the use case is coming up in D126097; it's not used yet because hasDescendant(StringLiteral) is used to skip it but this matchert would be a more precise solution (yes there's an actual StringLiteral inside ObjCStringLiteral).

Ah, great to hear this will be used quickly in tree too!

[aaron.ballman]

LGTM! Do you need me to commit on your behalf? If so, what name and email address would you like me to use for patch attribution?

[t-rasmud]

In D128103#3622223, @aaron.ballman wrote:

LGTM! Do you need me to commit on your behalf? If so, what name and email address would you like me to use for patch attribution?

Thank you @aaron.ballman. I believe I have the permissions to commit, so I can land the patch.

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

add_extra_unittest(ClangTidyTests
   DeclRefExprUtilsTest.cpp
   IncludeInserterTest.cpp
   GlobListTest.cpp
   GoogleModuleTest.cpp
   LLVMModuleTest.cpp
   ModernizeModuleTest.cpp
   NamespaceAliaserTest.cpp
   ObjCModuleTest.cpp
+  ObjCStringLiteralTest.cpp
   OptionsProviderTest.cpp
   OverlappingReplacementsTest.cpp
   UsingInserterTest.cpp
   ReadabilityModuleTest.cpp
   TransformerClangTidyCheckTest.cpp
   )
 
 clang_target_link_libraries(ClangTidyTests

clang-tools-extra/unittests/clang-tidy/ObjCStringLiteralTest.cpp

+//===---- ObjCStringLiteralTest.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 "ClangTidyTest.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace tidy {
+namespace test {
+namespace {
+
+class ObjCStringLiteralCheck : public ClangTidyCheck {
+public:
+    ObjCStringLiteralCheck(StringRef CheckName, ClangTidyContext *Context)
+      : ClangTidyCheck(CheckName, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override {
+    using namespace ast_matchers;
+      Finder->addMatcher(objCStringLiteral().bind("str_lit"), this);
+  }
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
+      const auto *StrExpr = Result.Nodes.getNodeAs<ObjCStringLiteral>("str_lit");
+      const StringLiteral* SL = cast<ObjCStringLiteral>(StrExpr)->getString();
+      diag(StrExpr->getExprLoc(), "Matched ObjC StringLiteral: %0") << SL->getString();
+  }
+};
+
+} // namespace
+
+TEST(ObjCStringLiteralTest, ObjCStringLiteralCheck) {
+  std::vector<ClangTidyError> Errors;
+  runCheckOnCode<ObjCStringLiteralCheck>(
+      "@interface NSObject\n"
+      "@end\n"
+      "@interface NSString\n"
+      "@end\n"
+      "@interface Test : NSObject\n"
+      "+ (void)someFunction:(NSString *)Desc;\n"
+      "@end\n"
+      "@implementation Test\n"
+      "+ (void)someFunction:(NSString *)Desc {\n"
+      "    return;\n"
+      "}\n"
+      "- (void) foo {\n"
+      "    [Test someFunction:@\"Ola!\"];\n"
+      "}\n"
+      "@end\n",
+      &Errors,
+      "input.m");
+  EXPECT_EQ(1ul, Errors.size());
+  EXPECT_EQ(
+      "Matched ObjC StringLiteral: Ola!",
+      Errors[0].Message.Message);
+}
+
+} // namespace test
+} // namespace tidy
+} // namespace clang

clang/include/clang/ASTMatchers/ASTMatchers.h

 /// "initWithString" instance method on the object returned from
 /// NSString's "alloc". This matcher should match both message sends.
 /// \code
 ///   [[NSString alloc] initWithString:@"Hello"]
 /// \endcode
 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCMessageExpr>
     objcMessageExpr;
 
+extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCStringLiteral>
+    objCStringLiteral;
+
 /// Matches Objective-C interface declarations.
 ///
 /// Example matches Foo
 /// \code
 ///   @interface Foo
 ///   @end
 /// \endcode
 extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCInterfaceDecl>

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt> cxxCatchStmt;
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt> cxxTryStmt;
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr> cxxThrowExpr;
 const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt> nullStmt;
 const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt> asmStmt;
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBoolLiteralExpr>
     cxxBoolLiteral;
 const internal::VariadicDynCastAllOfMatcher<Stmt, StringLiteral> stringLiteral;
+const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCStringLiteral> objCStringLiteral;
 const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral>
     characterLiteral;
 const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral>
     integerLiteral;
 const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral> floatLiteral;
 const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral> imaginaryLiteral;
 const internal::VariadicDynCastAllOfMatcher<Stmt, FixedPointLiteral>
     fixedPointLiteral;

clang/lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(specifiesNamespace);
   REGISTER_MATCHER(specifiesType);
   REGISTER_MATCHER(specifiesTypeLoc);
   REGISTER_MATCHER(statementCountIs);
   REGISTER_MATCHER(staticAssertDecl);
   REGISTER_MATCHER(stmt);
   REGISTER_MATCHER(stmtExpr);
   REGISTER_MATCHER(stringLiteral);
+  REGISTER_MATCHER(objCStringLiteral);
   REGISTER_MATCHER(substNonTypeTemplateParmExpr);
   REGISTER_MATCHER(substTemplateTypeParmType);
   REGISTER_MATCHER(switchCase);
   REGISTER_MATCHER(switchStmt);
   REGISTER_MATCHER(tagDecl);
   REGISTER_MATCHER(tagType);
   REGISTER_MATCHER(templateArgument);
   REGISTER_MATCHER(templateArgumentCountIs);