Check the containing context when checking access for operators

This might help eliminate operators from overload sets sooner, if they
weren't supposed to be accessed from the current context at all. Or it
might not make any noticeable difference.

No functionality change; the tests added did not change behavior.

Author: jrose-apple

lib/AST/Decl.cpp

@@ -2480,6 +2480,7 @@ static bool checkAccessUsingAccessScopes(const DeclContext *useDC,
 static bool checkAccess(const DeclContext *useDC, const ValueDecl *VD,
                         AccessLevel access, bool forConformance) {
   auto *sourceDC = VD->getDeclContext();
+  bool canUseFastPath = true;
 
   if (!forConformance) {
     if (auto *proto = sourceDC->getAsProtocolOrProtocolExtensionContext()) {
@@ -2496,9 +2497,16 @@ static bool checkAccess(const DeclContext *useDC, const ValueDecl *VD,
         }
       }
 
-      // Skip the fast path below and just compare access scopes.
-      return checkAccessUsingAccessScopes(useDC, VD, access);
+      canUseFastPath = false;
     }
+
+    if (VD->isOperator())
+      canUseFastPath = false;
+  }
+
+  if (!canUseFastPath) {
+    // Skip the fast path below and just compare access scopes.
+    return checkAccessUsingAccessScopes(useDC, VD, access);
   }
 
   // Fast path: assume that the client context already has access to our parent
@@ -2534,15 +2542,10 @@ bool ValueDecl::isAccessibleFrom(const DeclContext *useDC,
   auto access = getFormalAccess();
   bool result = checkAccess(useDC, this, access, forConformance);
 
-  // For everything outside of protocols and operators, we should get the same
-  // result using either implementation of checkAccess, because useDC must
-  // already have access to this declaration's DeclContext.
-  // FIXME: Arguably, we're doing the wrong thing for operators here too,
-  // because we're finding internal operators within private types. Fortunately
-  // we have a requirement that a member operator take the enclosing type as an
-  // argument, so it won't ever match.
+  // For everything outside of protocols, we should get the same result using
+  // either implementation of checkAccess, because useDC must already have
+  // access to this declaration's DeclContext.
   assert(getDeclContext()->getAsProtocolOrProtocolExtensionContext() ||
-         isOperator() ||
          result == checkAccessUsingAccessScopes(useDC, this, access));
 
   return result;

test/SILGen/witness_accessibility.swift

@@ -1,21 +1,32 @@
 // RUN: %target-swift-emit-silgen -Xllvm -sil-full-demangle -enable-sil-ownership %s | %FileCheck %s
 
+prefix operator ^
+prefix operator ^^
+prefix operator ^^^
+
 public protocol P {
   func publicRequirement()
+  static prefix func ^(_: Self)
 }
 
 protocol Q : P {
   func internalRequirement()
+  static prefix func ^^(_: Self)
 }
 
 fileprivate protocol R : Q {
   func privateRequirement()
+  static prefix func ^^^(_: Self)
 }
 
 extension R {
   public func publicRequirement() {}
   func internalRequirement() {}
   func privateRequirement() {}
+
+  public static prefix func ^(_: Self) {}
+  static prefix func ^^(_: Self) {}
+  static prefix func ^^^(_: Self) {}
 }
 
 public struct S : R {}

test/attr/Inputs/attr_usableFromInline_protocol_hole_helper.swift

@@ -1,9 +1,17 @@
+prefix operator ^
+prefix operator ^^
+prefix operator ^^^
+
 public protocol PublicProtocol {
 }
 extension PublicProtocol {
   public func publicExtensionMethod() {}
   @usableFromInline internal func ufiExtensionMethod() {}
   internal func internalExtensionMethod() {}
+
+  public static prefix func ^(_: Self) {}
+  @usableFromInline internal static prefix func ^^(_: Self) {}
+  internal static prefix func ^^^(_: Self) {}
 }
 
 public struct PublicImpl: PublicProtocol {}
@@ -15,6 +23,10 @@ extension UFIProtocol {
   public func publicExtensionMethod() {}
   @usableFromInline internal func ufiExtensionMethod() {}
   internal func internalExtensionMethod() {}
+
+  public static prefix func ^(_: Self) {}
+  @usableFromInline internal static prefix func ^^(_: Self) {}
+  internal static prefix func ^^^(_: Self) {}
 }
 
 public struct UFIImpl: PublicProtocol {}

test/attr/attr_usableFromInline_protocol_hole.swift

@@ -8,16 +8,28 @@ func test(_ obj: PublicProtocol) {
   obj.publicExtensionMethod()
   obj.ufiExtensionMethod() // expected-error {{inaccessible}}
   obj.internalExtensionMethod() // expected-error {{inaccessible}}
+
+  _ = ^obj // expected-error {{}} expected-note {{}}
+  _ = ^^obj // expected-error {{}}
+  _ = ^^^obj // expected-error {{}}
 }
 
 func test(_ obj: PublicImpl) {
   obj.publicExtensionMethod()
   obj.ufiExtensionMethod() // expected-error {{inaccessible}}
   obj.internalExtensionMethod() // expected-error {{inaccessible}}
+
+  _ = ^obj
+  _ = ^^obj // expected-error {{}}
+  _ = ^^^obj // expected-error {{}}
 }
 
 func test(_ obj: UFIImpl) {
   obj.publicExtensionMethod() // This being accessible is the "hole".
   obj.ufiExtensionMethod() // expected-error {{inaccessible}}
   obj.internalExtensionMethod() // expected-error {{inaccessible}}
+
+  _ = ^obj // This being accessible is the "hole".
+  _ = ^^obj // expected-error {{}}
+  _ = ^^^obj // expected-error {{}}
 }