Produce good looking diagnostics on ambiguous built-in operators.

Now we produce things like:
bug1.cpp:21:11: error: use of overloaded operator '->*' is ambiguous
        int i = c->*pmf;        // expected-error {{use of overloaded operator '->*' is ambiguous}} \
                ~^  ~~~
bug1.cpp:21:11: note: built-in candidate operator ->* ('struct A volatile *', 'int const struct A::*')
bug1.cpp:21:11: note: built-in candidate operator ->* ('struct A volatile *', 'int restrict struct A::*')
...

Still need to look at an issue (indicated as FIXME in the test case).

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@83650 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td
index 40e555cbfcacd0f16d7a94cd1cc59ed108cc84e3..ae2af6a0c5e5723d5e0cdea1fe60863c5b95d778 100644 (file)
--- a/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/include/clang/Basic/DiagnosticSemaKinds.td
@@ -778,7 +778,7 @@ def err_ovl_template_candidate : Note<
   "candidate function template specialization %0">;
 def err_ovl_candidate_deleted : Note<
   "candidate function has been explicitly %select{made unavailable|deleted}0">;
-def err_ovl_builtin_candidate : Note<"built-in candidate function %0 for operator '%1'">;
+def err_ovl_builtin_candidate : Note<"built-in candidate operator %2 (%0, %1)">;
 def err_ovl_no_viable_function_in_init : Error<
   "no matching constructor for initialization of %0">;
 def err_ovl_ambiguous_init : Error<"call to constructor of %0 is ambiguous">;

diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index f710f1e2d5c072bd93c5aaf3f792f942661eefc4..096a0bc03133dc33c5ff9490bea5959e457bd97a 100644 (file)
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -4045,14 +4045,12 @@ Sema::PrintOverloadCandidates(OverloadCandidateSet& CandidateSet,
         Diag(Cand->Surrogate->getLocation(), diag::err_ovl_surrogate_cand)
           << FnType;
       } else if (OnlyViable) {
-        QualType FnType
-          = Context.getFunctionType(Cand->BuiltinTypes.ResultTy,
-                                    Cand->BuiltinTypes.ParamTypes,
-                                    Cand->Conversions.size(),
-                                    false, 0);
-
-        Diag(OpLoc, diag::err_ovl_builtin_candidate) << FnType <<
-         BinaryOperator::getOpcodeStr(Opc);
+        assert(Cand->Conversions.size() == 2 && 
+               "builtin-binary-operator-not-binary");
+        Diag(OpLoc, diag::err_ovl_builtin_candidate) 
+          << Cand->BuiltinTypes.ParamTypes[0] 
+          << Cand->BuiltinTypes.ParamTypes[1] 
+          << BinaryOperator::getOpcodeStr(Opc);
       }
     }
   }

diff --git a/test/SemaCXX/builtin-ptrtomember-ambig.cpp b/test/SemaCXX/builtin-ptrtomember-ambig.cpp
new file mode 100644 (file)
index 0000000..7e20af3
--- /dev/null
+++ b/test/SemaCXX/builtin-ptrtomember-ambig.cpp
@@ -0,0 +1,24 @@
+// RUN: clang-cc -fsyntax-only -verify %s -std=c++0x
+
+struct A {};
+
+struct R {
+    operator const A*();
+};
+
+
+struct B  : R {
+    operator A*();
+};
+
+struct C : B {
+
+};
+
+
+void foo(C c, int A::* pmf) {
+                                       // FIXME. Why so many built-in candidates?
+       int i = c->*pmf;        // expected-error {{use of overloaded operator '->*' is ambiguous}} \
+                               // expected-note 40 {{built-in candidate operator ->* ('struct A}}
+}
+