[clang-tidy] Fix readability-braces-around-statements false positive

[curdeius]

Summary

This fixes a false-positive e.g. when string literals are returned from if statement.

This patch includes as well a small fix to includes and renames of the test suite that collided with the name of the check.

[hokein]

Thanks, LGTM with one nit.

clang-tidy/ReadabilityModuleTest.cpp

488 ↗

(On Diff #74510)

Extra blank line.

[curdeius]

Remove blank line.

[alexfh]

clang-tidy/modernize/UseUsingCheck.cpp

11–12

The change is fine, but it would be better to commit it separately (obviously, no need to do anything now, just for the future).

clang-tidy/readability/BracesAroundStatementsCheck.cpp

64

I'm thoroughly confused as to why the code in your test was not handled correctly and why this is the right fix. Can you explain?

clang-tidy/modernize/UseUsingCheck.cpp

 //===----------------------------------------------------------------------===//
 
 #include "UseUsingCheck.h"
-#include "../utils/LexerUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 

clang-tidy/readability/BracesAroundStatementsCheck.cpp

   bool SkipEndWhitespaceAndComments = true;
   tok::TokenKind TokKind = getTokenKind(Loc, SM, Context);
   if (TokKind == tok::NUM_TOKENS || TokKind == tok::semi ||
-      TokKind == tok::r_brace) {
+      TokKind == tok::r_brace || isStringLiteral(TokKind)) {
     // If we are at ";" or "}", we found the last token. We could use as well
     // `if (isa<NullStmt>(S))`, but it wouldn't work for nested statements.
     SkipEndWhitespaceAndComments = false;

unittests/clang-tidy/ReadabilityModuleTest.cpp

             runCheckOnCode<NamespaceCommentCheck>("namespace i {\n}"));
   EXPECT_EQ("namespace {\n} // namespace",
             runCheckOnCode<NamespaceCommentCheck>("namespace {\n}"));
-  EXPECT_EQ(
-      "namespace i { namespace j {\n} // namespace j\n } // namespace i",
-      runCheckOnCode<NamespaceCommentCheck>("namespace i { namespace j {\n} }"));
+  EXPECT_EQ("namespace i { namespace j {\n} // namespace j\n } // namespace i",
+            runCheckOnCode<NamespaceCommentCheck>(
+                "namespace i { namespace j {\n} }"));
 }
 
 TEST(NamespaceCommentCheckTest, SingleLineNamespaces) {

             "} // Anonymous namespace.",
             runCheckOnCode<NamespaceCommentCheck>("namespace {\n"
                                                   "} // Anonymous namespace."));
-  EXPECT_EQ("namespace q {\n"
-            "} // namespace q",
-            runCheckOnCode<NamespaceCommentCheck>("namespace q {\n"
-                                                  "} // anonymous namespace q"));
   EXPECT_EQ(
+      "namespace q {\n"
+      "} // namespace q",
+      runCheckOnCode<NamespaceCommentCheck>("namespace q {\n"
+                                            "} // anonymous namespace q"));
+  EXPECT_EQ(
       "namespace My_NameSpace123 {\n"
       "} // namespace My_NameSpace123",
       runCheckOnCode<NamespaceCommentCheck>("namespace My_NameSpace123 {\n"

                                                   "} // random text"));
 }
 
-TEST(BracesAroundStatementsCheck, IfWithComments) {
+TEST(BracesAroundStatementsCheckTest, IfWithComments) {
   EXPECT_EQ("int main() {\n"
             "  if (false /*dummy token*/) {\n"
             "    // comment\n"

                 "}"));
 }
 
-TEST(BracesAroundStatementsCheck, If) {
+TEST(BracesAroundStatementsCheckTest, If) {
   EXPECT_NO_CHANGES(BracesAroundStatementsCheck, "int main() {\n"
                                                  "  if (false) {\n"
                                                  "    return -1;\n"

                                                         "}"));
 }
 
-TEST(BracesAroundStatementsCheck, IfElseWithShortStatements) {
+TEST(BracesAroundStatementsCheckTest, IfElseWithShortStatements) {
   ClangTidyOptions Options;
   Options.CheckOptions["test-check-0.ShortStatementLines"] = "1";
 

                 nullptr, "input.cc", None, Options));
 }
 
-TEST(BracesAroundStatementsCheck, For) {
+TEST(BracesAroundStatementsCheckTest, For) {
   EXPECT_NO_CHANGES(BracesAroundStatementsCheck, "int main() {\n"
                                                  "  for (;;) {\n"
                                                  "    ;\n"

                                                         "}"));
 }
 
-TEST(BracesAroundStatementsCheck, ForRange) {
+TEST(BracesAroundStatementsCheckTest, ForRange) {
   EXPECT_NO_CHANGES(BracesAroundStatementsCheck, "int main() {\n"
                                                  "  int arr[4];\n"
                                                  "  for (int i : arr) {\n"

                                                         "}"));
 }
 
-TEST(BracesAroundStatementsCheck, DoWhile) {
+TEST(BracesAroundStatementsCheckTest, DoWhile) {
   EXPECT_NO_CHANGES(BracesAroundStatementsCheck, "int main() {\n"
                                                  "  do {\n"
                                                  "    ;\n"

                                                         "}"));
 }
 
-TEST(BracesAroundStatementsCheck, While) {
+TEST(BracesAroundStatementsCheckTest, While) {
   EXPECT_NO_CHANGES(BracesAroundStatementsCheck, "int main() {\n"
                                                  "  while (false) {\n"
                                                  "    ;\n"

                                                         "}"));
 }
 
-TEST(BracesAroundStatementsCheck, Nested) {
+TEST(BracesAroundStatementsCheckTest, Nested) {
   EXPECT_EQ("int main() {\n"
             "  do { if (true) {}} while (false);\n"
             "}",

                                                   "}"));
 }
 
-TEST(BracesAroundStatementsCheck, Macros) {
+TEST(BracesAroundStatementsCheckTest, Macros) {
   EXPECT_NO_CHANGES(BracesAroundStatementsCheck,
                     "#define IF(COND) if (COND) return -1;\n"
                     "int main() {\n"

                                                         "}"));
 }
 
+#define EXPECT_NO_CHANGES_WITH_OPTS(Check, Opts, Code)                         \
+  EXPECT_EQ(Code, runCheckOnCode<Check>(Code, nullptr, "input.cc", None, Opts))
+TEST(BracesAroundStatementsCheckTest, ImplicitCastInReturn) {
+  ClangTidyOptions Opts;
+  Opts.CheckOptions["test-check-0.ShortStatementLines"] = "1";
+
+  EXPECT_NO_CHANGES_WITH_OPTS(BracesAroundStatementsCheck, Opts,
+                              "const char *f() {\n"
+                              "  if (true) return \"\";\n"
+                              "  return \"abc\";\n"
+                              "}\n");
+}
+
 } // namespace test
 } // namespace tidy
 } // namespace clang