[Clang] Fix member lookup so that we don't ignore ambiguous lookups in some cases

[shafik]

Summary

There are some cases during member lookup we are aggressively suppressing diagnostics when we should just be suppressing access control diagnostic.

In this PR I add the ability to simply suppress access diagnostics while not suppressing ambiguous lookup diagnostics.

Fixes: https://github.com/llvm/llvm-project/issues/22413
https://github.com/llvm/llvm-project/issues/29942
https://github.com/llvm/llvm-project/issues/35574
https://github.com/llvm/llvm-project/issues/27224

[shafik]

It looks like the paragraphs in class.member.lookup have changed a lot and so the tests don't totally match in that directory. Fixing that seems like a big piece of work but maybe worth doing.

clang/include/clang/Sema/Lookup.h

152

Note sure about this, alternatively I could set it to what DiagnoseAccess is set to as well.

clang/lib/Sema/SemaOverload.cpp

14986

I was a bit conservative where I changed this but maybe we should do this everywhere.

[cor3ntin]

clang/include/clang/Sema/Lookup.h

197–200

these std::move are a bit superfluous :)

228–230

Does anything break if you remove these two lines? they don't appear useful

[rsmith]

clang/include/clang/Sema/Lookup.h

228–230

I think these make sense: if we move a lookup result into this one, then the other lookup result shouldn't issue diagnostics any more. (Otherwise we could see the same diagnostics twice.)

clang/lib/Sema/SemaOverload.cpp

14986

Most of the other calls in this file all look wrong. DiagnoseTwoPhaseLookup and BuildRecoveryCallExpr are doing error recovery and I think it's appropriate for them to suppress all diagnostics, but the rest are doing standard-mandated searches, and so should diagnose lookup ambiguity.

[cor3ntin]

clang/include/clang/Sema/Lookup.h

228–230

The reason I'm asking is that we don't seem consistent about resetting the state of the moved-from lookup, so i don;t know if moved from lookup are ever reused. and if they are, should we use std::exchange or something along those lines?

[rsmith]

clang/include/clang/Sema/Lookup.h

228–230

I don't think moved-from LookupResults are ever reused, and I don't think it's the intent for this function to leave a moved-from result in a state suitable for use in further lookups. (If you assign over a moved-from lookup result, that'd presumably work fine, though I doubt we ever do that.) The point here, I think, is just to leave the source of the move in a state where the destructor doesn't have side-effects any more.

[shafik]

clang/lib/Sema/SemaOverload.cpp

14986

So it looks like BuildOverloadedArrowExpr catches the ambiguous lookup when calling CandidateSet.BestViableFunction(...) while BuildCallToObjectOfClassType(...) does not. So if I change the suppressDiagnostics() call in BuildOverloadedArrowExpr we get double diagnostic. I am not seeing why we have the inconsistency here.

[shafik]

clang/lib/Sema/SemaOverload.cpp

14986

Correction, there are not duplicate diagnostics, one is for ambiguous overload and the other is for ambiguous name lookup. Maybe we should suppress the ambiguous overload if we have an ambiguous name lookup though.

[shafik]

• Adjusted more place to use suppressAccessDiagnostics

[shafik]

clang/include/clang/Sema/Lookup.h

197–200

Yeah, I was just keeping consistent. I don't think they are doing any harm in this case.

[shafik]

clang/lib/Sema/SemaOverload.cpp

15265

@rsmith if R.isAmbiguous() should we even check the overload candidates?

Right now in clang/test/SemaCXX/arrow-operator.cpp we are getting both an ambiguous name lookup and overload diagnostic.

[rsmith]

clang/lib/Sema/SemaOverload.cpp

15265

Hm, I think perhaps the ideal thing to do is: if BestViableFunction returns OR_Ambiguous, the lookup was ambiguous, and we found viable functions in multiple different base classes, then don't produce any further diagnostics. That way, we still get good error recovery in the case where the overloading is unambiguous despite the lookup being ambiguous, or when the overloading is ambiguous for some reason unrelated to the ambiguous lookup.

