[WIP][clang] Use RecoveryExpr to suppress secondary diagnostics for typo correction.

clang/lib/Sema/SemaExpr.cpp

return new (Context)
       ObjCAvailabilityCheckExpr(Version, AtLoc, RParen, Context.BoolTy);
 }
 
 ExprResult Sema::CreateRecoveryExpr(SourceLocation Begin, SourceLocation End,
                                     ArrayRef<Expr *> SubExprs, QualType T) {
   if (!Context.getLangOpts().RecoveryAST)
     return ExprError();
 
-  if (isSFINAEContext())
-    return ExprError();
-
   if (T.isNull() || !Context.getLangOpts().RecoveryASTType)
     // We don't know the concrete type, fallback to dependent type.
     T = Context.DependentTy;
   return RecoveryExpr::Create(Context, T, Begin, End, SubExprs);
 }

clang/lib/Sema/SemaExprCXX.cpp

static ExprResult attemptRecovery(Sema &SemaRef,
   CXXScopeSpec NewSS;
 
   // Use an approprate CXXScopeSpec for building the expr.
   if (auto *NNS = TC.getCorrectionSpecifier())
     NewSS.MakeTrivial(SemaRef.Context, NNS, TC.getCorrectionRange());
   else if (SS && !TC.WillReplaceSpecifier())
     NewSS = *SS;
 
+  auto Finish = [&](ExprResult R) {
+    if (!R.get())
+      return R;
+    return SemaRef.CreateRecoveryExpr(R.get()->getBeginLoc(),
+                                      R.get()->getEndLoc(), {R.get()});
+  };
   if (auto *ND = TC.getFoundDecl()) {
     R.setLookupName(ND->getDeclName());
     R.addDecl(ND);
     if (ND->isCXXClassMember()) {
       // Figure out the correct naming class to add to the LookupResult.
       CXXRecordDecl *Record = nullptr;
       if (auto *NNS = TC.getCorrectionSpecifier())
         Record = NNS->getAsType()->getAsCXXRecordDecl();
if (ND->isCXXClassMember()) {
       else if (R.isUnresolvableResult())
         MightBeImplicitMember = true;
       else
         MightBeImplicitMember = isa<FieldDecl>(ND) ||
                                 isa<IndirectFieldDecl>(ND) ||
                                 isa<MSPropertyDecl>(ND);
 
       if (MightBeImplicitMember)
-        return SemaRef.BuildPossibleImplicitMemberExpr(
+        return Finish(SemaRef.BuildPossibleImplicitMemberExpr(
             NewSS, /*TemplateKWLoc*/ SourceLocation(), R,
-            /*TemplateArgs*/ nullptr, /*S*/ nullptr);
+            /*TemplateArgs*/ nullptr, /*S*/ nullptr));
     } else if (auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
-      return SemaRef.LookupInObjCMethod(R, Consumer.getScope(),
-                                        Ivar->getIdentifier());
+      return Finish(SemaRef.LookupInObjCMethod(R, Consumer.getScope(),
+                                               Ivar->getIdentifier()));
     }
   }
 
-  return SemaRef.BuildDeclarationNameExpr(NewSS, R, /*NeedsADL*/ false,
+  auto RE = SemaRef.BuildDeclarationNameExpr(NewSS, R, /*NeedsADL*/ false,
                                              /*AcceptInvalidDecl*/ true);
+  return Finish(RE);
 }
 
 namespace {
 class FindTypoExprs : public RecursiveASTVisitor<FindTypoExprs> {
   llvm::SmallSetVector<TypoExpr *, 2> &TypoExprs;
 
 public:
   explicit FindTypoExprs(llvm::SmallSetVector<TypoExpr *, 2> &TypoExprs)

clang/test/Modules/submodules-merge-defs.cpp

 int pre_ff = F<int>().f(); // expected-error +{{must be declared}}
 int pre_fg = F<int>().g<int>(); // expected-error +{{must be declared}}
 // expected-note@defs.h:34 +{{here}}
 
 G::A pre_ga // expected-error +{{must be declared}}
   = G::a; // expected-error +{{must be declared}}
 // expected-note@defs.h:49 +{{here}}
 // expected-note@defs.h:50 +{{here}}
-decltype(G::h) pre_gh = G::h; // expected-error +{{must be declared}} expected-error +{{must be defined}}
+decltype(G::h) pre_gh = G::h; // expected-error +{{must be declared}}
 // expected-note@defs.h:51 +{{here}}
 
 int pre_h = H(); // expected-error +{{must be declared}}
 // expected-note@defs.h:56 +{{here}}
 using pre_i = I<>; // expected-error +{{must be declared}} expected-error +{{default argument of 'I' must be defined}}
 // expected-note@defs.h:57 +{{here}}
 
 J<> pre_j; // expected-error {{'J' must be declared}}

clang/test/Sema/PR28181.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 struct spinlock_t {
   int lock;
 } audit_skb_queue;
 
 void fn1() {
   audit_skb_queue = (lock); // expected-error {{use of undeclared identifier 'lock'; did you mean 'long'?}}
-}                           // expected-error@-1 {{assigning to 'struct spinlock_t' from incompatible type '<overloaded function type>'}}
+}
 
 void fn2() {
   audit_skb_queue + (lock); // expected-error {{use of undeclared identifier 'lock'; did you mean 'long'?}}
-}                           // expected-error@-1 {{reference to overloaded function could not be resolved; did you mean to call it?}}
+}

clang/test/Sema/typo-correction-ambiguity.cpp

 
 void testAmbiguousNoSuggestions()
 {
   AmbiguousCorrection::method_Ace(); // expected-error {{no member named 'method_Ace' in namespace 'AmbiguousCorrection'}}
 }
 
 namespace MultipleCorrectionsButNotAmbiguous
 {
-  int PrefixType_Name(int value);  // expected-note {{'PrefixType_Name' declared here}}
+  int PrefixType_Name(int value);
   int PrefixType_MIN();
   int PrefixType_MAX();
 };
 
 int testMultipleCorrectionsButNotAmbiguous() {
-  int val = MultipleCorrectionsButNotAmbiguous::PrefixType_Enum(0);  // expected-error {{no member named 'PrefixType_Enum' in namespace 'MultipleCorrectionsButNotAmbiguous'; did you mean 'PrefixType_Name'?}}
+  int val = MultipleCorrectionsButNotAmbiguous::PrefixType_Enum(0);  // expected-error {{no member named 'PrefixType_Enum' in namespace 'MultipleCorrectionsButNotAmbiguous'}}
   return val;
 }

clang/test/Sema/typo-correction-no-hang.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 // From `test/Sema/typo-correction.c` but for C++ since the behavior varies
 // between the two languages.
 struct rdar38642201 {
   int fieldName;
 };
 
 void rdar38642201_callee(int x, int y);
 void rdar38642201_caller() {
-  struct rdar38642201 structVar;
+  struct rdar38642201 structVar; // expected-note 2{{'structVar' declared here}}
   rdar38642201_callee(
-      structVar1.fieldName1.member1,  //expected-error{{use of undeclared identifier 'structVar1'}}
-      structVar2.fieldName2.member2); //expected-error{{use of undeclared identifier 'structVar2'}}
+      structVar1.fieldName1.member1,  //expected-error{{use of undeclared identifier 'structVar1'; did you mean 'structVar'}}
+      structVar2.fieldName2.member2); //expected-error{{use of undeclared identifier 'structVar2'; did you mean 'structVar'}}
 }
 
 // Similar reproducer.
 class A {
 public:
   int minut() const = delete;
   int hour() const = delete;
 

clang/test/Sema/typo-correction.c

void PR21656() {
   x = (float)arst;  // expected-error-re {{use of undeclared identifier 'arst'{{$}}}}
 }
 
 a = b ? : 0;  // expected-warning {{type specifier missing, defaults to 'int'}} \
               // expected-error {{use of undeclared identifier 'b'}}
 
 int foobar;  // expected-note {{'foobar' declared here}}
 new_a = goobar ?: 4; // expected-warning {{type specifier missing, defaults to 'int'}} \
-                      // expected-error {{use of undeclared identifier 'goobar'; did you mean 'foobar'?}} \
-                      // expected-error {{initializer element is not a compile-time constant}}
+                     // expected-error {{use of undeclared identifier 'goobar'; did you mean 'foobar'?}}
 
 struct ContainerStuct {
   enum { SOME_ENUM }; // expected-note {{'SOME_ENUM' declared here}}
 };
 
 void func(int arg) {
   switch (arg) {
   case SOME_ENUM_: // expected-error {{use of undeclared identifier 'SOME_ENUM_'; did you mean 'SOME_ENUM'}}

 
 // rdar://problem/38642201
 struct rdar38642201 {
   int fieldName;
 };
 
 void rdar38642201_callee(int x, int y);
 void rdar38642201_caller() {
-  struct rdar38642201 structVar;
+  struct rdar38642201 structVar; // expected-note 2{{'structVar' declared here}}
   rdar38642201_callee(
-      structVar1.fieldName1.member1, //expected-error{{use of undeclared identifier 'structVar1'}}
-      structVar2.fieldName2.member2); //expected-error{{use of undeclared identifier 'structVar2'}}
+      structVar1.fieldName1.member1, //expected-error{{use of undeclared identifier 'structVar1'; did you mean 'structVar'}}
+      structVar2.fieldName2.member2); //expected-error{{use of undeclared identifier 'structVar2'; did you mean 'structVar'}}
 }
 
 void PR40286_g(int x, int y);
 void PR40286_h(int x, int y, int z);
-void PR40286_1(int the_value) {
-  PR40286_g(the_walue); // expected-error {{use of undeclared identifier 'the_walue'}}
+void PR40286_1(int the_value) { // expected-note {{'the_value' declared here}}
+  PR40286_g(the_walue); // expected-error {{use of undeclared identifier 'the_walue'; did you mean 'the_value'}}
 }
-void PR40286_2(int the_value) {
-  PR40286_h(the_value, the_walue); // expected-error {{use of undeclared identifier 'the_walue'}}
+void PR40286_2(int the_value) { // expected-note {{'the_value' declared here}}
+  PR40286_h(the_value, the_walue); // expected-error {{use of undeclared identifier 'the_walue'; did you mean 'the_value'}}
 }
-void PR40286_3(int the_value) {
-  PR40286_h(the_walue); // expected-error {{use of undeclared identifier 'the_walue'}}
+void PR40286_3(int the_value) { // expected-note {{'the_value' declared here}}
+  PR40286_h(the_walue); // expected-error {{use of undeclared identifier 'the_walue'; did you mean 'the_value'}}
 }
 void PR40286_4(int the_value) { // expected-note {{'the_value' declared here}}
   PR40286_h(the_value, the_value, the_walue); // expected-error {{use of undeclared identifier 'the_walue'; did you mean 'the_value'?}}
 }

clang/test/Sema/var-redecl.c

float outer12;
       }
     }
   }
 }
 
 void g18(void) { // expected-note{{'g18' declared here}}
   extern int g19;
 }
-int *p=&g19; // expected-error{{use of undeclared identifier 'g19'}} \
-             // expected-warning{{incompatible pointer types}}
+int *p=&g19; // expected-error{{use of undeclared identifier 'g19'}}
 
 // PR3645
 static int a;
 extern int a; // expected-note {{previous declaration is here}}
 int a;  // expected-error {{non-static declaration of 'a' follows static declaration}}
 
 void f(int x) { // expected-note {{previous definition is here}}
   extern int x; // expected-error {{extern declaration of 'x' follows non-extern declaration}}
 }
 
 extern int b[];
 void g20() { extern int b[3]; } // expected-note{{previous declaration is here}}
 void g21() { extern int b[4]; } // expected-error{{redeclaration of 'b' with a different type: 'int [4]' vs 'int [3]'}}

clang/test/SemaCXX/enum-scoped.cpp

 
 namespace N2764 {
   enum class E *x0a; // expected-error {{reference to enumeration must use 'enum' not 'enum class'}}
   enum E2 *x0b; // OK
   enum class E { a, b };
   enum E x1 = E::a; // ok
   enum class E x2 = E::a; // expected-error {{reference to enumeration must use 'enum' not 'enum class'}}
 
-  enum F { a, b };
+  enum F { a, b }; // expected-note {{'N2764::a' declared here}}
   enum F y1 = a; // ok
   enum class F y2 = a; // expected-error {{reference to enumeration must use 'enum' not 'enum class'}}
 
   struct S {
     friend enum class E; // expected-error {{reference to enumeration must use 'enum' not 'enum class'}}
     friend enum class F; // expected-error {{reference to enumeration must use 'enum' not 'enum class'}}
 
     friend enum G {}; // expected-error {{forward reference}} expected-error {{cannot define a type in a friend declaration}}
namespace PR18044 {
   void E::f() {} // expected-error {{does not refer into a class}}
   struct E::S {}; // expected-error {{no struct named 'S'}}
   struct T : E::S {}; // expected-error {{expected class name}}
   enum E::E {}; // expected-error {{no enum named 'E'}}
   int E::*p; // expected-error {{does not point into a class}}
   using E::f; // expected-error {{no member named 'f'}}
 
   using E::a; // expected-error {{using declaration cannot refer to a scoped enumerator}}
-  E b = a; // expected-error {{undeclared}}
+  E b = a; // expected-error {{use of undeclared identifier 'a'; did you mean 'N2764::a'?}}
 }
 
 namespace test11 {
   enum class E { a };
   typedef E E2;
   E2 f1() { return E::a; }
 
   bool f() { return !f1(); } // expected-error {{invalid argument type 'test11::E2' (aka 'test11::E') to unary expression}}
 }
 
 namespace PR35586 {
   enum C { R, G, B };
   enum B { F = (enum C) -1, T}; // this should compile cleanly, it used to assert.
 };

clang/test/SemaCXX/nested-name-spec.cpp

template <int N> struct T1 {
   int a,b,c;
   static const unsigned N1 = N;
   typedef unsigned C1;
 };
 T1<C2::N1> var_1a;
 T1<C2:N1> var_1b;  // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
 template<int N> int F() {}
 int (*X1)() = (B1::B2 ? F<1> : F<2>);
-int (*X2)() = (B1:B2 ? F<1> : F<2>);  // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
+int (*X2)() = (B1:B2 ? F<1> : F<2>);  // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}} \
+                                         expected-note{{'PR18587::X2' declared here}}
 
 // Bit fields + templates
 struct S7a {
   T1<B1::B2>::C1 m1 : T1<B1::B2>::N1;
 };
 struct S7b {
   T1<B1:B2>::C1 m1 : T1<B1::B2>::N1;  // expected-error{{unexpected ':' in nested name specifier; did you mean '::'?}}
 };
int x3 = ns::an_enumeration::X; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}} \
                                   // expected-error{{no member named 'X'}}
 
   enum enumerator_2 {
     ENUMERATOR_2
   };
 
   int x4 = enumerator_2::ENUMERATOR_2; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}}
   int x5 = enumerator_2::X2; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}} \
