[Sema] Fix operator lookup to consider local extern declarations.

[EricWF]

Summary

Previously Clang was not considering operator declarations that occur at function scope. This is incorrect according to [over.match.oper]p3

The set of non-member candidates is the result of the unqualified lookup of operator@ in the context of the expression according to the usual rules for name lookup in unqualified function calls.

This patch changes operator name lookup to consider block scope declarations.
This patch fixes PR27027.

[EricWF]

Add more appropriate test.

[EricWF]

@rsmith Ping. This should be super simple to review.

[rsmith]

lib/Sema/SemaLookup.cpp

229

This isn't right; IDNS_LocalExtern finds local extern declarations in the namespace scope enclosing their declaration, so this will incorrectly allow:

struct A {} a;
void f() { extern bool operator==(A, A); }
bool b = a == a;

As far as I can see, the problem is that the constructor of FindLocalExternScope only enables finding local extern declarations if we're also looking for IDNS_Ordinary; the right fix would presumably be for it to also check for IDNS_NonMemberOperator.

[EricWF]

• Address issues in inline comments. The patch should be ready to go now :-)

[rsmith]

LGTM, thanks!

[EricWF]

@rsmith Should this be considered for the 5.0 release?

lib/Sema/SemaLookup.cpp

     if (Redeclaration)
       IDNS |= Decl::IDNS_LocalExtern;
     break;
 
   case Sema::LookupOperatorName:
     // Operator lookup is its own crazy thing;  it is not the same
     // as (e.g.) looking up an operator name for redeclaration.
     assert(!Redeclaration && "cannot do redeclaration operator lookup");
     IDNS = Decl::IDNS_NonMemberOperator;
     break;
 
   case Sema::LookupTagName:
     if (CPlusPlus) {
       IDNS = Decl::IDNS_Type;
 
       // When looking for a redeclaration of a tag name, we add:
       // 1) TagFriend to find undeclared friend decls

 
 namespace {
 /// An RAII object to specify that we want to find block scope extern
 /// declarations.
 struct FindLocalExternScope {
   FindLocalExternScope(LookupResult &R)
       : R(R), OldFindLocalExtern(R.getIdentifierNamespace() &
                                  Decl::IDNS_LocalExtern) {
-    R.setFindLocalExtern(R.getIdentifierNamespace() & Decl::IDNS_Ordinary);
+    R.setFindLocalExtern(R.getIdentifierNamespace() &
+                         (Decl::IDNS_Ordinary | Decl::IDNS_NonMemberOperator));
   }
   void restore() {
     R.setFindLocalExtern(OldFindLocalExtern);
   }
   ~FindLocalExternScope() {
     restore();
   }
   LookupResult &R;

test/SemaCXX/overloaded-operator.cpp

namespace NoADLForMemberOnlyOperators {
 
   void f(B<A<void> > b1, B<A<int> > b2, B<A<char> > b3) {
     b1 = b1; // ok, does not instantiate A<void>.
     (void)b1->n; // expected-error {{is not a pointer}}
     b2[3]; // expected-error {{does not provide a subscript}}
     b3 / 0; // expected-note {{in instantiation of}} expected-error {{invalid operands to}}
   }
 }
+
+
+namespace PR27027 {
+  template <class T> void operator+(T, T) = delete; // expected-note 4 {{candidate}}
+  template <class T> void operator+(T) = delete; // expected-note 4 {{candidate}}
+
+  struct A {} a_global;
+  void f() {
+    A a;
+    +a; // expected-error {{overload resolution selected deleted operator '+'}}
+    a + a; // expected-error {{overload resolution selected deleted operator '+'}}
+    bool operator+(A);
+    extern bool operator+(A, A);
+    +a; // OK
+    a + a;
+  }
+  bool test_global_1 = +a_global; // expected-error {{overload resolution selected deleted operator '+'}}
+  bool test_global_2 = a_global + a_global; // expected-error {{overload resolution selected deleted operator '+'}}
+}