[clang-tidy] Simplify braced init check

[steveire]

Summary

The normalization of matchers means that this now works in all language
modes.

clang-tools-extra/clang-tidy/modernize/ReturnBracedInitListCheck.h

 public:
   ReturnBracedInitListCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
     return LangOpts.CPlusPlus11;
   }
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_RETURN_BRACED_INIT_LIST_H

clang-tools-extra/clang-tidy/modernize/ReturnBracedInitListCheck.cpp

 namespace tidy {
 namespace modernize {
 
 void ReturnBracedInitListCheck::registerMatchers(MatchFinder *Finder) {
   // Skip list initialization and constructors with an initializer list.
   auto ConstructExpr =
       cxxConstructExpr(
           unless(anyOf(hasDeclaration(cxxConstructorDecl(isExplicit())),
-                       isListInitialization(), hasDescendant(initListExpr()),
-                       isInTemplateInstantiation())))
+                       isListInitialization(), hasDescendant(initListExpr()))))
           .bind("ctor");
 
-  auto CtorAsArgument = materializeTemporaryExpr(anyOf(
-      has(ConstructExpr), has(cxxFunctionalCastExpr(has(ConstructExpr)))));
-
   Finder->addMatcher(
-      traverse(TK_AsIs,
-               functionDecl(
-                   isDefinition(), // Declarations don't have return statements.
-                   returns(unless(anyOf(builtinType(), autoType()))),
-                   hasDescendant(returnStmt(hasReturnValue(
-                       has(cxxConstructExpr(has(CtorAsArgument)))))))
-                   .bind("fn")),
+      returnStmt(hasReturnValue(ConstructExpr),
+                 forFunction(functionDecl(returns(unless(anyOf(builtinType(),
+                                                               autoType()))))
+                                 .bind("fn"))),
       this);
 }
 
 void ReturnBracedInitListCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MatchedFunctionDecl = Result.Nodes.getNodeAs<FunctionDecl>("fn");
   const auto *MatchedConstructExpr =
       Result.Nodes.getNodeAs<CXXConstructExpr>("ctor");
 

clang-tools-extra/test/clang-tidy/checkers/modernize-return-braced-init-list.cpp

-// RUN: %check_clang_tidy -std=c++14 %s modernize-return-braced-init-list %t
-// FIXME: Fix the checker to work in C++17 mode.
+// RUN: %check_clang_tidy -std=c++14-or-later %s modernize-return-braced-init-list %t
 
 namespace std {
 typedef decltype(sizeof(int)) size_t;
 
 // libc++'s implementation
 template <class _E>
 class initializer_list {
   const _E *__begin_;