Sema: Refactor getDisallowedOriginKind() to take an ExportContext

Converting the innermost DeclContext into a Decl won't work if
the innermost DeclContext is the parent context of a VarDecl.

Instead, use the relevant bit of state from the ExportContext,
which is computed correctly.

This fixes a regression caused by an earlier commit in this PR
which our test suite did not catch.

Author: slavapestov

Diff for: lib/Sema/ResilienceDiagnostics.cpp

@@ -152,12 +152,8 @@ TypeChecker::diagnoseDeclRefExportability(SourceLoc loc,
 
   auto downgradeToWarning = DowngradeToWarning::No;
 
-  auto *DC = where.getDeclContext();
   auto originKind = getDisallowedOriginKind(
-      D,
-      *DC->getParentSourceFile(),
-      DC->getInnermostDeclarationDeclContext(),
-      downgradeToWarning);
+      D, where, downgradeToWarning);
   if (originKind == DisallowedOriginKind::None)
     return false;
 
@@ -195,11 +191,9 @@ TypeChecker::diagnoseConformanceExportability(SourceLoc loc,
   if (!where.mustOnlyReferenceExportedDecls())
     return false;
 
-  auto *DC = where.getDeclContext();
   auto originKind = getDisallowedOriginKind(
       rootConf->getDeclContext()->getAsDecl(),
-      *DC->getParentSourceFile(),
-      DC->getInnermostDeclarationDeclContext());
+      where);
   if (originKind == DisallowedOriginKind::None)
     return false;
 

Diff for: lib/Sema/TypeCheckAccess.cpp

@@ -1460,22 +1460,22 @@ class UsableFromInlineChecker : public AccessControlCheckerBase,
 /// Local variant to swift::getDisallowedOriginKind for downgrade to warnings.
 DisallowedOriginKind
 swift::getDisallowedOriginKind(const Decl *decl,
-                               const SourceFile &userSF,
-                               const Decl *userContext,
+                               ExportContext where,
                                DowngradeToWarning &downgradeToWarning) {
   downgradeToWarning = DowngradeToWarning::No;
   ModuleDecl *M = decl->getModuleContext();
-  if (userSF.isImportedImplementationOnly(M)) {
+  auto *SF = where.getDeclContext()->getParentSourceFile();
+  if (SF->isImportedImplementationOnly(M)) {
     // Temporarily downgrade implementation-only exportability in SPI to
     // a warning.
-    if (userContext->isSPI())
+    if (where.isSPI())
       downgradeToWarning = DowngradeToWarning::Yes;
 
     // Implementation-only imported, cannot be reexported.
     return DisallowedOriginKind::ImplementationOnly;
-  } else if (decl->isSPI() && !userContext->isSPI()) {
+  } else if (decl->isSPI() && !where.isSPI()) {
     // SPI can only be exported in SPI.
-    return userContext->getModuleContext() == M ?
+    return where.getDeclContext()->getParentModule() == M ?
       DisallowedOriginKind::SPILocal :
       DisallowedOriginKind::SPIImported;
   }
@@ -1842,10 +1842,9 @@ static void checkExtensionGenericParamAccess(const ExtensionDecl *ED) {
 }
 
 DisallowedOriginKind swift::getDisallowedOriginKind(const Decl *decl,
-                                                    const SourceFile &userSF,
-                                                    const Decl *declContext) {
+                                                    ExportContext where) {
   auto downgradeToWarning = DowngradeToWarning::No;
-  return getDisallowedOriginKind(decl, userSF, declContext, downgradeToWarning);
+  return getDisallowedOriginKind(decl, where, downgradeToWarning);
 }
 
 void swift::checkAccessControl(Decl *D) {

Diff for: lib/Sema/TypeCheckAccess.h

@@ -22,6 +22,7 @@
 namespace swift {
 
 class Decl;
+class ExportContext;
 class SourceFile;
 
 /// Performs access-related checks for \p D.
@@ -55,12 +56,10 @@ enum class DowngradeToWarning: bool {
 /// Returns the kind of origin, implementation-only import or SPI declaration,
 /// that restricts exporting \p decl from the given file and context.
 DisallowedOriginKind getDisallowedOriginKind(const Decl *decl,
-                                             const SourceFile &userSF,
-                                             const Decl *userContext);
+                                             ExportContext where);
 
 DisallowedOriginKind getDisallowedOriginKind(const Decl *decl,
-                                             const SourceFile &userSF,
-                                             const Decl *userContext,
+                                             ExportContext where,
                                              DowngradeToWarning &downgradeToWarning);
 
 } // end namespace swift

Diff for: lib/Sema/TypeCheckAvailability.cpp

@@ -98,7 +98,19 @@ bool swift::isExported(const Decl *D) {
 ExportContext ExportContext::forDeclSignature(Decl *D) {
   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);

Diff for: lib/Sema/TypeCheckProtocol.cpp

@@ -4337,9 +4337,11 @@ static void checkExportability(Type depTy, Type replacementTy,
       conformance->getRootConformance();
   ModuleDecl *M = rootConformance->getDeclContext()->getParentModule();
 
+  auto where = ExportContext::forDeclSignature(
+      DC->getInnermostDeclarationDeclContext());
   auto originKind = getDisallowedOriginKind(
       rootConformance->getDeclContext()->getAsDecl(),
-      *SF, DC->getAsDecl());
+      where);
   if (originKind == DisallowedOriginKind::None)
     return;
 

Diff for: test/SPI/spi_members.swift

@@ -0,0 +1,11 @@
+// RUN: %target-typecheck-verify-swift
+
+@_spi(Foo)
+public class Bar {}
+
+public struct Foo {
+  public init() {}
+
+  @_spi(Foo) public func method(_: Bar) {}
+  @_spi(Foo) public var property: Bar { Bar() }
+}