Sema: Don't check SPI violations in diagnoseInlinableDeclRefAccess()

There's no need to check for that here, because we also run
diagnoseDeclRefExportability() on declarations referenced
from inlinable code.

This changes some diagnostics; we now produce the same diagnostic
for references to SPI types in declaration signatures and for
references to non-type SPI declarations in inlinable function bodies.

Also note that the old inlinable reference diagnostic no longer has
to handle the 'public' and 'open' access levels, which previously
happened for '@_spi'; so I changed those entries in the %select to
%error.

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -5061,12 +5061,12 @@ ERROR(local_type_in_inlinable_function,
       (Identifier, unsigned))
 
 ERROR(resilience_decl_unavailable,
-      none, DECL_OR_ACCESSOR "4 %1 is %select{private|fileprivate|internal|'@_spi'|'@_spi'}2 and "
+      none, DECL_OR_ACCESSOR "4 %1 is %select{private|fileprivate|internal|%error|%error}2 and "
       "cannot be referenced from " FRAGILE_FUNC_KIND "3",
       (DescriptiveDeclKind, DeclName, AccessLevel, unsigned, bool))
 
 WARNING(resilience_decl_unavailable_warn,
-        none, DECL_OR_ACCESSOR "4 %1 is %select{private|fileprivate|internal|'@_spi'|'@_spi'}2 and "
+        none, DECL_OR_ACCESSOR "4 %1 is %select{private|fileprivate|internal|%error|%error}2 and "
         "should not be referenced from " FRAGILE_FUNC_KIND "3",
         (DescriptiveDeclKind, DeclName, AccessLevel, unsigned, bool))
 

lib/Sema/ResilienceDiagnostics.cpp

@@ -40,10 +40,11 @@ bool TypeChecker::diagnoseInlinableDeclRefAccess(SourceLoc loc,
 
   auto *DC = where.getDeclContext();
 
-  // Public declarations or SPI used from SPI are OK.
+  // Public declarations are OK, even if they're SPI or came from an
+  // implementation-only import. We'll diagnose exportability violations
+  // from diagnoseDeclRefExportability().
   if (D->getFormalAccessScope(/*useDC=*/nullptr,
-                              fragileKind.allowUsableFromInline).isPublic() &&
-      !(D->isSPI() && !DC->getInnermostDeclarationDeclContext()->isSPI()))
+                              fragileKind.allowUsableFromInline).isPublic())
     return false;
 
   auto &Context = DC->getASTContext();

lib/Sema/TypeCheckAvailability.cpp

@@ -148,14 +148,15 @@ static void forEachOuterDecl(DeclContext *DC, Fn fn) {
   }
 }
 