(We'd want to do this in all the overloaded operator lookups in this file, not just for operator->.)

[shafik]

• Updated so that we ignore ambiguous overload candidate if the name lookup was also ambiguous.

[shafik]

clang/lib/Sema/SemaOverload.cpp

15265

I only found one other location that matched this pattern if you meant a larger change let me know.

[shafik]

rebase

[rsmith]

This looks good to me. I think we can further refine the handling of duplicate diagnostics but I don't think that needs to be done as part of this bugfix.

clang/lib/Sema/SemaOverload.cpp

953

Can we get duplicate diagnostics here if this lookup fails due to ambiguity? I think we'll perform the same lookup again when looking for candidates if the original operator was !=.

(I wonder if we can fix that by avoiding the duplicate lookup, rather than by suppressing ambiguity diagnostics.)

964

There can't be any access diagnostics here because this is a namespace-scope lookup. You can just drop this call entirly.

15083–15089

I think we should also check whether the ambiguous viable functions were all first declared in the same base class here. If so, then it still makes sense to NoteCandidates, because the ambiguous lookup had nothing to do with the ambiguous overload resolution.

15265

Ideally, we should make AddMemberOperatorCandidates (and LookupOverloadedBinOp) inform its three callers whether its lookup was ambiguous, so that they can also suppress the duplicate ambiguity diagnostics, for unary operators, binary operators, and subscripting.

15293–15298

(Likewise here.)

[shafik]

Add release note.

[hctim]

Hi folks,

I found an issue with building Android using this patch. I've reduced it down to the following problem where the evaluation of the std::visit is believed to be non-exhaustive, but it seems like it is? Would you mind taking a look? Admittedly, my knowledge in this area of the cxx stdlib is not so great.

Thanks.

$ cat /tmp/variant.cpp
#include <utility>
#include <variant>

struct A {};
struct B {};

using MyVariant = std::variant<A, B>;

// Helper to std::visit with lambdas.
template <typename... V>
struct Visitor : V... {};
// explicit deduction guide (not needed as of C++20)
template <typename... V>
Visitor(V...) -> Visitor<V...>;

const char* toString(const MyVariant& args) {
    Visitor toStringVisitor{
            [&](const A&) { return "A"; },
            [&](const B&) { return "B"; },
    };
    return std::visit(toStringVisitor, args);
}

$ ~/llvm-build/opt/bin/clang++ /tmp/variant.cpp -c -o /tmp/variant.o -std=c++17 -stdlib=libc++
In file included from /tmp/variant.cpp:2:
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:680:19: error: static assertion failed due to requirement 'is_invocable_v<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &, const A &>': `std::visit` requires the visitor to be exhaustive.
  680 |     static_assert(is_invocable_v<_Visitor, _Values...>,
      |                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:689:7: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__variant::__std_visit_exhaustive_visitor_check<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &, const A &>' requested here
  689 |       __std_visit_exhaustive_visitor_check<
      |       ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/__type_traits/invoke.h:337:10: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &>::operator()<const std::__variant_detail::__alt<0, A> &>' requested here
  337 | decltype(std::declval<_Fp>()(std::declval<_Args>()...))
      |          ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:572:16: note: while substituting deduced template arguments into function template '__invoke' [with _Fp = std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &>, _Args = <const __alt<0UL, A> &>]
  572 |         return _VSTD::__invoke(
      |                ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/__config:805:17: note: expanded from macro '_VSTD'
  805 | #  define _VSTD std
      |                 ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:581:43: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__dispatcher<0>::__dispatch<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &>' requested here
  581 |     return __dispatcher<_Is...>::template __dispatch<_Fp, _Vs...>;
      |                                           ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:608:12: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__make_dispatch<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &, 0UL>' requested here
  608 |     return __make_dispatch<_Fp, _Vs...>(__is);
      |            ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:616:34: note: (skipping 2 contexts in backtrace; use -ftemplate-backtrace-limit=0 to see all)
  616 |     return __base::__make_farray(__make_fmatrix_impl<_Fp, _Vs...>(
      |                                  ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:533:9: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__make_fmatrix<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &>' requested here
  533 |         __make_fmatrix<_Visitor&&,
      |         ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:642:20: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__visit_alt<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &>, const std::__variant_detail::__impl<A, B> &>' requested here
  642 |     return __base::__visit_alt(
      |                    ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:661:12: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__variant::__visit_alt<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &>, const std::variant<A, B> &>' requested here
  661 |     return __visit_alt(
      |            ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:1759:21: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__variant::__visit_value<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &, const std::variant<A, B> &>' requested here
 1759 |   return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor),
      |                     ^
/tmp/variant.cpp:21:17: note: in instantiation of function template specialization 'std::visit<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &, const std::variant<A, B> &, void>' requested here
   21 |     return std::visit(toStringVisitor, args);
      |                 ^
In file included from /tmp/variant.cpp:2:
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:692:14: error: attempt to use a deleted function
  692 |       return _VSTD::__invoke(_VSTD::forward<_Visitor>(__visitor),
      |              ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/__config:805:17: note: expanded from macro '_VSTD'
  805 | #  define _VSTD std
      |                 ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/__type_traits/invoke.h:337:10: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &>::operator()<const std::__variant_detail::__alt<0, A> &>' requested here
  337 | decltype(std::declval<_Fp>()(std::declval<_Args>()...))
      |          ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:572:16: note: while substituting deduced template arguments into function template '__invoke' [with _Fp = std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &>, _Args = <const __alt<0UL, A> &>]
  572 |         return _VSTD::__invoke(
      |                ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/__config:805:17: note: expanded from macro '_VSTD'
  805 | #  define _VSTD std
      |                 ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:581:43: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__dispatcher<0>::__dispatch<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &>' requested here
  581 |     return __dispatcher<_Is...>::template __dispatch<_Fp, _Vs...>;
      |                                           ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:608:12: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__make_dispatch<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &, 0UL>' requested here
  608 |     return __make_dispatch<_Fp, _Vs...>(__is);
      |            ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:616:34: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__make_fmatrix_impl<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &, 0UL>' requested here
  616 |     return __base::__make_farray(__make_fmatrix_impl<_Fp, _Vs...>(
      |                                  ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:623:12: note: (skipping 1 context in backtrace; use -ftemplate-backtrace-limit=0 to see all)
  623 |     return __make_fmatrix_impl<_Fp, _Vs...>(
      |            ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:533:9: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__make_fmatrix<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &>' requested here
  533 |         __make_fmatrix<_Visitor&&,
      |         ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:642:20: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__visit_alt<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &>, const std::__variant_detail::__impl<A, B> &>' requested here
  642 |     return __base::__visit_alt(
      |                    ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:661:12: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__variant::__visit_alt<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &>, const std::variant<A, B> &>' requested here
  661 |     return __visit_alt(
      |            ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:1759:21: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__variant::__visit_value<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &, const std::variant<A, B> &>' requested here
 1759 |   return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor),
      |                     ^
/tmp/variant.cpp:21:17: note: in instantiation of function template specialization 'std::visit<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &, const std::variant<A, B> &, void>' requested here
   21 |     return std::visit(toStringVisitor, args);
      |                 ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/__type_traits/nat.h:25:3: note: '~__nat' has been explicitly marked deleted here
   25 |   ~__nat()                       = delete;
      |   ^
In file included from /tmp/variant.cpp:2:
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:572:16: error: attempt to use a deleted function
  572 |         return _VSTD::__invoke(
      |                ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/__config:805:17: note: expanded from macro '_VSTD'
  805 | #  define _VSTD std
      |                 ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:581:43: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__dispatcher<0>::__dispatch<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &>' requested here
  581 |     return __dispatcher<_Is...>::template __dispatch<_Fp, _Vs...>;
      |                                           ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:608:12: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__make_dispatch<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &, 0UL>' requested here
  608 |     return __make_dispatch<_Fp, _Vs...>(__is);
      |            ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:616:34: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__make_fmatrix_impl<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &, 0UL>' requested here
  616 |     return __base::__make_farray(__make_fmatrix_impl<_Fp, _Vs...>(
      |                                  ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:623:12: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__make_fmatrix_impl<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &, 0UL, 1UL>' requested here
  623 |     return __make_fmatrix_impl<_Fp, _Vs...>(
      |            ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:533:9: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__make_fmatrix<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &>' requested here
  533 |         __make_fmatrix<_Visitor&&,
      |         ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:642:20: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__visit_alt<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &>, const std::__variant_detail::__impl<A, B> &>' requested here
  642 |     return __base::__visit_alt(
      |                    ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:661:12: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__variant::__visit_alt<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &>, const std::variant<A, B> &>' requested here
  661 |     return __visit_alt(
      |            ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:1759:21: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__variant::__visit_value<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &, const std::variant<A, B> &>' requested here
 1759 |   return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor),
      |                     ^
/tmp/variant.cpp:21:17: note: in instantiation of function template specialization 'std::visit<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &, const std::variant<A, B> &, void>' requested here
   21 |     return std::visit(toStringVisitor, args);
      |                 ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/__type_traits/nat.h:25:3: note: '~__nat' has been explicitly marked deleted here
   25 |   ~__nat()                       = delete;
      |   ^
In file included from /tmp/variant.cpp:2:
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:581:12: error: cannot deduce return type 'auto' from returned value of type '<overloaded function type>'
  581 |     return __dispatcher<_Is...>::template __dispatch<_Fp, _Vs...>;
      |            ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:608:12: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__make_dispatch<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &, 0UL>' requested here
  608 |     return __make_dispatch<_Fp, _Vs...>(__is);
      |            ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:616:34: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__make_fmatrix_impl<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &, 0UL>' requested here
  616 |     return __base::__make_farray(__make_fmatrix_impl<_Fp, _Vs...>(
      |                                  ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:623:12: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__make_fmatrix_impl<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &, 0UL, 1UL>' requested here
  623 |     return __make_fmatrix_impl<_Fp, _Vs...>(
      |            ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:533:9: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__make_fmatrix<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &> &&, const std::__variant_detail::__base<std::__variant_detail::_Trait::_TriviallyAvailable, A, B> &>' requested here
  533 |         __make_fmatrix<_Visitor&&,
      |         ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:642:20: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__base::__visit_alt<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &>, const std::__variant_detail::__impl<A, B> &>' requested here
  642 |     return __base::__visit_alt(
      |                    ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:661:12: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__variant::__visit_alt<std::__variant_detail::__visitation::__variant::__value_visitor<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &>, const std::variant<A, B> &>' requested here
  661 |     return __visit_alt(
      |            ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:1759:21: note: in instantiation of function template specialization 'std::__variant_detail::__visitation::__variant::__visit_value<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &, const std::variant<A, B> &>' requested here
 1759 |   return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor),
      |                     ^
/tmp/variant.cpp:21:17: note: in instantiation of function template specialization 'std::visit<Visitor<(lambda at /tmp/variant.cpp:18:13), (lambda at /tmp/variant.cpp:19:13)> &, const std::variant<A, B> &, void>' requested here
   21 |     return std::visit(toStringVisitor, args);
      |                 ^
/usr/local/google/home/mitchp/llvm-build/opt/bin/../include/c++/v1/variant:571:37: note: candidate template ignored: failed template argument deduction
  571 |     static constexpr decltype(auto) __dispatch(_Fp __f, _Vs... __vs) {
      |                                     ^
4 errors generated.

[jyknight]

In D155387#4557834, @hctim wrote:

I found an issue with building Android using this patch. I've reduced it down to the following problem where the evaluation of the std::visit is believed to be non-exhaustive, but it seems like it is? Would you mind taking a look? Admittedly, my knowledge in this area of the cxx stdlib is not so great.

Your example code is invalid, and Clang is now correctly diagnosing that. You can fix the problem by adding using V::operator()...; inside struct Visitor.

[ilya-biryukov]

This change seems to expose a bug in Clang in C++20 see godbolt.
I believe following code should compile, but it does not:

struct X {
  virtual ~X();
  virtual bool operator ==(X);
  bool operator !=(X);
};

struct Y {
  virtual ~Y();
  virtual bool operator ==(Y);
  bool operator !=(Y);
};

struct Z : X, Y {
  virtual bool operator==(Z);
  bool operator==(X) override;
  bool operator==(Y) override;
};

int main() {
  bool b = Z() == Z(); // Clang errors saying `lookup for operator != is ambiguous`
  (void)b;
}

The operator != is coming from checking if we need to add a reversed candidates.
I believe this should compile as according to (over.match.oper)p4:

A non-template function or function template F named operator== is a rewrite target with first operand o unless a search for the name operator!= in the scope S from the instantiation context of the operator expression finds a function …

And 'search' is defined without any checks for ambiguous bases in (basic.lookup.general)p3

A single search in a scope S for a name N from a program point P finds all declarations that precede P to which any name that is the same as N ([basic.pre]) is bound in S. If any such declaration is a using-declarator whose terminal name ([expr.prim.id.unqual]) is not dependent ([temp.dep.type]), it is replaced by the declarations named by the using-declarator ([namespace.udecl]).

Clang does a full lookup instead, therefore exposing the errors that it should not diagnose.

We actually hit this on real code and found this during integration.

I have sent a fix for review in D157708.

[rsmith]

In D155387#4579866, @ilya-biryukov wrote:

I believe this should compile as according to (over.match.oper)p4:

A non-template function or function template F named operator== is a rewrite target with first operand o unless a search for the name operator!= in the scope S from the instantiation context of the operator expression finds a function …

And 'search' is defined without any checks for ambiguous bases in (basic.lookup.general)p3

A single search in a scope S for a name N from a program point P finds all declarations that precede P to which any name that is the same as N ([basic.pre]) is bound in S. If any such declaration is a using-declarator whose terminal name ([expr.prim.id.unqual]) is not dependent ([temp.dep.type]), it is replaced by the declarations named by the using-declarator ([namespace.udecl]).

Clang does a full lookup instead, therefore exposing the errors that it should not diagnose.

A search of a class scope is ill-formed if it finds an ambiguous result, see http://eel.is/c++draft/basic.lookup#class.member.lookup-6.sentence-2 -- that's the rule that we're now enforcing more broadly, and it applies to all searches of class scopes. So I think Clang is correct to reject your testcase, even though the ambiguity seems much less relevant in this case and the rejection is surprising. The fix / workaround is to add using X::operator!=; using Y::operator!=; to the derived class.

[dewen]

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

15

bool correctness{true};
struct A {
    bool operator==(A const&oth) const {
	return true;
    }
};

struct B {
    bool operator==(B const&oth) const {
	return false;
    }
};

struct C {
    bool operator==(C const&oth) const {
	correctness=false;
	return false;
    }
};

typedef std::tuple<A,B,C> tuple_t ;

int test_it (void) {
    tuple_t x,y;
    return ( !(x==y) ) && correctness ;
}

This test case does not report an error in GCC11 and later versions. The tuple class overloads the operator==() method. Different structs also overload the operator==() method. Due to the introduction of the patch, the llvm18 reports an error when compiling the test case. Is this reasonable?

clang/docs/ReleaseNotes.rst

- Clang limits the size of arrays it will try to evaluate at compile time
   to avoid memory exhaustion.
   This limit can be modified by `-fconstexpr-steps`.
   (`#63562 <https://github.com/llvm/llvm-project/issues/63562>`_)
 
 - Fix a crash caused by some named unicode escape sequences designating
   a Unicode character whose name contains a ``-``.
   (`Fixes #64161 <https://github.com/llvm/llvm-project/issues/64161>_`)
 
+- Fix cases where we ignore ambiguous name lookup when looking up memebers.
+  (`#22413 <https://github.com/llvm/llvm-project/issues/22413>_`),
+  (`#29942 <https://github.com/llvm/llvm-project/issues/29942>_`),
+  (`#35574 <https://github.com/llvm/llvm-project/issues/35574>_`) and
+  (`#27224 <https://github.com/llvm/llvm-project/issues/27224>_`).
+
 Bug Fixes to AST Handling
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Miscellaneous Bug Fixes
 ^^^^^^^^^^^^^^^^^^^^^^^
 
 Miscellaneous Clang Crashes Fixed
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

clang/include/clang/Sema/Lookup.h

public:
   using iterator = UnresolvedSetImpl::iterator;
 
   LookupResult(Sema &SemaRef, const DeclarationNameInfo &NameInfo,
                Sema::LookupNameKind LookupKind,
                Sema::RedeclarationKind Redecl = Sema::NotForRedeclaration)
       : SemaPtr(&SemaRef), NameInfo(NameInfo), LookupKind(LookupKind),
         Redecl(Redecl != Sema::NotForRedeclaration),
         ExternalRedecl(Redecl == Sema::ForExternalRedeclaration),
-        Diagnose(Redecl == Sema::NotForRedeclaration) {
+        DiagnoseAccess(Redecl == Sema::NotForRedeclaration),
+        DiagnoseAmbiguous(Redecl == Sema::NotForRedeclaration) {
     configure();
   }
 
   // TODO: consider whether this constructor should be restricted to take
   // as input a const IdentifierInfo* (instead of Name),
   // forcing other cases towards the constructor taking a DNInfo.
-  LookupResult(Sema &SemaRef, DeclarationName Name,
-               SourceLocation NameLoc, Sema::LookupNameKind LookupKind,
+  LookupResult(Sema &SemaRef, DeclarationName Name, SourceLocation NameLoc,
+               Sema::LookupNameKind LookupKind,
                Sema::RedeclarationKind Redecl = Sema::NotForRedeclaration)
       : SemaPtr(&SemaRef), NameInfo(Name, NameLoc), LookupKind(LookupKind),
         Redecl(Redecl != Sema::NotForRedeclaration),
         ExternalRedecl(Redecl == Sema::ForExternalRedeclaration),
-        Diagnose(Redecl == Sema::NotForRedeclaration) {
+        DiagnoseAccess(Redecl == Sema::NotForRedeclaration),
+        DiagnoseAmbiguous(Redecl == Sema::NotForRedeclaration) {
     configure();
   }
 
   /// Creates a temporary lookup result, initializing its core data
   /// using the information from another result.  Diagnostics are always
   /// disabled.
   LookupResult(TemporaryToken _, const LookupResult &Other)
       : SemaPtr(Other.SemaPtr), NameInfo(Other.NameInfo),
LookupResult(LookupResult &&Other)
         NamingClass(std::move(Other.NamingClass)),
         BaseObjectType(std::move(Other.BaseObjectType)),
         SemaPtr(std::move(Other.SemaPtr)), NameInfo(std::move(Other.NameInfo)),
         NameContextRange(std::move(Other.NameContextRange)),
         LookupKind(std::move(Other.LookupKind)), IDNS(std::move(Other.IDNS)),
         Redecl(std::move(Other.Redecl)),
         ExternalRedecl(std::move(Other.ExternalRedecl)),
         HideTags(std::move(Other.HideTags)),
-        Diagnose(std::move(Other.Diagnose)),
+        DiagnoseAccess(std::move(Other.DiagnoseAccess)),
+        DiagnoseAmbiguous(std::move(Other.DiagnoseAmbiguous)),
         AllowHidden(std::move(Other.AllowHidden)),
         Shadowed(std::move(Other.Shadowed)),
         TemplateNameLookup(std::move(Other.TemplateNameLookup)) {
     Other.Paths = nullptr;
-    Other.Diagnose = false;
+    Other.DiagnoseAccess = false;
+    Other.DiagnoseAmbiguous = false;
   }
 
   LookupResult &operator=(LookupResult &&Other) {
     ResultKind = std::move(Other.ResultKind);
     Ambiguity = std::move(Other.Ambiguity);
     Decls = std::move(Other.Decls);
     Paths = std::move(Other.Paths);
     NamingClass = std::move(Other.NamingClass);
     BaseObjectType = std::move(Other.BaseObjectType);
     SemaPtr = std::move(Other.SemaPtr);
     NameInfo = std::move(Other.NameInfo);
     NameContextRange = std::move(Other.NameContextRange);
     LookupKind = std::move(Other.LookupKind);
     IDNS = std::move(Other.IDNS);
     Redecl = std::move(Other.Redecl);
     ExternalRedecl = std::move(Other.ExternalRedecl);
     HideTags = std::move(Other.HideTags);
-    Diagnose = std::move(Other.Diagnose);
+    DiagnoseAccess = std::move(Other.DiagnoseAccess);
+    DiagnoseAmbiguous = std::move(Other.DiagnoseAmbiguous);
     AllowHidden = std::move(Other.AllowHidden);
     Shadowed = std::move(Other.Shadowed);
     TemplateNameLookup = std::move(Other.TemplateNameLookup);
     Other.Paths = nullptr;
-    Other.Diagnose = false;
+    Other.DiagnoseAccess = false;
+    Other.DiagnoseAmbiguous = false;
     return *this;
   }
 
   ~LookupResult() {
-    if (Diagnose) diagnose();
+    if (DiagnoseAccess)
+      diagnoseAccess();
+    if (DiagnoseAmbiguous)
+      diagnoseAmbiguous();
     if (Paths) deletePaths(Paths);
   }
 
   /// Gets the name info to look up.
   const DeclarationNameInfo &getLookupNameInfo() const {
     return NameInfo;
   }
 
public:
   }
 
   void dump();
   void print(raw_ostream &);
 
   /// Suppress the diagnostics that would normally fire because of this
   /// lookup.  This happens during (e.g.) redeclaration lookups.
   void suppressDiagnostics() {
-    Diagnose = false;
+    DiagnoseAccess = false;
+    DiagnoseAmbiguous = false;
   }
 
-  /// Determines whether this lookup is suppressing diagnostics.
-  bool isSuppressingDiagnostics() const {
-    return !Diagnose;
-  }
+  /// Suppress the diagnostics that would normally fire because of this
+  /// lookup due to access control violations.
+  void suppressAccessDiagnostics() { DiagnoseAccess = false; }
+
+  /// Determines whether this lookup is suppressing access control diagnostics.
+  bool isSuppressingAccessDiagnostics() const { return !DiagnoseAccess; }
+
+  /// Determines whether this lookup is suppressing ambiguous lookup
+  /// diagnostics.
+  bool isSuppressingAmbiguousDiagnostics() const { return !DiagnoseAmbiguous; }
 
   /// Sets a 'context' source range.
   void setContextRange(SourceRange SR) {
     NameContextRange = SR;
   }
 
   /// Gets the source range of the context of this name; for C++
   /// qualified lookups, this is the source range of the scope
public:
   void setFindLocalExtern(bool FindLocalExtern) {
     if (FindLocalExtern)
       IDNS |= Decl::IDNS_LocalExtern;
     else
       IDNS &= ~Decl::IDNS_LocalExtern;
   }
 
 private:
-  void diagnose() {
+  void diagnoseAccess() {
+    if (isClassLookup() && getSema().getLangOpts().AccessControl)
+      getSema().CheckLookupAccess(*this);
+  }
+
+  void diagnoseAmbiguous() {
     if (isAmbiguous())
       getSema().DiagnoseAmbiguousLookup(*this);
-    else if (isClassLookup() && getSema().getLangOpts().AccessControl)
-      getSema().CheckLookupAccess(*this);
   }
 
   void setAmbiguous(AmbiguityKind AK) {
     ResultKind = Ambiguous;
     Ambiguity = AK;
   }
 
   void addDeclsFromBasePaths(const CXXBasePaths &P);
private:
 
   bool Redecl;
   bool ExternalRedecl;
 
   /// True if tag declarations should be hidden if non-tags
   ///   are present
   bool HideTags = true;
 
-  bool Diagnose = false;
+  bool DiagnoseAccess = false;
+  bool DiagnoseAmbiguous = false;
 
   /// True if we should allow hidden declarations to be 'visible'.
   bool AllowHidden = false;
 
   /// 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;

clang/lib/Sema/SemaOverload.cpp

if (isa<CXXMethodDecl>(EqFD)) {
     // If F is a class member, search scope is class type of first operand.
     QualType RHS = FirstOperand->getType();
     auto *RHSRec = RHS->getAs<RecordType>();
     if (!RHSRec)
       return true;
     LookupResult Members(S, NotEqOp, OpLoc,
                          Sema::LookupNameKind::LookupMemberName);
     S.LookupQualifiedName(Members, RHSRec->getDecl());
-    Members.suppressDiagnostics();
+    Members.suppressAccessDiagnostics();
     for (NamedDecl *Op : Members)
       if (FunctionsCorrespond(S.Context, EqFD, Op->getAsFunction()))
         return false;
     return true;
   }
   // Otherwise the search scope is the namespace scope of which F is a member.
   LookupResult NonMembers(S, NotEqOp, OpLoc,
                           Sema::LookupNameKind::LookupOperatorName);
   S.LookupName(NonMembers,
                S.getScopeForContext(EqFD->getEnclosingNamespaceContext()));
-  NonMembers.suppressDiagnostics();
+  NonMembers.suppressAccessDiagnostics();
   for (NamedDecl *Op : NonMembers) {
     auto *FD = Op->getAsFunction();
     if(auto* UD = dyn_cast<UsingShadowDecl>(Op))
       FD = UD->getUnderlyingDecl()->getAsFunction();
     if (FunctionsCorrespond(S.Context, EqFD, FD) &&
         declaresSameEntity(cast<Decl>(EqFD->getDeclContext()),
                            cast<Decl>(Op->getDeclContext())))
       return false;
if (const RecordType *T1Rec = T1->getAs<RecordType>()) {
     if (!isCompleteType(OpLoc, T1) && !T1Rec->isBeingDefined())
       return;
     // If the type is neither complete nor being defined, bail out now.
     if (!T1Rec->getDecl()->getDefinition())
       return;
 
     LookupResult Operators(*this, OpName, OpLoc, LookupOrdinaryName);
     LookupQualifiedName(Operators, T1Rec->getDecl());
-    Operators.suppressDiagnostics();
+    Operators.suppressAccessDiagnostics();
 
     for (LookupResult::iterator Oper = Operators.begin(),
                                 OperEnd = Operators.end();
          Oper != OperEnd; ++Oper) {
       if (Oper->getAsFunction() &&
           PO == OverloadCandidateParamOrder::Reversed &&
           !CandidateSet.getRewriteInfo().shouldAddReversed(
               *this, {Args[1], Args[0]}, Oper->getAsFunction()))
Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
 
   if (RequireCompleteType(LParenLoc, Object.get()->getType(),
                           diag::err_incomplete_object_call, Object.get()))
     return true;
 
   const auto *Record = Object.get()->getType()->castAs<RecordType>();
   LookupResult R(*this, OpName, LParenLoc, LookupOrdinaryName);
   LookupQualifiedName(R, Record->getDecl());
-  R.suppressDiagnostics();
+  R.suppressAccessDiagnostics();
 
   for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
        Oper != OperEnd; ++Oper) {
     AddMethodCandidate(Oper.getPair(), Object.get()->getType(),
                        Object.get()->Classify(Context), Args, CandidateSet,
                        /*SuppressUserConversion=*/false);
   }
 
PartialDiagnostic PD =
             : (PDiag(diag::err_ovl_no_viable_object_call)
                << Object.get()->getType() << Object.get()->getSourceRange());
     CandidateSet.NoteCandidates(
         PartialDiagnosticAt(Object.get()->getBeginLoc(), PD), *this,
         OCD_AllCandidates, Args);
     break;
   }
   case OR_Ambiguous:
+    if (!R.isAmbiguous())
       CandidateSet.NoteCandidates(
           PartialDiagnosticAt(Object.get()->getBeginLoc(),
                               PDiag(diag::err_ovl_ambiguous_object_call)
                                   << Object.get()->getType()
                                   << Object.get()->getSourceRange()),
           *this, OCD_AmbiguousCandidates, Args);
     break;
 
   case OR_Deleted:
     CandidateSet.NoteCandidates(
         PartialDiagnosticAt(Object.get()->getBeginLoc(),
                             PDiag(diag::err_ovl_deleted_object_call)
                                 << Object.get()->getType()
                                 << Object.get()->getSourceRange()),
Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc,
   OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Operator);
 
   if (RequireCompleteType(Loc, Base->getType(),
                           diag::err_typecheck_incomplete_tag, Base))
     return ExprError();
 
   LookupResult R(*this, OpName, OpLoc, LookupOrdinaryName);
   LookupQualifiedName(R, Base->getType()->castAs<RecordType>()->getDecl());
-  R.suppressDiagnostics();
+  R.suppressAccessDiagnostics();
 
   for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
        Oper != OperEnd; ++Oper) {
     AddMethodCandidate(Oper.getPair(), Base->getType(), Base->Classify(Context),
                        std::nullopt, CandidateSet,
                        /*SuppressUserConversion=*/false);
   }
 
   bool HadMultipleCandidates = (CandidateSet.size() > 1);
 
   // Perform overload resolution.
   OverloadCandidateSet::iterator Best;
   switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
   case OR_Success:
     // Overload resolution succeeded; we'll build the call below.
     break;
 
   case OR_No_Viable_Function: {
     auto Cands = CandidateSet.CompleteCandidates(*this, OCD_AllCandidates, Base);
     if (CandidateSet.empty()) {
       QualType BaseType = Base->getType();
if (CandidateSet.empty()) {
       }
     } else
       Diag(OpLoc, diag::err_ovl_no_viable_oper)
         << "operator->" << Base->getSourceRange();
     CandidateSet.NoteCandidates(*this, Base, Cands);
     return ExprError();
   }
   case OR_Ambiguous:
+    if (!R.isAmbiguous())
       CandidateSet.NoteCandidates(
           PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_ambiguous_oper_unary)
                                          << "->" << Base->getType()
                                          << Base->getSourceRange()),
           *this, OCD_AmbiguousCandidates, Base);
     return ExprError();
 
   case OR_Deleted:
     CandidateSet.NoteCandidates(
         PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_deleted_oper)
                                        << "->" << Base->getSourceRange()),
         *this, OCD_AllCandidates, Base);
     return ExprError();

clang/lib/Sema/SemaTemplate.cpp

if (FoundOuter.empty()) {
       //     object expression is used, otherwise
     } else if (FoundOuter.isAmbiguous() || !FoundOuter.isSingleResult() ||
                !(OuterTemplate =
                      getAsTemplateNameDecl(FoundOuter.getFoundDecl()))) {
       //   - if the name is found in the context of the entire
       //     postfix-expression and does not name a class template, the name
       //     found in the class of the object expression is used, otherwise
       FoundOuter.clear();
-    } else if (!Found.isSuppressingDiagnostics()) {
+    } else if (!Found.isSuppressingAmbiguousDiagnostics()) {
       //   - if the name found is a class template, it must refer to the same
       //     entity as the one found in the class of the object expression,
       //     otherwise the program is ill-formed.
       if (!Found.isSingleResult() ||
           getAsTemplateNameDecl(Found.getFoundDecl())->getCanonicalDecl() !=
               OuterTemplate->getCanonicalDecl()) {
         Diag(Found.getNameLoc(),
              diag::ext_nested_name_member_ref_lookup_ambiguous)

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

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+struct A {
+  void operator()(int); // expected-note {{member found by ambiguous name lookup}}
+  void f(int); // expected-note {{member found by ambiguous name lookup}}
+};
+struct B {
+  void operator()(); // expected-note {{member found by ambiguous name lookup}}
+  void f() {} // expected-note {{member found by ambiguous name lookup}}
+};
+
+struct C : A, B {};
+
+int f() {
+    C c;
+    c(); // expected-error {{member 'operator()' found in multiple base classes of different types}}
+    c.f(10); //expected-error {{member 'f' found in multiple base classes of different types}}
+    return 0;
+}

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

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+struct B1 {
+  void f();
+  static void f(int);
+  int i; // expected-note 2{{member found by ambiguous name lookup}}
+};
+struct B2 {
+  void f(double);
+};
+struct I1: B1 { };
+struct I2: B1 { };
+
+struct D: I1, I2, B2 {
+  using B1::f;
+  using B2::f;
+  void g() {
+    f(); // expected-error {{ambiguous conversion from derived class 'D' to base class 'B1'}}
+    f(0); // ok
+    f(0.0); // ok
+    // FIXME next line should be well-formed
+    int B1::* mpB1 = &D::i; // expected-error {{non-static member 'i' found in multiple base-class subobjects of type 'B1'}}
+    int D::* mpD = &D::i; // expected-error {{non-static member 'i' found in multiple base-class subobjects of type 'B1'}}
+  }
+};

clang/test/SemaCXX/arrow-operator.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 struct T { 
   void f();
 };
 
 struct A {
-  T* operator->(); // expected-note{{candidate function}}
+  T* operator->();
+                   // expected-note@-1 {{member found by ambiguous name lookup}}
 };
 
 struct B {
-  T* operator->(); // expected-note{{candidate function}}
+  T* operator->();
+                   // expected-note@-1 {{member found by ambiguous name lookup}}
 };
 
 struct C : A, B {
 };
 
 struct D : A { };
 
 struct E; // expected-note {{forward declaration of 'E'}}
 
 void f(C &c, D& d, E& e) {
-  c->f(); // expected-error{{use of overloaded operator '->' is ambiguous}}
+  c->f();
+          // expected-error@-1 {{member 'operator->' found in multiple base classes of different types}}
   d->f();
   e->f(); // expected-error{{incomplete definition of type}}
 }
 
 // rdar://8875304
 namespace rdar8875304 {
 class Point {};
 class Line_Segment{ public: Line_Segment(const Point&){} };