[AST][RecoveryExpr] Don't preserve the return type if the FunctionDecl is invalid.

[hokein]

Summary

If a functionDecl is invalid (e.g. return type cannot be formed), int is
use as he fallback type, which may lead to some bogus diagnostics.

clang/lib/Sema/SemaOverload.cpp

 // Guess at what the return type for an unresolvable overload should be.
 static QualType chooseRecoveryType(OverloadCandidateSet &CS,
                                    OverloadCandidateSet::iterator *Best) {
   llvm::Optional<QualType> Result;
   // Adjust Type after seeing a candidate.
   auto ConsiderCandidate = [&](const OverloadCandidate &Candidate) {
     if (!Candidate.Function)
       return;
+    if (Candidate.Function->isInvalidDecl())
+      return;
     QualType T = Candidate.Function->getReturnType();
     if (T.isNull())
       return;
     if (!Result)
       Result = T;
     else if (Result != T)
       Result = QualType();
   };

clang/test/SemaCXX/recovery-expr-type.cpp

constexpr auto x2 = AA<int>::foo2(); // expected-error {{be initialized by a constant expression}} \
                                      // expected-note {{in call to}}
 }
 
 // verify no assertion failure on violating value category.
 namespace test4 {
 int &&f(int);  // expected-note {{candidate function not viable}}
 int &&k = f(); // expected-error {{no matching function for call}}
 }
+
+// verify that "type 'double' cannot bind to a value of unrelated type 'int'" diagnostic is suppressed.
+namespace test5 {
+  template<typename T> using U = T; // expected-note {{template parameter is declared here}}
+  template<typename...Ts> U<Ts...>& f(); // expected-error {{pack expansion used as argument for non-pack parameter of alias template}}
+  double &s1 = f(); // expected-error {{no matching function}}
+}