[AST][RecoveryExpr] Preserve type for broken member call expr.

[hokein]

clang/lib/Sema/SemaOverload.cpp

14105

It is a bit sad that the broken function call cases (too many/few agguments) are failing into this group, all candidates are not viable -- this means we don't get any benefits (no Best), for some cases, it is suboptimal even though the best candidate looks like obvious.

class Collection {
  const char *find(int) const;
  char* find(int);
};
void test1(const Collection &C) {
 C.find(); // we want const char*, but all overloads are not viable and return types are not the same, so no type captured here.
}

[sammccall]

clang/lib/Sema/SemaOverload.cpp

14083

seems like bool Success = false would be a "safer" default and have to be set in fewer places

14105

Yeah, at some point we can add more heuristics (discard non-viable or hidden functions using heuristics) to handle this case, like I did in SemaCodeComplete...

14133

resolvation -> resolution

clang/test/AST/ast-dump-recovery.cpp

123

why does this not work?
isn't there only one candidate, so chooseRecoveryType should pick it?

[sammccall]

@hokein Did this get landed at some point?

[hokein]

rebase and address comments.

[hokein]

sorry for the delay, picking it up now.

clang/lib/Sema/SemaCoroutine.cpp

864 ↗

(On Diff #308267)

we need this change to prevent a regression on co_await-range-for.

without this change, we will emit 2 call to deleted member function 'await_transform' diagnostics on https://github.com/llvm/llvm-project/blob/master/clang/test/SemaCXX/co_await-range-for.cpp#L52-L54.

clang/test/AST/ast-dump-recovery.cpp

123

this is on a different codepath, will fix in https://reviews.llvm.org/D92298

[hokein]

rebase

clang/lib/Sema/SemaOverload.cpp

for (UnresolvedMemberExpr::decls_iterator I = UnresExpr->decls_begin(),
       }
     }
 
     DeclarationName DeclName = UnresExpr->getMemberName();
 
     UnbridgedCasts.restore();
 
     OverloadCandidateSet::iterator Best;
+    bool Succeeded = true;
     switch (CandidateSet.BestViableFunction(*this, UnresExpr->getBeginLoc(),
                                             Best)) {
     case OR_Success:
       Method = cast<CXXMethodDecl>(Best->Function);
       FoundDecl = Best->FoundDecl;
       CheckUnresolvedMemberAccess(UnresExpr, Best->FoundDecl);
-      if (DiagnoseUseOfDecl(Best->FoundDecl, UnresExpr->getNameLoc()))
-        return ExprError();
+      if (DiagnoseUseOfDecl(Best->FoundDecl, UnresExpr->getNameLoc())) {
+        Succeeded = false;
+        break;
+      }
       // If FoundDecl is different from Method (such as if one is a template
       // and the other a specialization), make sure DiagnoseUseOfDecl is
       // called on both.
       // FIXME: This would be more comprehensively addressed by modifying
       // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
       // being used.
       if (Method != FoundDecl.getDecl() &&
                       DiagnoseUseOfDecl(Method, UnresExpr->getNameLoc()))
-        return ExprError();
+        Succeeded = false;
       break;
 
     case OR_No_Viable_Function:
       CandidateSet.NoteCandidates(
           PartialDiagnosticAt(
               UnresExpr->getMemberLoc(),
               PDiag(diag::err_ovl_no_viable_member_function_in_call)
                   << DeclName << MemExprE->getSourceRange()),
           *this, OCD_AllCandidates, Args);
-      // FIXME: Leaking incoming expressions!
-      return ExprError();
+      Succeeded = false;
+      break;
 
     case OR_Ambiguous:
       CandidateSet.NoteCandidates(
           PartialDiagnosticAt(UnresExpr->getMemberLoc(),
                               PDiag(diag::err_ovl_ambiguous_member_call)
                                   << DeclName << MemExprE->getSourceRange()),
           *this, OCD_AmbiguousCandidates, Args);
-      // FIXME: Leaking incoming expressions!
-      return ExprError();
+      Succeeded = false;
+      break;
 
     case OR_Deleted:
       CandidateSet.NoteCandidates(
           PartialDiagnosticAt(UnresExpr->getMemberLoc(),
                               PDiag(diag::err_ovl_deleted_member_call)
                                   << DeclName << MemExprE->getSourceRange()),
           *this, OCD_AllCandidates, Args);
-      // FIXME: Leaking incoming expressions!
-      return ExprError();
+      Succeeded = false;
+      break;
     }
+    // Overload resolvation fails, try to recover.
+    if (!Succeeded)
+      return CreateRecoveryExpr(MemExprE->getBeginLoc(), MemExprE->getEndLoc(),
+                                {MemExprE},
+                                chooseRecoveryType(CandidateSet, &Best));
 
     MemExprE = FixOverloadedFunctionReference(MemExprE, FoundDecl, Method);
 
     // If overload resolution picked a static member, build a
     // non-member call based on that function.
     if (Method->isStatic()) {
       return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args,
                                    RParenLoc);

clang/test/AST/ast-dump-recovery.cpp

 // CHECK-NEXT:  | `-DeclRefExpr {{.*}} 'foo'
 // CHECK-NEXT:  `-DeclRefExpr {{.*}} 'x'
 struct Foo {} foo;
 void test(int x) {
   foo.abc;
   foo->func(x);
 }
 
+// CHECK:      FunctionDecl {{.*}} test2
+// CHECK-NEXT: |-ParmVarDecl {{.*}} f
+// CHECK-NEXT: `-CompoundStmt
+// CHECK-NEXT:   |-RecoveryExpr {{.*}} 'int' contains-errors
+// CHECK-NEXT:     `-UnresolvedMemberExpr
+// CHECK-NEXT:       `-DeclRefExpr {{.*}} 'Foo2'
+// CHECK-NEXT:   `-RecoveryExpr {{.*}} '<dependent type>'
+// CHECK-NEXT:     |-MemberExpr {{.*}} '<bound member function type>'
+// CHECK-NEXT:     | `-DeclRefExpr {{.*}}
+// CHECK-NEXT:   `-IntegerLiteral {{.*}} 'int' 1
+struct Foo2 {
+  int overload(int);
+  int overload(int, int);
+
+  double func();
+};
+void test2(Foo2 f) {
+  f.overload(); // verify "int" is preserved
+
+  // FIXME: capture the type!
+  f.func(1);
+}
+
 // CHECK:     |-AlignedAttr {{.*}} alignas
 // CHECK-NEXT:| `-RecoveryExpr {{.*}} contains-errors
 // CHECK-NEXT:|   `-UnresolvedLookupExpr {{.*}} 'invalid'
 struct alignas(invalid()) Aligned {};
 
 void InvalidInitalizer(int x) {
   struct Bar { Bar(); };
   // CHECK:     `-VarDecl {{.*}} a1 'Bar'