Use C++14-style return type deduction in clang.

[jlebar]

Summary

Simplifies the C++11-style "-> decltype(...)" return-type deduction.

Note that you have to be careful about whether the function return type
is auto or decltype(auto). The difference is that bare auto
strips const and reference, just like lambda return type deduction. In
some cases that's what we want (or more likely, we know that the return
type is a value type), but whenever we're wrapping a templated function
which might return a reference, we need to be sure that the return type
is decltype(auto).

No functional change.

[bkramer]

lg

clang/lib/AST/ASTImporter.cpp

template <typename T> T importChecked(Error &Err, const T &From) {
         Err = MaybeVal.takeError();
         return T{};
       }
       return *MaybeVal;
     }
 
     // Wrapper for an overload set.
     template <typename ToDeclT> struct CallOverloadedCreateFun {
-      template <typename... Args>
-      auto operator()(Args &&... args)
-          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
+      template <typename... Args> decltype(auto) operator()(Args &&... args) {
         return ToDeclT::Create(std::forward<Args>(args)...);
       }
     };
 
     // Always use these functions to create a Decl during import. There are
     // certain tasks which must be done after the Decl was created, e.g. we
     // must immediately register that as an imported Decl.  The parameter `ToD`
     // will be set to the newly created Decl or if had been imported before

clang/lib/StaticAnalyzer/Checkers/GCDAntipatternChecker.cpp

 
 class GCDAntipatternChecker : public Checker<check::ASTCodeBody> {
 public:
   void checkASTCodeBody(const Decl *D,
                         AnalysisManager &AM,
                         BugReporter &BR) const;
 };
 
-auto callsName(const char *FunctionName)
-    -> decltype(callee(functionDecl())) {
+decltype(auto) callsName(const char *FunctionName) {
   return callee(functionDecl(hasName(FunctionName)));
 }
 
-auto equalsBoundArgDecl(int ArgIdx, const char *DeclName)
-    -> decltype(hasArgument(0, expr())) {
+decltype(auto) equalsBoundArgDecl(int ArgIdx, const char *DeclName) {
   return hasArgument(ArgIdx, ignoringParenCasts(declRefExpr(
                                  to(varDecl(equalsBoundNode(DeclName))))));
 }
 
-auto bindAssignmentToDecl(const char *DeclName) -> decltype(hasLHS(expr())) {
+decltype(auto) bindAssignmentToDecl(const char *DeclName) {
   return hasLHS(ignoringParenImpCasts(
                          declRefExpr(to(varDecl().bind(DeclName)))));
 }
 
 /// The pattern is very common in tests, and it is OK to use it there.
 /// We have to heuristics for detecting tests: method name starts with "test"
 /// (used in XCTest), and a class name contains "mock" or "test" (used in
 /// helpers which are not tests themselves, but used exclusively in tests).

clang/lib/StaticAnalyzer/Checkers/OSObjectCStyleCast.cpp

BR.EmitBasicReport(
     Checker,
     /*Name=*/"OSObject C-Style Cast",
     /*BugCategory=*/"Security",
     OS.str(),
     PathDiagnosticLocation::createBegin(CE, BR.getSourceManager(), ADC),
     CE->getSourceRange());
 }
 
-static auto hasTypePointingTo(DeclarationMatcher DeclM)
-    -> decltype(hasType(pointerType())) {
+static decltype(auto) hasTypePointingTo(DeclarationMatcher DeclM) {
   return hasType(pointerType(pointee(hasDeclaration(DeclM))));
 }
 
 void OSObjectCStyleCastChecker::checkASTCodeBody(const Decl *D, AnalysisManager &AM,
                                                  BugReporter &BR) const {
 
   AnalysisDeclContext *ADC = AM.getAnalysisDeclContext(D);
 

clang/lib/StaticAnalyzer/Checkers/ObjCAutoreleaseWriteChecker.cpp

std::vector<std::string> FunctionsWithAutoreleasingPool = {
       "dispatch_async", "dispatch_group_async", "dispatch_barrier_async"};
 };
 }
 
 static inline std::vector<llvm::StringRef> toRefs(std::vector<std::string> V) {
   return std::vector<llvm::StringRef>(V.begin(), V.end());
 }
 
-static auto callsNames(std::vector<std::string> FunctionNames)
-    -> decltype(callee(functionDecl())) {
+static decltype(auto) callsNames(std::vector<std::string> FunctionNames) {
   return callee(functionDecl(hasAnyName(toRefs(FunctionNames))));
 }
 
 static void emitDiagnostics(BoundNodes &Match, const Decl *D, BugReporter &BR,
                             AnalysisManager &AM,
                             const ObjCAutoreleaseWriteChecker *Checker) {
   AnalysisDeclContext *ADC = AM.getAnalysisDeclContext(D);
 

clang/lib/StaticAnalyzer/Checkers/PointerSortingChecker.cpp

static void emitDiagnostics(const BoundNodes &Match, const Decl *D,
   OS << "Sorting pointer-like elements "
      << "can result in non-deterministic ordering";
 
   BR.EmitBasicReport(ADC->getDecl(), Checker,
                      "Sorting of pointer-like elements", "Non-determinism",
                      OS.str(), Location, Range);
 }
 
-auto callsName(const char *FunctionName) -> decltype(callee(functionDecl())) {
+decltype(auto) callsName(const char *FunctionName) {
   return callee(functionDecl(hasName(FunctionName)));
 }
 
 // FIXME: Currently we simply check if std::sort is used with pointer-like
 // elements. This approach can have a big false positive rate. Using std::sort,
 // std::unique and then erase is common technique for deduplicating a container
 // (which in some cases might even be quicker than using, let's say std::set).
 // In case a container contains arbitrary memory addresses (e.g. multiple