-static void computeExportContextBits(Decl *D,
-                                     bool *implicit, bool *deprecated,
+static void computeExportContextBits(ASTContext &Ctx, Decl *D,
+                                     bool *spi, bool *implicit, bool *deprecated,
                                      Optional<PlatformKind> *unavailablePlatformKind) {
+  if (D->isSPI())
+    *spi = true;
+
   if (D->isImplicit())
     *implicit = true;
 
-  auto &Ctx = D->getASTContext();
-
   if (D->getAttrs().getDeprecated(Ctx))
     *deprecated = true;
 
@@ -166,66 +167,55 @@ static void computeExportContextBits(Decl *D,
   if (auto *PBD = dyn_cast<PatternBindingDecl>(D)) {
     for (unsigned i = 0, e = PBD->getNumPatternEntries(); i < e; ++i) {
       if (auto *VD = PBD->getAnchoringVarDecl(i))
-        computeExportContextBits(VD, implicit, deprecated,
+        computeExportContextBits(Ctx, VD, spi, implicit, deprecated,
                                  unavailablePlatformKind);
     }
   }
 }
 
 ExportContext ExportContext::forDeclSignature(Decl *D) {
+  auto &Ctx = D->getASTContext();
+
+  auto *DC = D->getInnermostDeclContext();
+  auto fragileKind = DC->getFragileFunctionKind();
+
+  bool spi = false;
   bool implicit = false;
   bool deprecated = false;
   Optional<PlatformKind> unavailablePlatformKind;
-  computeExportContextBits(D, &implicit, &deprecated,
+  computeExportContextBits(Ctx, D, &spi, &implicit, &deprecated,
                            &unavailablePlatformKind);
   forEachOuterDecl(D->getDeclContext(),
                    [&](Decl *D) {
-                     computeExportContextBits(D, &implicit, &deprecated,
+                     computeExportContextBits(Ctx, D,
+                                              &spi, &implicit, &deprecated,
                                               &unavailablePlatformKind);
                    });
 
-  auto *DC = D->getInnermostDeclContext();
-  auto fragileKind = DC->getFragileFunctionKind();
-
-  bool spi = D->isSPI();
-  if (auto *PBD = dyn_cast<PatternBindingDecl>(D)) {
-    for (unsigned i = 0, e = PBD->getNumPatternEntries(); i < e; ++i) {
-      if (auto *VD = PBD->getAnchoringVarDecl(i)) {
-        if (VD->isSPI()) {
-          spi = true;
-          break;
-        }
-      }
-    }
-  }
-
   bool exported = ::isExported(D);
 
   return ExportContext(DC, fragileKind, spi, exported, implicit, deprecated,
                        unavailablePlatformKind);
 }
 
 ExportContext ExportContext::forFunctionBody(DeclContext *DC) {
+  auto &Ctx = DC->getASTContext();
+
+  auto fragileKind = DC->getFragileFunctionKind();
+
+  bool spi = false;
   bool implicit = false;
   bool deprecated = false;
   Optional<PlatformKind> unavailablePlatformKind;
   forEachOuterDecl(DC,
                    [&](Decl *D) {
-                     computeExportContextBits(D, &implicit, &deprecated,
+                     computeExportContextBits(Ctx, D,
+                                              &spi, &implicit, &deprecated,
                                               &unavailablePlatformKind);
                    });
 
-  auto fragileKind = DC->getFragileFunctionKind();
-
-  bool spi = false;
   bool exported = false;
 
-  if (auto *D = DC->getInnermostDeclarationDeclContext()) {
-    spi = D->isSPI();
-  } else {
-    assert(fragileKind.kind == FragileFunctionKind::None);
-  }
-
   return ExportContext(DC, fragileKind, spi, exported, implicit, deprecated,
                        unavailablePlatformKind);
 }

test/SPI/implementation_only_spi_import_exposability.swift

@@ -36,10 +36,10 @@ public struct PublicStruct : IOIProtocol, SPIProtocol { // expected-error {{cann
 
   @inlinable
   public func publicInlinable() {
-    spiFunc() // expected-error {{global function 'spiFunc()' is '@_spi' and cannot be referenced from an '@inlinable' function}}
+    spiFunc() // expected-error {{global function 'spiFunc()' cannot be used in an '@inlinable' function because 'Lib' was imported implementation-only}}
     ioiFunc() // expected-error {{global function 'ioiFunc()' cannot be used in an '@inlinable' function because 'Lib' was imported implementation-only}}
-    let _ = SPIStruct() // expected-error {{struct 'SPIStruct' is '@_spi' and cannot be referenced from an '@inlinable' function}}
-    // expected-error@-1 {{initializer 'init()' is '@_spi' and cannot be referenced from an '@inlinable' function}}
+    let _ = SPIStruct() // expected-error {{struct 'SPIStruct' cannot be used in an '@inlinable' function because 'Lib' was imported implementation-only}}
+    // expected-error@-1 {{initializer 'init()' cannot be used in an '@inlinable' function because 'Lib' was imported implementation-only}}
     let _ = IOIStruct() // expected-error {{struct 'IOIStruct' cannot be used in an '@inlinable' function because 'Lib' was imported implementation-only}}
     // expected-error@-1 {{initializer 'init()' cannot be used in an '@inlinable' function because 'Lib' was imported implementation-only}}
   }

test/SPI/local_spi_decls.swift

@@ -7,18 +7,14 @@
 // RUN: %target-typecheck-verify-swift -I %t -verify-ignore-unknown -swift-version 5
 
 // SPI declarations
-@_spi(MySPI) public func spiFunc() {} // expected-note 2 {{global function 'spiFunc()' is not '@usableFromInline' or public}}
+@_spi(MySPI) public func spiFunc() {}
 @_spi(+) public func invalidSPIName() {} // expected-error {{expected an SPI identifier as subject of the '@_spi' attribute}}
 @_spi(🤔) public func emojiNamedSPI() {}
 @_spi() public func emptyParensSPI() {} // expected-error {{expected an SPI identifier as subject of the '@_spi' attribute}}
 @_spi(set) public func keywordSPI() {} // expected-error {{expected an SPI identifier as subject of the '@_spi' attribute}}
 
 @_spi(S) public class SPIClass { // expected-note 6 {{type declared here}}
-  // expected-note@-1 3 {{class 'SPIClass' is not '@usableFromInline' or public}}
-  // expected-note@-2 {{class 'SPIClass' is not public}}
   public init() {}
-  // expected-note@-1 2 {{initializer 'init()' is not '@usableFromInline' or public}}
-  // expected-note@-2 {{initializer 'init()' is not public}}
 }
 class InternalClass {} // expected-note 2 {{type declared here}}
 private class PrivateClass {} // expected-note 2 {{type declared here}}
@@ -31,28 +27,24 @@ public func useOfSPITypeInvalid() -> SPIClass { fatalError() } // expected-error
 @_spi(S) public func spiUseOfPrivateType(_ a: PrivateClass)  { fatalError() } // expected-error{{function cannot be declared public because its parameter uses a private type}}
 
 @inlinable
-func inlinable() -> SPIClass { // expected-error {{class 'SPIClass' is '@_spi' and cannot be referenced from an '@inlinable' function}}
-  spiFunc() // expected-error {{global function 'spiFunc()' is '@_spi' and cannot be referenced from an '@inlinable' function}}
-  _ = SPIClass() // expected-error {{class 'SPIClass' is '@_spi' and cannot be referenced from an '@inlinable' function}}
-  // expected-error@-1 {{initializer 'init()' is '@_spi' and cannot be referenced from an '@inlinable' function}}
+func inlinable() -> SPIClass { // expected-error {{class 'SPIClass' cannot be used in an '@inlinable' function because it is SPI}}
+  spiFunc() // expected-error {{global function 'spiFunc()' cannot be used in an '@inlinable' function because it is SPI}}
+  _ = SPIClass() // expected-error {{class 'SPIClass' cannot be used in an '@inlinable' function because it is SPI}}
+  // expected-error@-1 {{initializer 'init()' cannot be used in an '@inlinable' function because it is SPI}}
 }
 
-@_spi(S) public struct SPIStruct { // expected-note 2 {{struct 'SPIStruct' is not '@usableFromInline' or public}}
-// expected-note@-1 2 {{type declared here}}
-  // FIXME: Misleading diagnostic here
+@_spi(S) public struct SPIStruct {
+// expected-note@-1 {{type declared here}}
   public init() {}
-  // expected-note@-1 2 {{initializer 'init()' is not '@usableFromInline' or public}}
 }
 
 @frozen public struct FrozenStruct {
-  @_spi(S) public var spiInFrozen = SPIStruct() // expected-error {{struct 'SPIStruct' is '@_spi' and cannot be referenced from a property initializer in a '@frozen' type}}
+  @_spi(S) public var spiInFrozen = SPIStruct()
   // expected-error@-1 {{stored property 'spiInFrozen' cannot be declared '@_spi' in a '@frozen' struct}}
-  // expected-error@-2 {{cannot use struct 'SPIStruct' here; it is SPI}}
-  // expected-error@-3 {{initializer 'init()' is '@_spi' and cannot be referenced from a property initializer in a '@frozen' type}}
 
-  var spiTypeInFrozen = SPIStruct() // expected-error {{struct 'SPIStruct' is '@_spi' and cannot be referenced from a property initializer in a '@frozen' type}}
+  var spiTypeInFrozen = SPIStruct() // expected-error {{struct 'SPIStruct' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
   // expected-error@-1 {{cannot use struct 'SPIStruct' here; it is SPI}}
-  // expected-error@-2 {{initializer 'init()' is '@_spi' and cannot be referenced from a property initializer in a '@frozen' type}}
+  // expected-error@-2 {{initializer 'init()' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
 
   private var spiTypeInFrozen1: SPIClass // expected-error {{cannot use class 'SPIClass' here; it is SPI}}
 }
@@ -109,17 +101,17 @@ public struct NestedParent {
 }
 
 public func publicFuncWithDefaultValue(_ p: SPIClass = SPIClass()) {} // expected-error {{cannot use class 'SPIClass' here; it is SPI}}
-// expected-error@-1 {{class 'SPIClass' is '@_spi' and cannot be referenced from a default argument value}}
-// expected-error@-2 {{initializer 'init()' is '@_spi' and cannot be referenced from a default argument value}}
+// expected-error@-1 {{class 'SPIClass' cannot be used in a default argument value because it is SPI}}
+// expected-error@-2 {{initializer 'init()' cannot be used in a default argument value because it is SPI}}
 
 @_spi(S)
 public func spiFuncWithDefaultValue(_ p: SPIClass = SPIClass()) {}
 
 @inlinable
 public func inlinablePublic() {
-  spiFunc() // expected-error {{global function 'spiFunc()' is '@_spi' and cannot be referenced from an '@inlinable' function}}
-  let _ = SPIClass() // expected-error {{class 'SPIClass' is '@_spi' and cannot be referenced from an '@inlinable' function}}
-  // expected-error@-1 {{initializer 'init()' is '@_spi' and cannot be referenced from an '@inlinable' function}}
+  spiFunc() // expected-error {{global function 'spiFunc()' cannot be used in an '@inlinable' function because it is SPI}}
+  let _ = SPIClass() // expected-error {{class 'SPIClass' cannot be used in an '@inlinable' function because it is SPI}}
+  // expected-error@-1 {{initializer 'init()' cannot be used in an '@inlinable' function because it is SPI}}
 }
 
 @_spi(S)

test/SPI/spi_client.swift

@@ -53,11 +53,11 @@ public func publicUseOfSPI(param: SPIClass) -> SPIClass {} // expected-error 2{{
 public func publicUseOfSPI2() -> [SPIClass] {} // expected-error {{cannot use class 'SPIClass' here; it is an SPI imported from 'SPIHelper'}}
 
 @inlinable
-public func inlinable1() -> SPIClass { // expected-error {{class 'SPIClass' is '@_spi' and cannot be referenced from an '@inlinable' function}}
-  spiFunc() // expected-error {{global function 'spiFunc()' is '@_spi' and cannot be referenced from an '@inlinable' function}}
-  _ = SPIClass() // expected-error {{class 'SPIClass' is '@_spi' and cannot be referenced from an '@inlinable' function}}
-  // expected-error@-1 {{initializer 'init()' is '@_spi' and cannot be referenced from an '@inlinable' function}}
-  _ = [SPIClass]() // expected-error {{class 'SPIClass' is '@_spi' and cannot be referenced from an '@inlinable' function}}
+public func inlinable1() -> SPIClass { // expected-error {{class 'SPIClass' cannot be used in an '@inlinable' function because it is an SPI imported from 'SPIHelper'}}
+  spiFunc() // expected-error {{global function 'spiFunc()' cannot be used in an '@inlinable' function because it is an SPI imported from 'SPIHelper'}}
+  _ = SPIClass() // expected-error {{class 'SPIClass' cannot be used in an '@inlinable' function because it is an SPI imported from 'SPIHelper'}}
+  // expected-error@-1 {{initializer 'init()' cannot be used in an '@inlinable' function because it is an SPI imported from 'SPIHelper'}}
+  _ = [SPIClass]() // expected-error {{class 'SPIClass' cannot be used in an '@inlinable' function because it is an SPI imported from 'SPIHelper'}}
 }
 
 @_spi(S)

test/SPI/spi_members.swift

@@ -1,11 +1,110 @@
 // RUN: %target-typecheck-verify-swift
 
+@propertyWrapper
+public struct Wrapper<T> {
+  public init(wrappedValue: T) {}
+
+  public var wrappedValue: T { fatalError() }
+}
+
 @_spi(Foo)
-public class Bar {}
+public class Bar {
+  // expected-note@-1 11{{type declared here}}
+
+  public init() {}
+}
+
+public struct Resilient {
+  public init() {}
+
+  @_spi(Foo) public func method(_: Bar) {}
+  @_spi(Foo) public var computedProperty: Bar { Bar() }
+
+  @_spi(Foo) public var storedProperty1: Bar
+  @_spi(Foo) public var storedProperty2 = Bar()
+  @_spi(Foo) public lazy var lazyProperty1 = Bar()
+  @_spi(Foo) public lazy var lazyProperty2: Bar = Bar()
+  @_spi(Foo) @Wrapper public var wrappedProperty1: Bar
+  @_spi(Foo) @Wrapper public var wrappedProperty2 = Bar()
+}
 
-public struct Foo {
+@frozen public struct Good {
   public init() {}
 
   @_spi(Foo) public func method(_: Bar) {}
-  @_spi(Foo) public var property: Bar { Bar() }
+  @_spi(Foo) public var computedProperty: Bar { Bar() }
+
+  @_spi(Foo) public var storedProperty1: Bar
+  // expected-error@-1 {{cannot use class 'Bar' here; it is SPI}}
+  // expected-error@-2 {{stored property 'storedProperty1' cannot be declared '@_spi' in a '@frozen' struct}}
+
+  @_spi(Foo) public var storedProperty2 = Bar()
+  // expected-error@-1 {{stored property 'storedProperty2' cannot be declared '@_spi' in a '@frozen' struct}}
+
+  @_spi(Foo) public lazy var lazyProperty1 = Bar()
+  @_spi(Foo) public lazy var lazyProperty2: Bar = Bar()
+  @_spi(Foo) @Wrapper public var wrappedProperty1: Bar
+  @_spi(Foo) @Wrapper public var wrappedProperty2 = Bar()
+}
+
+@frozen public struct Bad {
+  public init() {}
+
+  public func method(_: Bar) {} // expected-error {{cannot use class 'Bar' here; it is SPI}}
+
+  public var storedProperty1: Bar
+  // expected-error@-1 {{cannot use class 'Bar' here; it is SPI}}
+
+  public var storedProperty2 = Bar()
+  // expected-error@-1 {{cannot use class 'Bar' here; it is SPI}}
+  // expected-error@-2 {{class 'Bar' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
+  // expected-error@-3 {{initializer 'init()' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
+
+  public var computedProperty: Bar { Bar() } // expected-error {{cannot use class 'Bar' here; it is SPI}}
+
+  public lazy var lazyProperty1 = Bar() // expected-error {{cannot use class 'Bar' here; it is SPI}}
+  // expected-error@-1 {{initializer 'init()' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
+  // expected-error@-2 {{class 'Bar' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
+
+  public lazy var lazyProperty2: Bar = Bar() // expected-error {{cannot use class 'Bar' here; it is SPI}}
+  // expected-error@-1 {{initializer 'init()' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
+  // expected-error@-2 {{class 'Bar' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
+
+  @Wrapper public var wrappedProperty1: Bar
+  // expected-error@-1 {{cannot use class 'Bar' here; it is SPI}}
+
+  @Wrapper public var wrappedProperty2 = Bar()
+  // expected-error@-1 {{cannot use class 'Bar' here; it is SPI}}
+  // expected-error@-2 {{class 'Bar' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
+  // expected-error@-3 {{initializer 'init()' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
+}
+
+@frozen public struct BadPrivate {
+  private init() {}
+
+  private func method(_: Bar) {}
+
+  private var storedProperty1: Bar
+  // expected-error@-1 {{cannot use class 'Bar' here; it is SPI}}
+
+  private var storedProperty2 = Bar()
+  // expected-error@-1 {{cannot use class 'Bar' here; it is SPI}}
+  // expected-error@-2 {{class 'Bar' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
+  // expected-error@-3 {{initializer 'init()' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
+
+  private var computedProperty: Bar { Bar() }
+
+  private lazy var lazyProperty1 = Bar()
+  // expected-error@-1 {{initializer 'init()' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
+  // expected-error@-2 {{class 'Bar' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
+
+  private lazy var lazyProperty2: Bar = Bar()
+  // expected-error@-1 {{initializer 'init()' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
+  // expected-error@-2 {{class 'Bar' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
+
+  @Wrapper private var wrappedProperty1: Bar
+
+  @Wrapper private var wrappedProperty2 = Bar()
+  // expected-error@-1 {{class 'Bar' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
+  // expected-error@-2 {{initializer 'init()' cannot be used in a property initializer in a '@frozen' type because it is SPI}}
 }