Diagnose cases where the name of a class member is used within a class definition before the member name is declared.

[rsmith]

Summary

This is ill-formed per [basic.scope.class]p2.

This is done by tracking all unqualified lookups performed within the
scope of a class definition that find nothing within the class, and
checking for conflicting declarations later introduced into the class.

[rsmith]

I'm not entirely happy with this approach; there are lots of places where we perform lookups that are incidental and shouldn't result in an error if we end up looking outside the class, and I'm not sure I've marked them all as "synthetic". That said, I've tested this over a fairly substantial amount of code and all the issues it reported were true positives.

[efriedma]

(Partial review; I'll continue reviewing later.)

clang/lib/Sema/SemaDecl.cpp

1543

Not really about this patch, but take given the following example:

typedef int f;
class C { C (f)(); };

It looks like every compiler somehow parses this as an invalid constructor declaration. As far as I can tell, it doesn't conform to the grammar for a constructor, though: parentheses aren't allowed after the parameter-declaration-clause. So it should declare a member function f, whether or not f is a type. Maybe I'm missing something, though.

It doesn't matter for this patch, of course, because you can also write C(f());, which actually depends on whether f is a type.

clang/test/CXX/basic/basic.scope/basic.scope.class/p2.cpp

154

I'm seeing a test failure here with this patch applied.

[rsmith]

Rebase and fix test failure.

clang/include/clang/Basic/DiagnosticGroups.td

 def : DiagGroup<"missing-format-attribute">;
 def : DiagGroup<"missing-include-dirs">;
 def MissingNoreturn : DiagGroup<"missing-noreturn">;
 def MultiChar : DiagGroup<"multichar">;
 def : DiagGroup<"nested-externs">;
 def CXX11LongLong : DiagGroup<"c++11-long-long">;
 def LongLong : DiagGroup<"long-long", [CXX11LongLong]>;
 def ImplicitlyUnsignedLiteral : DiagGroup<"implicitly-unsigned-literal">;
+def MemberShadowsUse : DiagGroup<"member-shadows-use">;
 def MethodSignatures : DiagGroup<"method-signatures">;
 def MismatchedParameterTypes : DiagGroup<"mismatched-parameter-types">;
 def MismatchedReturnTypes : DiagGroup<"mismatched-return-types">;
 def MismatchedTags : DiagGroup<"mismatched-tags">;
 def MissingFieldInitializers : DiagGroup<"missing-field-initializers">;
 def ModuleBuild : DiagGroup<"module-build">;
 def ModuleImport : DiagGroup<"module-import">;
 def ModuleConflict : DiagGroup<"module-conflict">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_member_function_initialization : Error<
   "initializer on function does not look like a pure-specifier">;
 def err_non_virtual_pure : Error<
   "%0 is not virtual and cannot be declared pure">;
 def ext_pure_function_definition : ExtWarn<
   "function definition with pure-specifier is a Microsoft extension">,
   InGroup<MicrosoftPureDefinition>;
 def err_qualified_member_of_unrelated : Error<
   "%q0 is not a member of class %1">;
+def ext_member_declared_too_late : ExtWarn<
+  "name %0 refers to a member of class %1 that has not yet been declared">,
+  InGroup<MemberShadowsUse>;
+def note_tag_decl_injects_non_member : Note<
+  "declaration injects non-member %q0; "
+  "%select{use a standalone forward declaration to introduce a class member|"
+  "if a member was intended, remove this friend declaration (befriending a "
+  "member has no effect)}1">;
+def note_member_declared_too_late_qualify : Note<
+  "use a qualified name to refer to member of %0">;
+def note_member_declared_too_late : Note<
+  "member %0 declared here after its point of use">;
+def ext_member_declared_too_late_multi_idns : ExtWarn<
+  "declaration of member %0 after its name has already been used "
+  "within the definition of class %1">, InGroup<MemberShadowsUse>;
 
 def err_member_function_call_bad_cvr : Error<
   "'this' argument to member function %0 has type %1, but function is not marked "
   "%select{const|restrict|const or restrict|volatile|const or volatile|"
   "volatile or restrict|const, volatile, or restrict}2">;
 def err_member_function_call_bad_ref : Error<
   "'this' argument to member function %0 is an %select{lvalue|rvalue}1, "
   "but function has %select{non-const lvalue|rvalue}2 ref-qualifier">;

clang/include/clang/Parse/Parser.h

ParsingClass &getCurrentClass() {
     return *ClassStack.top();
   }
 
   /// RAII object used to manage the parsing of a class definition.
   class ParsingClassDefinition {
     Parser &P;
     bool Popped;
     Sema::ParsingClassState State;
+    Scope::EmptyLookupMap EmptyLookups;
 
   public:
     ParsingClassDefinition(Parser &P, Decl *TagOrTemplate, bool TopLevelClass,
                            bool IsInterface)
       : P(P), Popped(false),
         State(P.PushParsingClass(TagOrTemplate, TopLevelClass, IsInterface)) {
     }
 
-    /// Pop this class of the stack.
+    void startBody() {
+      assert(!Popped);
+      assert(P.getCurScope()->isClassScope());
+      P.getCurScope()->enableLookupTracking(&EmptyLookups);
+    }
+
+    void finishBody() {
+      assert(!Popped);
+      assert(P.getCurScope()->isClassScope());
+      P.getCurScope()->disableLookupTracking();
+    }
+
+    /// Pop this class off the stack.
     void Pop() {
       assert(!Popped && "Nested class has already been popped");
+      finishBody();
       Popped = true;
       P.PopParsingClass(State);
     }
 
     ~ParsingClassDefinition() {
       if (!Popped)
         P.PopParsingClass(State);
     }

clang/include/clang/Sema/Lookup.h

public:
   /// injected-class-names are treated as naming a template rather than a
   /// template specialization.
   void setTemplateNameLookup(bool TemplateName) {
     TemplateNameLookup = TemplateName;
   }
 
   bool isTemplateNameLookup() const { return TemplateNameLookup; }
 
+  /// Sets that this is corresponds to a synthetic name lookup (for example,
+  /// during typo correction) rather than any source-level syntax.
+  void setSynthetic() { Synthetic = true; }
+
+  bool isSynthetic() { return Synthetic; }
+
   bool isAmbiguous() const {
     return getResultKind() == Ambiguous;
   }
 
   /// Determines if this names a single result which is not an
   /// unresolved value using decl.  If so, it is safe to call
   /// getFoundDecl().
   bool isSingleResult() const {
private:
   NamedDecl *getAcceptableDeclSlow(NamedDecl *D) const;
 
 public:
   /// Returns the identifier namespace mask for this lookup.
   unsigned getIdentifierNamespace() const {
     return IDNS;
   }
 
+  /// Override the identifier namespace for this lookup. This should generally
+  /// not be used; the identifier namespace should instead be inferred from the
+  /// LookupNameKind.
+  void setIdentifierNamespace(unsigned IDNS) { this->IDNS = IDNS; }
+
   /// Returns whether these results arose from performing a
   /// lookup into a class.
   bool isClassLookup() const {
     return NamingClass != nullptr;
   }
 
   /// Returns the 'naming class' for this lookup, i.e. the
   /// class which was looked into to find these results.
private:
 
   /// True if the found declarations were shadowed by some other
   /// declaration that we skipped. This only happens when \c LookupKind
   /// is \c LookupRedeclarationWithLinkage.
   bool Shadowed = false;
 
   /// True if we're looking up a template-name.
   bool TemplateNameLookup = false;
+
+  /// True if this is a synthetic name lookup (one generated internally and not
+  /// part of the interpretation of the program, such as during typo
+  /// correction).
+  bool Synthetic = false;
 };
 
 /// Consumes visible declarations found when searching for
 /// all visible names within a given scope or context.
 ///
 /// This abstract class is meant to be subclassed by clients of \c
 /// Sema::LookupVisibleDecls(), each of which should override the \c
 /// FoundDecl() function to process declarations as they are found.

clang/include/clang/Sema/Scope.h

 //===- Scope.h - Scope interface --------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the Scope interface.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_SEMA_SCOPE_H
 #define LLVM_CLANG_SEMA_SCOPE_H
 
 #include "clang/AST/Decl.h"
+#include "clang/AST/DeclarationName.h"
 #include "clang/Basic/Diagnostic.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/iterator_range.h"
 #include <cassert>
 
 namespace llvm {
 
enum ScopeFlags {
 
     /// We are between inheritance colon and the real class/struct definition scope.
     ClassInheritanceScope = 0x800000,
 
     /// This is the scope of a C++ catch statement.
     CatchScope = 0x1000000,
   };
 
+  /// A lookup that was performed in this scope and that found nothing here.
+  struct EmptyLookup {
+    /// The point of first use.
+    SourceLocation FirstUseLoc;
+    /// The Decl::IdentifierNamespace mask for the first use.
+    unsigned FirstIDNS : 16;
+    /// The Decl::IdentifierNamespace mask for all uses of this name in this
+    /// scope. Guaranteed to be a superset of FirstIDNS.
+    unsigned CumulativeIDNS : 16;
+    /// Determine whether this represents a lookup that has been attempted and
+    /// failed (\c true) or a lookup that has never been attempted (\c false).
+    explicit operator bool() const { return FirstUseLoc.isValid(); }
+  };
+  using EmptyLookupMap = llvm::SmallDenseMap<DeclarationName, EmptyLookup, 16>;
+
 private:
   /// The parent scope for this scope.  This is null for the translation-unit
   /// scope.
   Scope *AnyParent;
 
   /// Flags - This contains a set of ScopeFlags, which indicates how the scope
   /// interrelates with other control flow statements.
   unsigned Flags;
private:
 
   /// Used to determine if errors occurred in this scope.
   DiagnosticErrorTrap ErrorTrap;
 
   /// A lattice consisting of undefined, a single NRVO candidate variable in
   /// this scope, or over-defined. The bit is true when over-defined.
   llvm::PointerIntPair<VarDecl *, 1, bool> NRVO;
 
+  /// DeclarationNames that have been looked up in this scope and not found,
+  /// for scopes where that is tracked. This is tracked in C++ class scopes in
+  /// order to diagnose cases where a class member is declared after that
+  /// identifier has already been used with a different meaning.
+  EmptyLookupMap *EmptyLookups = nullptr;
+
   void setFlags(Scope *Parent, unsigned F);
 
+  void noteEmptyLookupImpl(DeclarationName N, SourceLocation UseLoc,
+                           unsigned IDNS);
+
 public:
   Scope(Scope *Parent, unsigned ScopeFlags, DiagnosticsEngine &Diag)
       : ErrorTrap(Diag) {
     Init(Parent, ScopeFlags);
   }
 
   /// getFlags - Return the flags for this scope.
   unsigned getFlags() const { return Flags; }
public:
 
   /// Return the number of parameters declared in this function
   /// prototype, increasing it by one for the next call.
   unsigned getNextFunctionPrototypeIndex() {
     assert(isFunctionPrototypeScope());
     return PrototypeIndex++;
   }
 
+  /// For a class scope, enable tracking of members that are declared after
+  /// their names have already been looked up. This is ill-formed by
+  /// C++ [basic.scope.class]p2.
+  void enableLookupTracking(EmptyLookupMap *Map) {
+    assert(!EmptyLookups && "lookup map set twice");
+    if (!Map)
+      return;
+
+    assert((getFlags() & ClassScope) && "not a class scope");
+    EmptyLookups = Map;
+  }
+
+  EmptyLookupMap *disableLookupTracking() {
+    auto *Map = EmptyLookups;
+    EmptyLookups = nullptr;
+    return Map;
+  }
+
+  /// Note that the given name was looked up within this scope, and nothing was
+  /// found.
+  void noteEmptyLookup(DeclarationName N, SourceLocation UseLoc,
+                       unsigned IDNS) {
+    if (EmptyLookups)
+      noteEmptyLookupImpl(N, UseLoc, IDNS);
+  }
+
+  /// Determine whether a lookup for name N in this scope was attempted and
+  /// found nothing, and if so, what kind of name was looked for and where.
+  EmptyLookup getEmptyLookupForName(DeclarationName N) {
+    return EmptyLookups ? EmptyLookups->lookup(N) : EmptyLookup();
+  }
+
+  // Forget about an empty lookup from a given location (to avoid duplicate
+  // diagnostics).
+  void eraseEmptyLookup(DeclarationName N) {
+    if (EmptyLookups)
+      EmptyLookups->erase(N);
+  }
+
   using decl_range = llvm::iterator_range<DeclSetTy::iterator>;
 
   decl_range decls() const {
     return decl_range(DeclsInScope.begin(), DeclsInScope.end());
   }
 
   bool decl_empty() const { return DeclsInScope.empty(); }
 

clang/include/clang/Sema/SemaInternal.h

TypoCorrectionConsumer(Sema &SemaRef,
       : Typo(TypoName.getName().getAsIdentifierInfo()), CurrentTCIndex(0),
         SavedTCIndex(0), SemaRef(SemaRef), S(S),
         SS(SS ? std::make_unique<CXXScopeSpec>(*SS) : nullptr),
         CorrectionValidator(std::move(CCC)), MemberContext(MemberContext),
         Result(SemaRef, TypoName, LookupKind),
         Namespaces(SemaRef.Context, SemaRef.CurContext, SS),
         EnteringContext(EnteringContext), SearchNamespaces(false) {
     Result.suppressDiagnostics();
+    Result.setSynthetic();
     // Arrange for ValidatedCorrections[0] to always be an empty correction.
     ValidatedCorrections.push_back(TypoCorrection());
   }
 
   bool includeHiddenDecls() const override { return true; }
 
   // Methods for adding potential corrections to the consumer.
   void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,

clang/lib/Parse/ParseCXXInlineMethods.cpp

public:
   explicit UnannotatedTentativeParsingAction(Parser &Self,
                                              tok::TokenKind EndKind)
       : TentativeParsingAction(Self), Self(Self), EndKind(EndKind) {
     // Stash away the old token stream, so we can restore it once the
     // tentative parse is complete.
     TentativeParsingAction Inner(Self);
     Self.ConsumeAndStoreUntil(EndKind, Toks, true, /*ConsumeFinalToken*/false);
     Inner.Revert();
+
+    // Disable lookup tracking; these lookups are going to be reverted, so
+    // don't count.
+    for (Scope *S = Self.getCurScope(); S; S = S->getParent())
+      if (auto *Map = S->disableLookupTracking())
+        OldLookupMaps.push_back({S, Map});
   }
 
   void RevertAnnotations() {
     Revert();
 
     // Put back the original tokens.
     Self.SkipUntil(EndKind, StopAtSemi | StopBeforeMatch);
     if (Toks.size()) {
       auto Buffer = std::make_unique<Token[]>(Toks.size());
       std::copy(Toks.begin() + 1, Toks.end(), Buffer.get());
       Buffer[Toks.size() - 1] = Self.Tok;
       Self.PP.EnterTokenStream(std::move(Buffer), Toks.size(), true,
                                /*IsReinject*/ true);
 
       Self.Tok = Toks.front();
     }
+
+    for (auto Map : OldLookupMaps)
+      Map.first->enableLookupTracking(Map.second);
   }
 
 private:
   Parser &Self;
   CachedTokens Toks;
   tok::TokenKind EndKind;
+
+  llvm::SmallVector<std::pair<Scope *, Scope::EmptyLookupMap *>, 4>
+      OldLookupMaps;
 };
 
 /// ConsumeAndStoreInitializer - Consume and store the token at the passed token
 /// container until the end of the current initializer expression (either a
 /// default argument or an in-class initializer for a non-static data member).
 ///
 /// Returns \c true if we reached the end of something initializer-shaped,
 /// \c false if we bailed out.

clang/lib/Parse/ParseDeclCXX.cpp

if (!Tok.is(tok::l_brace)) {
       }
     }
   }
 
   assert(Tok.is(tok::l_brace));
   BalancedDelimiterTracker T(*this, tok::l_brace);
   T.consumeOpen();
 
+  ParsingDef.startBody();
+
   if (TagDecl)
     Actions.ActOnStartCXXMemberDeclarations(getCurScope(), TagDecl, FinalLoc,
                                             IsFinalSpelledSealed,
                                             T.getOpenLocation());
 
   // C++ 11p3: Members of a class defined with the keyword class are private
   // by default. Members of a class defined with the keywords struct or union
   // are public by default.
void Parser::ParseCXXMemberSpecification(SourceLocation RecordLoc,
   ParsedAttributes attrs(AttrFactory);
   MaybeParseGNUAttributes(attrs);
 
   if (TagDecl)
     Actions.ActOnFinishCXXMemberSpecification(getCurScope(), RecordLoc, TagDecl,
                                               T.getOpenLocation(),
                                               T.getCloseLocation(), attrs);
 
+  ParsingDef.finishBody();
+
   // C++11 [class.mem]p2:
   //   Within the class member-specification, the class is regarded as complete
   //   within function bodies, default arguments, exception-specifications, and
   //   brace-or-equal-initializers for non-static data members (including such
   //   things in nested classes).
   if (TagDecl && NonNestedClass) {
     // We are not inside a nested class. This class and its nested classes
     // are complete and we can parse the delayed portions of method

clang/lib/Sema/Scope.cpp

 void Scope::Init(Scope *parent, unsigned flags) {
   setFlags(parent, flags);
 
   DeclsInScope.clear();
   UsingDirectives.clear();
   Entity = nullptr;
   ErrorTrap.reset();
   NRVO.setPointerAndInt(nullptr, 0);
+  assert(!EmptyLookups &&
+         "failed to disable lookup tracking before reusing scope");
 }
 
 bool Scope::containedInPrototypeScope() const {
   const Scope *S = this;
   while (S) {
     if (S->isFunctionPrototypeScope())
       return true;
     S = S->getParent();
void Scope::AddFlags(unsigned FlagsToSet) {
   }
   if (FlagsToSet & ContinueScope) {
     assert((Flags & ContinueScope) == 0 && "Already set");
     ContinueParent = this;
   }
   Flags |= FlagsToSet;
 }
 
+void Scope::noteEmptyLookupImpl(DeclarationName N, SourceLocation UseLoc,
+                                unsigned IDNS) {
+  auto Ret = EmptyLookups->insert({N, {UseLoc, IDNS, IDNS}});
+  if (Ret.second)
+    return;
+
+  // We might have performed lookups with different IDNSes. For example:
+  //
+  //   struct S {
+  //     A::B *p;     // #1
+  //     A *q;        // #2
+  //     struct A {}; // #3
+  //   };
+  //
+  // In such cases, preserve the first source location but all of the IDNSes.
+  // We'll diagnose at the first use location if possible and fall back to not
+  // giving a use location if the first use was valid (which is rare).
+  auto &Old = Ret.first->second;
+  if (Old.FirstUseLoc == UseLoc)
+    Old.FirstIDNS |= IDNS;
+  Old.CumulativeIDNS |= IDNS;
+}
+
 void Scope::mergeNRVOIntoParent() {
   if (VarDecl *Candidate = NRVO.getPointer()) {
     if (isDeclScope(Candidate))
       Candidate->setNRVOVariable(true);
   }
 
   if (getEntity())
     return;

clang/lib/Sema/SemaDecl.cpp

 /// to determine if the specified name is a valid tag name ("struct foo").  If
 /// so, this returns the TST for the tag corresponding to it (TST_enum,
 /// TST_union, TST_struct, TST_interface, TST_class).  This is used to diagnose
 /// cases in C where the user forgot to specify the tag.
 DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
   // Do a tag name lookup in this scope.
   LookupResult R(*this, &II, SourceLocation(), LookupTagName);
   LookupName(R, S, false);
+  R.setSynthetic();
   R.suppressDiagnostics();
   if (R.getResultKind() == LookupResult::Found)
     if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
       switch (TD->getTagKind()) {
       case TTK_Struct: return DeclSpec::TST_struct;
       case TTK_Interface: return DeclSpec::TST_interface;
       case TTK_Union:  return DeclSpec::TST_union;
       case TTK_Class:  return DeclSpec::TST_class;
static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) {
   return false;
 }
 
 static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result,
                                     Scope *S, CXXScopeSpec &SS,
                                     IdentifierInfo *&Name,
                                     SourceLocation NameLoc) {
   LookupResult R(SemaRef, Name, NameLoc, Sema::LookupTagName);
+  R.setSynthetic();
   SemaRef.LookupParsedName(R, S, &SS);
   if (TagDecl *Tag = R.getAsSingle<TagDecl>()) {
     StringRef FixItTagName;
     switch (Tag->getTagKind()) {
       case TTK_Class:
         FixItTagName = "class ";
         break;
 
static bool AllowOverloadingOfFunction(LookupResult &Previous,
   if (Previous.getResultKind() == LookupResult::FoundOverloaded)
     return true;
 
   return Previous.getResultKind() == LookupResult::Found &&
          (Previous.getFoundDecl()->hasAttr<OverloadableAttr>() ||
           New->hasAttr<OverloadableAttr>());
 }
 
+/// Get a nested name specifier suitable to name \p TargetContext from \p
+/// CurContext.
+///
+/// This is implemented below in terms of
+/// TypoCorrectionConsumer::NestedNameSpecifierSet.
+static NestedNameSpecifier *
+getRelativeNestedNameSpecifier(Sema &SemaRef, Scope *CurScope,
+                               DeclContext *TargetContext) {
+  llvm::function_ref<NestedNameSpecifier *(DeclContext *)> MakeRec;
+  auto Make = [&](DeclContext *DC) -> NestedNameSpecifier * {
+    if (isa<TranslationUnitDecl>(DC))
+      return NestedNameSpecifier::GlobalSpecifier(SemaRef.Context);
+
+    // If the DeclContext is a type, we're looking for a way to name that type.
+    QualType DCType;
+    if (auto *TD = dyn_cast<TypeDecl>(DC))
+      DCType = SemaRef.Context.getTypeDeclType(TD);
+
+    // If we hit something like a function scope that's not common between the
+    // current context and the target, we can't reasonably build a nested name
+    // specifier.
+    if (!isa<NamespaceDecl>(DC) && DCType.isNull())
+      return nullptr;
+
+    DeclarationName Name = cast<NamedDecl>(DC)->getDeclName();
+
+    // We might be able to refer to this by unqualified name. Try it.
+    LookupResult R(SemaRef, Name, SourceLocation(),
+                   Sema::LookupNestedNameSpecifierName);
+    if (Name) {
+      R.setSynthetic();
+      R.suppressDiagnostics();
+      SemaRef.LookupName(R, CurScope);
+    }
+
+    QualType RAsType;
+    if (auto *TD = R.getAsSingle<TypeDecl>())
+      RAsType = SemaRef.Context.getTypeDeclType(TD);
+
+    NestedNameSpecifier *Prefix = nullptr;
+    if (R.isSingleResult() &&
+        declaresSameEntity(R.getFoundDecl(), cast<Decl>(DC))) {
+      // No prefix: we can name the entity directly in this context.
+    } else if (!DCType.isNull() && !RAsType.isNull() &&
+               SemaRef.Context.hasSameUnqualifiedType(DCType, RAsType)) {
+      // No prefix: we can name the type directly in this context.
+    } else {
+      Prefix = MakeRec(DC->getLookupParent());
+      if (!Prefix)
+        return nullptr;
+
+      // When naming a class template from an enclosing context, switch from
+      // the injected-class-name to the template specialization type.
+      if (!DCType.isNull())
+        if (auto *Injected = DCType->getAs<InjectedClassNameType>())
+          DCType = Injected->getInjectedSpecializationType();
+    }
+
+    if (auto *ND = dyn_cast<NamespaceDecl>(DC)) {
+      // Don't mention inline namespaces if we can help it.
+      // FIXME: Do we ever need to mention them for disambiguation?
+      if (ND->isInline() && Prefix)
+        return Prefix;
+      return NestedNameSpecifier::Create(SemaRef.Context, Prefix, ND);
+    }
+
+    return NestedNameSpecifier::Create(SemaRef.Context, Prefix,
+                                       /*TemplateKW=*/false,
+                                       DCType.getTypePtr());
+  };
+  MakeRec = Make;
+
+  return Make(TargetContext);
+}
+
+static Scope *getTagInjectionScope(Scope *S, const LangOptions &LangOpts);
+
+/// Diagnose the case where we have performed a lookup for the name of a
+/// declaration at class scope and found nothing, then later seen a declaration
+/// of a class member with the given name.
+///
+/// This is ill-formed (no diagnostic required) by [basic.scope.class.p2].
+static void diagnoseEmptyLookupShadow(Sema &SemaRef, Scope *S, NamedDecl *D,
+                                      Scope::EmptyLookup Lookup) {
+  // C++ [basic.scope.class]p2:
+  //   A name N used in a class S shall refer to the same declaration in its
+  //   context and when re-evaluated in the completed scope of S. No diagnostic
+  //   is required for a violation of this rule.
+  assert(SemaRef.getLangOpts().CPlusPlus &&
+         "empty lookup detection should only be done in C++");
+
+  // Suppress diagnostics for this if we hit any errors while processing the
+  // class. For example, if lookup for the name fails entirely, producing a
+  // duplicate warning is likely not useful. Similarly for a case such as
+  // 'struct A { f(); };' where we first look up 'f' as a type and then recover
+  // by injecting it as a member name.
+  if (S->hasUnrecoverableErrorOccurred() || !D->isCXXClassMember())
+    return;
+
+  // This must be a class scope.
+  CXXRecordDecl *RD = cast<CXXRecordDecl>(S->getEntity());
+
+  if (Lookup.FirstUseLoc == D->getLocation()) {
+    // We looked this up but ended up declaring it instead. Don't count
+    // this as an empty lookup. This happens for cases like
+    //   auto m = 0;
+    // in C++98 mode, where we would first look up 'm' as the name of a type,
+    // and then introduce it as a non-type name, and also for things like
+    //   C (f)();
+    //   C (f)(int);
+    // in class 'C', where we look up 'f' to determine if we're declaring a
+    // constructor.
+  } else if (D->isInIdentifierNamespace(Lookup.FirstIDNS)) {
+    SemaRef.Diag(Lookup.FirstUseLoc, diag::ext_member_declared_too_late)
+        << D->getDeclName() << D->getDeclContext()->getRedeclContext();
+
+    // Consider suggesting a qualified name. Reconstruct the original
+    // lookup result to figure out what qualifier to suggest.
+    LookupResult R(SemaRef, D->getDeclName(), Lookup.FirstUseLoc,
+                   Sema::LookupOrdinaryName);
+    R.setSynthetic();
+    R.suppressDiagnostics();
+    R.setIdentifierNamespace(Lookup.FirstIDNS);
+    SemaRef.LookupName(R, S->getParent());
+
+    // Ignore declarations lexically within the class (eg, injected tag
+    // declarations). Those will be invalid too, so don't suggest using a
+    // qualified name to name them.
+    auto Filter = R.makeFilter();
+    while (Filter.hasNext()) {
+      NamedDecl *D = Filter.next();
+      if (D->getLexicalDeclContext()->getRedeclContext()->Equals(RD)) {
+        bool FoundReplacement = false;
+        for (auto *Redecl : D->redecls()) {
+          if (!D->getLexicalDeclContext()->getRedeclContext()->Equals(RD)) {
+            Filter.replace(cast<NamedDecl>(Redecl));
+            FoundReplacement = true;
+            break;
+          }
+        }
+        if (!FoundReplacement)
+          Filter.erase();
+      }
+    }
+    Filter.done();
+
+    // If anything remains, that's likely to be what was intended.
+    if (!R.empty()) {
+      NamedDecl *OldD = R.getRepresentativeDecl();
+
+      // Attempt to form a good fix-it hint describing how to properly name
+      // the declaration we found earlier. This might fail.
+      FixItHint Hint;
+      if (NestedNameSpecifier *NNS = getRelativeNestedNameSpecifier(
+              SemaRef, S, OldD->getDeclContext()->getRedeclContext())) {
+        llvm::SmallString<64> Str;
+        llvm::raw_svector_ostream OS(Str);
+        PrintingPolicy Policy = SemaRef.Context.getPrintingPolicy();
+        Policy.PrintInjectedClassNameWithArguments = false;
+        NNS->print(OS, Policy);
+        Hint = FixItHint::CreateInsertion(Lookup.FirstUseLoc, Str);
+      }
+
+      SemaRef.Diag(OldD->getLocation(),
+                   diag::note_member_declared_too_late_qualify)
+          << OldD->getDeclContext() << Hint;
+    }
+
+    if (R.empty() && (Lookup.FirstIDNS == Decl::IDNS_Type) && isa<TagDecl>(D)) {
+      // This was a failed tag lookup, and has been shadowed by a tag
+      // declaration. It's very likely that the programmer believed that the
+      // tag reference would declare the tag as a member. For example:
+      //   struct A {
+      //     friend class X;
+      //     class X {};
+      //   };
+      // Look for the injected tag declaration to check that this is what
+      // happened.
+      LookupResult TagR(SemaRef, D->getDeclName(), Lookup.FirstUseLoc,
+                        Sema::LookupTagName, Sema::ForVisibleRedeclaration);
+      TagR.setSynthetic();
+      TagR.suppressDiagnostics();
+      SemaRef.LookupName(TagR, getTagInjectionScope(S, SemaRef.getLangOpts()));
+
+      if (auto *FoundTag = TagR.getAsSingle<TagDecl>()) {
+        for (auto *Redecl : FoundTag->redecls()) {
+          if (Redecl->getLocation() == Lookup.FirstUseLoc) {
+            SemaRef.Diag(Lookup.FirstUseLoc,
+                         diag::note_tag_decl_injects_non_member)
+                << Redecl << !!Redecl->getFriendObjectKind();
+            break;
+          }
+        }
+      }
+    }
+
+    SemaRef.Diag(D->getLocation(), diag::note_member_declared_too_late) << D;
+  } else if (D->isInIdentifierNamespace(Lookup.CumulativeIDNS)) {
+    // The first use location was a valid use of an enclosing name, but some
+    // later use would have been interpreted as the class member.
+    SemaRef.Diag(D->getLocation(),
+                 diag::ext_member_declared_too_late_multi_idns)
+        << D << D->getDeclContext()->getRedeclContext();
+  } else {
+    // This declaration does not actually shadow the prior uses.
+    return;
+  }
+
+  // Ensure we don't issue more diagnostics if the name is redeclared in
+  // this class or declared in an enclosing class.
+  for (Scope *InnerS = S; InnerS; InnerS = InnerS->getParent())
+    InnerS->eraseEmptyLookup(D->getDeclName());
+}
+
 /// Add this decl to the scope shadowed decl chains.
 void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
   // Move up the scope chain until we find the nearest enclosing
   // non-transparent context. The declaration will be introduced into this
   // scope.
   while (S->getEntity() && S->getEntity()->isTransparentContext())
     S = S->getParent();
 
if (S->isDeclScope(*I) && D->declarationReplaces(*I)) {
       S->RemoveDecl(*I);
       IdResolver.RemoveDecl(*I);
 
       // Should only need to replace one decl.
       break;
     }
   }
 
+  // If we're tracking empty lookups in this context, see if we already tried
+  // and failed to look for this name, and diagnose if so.
+  if (Scope::EmptyLookup Lookup = S->getEmptyLookupForName(D->getDeclName()))
+    diagnoseEmptyLookupShadow(*this, S, D, Lookup);
+
   S->AddDecl(D);
 
   if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
     // Implicitly-generated labels may end up getting generated in an order that
     // isn't strictly lexical, which breaks name lookup. Be careful to insert
     // the label at the appropriate place in the identifier chain.
     for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) {
       DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext();

 
 /// Check -Wshadow without the advantage of a previous lookup.
 void Sema::CheckShadow(Scope *S, VarDecl *D) {
   if (Diags.isIgnored(diag::warn_decl_shadow, D->getLocation()))
     return;
 
   LookupResult R(*this, D->getDeclName(), D->getLocation(),
                  Sema::LookupOrdinaryName, Sema::ForVisibleRedeclaration);
+  R.setSynthetic();
   LookupName(R, S);
   if (NamedDecl *ShadowedDecl = getShadowedDeclaration(D, R))
     CheckShadow(D, ShadowedDecl, R);
 }
 
 /// Check if 'E', which is an expression that is about to be modified, refers
 /// to a constructor parameter that shadows a field.
 void Sema::CheckShadowingDeclModification(Expr *E, SourceLocation Loc) {
static NamedDecl *DiagnoseInvalidRedeclaration(
   unsigned DiagMsg =
     IsLocalFriend ? diag::err_no_matching_local_friend :
     NewFD->getFriendObjectKind() ? diag::err_qualified_friend_no_match :
     diag::err_member_decl_does_not_match;
   LookupResult Prev(SemaRef, Name, NewFD->getLocation(),
                     IsLocalFriend ? Sema::LookupLocalFriendName
                                   : Sema::LookupOrdinaryName,
                     Sema::ForVisibleRedeclaration);
+  Prev.setSynthetic();
 
   NewFD->setInvalidDecl();
   if (IsLocalFriend)
     SemaRef.LookupName(Prev, S);
   else
     SemaRef.LookupQualifiedName(Prev, NewDC);
   assert(!Prev.isAmbiguous() &&
          "Cannot have an ambiguity in previous-declaration lookup");

clang/lib/Sema/SemaDeclCXX.cpp

bool NeedsCollectableMemCpy =
       E->castAs<RecordType>()->getDecl()->hasObjectMember();
 
   // Create a reference to the __builtin_objc_memmove_collectable function
   StringRef MemCpyName = NeedsCollectableMemCpy ?
     "__builtin_objc_memmove_collectable" :
     "__builtin_memcpy";
   LookupResult R(S, &S.Context.Idents.get(MemCpyName), Loc,
                  Sema::LookupOrdinaryName);
+  R.setSynthetic();
   S.LookupName(R, S.TUScope, true);
 
   FunctionDecl *MemCpy = R.getAsSingle<FunctionDecl>();
   if (!MemCpy)
     // Something went horribly wrong earlier, and we will have complained
     // about it.
     return StmtError();
 

clang/lib/Sema/SemaExprCXX.cpp

#endif // NDEBUG
   CurrentLSI->clearPotentialCaptures();
 }
 
 static ExprResult attemptRecovery(Sema &SemaRef,
                                   const TypoCorrectionConsumer &Consumer,
                                   const TypoCorrection &TC) {
   LookupResult R(SemaRef, Consumer.getLookupResult().getLookupNameInfo(),
                  Consumer.getLookupResult().getLookupKind());
+  R.setSynthetic();
   const CXXScopeSpec *SS = Consumer.getSS();
   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;

clang/lib/Sema/SemaLookup.cpp

if (NameKind == LookupLocalFriendName && !S->isClassScope()) {
       // C++11 [class.friend]p11:
       //   If a friend declaration appears in a local class and the name
       //   specified is an unqualified name, a prior declaration is
       //   looked up without considering scopes that are outside the
       //   innermost enclosing non-class scope.
       return false;
     }
 
+    // If we've just searched a lookup-tracking scope and found nothing, make a
+    // note that declaring a new name in this scope could change the lookup
+    // result.
+    if (R.empty() && !R.isForRedeclaration() && !R.isSynthetic())
+      S->noteEmptyLookup(Name, R.getNameLoc(), R.getIdentifierNamespace());
+
     if (!Ctx && S->isTemplateParamScope() && OutsideOfTemplateParamDC &&
         S->getParent() && !S->getParent()->isTemplateParamScope()) {
       // We've just searched the last template parameter scope and
       // found nothing, so look into the contexts between the
       // lexical and semantic declaration contexts returned by
       // findOuterContext(). This implements the name lookup behavior
       // of C++ [temp.local]p8.
       Ctx = OutsideOfTemplateParamDC;
bool Sema::LookupInSuper(LookupResult &R, CXXRecordDecl *Class) {
   // The access-control rules we use here are essentially the rules for
   // doing a lookup in Class that just magically skipped the direct
   // members of Class itself.  That is, the naming class is Class, and the
   // access includes the access of the base.
   for (const auto &BaseSpec : Class->bases()) {
     CXXRecordDecl *RD = cast<CXXRecordDecl>(
         BaseSpec.getType()->castAs<RecordType>()->getDecl());
     LookupResult Result(*this, R.getLookupNameInfo(), R.getLookupKind());
+    if (R.isSynthetic())
+      Result.setSynthetic();
     Result.setBaseObjectType(Context.getRecordType(Class));
     LookupQualifiedName(Result, RD);
 
     // Copy the lookup results into the target, merging the base's access into
     // the path access.
     for (auto I = Result.begin(), E = Result.end(); I != E; ++I) {
       R.addDecl(I.getDecl(),
                 CXXRecordDecl::MergeAccess(BaseSpec.getAccessSpecifier(),

 
 void Sema::clearDelayedTypo(TypoExpr *TE) {
   DelayedTypos.erase(TE);
 }
 
 void Sema::ActOnPragmaDump(Scope *S, SourceLocation IILoc, IdentifierInfo *II) {
   DeclarationNameInfo Name(II, IILoc);
   LookupResult R(*this, Name, LookupAnyName, Sema::NotForRedeclaration);
+  R.setSynthetic();
   R.suppressDiagnostics();
   R.setHideTags(false);
   LookupName(R, S);
   R.dump();
 }

clang/lib/Sema/SemaTemplate.cpp

if (LookupCtx) {
     // is a type template, or finds no such members and lookup in the context
     // of the postfix-expression finds a type template. In the latter case, the
     // name is nonetheless dependent, and we may resolve it to a member of an
     // unknown specialization when we come to instantiate the template.
     IsDependent |= Found.wasNotFoundInCurrentInstantiation();
   }
 
   if (SS.isEmpty() && (ObjectType.isNull() || Found.empty())) {
+    if (IsDependent) {
+      // FIXME: Conservatively treat this fallback lookup as synthetic. We
+      // don't know whether we will actually want to look in the scope until
+      // instantiation.
+      Found.setSynthetic();
+    }
+
     // C++ [basic.lookup.classref]p1:
     //   In a class member access expression (5.2.5), if the . or -> token is
     //   immediately followed by an identifier followed by a <, the
     //   identifier must be looked up to determine whether the < is the
     //   beginning of a template argument list (14.2) or a less-than operator.
     //   The identifier is first looked up in the class of the object
     //   expression. If the identifier is not found, it is then looked up in
     //   the context of the entire postfix-expression and shall name a class

clang/test/CXX/basic/basic.scope/basic.scope.class/p2.cpp

+// RUN: %clang_cc1 -std=c++20 -verify %s
+
+// A name N used in a class S shall refer to the same declaration in its
+// context and when re-evaluated in the completed scope of S.
+
+enum Enum {};         // expected-note {{use a qualified name}}
+enum Enum2 {};        // expected-note {{use a qualified name}}
+class Class {};       // expected-note 4{{use a qualified name}}
+class Class2 {};      // expected-note 2{{use a qualified name}}
+class Class3 {};      // expected-note {{use a qualified name}}
+using Typedef = int;  // expected-note {{use a qualified name}}
+using Typedef2 = int; // expected-note {{use a qualified name}}
+int Function();       // expected-note {{use a qualified name}}
+
+struct UseInSelf {
+  Class *    // expected-warning {{name 'Class' refers to a member of class 'UseInSelf' that has not yet been declared}}
+      Class; // expected-note {{declared here after its point of use}}
+};
+
+struct Friends {
+  friend class FriendClass; // expected-warning {{name 'FriendClass' refers to a member of class 'Friends' that has not yet been declared}} expected-note {{injects non-member 'FriendClass'; if a member was intended, remove this friend declaration (befriending a member has no effect)}}
+  class FriendClass;        // expected-note {{member 'FriendClass' declared here after its point of use}}
+
+  friend class Class; // expected-warning {{not yet been declared}}
+  class Class;        // expected-note {{declared here}}
+
+  friend Class2; // expected-warning {{not yet been declared}}
+  class Class2;  // expected-note {{declared here}}
+
+  friend enum Enum;      // expected-warning {{not yet been declared}}
+  enum class Enum : int; // expected-note {{declared here}}
+
+  friend Enum2;           // expected-warning {{not yet been declared}}
+  enum class Enum2 : int; // expected-note {{declared here}}
+
+  friend int FriendFunction();
+  int FriendFunction();
+
+  friend int Function();
+  int Function();
+
+  friend Typedef;      // expected-warning {{not yet been declared}}
+  using Typedef = int; // expected-note {{declared here}}
+
+  friend Typedef2; // expected-warning {{not yet been declared}}
+  class Typedef2;  // expected-note {{declared here}}
+};
+
+struct Elaborated {
+  class Class *p1; // expected-warning {{not yet been declared}}
+  Class *q1;
+  class Class {}; // expected-note {{declared here}}
+
+  class Class2 *p2; // expected-warning {{not yet been declared}}
+  Class2 *q2;
+  using Class2 = int; // expected-note {{declared here}}
+
+  class Class3 *p3;   // expected-warning {{not yet been declared}}
+  using Class3 = int; // expected-note {{declared here}}
+};
+
+struct HasMember { // expected-note 2{{use a qualified name}}
+  using Member = int;
+};
+
+struct NestedNameSpecifierLookup1 {
+  // Here, it would not be OK to warn on the first usage, because the lookup
+  // for HasMember would ignore the member below.
+  HasMember::Member *p;
+  HasMember *q;  // FIXME: would be nice to indicate this usage is erroneous
+  int HasMember; // expected-warning {{declaration of member 'HasMember' after its name has already been used}}
+};
+
+struct NestedNameSpecifierLookup2 {
+  HasMember::Member *p; // expected-warning {{not yet been declared}}
+  HasMember *q;
+  struct HasMember; // expected-note {{declared here}}
+};
+
+struct NestedNameSpecifierLookup3 {
+  HasMember::Member *p; // OK, lookup ignores non-types.
+  int HasMember;
+};
+
+struct NestedNameSpecifierLookup4 {
+  HasMember::Member *p; // expected-warning {{not yet been declared}}
+  struct HasMember;     // expected-note {{declared here}}
+};
+
+struct NestedOuter {
+  struct NestedMiddle {
+    struct Inner {
+      Class *p; // expected-warning {{refers to a member of class 'NestedOuter::NestedMiddle' that has not yet been declared}}
+    };
+    struct Class {}; // expected-note {{declared here}}
+  };
+  struct Class {};
+};
+
+struct Enumerators {
+  int arr[sizeof(Function())]; // expected-warning {{refers to a member of class 'Enumerators'}}
+  enum {
+    Function = 1 // expected-note {{here}}
+  };
+};
+
+struct Operators {};
+int operator+(Operators, Operators);
+struct OperatorMembers {
+  int arr[sizeof(Operators() + Operators())];
+  int operator+(Operators);                   // OK, no conflict with the above
+  friend int operator+(Operators, Operators); // OK, no conflict with the above
+};
+
+namespace Namespace {}
+
+namespace A {
+struct Namespace {};
+
+struct UsingDirective1 {
+  constexpr static int a = [] { using namespace Namespace; return 0; }();
+  struct Namespace *ns;
+  int Namespace; // OK, does not hide either use.
+};
+
+// We get a worse warning here (with no use location) because neither use
+// below has a strictly more permissive IDNS.
+// FIXME: We could improve the diagnostic here: there's no way for a name
+// found by 'using namespace' to be hidden by a class-scope declaration.
+struct UsingDirective2 {
+  constexpr static int a = [] { using namespace Namespace; return 0; }();
+  struct Namespace *ns;
+  struct Namespace {}; // expected-warning {{declaration of member 'Namespace' after its name has already been used within the definition of class 'A::UsingDirective2'}}
+};
+
+struct UsingDirective3 {
+  constexpr static int a = [] { using namespace Namespace; return 0; }();
+  struct Namespace *ns;
+  using Namespace = int; // expected-warning {{declaration of member 'Namespace' after its name has already been used within the definition of class 'A::UsingDirective3'}}
+};
+} // namespace A
+
+struct DeclaredTooLate {
+  // FIXME: In this case it would be prefereable to diagnose that NewUniqueType
+  // has not yet been declared.
+  //
+  // We could in principle get this result by delaying the "undeclared"
+  // diagnostic until the end of the class (or until we want to produce another
+  // error, which might be a follow-on error from that error). It's not clear
+  // that this would be worth the complexity.
+  NewUniqueType f(); // expected-error {{unknown type name}}
+  struct NewUniqueType {};
+
+  static int a = unique_member_function_name(); // expected-error {{undeclared identifier}}
+  static int unique_member_function_name();
+};
+
+struct Undeclared {
+  // Don't also produce a "declared after use" warning here, even though we
+  // look up 'f' as a type before we declare it as a member.
+  f(); // expected-error {{requires a type specifier}}
+};
+
+struct IgnoringNonTypes {
+  template <typename T>
+  auto f(T t) -> decltype(t.template operator()<int>());
+  template <typename T>
+  auto f(T t) -> decltype(t.template g<int>());
+  template <typename T>
+  auto f(T t) -> decltype(t.template T<int>());
+  template <typename T>
+  auto f(T t) -> decltype(t.template U<int>::f());
+
+  template <typename>
+  void operator()();
+  template <typename>
+  void g();
+  template <typename>
+  struct T {};
+  template <typename>
+  struct U {};
+};
+
+namespace TagShadow {
+template <typename T>
+struct A {
+  struct X {}; // expected-note 2{{use a qualified name to refer to member of 'A<T>'}}
+  struct B {
+    X       // expected-warning {{member of class 'TagShadow::A::B' that has not yet been declared}}
+        *X; // expected-note {{declared here after its point of use}}
+  };
+  struct C {
+    using A = int;
+    X       // expected-warning {{not yet been declared}}
+        *X; // expected-note {{declared here}}
+  };
+  friend class Z; // expected-warning {{not yet been declared}} expected-note {{declaration injects non-member 'TagShadow::Z'; if a member was intended, remove}}
+  class Z {};     // expected-note {{declared here}}
+};
+struct W {
+  // FIXME: We should point out that this injects a non-member too, but this
+  // doesn't inject a tag declaration because 'TagShadow::Z' was already
+  // declared by 'A'.
+  friend class Z; // expected-warning {{not yet been declared}}
+  class Z {};     // expected-note {{declared here}}
+};
+
+struct QB; // expected-note {{use a qualified name}}
+struct Q {
+  struct QA *p; // tag lookup, expected-warning {{not yet been declared}} expected-note {{use a standalone forward declaration}}
+  int QA::*q;   // nested name specifier lookup
+  int QB::*r;   // nested name specifier lookup, expected-warning {{not yet been declared}}
+  struct QB *s; // tag lookup
+
+  struct QA {}; // expected-note {{declared here after its point of use}}
+  struct QB {}; // expected-note {{declared here after its point of use}}
+};
+} // namespace TagShadow

clang/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p4.cpp

 // RUN: %clang_cc1 -verify %s
 
 struct S {
   typedef struct A {} A; // expected-note {{previous definition is here}}
-  typedef struct B B;
+  typedef struct B       // expected-warning {{name 'B' refers to a member of class 'S' that has not yet been declared}}
+      B;                 // expected-note {{declared here}}
   typedef A A; // expected-error {{redefinition of 'A'}}
 
   struct C { };
   typedef struct C OtherC;
   typedef OtherC C;
 
   typedef struct D { } D2;
   typedef D2 D;
 };
 

clang/test/CXX/drs/dr2xx.cpp

struct S {
     friend inline void c(); // FIXME: ill-formed
     friend inline void d() {}
     friend inline void e() {}
     friend inline void f() {}
   };
 }
 
 namespace dr283 { // dr283: yes
-  template<typename T> // expected-note 2{{here}}
-  struct S {
-    friend class T; // expected-error {{shadows}}
-    class T; // expected-error {{shadows}}
-  };
+template <typename T> // expected-note {{here}}
+struct S1 {
+};
+template <typename T> // expected-note {{here}}
+struct S2 {
 }
 
 namespace dr284 { // dr284: no
   namespace A {
     struct X;
     enum Y {};
     class Z {};
   }

clang/test/CXX/expr/expr.prim/expr.prim.general/p3-0x.cpp

 }
 
 namespace rdar13473493 {
   template <typename F>
   class wrap
   {
   public:
     template <typename... Args>
-    auto operator()(Args&&... args) const -> decltype(wrapped(args...)) // expected-note{{candidate template ignored: substitution failure [with Args = <int>]: use of undeclared identifier 'wrapped'}}
+    auto operator()(Args &&... args) const -> decltype(wrapped(args...)) // expected-note{{candidate template ignored: substitution failure [with Args = <int>]: use of undeclared identifier 'wrapped'}}
+    // expected-warning@-1 {{name 'wrapped' refers to a member of class 'wrap<F>' that has not yet been declared}}
     {
       return wrapped(args...);
     }
-  
   private:
-    F wrapped;
+    F wrapped; // expected-note {{declared here}}
   };
 
   void test(wrap<int (*)(int)> w) {
     w(5); // expected-error{{no matching function for call to object of type 'wrap<int (*)(int)>'}}
   }
 }

clang/test/Parser/cxx-ambig-init-templ.cpp

struct S {
   int np1 = e<0, int a<b<c,b<c>::*>();
 
   static const int T1 = 4;
   template<int, int &(S::*)(int)> struct T2 { static const int val = 0; };
 };
 
 namespace NoAnnotationTokens {
   template<bool> struct Bool { Bool(int); };
-  static const bool in_class = false;
+  static const bool in_class = false; // expected-note {{use a qualified name to refer to member of namespace 'NoAnnotationTokens'}}
 
   struct Test {
     // Check we don't keep around a Bool<false> annotation token here.
     int f(Bool<true> = X<Y, Bool<in_class> >(0));
 
     // But it's OK if we do here.
-    int g(Bool<true> = Z<Y, Bool<in_class> = Bool<false>(0));
+    int g(Bool<true> = Z < Y, Bool<in_class> = Bool<false>(0)); // expected-warning {{not yet been declared}}
 
-    static const bool in_class = true;
+    static const bool in_class = true; // expected-note {{declared here}}
     template<int, typename U> using X = U;
     static const int Y = 0, Z = 0;
   };
 }
 
 namespace ImplicitInstantiation {
   template<typename T> struct HasError { typename T::error error; }; // expected-error {{has no members}}
 

clang/test/Parser/cxx0x-override-control-keywords.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
-// expected-no-diagnostics
 
 struct Base {
   virtual void override();
 };
 
 struct S : Base {
   virtual void final() final;
   virtual void override() override;
 };
 
 struct T : Base {
   virtual void override() override { } 
 };
 
-struct override;
+struct override; // expected-note {{use a qualified name to refer to member of the global namespace}}
 struct Base2 {
-  virtual override override(int override);
+  virtual override        // expected-warning {{not yet been declared}}
+  override(int override); // expected-note {{here}}
 };
 
 struct A : Base2 {
   virtual struct override override(int override) override;
 };

clang/test/SemaTemplate/alias-templates.cpp

namespace X {
   template<typename T> struct ptr_traits {
     typedef T *type;
   };
   template<typename T> using ptr = typename ptr_traits<T>::type;
 
   template<typename T> struct thing {
     typedef T inner;
     typedef ptr<inner> inner_ptr;
-    typedef traits<thing<inner>> traits_type;
+    typedef X::traits<thing<inner>> traits_type;
 
     template<typename U> using rebind = thing<U>;
 
     thing(traits_type &traits) : traits(traits), val(traits.alloc()) {}
     ~thing() { traits.free(static_cast<inner_ptr&&>(val)); }
 
     traits_type &traits;
     inner_ptr val;

clang/test/SemaTemplate/deduction-crash.cpp

 template<class>struct aaa
 {
   typedef ac<1,int,int>::ae ae // expected-error +{{}}
 };
 
 template<class>
 struct state_machine
 {
-  typedef aaa<int>::ae aaa;
+  typedef ::aaa<int>::ae aaa;
   int start()
   {
     ant(0);
   }
   
   template<class>
   struct region_processing_helper
   {

clang/test/SemaTemplate/instantiate-exception-spec-cxx11.cpp

namespace dr1330_example {
   struct U {
     void f() noexcept(T::error);
     void (g)() noexcept(T::error);
   };
   U<int> uint; // ok
 }
 
 namespace core_19754_example {
-  template<typename T> T declval() noexcept;
+namespace N {
+template <typename T>
+T declval() noexcept;
 
-  template<typename T, typename = decltype(T(declval<T&&>()))>
-  struct is_movable { static const bool value = true; };
+template <typename T, typename = decltype(T(declval<T &&>()))>
 
-  template<typename T>
-  struct wrap {
-    T val;
-    void irrelevant(wrap &p) noexcept(is_movable<T>::value);
-  };
+template <typename T>
 
   template<typename T>
   struct base {
      base() {}
      base(const typename T::type1 &);
      base(const typename T::type2 &);
   };
 
   template<typename T>
   struct type1 {
      wrap<typename T::base> base;
   };
 
   template<typename T>
   struct type2 {
      wrap<typename T::base> base;
   };
 
   struct types {
-     typedef base<types> base;
-     typedef type1<types> type1;
-     typedef type2<types> type2;
+    typedef N::base<types> base;
+    typedef N::type1<types> type1;
+    typedef N::type2<types> type2;
   };
 
   base<types> val = base<types>();
-}
+  } // namespace N
+  } // namespace core_19754_example
 
 namespace pr9485 {
   template <typename T> void f1(T) throw(typename T::exception); // expected-note {{candidate}}
   template <typename T> void f1(T, int = 0) throw(typename T::noitpecxe); // expected-note {{candidate}}
 
   template <typename T> void f2(T) noexcept(T::throws); // expected-note {{candidate}}
   template <typename T> void f2(T, int = 0) noexcept(T::sworht); // expected-note {{candidate}}
 

clang/test/SemaTemplate/ms-delayed-default-template-args.cpp

 }
 typedef double Baz;
 template struct nested::Foo<>;
 }
 
 namespace test_inner_class_template {
 struct Outer {
   template <typename T = Baz> // expected-warning {{using the undeclared type 'Baz' as a default template argument is a Microsoft extension}}
+  // expected-warning@-1 {{not yet been declared}}
   struct Foo {
     static_assert(sizeof(T) == 4, "should get int, not double");
   };
-  typedef int Baz;
+  typedef int Baz; // expected-note {{declared here}}
 };
 typedef double Baz;
 template struct Outer::Foo<>;
 }
 
 namespace test_nontype_param {
 template <typename T> struct Bar { T x; };
 typedef int Qux;