[clang][sema] Note decl location on missing member

[tbaeder]

Summary

Hi,

when trying to access a member of a namespace/class/struct/enum, clang currently just prints that the given namespace does not have a member with the given name, for example:

./enum.cpp:12:7: error: no member named 'b' in 'Foo'
  foo.b = 10;
  ~~~ ^
1 error generated.

However, for programmers it is usually also important to know where the namespace has been declared, e.g. in the example above it would be useful to know where foo's type has been declared. The following patch adds support for this by simply printing a note:

./enum.cpp:12:7: error: no member named 'b' in 'Foo'
  foo.b = 10;
  ~~~ ^
./enum.cpp:3:7: note: 'Foo' declared here
class Foo {
      ^~~
1 error generated.

That is of course a very simple example, but I think this adds value in real-world scenarios.

The patch is unfortunately all over the place and mostly updating test cases with the additional expected note.

In addition to the usual review I'd like opinions on the following open questions:

• There are now three places where the patch adds the exact same code, would a helper function (in Sema?) be better and if so, where is the best place for it?
• The notes are pretty clunky to read when the namespace is created by a lambda: " note: '(lambda at enum.cpp:41:12)' declared here" - should lambdas simply be ignored (how to do that?) or should I handle them differently?
• The patch only emits the note if clang does not output a typo correction. I thought it might not be as useful in this case since it would clutter the output and chances are that the typo fix _is_ the right thing to show. Opinions on this?

Thanks,
Timm

[tbaeder]

Forgot clang-format of course, sorry.

[tbaeder]

Answered one of my questions by adding a new function directly to Sema.

[tbaeder]

Fixed the Lambda oddity as well.

[tbaeder]

Any update on this?

[aaron.ballman]

In D95536#2551332, @tbaeder wrote:

Any update on this?

Thank you for the patch! Do you have some motivating examples of when this would really add clarity to the diagnostic? I'm not opposed to the patch per se, but I'm a bit wary about adding an additional note because that makes the diagnostic output seem that much longer, which makes the salient diagnostics a bit harder to find (colorization in the terminal helps with this, though).

The patch only emits the note if clang does not output a typo correction. I thought it might not be as useful in this case since it would clutter the output and chances are that the typo fix _is_ the right thing to show. Opinions on this?

I think that makes sense -- the typo correction already has a note that points to somewhere which is likely to get the user into the right area anyway: https://godbolt.org/z/1Yo3Pj

clang/include/clang/Sema/Sema.h

9795

clang/lib/Sema/Sema.cpp

2549

2553

2557–2560

[tbaeder]

In D95536#2552258, @aaron.ballman wrote:

In D95536#2551332, @tbaeder wrote:

Any update on this?

Thank you for the patch! Do you have some motivating examples of when this would really add clarity to the diagnostic? I'm not opposed to the patch per se, but I'm a bit wary about adding an additional note because that makes the diagnostic output seem that much longer, which makes the salient diagnostics a bit harder to find (colorization in the terminal helps with this, though).

I run into this a lot when looking into a larger, new code base. When adding new code, I often look at surrounding code and infer how e.g. an enum member is called. Take https://godbolt.org/z/Tcoxf5 for example, I could've seen code using OsType::Unix and inferred that the OsType for Windows will be called OsType::Windows, but it's Win32. The next step for me as a human is of course to grep the source code for the declaration of OsType and check the members. (On the other hand, a "Foo is not a member of enum FooEnum, existing members are: Bar1, Bar2, Bar3, ..." diagnostic would probably be more useful. But that has its own drawbacks).

[aaron.ballman]

In D95536#2553325, @tbaeder wrote:

In D95536#2552258, @aaron.ballman wrote:

In D95536#2551332, @tbaeder wrote:

Any update on this?

Thank you for the patch! Do you have some motivating examples of when this would really add clarity to the diagnostic? I'm not opposed to the patch per se, but I'm a bit wary about adding an additional note because that makes the diagnostic output seem that much longer, which makes the salient diagnostics a bit harder to find (colorization in the terminal helps with this, though).

I run into this a lot when looking into a larger, new code base. When adding new code, I often look at surrounding code and infer how e.g. an enum member is called. Take https://godbolt.org/z/Tcoxf5 for example, I could've seen code using OsType::Unix and inferred that the OsType for Windows will be called OsType::Windows, but it's Win32. The next step for me as a human is of course to grep the source code for the declaration of OsType and check the members. (On the other hand, a "Foo is not a member of enum FooEnum, existing members are: Bar1, Bar2, Bar3, ..." diagnostic would probably be more useful. But that has its own drawbacks).

Hmm... I feel like the diagnostic should already be sufficient to locate the originating location of the class or namespace and the note is adding a bit more (almost, but not quite) noise, but at the same time, I don't feel so strongly that I'd block the patch. I'd like to hear from other reviewers though.

As for some interesting test cases -- I don't think we should issue the note when the diagnostic already appears within the class declaration itself. e.g.,

struct S {
  void func();

  void other(S s) {
    s.foo(); // error, but no need to point to where S is declared
  }
};

Another similar case but involving an anonymous class:

struct S {
  struct {
    void func();
  } t;

  void foo() {
    t.blech(); // Should we do anything about this?
  }
};

A pathological case for C code, which shows another case where I think the note is more noise than anything (not that I expect anyone to ever write this code, so not worth special handling for unless it's fallout from other special handling code that's more useful):

int func(struct S { int a; } s) {
  return s.b;
}

Anonymous namespaces:

namespace foo {
namespace {
  void func();
}
}

void bar() {
  foo::blarg(); // Should point to 'foo'?
}

[tbaeder]

In D95536#2557197, @aaron.ballman wrote:

Hmm... I feel like the diagnostic should already be sufficient to locate the originating location of the class or namespace and the note is adding a bit more (almost, but not quite) noise,

I guess this makes sense when you're talking about https://godbolt.org/z/1Yo3Pj, but I don't understand how I would know where OsType is defined in https://godbolt.org/ in a larger code base (e.g. when using OsType in clang, with it being defined in llvm).

Anonymous namespaces:

namespace foo {
namespace {
  void func();
}
}

void bar() {
  foo::blarg(); // Should point to 'foo'?
}

Seems to work:

./enum.cpp:56:8: error: no member named 'blarg' in namespace 'foo'
  foo::blarg(); // Should point to 'foo'?
  ~~~~~^
./enum.cpp:49:11: note: namespace 'foo' declared here
namespace foo {
          ^~~

You list a few more interesting corner cases however. I'm not sure if I want to pursue this patch further as it is already quite ugly because it's touching all those tests. Or if it would be better to implement a note that lists all enum members (up to a certain threshold?), but just for enums.

[aaron.ballman]

In D95536#2568252, @tbaeder wrote:

In D95536#2557197, @aaron.ballman wrote:

Hmm... I feel like the diagnostic should already be sufficient to locate the originating location of the class or namespace and the note is adding a bit more (almost, but not quite) noise,

I guess this makes sense when you're talking about https://godbolt.org/z/1Yo3Pj, but I don't understand how I would know where OsType is defined in https://godbolt.org/ in a larger code base (e.g. when using OsType in clang, with it being defined in llvm).

I think that the name in the diagnostic should be sufficient for you to track that down using the editor of your choice (including super simple editors like notepad), such as by using a simple search. With that example, when I search for "enum OsType" in my editor, there's only one hit in the code base. Even in slightly more complex cases where you try to make things look ambiguous, the diagnostic text does a pretty good job of making it clear roughly where to look: https://godbolt.org/z/41nPnd

Anonymous namespaces:

namespace foo {
namespace {
  void func();
}
}

void bar() {
  foo::blarg(); // Should point to 'foo'?
}

Seems to work:

./enum.cpp:56:8: error: no member named 'blarg' in namespace 'foo'
  foo::blarg(); // Should point to 'foo'?
  ~~~~~^
./enum.cpp:49:11: note: namespace 'foo' declared here
namespace foo {
          ^~~

You list a few more interesting corner cases however. I'm not sure if I want to pursue this patch further as it is already quite ugly because it's touching all those tests. Or if it would be better to implement a note that lists all enum members (up to a certain threshold?), but just for enums.

I'd be worried that would add even more output that would largely be noise in the common case. My personal preference in this case would be to try to improve the existing diagnostics to be more clear as to what's referenced rather than adding an extra note. However, I won't block the patch based solely on my personal preference if you'd like to continue to pursue this -- I leave the final decision to @rsmith in that case.

[tbaeder]

Abandoning this since it's probably not worth it.

clang/include/clang/Sema/Sema.h

bool CheckObjCBridgeRelatedConversions(SourceLocation Loc,
                                          QualType DestType, QualType SrcType,
                                          Expr *&SrcExpr, bool Diagnose = true);
 
   bool CheckConversionToObjCLiteral(QualType DstType, Expr *&SrcExpr,
                                     bool Diagnose = true);
 
   bool checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall);
 
+  /// Report a Note for an unknown member of the given decl context
+  void reportDeclForUnknownMember(const DeclContext *Ctx);
+
   /// Check whether the given new method is a valid override of the
   /// given overridden method, and set any properties that should be inherited.
   void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod,
                                const ObjCMethodDecl *Overridden);
 
   /// Describes the compatibility of a result type with its method.
   enum ResultTypeCompatibilityKind {
     RTC_Compatible,

clang/lib/Sema/Sema.cpp

return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
                                        QT, OpenCLTypeExtMap);
 }
 
 bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) {
   IdentifierInfo *FnName = D.getIdentifier();
   return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
                                        OpenCLDeclExtMap, 1, D.getSourceRange());
 }