-                             // expected-error{{no member named 'X2' in 'PR16951::enumerator_2'}}
+                             // expected-error{{no member named 'X2' in 'PR16951::enumerator_2'; did you mean 'PR18587::X2'}}
 
 }
 
 namespace PR30619 {
 c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d;
 // expected-error@-1 16{{unknown type name 'c'}}
 c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d; c d;
 // expected-error@-1 16{{unknown type name 'c'}}

clang/test/SemaCXX/typo-correction-crash.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++17 -verify %s
 auto check1() {
   return 1;
   return s; // expected-error {{use of undeclared identifier 's'}}
 }
 
 int test = 11; // expected-note 2 {{'test' declared here}}
 auto check2() {
   return "s";
   return tes; // expected-error {{use of undeclared identifier 'tes'; did you mean 'test'?}}
-              // expected-error@-1 {{deduced as 'int' here but deduced as 'const char *' in earlier}}
 }
 
 template <class A, class B> struct is_same { static constexpr bool value = false; };
 template <class A> struct is_same<A,A> { static constexpr bool value = true; };
 
 auto L1 = [] { return s; }; // expected-error {{use of undeclared identifier 's'}}
 using T1 = decltype(L1());
 static_assert(is_same<T1, void>::value, "Return statement should be discarded");
 auto L2 = [] { return tes; }; // expected-error {{use of undeclared identifier 'tes'; did you mean 'test'?}}
 using T2 = decltype(L2());
-static_assert(is_same<T2, int>::value, "Return statement was corrected");
+// FIXME: fix the bogus "undeclared identifier 'T2'" diagnostic.
+static_assert(is_same<T2, int>::value, "Return statement was corrected"); // expected-error {{use of undeclared identifier 'T2'}}
 
 namespace BarNamespace {
 namespace NestedNamespace { // expected-note {{'BarNamespace::NestedNamespace' declared here}}
 typedef int type;
 }
 }
 struct FooRecord { };
 FooRecord::NestedNamespace::type x; // expected-error {{no member named 'NestedNamespace' in 'FooRecord'; did you mean 'BarNamespace::NestedNamespace'?}}

clang/test/SemaCXX/typo-correction-cxx11.cpp

 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
 
 namespace PR23186 {
-decltype(ned);  // expected-error-re {{use of undeclared identifier 'ned'{{$}}}}
+// FIXME: what's going on here? suppress the bogus correction of 'ned' to 'new'
+decltype(ned);  // expected-error {{use of undeclared identifier 'ned'; did you mean 'new'}} expected-warning {{declaration does not declare anything}}
 // The code below was triggering an UNREACHABLE in ASTContext::getTypeInfoImpl
 // once the above code failed to recover properly after making the bogus
 // correction of 'ned' to 'new'.
 template <typename>
 struct S {
   enum { V };
   void f() {
     switch (0)
public:
   pair find(int x);
 };
 
 void run(A *annotations) {
   map new_annotations;
 
   auto &annotation = *annotations;
   auto new_it = new_annotations.find(5);
-  auto &new_anotation = new_it.second;  // expected-note {{'new_anotation' declared here}}
-  new_annotation->Swap(&annotation);  // expected-error {{use of undeclared identifier 'new_annotation'; did you mean 'new_anotation'?}}
+  auto &new_anotation = new_it.second;
+  new_annotation->Swap(&annotation);  // expected-error {{use of undeclared identifier 'new_annotation'}}
 }
 }

clang/test/SemaCXX/typo-correction-delayed.cpp

void UseOverload() {
   // expected-note@+1 {{'result' declared here}}
   const char *result;
   // expected-error@+1 {{use of undeclared identifier 'resulta'; did you mean 'result'?}}
   Overload(resulta);
 }
 
 namespace PR21925 {
 struct X {
-  int get() { return 7; }  // expected-note {{'get' declared here}}
+  int get() { return 7; }
 };
 void test() {
   X variable;  // expected-note {{'variable' declared here}}
 
-  // expected-error@+2 {{use of undeclared identifier 'variableX'; did you mean 'variable'?}}
-  // expected-error@+1 {{no member named 'getX' in 'PR21925::X'; did you mean 'get'?}}
+  // expected-error@+1 {{use of undeclared identifier 'variableX'; did you mean 'variable'?}}
   int x = variableX.getX();
 }
 }
 
 namespace PR21905 {
 int (*a)() = (void)Z; // expected-error-re {{use of undeclared identifier 'Z'{{$}}}} \
                       // expected-error {{cannot initialize a variable of type 'int (*)()' with an rvalue of type 'void'}}
 }
template <unsigned I> void f() {
   // expected-error@+1 {{use of undeclared identifier 'prio_op_array'; did you mean 'prio_bits_array'?}}
   __atomic_store_n(prio_op_array + I, false, __ATOMIC_RELAXED);
 }
 }
 
 namespace PR22297 {
 double pow(double x, double y);
 struct TimeTicks {
-  static void Now();  // expected-note {{'Now' declared here}}
+  static void Now();
 };
 void f() {
-  TimeTicks::now();  // expected-error {{no member named 'now' in 'PR22297::TimeTicks'; did you mean 'Now'?}}
+  // FIXME: should correct to Now.
+  TimeTicks::now();  // expected-error {{no member named 'now' in 'PR22297::TimeTicks'}}
 }
 }
 
 namespace PR23005 {
 void f() { int a = Unknown::b(c); }  // expected-error {{use of undeclared identifier 'Unknown'}}
 // expected-error@-1 {{use of undeclared identifier 'c'}}
 }
 

clang/test/SemaObjC/error-outof-scope-property-use.m

 // RUN: %clang_cc1  -fsyntax-only -verify -Wno-objc-root-class %s
 // RUN: %clang_cc1 -x objective-c++ -fsyntax-only -verify -Wno-objc-root-class %s
 // rdar://13178483
 
-@class NSMutableDictionary; // expected-note {{receiver is instance of class declared here}}
+@class NSMutableDictionary;
 
 @interface LaunchdJobs 
 
 @property (nonatomic,retain) NSMutableDictionary *uuids_jobs; // expected-note {{'_uuids_jobs' declared here}}
 
 @end
 
 @implementation LaunchdJobs
 
 -(void)job
 {
 
- [uuids_jobs objectForKey]; // expected-error {{use of undeclared identifier 'uuids_jobs'}} \
-                            // expected-warning {{instance method '-objectForKey' not found}}
+ [uuids_jobs objectForKey]; // expected-error {{use of undeclared identifier 'uuids_jobs'}}
 }
 
 
 @end
 
 void
 doLaunchdJobCPU()
 {
  [uuids_jobs enumerateKeysAndObjectsUsingBlock]; // expected-error {{use of undeclared identifier 'uuids_jobs'}}
 }

clang/test/SemaObjCXX/block-for-lambda-conversion.mm

 // RUN: %clang_cc1 -fsyntax-only -fblocks -verify -std=c++11 %s
 
 enum NSEventType {
   NSEventTypeFlagsChanged = 12
 };
 
 enum NSEventMask {
   NSEventMaskLeftMouseDown = 1
 };
 
-static const NSEventType NSFlagsChanged = NSEventTypeFlagsChanged;
+static const NSEventType NSFlagsChanged = NSEventTypeFlagsChanged; // expected-note {{declared here}}
 
 @interface NSObject
 @end
 @interface NSEvent : NSObject {
 }
 + (nullable id)
 addMonitor:(NSEventMask)mask handler:(NSEvent *_Nullable (^)(NSEvent *))block;
 @end
 
 void test(id weakThis) {
   id m_flagsChangedEventMonitor = [NSEvent
-      addMonitor:NSFlagsChangedMask //expected-error {{use of undeclared identifier 'NSFlagsChangedMask'}}
+      addMonitor:NSFlagsChangedMask // expected-error {{use of undeclared identifier 'NSFlagsChangedMask'; did you mean 'NSFlagsChanged'?}}
          handler:[weakThis](NSEvent *flagsChangedEvent) {
              return flagsChangedEvent;
          }];
 }