Merge pull request #85919 from slavapestov/strict-access-control

Sema: New StrictAccessControl upcoming feature

Author: slavapestov

include/swift/Basic/Features.def

@@ -303,6 +303,7 @@ MIGRATABLE_UPCOMING_FEATURE(MemberImportVisibility, 444, 7)
 MIGRATABLE_UPCOMING_FEATURE(InferIsolatedConformances, 470, 7)
 MIGRATABLE_UPCOMING_FEATURE(NonisolatedNonsendingByDefault, 461, 7)
 UPCOMING_FEATURE(ImmutableWeakCaptures, 481, 7)
+UPCOMING_FEATURE(StrictAccessControl, 0, 7)
 
 // Optional language features / modes
 

lib/AST/FeatureSet.cpp

@@ -500,6 +500,7 @@ static bool usesFeatureTildeSendable(Decl *decl) {
 }
 
 UNINTERESTING_FEATURE(AnyAppleOSAvailability)
+UNINTERESTING_FEATURE(StrictAccessControl)
 
 // ----------------------------------------------------------------------------
 // MARK: - FeatureSet

lib/Sema/ResilienceDiagnostics.cpp

@@ -119,7 +119,9 @@ bool TypeChecker::diagnoseInlinableDeclRefAccess(SourceLoc loc,
   }
 
   // Swift 5.0 did not check the underlying types of local typealiases.
-  if (isa<TypeAliasDecl>(DC) && !Context.isLanguageModeAtLeast(6))
+  if (isa<TypeAliasDecl>(DC) &&
+      !Context.LangOpts.hasFeature(Feature::StrictAccessControl) &&
+      !Context.isLanguageModeAtLeast(6))
     downgradeToWarning = DowngradeToWarning::Yes;
 
   auto diagID = diag::resilience_decl_unavailable;
@@ -207,7 +209,8 @@ static bool diagnoseTypeAliasDeclRefExportability(SourceLoc loc,
   }
   D->diagnose(diag::kind_declared_here, DescriptiveDeclKind::Type);
 