+
+void Sema::reportDeclForUnknownMember(const DeclContext *Ctx) {
+  // Don't report the global scope decl
+  if (isa<TranslationUnitDecl>(Ctx))
+    return;
+
+  // Lambdas already report their declaration location themselves
+  if (isa<CXXRecordDecl>(Ctx) && cast<CXXRecordDecl>(Ctx)->isLambda())
+    return;
+
+  if (const Decl *D = dyn_cast<Decl>(Ctx)) {
+    Diag(D->getLocation(), diag::note_entity_declared_at)
+        << Ctx << D->getLocation();
+  }
+}

clang/lib/Sema/SemaExpr.cpp

static void emitEmptyLookupTypoDiagnostic(
     const TypoCorrection &TC, Sema &SemaRef, const CXXScopeSpec &SS,
     DeclarationName Typo, SourceLocation TypoLoc,
     unsigned DiagnosticID, unsigned DiagnosticSuggestID) {
   DeclContext *Ctx =
       SS.isEmpty() ? nullptr : SemaRef.computeDeclContext(SS, false);
   if (!TC) {
     // Emit a special diagnostic for failed member lookups.
     // FIXME: computing the declaration context might fail here (?)
-    if (Ctx)
+    if (Ctx) {
       SemaRef.Diag(TypoLoc, diag::err_no_member) << Typo << Ctx
                                                  << SS.getRange();
-    else
+
+      SemaRef.reportDeclForUnknownMember(Ctx);
+    } else
       SemaRef.Diag(TypoLoc, DiagnosticID) << Typo;
     return;
   }
 
   std::string CorrectedStr = TC.getAsString(SemaRef.getLangOpts());
   bool DroppedSpecifier =
       TC.WillReplaceSpecifier() && Typo.getAsString() == CorrectedStr;
   unsigned NoteID = TC.getCorrectionDeclAs<ImplicitParamDecl>()

clang/lib/Sema/SemaExprMember.cpp

TE = SemaRef.CorrectTypoDelayed(
           bool DroppedSpecifier =
               TC.WillReplaceSpecifier() &&
               Typo.getAsString() == TC.getAsString(SemaRef.getLangOpts());
           SemaRef.diagnoseTypo(TC, SemaRef.PDiag(diag::err_no_member_suggest)
                                        << Typo << DC << DroppedSpecifier
                                        << SS.getRange());
         } else {
           SemaRef.Diag(TypoLoc, diag::err_no_member) << Typo << DC << BaseRange;
+          SemaRef.reportDeclForUnknownMember(DC);
         }
       },
       [=](Sema &SemaRef, TypoExpr *TE, TypoCorrection TC) mutable {
         LookupResult R(Q.SemaRef, Q.NameInfo, Q.LookupKind, Q.Redecl);
         R.clear(); // Ensure there's no decls lingering in the shared state.
         R.suppressDiagnostics();
         R.setLookupName(TC.getCorrection());
         for (NamedDecl *ND : TC)
if (ExtraArgs) {
           << MemberName << DC << FixItHint::CreateReplacement(OpLoc, "->");
         return RetryExpr;
       }
     }
 
     Diag(R.getNameLoc(), diag::err_no_member)
       << MemberName << DC
       << (BaseExpr ? BaseExpr->getSourceRange() : SourceRange());
+    reportDeclForUnknownMember(DC);
+
     return ExprError();
   }
 
   // Diagnose lookups that find only declarations from a non-base
   // type.  This is possible for either qualified lookups (which may
   // have been qualified with an unrelated type) or implicit member
   // expressions (which were found with unqualified lookup and thus
   // may have come from an enclosing scope).  Note that it's okay for

clang/test/CXX/basic/basic.lookup/basic.lookup.classref/p1-cxx11.cpp

namespace PR11856 {
   void Foo() {
     T it1;
     if (it1->end < it1->end) {
     }
   }
 
   template<typename T> T *end(T*);
 
-  class X { };
+  class X { }; // expected-note {{X' declared here}}
   template <typename T>
   void Foo2() {
     T it1;
     if (it1->end < it1->end) {
     }
 
     X *x;
     if (x->end < 7) {  // expected-error{{no member named 'end' in 'PR11856::X'}}
     }
   }
 }

clang/test/CXX/basic/basic.lookup/basic.lookup.classref/p1.cpp

namespace PR11856 {
   void Foo() {
     T it1;
     if (it1->end < it1->end) {
     }
   }
 
   template<typename T> T *end(T*);
 
-  class X { };
+  class X { }; // expected-note {{X' declared here}}
   template <typename T>
   void Foo2() {
     T it1;
     if (it1->end < it1->end) {
     }
 
     X *x;
     if (x->end < 7) {  // expected-error{{no member named 'end' in 'PR11856::X'}}
     }
   }
 }

clang/test/CXX/class.access/class.friend/p1.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 // C++'0x [class.friend] p1:
 //   A friend of a class is a function or class that is given permission to use
 //   the private and protected member names from the class. A class specifies
 //   its friends, if any, by way of friend declarations. Such declarations give
 //   special access rights to the friends, but they do not make the nominated
 //   friends members of the befriending class.
 
 struct S { static void f(); }; // expected-note 2 {{'S' declared here}}
 S* g() { return 0; } // expected-note 2 {{'g' declared here}}
 
