DR39: Perform ambiguous subobject checks for class member access as part of object argument conversion, not as part of name lookup.

[rsmith]

Summary

Under C++ core issue 39, the rules for class-scope name lookup were reworked so
that name lookup no longer concerns itself with whether the names were found in
an ambiguous subobject. The checks for an ambiguous subobject are now done as
part of conversion of the object argument in a member access (if needed)
instead.

One other important consequence of the new lookup rule is that it's now OK to
find different lookup results in multiple different classes, so long as the
same set of entities is found in each case (in any order, perhaps with
duplicates, and in the type case, perhaps via unrelated typedef declarations).

This patch implements the new lookup rule. This also has some follow-on impact
on access checks: it's now OK for name lookup to find different member
declarations in different base classes so long as they all resolve to the same
set of entities, so we now need to compute what the corresponding found
declaration is, and access-check it, for each path independently.

[rjmccall]

How does this new rule work if we find overlapping but non-equal sets of declarations in different subobjects? I'm sure you can get that with using declarations.

clang/include/clang/AST/CXXInheritance.h

77

Is there a way to know which case we're in, or do different consumers do different things?

[rjmccall]

(I didn't mean to submit the last comment before I finished the review, sorry)

It looks like you've chosen to treat this as a DR that we should apply under all standards. Have you investigated whether it causes compatibility problems? It does look like it'd be painful to try to support both rules.

clang/lib/Sema/SemaAccess.cpp

891

Is it okay to check them in sequence like this, or do we need to check in advance which case to use?

983

Is this not doing a *lot* of extra work? I suppose this is only in the slow path where we weren't able to immediately recognize that the found decl is public or we're in a scope with obviously adequate access?

clang/lib/Sema/SemaLookup.cpp

2296

I wonder under this new model if we can record that we saw something along ambiguous paths and avoid a lot of work in access-checking in the common case where we don't?

[rsmith]

In D94987#2507481, @rjmccall wrote:

How does this new rule work if we find overlapping but non-equal sets of declarations in different subobjects? I'm sure you can get that with using declarations.

You can. The rule is that you resolve using-declarations to the declarations they name, and you resolve typedef declarations to the types they name, and the resulting set of declarations and types must be the same in every subobject in which there are (non-shadowed) results -- if not, the lookup is ill-formed. (Put another way, the set of entities found in each subobject must be the same, but the set of declarations found in each subobject can differ.)

clang/include/clang/AST/CXXInheritance.h

77

We could use a discriminated union here. Ultimately, I think what we really want is to provide some opaque storage for the consumer to use, rather than to have some hard-coded list here. I haven't thought of a good way to expose that; I don't think it's worth templating the entire base path finding mechanism to add such storage, and a single pointer isn't large enough for a DeclContext::lookup_result.

Vassil's https://reviews.llvm.org/D91524 will make the lookup_result case fit into a single pointer; once we adopt that, perhaps we can switch to holding an opaque void* here?

clang/lib/Sema/SemaAccess.cpp

891

For types, declaresSameEntity returns true for a subset of the cases for which declaresSameType returns true, so it will always be correct to check both (though for a type, checking declaresSameEntity will always be redundant).

983

Compared to the isDerivedFrom check, this will be doing one extra decl context hash table lookup per class we consider on each path. I haven't measured the extra work here; I can if you're concerned.

I thought for a while about better ways to handle this, and I'm not sure there's a good middle ground between redoing the work like this and saving the base paths from name lookup and using them here. If you have better ideas, I'd appreciate them!

I suppose we probably have a spare bit on DeclAccessPair that we could use to track whether we're in the "hard" (found in classes of different types) case, and we could use isDerivedFrom in the "easy" cases. Do you think that's worthwhile?

Ah, I see you suggest doing something like that below. Yes, I can give that a go.

[rjmccall]

You can. The rule is that you resolve using-declarations to the declarations they name, and you resolve typedef declarations to the types they name, and the resulting set of declarations and types must be the same in every subobject in which there are (non-shadowed) results -- if not, the lookup is ill-formed. (Put another way, the set of entities found in each subobject must be the same, but the set of declarations found in each subobject can differ.)

Okay, makes sense. So the DeclAccessPairs in the lookup result are basically just the first+best pair we found for any particular entity?

clang/include/clang/AST/CXXInheritance.h

77

Yeah, that might be cleaner, assuming we really need this. What are the clients that need to store something specifically in the CXXBasePath object and can't just keep it separate?

clang/lib/Sema/SemaAccess.cpp

983

Thanks. Yeah, I think it would be nice if the very common case of finding something in a unique class didn't have to redo any lookups.

[rsmith]

In D94987#2521774, @rjmccall wrote:

You can. The rule is that you resolve using-declarations to the declarations they name, and you resolve typedef declarations to the types they name, and the resulting set of declarations and types must be the same in every subobject in which there are (non-shadowed) results -- if not, the lookup is ill-formed. (Put another way, the set of entities found in each subobject must be the same, but the set of declarations found in each subobject can differ.)

Okay, makes sense. So the DeclAccessPairs in the lookup result are basically just the first+best pair we found for any particular entity?

Yes, each pair comprises the declaration from the first subobject, with the best unprivileged access for the corresponding declarations in all subobjects.

clang/include/clang/AST/CXXInheritance.h

77

The main users of this are in name lookup proper (where we store the lookup results on the path to avoid redoing the class scope hash table lookup) and now in access checking (where we store the most-accessible declaration). I think there's a couple of other name-lookup-like clients that also store a lookup result here.

In all cases the side storage is just a convenience. But it's probably an important convenience; it's awkward for a client to maintain a mapping on the side, because the key for that map would end up being the entire base path.

We could just number the paths as we find them, and let the consumers build a SmallVector on the side rather than storing data in the CXXBasePaths. We'd need to be careful about the post-processing pass in lookupInBases that removes virtual base paths that are shadowed by non-virtual inheritance from the vbase, but that seems feasible. Worthwhile?

[rjmccall]

clang/include/clang/AST/CXXInheritance.h

77

I see what you're saying. We have places that compute all the base paths in an array, and it's convenient to be able to stash things into the elements of that array instead of having a second data structure that's parallel to it. I guess there are three options:

• Tell clients to just make a parallel structure.

• Have this sort of intrusive storage and just accept that clients that want to use it will have some awkward casting to do.

• Get rid of the initial array dependence by making it a callback API instead of an array-building API, and then clients that want to build an array can build an array with the type they actually want.

I guess the third might be awkward?

[rsmith]

clang/include/clang/AST/CXXInheritance.h

77

Yes, the problem with the third option is its interaction with the post-processing step in CXXRecordDecl::lookupInBases. We're not supposed to consider virtual bases if they're shadowed along any path. The way that lookupInBases handles this is by first finding all paths to subobjects, and then removing any path containing an edge to a virtual base for which some other path ends in a class deriving from that vbase. So we end up with the callback being called spuriously in some cases, and lookupInBases ends up producing only a subset of the paths that were followed.

I'm pretty sure we could rearchitect the lookup process so that this doesn't happen -- so that we never visit a virtual base until we've finished traversing all subobjects that virtually inherit from it -- but that's not what the lookupInBases algorithm is doing right now.

[rjmccall]

clang/include/clang/AST/CXXInheritance.h

77

Okay. In the end, architecturally it's a little suspect that this is here, but I definitely don't think we need to hold up this patch to eliminate it; we can just flag that this is for arbitrary client use.

clang/include/clang/AST/CXXInheritance.h

 /// subobject is being used.
 class CXXBasePath : public SmallVector<CXXBasePathElement, 4> {
 public:
   /// The access along this inheritance path.  This is only
   /// calculated when recording paths.  AS_none is a special value
   /// used to indicate a path which permits no legal access.
   AccessSpecifier Access = AS_public;
 
-  CXXBasePath() = default;
-
+  /// Additional data stashed on the base path by its consumers.
+  union {
     /// The set of declarations found inside this base class
-  /// subobject.
-  DeclContext::lookup_result Decls;
+    /// subobject. Used by name lookup.
+    DeclContext::lookup_result Decls = {};
+
+    /// The most-accessible declaration found inside this base class.
+    /// Used by access checking.
+    NamedDecl *BestDecl;
+  };
 
   void clear() {
     SmallVectorImpl<CXXBasePathElement>::clear();
     Access = AS_public;
   }
 };
 
 /// BasePaths - Represents the set of paths from a derived class to
public:
   const_paths_iterator begin() const { return Paths.begin(); }
   const_paths_iterator end()   const { return Paths.end(); }
 
   CXXBasePath&       front()       { return Paths.front(); }
   const CXXBasePath& front() const { return Paths.front(); }
 
   using decl_range = llvm::iterator_range<decl_iterator>;
 
+  const CXXBasePath *getUniquePath() const {
+    if (begin() == end())
+      return nullptr;
+    if (std::next(begin()) == end())
+      return &*begin();
+    return nullptr;
+  }
+
   /// Determine whether the path from the most-derived type to the
   /// given base type is ambiguous (i.e., it refers to multiple subobjects of
   /// the same base type).
   bool isAmbiguous(CanQualType BaseType);
 
   /// Whether we are finding multiple paths to detect ambiguities.
   bool isFindingAmbiguities() const { return FindAmbiguities; }
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

def ext_ms_ambiguous_direct_base : ExtWarn<
   "accessing inaccessible direct base %0 of %1 is a Microsoft extension">,
   InGroup<MicrosoftInaccessibleBase>;
 
 def err_memptr_conv_via_virtual : Error<
   "conversion from pointer to member of class %0 to pointer to member "
   "of class %1 via virtual base %2 is not allowed">;
 
 // C++ member name lookup
-def err_ambiguous_member_multiple_subobjects : Error<
-  "non-static member %0 found in multiple base-class subobjects of type %1:%2">;
-def err_ambiguous_member_multiple_subobject_types : Error<
-  "member %0 found in multiple base classes of different types">;
-def note_ambiguous_member_found : Note<"member found by ambiguous name lookup">;
+def err_ambiguous_member_different_results_in_multiple_subobjects : Error<
+  "member %0 found in multiple base classes with differing lookup results">;
+def note_ambiguous_member_found : Note<
+  "member found by ambiguous name lookup in %0">;
 def note_ambiguous_member_type_found : Note<
-  "member type %0 found by ambiguous name lookup">;
+  "member type %1 found by ambiguous name lookup in %0">;
 def err_ambiguous_reference : Error<"reference to %0 is ambiguous">;
 def note_ambiguous_candidate : Note<"candidate found by name lookup is %q0">;
 def err_ambiguous_tag_hiding : Error<"a type named %0 is hidden by a "
   "declaration in a different namespace">;
 def note_hidden_tag : Note<"type declaration hidden">;
 def note_hiding_object : Note<"declaration hides type">;
 
 // C++ operator overloading

clang/include/clang/Sema/DelayedDiagnostic.h

public:
   /// A hierarchy (base-to-derived or derived-to-base) conversion.
   /// The target is the base class.
   enum BaseNonce { Base };
 
   AccessedEntity(PartialDiagnostic::DiagStorageAllocator &Allocator,
                  MemberNonce _, CXXRecordDecl *NamingClass,
                  DeclAccessPair FoundDecl, QualType BaseObjectType)
       : Access(FoundDecl.getAccess()), IsMember(true),
-        Target(FoundDecl.getDecl()), NamingClass(NamingClass),
-        BaseObjectType(BaseObjectType), Diag(0, Allocator) {}
+        Target(FoundDecl.getDecl()->getUnderlyingDecl()),
+        NamingClass(NamingClass), BaseObjectType(BaseObjectType),
+        Diag(0, Allocator) {}
 
   AccessedEntity(PartialDiagnostic::DiagStorageAllocator &Allocator,
                  BaseNonce _, CXXRecordDecl *BaseClass,
                  CXXRecordDecl *DerivedClass, AccessSpecifier Access)
       : Access(Access), IsMember(false), Target(BaseClass),
         NamingClass(DerivedClass), Diag(0, Allocator) {}
 
   bool isMemberAccess() const { return IsMember; }
 
   bool isQuiet() const { return Diag.getDiagID() == 0; }
 
   AccessSpecifier getAccess() const { return AccessSpecifier(Access); }
 
   // These apply to member decls...
   NamedDecl *getTargetDecl() const { return Target; }
   CXXRecordDecl *getNamingClass() const { return NamingClass; }
+  void setTargetDecl(NamedDecl *ND) { Target = ND; }
 
   // ...and these apply to hierarchy conversions.
   CXXRecordDecl *getBaseClass() const {
     assert(!IsMember); return cast<CXXRecordDecl>(Target);
   }
   CXXRecordDecl *getDerivedClass() const { return NamingClass; }
 
   /// Retrieves the base object type, important when accessing

clang/include/clang/Sema/Lookup.h

enum LookupResultKind {
     /// getAmbiguityKind to figure out what kind of ambiguity
     /// we have.
     Ambiguous
   };
 
   enum AmbiguityKind {
     /// Name lookup results in an ambiguity because multiple
     /// entities that meet the lookup criteria were found in
-    /// subobjects of different types. For example:
+    /// subobjects of different types, and the lookup results
+    /// were not the same in every type. For example:
     /// @code
     /// struct A { void f(int); }
     /// struct B { void f(double); }
     /// struct C : A, B { };
     /// void test(C c) {
     ///   c.f(0); // error: A::f and B::f come from subobjects of different
     ///           // types. overload resolution is not performed.
     /// }
     /// @endcode
-    AmbiguousBaseSubobjectTypes,
-
-    /// Name lookup results in an ambiguity because multiple
-    /// nonstatic entities that meet the lookup criteria were found
-    /// in different subobjects of the same type. For example:
-    /// @code
-    /// struct A { int x; };
-    /// struct B : A { };
-    /// struct C : A { };
-    /// struct D : B, C { };
-    /// int test(D d) {
-    ///   return d.x; // error: 'x' is found in two A subobjects (of B and C)
-    /// }
-    /// @endcode
-    AmbiguousBaseSubobjects,
+    AmbiguousBaseSubobjectResults,
 
     /// Name lookup results in an ambiguity because multiple definitions
     /// of entity that meet the lookup criteria were found in different
     /// declaration contexts.
     /// @code
     /// namespace A {
     ///   int i;
     ///   namespace B { int i; }
NamedDecl *getRepresentativeDecl() const {
     return *begin();
   }
 
   /// Asks if the result is a single tag decl.
   bool isSingleTagDecl() const {
     return getResultKind() == Found && isa<TagDecl>(getFoundDecl());
   }
 
-  /// Make these results show that the name was found in
-  /// base classes of different types.
-  ///
-  /// The given paths object is copied and invalidated.
-  void setAmbiguousBaseSubobjectTypes(CXXBasePaths &P);
-
-  /// Make these results show that the name was found in
-  /// distinct base classes of the same type.
+  /// Make these results show that different lookup results were found in
+  /// multiple base classes.
   ///
   /// The given paths object is copied and invalidated.
-  void setAmbiguousBaseSubobjects(CXXBasePaths &P);
+  void setAmbiguousBaseSubobjectResults(CXXBasePaths &P);
 
   /// Make these results show that the name was found in
   /// different contexts and a tag decl was hidden by an ordinary
   /// decl in a different context.
   void setAmbiguousQualifiedTagHiding() {
     setAmbiguous(AmbiguousTagHiding);
   }
 

clang/lib/Sema/SemaAccess.cpp

struct AccessTarget : public AccessedEntity {
   /// class containing the actual naming class.
   const CXXRecordDecl *getEffectiveNamingClass() const {
     const CXXRecordDecl *namingClass = getNamingClass();
     while (namingClass->isAnonymousStructOrUnion())
       namingClass = cast<CXXRecordDecl>(namingClass->getParent());
     return namingClass->getCanonicalDecl();
   }
 
+  /// Update the target to a specific, most-accessible declaration of the
+  /// entity.
+  void resolveTarget(NamedDecl *ND) {
+    setTargetDecl(ND);
+    DeclaringClass = FindDeclaringClass(ND);
+  }
+
 private:
   void initialize() {
     HasInstanceContext = (isMemberAccess() &&
                           !getBaseObjectType().isNull() &&
                           getTargetDecl()->isCXXInstanceMember());
     CalculatedInstanceContext = false;
     InstanceContext = nullptr;
 
static AccessResult HasAccess(Sema &S,
   case AR_inaccessible: return OnFailure;
   case AR_dependent: return AR_dependent;
   }
 
   // Silence bogus warnings
   llvm_unreachable("impossible friendship kind");
 }
 
+static bool declaresSameType(ASTContext &Ctx, NamedDecl *D1, NamedDecl *D2) {
+  auto *T1 = dyn_cast<TypeDecl>(D1);
+  auto *T2 = dyn_cast<TypeDecl>(D2);
+  return T1 && T2 &&
+         Ctx.hasSameType(Ctx.getTypeDeclType(T1), Ctx.getTypeDeclType(T2));
+}
+
+/// Find the most accessible redeclaration of the target in RD.
+static NamedDecl *
+FindBestCorrespondingMember(Sema &S, const CXXRecordDecl *RD,
+                            const AccessTarget &Target) {
+  NamedDecl *Best = nullptr;
+  for (NamedDecl *Corresponding :
+       RD->lookup(Target.getTargetDecl()->getDeclName())) {
+    // Note that declaresSameEntity doesn't correctly determine whether
+    // two type declarations declare the same type entity.
+    if ((!Best || Best->getAccess() > Corresponding->getAccess()) &&
+        (declaresSameEntity(Corresponding->getUnderlyingDecl(),
+                            Target.getTargetDecl()->getUnderlyingDecl()) ||
+         declaresSameType(S.Context, Corresponding->getUnderlyingDecl(),
+                          Target.getTargetDecl()->getUnderlyingDecl())))
+      Best = Corresponding;
+  }
+  return Best;
+}
+
 /// Finds the best path from the naming class to the declaring class,
 /// taking friend declarations into account.
 ///
 /// C++0x [class.access.base]p5:
 ///   A member m is accessible at the point R when named in class N if
 ///   [M1] m as a member of N is public, or
 ///   [M2] m as a member of N is private, and R occurs in a member or
 ///        friend of class N, or

 ///   Accessible(c, public) = true
 ///   ACAB(n) = public
 ///   ACAB(i) =
 ///     let AccessToBase = Merge(Access(B_i, B_{i+1}), ACAB(i+1)) in
 ///     if Accessible(B_i, AccessToBase) then public else AccessToBase
 ///
 /// B is an accessible base of N at R iff ACAB(1) = public.
 ///
-/// \param FinalAccess the access of the "final step", or AS_public if
-///   there is no final step.
+/// Note that we don't actually know which member was named here, because class
+/// scope name lookup can find different sets of declarations of the same
+/// entities in different classes. So we also redo the name lookup for the
+/// member in each class in case a using-declaration or typedef changed its
+/// access along some path.
+///
+/// \param Target the access target, updated to the corresponding member found
+///        along the best path.
 /// \return null if friendship is dependent
 static CXXBasePath *FindBestPath(Sema &S,
                                  const EffectiveContext &EC,
                                  AccessTarget &Target,
-                                 AccessSpecifier FinalAccess,
                                  CXXBasePaths &Paths) {
   // Derive the paths to the desired base.
   const CXXRecordDecl *Derived = Target.getNamingClass();
-  const CXXRecordDecl *Base = Target.getDeclaringClass();
 
-  // FIXME: fail correctly when there are dependent paths.
+  if (Target.isMemberAccess()) {
+    // Redo class-scope lookup to find the set of possible access paths.
+    auto DeclaresCorrespondingMember = [&](const CXXBaseSpecifier *Specifier,
+                                           CXXBasePath &Path) {
+      // Because name lookup didn't encounter an ambiguity, we know that this
+      // lookup will stop at exactly the classes where non-shadowed
+      // declarations of the found entity were found.
+      if (NamedDecl *BestMember = FindBestCorrespondingMember(
+              S, Specifier->getType()->getAsCXXRecordDecl(), Target)) {
+        Path.BestDecl = BestMember;
+        return true;
+      }
+      return false;
+    };
+    Derived->lookupInBases(DeclaresCorrespondingMember, Paths);
+  } else {
+    const CXXRecordDecl *Base = Target.getDeclaringClass();
     bool isDerived = Derived->isDerivedFrom(const_cast<CXXRecordDecl*>(Base),
                                             Paths);
     assert(isDerived && "derived class not actually derived from base");
     (void) isDerived;
+  }
 
-  CXXBasePath *BestPath = nullptr;
+  assert(Paths.begin() != Paths.end() && "no paths?");
 
-  assert(FinalAccess != AS_none && "forbidden access after declaring class");
+  CXXBasePath *BestPath = nullptr;
+  NamedDecl *BestTarget = nullptr;
 
   bool AnyDependent = false;
 
   // Derive the friend-modified access along each path.
   for (CXXBasePaths::paths_iterator PI = Paths.begin(), PE = Paths.end();
          PI != PE; ++PI) {
     AccessTarget::SavedInstanceContext _ = Target.saveInstanceContext();
+    AccessSpecifier PathAccess;
+
+    if (Target.isMemberAccess()) {
+      // Determine if the declaration at the end of this path is accessible
+      // from EC when named in the corresponding base class.
+      const CXXRecordDecl *DeclaringClass =
+          PI->back().Base->getType()->getAsCXXRecordDecl();
+      PathAccess = PI->BestDecl->getAccess();
+      switch (HasAccess(S, EC, DeclaringClass, PathAccess, Target)) {
+      case AR_accessible:
+        PathAccess = AS_public;
+        // Future tests are not against members and so do not have
+        // instance context.
+        Target.suppressInstanceContext();
+        break;
+      case AR_inaccessible:
+        break;
+      case AR_dependent:
+        AnyDependent = true;
+        continue;
+      }
+    } else {
+      PathAccess = AS_public;
+    }
 
     // Walk through the path backwards.
-    AccessSpecifier PathAccess = FinalAccess;
     CXXBasePath::iterator I = PI->end(), E = PI->begin();
     while (I != E) {
       --I;
 
-      assert(PathAccess != AS_none);
-
       // If the declaration is a private member of a base class, there
       // is no level of friendship in derived classes that can make it
       // accessible.
-      if (PathAccess == AS_private) {
+      if (PathAccess == AS_private)
         PathAccess = AS_none;
-        break;
-      }
 
       const CXXRecordDecl *NC = I->Class->getCanonicalDecl();
 
       AccessSpecifier BaseAccess = I->Base->getAccessSpecifier();
       PathAccess = std::max(PathAccess, BaseAccess);
 
+      if (PathAccess == AS_none) {
+        if (Target.isMemberAccess())
+          continue;
+        else
+          break;
+      }
+
       switch (HasAccess(S, EC, NC, PathAccess, Target)) {
       case AR_inaccessible: break;
       case AR_accessible:
         PathAccess = AS_public;
 
         // Future tests are not against members and so do not have
         // instance context.
         Target.suppressInstanceContext();
         break;
       case AR_dependent:
         AnyDependent = true;
         goto Next;
       }
     }
 
-    // Note that we modify the path's Access field to the
-    // friend-modified access.
+    // Note that we modify the path's Access field to the friend-modified,
+    // target-specific access to the best corresponding member.
     if (BestPath == nullptr || PathAccess < BestPath->Access) {
       BestPath = &*PI;
       BestPath->Access = PathAccess;
+      BestTarget = PI->BestDecl;
 
       // Short-circuit if we found a public path.
-      if (BestPath->Access == AS_public)
+      if (BestPath->Access == AS_public) {
+        if (Target.isMemberAccess())
+          Target.resolveTarget(BestTarget);
         return BestPath;
       }
+    }
 
   Next: ;
   }
 
   assert((!BestPath || BestPath->Access != AS_public) &&
          "fell out of loop with public path");
 
   // We didn't find a public path, but at least one path was subject
   // to dependent friendship, so delay the check.
   if (AnyDependent)
     return nullptr;
 
+  if (Target.isMemberAccess() && BestPath)
+    Target.resolveTarget(BestTarget);
   return BestPath;
 }
 
 /// Given that an entity has protected natural access, check whether
 /// access might be denied because of the protected member access
 /// restriction.
 ///
 /// \return true if a note was emitted
static void DiagnoseAccessPath(Sema &S,
                                const EffectiveContext &EC,
                                AccessTarget &entity) {
   // Save the instance context to preserve invariants.
   AccessTarget::SavedInstanceContext _ = entity.saveInstanceContext();
 
   // This basically repeats the main algorithm but keeps some more
   // information.
 
-  // The natural access so far.
-  AccessSpecifier accessSoFar = AS_public;
+  // We might find the declaration in the naming class itself. In that case,
+  // we don't need to consider paths.
+  if (NamedDecl *BestMember = FindBestCorrespondingMember(
+          S, entity.getEffectiveNamingClass(), entity)) {
+    entity.resolveTarget(BestMember);
+    return diagnoseBadDirectAccess(S, EC, entity);
+  }
 
-  // Check whether we have special rights to the declaring class.
+  CXXBasePaths paths;
+  CXXBasePath &path = *FindBestPath(S, EC, entity, paths);
+  assert(path.Access != AS_public);
+
+  // Re-derive the access to the declaration, if any.
+  AccessSpecifier accessSoFar = AS_public;
   if (entity.isMemberAccess()) {
-    NamedDecl *D = entity.getTargetDecl();
-    accessSoFar = D->getAccess();
-    const CXXRecordDecl *declaringClass = entity.getDeclaringClass();
+    accessSoFar = path.BestDecl->getAccess();
+    assert(accessSoFar != AS_none);
 
+    const CXXRecordDecl *declaringClass =
+        path.back().Base->getType()->getAsCXXRecordDecl();
     switch (HasAccess(S, EC, declaringClass, accessSoFar, entity)) {
-    // If the declaration is accessible when named in its declaring
-    // class, then we must be constrained by the path.
+    case AR_inaccessible: break;
     case AR_accessible:
       accessSoFar = AS_public;
       entity.suppressInstanceContext();
       break;
-
-    case AR_inaccessible:
-      if (accessSoFar == AS_private ||
-          declaringClass == entity.getEffectiveNamingClass())
-        return diagnoseBadDirectAccess(S, EC, entity);
-      break;
-
     case AR_dependent:
       llvm_unreachable("cannot diagnose dependent access");
     }
+    if (accessSoFar == AS_private)
+      return diagnoseBadDirectAccess(S, EC, entity);
   }
 
-  CXXBasePaths paths;
-  CXXBasePath &path = *FindBestPath(S, EC, entity, accessSoFar, paths);
-  assert(path.Access != AS_public);
-
   CXXBasePath::iterator i = path.end(), e = path.begin();
   CXXBasePath::iterator constrainingBase = i;
   while (i != e) {
     --i;
 
-    assert(accessSoFar != AS_none && accessSoFar != AS_private);
-
     // Is the entity accessible when named in the deriving class, as
     // modified by the base specifier?
     const CXXRecordDecl *derivingClass = i->Class->getCanonicalDecl();
     const CXXBaseSpecifier *base = i->Base;
 
     // If the access to this base is worse than the access we have to
     // the declaration, remember it.
     AccessSpecifier baseAccess = base->getAccessSpecifier();
     if (baseAccess > accessSoFar) {
       constrainingBase = i;
       accessSoFar = baseAccess;
     }
 
     switch (HasAccess(S, EC, derivingClass, accessSoFar, entity)) {
     case AR_inaccessible: break;
     case AR_accessible:
       accessSoFar = AS_public;
       entity.suppressInstanceContext();
-      constrainingBase = nullptr;
+      constrainingBase = path.end();
       break;
     case AR_dependent:
       llvm_unreachable("cannot diagnose dependent access");
     }
 
     // If this was private inheritance, but we don't have access to
     // the deriving class, we're done.
     if (accessSoFar == AS_private) {
case AR_dependent:
       // access.
       return AR_dependent;
 
     case AR_accessible: return AR_accessible;
     case AR_inaccessible: break;
     }
   }
 
-  AccessTarget::SavedInstanceContext _ = Entity.saveInstanceContext();
-
-  // We lower member accesses to base accesses by pretending that the
-  // member is a base class of its declaring class.
-  AccessSpecifier FinalAccess;
-
+  // If the entity is declared in the naming class, we don't need to consider
+  // paths.
   if (Entity.isMemberAccess()) {
-    // Determine if the declaration is accessible from EC when named
-    // in its declaring class.
-    NamedDecl *Target = Entity.getTargetDecl();
-    const CXXRecordDecl *DeclaringClass = Entity.getDeclaringClass();
-
-    FinalAccess = Target->getAccess();
-    switch (HasAccess(S, EC, DeclaringClass, FinalAccess, Entity)) {
-    case AR_accessible:
-      // Target is accessible at EC when named in its declaring class.
-      // We can now hill-climb and simply check whether the declaring
-      // class is accessible as a base of the naming class.  This is
-      // equivalent to checking the access of a notional public
-      // member with no instance context.
-      FinalAccess = AS_public;
-      Entity.suppressInstanceContext();
-      break;
-    case AR_inaccessible: break;
-    case AR_dependent: return AR_dependent; // see above
+    if (NamedDecl *BestMember =
+            FindBestCorrespondingMember(S, NamingClass, Entity)) {
+      Entity.resolveTarget(BestMember);
+      // Don't repeat checks we already performed when checking unprivileged
+      // access above.
+      if (UnprivilegedAccess != AS_none &&
+          BestMember->getAccess() >= UnprivilegedAccess)
+        return AR_inaccessible;
+      return HasAccess(S, EC, NamingClass, BestMember->getAccess(), Entity);
     }
-
-    if (DeclaringClass == NamingClass)
-      return (FinalAccess == AS_public ? AR_accessible : AR_inaccessible);
-  } else {
-    FinalAccess = AS_public;
   }
 
-  assert(Entity.getDeclaringClass() != NamingClass);
-
-  // Append the declaration's access if applicable.
+  // Find the most-accessible path to the entity.
   CXXBasePaths Paths;
-  CXXBasePath *Path = FindBestPath(S, EC, Entity, FinalAccess, Paths);
+  CXXBasePath *Path = FindBestPath(S, EC, Entity, Paths);
   if (!Path)
     return AR_dependent;
 
   assert(Path->Access <= UnprivilegedAccess &&
          "access along best path worse than direct?");
   if (Path->Access == AS_public)
     return AR_accessible;
   return AR_inaccessible;

clang/lib/Sema/SemaLookup.cpp

bool LookupResult::sanity() const {
   // This function is never called by NDEBUG builds.
   assert(ResultKind != NotFound || Decls.size() == 0);
   assert(ResultKind != Found || Decls.size() == 1);
   assert(ResultKind != FoundOverloaded || Decls.size() > 1 ||
          (Decls.size() == 1 &&
           isa<FunctionTemplateDecl>((*begin())->getUnderlyingDecl())));
   assert(ResultKind != FoundUnresolvedValue || sanityCheckUnresolved());
   assert(ResultKind != Ambiguous || Decls.size() > 1 ||
-         (Decls.size() == 1 && (Ambiguity == AmbiguousBaseSubobjects ||
-                                Ambiguity == AmbiguousBaseSubobjectTypes)));
+         (Decls.size() == 1 && Ambiguity == AmbiguousBaseSubobjectResults));
   assert((Paths != nullptr) == (ResultKind == Ambiguous &&
-                                (Ambiguity == AmbiguousBaseSubobjectTypes ||
-                                 Ambiguity == AmbiguousBaseSubobjects)));
+                                Ambiguity == AmbiguousBaseSubobjectResults));
   return true;
 }
 
 // Necessary because CXXBasePaths is not complete in Sema.h
 void LookupResult::deletePaths(CXXBasePaths *Paths) {
   delete Paths;
 }
 
if (!ExistingI) {
       if (!UniqueResult.second) {
         // We've seen this entity before.
         ExistingI = UniqueResult.first->second;
       }
     }
 
     if (ExistingI) {
       // This is not a unique lookup result. Pick one of the results and
-      // discard the other.
+      // discard the other. Keep the more-permissive access specifier.
+      AccessSpecifier AS =
+          std::min(Decls[I].getAccess(), Decls[*ExistingI].getAccess());
       if (isPreferredLookupResult(getSema(), getLookupKind(), Decls[I],
                                   Decls[*ExistingI]))
         Decls[*ExistingI] = Decls[I];
+      Decls[*ExistingI].setAccess(AS);
       Decls[I] = Decls[--N];
       continue;
     }
 
     // Otherwise, do some decl type analysis and then continue.
 
     if (isa<UnresolvedUsingValueDecl>(D)) {
       HasUnresolved = true;

 void LookupResult::addDeclsFromBasePaths(const CXXBasePaths &P) {
   CXXBasePaths::const_paths_iterator I, E;
   for (I = P.begin(), E = P.end(); I != E; ++I)
     for (DeclContext::lookup_iterator DI = I->Decls.begin(),
          DE = I->Decls.end(); DI != DE; ++DI)
       addDecl(*DI);
 }
 
-void LookupResult::setAmbiguousBaseSubobjects(CXXBasePaths &P) {
+void LookupResult::setAmbiguousBaseSubobjectResults(CXXBasePaths &P) {
   Paths = new CXXBasePaths;
   Paths->swap(P);
   addDeclsFromBasePaths(*Paths);
   resolveKind();
-  setAmbiguous(AmbiguousBaseSubobjects);
-}
-
-void LookupResult::setAmbiguousBaseSubobjectTypes(CXXBasePaths &P) {
-  Paths = new CXXBasePaths;
-  Paths->swap(P);
-  addDeclsFromBasePaths(*Paths);
-  resolveKind();
-  setAmbiguous(AmbiguousBaseSubobjectTypes);
+  setAmbiguous(AmbiguousBaseSubobjectResults);
 }
 
 void LookupResult::print(raw_ostream &Out) {
   Out << Decls.size() << " result(s)";
   if (isAmbiguous()) Out << ", ambiguous";
   if (Paths) Out << ", base paths present";
 
   for (iterator I = begin(), E = end(); I != E; ++I) {
bool Sema::LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
   // See also [class.mfct]p5 and [class.static.data]p2.
   if (R.isForRedeclaration())
     return false;
 
   // If this is a namespace, look it up in the implied namespaces.
   if (LookupCtx->isFileContext())
     return LookupQualifiedNameInUsingDirectives(*this, R, LookupCtx);
 
-  // If this isn't a C++ class, we aren't allowed to look into base
+  // If this isn't a C++ class, or we aren't allowed to look into base
   // classes, we're done.
   CXXRecordDecl *LookupRec = dyn_cast<CXXRecordDecl>(LookupCtx);
   if (!LookupRec || !LookupRec->getDefinition())
     return false;
 
   // We're done for lookups that can never succeed for C++ classes.
   if (R.getLookupKind() == LookupOperatorName ||
       R.getLookupKind() == LookupNamespaceName ||
       R.getLookupKind() == LookupObjCProtocolName ||
       R.getLookupKind() == LookupLabel)
     return false;
 
   // If we're performing qualified name lookup into a dependent class,
   // then we are actually looking into a current instantiation. If we have any
   // dependent base classes, then we either have to delay lookup until
   // template instantiation time (at which point all bases will be available)
   // or we have to fail.
   if (!InUnqualifiedLookup && LookupRec->isDependentContext() &&
       LookupRec->hasAnyDependentBases()) {
     R.setNotFoundInCurrentInstantiation();
     return false;
   }
 
   // Perform lookup into our base classes.
+  //
+  // C++ [class.member.lookup] describes the process to perform here as if we
+  // recursively perform lookups in all base classes and merge them, but it's
+  // equivalent and much simpler to think about it differently: find all the
+  // base class subobjects that have lookup results that are not shadowed along
+  // any inheritance path to that subobject. Those lookup results are required
+  // to all be the same, and are the result of the class-scope lookup.
 
   DeclarationName Name = R.getLookupName();
   unsigned IDNS = R.getIdentifierNamespace();
 
   // Look for this member in our base classes.
   auto BaseCallback = [Name, IDNS](const CXXBaseSpecifier *Specifier,
                                    CXXBasePath &Path) -> bool {
     CXXRecordDecl *BaseRecord = Specifier->getType()->getAsCXXRecordDecl();
bool Sema::LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
 
   CXXBasePaths Paths;
   Paths.setOrigin(LookupRec);
   if (!LookupRec->lookupInBases(BaseCallback, Paths))
     return false;
 
   R.setNamingClass(LookupRec);
 
-  // C++ [class.member.lookup]p2:
-  //   [...] If the resulting set of declarations are not all from
-  //   sub-objects of the same type, or the set has a nonstatic member
-  //   and includes members from distinct sub-objects, there is an
-  //   ambiguity and the program is ill-formed. Otherwise that set is
-  //   the result of the lookup.
-  QualType SubobjectType;
-  int SubobjectNumber = 0;
-  AccessSpecifier SubobjectAccess = AS_none;
-
-  // Check whether the given lookup result contains only static members.
-  auto HasOnlyStaticMembers = [&](DeclContextLookupResult Result) {
-    for (NamedDecl *ND : Result)
-      if (ND->isInIdentifierNamespace(IDNS) && ND->isCXXInstanceMember())
-        return false;
+  // Fast-path the common case where we find results along exactly one path.
+  if (const CXXBasePath *Path = Paths.getUniquePath()) {
+    for (NamedDecl *ND : Path->Decls) {
+      if (!ND->isInIdentifierNamespace(R.getIdentifierNamespace()))
+        continue;
+
+      AccessSpecifier AS =
+          CXXRecordDecl::MergeAccess(Path->Access, ND->getAccess());
+      R.addDecl(ND, AS);
+    }
+    R.resolveKind();
     return true;
-  };
+  }
 
-  bool TemplateNameLookup = R.isTemplateNameLookup();
+  // Otherwise we need to compute the corresponding members in all base classes
+  // in order to check for ambiguity and find the path with maximal access.
 
-  // Determine whether two sets of members contain the same members, as
-  // required by C++ [class.member.lookup]p6.
-  auto HasSameDeclarations = [&](DeclContextLookupResult A,
-                                 DeclContextLookupResult B) {
-    using Iterator = DeclContextLookupResult::iterator;
-    using Result = const void *;
-
-    auto Next = [&](Iterator &It, Iterator End) -> Result {
-      while (It != End) {
-        NamedDecl *ND = *It++;
-        if (!ND->isInIdentifierNamespace(IDNS))
-          continue;
+  using MemberResult = const void*;
+
+  auto AsMemberResult = [&](NamedDecl *ND) -> MemberResult {
+    ND = ND->getUnderlyingDecl();
 
-        // C++ [temp.local]p3:
-        //   A lookup that finds an injected-class-name (10.2) can result in
-        //   an ambiguity in certain cases (for example, if it is found in
-        //   more than one base class). If all of the injected-class-names
-        //   that are found refer to specializations of the same class
-        //   template, and if the name is used as a template-name, the
-        //   reference refers to the class template itself and not a
-        //   specialization thereof, and is not ambiguous.
-        if (TemplateNameLookup)
-          if (auto *TD = getAsTemplateNameDecl(ND))
-            ND = TD;
+    if (R.isTemplateNameLookup())
 
-        // C++ [class.member.lookup]p3:
-        //   type declarations (including injected-class-names) are replaced by
-        //   the types they designate
-        if (const TypeDecl *TD = dyn_cast<TypeDecl>(ND->getUnderlyingDecl())) {
-          QualType T = Context.getTypeDeclType(TD);
-          return T.getCanonicalType().getAsOpaquePtr();
-        }
+    if (const TypeDecl *TD = dyn_cast<TypeDecl>(ND)) {
 
-        return ND->getUnderlyingDecl()->getCanonicalDecl();
-      }
-      return nullptr;
-    };
+    return ND->getCanonicalDecl();
 
-    // We'll often find the declarations are in the same order. Handle this
-    // case (and the special case of only one declaration) efficiently.
-    Iterator AIt = A.begin(), BIt = B.begin(), AEnd = A.end(), BEnd = B.end();
-    while (true) {
-      Result AResult = Next(AIt, AEnd);
-      Result BResult = Next(BIt, BEnd);
-      if (!AResult && !BResult)
-        return true;
-      if (!AResult || !BResult)
-        return false;
-      if (AResult != BResult) {
-        // Found a mismatch; carefully check both lists, accounting for the
-        // possibility of declarations appearing more than once.
-        llvm::SmallDenseMap<Result, bool, 32> AResults;
-        for (; AResult; AResult = Next(AIt, AEnd))
-          AResults.insert({AResult, /*FoundInB*/false});
-        unsigned Found = 0;
-        for (; BResult; BResult = Next(BIt, BEnd)) {
-          auto It = AResults.find(BResult);
-          if (It == AResults.end())
-            return false;
-          if (!It->second) {
-            It->second = true;
-            ++Found;
-          }
-        }
-        return AResults.size() == Found;
-      }
-    }
+  struct MemberInfo {
+    MemberInfo() : Access(AS_none), FoundInBases(0) {}
+    unsigned Access : 2;
+    unsigned FoundInBases : 30;
   };
 
-  for (CXXBasePaths::paths_iterator Path = Paths.begin(), PathEnd = Paths.end();
-       Path != PathEnd; ++Path) {
-    const CXXBasePathElement &PathElement = Path->back();
+  llvm::SmallDenseMap<MemberResult, MemberInfo, 16> Members;
 
-    // Pick the best (i.e. most permissive i.e. numerically lowest) access
-    // across all paths.
-    SubobjectAccess = std::min(SubobjectAccess, Path->Access);
-
-    // Determine whether we're looking at a distinct sub-object or not.
-    if (SubobjectType.isNull()) {
-      // This is the first subobject we've looked at. Record its type.
-      SubobjectType = Context.getCanonicalType(PathElement.Base->getType());
-      SubobjectNumber = PathElement.SubobjectNumber;
-      continue;
-    }
-
-    if (SubobjectType !=
-        Context.getCanonicalType(PathElement.Base->getType())) {
-      // We found members of the given name in two subobjects of
-      // different types. If the declaration sets aren't the same, this
-      // lookup is ambiguous.
-      //
-      // FIXME: The language rule says that this applies irrespective of
-      // whether the sets contain only static members.
-      if (HasOnlyStaticMembers(Path->Decls) &&
-          HasSameDeclarations(Paths.begin()->Decls, Path->Decls))
+  // C++ [class.member.lookup]/6.2:
+  //   if the declaration sets of [any two paths we found] differ, the merge is
+  //   ambiguous: the [result] is a lookup set with an invalid declaration set
+  // C++ [class.member.lookup]/7:
+  //   If [the result] is an invalid set, the program is ill-formed.
+  unsigned Bases = 0;
+  for (const CXXBasePath &Path : Paths) {
+    unsigned FoundMembers = 0;
+    for (NamedDecl *ND : Path.Decls) {
+      if (!ND->isInIdentifierNamespace(IDNS))
         continue;
 
-      R.setAmbiguousBaseSubobjectTypes(Paths);
+      MemberResult Res = AsMemberResult(ND);
+      auto InfoIt =
+          Bases ? Members.find(Res) : Members.insert({Res, MemberInfo()}).first;
+      if (InfoIt == Members.end()) {
+        // A member in this path was not in the first path. The lookup is
+        // ambiguous.
+        R.setAmbiguousBaseSubobjectResults(Paths);
         return true;
       }
 
-    // FIXME: This language rule no longer exists. Checking for ambiguous base
-    // subobjects should be done as part of formation of a class member access
-    // expression (when converting the object parameter to the member's type).
-    if (SubobjectNumber != PathElement.SubobjectNumber) {
-      // We have a different subobject of the same type.
-
-      // C++ [class.member.lookup]p5:
-      //   A static member, a nested type or an enumerator defined in
-      //   a base class T can unambiguously be found even if an object
-      //   has more than one base class subobject of type T.
-      if (HasOnlyStaticMembers(Path->Decls))
-        continue;
-
-      // We have found a nonstatic member name in multiple, distinct
-      // subobjects. Name lookup is ambiguous.
-      R.setAmbiguousBaseSubobjects(Paths);
+      // C++ [class.paths]p1:
+      //   If a name can be reached by several paths through a multiple
+      //   inheritance graph, the access is that of the path that gives the
+      //   most access.
+      AccessSpecifier Access =
+          CXXRecordDecl::MergeAccess(Path.Access, ND->getAccess());
+      InfoIt->second.Access = std::min<unsigned>(InfoIt->second.Access, Access);
+
+      if (InfoIt->second.FoundInBases == Bases) {
+        ++FoundMembers;
+        ++InfoIt->second.FoundInBases;
+      }
+    }
+
+    // If this path didn't have all the members from the first path, the lookup
+    // is ambiguous.
+    if (FoundMembers != Members.size()) {
+      R.setAmbiguousBaseSubobjectResults(Paths);
       return true;
     }
+
+    ++Bases;
   }
 
   // Lookup in a base class succeeded; return these results.
 
-  for (auto *D : Paths.front().Decls) {
-    AccessSpecifier AS = CXXRecordDecl::MergeAccess(SubobjectAccess,
-                                                    D->getAccess());
-    if (NamedDecl *ND = R.getAcceptableDecl(D))
-      R.addDecl(ND, AS);
+  // Different paths can have different (but equivalent) sets of declarations;
+  // arbitrarily pick the declarations from the first path, but use the best
+  // access from any path.
+  for (NamedDecl *ND : Paths.front().Decls) {
+    if (!ND->isInIdentifierNamespace(R.getIdentifierNamespace()))
+      continue;
+
+    MemberInfo Info = Members[AsMemberResult(ND)];
+    assert(Info.FoundInBases == Bases && "member not found in all bases");
+    R.addDecl(ND, static_cast<AccessSpecifier>(Info.Access));
   }
   R.resolveKind();
   return true;
 }
 
 /// Performs qualified name lookup or special type of lookup for
 /// "__super::" scope specifier.
 ///

 ///
 /// \returns true if lookup succeeded, false if it failed.
 bool Sema::LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
                                CXXScopeSpec &SS) {
   auto *NNS = SS.getScopeRep();
   if (NNS && NNS->getKind() == NestedNameSpecifier::Super)
     return LookupInSuper(R, NNS->getAsRecordDecl());
   else
-
     return LookupQualifiedName(R, LookupCtx);
 }
 
 /// Performs name lookup for a name that was parsed in the
 /// source code, and may contain a C++ scope specifier.
 ///
 /// This routine is a convenience routine meant to be called from
 /// contexts that receive a name and an optional C++ scope specifier

 void Sema::DiagnoseAmbiguousLookup(LookupResult &Result) {
   assert(Result.isAmbiguous() && "Lookup result must be ambiguous");
 
   DeclarationName Name = Result.getLookupName();
   SourceLocation NameLoc = Result.getNameLoc();
   SourceRange LookupRange = Result.getContextRange();
 
   switch (Result.getAmbiguityKind()) {
-  case LookupResult::AmbiguousBaseSubobjects: {
-    CXXBasePaths *Paths = Result.getBasePaths();
-    QualType SubobjectType = Paths->front().back().Base->getType();
-    Diag(NameLoc, diag::err_ambiguous_member_multiple_subobjects)
-      << Name << SubobjectType << getAmbiguousPathsDisplayString(*Paths)
-      << LookupRange;
-
-    DeclContext::lookup_iterator Found = Paths->front().Decls.begin();
-    while (isa<CXXMethodDecl>(*Found) &&
-           cast<CXXMethodDecl>(*Found)->isStatic())
-      ++Found;
-
-    Diag((*Found)->getLocation(), diag::note_ambiguous_member_found);
-    break;
-  }
-
-  case LookupResult::AmbiguousBaseSubobjectTypes: {
-    Diag(NameLoc, diag::err_ambiguous_member_multiple_subobject_types)
+  case LookupResult::AmbiguousBaseSubobjectResults: {
+    Diag(NameLoc,
+         diag::err_ambiguous_member_different_results_in_multiple_subobjects)
         << Name << LookupRange;
 
     CXXBasePaths *Paths = Result.getBasePaths();
-    std::set<const NamedDecl *> DeclsPrinted;
+    std::set<const CXXRecordDecl *> BasesPrinted;
     for (CXXBasePaths::paths_iterator Path = Paths->begin(),
                                       PathEnd = Paths->end();
          Path != PathEnd; ++Path) {
-      const NamedDecl *D = Path->Decls.front();
+      QualType Base = Path->back().Base->getType();
+      if (!BasesPrinted.insert(Base->getAsCXXRecordDecl()->getCanonicalDecl())
+               .second)
+        continue;
+      for (const NamedDecl *D : Path->Decls) {
         if (!D->isInIdentifierNamespace(Result.getIdentifierNamespace()))
           continue;
-      if (DeclsPrinted.insert(D).second) {
-        if (const auto *TD = dyn_cast<TypedefNameDecl>(D->getUnderlyingDecl()))
+        if (const auto *TD =
+                dyn_cast<TypedefNameDecl>(D->getUnderlyingDecl()))
           Diag(D->getLocation(), diag::note_ambiguous_member_type_found)
-              << TD->getUnderlyingType();
+              << Base << TD->getUnderlyingType();
         else if (const auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))
           Diag(D->getLocation(), diag::note_ambiguous_member_type_found)
-              << Context.getTypeDeclType(TD);
+              << Base << Context.getTypeDeclType(TD);
         else
-          Diag(D->getLocation(), diag::note_ambiguous_member_found);
+          Diag(D->getLocation(), diag::note_ambiguous_member_found) << Base;
       }
     }
     break;
   }
 
   case LookupResult::AmbiguousTagHiding: {
     Diag(NameLoc, diag::err_ambiguous_tag_hiding) << Name << LookupRange;
 

clang/test/CXX/class.derived/class.member.lookup/p6.cpp

 
 class C : public virtual V, public W { };
 
 class D : public B, public C { void glorp(); };
 
 void D::glorp() {
   x++;
   f();
-  y++; // expected-error{{member 'y' found in multiple base classes of different types}}
-  g(); // expected-error{{member 'g' found in multiple base classes of different types}}
+  y++; // expected-error{{member 'y' found in multiple base classes with differing lookup results}}
+  g(); // expected-error{{member 'g' found in multiple base classes with differing lookup results}}
 }
 
 // PR6462
 struct BaseIO { BaseIO* rdbuf() { return 0; } };
 struct Pcommon : virtual BaseIO { int rdbuf() { return 0; } };
 struct P : virtual BaseIO, Pcommon {};
 
 void f() { P p; p.rdbuf(); }

clang/test/CXX/class.derived/class.member.lookup/p8.cpp

void Derived::Inner() {
     D1::Member = 42;
     this->D1::Foo();
     this->D1::Member = 42;
   }
 }
 
 template<typename T>
 struct BaseT {
-  void Foo(); // expected-note{{found by ambiguous name lookup}}
+  void Foo();
   int Member;
 };
 
 template<typename T> struct Derived1T : BaseT<T> { };
 template<typename T> struct Derived2T : BaseT<T> { };
 
 template<typename T>
 struct DerivedT : public Derived1T<T>, public Derived2T<T> {
   void Inner();
 };
 
 template<typename T>
 void DerivedT<T>::Inner() {
   Derived1T<T>::Foo();
   Derived2T<T>::Member = 42;
   this->Derived1T<T>::Foo();
   this->Derived2T<T>::Member = 42;
-  this->Foo(); // expected-error{{non-static member 'Foo' found in multiple base-class subobjects of type 'BaseT<int>'}}
+  this->Foo(); // expected-error{{ambiguous conversion from derived class 'DerivedT<int>' to base class 'BaseT<int>'}}
 }
 
 template<typename T>
 void Test(DerivedT<T> d) {
   d.template Derived1T<T>::Foo();
   d.template Derived2T<T>::Member = 17;
   d.Inner(); // expected-note{{in instantiation}}
 }
 
 template void Test(DerivedT<int>);

clang/test/CXX/class.derived/class.member.lookup/p9.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 namespace rdar8436162 {
   class ClsA {
   public:
     static void f();
     void g();
   };
 
   class ClsB : virtual private ClsA {
   public:
     using ClsA::f;
-    using ClsA::g; // expected-note{{member found by ambiguous name lookup}}
+    using ClsA::g;
   };
 
   class ClsF : virtual private ClsA {
   public:
     using ClsA::f;
-    using ClsA::g; // expected-note{{member found by ambiguous name lookup}}
+    using ClsA::g;
   };
 
   class ClsE : public ClsB, public ClsF {
-    void test() { 
+    void test() {
       f();
-      g(); // expected-error{{member 'g' found in multiple base classes of different types}}
+      g();
+    }
+  };
+
+  struct A {
+    static void f();
+    void g();
+  };
+  struct B : private A {
+    using A::f;
+    using A::g;
+  };
+  struct C : private A {
+    using A::f;
+    using A::g;
+  };
+  struct D : B, C {
+    void test() {
+      f();
+      g(); // expected-error {{ambiguous conversion from derived class}}
     }
   };
 }

clang/test/CXX/dcl.decl/dcl.decomp/p3.cpp

 struct Base2 {
   template<int> int get(); // expected-note{{member found by ambiguous name lookup}}
 };
 struct Derived : Base1, Base2 {};
 
 template <> struct std::tuple_size<Derived> { static constexpr size_t value = 1; };
 template <> struct std::tuple_element<0, Derived> { typedef int type; };
 
-auto [x] = Derived(); // expected-error{{member 'get' found in multiple base classes of different types}}
+auto [x] = Derived(); // expected-error{{member 'get' found in multiple base classes}}
 
 struct Base {
   template<int> int get();
 };
 struct UsingGet : Base {
   using Base::get;
 };
 
 template <> struct std::tuple_size<UsingGet> {
   static constexpr size_t value = 1;
 };
 template <> struct std::tuple_element<0, UsingGet> { typedef int type; };
 
 auto [y] = UsingGet();

clang/test/CXX/drs/dr0xx.cpp

 // dr37: sup 475
 
 namespace dr38 { // dr38: yes
   template<typename T> struct X {};
   template<typename T> X<T> operator+(X<T> a, X<T> b) { return a; }
   template X<int> operator+<int>(X<int>, X<int>);
 }
 
-namespace dr39 { // dr39: no
+namespace dr39 { // dr39: 12
   namespace example1 {
     struct A { int &f(int); };
     struct B : A {
       using A::f;
       float &f(float);
     } b;
     int &r = b.f(0);
   }
 
   namespace example2 {
     struct A {
       int &x(int); // expected-note {{found}}
       static int &y(int); // expected-note {{found}}
     };
     struct V {
       int &z(int);
     };
     struct B : A, virtual V {
       using A::x; // expected-note {{found}}
-      float &x(float);
+      float &x(float); // expected-note {{found}}
       using A::y; // expected-note {{found}}
-      static float &y(float);
+      static float &y(float); // expected-note {{found}}
       using V::z;
       float &z(float);
     };
     struct C : A, B, virtual V {} c; // expected-warning {{direct base 'dr39::example2::A' is inaccessible due to ambiguity:\n    struct dr39::example2::C -> struct dr39::example2::A\n    struct dr39::example2::C -> struct dr39::example2::B -> struct dr39::example2::A}}
     int &x = c.x(0); // expected-error {{found in multiple base classes}}
-    // FIXME: This is valid, because we find the same static data member either way.
     int &y = c.y(0); // expected-error {{found in multiple base classes}}
     int &z = c.z(0);
   }
 
   namespace example3 {
     struct A { static int f(); };
     struct B : virtual A { using A::f; };
     struct C : virtual A { using A::f; };
     struct D : B, C {} d;
     int k = d.f();
   }
 
   namespace example4 {
-    struct A { int n; }; // expected-note {{found}}
+    struct A { int n; };
     struct B : A {};
     struct C : A {};
-    struct D : B, C { int f() { return n; } }; // expected-error {{found in multiple base-class}}
+    struct D : B, C { int f() { return n; } }; // expected-error {{ambiguous conversion}}
   }
 
   namespace PR5916 {
-    // FIXME: This is valid.
-    struct A { int n; }; // expected-note +{{found}}
+    struct A { int n; };
     struct B : A {};
     struct C : A {};
     struct D : B, C {};
-    int k = sizeof(D::n); // expected-error {{found in multiple base}} expected-error {{unknown type name}}
-#if __cplusplus >= 201103L
-    decltype(D::n) n; // expected-error {{found in multiple base}}
+    int k = sizeof(D::n);
+#if __cplusplus < 201103L
+    // expected-error@-2 {{invalid use of non-static data member}}
+#else
+    decltype(D::n) n;
 #endif
   }
+
+  namespace type {
+    struct A {
+      typedef int I;
+      typedef int J; // expected-note {{found}}
+    };
+    struct B {
+      typedef type::A A;
+      typedef int I;
+      typedef const int J; // expected-note {{found}}
+    };
+    struct C : A, B {};
+    C::A ca;
+    C::I i;
+    C::J j; // expected-error {{found in multiple base classes}}
+  }
+
+  namespace resolve_overload_before_checking_subobject_ambiguity {
+    struct A {
+      void f();
+      static void f(int);
+    };
+    struct B : A {};
+    struct C : A {};
+    struct D : B, C {};
+    void f(D d) {
+      d.f(0); // OK
+      d.f(); // expected-error {{ambiguous conversion}}
+    }
+  }
 }
 
 // dr40: na
 
 namespace dr41 { // dr41: yes
   struct S f(S);
 }
 

clang/test/CXX/drs/dr1xx.cpp

namespace dr176 { // dr176: yes
   template<typename T> class Y;
   template<> class Y<int> {
     void f() {
       typedef Y A; // expected-note {{here}}
       typedef Y<char> A; // expected-error {{different types ('Y<char>' vs 'Y<int>')}}
     }
   };
 
-  template<typename T> struct Base {}; // expected-note 2{{found}}
+  template<typename T> struct Base {}; // expected-note-re 2{{Base<{{int|char}}>' found}}
   template<typename T> struct Derived : public Base<T> {
     void f() {
       typedef typename Derived::template Base<T> A;
       typedef typename Derived::Base A;
     }
   };
   template struct Derived<int>;
 

clang/test/CXX/drs/dr3xx.cpp

namespace dr306 { // dr306: dup 39
   struct C { typedef A::B B; };
   struct D : A, A::B, C {};
   D::B b;
 
   struct X {}; // expected-note {{member type 'dr306::X' found}}
   template<typename T> struct Y { typedef T X; }; // expected-note {{member type 'const dr306::X' found}}
   template<typename T> struct Z : X, Y<T> {};
   Z<X>::X zx;
-  Z<const X>::X zcx; // expected-error {{member 'X' found in multiple base classes of different types}}
+  Z<const X>::X zcx; // expected-error {{member 'X' found in multiple base classes with differing lookup results}}
 }
 
 // dr307: na
 
 namespace dr308 { // dr308: yes
   // This is mostly an ABI library issue.
   struct A {};
   struct B : A {};

clang/test/CXX/drs/dr4xx.cpp

namespace dr470 { // dr470: yes
   template struct A<int>::B; // expected-error {{duplicate explicit instantiation}}
 
   // ok, instantiating C<char> doesn't instantiate base class members.
   template struct A<char>;
   template struct C<char>;
 }
 
 namespace dr471 { // dr471: yes
-  struct A { int n; };
-  struct B : private virtual A {};
+  // It's unimportant which of the two private paths we show. (Maybe ideally we
+  // should show both?)
+  struct A { int n; }; // expected-note 0-1{{here}}
+  struct B : private virtual A {}; // expected-note 0-1{{constrained by private inheritance}}
   struct C : protected virtual A {};
   struct D : B, C { int f() { return n; } };
   struct E : private virtual A {
     using A::n;
   };
   struct F : E, B { int f() { return n; } };
   struct G : virtual A {
   private:
-    using A::n; // expected-note {{here}}
+    using A::n; // expected-note 0-1{{declared private here}}
   };
   struct H : B, G { int f() { return n; } }; // expected-error {{private}}
 }
 
 namespace dr474 { // dr474: yes
   namespace N {
     struct S {
       void f();

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 { };
 
 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 b;  // expected-error{{member 'Base' found in multiple base classes}}
   typename Derived::Base<double> d;  // OK
 
   void g(X0 *t) {
     t->Derived::Base<T>::f();
     t->Base<T>::f();
-    t->Base::f(); // expected-error{{member 'Base' found in multiple base classes of different types}} \
+    t->Base::f(); // expected-error{{member 'Base' found in multiple base classes}} \
     // expected-error{{no member named 'f' in 'X0'}}
   }
 };
 
 namespace PR6717 {
   template <typename T>
   class WebVector {
   } // expected-error {{expected ';' after class}}
 
     WebVector(const WebVector<T>& other) { } // expected-error{{undeclared identifier 'T'}} \
                                                 expected-error{{requires a type specifier}}
 
   template <typename C>
   WebVector<T>& operator=(const C& other) { } // expected-error{{undeclared identifier 'T'}}
 }

clang/test/SemaCXX/access.cpp

namespace OverloadedMemberFunctionPointer {
   public:
     void init(bool c) {
       if (c) {
         auto f = foo1<int>;
       }
     }
   };
 }
+
+namespace MultiplePathsToSameMember {
+  namespace NonVirtual {
+    struct A {
+      static int a; // expected-note {{declared here}}
+      using T = int; // expected-note {{declared here}}
+    };
+    struct B : private A {}; // expected-note 2{{constrained by private inheritance here}}
+    struct C : public A {
+    private:
+      using A::a; // expected-note {{declared private here}}
+      using T = int; // expected-note {{declared private here}}
+    };
+    struct D : public A {};
+    struct E : public A {
+    public:
+      using A::a;
+      using T = int;
+    };
+
+    struct X1 : B, C {};
+    struct X2 : C, B {};
+    struct X3 : D, C {};
+    struct X4 : C, D {};
+    struct X5 : B, E {};
+    struct X6 : E, B {};
+
+    int k1 = X1::a; // expected-error {{'a' is a private member of 'MultiplePathsToSameMember::NonVirtual::A'}}
+    int k2 = X2::a; // expected-error {{'a' is a private member of 'MultiplePathsToSameMember::NonVirtual::C'}}
+    int k3 = X3::a;
+    int k4 = X4::a;
+    int k5 = X5::a;
+    int k6 = X6::a;
+    X1::T u1; // expected-error {{'T' is a private member of 'MultiplePathsToSameMember::NonVirtual::A'}}
+    X2::T u2; // expected-error {{'T' is a private member of 'MultiplePathsToSameMember::NonVirtual::C'}}
+    X3::T u3;
+    X4::T u4;
+    X5::T u5;
+    X6::T u6;
+  }
+
+  namespace Virtual {
+    struct A {
+      int a;
+      using T = int;
+    };
+    struct B : private virtual A {};
+    struct C : public virtual A {
+    private:
+      using A::a; // expected-note 4{{declared private here}}
+      using T = int; // expected-note 4{{declared private here}}
+    };
+    struct D : public virtual A {};
+    struct E : public virtual A {
+    public:
+      using A::a;
+      using T = int;
+    };
+
+    struct X1 : B, C {};
+    struct X2 : C, B {};
+    struct X3 : D, C {};
+    struct X4 : C, D {};
+    struct X5 : B, E {};
+    struct X6 : E, B {};
+
+    int k1 = X1().a; // expected-error {{'a' is a private member of 'MultiplePathsToSameMember::Virtual::C'}}
+    int k2 = X2().a; // expected-error {{'a' is a private member of 'MultiplePathsToSameMember::Virtual::C'}}
+    // Public declarations in vbase A (reached via D) are hidden by private
+    // declarations in C.
+    int k3 = X3().a; // expected-error {{'a' is a private member of 'MultiplePathsToSameMember::Virtual::C'}}
+    int k4 = X4().a; // expected-error {{'a' is a private member of 'MultiplePathsToSameMember::Virtual::C'}}
+    int k5 = X5().a;
+    int k6 = X6().a;
+    X1::T u1; // expected-error {{'T' is a private member of 'MultiplePathsToSameMember::Virtual::C'}}
+    X2::T u2; // expected-error {{'T' is a private member of 'MultiplePathsToSameMember::Virtual::C'}}
+    // Public declarations in vbase A (reached via D) are hidden by private
+    // declarations in C.
+    X3::T u3; // expected-error {{'T' is a private member of 'MultiplePathsToSameMember::Virtual::C'}}
+    X4::T u4; // expected-error {{'T' is a private member of 'MultiplePathsToSameMember::Virtual::C'}}
+    X5::T u5;
+    X6::T u6;
+  }
+
+  namespace Unrelated {
+    struct A { using T = int; };
+    class B { using T = int; };
+    struct C { using T = int; }; // expected-note 3{{declared here}}
+    struct D1 : A, B {};
+    struct D2 : B, A {};
+    struct D3 : private C, B {}; // expected-note {{constrained by}}
+    struct D4 : B, private C {}; // expected-note {{constrained by}}
+    struct D5 : B, private C {}; // expected-note {{constrained by}}
+
+    using T = int;
+    using T = D1::T;
+    using T = D2::T;
+    using T = D3::T; // expected-error {{private}}
+    using T = D4::T; // expected-error {{private}}
+    using T = D5::T; // expected-error {{private}}
+  }
+}

clang/test/SemaCXX/lookup-member.cpp

namespace UnambiguousStaticMemberTemplate {
   void f(D d) { d.f(0); d.g(); }
 }
 
 namespace UnambiguousReorderedMembers {
   // Static members are not ambiguous if we find them in a different order in
   // multiple base classes.
   struct A { static void f(); };
   struct B { static void f(int); };
-  struct C : A, B { using A::f; using B::f; }; // expected-note {{found}}
+  struct C : A, B { using A::f; using B::f; }; // expected-note 2{{found}}
   struct D : B, A { using B::f; using A::f; };
   struct E : C, D {};
   void f(E e) { e.f(0); }
 
   // But a different declaration set in different base classes does result in ambiguity.
-  struct X : B, A { using B::f; using A::f; static void f(int, int); }; // expected-note {{found}}
+  struct X : B, A { using B::f; using A::f; static void f(int, int); }; // expected-note 3{{found}}
   struct Y : C, X {};
-  void g(Y y) { y.f(0); } // expected-error {{found in multiple base classes of different types}}
+  void g(Y y) { y.f(0); } // expected-error {{found in multiple base classes with differing lookup results}}
 }

clang/test/SemaCXX/member-name-lookup.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 struct A { 
-  int a;  // expected-note 4{{member found by ambiguous name lookup}}
+  int a;
   static int b;
   static int c; // expected-note 2{{member found by ambiguous name lookup}}
 
   enum E { enumerator };
 
   typedef int type;
 
   static void f(int);
-  void f(float); // expected-note 2{{member found by ambiguous name lookup}}
+  void f(float);
 
   static void static_f(int);
   static void static_f(double);
 };
 
 struct B : A {
   int d; // expected-note 2{{member found by ambiguous name lookup}}
 
struct C : A {
   enum E3 { enumerator3_2 }; // expected-note 2{{member type 'C::E3' found by ambiguous name lookup}}
 };
 
 struct D : B, C {
   void test_lookup();
 };
 
 void test_lookup(D d) {
-  d.a; // expected-error{{non-static member 'a' found in multiple base-class subobjects of type 'A':}}
+  d.a; // expected-error{{ambiguous conversion from derived class 'D' to base class 'A'}}
   (void)d.b; // okay
-  d.c; // expected-error{{member 'c' found in multiple base classes of different types}}
-  d.d; // expected-error{{member 'd' found in multiple base classes of different types}}
-  d.f(0); // expected-error{{non-static member 'f' found in multiple base-class subobjects of type 'A':}}
+  d.c; // expected-error{{member 'c' found in multiple base classes with differing lookup results}}
+  d.d; // expected-error{{member 'd' found in multiple base classes with differing lookup results}}
+  d.f(0);
+  d.f(0.0f); // expected-error{{ambiguous conversion from derived class 'D' to base class 'A'}}
   d.static_f(0); // okay
 
   D::E e = D::enumerator; // okay
   D::type t = 0; // okay
 
   D::E2 e2 = D::enumerator2; // okay
 
   D::E3 e3; // expected-error{{multiple base classes}}
 }
 
 void D::test_lookup() {
-  a; // expected-error{{non-static member 'a' found in multiple base-class subobjects of type 'A':}}
+  a; // expected-error{{ambiguous conversion from derived class 'D' to base class 'A'}}
   (void)b; // okay
-  c; // expected-error{{member 'c' found in multiple base classes of different types}}
-  d; // expected-error{{member 'd' found in multiple base classes of different types}}
-  f(0); // expected-error{{non-static member 'f' found in multiple base-class subobjects of type 'A':}}
+  c; // expected-error{{member 'c' found in multiple base classes with differing lookup results}}
+  d; // expected-error{{member 'd' found in multiple base classes with differing lookup results}}
+  f(0);
+  f(0.0f); // expected-error {{ambiguous conversion from derived class 'D' to base class 'A'}}
   static_f(0); // okay
 
   E e = enumerator; // okay
   type t = 0; // okay
 
   E2 e2 = enumerator2; // okay
 
-  E3 e3; // expected-error{{member 'E3' found in multiple base classes of different types}}
+  E3 e3; // expected-error{{member 'E3' found in multiple base classes with differing lookup results}}
 }
 
 struct B2 : virtual A {
   int d; // expected-note 2{{member found by ambiguous name lookup}}
 
   enum E2 { enumerator2 };
 
   enum E3 { enumerator3 }; // expected-note 2 {{member type 'B2::E3' found by ambiguous name lookup}}

 struct G : F, D2 { 
   void test_virtual_lookup();
 };
 
 void test_virtual_lookup(D2 d2, G g) {
   (void)d2.a;
   (void)d2.b;
   (void)d2.c; // okay
-  d2.d; // expected-error{{member 'd' found in multiple base classes of different types}}
+  d2.d; // expected-error{{member 'd' found in multiple base classes with differing lookup results}}
   d2.f(0); // okay
+  d2.f(0.0f);
   d2.static_f(0); // okay
 
   D2::E e = D2::enumerator; // okay
   D2::type t = 0; // okay
 
   D2::E2 e2 = D2::enumerator2; // okay
 
-  D2::E3 e3; // expected-error{{member 'E3' found in multiple base classes of different types}}
+  D2::E3 e3; // expected-error{{member 'E3' found in multiple base classes with differing lookup results}}
 
-  g.a; // expected-error{{non-static member 'a' found in multiple base-class subobjects of type 'A':}}
+  g.a; // expected-error{{ambiguous conversion from derived class 'G' to base class 'A'}}
   g.static_f(0); // okay
 }
 
 void D2::test_virtual_lookup() {
   (void)a;
   (void)b;
   (void)c; // okay
-  d; // expected-error{{member 'd' found in multiple base classes of different types}}
+  d; // expected-error{{member 'd' found in multiple base classes with differing lookup results}}
   f(0); // okay
+  f(0.0f); // okay
   static_f(0); // okay
 
   E e = enumerator; // okay
   type t = 0; // okay
 
   E2 e2 = enumerator2; // okay
 
-  E3 e3; // expected-error{{member 'E3' found in multiple base classes of different types}}
+  E3 e3; // expected-error{{member 'E3' found in multiple base classes with differing lookup results}}
 }
 
 void G::test_virtual_lookup() {
-  a; // expected-error{{non-static member 'a' found in multiple base-class subobjects of type 'A':}}
+  a; // expected-error{{ambiguous conversion from derived class 'G' to base class 'A'}}
   static_f(0); // okay
 }
 
 
 struct HasMemberType1 {
   struct type { }; // expected-note{{member type 'HasMemberType1::type' found by ambiguous name lookup}}
 };
 
 struct HasMemberType2 {
   struct type { }; // expected-note{{member type 'HasMemberType2::type' found by ambiguous name lookup}}
 };
 
 struct HasAnotherMemberType : HasMemberType1, HasMemberType2 { 
   struct type { };
 };
 
 struct UsesAmbigMemberType : HasMemberType1, HasMemberType2 {
-  type t; // expected-error{{member 'type' found in multiple base classes of different types}}
+  type t; // expected-error{{member 'type' found in multiple base classes with differing lookup results}}
 };
 
 struct X0 {
   struct Inner {
     static const int m;
   };
   
   static const int n = 17;
 };
 
 const int X0::Inner::m = n;

clang/test/SemaCXX/microsoft-dtor-lookup.cpp

struct B {
   void operator delete(void *); // expected-note {{member found by ambiguous name lookup}}
 };
 
 struct C : A, B {
   ~C();
 };
 
 struct VC : A, B {
-  virtual ~VC(); // expected-error {{member 'operator delete' found in multiple base classes of different types}}
+  virtual ~VC(); // expected-error {{member 'operator delete' found in multiple base classes with differing lookup results}}
 };
 
 void f() {
   // This marks VC's vtable used.
   VC vc;
 }
 
 }

clang/test/SemaCXX/new-delete.cpp

 public:
   static void operator delete(void*, int); // expected-note {{member found by ambiguous name lookup}}
 };
 
 class X8 : public X6, public X7 {
 };
 
 void f(X8 *x8) {
-  delete x8; // expected-error {{member 'operator delete' found in multiple base classes of different types}}
+  delete x8; // expected-error {{member 'operator delete' found in multiple base classes}}
 }
 
 class X9 {
 public:
   static void operator delete(void*, int); // expected-note {{'operator delete' declared here}}
   static void operator delete(void*, float); // expected-note {{'operator delete' declared here}}
 };
 

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

namespace Ambig {
   };
 
   struct Base2 {
     typedef float type; // expected-note{{member type 'float' found by ambiguous name lookup}}
   };
 
   template<typename T>
   struct Derived : Base1<T>, Base2 {
-    typedef typename Derived::type type; // expected-error{{member 'type' found in multiple base classes of different types}}
+    typedef typename Derived::type type; // expected-error{{member 'type' found in multiple base classes}}
     type *foo(float *fp) { return fp; }
   };
 
   Derived<int> di; // expected-note{{instantiation of}}
 }
 
 namespace PR6081 {
   template<typename T>

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

 };
 static_assert(sizeof(B<int>) == sizeof(A<int>::NameFromBase), "");
 }
 
 namespace two_types_in_base {
 template <typename T> struct A { typedef T NameFromBase; }; // expected-note {{member type 'int' found by ambiguous name lookup}}
 template <typename T> struct B { struct NameFromBase { T m; }; }; // expected-note {{member type 'two_types_in_base::B<int>::NameFromBase' found by ambiguous name lookup}}
 template <typename T> struct C : A<T>, B<T> {
-  NameFromBase m; // expected-error {{member 'NameFromBase' found in multiple base classes of different types}} expected-warning {{use of member 'NameFromBase' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+  NameFromBase m; // expected-error {{member 'NameFromBase' found in multiple base classes}} expected-warning {{use of member 'NameFromBase' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
 };
 static_assert(sizeof(C<int>) != 0, ""); // expected-note {{in instantiation of template class 'two_types_in_base::C<int>' requested here}}
 }
 
 namespace type_and_decl_in_base {
 template <typename T> struct A { typedef T NameFromBase; };
 template <typename T> struct B { static const T NameFromBase = 42; };
 template <typename T> struct C : A<T>, B<T> {

clang/test/SemaTemplate/temp.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 
 namespace test0 {
   // p3
   template<typename T> int foo(T), bar(T, T); // expected-error{{single entity}}
 }
 
 // PR7252
 namespace test1 {
   namespace A { template<typename T> struct Base { typedef T t; }; } // expected-note {{member type 'test1::A::Base<char>' found}} expected-note 2{{declared here}}
   namespace B { template<typename T> struct Base { typedef T t; }; } // expected-note {{member type 'test1::B::Base<int>' found}}
 
   template<typename T> struct Derived : A::Base<char>, B::Base<int> {
-    typename Derived::Base<float>::t x; // expected-error {{found in multiple base classes of different types}}
+    typename Derived::Base<float>::t x; // expected-error {{found in multiple base classes}}
   };
 
   class X : A::Base<int> {}; // expected-note 2{{private}}
   class Y : A::Base<float> {};
   struct Z : A::Base<double> {};
   struct Use1 : X, Y {
     Base<double> b1; // expected-error {{private}}
     Use1::Base<double> b2; // expected-error {{private}}
namespace test2 {
   struct A { static int x; }; // expected-note 4{{member}}
   struct B { template<typename T> static T x(); }; // expected-note 4{{member}}
   struct C { template<typename T> struct x {}; }; // expected-note 3{{member}}
   struct D { template<typename T> static T x(); }; // expected-note {{member}}
 
   template<typename ...T> struct X : T... {};
 
   void f() {
-    X<A, B>::x<int>(); // expected-error {{found in multiple base classes of different types}}
-    X<A, C>::x<int>(); // expected-error {{found in multiple base classes of different types}}
-    X<B, C>::x<int>(); // expected-error {{found in multiple base classes of different types}}
-    X<A, B, C>::x<int>(); // expected-error {{found in multiple base classes of different types}}
-    X<A, B, D>::x<int>(); // expected-error {{found in multiple base classes of different types}}
+    X<A, B>::x<int>(); // expected-error {{found in multiple base classes}}
+    X<A, C>::x<int>(); // expected-error {{found in multiple base classes}}
+    X<B, C>::x<int>(); // expected-error {{found in multiple base classes}}
+    X<A, B, C>::x<int>(); // expected-error {{found in multiple base classes}}
+    X<A, B, D>::x<int>(); // expected-error {{found in multiple base classes}}
   }
 }

clang/www/cxx_dr_status.html

<tr id="38">
     <td>TC1</td>
     <td>Explicit template arguments and operator functions</td>
     <td class="full" align="center">Yes</td>
   </tr>
   <tr id="39">
     <td><a href="https://wg21.link/cwg39">39</a></td>
     <td>CD1</td>
     <td>Conflicting ambiguity rules</td>
-    <td class="none" align="center">No</td>
+    <td class="unreleased" align="center">Clang 12</td>
   </tr>
   <tr id="40">
     <td><a href="https://wg21.link/cwg40">40</a></td>
     <td>TC1</td>
     <td>Syntax of <I>declarator-id</I></td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="41">
<tr id="305">
     <td>CD1</td>
     <td>Name lookup in destructor call</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="306">
     <td><a href="https://wg21.link/cwg306">306</a></td>
     <td>CD1</td>
     <td>Ambiguity by class name injection</td>
-    <td class="none" align="center">Duplicate of <a href="#39">39</a></td>
+    <td class="unreleased" align="center">Duplicate of <a href="#39">39</a></td>
   </tr>
   <tr id="307">
     <td><a href="https://wg21.link/cwg307">307</a></td>
     <td>NAD</td>
     <td>Initialization of a virtual base class subobject</td>
     <td class="na" align="center">N/A</td>
   </tr>
   <tr id="308">