-  if (originKind == DisallowedOriginKind::MissingImport &&
+  if (!ctx.LangOpts.hasFeature(Feature::StrictAccessControl) &&
+      originKind == DisallowedOriginKind::MissingImport &&
       !ctx.isLanguageModeAtLeast(6))
     addMissingImport(loc, D, where);
 
@@ -460,7 +463,8 @@ TypeChecker::diagnoseConformanceExportability(SourceLoc loc,
               originKind == DisallowedOriginKind::MissingImport,
           6);
 
-  if (originKind == DisallowedOriginKind::MissingImport &&
+  if (!ctx.LangOpts.hasFeature(Feature::StrictAccessControl) &&
+      originKind == DisallowedOriginKind::MissingImport &&
       !ctx.isLanguageModeAtLeast(6))
     addMissingImport(loc, ext, where);
 

lib/Sema/TypeCheckAccess.cpp

@@ -550,11 +550,12 @@ void AccessControlCheckerBase::checkGenericParamAccess(
   if (minAccessScope.isPublic())
     return;
 
-  // FIXME: Promote these to an error in the next -swift-version break.
-  if (isa<SubscriptDecl>(ownerDecl) || isa<TypeAliasDecl>(ownerDecl))
+  auto &Context = ownerDecl->getASTContext();
+
+  if (!Context.LangOpts.hasFeature(Feature::StrictAccessControl) &&
+      (isa<SubscriptDecl>(ownerDecl) || isa<TypeAliasDecl>(ownerDecl)))
     downgradeToWarning = DowngradeToWarning::Yes;
 
-  auto &Context = ownerDecl->getASTContext();
   if (checkUsableFromInline) {
     if (!Context.isLanguageModeAtLeast(5))
       downgradeToWarning = DowngradeToWarning::Yes;
@@ -2042,14 +2043,16 @@ swift::getDisallowedOriginKind(const Decl *decl,
   downgradeToWarning = DowngradeToWarning::No;
   ModuleDecl *M = decl->getModuleContext();
   auto *SF = where.getDeclContext()->getParentSourceFile();
+  auto &Context = M->getASTContext();
 
   RestrictedImportKind howImported = SF->getRestrictedImportKind(M);
   if (howImported != RestrictedImportKind::None) {
     // Temporarily downgrade implementation-only exportability in SPI to
     // a warning.
-    if (where.isSPI() &&
+    if (!Context.LangOpts.hasFeature(Feature::StrictAccessControl) &&
+        where.isSPI() &&
         where.getFragileFunctionKind().kind == FragileFunctionKind::None &&
-        !SF->getASTContext().LangOpts.EnableSPIOnlyImports)
+        !Context.LangOpts.EnableSPIOnlyImports)
       downgradeToWarning = DowngradeToWarning::Yes;
 
     if (where.isSPI() && howImported == RestrictedImportKind::SPIOnly)
@@ -2058,8 +2061,9 @@ swift::getDisallowedOriginKind(const Decl *decl,
     // Before Swift 6, implicit imports were not reported unless an
     // implementation-only import was also present. Downgrade to a warning
     // just in this case.
-    if (howImported == RestrictedImportKind::MissingImport &&
-        !SF->getASTContext().isLanguageModeAtLeast(6) &&
+    if (!Context.LangOpts.hasFeature(Feature::StrictAccessControl) &&
+        howImported == RestrictedImportKind::MissingImport &&
+        !Context.isLanguageModeAtLeast(6) &&
         !SF->hasImportsWithFlag(ImportFlags::ImplementationOnly)) {
       downgradeToWarning = DowngradeToWarning::Yes;
     }
@@ -2087,7 +2091,7 @@ swift::getDisallowedOriginKind(const Decl *decl,
         if (!owningModule)
           continue;
         auto moduleWrapper =
-            decl->getASTContext().getClangModuleLoader()->getWrapperForModule(
+            Context.getClangModuleLoader()->getWrapperForModule(
                 owningModule);
         auto visibleAccessPath =
             find_if(sfImportedModules, [&moduleWrapper](auto importedModule) {
@@ -2150,7 +2154,7 @@ swift::getDisallowedOriginKind(const Decl *decl,
   }
 
   // C++ APIs do not support library evolution.
-  if (SF->getASTContext().LangOpts.EnableCXXInterop && where.getDeclContext() &&
+  if (Context.LangOpts.EnableCXXInterop && where.getDeclContext() &&
       where.getDeclContext()->getAsDecl() &&
       where.getDeclContext()->getAsDecl()->getModuleContext()->isResilient() &&
       !where.getDeclContext()
@@ -2159,13 +2163,13 @@ swift::getDisallowedOriginKind(const Decl *decl,
            ->getUnderlyingModuleIfOverlay() &&
       decl->hasClangNode() && !decl->getModuleContext()->isSwiftShimsModule() &&
       isFragileClangNode(decl->getClangNode()) &&
-      !SF->getASTContext().LangOpts.hasFeature(
+      !Context.LangOpts.hasFeature(
           Feature::AssumeResilientCxxTypes))
     return DisallowedOriginKind::FragileCxxAPI;
 
   // Implementation-only memory layouts for non-library-evolution mode.
   if (isa<NominalTypeDecl>(decl) &&
-      decl->getASTContext().LangOpts.hasFeature(
+      Context.LangOpts.hasFeature(
           Feature::CheckImplementationOnly) &&
       decl->getAttrs().hasAttribute<ImplementationOnlyAttr>())
     return DisallowedOriginKind::ImplementationOnlyMemoryLayout;

lib/Sema/TypeCheckAvailability.cpp

@@ -1087,7 +1087,7 @@ static bool diagnosePotentialUnavailability(
       // Don't downgrade
     } else if (behaviorLimit >= DiagnosticBehavior::Warning) {
       err.limitBehavior(behaviorLimit);
-    } else {
+    } else if (!ctx.LangOpts.hasFeature(Feature::StrictAccessControl)) {
       err.warnUntilLanguageMode(6);
     }
 
@@ -2179,7 +2179,8 @@ bool diagnoseExplicitUnavailability(
   // obsolete decls still map to valid ObjC runtime names, so behave correctly
   // at runtime, even though their use would produce an error outside of a
   // #keyPath expression.
-  auto limit = Flags.contains(DeclAvailabilityFlag::ForObjCKeyPath)
+  auto limit = (!ctx.LangOpts.hasFeature(Feature::StrictAccessControl) &&
+                Flags.contains(DeclAvailabilityFlag::ForObjCKeyPath))
                   ? DiagnosticBehavior::Warning
                   : DiagnosticBehavior::Unspecified;
 
@@ -2968,10 +2969,12 @@ diagnoseDeclAsyncAvailability(const ValueDecl *D, SourceRange R,
                                    attr->getMessage());
     if (D->preconcurrency()) {
       diag.limitBehavior(DiagnosticBehavior::Warning);
-    } else if (shouldWarnUntilFutureVersion()) {
-      diag.warnUntilFutureLanguageMode();
-    } else {
-      diag.warnUntilLanguageMode(6);
+    } else if (!ctx.LangOpts.hasFeature(Feature::StrictAccessControl)) {
+      if (shouldWarnUntilFutureVersion()) {
+        diag.warnUntilFutureLanguageMode();
+      } else {
+        diag.warnUntilLanguageMode(6);
+      }
     }
 
     if (!attr->getRename().empty()) {
@@ -2992,10 +2995,12 @@ diagnoseDeclAsyncAvailability(const ValueDecl *D, SourceRange R,
     SourceLoc diagLoc = call ? call->getLoc() : R.Start;
     auto diag = ctx.Diags.diagnose(diagLoc, diag::async_unavailable_decl, D,
                                    attr->Message);
-    if (shouldWarnUntilFutureVersion()) {
-      diag.warnUntilFutureLanguageMode();
-    } else {
-      diag.warnUntilLanguageMode(6);
+    if (!ctx.LangOpts.hasFeature(Feature::StrictAccessControl)) {
+      if (shouldWarnUntilFutureVersion()) {
+        diag.warnUntilFutureLanguageMode();
+      } else {
+        diag.warnUntilLanguageMode(6);
+      }
     }
   }
   D->diagnose(diag::decl_declared_here, D);

test/Sema/Inputs/strict_access_control_other.swift

@@ -0,0 +1 @@
+public struct ImplementationOnly {}

test/Sema/strict_access_control.swift

@@ -0,0 +1,31 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -emit-module-path %t/Other.swiftmodule %S/Inputs/strict_access_control_other.swift -module-name Other -swift-version 5
+// RUN: %target-typecheck-verify-swift -enable-upcoming-feature StrictAccessControl -swift-version 5 -enable-library-evolution -I %t -verify-ignore-unrelated
+
+// REQUIRES: swift_feature_StrictAccessControl
+
+@_implementationOnly import Other
+// expected-warning@-1 {{'@_implementationOnly' is deprecated, use 'internal import' instead}}
+
+private struct PrivateType {}
+// expected-note@-1 {{struct 'PrivateType' is not '@usableFromInline' or public}}
+
+@inlinable public func localTypeAliasTest() {
+  typealias Bad = PrivateType
+  // expected-error@-1 {{struct 'PrivateType' is private and cannot be referenced from an '@inlinable' function}}
+}
+
+private protocol PrivateProtocol {}
+// expected-note@-1 2{{type declared here}}
+
+public typealias BadRequirements<T> = T where T: PrivateProtocol
+// expected-error@-1 {{generic type alias cannot be declared public because its generic requirement uses a private type}}
+
+public struct S {
+  public subscript<T>(_: T) -> T where T: PrivateProtocol { fatalError() }
+  // expected-error@-1 {{subscript cannot be declared public because its generic requirement uses a private type}}
+}
+
+@_spi(Testing)
+public func badImplementationOnlyExport(_: ImplementationOnly) {}
+// expected-error@-1 {{cannot use struct 'ImplementationOnly' here; 'Other' has been imported as implementation-only}}