-struct X {
+struct X { // expected-note {{declared here}}
   friend struct S;
   friend S* g();
 };
 
 void test1() {
   S s;
   g()->f();
   S::f();
   X::g(); // expected-error{{no member named 'g' in 'X'; did you mean simply 'g'?}}
   X::S x_s; // expected-error{{no type named 'S' in 'X'; did you mean simply 'S'?}}
   X x;
   x.g(); // expected-error{{no member named 'g' in 'X'}}
 }
 
 // Test that we recurse through namespaces to find already declared names, but
 // new names are declared within the enclosing namespace.
 namespace N {
-  struct X {
+  struct X { // expected-note 2 {{declared here}}
     friend struct S;
     friend S* g();
 
     friend struct S2;
     friend struct S2* g2();
   };
 
   struct S2 { static void f2(); }; // expected-note 2 {{'S2' declared here}}

clang/test/CXX/class/class.mfct/class.mfct.non-static/p3.cpp

template <class T> struct A {
     void test3() {
       C<T>::foo(); // expected-error {{no member named 'foo'}}
     }
   };
 
   template <class T> struct B : A<T> {
   };
 
-  template <class T> struct C {
+  template <class T> struct C { // expected-note {{declared here}}
   };
 
   int test() {
     A<int> a;
     a.test0(); // no instantiation note here, decl is ill-formed
     a.test1();
     a.test2(); // expected-note {{in instantiation}}
     a.test3(); // expected-note {{in instantiation}}
   }
 }

clang/test/CXX/drs/dr1xx.cpp

namespace dr140 { // dr140: yes
   void g(int n) { n = 2; }
 }
 
 namespace dr141 { // dr141: yes
   template<typename T> void f();
   template<typename T> struct S { int n; };
   struct A : S<int> {
     template<typename T> void f();
-    template<typename T> struct S {};
+    template<typename T> struct S {}; // expected-note {{declared here}}
   } a;
-  struct B : S<int> {} b;
+  struct B : S<int> {} b; // expected-note {{B' declared here}}
   void g() {
     a.f<int>();
     (void)a.S<int>::n; // expected-error {{no member named 'n'}}
 #if __cplusplus < 201103L
     // expected-error@-2 {{ambiguous}}
     // expected-note@-11 {{lookup from the current scope}}
     // expected-note@-9 {{lookup in the object type}}
 #endif

clang/test/CXX/drs/dr21xx.cpp

#endif
   int q = A<int>().f() + A<int>().g();
 
   // Corresponding constructs where the address is not taken are not
   // value-dependent.
   template<int N, bool = true> struct Y {};
   template<typename T> struct B {
     static const int n = 1;
     int f() {
-      return Y<n>::declared_later; // expected-error {{no member named 'declared_later'}}
+      return Y<n>::declared_later; // expected-error {{no member named 'declared_later'}} expected-note@-4 {{here}}
     }
     int g() {
       static const int n = 2;
-      return Y<n>::declared_later; // expected-error {{no member named 'declared_later'}}
+      return Y<n>::declared_later; // expected-error {{no member named 'declared_later'}} expected-note@-8 {{here}}
     }
   };
   template<int N> struct Y<N> {
     static const int declared_later = 0;
   };
 }
 
 namespace dr2103 { // dr2103: yes

clang/test/CXX/drs/dr3xx.cpp

void g(B *b) {
     b->~B();
     b->~C();
   }
   void h(B *b) {
     struct B {}; // expected-note {{type 'B' found by destructor name lookup}}
     b->~B(); // expected-error {{does not match}}
   }
 
-  template<typename T> struct X {};
+  template<typename T> struct X {}; // expected-note {{declared here}}
   void i(X<int>* x) {
     struct X {};
     x->~X<int>();
     x->~X();
     x->~X<char>(); // expected-error {{no member named}}
   }
 
 #if __cplusplus >= 201103L
   struct Y {
     template<typename T> using T1 = Y;
   };
   template<typename T> using T2 = Y;
   void j(Y *y) {
     y->~T1<int>();
     y->~T2<int>();
   }
-  struct Z {
+  struct Z { // expected-note {{Z' declared here}}
     template<typename T> using T2 = T;
   };
   void k(Z *z) {
     z->~T1<int>(); // expected-error {{no member named 'T1' in 'dr305::Z'}}
     z->~T2<int>(); // expected-error {{no member named '~int'}}
     z->~T2<Z>();
   }
 
   // FIXME: This is valid.
   namespace Q {
-    template<typename A> struct R {};
+    template<typename A> struct R {}; // expected-note {{declared here}}
   }
   template<typename A> using R = Q::R<int>;
   void qr(Q::R<int> x) { x.~R<char>(); } // expected-error {{no member named}}
 #endif
 }
 
 namespace dr306 { // dr306: dup 39
   struct A { struct B {}; };

clang/test/CXX/drs/dr6xx.cpp

namespace dr642 { // dr642: yes
   void g(int s) {
     struct s *p = new struct s;
     p->a = s;
   }
 }
 
 #if __cplusplus >= 201103L
 namespace dr643 { // dr643: yes
-  struct A {
+  struct A { // expected-note 2 {{declared here}}
     int x;
     auto f() -> decltype(this->x);
     auto f(A &a) -> decltype(a.x);
     auto g() -> decltype(x);
     auto h() -> decltype(this->y); // expected-error {{no member named 'y'}}
     auto h(A &a) -> decltype(a.y); // expected-error {{no member named 'y'}}
     auto i() -> decltype(y); // expected-error {{undeclared identifier 'y'}}
     int y;

clang/test/CXX/module/module.interface/p2.cpp

 int use_header() { return foo + bar::baz(); }
 
 #elif defined(USER)
 import p2;
 import "header.h";
 
 void use() {
   // namespace A is implicitly exported by the export of A::g.
-  A::f(); // expected-error {{no member named 'f' in namespace 'A'}}
+  A::f(); // expected-error {{no member named 'f' in namespace 'A'}} expected-note@23 {{here}}
   A::g();
-  A::h(); // expected-error {{no member named 'h' in namespace 'A'}}
+  A::h(); // expected-error {{no member named 'h' in namespace 'A'}} expected-note@23 {{here}}
   using namespace A::inner; // expected-error {{expected namespace name}}
 
   // namespace B and B::inner are explicitly exported
   using namespace B;
   using namespace B::inner;
-  B::f(); // expected-error {{no member named 'f' in namespace 'B'}}
+  B::f(); // expected-error {{no member named 'f' in namespace 'B'}} expected-note@29 {{here}}
   f(); // expected-error {{undeclared identifier 'f'}}
 
   // namespace C is not exported
   using namespace C; // expected-error {{expected namespace name}}
 
   // namespace D is exported, but D::f is not
-  D::f(); // expected-error {{no member named 'f' in namespace 'D'}}
+  D::f(); // expected-error {{no member named 'f' in namespace 'D'}} expected-note@37 {{here}}
 }
 
 int use_header() { return foo + bar::baz(); }
 
 #else
 #error unknown mode
 #endif

clang/test/CXX/special/class.copy/p28-cxx11.cpp

 // RUN: %clang_cc1 -std=c++98 %s -fsyntax-only
 // RUN: %clang_cc1 -std=c++11 %s -verify
 
 // In C++11, we must perform overload resolution to determine which function is
 // called by a defaulted assignment operator, and the selected operator might
 // not be a copy or move assignment (it might be a specialization of a templated
 // 'operator=', for instance).
-struct A {
+struct A { // expected-note {{declared here}}
   A &operator=(const A &);
 
   template<typename T>
   A &operator=(T &&) { return T::error; } // expected-error {{no member named 'error' in 'A'}}
 };
 
 struct B : A {
   B &operator=(B &&);
 };
 
 B &B::operator=(B &&) = default; // expected-note {{here}}

clang/test/CXX/special/class.dtor/p10-0x.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 // PR10127/N3031
-struct A { ~A(); };
+struct A { ~A(); }; // expected-note 2 {{declared here}}
 struct B {};
 template<typename T>
 void b(const T *x, const A *y) {
   x->~decltype(T())();
   x->~decltype(*x)(); // expected-error{{the type of object expression ('const int') does not match the type being destroyed ('decltype(*x)' (aka 'const int &')) in pseudo-destructor expression}} \
                          expected-error{{no member named '~const A &' in 'A'}}
   x->~decltype(int())(); // expected-error{{no member named '~int' in 'A'}}
 

clang/test/CXX/temp/temp.decls/temp.class/temp.mem.enum/p1.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s
 
-template<typename T> struct A {
+template<typename T> struct A { // expected-note {{here}}
   enum E : T; // expected-note {{here}}
   E v;
   E f() { return A::e1; } // expected-error {{no member named 'e1' in 'A<T>'}}
   E g() { return E::e1; }
   E h();
 };
 
 A<int> a;

 template<> enum class C<long long>::E : long long { e3, e4 };
 C<long long>::E c0 = C<long long>::E::e3;
 
 C<long>::E c1;
 template<> enum class C<long>::E : long { e5 };
 void fc1() { c1 = decltype(c1)::e5; }
 C<long>::E c2 = C<long>::E::e5;
 
-template<> enum class C<int>::E : int { e6 };
+template<> enum class C<int>::E : int { e6 }; // expected-note {{here}}
 template<typename T> enum class C<T>::E : T { e0 };
 C<int>::E c3 = C<int>::E::e6;
 C<int>::E c4 = C<int>::E::e0; // expected-error {{no member named 'e0' in 'C<int>::E'}}
 
 
 // Enumeration members can't be partially-specialized.
 template<typename T> enum class B<T*>::E { e5, e6 }; // expected-error {{nested name specifier for a declaration cannot depend on a template parameter}}
 

clang/test/CXX/temp/temp.res/temp.local/p3.cpp

 // RUN: %clang_cc1 -verify %s
 
 template <class T> struct Base {
   // expected-note@-1 2{{member type 'Base<int>' found by ambiguous name lookup}}
   // expected-note@-2 2{{member type 'Base<char>' found by ambiguous name lookup}}
   static void f();
 }; 
 
-struct X0 { };
+struct X0 { }; // expected-note {{declared here}}
 
 template <class T> struct Derived: Base<int>, Base<char> {
   typename Derived::Base b;  // expected-error{{member 'Base' found in multiple base classes of different types}}
   typename Derived::Base<double> d;  // OK
 
   void g(X0 *t) {
     t->Derived::Base<T>::f();
     t->Base<T>::f();

clang/test/CXX/temp/temp.res/temp.local/p9.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 struct A { 
-  struct B { void f(); }; 
+  struct B { void f(); }; // expected-note {{declared here}}
   int a; 
   int Y;
 };
 
 template<class B, class a> struct X : A { 
   B b;  // A's B 
   a c;  // expected-error{{unknown type name 'a'}} 
 
   void g() {
     b.g(); // expected-error{{no member named 'g' in 'A::B'}}
   }
 };

clang/test/CXX/temp/temp.spec/temp.expl.spec/p19.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 template<typename T>
 struct X {
-  template<typename U> struct Inner { };
+  template<typename U> struct Inner { }; // expected-note {{declared here}}
   
   template<typename U> void f(T, U) { }
 };
 
 template<> template<typename U>
 struct X<int>::Inner {
   U member;
 };

clang/test/Misc/diag-template.cpp

 // RUN: %clang_cc1 -verify %s
 
 namespace default_args {
   template<typename T> struct char_traits;
   template<typename T> struct allocator;
-  template<typename T, typename = char_traits<T>, typename = allocator<T>> struct basic_string {};
+  template<typename T, typename = char_traits<T>, typename = allocator<T>> struct basic_string {}; // expected-note 2 {{declared here}}
 
   typedef basic_string<char> string;
 
   template<typename T> T f(T);
 
   void test1() {
     string s;
     f(s).size(); // expected-error {{no member named 'size' in 'default_args::basic_string<char>'}}
   }
 
   template<typename T> struct default_delete {};
-  template<class T, class Deleter = default_delete<T>> class unique_ptr {
+  template<class T, class Deleter = default_delete<T>> class unique_ptr { // expected-note {{declared here}}
   public:
     void f() { T::error(); } // expected-error {{no member named 'error' in 'default_args::basic_string<char>'}}
   };
   template<class T, class Deleter> class unique_ptr<T[], Deleter> {};
   void test2() {
     unique_ptr<string> ups;
     f(ups).reset(); // expected-error {{no member named 'reset' in 'default_args::unique_ptr<default_args::basic_string<char>>'}}
     f(ups).f(); // expected-note {{in instantiation of member function 'default_args::unique_ptr<default_args::basic_string<char>>::f' requested here}}
   }
 
   template<int A, int B = A> struct Z { int error[B]; }; // expected-error {{negative size}}
   Z<-1> z; // expected-note {{in instantiation of template class 'default_args::Z<-1>' requested here}}
 
-  template<template<typename> class A = allocator, template<typename> class B = A> struct Q {};
+  template<template<typename> class A = allocator, template<typename> class B = A> struct Q {}; // expected-note 6 {{declared here}}
   void test3() {
     f(Q<>()).g(); // expected-error {{no member named 'g' in 'default_args::Q<>'}}
     f(Q<allocator>()).g(); // expected-error {{no member named 'g' in 'default_args::Q<>'}}
     f(Q<allocator, allocator>()).g(); // expected-error {{no member named 'g' in 'default_args::Q<>'}}
     f(Q<char_traits>()).g(); // expected-error {{no member named 'g' in 'default_args::Q<char_traits>'}}
     f(Q<char_traits, char_traits>()).g(); // expected-error {{no member named 'g' in 'default_args::Q<char_traits>'}}
     f(Q<char_traits, allocator>()).g(); // expected-error {{no member named 'g' in 'default_args::Q<char_traits, allocator>'}}
   }
 }

clang/test/Modules/Inputs/redecl_namespaces_left.h

-namespace A {
+namespace A { // expected-note {{here}}
   int i;
 }

clang/test/Modules/cxx-templates.cpp

void g() {
   //
   // We turn off error recovery for modules in this test (so we don't get an
   // implicit import of cxx_templates_b_impl), and that results in us producing
   // a big spew of errors here.
   //
   // expected-error@Inputs/cxx-templates-a.h:19 {{definition of 'DefinedInBImpl' must be imported}}
   // expected-note@Inputs/cxx-templates-b-impl.h:1 +{{definition here is not reachable}}
   // expected-error@Inputs/cxx-templates-a.h:19 +{{}}
+  // expected-note@Inputs/cxx-templates-b-impl.h:1 {{declared here}}
   // expected-error@Inputs/cxx-templates-a.h:20 +{{}}
   PerformDelayedLookup(defined_in_b_impl); // expected-note {{in instantiation of}}
 
   merge_templates_a = merge_templates_b; // ok, same type
 
   using T = decltype(enum_a_from_a);
   using T = decltype(enum_b_from_b);
   T e = true ? enum_a_from_a : enum_b_from_b;

clang/test/Modules/module-private.cpp

int test_broken() {
   Integer i; // expected-error{{unknown type name 'Integer'}}
 
   int *ip = 0;
   f1(ip); // expected-error{{use of undeclared identifier 'f1'}}
 
   vector<int> vec; // expected-error{{no template named 'vector'}}
 
   VisibleStruct vs;
-  vs.field = 0; // expected-error{{no member named 'field' in 'VisibleStruct'}}
-  vs.setField(1); // expected-error{{no member named 'setField' in 'VisibleStruct'}}
+  vs.field = 0; // expected-error{{no member named 'field' in 'VisibleStruct'}} \
+                // expected-note@module_private_right.h:10 {{declared here}}
+  vs.setField(1); // expected-error{{no member named 'setField' in 'VisibleStruct'}} \
+                  // expected-note@module_private_right.h:10 {{declared here}}
 
   return hidden_var; // expected-error{{use of undeclared identifier 'hidden_var'}}
 }
 
 // Check for private redeclarations of public entities.
 template<typename T>
 class public_class_template;
 

clang/test/Modules/redecl-namespaces.mm

 @import redecl_namespaces_left;
 @import redecl_namespaces_right;
 
 void test() {
   A::i;
   A::j;
-  A::k;  // expected-error {{no member named 'k' in namespace 'A'}}
+  A::k;  // expected-error {{no member named 'k' in namespace 'A'}} \
+         // expected-note@redecl_namespaces_left.h:1 {{here}}
 }
 
 // RUN: rm -rf %t
 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -fmodules-cache-path=%t -emit-module -fmodule-name=redecl_namespaces_left %S/Inputs/module.map
 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -x objective-c++ -fmodules-cache-path=%t -emit-module -fmodule-name=redecl_namespaces_right %S/Inputs/module.map
 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs -w %s -verify

clang/test/OpenMP/target_map_messages.cpp

void func(int arg) {
     #pragma omp target map(close bf: a)   // expected-error {{incorrect map type, expected one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'}}
     {}
     #pragma omp target map(([b[I]][bf])f)  // lt50-error {{expected ',' or ']' in lambda capture list}} lt50-error {{expected ')'}} lt50-note {{to match this '('}}
     {}
     return;
   }
 };
 
-struct SB {
+struct SB { // expected-note {{declared here}}
   unsigned A;
   unsigned B;
   float Arr[100];
   float *Ptr;
   float *foo() {
     return &Arr[0];
   }
 };

clang/test/OpenMP/target_teams_map_messages.cpp

void func(int arg) {
     #pragma omp target teams map(always, tofrom: c[:],f)   // expected-error {{section length is unspecified and cannot be inferred because subscripted value is not an array}}
     {}
     #pragma omp target teams map(always, tofrom: c,f[:])   // expected-error {{section length is unspecified and cannot be inferred because subscripted value is not an array}}
     {}
     return;
   }
 };
 
-struct SB {
+struct SB { // expected-note {{declared here}}
   unsigned A;
   unsigned B;
   float Arr[100];
   float *Ptr;
   float *foo() {
     return &Arr[0];
   }
 };

clang/test/PCH/decl-attrs.cpp

 
 #else
 
 namespace preferred_name {
   Z z;
 
   template<typename T> T forget(T t) { return t; }
   void f() {
-    forget(y).foo(); // expected-error {{no member named 'foo' in 'preferred_name::Y'}}
-    forget(z).foo(); // expected-error {{no member named 'foo' in 'preferred_name::Z'}}
+    forget(y).foo(); // expected-error {{no member named 'foo' in 'preferred_name::Y'}} \
+                     // expected-note@11 {{declared here}}
+    forget(z).foo(); // expected-error {{no member named 'foo' in 'preferred_name::Z'}} \
+                     // expected-note@11 {{declared here}}
   }
 }
 
 namespace aligned {
   extern Y1 y1;
   extern Y2 y2;
   static_assert(alignof(Y1) == alignof(Y1*), "");
   static_assert(alignof(Y2) == alignof(Y2*), "");
 }
 
 #endif

clang/test/Parser/recovery.c

 
 
 // PR3172
 } // expected-error {{extraneous closing brace ('}')}}
 
 
 // rdar://6094870
 void test(int a) {
-  struct { int i; } x;
+  struct { int i; } x; // expected-note 3 {{declared here}}
   
   if (x.hello)   // expected-error {{no member named 'hello'}}
     test(0);
   else
     ;
   
   if (x.hello == 0)   // expected-error {{no member named 'hello'}}
     test(0);

clang/test/Parser/recovery.cpp

 }
 int k;
 int l = k // expected-error {{expected ';'}}
 constexpr int foo();
 
 5int m = { l }, n = m; // expected-error {{unqualified-id}}
 
 namespace MissingBrace {
-  struct S { // expected-error {{missing '}' at end of definition of 'MissingBrace::S'}}
+  struct S { // expected-error {{missing '}' at end of definition of 'MissingBrace::S'}} \
+             // expected-note {{declared here}}
     int f();
   // };
 
   namespace N { int g(); } // expected-note {{still within definition of 'MissingBrace::S' here}}
 
   int k1 = S().h(); // expected-error {{no member named 'h' in 'MissingBrace::S'}}
   int k2 = S().f() + N::g();
 

clang/test/Sema/MicrosoftExtensions.c

union nested5 { // expected-warning {{anonymous unions are a Microsoft extension}}
     long f;
   };
 };
 
 typedef union nested6 {
   long f;
 } NESTED6;
 
-struct test {
+struct test { // expected-note 2 {{here}}
   int c;
   struct nested2;   // expected-warning {{anonymous structs are a Microsoft extension}}
   NESTED6;   // expected-warning {{anonymous unions are a Microsoft extension}}
 };
 
 void foo()
 {
   struct test var;

clang/test/Sema/anonymous-struct-union.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
-struct X {
+struct X { // expected-note {{here}}
   union {
     float f3;
     double d2;
   } named;
 
   union {
     int i;
     float f;

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

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 // Check the following typo correction behavior in namespaces:
 // - no typos are diagnosed when an expression has ambiguous (multiple) corrections
 // - proper iteration through multiple potentially ambiguous corrections
 
 namespace AmbiguousCorrection
 {
   void method_Bar();
   void method_Foo();
   void method_Zoo();
 };
 
 void testAmbiguousNoSuggestions()
 {
-  AmbiguousCorrection::method_Ace(); // expected-error {{no member named 'method_Ace' in namespace 'AmbiguousCorrection'}}
+  AmbiguousCorrection::method_Ace(); // expected-error {{no member named 'method_Ace' in namespace 'AmbiguousCorrection'}} expected-note@7 {{here}}
 }
 
 namespace MultipleCorrectionsButNotAmbiguous
 {
   int PrefixType_Name(int value);  // expected-note {{'PrefixType_Name' declared here}}
   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'?}}
   return val;
 }

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

 void rdar38642201_caller() {
   struct rdar38642201 structVar;
   rdar38642201_callee(
       structVar1.fieldName1.member1,  //expected-error{{use of undeclared identifier 'structVar1'}}
       structVar2.fieldName2.member2); //expected-error{{use of undeclared identifier 'structVar2'}}
 }
 
 // Similar reproducer.
-class A {
+class A { // expected-note 1 {{here}}
 public:
   int minut() const = delete;
   int hour() const = delete;
 
   int longit() const; //expected-note{{'longit' declared here}}
   int latit() const;
 };
 
-class B {
+class B { // expected-note 2 {{here}}
 public:
   A depar() const { return A(); }
 };
 
 int Foo(const B &b) {
   return b.deparT().hours() * 60 + //expected-error{{no member named 'deparT' in 'B'}}
          b.deparT().minutes();     //expected-error{{no member named 'deparT' in 'B'}}
 }
 
 int Bar(const B &b) {
   return b.depar().longitude() + //expected-error{{no member named 'longitude' in 'A'; did you mean 'longit'?}}
          b.depar().latitude();   //expected-error{{no member named 'latitude' in 'A'}}
 }

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

 {
 public:
   const DeepClass& getX() const { return m_deepInstance; }  // expected-note {{'getX' declared here}}
 private:
   DeepClass m_deepInstance;
   int m_n;
 };
 
-class Z
+class Z // expected-note {{here}}
 {
 public:
   const Y& getY0() const { return m_y0; }  // expected-note {{'getY0' declared here}}
   const Y& getActiveY() const { return m_y0; }
 
 private:
   Y m_y0;
   Y m_y1;
return scope_obj.make_an_E().  // expected-error {{no member named 'make_an_E' in 'Scope'; did you mean 'make_a_B'}}
       get_me_a_Z().value;        // expected-error {{no member named 'get_me_a_Z' in 'B'; did you mean 'get_me_a_D'}}
 }
 
 class AmbiguousHelper {
 public:
   int helpMe();
   int helpBe();
 };
-class Ambiguous {
+class Ambiguous { // expected-note 2 {{here}}
 public:
   int calculateA();
   int calculateB();
 
   AmbiguousHelper getHelp1();
   AmbiguousHelper getHelp2();
 };
 
 Ambiguous ambiguous_obj;
 
 int testDirectAmbiguousCorrection() {
   return ambiguous_obj.calculateZ();  // expected-error {{no member named 'calculateZ' in 'Ambiguous'}}
 }
 
 int testRecursiveAmbiguousCorrection() {
   return ambiguous_obj.getHelp3().    // expected-error {{no member named 'getHelp3' in 'Ambiguous'}}
       helpCe();
 }
 
 
-class DeepAmbiguityHelper {
+class DeepAmbiguityHelper { // expected-note {{here}}
 public:
   DeepAmbiguityHelper& help1();
   DeepAmbiguityHelper& help2();
 
   DeepAmbiguityHelper& methodA();
   DeepAmbiguityHelper& somethingMethodB();
   DeepAmbiguityHelper& functionC();
   DeepAmbiguityHelper& deepMethodD();

clang/test/SemaCXX/MicrosoftExtensions.cpp

 void f() { int __except = 0; }
 
 void ::f(); // expected-warning{{extra qualification on member 'f'}}
 
 class C {
   C::C(); // expected-warning{{extra qualification on member 'C'}}
 };
 
-struct StructWithProperty {
+struct StructWithProperty { // expected-note 2 {{declared here}}
   __declspec(property(get=GetV)) int V1;
   __declspec(property(put=SetV)) int V2;
   __declspec(property(get=GetV, put=SetV_NotExist)) int V3;
   __declspec(property(get=GetV_NotExist, put=SetV)) int V4;
   __declspec(property(get=GetV, put=SetV)) int V5;
 
   int GetV() { return 123; }
   void SetV(int i) {}

clang/test/SemaCXX/anonymous-union.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s
-struct X {
+struct X { // expected-note {{declared here}}
   union {
     float f3;
     double d2;
   } named;
 
   union {
     int i;
     float f;

clang/test/SemaCXX/attr-cleanup.cpp

 // RUN: %clang_cc1 %s -verify -fsyntax-only -Wno-gcc-compat
 
-namespace N {
+namespace N { // expected-note {{here}}
   void c1(int *a) {}
 }
 
 class C {
   static void c2(int *a) {}  // expected-note {{implicitly declared private here}} expected-note {{implicitly declared private here}}
 };
 
 void t1() {

clang/test/SemaCXX/co_await-range-for.cpp

struct Awaiter {
   void await_suspend(coroutine_handle<>);
   Begin await_resume();
 };
 
 template <class Iter> struct BeginTag { BeginTag() = delete; };
 template <class Iter> struct IncTag { IncTag() = delete; };
 
 template <class Iter, bool Delete = false>
-struct CoawaitTag { CoawaitTag() = delete; };
+struct CoawaitTag { CoawaitTag() = delete; }; // expected-note {{declared here}}
 
 template <class T>
 struct Iter {
   using value_type = T;
   using reference = T &;
   using pointer = T *;
 
   IncTag<Iter> operator++();

clang/test/SemaCXX/constructor-initializer.cpp

 namespace test3 {
   class A : public std::exception {}; // expected-error {{undeclared identifier}} expected-error {{expected class name}}
   // expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable}}
 #if __cplusplus >= 201103L // C++11 or later
   // expected-note@-3 {{candidate constructor (the implicit move constructor) not viable}}
 #endif
   // expected-note@-5 {{candidate constructor (the implicit default constructor) not viable}}
 
-  class B : public A {
+  class B : public A { // expected-note {{declared here}}
   public:
     B(const String& s, int e=0) // expected-error {{unknown type name}} 
       : A(e), m_String(s) , m_ErrorStr(__null) {} // expected-error {{no matching constructor}} expected-error {{does not name}}
     B(const B& e)
       : A(e), m_String(e.m_String), m_ErrorStr(__null) { // expected-error 2{{does not name}} \
       // expected-error {{no member named 'm_String' in 'test3::B'}}
     }
   };

clang/test/SemaCXX/conversion-function.cpp

struct A {
     operator struct S { int n; } (); // expected-error {{'PR18234::A::S' cannot be defined in a type specifier}}
     // expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'struct A' to 'const PR18234::A::S &' for 1st argument}}
 #if __cplusplus >= 201103L
   // expected-note@-3 {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'struct A' to 'PR18234::A::S &&' for 1st argument}}
 #endif
   } a;
   A::S s = a; // expected-error {{no viable conversion from 'struct A' to 'A::S'}}
   A::E e = a;
-  bool k1 = e == A::e; // expected-error {{no member named 'e'}}
+  bool k1 = e == A::e; // expected-error {{no member named 'e'}} expected-note@-10 {{here}}
   bool k2 = e.n == 0;
 }
 
 namespace PR30595 {
 struct S {
   const operator int(); // expected-error {{cannot specify any part of a return type in the declaration of a conversion function; put the complete type after 'operator'}}
   const operator int() const; // expected-error {{cannot specify any part of a return type}}
   volatile const operator int(); // expected-error {{cannot specify any part of a return type}}
 
   operator const int() const;
 };
 }

clang/test/SemaCXX/coroutines.cpp

 template <>
 struct std::experimental::coroutine_traits<double, double> { typedef int promise_type; };
 double bad_promise_type(double) { // expected-error {{this function cannot be a coroutine: 'experimental::coroutine_traits<double, double>::promise_type' (aka 'int') is not a class}}
   co_await a;
 }
 
 template <>
 struct std::experimental::coroutine_traits<double, int> {
-  struct promise_type {};
+  struct promise_type {}; // expected-note 2 {{declared here}}
 };
 double bad_promise_type_2(int) { // expected-error {{no member named 'initial_suspend'}}
   co_yield 0; // expected-error {{no member named 'yield_value' in 'std::experimental::coroutine_traits<double, int>::promise_type'}}
 }
 
 struct promise; // expected-note {{forward declaration}}
 struct promise_void;
 struct void_tag {};
 template <typename... T>
 struct std::experimental::coroutine_traits<void, T...> { using promise_type = promise; };
 template <typename... T>
 struct std::experimental::coroutine_traits<void, void_tag, T...>
 { using promise_type = promise_void; };
 
 // FIXME: This diagnostic is terrible.
 void undefined_promise() { // expected-error {{this function cannot be a coroutine: 'experimental::coroutine_traits<void>::promise_type' (aka 'promise') is an incomplete type}}
   co_await a;
 }
 
 struct yielded_thing { const char *p; short a, b; };
 
-struct not_awaitable {};
+struct not_awaitable {}; // expected-note 3 {{declared here}}
 
-struct promise {
+struct promise { // expected-note {{declared here}}
   void get_return_object();
   suspend_always initial_suspend();
   suspend_always final_suspend() noexcept;
   awaitable yield_value(int); // expected-note 2{{candidate}}
   awaitable yield_value(yielded_thing); // expected-note 2{{candidate}}
   not_awaitable yield_value(void()); // expected-note 2{{candidate}}
   void return_value(int); // expected-note 2{{here}}
   void unhandled_exception();
 };
 
-struct promise_void {
+struct promise_void { // expected-note {{declared here}}
   void get_return_object();
   suspend_always initial_suspend();
   suspend_always final_suspend() noexcept;
   void return_void();
   void unhandled_exception();
 };
 
 void no_coroutine_handle() { // expected-error {{std::experimental::coroutine_handle type was not found; include <experimental/coroutine> before defining a coroutine}}
template<typename T> void await_template(T t) {
     // expected-error@-1 {{call to function 'operator co_await' that is neither visible in the template definition nor found by argument-dependent lookup}}
   };
   template void await_template(awaitable);
 
   struct indirectly_awaitable { indirectly_awaitable(outer); };
   awaitable operator co_await(indirectly_awaitable); // expected-note {{should be declared prior to}}
   template void await_template(indirectly_awaitable);
 
-  struct not_awaitable {};
+  struct not_awaitable {}; // expected-note {{declared here}}
   template void await_template(not_awaitable); // expected-note {{instantiation}}
 
   template<typename T> void await_template_2(T t) {
     // one unqualified lookup result
     co_await t;
   };
   template void await_template(outer); // expected-note {{instantiation}}
   template void await_template_2(outer);
 
   struct transform_awaitable {};
-  struct transformed {};
+  struct transformed {}; // expected-note 4 {{declared here}}
 
   struct transform_promise {
     typedef transform_awaitable await_arg;
     coro<transform_promise> get_return_object();
     transformed initial_suspend();
     ::adl_ns::coawait_arg_type final_suspend() noexcept;
     transformed await_transform(transform_awaitable);
     void unhandled_exception();
void y(yield_fn_tag) {
     co_yield g;
   }
   void z(yield_fn_tag) {
     co_await a;
     co_return g;
   }
 }
 
-struct bad_promise_1 {
+struct bad_promise_1 { // expected-note {{declared here}}
   suspend_always initial_suspend();
   suspend_always final_suspend() noexcept;
   void unhandled_exception();
   void return_void();
 };
 coro<bad_promise_1> missing_get_return_object() { // expected-error {{no member named 'get_return_object' in 'bad_promise_1'}}
   co_await a;
 }

 }
 
 coro<check_warning_promise<awaitable_unused_warn>>
 test_unused_warning() {
   co_await awaitable_unused_warn(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
   co_yield 42; // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 }
 
-struct missing_await_ready {
+struct missing_await_ready { // expected-note {{declared here}}
   void await_suspend(std::experimental::coroutine_handle<>);
   void await_resume();
 };
-struct missing_await_suspend {
+struct missing_await_suspend { // expected-note {{declared here}}
   bool await_ready();
   void await_resume();
 };
 struct missing_await_resume {
   bool await_ready();
   void await_suspend(std::experimental::coroutine_handle<>);
 };
 
 void test_missing_awaitable_members() {
   co_await missing_await_ready{}; // expected-error {{no member named 'await_ready' in 'missing_await_ready'}}
   co_await missing_await_suspend{}; // expected-error {{no member named 'await_suspend' in 'missing_await_suspend'}}
   co_await missing_await_resume{}; // expected-error {{no member named 'await_resume' in 'missing_await_resume'}}
 }

clang/test/SemaCXX/cxx1y-deduced-return-type.cpp

 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only %s
 // RUN: %clang_cc1 -std=c++1y -verify -fsyntax-only %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
 
 auto f(); // expected-note {{previous}}
 int f(); // expected-error {{differ only in their return type}}
 
 auto &g();
 auto g() -> auto &;
 
 auto h() -> auto *;
 auto *h();
 
-struct Conv1 {
+struct Conv1 { // expected-note {{declared here}}
   operator auto(); // expected-note {{declared here}}
 } conv1;
 int conv1a = conv1; // expected-error {{function 'operator auto' with deduced return type cannot be used before it is defined}}
 // expected-error@-1 {{no viable conversion}}
 Conv1::operator auto() { return 123; }
 int conv1b = conv1;
 int conv1c = conv1.operator auto();
 int conv1d = conv1.operator int(); // expected-error {{no member named 'operator int'}}

 
 // Allow 'operator auto' to call only the explicit operator auto.
 struct BothOps {
   template <typename T> operator T();
   template <typename T> operator T *();
   operator auto() { return 0; }
   operator auto *() { return this; }
 };
-struct JustTemplateOp {
+struct JustTemplateOp { // expected-note 2 {{declared here}}
   template <typename T> operator T();
   template <typename T> operator T *();
 };
 
 auto c() {
   BothOps().operator auto(); // ok
   BothOps().operator auto *(); // ok
   JustTemplateOp().operator auto(); // expected-error {{no member named 'operator auto' in 'JustTemplateOp'}}

clang/test/SemaCXX/cxx1y-variable-templates_in_class.cpp

namespace dependent_static_var_template {
   namespace B {
     template<int = 0> static int n; // expected-note {{here}}
   }
   int &t = B::template n; // expected-error {{use of variable template 'n' requires template arguments}}
 }
 
 #ifndef PRECXX11
 namespace template_vars_in_template {
-template <int> struct TakesInt {};
+template <int> struct TakesInt {}; // expected-note {{declared here}}
 
 template <class T2>
 struct S {
   template <class T1>
   static constexpr int v = 42;
 
   template <class T>
   void mf() {

clang/test/SemaCXX/friend.cpp

void g(X x) {
     f10_a();
     f10_b();
     f10_c();
     f10_d(); // expected-error {{undeclared identifier}}
 
     ::test10::f10_a();
     ::test10::f10_b();
     ::test10::f10_c();
-    ::test10::f10_d(); // expected-error {{no member named 'f10_d'}}
+    ::test10::f10_d(); // expected-error {{no member named 'f10_d'}} expected-note@169 {{here}}
 
     f10_a(x);
     f10_b(x);
     f10_c(x);
     f10_d(x); // PR16597: expected-error {{undeclared identifier}}
 
     ::test10::f10_a(x);
     ::test10::f10_b(x);
     ::test10::f10_c(x);
-    ::test10::f10_d(x); // expected-error {{no type named 'f10_d'}}
+    ::test10::f10_d(x); // expected-error {{no type named 'f10_d'}} expected-note@169 {{here}}
   }
 
   struct Y : X {
     friend void f10_d();
     friend void f10_d(X);
   };
 
   struct Z {

clang/test/SemaCXX/invalid-member-expr.cpp

 #if __cplusplus <= 199711L // C++03 or earlier modes
     // expected-error@-2 {{expected expression}}
 #else
     // expected-error@-4 {{no matching function for call to 'minmax'}}
     // expected-note@-8 {{candidate template ignored: couldn't infer template argument '_Tp'}}
 #endif
   }
 
-  struct string {
+  struct string { // expected-note {{declared here}}
     class iterator {};
   };
 
   void test1() {
     string s;
     string::iterator i = s.foo(); // expected-error {{no member named 'foo'}}
   }
 }

clang/test/SemaCXX/member-operator-expr.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
-class X {
+class X { // expected-note 4 {{declared here}}
 public:
   int operator++();
   operator int();
 };
 
 void test() {
   X x;
   int i;
void test2() {
   x->operator--(); // expected-error{{no member named 'operator--'}}
   x->operator float(); // expected-error{{no member named 'operator float'}}
   x->operator; // expected-error{{expected a type}}
 }
 
 namespace pr13157 {
   class A { public: void operator()(int x, int y = 2, ...) {} };
   void f() { A()(1); }
-}
+}
 

clang/test/SemaCXX/missing-members.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 namespace A {
   namespace B {
     class C { }; // expected-note {{'A::B::C' declared here}}
     struct S { };
     union U { };
   }
 }
 
 void f() {
-  A::B::i; // expected-error {{no member named 'i' in namespace 'A::B'}}
+  A::B::i; // expected-error {{no member named 'i' in namespace 'A::B'}} expected-note@3 {{here}}
   A::B::C::i; // expected-error {{no member named 'i' in 'A::B::C'}}
   ::i; // expected-error {{no member named 'i' in the global namespace}}
 }
 
 namespace B {
   class B { };
 }
 
 void g() {
   A::B::D::E; // expected-error-re {{no member named 'D' in namespace 'A::B'{{$}}}}
   // FIXME: The typo corrections below should be suppressed since A::B::C
   // doesn't have a member named D.
   B::B::C::D; // expected-error {{no member named 'C' in 'B::B'; did you mean 'A::B::C'?}} \
-              // expected-error-re {{no member named 'D' in 'A::B::C'{{$}}}}
+              // expected-error-re {{no member named 'D' in 'A::B::C'{{$}}}} \
+              // expected-note@4 {{here}}
   ::C::D; // expected-error-re {{no member named 'C' in the global namespace{{$}}}}
 }
 
 int A::B::i = 10; // expected-error {{no member named 'i' in namespace 'A::B'}}
 int A::B::C::i = 10; // expected-error {{no member named 'i' in 'A::B::C'}}
 int A::B::S::i = 10; // expected-error {{no member named 'i' in 'A::B::S'}}
 int A::B::U::i = 10; // expected-error {{no member named 'i' in 'A::B::U'}}
 
 using A::B::D; // expected-error {{no member named 'D' in namespace 'A::B'}}
 
-struct S : A::B::C { 
-  using A::B::C::f; // expected-error {{no member named 'f' in 'A::B::C'}}
-  
+struct S : A::B::C {
+  using A::B::C::f; // expected-error {{no member named 'f' in 'A::B::C'}} expected-note@4 {{here}}
 };
 
-struct S1 {};
+struct S1 {}; // expected-note {{declared here}}
 
 struct S2 : S1 {};
 
 struct S3 : S2 {
   void run();
 };
 
 struct S4: S3 {};
 
 void test(S4 *ptr) {
   ptr->S1::run();  // expected-error {{no member named 'run' in 'S1'}}
 }

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

-// RUN: %clang_cc1 -fsyntax-only -std=c++98 -verify -fblocks %s 
+// RUN: %clang_cc1 -fsyntax-only -std=c++98 -verify -fblocks %s
 namespace A {
   struct C {
     static int cx;
 
     static int cx2;
 
     static int Ag1();
     static int Ag2();

 
 void f1() {
   void A::Af(); // expected-error {{definition or redeclaration of 'Af' not allowed inside a function}}
   void (^x)() = ^{ void A::Af(); }; // expected-error {{definition or redeclaration of 'Af' not allowed inside a block}}
 }
 
 void f2() {
   A:: ; // expected-error {{expected unqualified-id}}
-  A::C::undef = 0; // expected-error {{no member named 'undef'}}
+  A::C::undef = 0; // expected-error {{no member named 'undef'}} expected-note@3 {{here}}
   ::A::C::cx = 0;
   int x = ::A::ax = A::C::cx;
   x = sizeof(A::C);
   x = sizeof(::A::C::cx);
 }
 
 A::C c1;
 struct A::C c2;
void f3() {
   N::x = 0; // expected-error {{use of undeclared identifier 'N'}}
   // FIXME: Consider including the kind of entity that 'N' is ("variable 'N'
   // declared here", "template 'X' declared here", etc) to help explain what it
   // is if it's 'not a class, namespace, or scoped enumeration'.
   int N; // expected-note {{'N' declared here}}
   N::x = 0; // expected-error {{'N' is not a class, namespace, or enumeration}}
   { int A;           A::ax = 0; }
   { typedef int A;   A::ax = 0; } // expected-error{{'A' (aka 'int') is not a class, namespace, or enumeration}}
-  { typedef A::C A;  A::ax = 0; } // expected-error {{no member named 'ax'}}
+  { typedef A::C A;  A::ax = 0; } // expected-error {{no member named 'ax'}} expected-note@3 {{here}}
   { typedef A::C A;  A::cx = 0; }
 }
 
 // make sure the following doesn't hit any asserts
 void f4(undef::C); // expected-error {{use of undeclared identifier 'undef'}}
 
 typedef void C2::f5(int); // expected-error{{typedef declarator cannot be qualified}}
 
namespace PR16951 {
   }
 
   int x1 = ns::an_enumeration::ENUMERATOR; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}}
 
   int x2 = ns::an_enumeration::ENUMERATOR::vvv; // expected-warning{{use of enumeration in a nested name specifier is a C++11 extension}} \
                                                 // expected-error{{'ENUMERATOR' is not a class, namespace, or enumeration}} \
 
   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'}}
+                                  // expected-error{{no member named 'X'}} expected-note@-10 {{here}}
 
   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'}} expected-note@-5 {{here}}
 
 }
 
 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/pseudo-destructors.cpp

 
 namespace TwoPhaseLookup {
   namespace NonTemplate {
     struct Y {};
     using G = Y;
     template<typename T> void f(T *p) { p->~G(); } // expected-error {{no member named '~Y'}}
     void h1(Y *p) { p->~G(); }
     void h2(Y *p) { f(p); }
-    namespace N { struct G{}; }
+    namespace N { struct G{}; } // expected-note {{declared here}}
     void h3(N::G *p) { p->~G(); }
     void h4(N::G *p) { f(p); } // expected-note {{instantiation of}}
   }
 
   namespace NonTemplateUndeclared {
     struct Y {};
     template<typename T> void f(T *p) { p->~G(); } // expected-error {{undeclared identifier 'G' in destructor name}}
     using G = Y;
     void h1(Y *p) { p->~G(); }
     void h2(Y *p) { f(p); } // expected-note {{instantiation of}}
     namespace N { struct G{}; }
     void h3(N::G *p) { p->~G(); }
     void h4(N::G *p) { f(p); }
   }
 
   namespace Template {
     template<typename T> struct Y {};
     template<class U> using G = Y<U>;
     template<typename T> void f(T *p) { p->~G<int>(); } // expected-error {{no member named '~Y'}}
     void h1(Y<int> *p) { p->~G<int>(); }
     void h2(Y<int> *p) { f(p); }
-    namespace N { template<typename T> struct G {}; }
+    namespace N { template<typename T> struct G {}; } // expected-note {{declared here}}
     void h3(N::G<int> *p) { p->~G<int>(); }
     void h4(N::G<int> *p) { f(p); } // expected-note {{instantiation of}}
   }
 
   namespace TemplateUndeclared {
     template<typename T> struct Y {};
     // FIXME: Formally, this is ill-formed before we hit any instantiation,
     // because we aren't supposed to treat the '<' as introducing a template

clang/test/SemaCXX/qualified-id-lookup.cpp

namespace a {
   typedef int f2_type(int, int);
 
   void test_f2() {
     ::f2_type(1, 2); // expected-error {{excess elements in scalar initializer}}
   }
 }
 
 // PR clang/3291
-namespace a {  
+namespace a {
   namespace a {   // A1
     namespace a { // A2
       int i; // expected-note{{'a::a::a::i' declared here}}
     }
   }
 }
 
 void test_a() {
   a::a::i = 3; // expected-error{{no member named 'i' in namespace 'a::a'; did you mean 'a::a::a::i'?}}
   a::a::a::i = 4;
-  a::a::j = 3; // expected-error-re{{no member named 'j' in namespace 'a::a'{{$}}}}
+  a::a::j = 3; // expected-error-re{{no member named 'j' in namespace 'a::a'{{$}}}} expected-note@-10 {{here}}
 }
-  
 struct Undef { // expected-note{{definition of 'Undef' is not complete until the closing '}'}}
   typedef int type;
 
   Undef::type member;
 
   static int size = sizeof(Undef); // expected-error{{invalid application of 'sizeof' to an incomplete type 'Undef'}}
 
   int f();

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

 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-c++11-extensions %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 -Wno-c++11-extensions %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 struct A {};
 struct B {};
-struct D {
+struct D { // expected-note 4 {{declared here}}
   A fizbin;  // expected-note 2 {{declared here}}
   A foobar;  // expected-note 2 {{declared here}}
   B roxbin;  // expected-note 2 {{declared here}}
   B toobad;  // expected-note 2 {{declared here}}
   void BooHoo();
   void FoxBox();
 };
 

 void testExprFilter(Item *i) {
   Item *j;
   j = i->Next();  // expected-error {{no member named 'Next' in 'Item'; did you mean 'next'?}}
 }
 
 // Test that initializer expressions are handled correctly and that the type
 // being initialized is taken into account when choosing a correction.
 namespace initializerCorrections {
-struct Node {
+struct Node { // expected-note {{declared here}}
   string text() const;
   // Node* Next() is not implemented yet
 };
 void f(Node *node) {
   // text is only an edit distance of 1 from Next, but would trigger type
   // conversion errors if used in this initialization expression.
   Node *next = node->Next();  // expected-error-re {{no member named 'Next' in 'initializerCorrections::Node'{{$}}}}
 }
 
 struct LinkedNode {
   LinkedNode* next();  // expected-note {{'next' declared here}}
   string text() const;
 };
 void f(LinkedNode *node) {
   // text and next are equidistant from Next, but only one results in a valid
   // initialization expression.
   LinkedNode *next = node->Next();  // expected-error {{no member named 'Next' in 'initializerCorrections::LinkedNode'; did you mean 'next'?}}
 }
 
-struct NestedNode {
+struct NestedNode { // expected-note {{declared here}}
   NestedNode* Nest();
   NestedNode* next();
   string text() const;
 };
 void f(NestedNode *node) {
   // There are two equidistant, usable corrections for Next: next and Nest
   NestedNode *next = node->Next();  // expected-error-re {{no member named 'Next' in 'initializerCorrections::NestedNode'{{$}}}}
 }

 }
 
 const int DefaultArg = 9;  // expected-note {{'DefaultArg' declared here}}
 template <int I = defaultArg> struct S {};  // expected-error {{use of undeclared identifier 'defaultArg'; did you mean 'DefaultArg'?}}
 S<1> s;
 
 namespace foo {}
 void test_paren_suffix() {
-  foo::bar({5, 6});  // expected-error-re {{no member named 'bar' in namespace 'foo'{{$}}}}
+  foo::bar({5, 6});  // expected-error-re {{no member named 'bar' in namespace 'foo'{{$}}}} expected-note@-2 {{here}}
 #if __cplusplus <= 199711L
   // expected-error@-2 {{expected expression}}
 #endif
 }
 
 const int kNum = 10;  // expected-note {{'kNum' declared here}}
 class SomeClass {
   int Kind;

clang/test/SemaCXX/typo-correction.cpp

namespace b6956809_test1 {
   };
 
   void test1() {
     B b;
     S1 s;
     s.methodd(&b);  // expected-error{{no member named 'methodd' in 'b6956809_test1::S1'; did you mean 'method'}}
   }
 
-  struct S2 {
+  struct S2 { // expected-note {{here}}
     S2();
     void method(A*) const;
    private:
     void method(B*);
   };
 
   void test2() {
     B b;

clang/test/SemaCXX/unknown-type-name.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 // PR3990
 namespace N {
-  struct Wibble {
+  struct Wibble { // expected-note {{here}}
   };
 
   typedef Wibble foo;
 
   int zeppelin; // expected-note{{declared here}}
 }
 using namespace N;
 

clang/test/SemaObjCXX/deduction.mm

 @protocol Test1Protocol;
 namespace test1 {
   template <typename T> struct RemovePointer {
     typedef T type;
   };
   template <typename T> struct RemovePointer<T*> {
     typedef T type;
   };
-  template <typename A, typename B> struct is_same {};
+  template <typename A, typename B> struct is_same {}; // expected-note 2 {{declared here}}
   template <typename A> struct is_same<A,A> {
     static void foo();
   };
   template <typename T> struct tester {
     void test() {
       is_same<T, typename RemovePointer<T>::type*>::foo(); // expected-error 2 {{no member named 'foo'}}
     }
   };

clang/test/SemaObjCXX/interface-return-type.mm

 // RUN: %clang_cc1 -fsyntax-only -std=c++11 %s -verify
 
 @class NSObject;
-template<typename T> struct C {
+template<typename T> struct C { // expected-note {{declared here}}
       static T f(); // expected-error {{interface type 'NSObject' cannot be returned by value; did you forget * in 'NSObject'?}}
 };
 int g() { NSObject *x = C<NSObject>::f(); }//expected-error {{no member named 'f' in 'C<NSObject>'}} expected-note {{in instantiation of template class 'C<NSObject>' requested here}}

clang/test/SemaTemplate/attributes.cpp

namespace preferred_name {
   template<typename T> struct C;
   using X = C<int>; // expected-note {{'X' declared here}}
   typedef C<float> Y;
   using Z = const C<double>; // expected-note {{'Z' declared here}}
   template<typename T> struct [[clang::preferred_name(C<int>)]] C; // expected-error {{argument 'C<int>' to 'preferred_name' attribute is not a typedef for a specialization of 'C'}}
   template<typename T> struct [[clang::preferred_name(X), clang::preferred_name(Y)]] C;
   template<typename T> struct [[clang::preferred_name(const X)]] C; // expected-error {{argument 'const preferred_name::X'}}
   template<typename T> struct [[clang::preferred_name(Z)]] C; // expected-error {{argument 'preferred_name::Z' (aka 'const C<double>')}}
-  template<typename T> struct C {};
+  template<typename T> struct C {}; // expected-note 3 {{declared here}}
 
   // CHECK: ClassTemplateDecl {{.*}} <line:[[@LINE-10]]:{{.*}} C
   // CHECK:   ClassTemplateSpecializationDecl {{.*}} struct C definition
   // CHECK:     TemplateArgument type 'int'
   // CHECK-NOT: PreferredNameAttr
   // CHECK:     PreferredNameAttr {{.*}} preferred_name::X
   // CHECK-NOT: PreferredNameAttr
   // CHECK:     CXXRecordDecl
void f(C<int> a, C<float> b, C<double> c) {
     p.f(); // expected-error {{no member named 'f' in 'preferred_name::X'}}
     q.f(); // expected-error {{no member named 'f' in 'preferred_name::Y'}}
     r.f(); // expected-error {{no member named 'f' in 'preferred_name::C<double>'}}
   }
 
   template<typename T> struct D;
   using DInt = D<int>;
   template<typename T> struct __attribute__((__preferred_name__(DInt))) D {};
-  template struct D<int>;
+  template struct D<int>; // expected-note {{declared here}}
   int use_dint = D<int>().get(); // expected-error {{no member named 'get' in 'preferred_name::DInt'}}
 
   template<typename T> struct MemberTemplate {
     template<typename U> struct Iter;
     using iterator = Iter<T>;
     using const_iterator = Iter<const T>;
     template<typename U>
     struct [[clang::preferred_name(iterator),

clang/test/SemaTemplate/cxx1z-using-declaration.cpp

 };
 void test_Unexpanded() {
   struct A { void f(); };
   struct B { void f(int); }; // expected-note {{here}}
   Unexpanded<A, B>().g(0); // expected-note {{instantiation of}}
 }
 
 // Test using non-type members from pack of base classes.
-template<typename ...T> struct A : T... {
+template<typename ...T> struct A : T... { // expected-note {{declared here}}
   using T::T ...; // expected-note 2{{inherited here}}
   using T::operator() ...;
   using T::operator T* ...;
   using T::h ...;
 
   void f(int n) { h(n); } // expected-error {{ambiguous}}
   void f(int n, int m) { h(n, m); } // expected-error {{member using declaration 'h' instantiates to an empty pack}}
   void g(int n) { (*this)(n); } // expected-error {{ambiguous}}
template<typename ...T> void fn2() {
   // class, and a class member cannot be named by a block-scope using declaration.
   using typename T::type ...; // expected-error {{class member}}
   type x; // expected-error {{unknown type name 'type'}}
 }
 
 // Test partial substitution into class-scope pack.
 template<typename ...T> auto lambda1() {
   return [](auto x) {
-    struct A : T::template X<decltype(x)>... { // expected-note 1+{{instantiation of}}
+    struct A : T::template X<decltype(x)>... { // expected-note 1+{{instantiation of}} expected-note {{declared here}}
       using T::template X<decltype(x)>::f ...;
       using typename T::template X<decltype(x)>::type ...;
       void g(int n) { f(n); } // expected-error {{empty pack}} expected-error {{expected 2, have 1}} expected-error {{ambiguous}}
       void h() { type value; } // expected-error {{empty pack}}
     };
     return A();
   };
 }

clang/test/SemaTemplate/dependent-base-classes.cpp

struct HasDepBase : Base<T> {
     }
   };
 
   template<typename T>
   struct NoDepBase {
     int foo() {
       class NoDepBase::Nested nested; // expected-error{{no class named 'Nested' in 'NoDepBase<T>'}}
       typedef typename NoDepBase::template MemberTemplate<T>::type type; // expected-error{{no member named 'MemberTemplate' in 'NoDepBase<T>'}}
-      return NoDepBase::a; // expected-error{{no member named 'a' in 'NoDepBase<T>'}}
+      return NoDepBase::a; // expected-error{{no member named 'a' in 'NoDepBase<T>'}} expected-note@-4 {{here}}
     }
   };
 }
 
 namespace Ambig {
   template<typename T>
   struct Base1 {
     typedef int type; // expected-note{{member type 'int' found by ambiguous name lookup}}

clang/test/SemaTemplate/instantiate-method.cpp

namespace SameSignatureAfterInstantiation {
   template<typename T> struct S {
     void f(T *); // expected-note {{previous}}
     void f(const T*); // expected-error-re {{multiple overloads of 'f' instantiate to the same signature 'void (const int *){{( __attribute__\(\(thiscall\)\))?}}'}}
   };
   S<const int> s; // expected-note {{instantiation}}
 }
 
 namespace PR22040 {
-  template <typename T> struct Foobar {
+  template <typename T> struct Foobar { // expected-note 3 {{here}}
     template <> void bazqux(typename T::type) {}  // expected-error 2{{cannot be used prior to '::' because it has no members}}
   };
 
   void test() {
     // FIXME: we should suppress the "no member" errors
     Foobar<void>::bazqux();  // expected-error{{no member named 'bazqux' in }}  expected-note{{in instantiation of template class }}
     Foobar<int>::bazqux();  // expected-error{{no member named 'bazqux' in }}  expected-note{{in instantiation of template class }}
     Foobar<int>::bazqux(3);  // expected-error{{no member named 'bazqux' in }}

clang/test/SemaTemplate/instantiate-non-dependent-types.cpp

void f(T &t) {
     // expected-error@+2 {{no member named '~int' in 'Q'}}
     // expected-error@+1 {{no member named '~Colors' in 'Q'}}
     q->~A();
 
     delete q;
   }
 };
 
-class Q {
+class Q { // expected-note 2 {{declared here}}
 public:
   Q() {}
   ~Q() {}
 };
 
-enum Colors {red, green, blue};
+enum Colors {red, green, blue}; // expected-note {{declared here}}
 
 C<Q, int> dummy;
 C<Q, Colors> dummyColors;
 int main() {
   Q qinst;
   // expected-note@+1 {{in instantiation of member function 'C<Q, int>::f' requested here}}
   dummy.f(qinst);
   // expected-note@+1 {{in instantiation of member function 'C<Q, Colors>::f' requested here}}
   dummyColors.f(qinst);
 }
 

clang/test/SemaTemplate/member-access-ambig.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-unused-comparison %s
 
 // PR8439
-class A
+class A // expected-note {{declared here}}
 {
 };
 
 class B
 {
 public:
   A & m;
 };

clang/test/SemaTemplate/member-access-expr.cpp

#endif
 
   x.CrazyBase::f0(); // expected-error 2{{no member named}}
 #if __cplusplus <= 199711L
   // expected-error@-2 {{lookup of 'CrazyBase' in member access expression is ambiguous}}
 #endif
 
 }
 
-struct OtherBase { };
+struct OtherBase { }; // expected-note 2 {{declared here}}
 
 struct X1 : Base, OtherBase { 
   typedef OtherBase CrazyBase;
 #if __cplusplus <= 199711L
   // expected-note@-2 {{lookup in the object type 'X1' refers here}}
 #endif
 };
 
 void test_f0_through_typedef2(X0 x0, X1 x1) {
   call_f0_through_typedef2<Base>(x0);
   call_f0_through_typedef2<OtherBase>(x1); // expected-note{{instantiation}}
   call_f0_through_typedef2<Base>(x1); // expected-note{{instantiation}}
 }
 
 
-struct X2 {
+struct X2 { // expected-note {{declared here}}
   operator int() const;
 };
 
 template<typename T, typename U>
 T convert(const U& value) {
   return value.operator T(); // expected-error{{operator long}}
 }
 

clang/test/SemaTemplate/ms-lookup-template-base-classes.cpp

void f() {
   Container<B> text_provider2;
   text_provider2 = text_provider;  // expected-note {{in instantiation of function template specialization}}
 }
 
 }  // namespace PR12701
 
 namespace PR16014 {
 
-struct A {
+struct A { // expected-note {{declared here}}
   int a;
   static int sa;
 };
 template <typename T> struct B : T {
   int     foo() { return a; }           // expected-warning {{lookup into dependent bases}}
   int    *bar() { return &a; }          // expected-warning {{lookup into dependent bases}}
   int     baz() { return T::a; }
   int T::*qux() { return &T::a; }
template <typename T> struct C : T {
   int    *bar() { return &b; }     // expected-error {{no member named 'b' in 'PR16014::C<PR16014::A>'}} expected-warning {{lookup into dependent bases}}
   int     baz() { return T::b; }   // expected-error {{no member named 'b' in 'PR16014::A'}}
   int T::*qux() { return &T::b; }  // expected-error {{no member named 'b' in 'PR16014::A'}}
   int T::*fuz() { return &U::a; }  // expected-error {{use of undeclared identifier 'U'}} \
   // expected-warning {{unqualified lookup into dependent bases of class template 'C'}}
 };
 
 template struct B<A>;
-template struct C<A>;  // expected-note-re 1+ {{in instantiation of member function 'PR16014::C<PR16014::A>::{{.*}}' requested here}}
+template struct C<A>;  // expected-note-re 1+ {{in instantiation of member function 'PR16014::C<PR16014::A>::{{.*}}' requested here}} \
+                       // expected-note 2 {{declared here}}
 
 template <typename T> struct D : T {
   struct Inner {
     int foo() {
       // FIXME: MSVC can find this in D's base T!  Even worse, if ::sa exists,
       // clang will use it instead.
       return sa; // expected-error {{use of undeclared identifier 'sa'}}
     }