Merge pull request #36608 from xymus/lib-access-level

[Sema] Define library levels to detect public import of private modules and more

Author: xymus

include/swift/AST/DiagnosticsFrontend.def

@@ -36,6 +36,10 @@ ERROR(error_unsupported_target_os, none,
 ERROR(error_unsupported_target_arch, none,
       "unsupported target architecture: '%0'", (StringRef))
 
+ERROR(error_unknown_library_level, none,
+      "unknown library level '%0', "
+      "expected one of 'api', 'spi' or 'other'", (StringRef))
+
 ERROR(error_unsupported_opt_for_target, none,
       "unsupported option '%0' for target '%1'", (StringRef, StringRef))
 

include/swift/AST/DiagnosticsSema.def

@@ -2843,6 +2843,9 @@ WARNING(warn_implementation_only_conflict,none,
         (Identifier))
 NOTE(implementation_only_conflict_here,none,
      "imported as implementation-only here", ())
+WARNING(warn_public_import_of_private_module,none,
+        "private module %0 is imported publicly from the public module %1",
+        (Identifier, Identifier))
 
 ERROR(implementation_only_decl_non_override,none,
       "'@_implementationOnly' can only be used on overrides", ())

include/swift/AST/Module.h

@@ -56,6 +56,7 @@ namespace swift {
   class FileUnit;
   class FuncDecl;
   class InfixOperatorDecl;
+  enum class LibraryLevel : uint8_t;
   class LinkLibrary;
   class ModuleLoader;
   class NominalTypeDecl;
@@ -462,6 +463,9 @@ class ModuleDecl : public DeclContext, public TypeDecl {
     Bits.ModuleDecl.RawResilienceStrategy = unsigned(strategy);
   }
 
+  /// Distribution level of the module.
+  LibraryLevel getLibraryLevel() const;
+
   /// Returns true if this module was or is being compiled for testing.
   bool hasIncrementalInfo() const { return Bits.ModuleDecl.HasIncrementalInfo; }
   void setHasIncrementalInfo(bool enabled = true) {

include/swift/AST/TypeCheckRequests.h

@@ -2753,6 +2753,24 @@ class HasImplementationOnlyImportsRequest
   bool isCached() const { return true; }
 };
 
+/// Get the library level of a module.
+class ModuleLibraryLevelRequest
+    : public SimpleRequest<ModuleLibraryLevelRequest,
+                           LibraryLevel(const ModuleDecl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  LibraryLevel evaluate(Evaluator &evaluator, const ModuleDecl *module) const;
+
+public:
+  // Cached.
+  bool isCached() const { return true; }
+};
+
 class ResolveTypeRequest
     : public SimpleRequest<ResolveTypeRequest,
                            Type(const TypeResolution *, TypeRepr *,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -126,6 +126,8 @@ SWIFT_REQUEST(TypeChecker, HasDynamicCallableAttributeRequest,
               bool(CanType), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, HasImplementationOnlyImportsRequest,
               bool(SourceFile *), Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, ModuleLibraryLevelRequest,
+              LibraryLevel(ModuleDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, InferredGenericSignatureRequest,
               GenericSignature (ModuleDecl *, const GenericSignatureImpl *,
                                  GenericParamSource,

include/swift/Basic/LangOptions.h

@@ -55,6 +55,20 @@ namespace swift {
     Complete,
   };
 
+  /// Access or distribution level of a library.
+  enum class LibraryLevel : uint8_t {
+    /// Application Programming Interface that is publicly distributed so
+    /// public decls are really public and only @_spi decls are SPI.
+    API,
+
+    /// System Programming Interface that has restricted distribution
+    /// all decls in the module are considered to be SPI including public ones.
+    SPI,
+
+    /// The library has some other undefined distribution.
+    Other
+  };
+
   /// A collection of options that affect the language dialect and
   /// provide compiler debugging facilities.
   class LangOptions final {
@@ -306,6 +320,9 @@ namespace swift {
     /// Objective-C-derived classes and 'dynamic' members.
     bool EnableSwift3ObjCInference = false;
 
+    /// Access or distribution level of the whole module being parsed.
+    LibraryLevel LibraryLevel = LibraryLevel::Other;
+
     /// Warn about cases where Swift 3 would infer @objc but later versions
     /// of Swift do not.
     Swift3ObjCInferenceWarnings WarnSwift3ObjCInference =

include/swift/Option/FrontendOptions.td

@@ -433,6 +433,11 @@ def disable_swift3_objc_inference :
   Flags<[FrontendOption, HelpHidden]>,
   HelpText<"Disable Swift 3's @objc inference rules for NSObject-derived classes and 'dynamic' members (emulates Swift 4 behavior)">;
 
+def library_level : Separate<["-"], "library-level">,
+  MetaVarName<"<level>">,
+  Flags<[FrontendOption]>,
+  HelpText<"Library distribution level 'api', 'spi' or 'other' (the default)">;
+
 def enable_implicit_dynamic : Flag<["-"], "enable-implicit-dynamic">,
   Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
   HelpText<"Add 'dynamic' to all declarations">;

lib/AST/Module.cpp

@@ -2246,6 +2246,53 @@ SPIGroupsRequest::evaluate(Evaluator &evaluator, const Decl *decl) const {
   return ctx.AllocateCopy(spiGroups.getArrayRef());
 }
 
+LibraryLevel ModuleDecl::getLibraryLevel() const {
+  return evaluateOrDefault(getASTContext().evaluator,
+                           ModuleLibraryLevelRequest{this},
+                           LibraryLevel::Other);
+}
+
+LibraryLevel
+ModuleLibraryLevelRequest::evaluate(Evaluator &evaluator,
+                                    const ModuleDecl *module) const {
+  auto &ctx = module->getASTContext();
+
+  /// Is \p modulePath from System/Library/PrivateFrameworks/?
+  auto fromPrivateFrameworks = [&](StringRef modulePath) -> bool {
+    if (!ctx.LangOpts.Target.isOSDarwin()) return false;
+
+    namespace path = llvm::sys::path;
+    SmallString<128> scratch;
+    scratch = ctx.SearchPathOpts.SDKPath;
+    path::append(scratch, "System", "Library", "PrivateFrameworks");
+    return hasPrefix(path::begin(modulePath), path::end(modulePath),
+                     path::begin(scratch), path::end(scratch));
+  };
+
+  if (module->isNonSwiftModule()) {
+    if (auto *underlying = module->findUnderlyingClangModule()) {
+      // Imported clangmodules are SPI if they are defined by a private
+      // modulemap or from the PrivateFrameworks folder in the SDK.
+      bool moduleIsSPI = underlying->ModuleMapIsPrivate ||
+                         (underlying->isPartOfFramework() &&
+                          fromPrivateFrameworks(underlying->PresumedModuleMapFile));
+      return moduleIsSPI ? LibraryLevel::SPI : LibraryLevel::API;
+    }
+    return LibraryLevel::Other;
+
+  } else if (module->isMainModule()) {
+    // The current compilation target.
+    return ctx.LangOpts.LibraryLevel;
+
+  } else {
+    // Other Swift modules are SPI if they are from the PrivateFrameworks
+    // folder in the SDK.
+    auto modulePath = module->getModuleFilename();
+    return fromPrivateFrameworks(modulePath) ?
+      LibraryLevel::SPI : LibraryLevel::API;
+  }
+}
+
 bool SourceFile::shouldCrossImport() const {
   return Kind != SourceFileKind::SIL && Kind != SourceFileKind::Interface &&
          getASTContext().LangOpts.EnableCrossImportOverlays;

lib/Frontend/CompilerInvocation.cpp

@@ -538,6 +538,27 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     Args.hasFlag(OPT_enable_swift3_objc_inference,
                  OPT_disable_swift3_objc_inference, false);
 
+  if (const Arg *A = Args.getLastArg(OPT_library_level)) {
+    StringRef contents = A->getValue();
+    if (contents == "api") {
+      Opts.LibraryLevel = LibraryLevel::API;
+    } else if (contents == "spi") {
+      Opts.LibraryLevel = LibraryLevel::SPI;
+    } else {
+      Opts.LibraryLevel = LibraryLevel::Other;
+      if (contents != "other") {
+        // Error on unknown library levels.
+        auto inFlight = Diags.diagnose(SourceLoc(),
+                                       diag::error_unknown_library_level,
+                                       contents);
+
+        // Only warn for "ipi" as we may use it in the future.
+        if (contents == "ipi")
+          inFlight.limitBehavior(DiagnosticBehavior::Warning);
+      }
+    }
+  }
+
   if (Opts.EnableSwift3ObjCInference) {
     if (const Arg *A = Args.getLastArg(
                                    OPT_warn_swift3_objc_inference_minimal,

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1610,6 +1610,25 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     // Force the lookup of decls referenced by a scoped import in case it emits
     // diagnostics.
     (void)ID->getDecls();
+
+    // Report the public import of a private module.
+    if (ID->getASTContext().LangOpts.LibraryLevel == LibraryLevel::API) {
+      auto target = ID->getModule();
+      auto importer = ID->getModuleContext();
+      if (target &&
+          !ID->getAttrs().hasAttribute<ImplementationOnlyAttr>() &&
+          target->getLibraryLevel() == LibraryLevel::SPI) {
+
+        auto &diags = ID->getASTContext().Diags;
+        InFlightDiagnostic inFlight =
+            diags.diagnose(ID, diag::warn_public_import_of_private_module,
+                           target->getName(), importer->getName());
+        if (ID->getAttrs().isEmpty()) {
+           inFlight.fixItInsert(ID->getStartLoc(),
+                              "@_implementationOnly ");
+        }
+      }
+    }
   }
 
   void visitOperatorDecl(OperatorDecl *OD) {

test/Sema/Inputs/public-private-sdk/System/Library/Frameworks/PublicClang.framework/Headers/PublicClang.h

@@ -0,0 +1 @@
+void bar() {}

test/Sema/Inputs/public-private-sdk/System/Library/Frameworks/PublicClang.framework/Modules/module.modulemap

@@ -0,0 +1,4 @@
+framework module PublicClang {
+  umbrella header "PublicClang.h"
+  export *
+}

test/Sema/Inputs/public-private-sdk/System/Library/Frameworks/PublicClang.framework/Modules/module.private.modulemap

@@ -0,0 +1,4 @@
+framework module PublicClang_Private {
+  umbrella header "PublicClang_Private.h"
+  export *
+}

test/Sema/Inputs/public-private-sdk/System/Library/Frameworks/PublicClang.framework/PrivateHeaders/PublicClang_Private.h

@@ -0,0 +1 @@
+void bar() {}

test/Sema/Inputs/public-private-sdk/System/Library/Frameworks/PublicSwift.framework/Modules/PublicSwift.swiftmodule/x86_64-apple-macos.swiftinterface

@@ -0,0 +1,5 @@
+// swift-interface-format-version: 1.0
+// swift-module-flags: -module-name PublicSwift -enable-library-evolution
+import Swift
+
+public func foo() {}

test/Sema/Inputs/public-private-sdk/System/Library/PrivateFrameworks/FullyPrivateClang.framework/Headers/FullyPrivateClang.h

@@ -0,0 +1 @@
+void bar() {}

test/Sema/Inputs/public-private-sdk/System/Library/PrivateFrameworks/FullyPrivateClang.framework/Modules/module.modulemap

@@ -0,0 +1,6 @@
+framework module FullyPrivateClang {
+  umbrella header "FullyPrivateClang.h"
+
+  export *
+  module * { export * }
+}

test/Sema/Inputs/public-private-sdk/System/Library/PrivateFrameworks/PrivateSwift.framework/Modules/PrivateSwift.swiftmodule/x86_64-apple-macos.swiftinterface

@@ -0,0 +1,5 @@
+// swift-interface-format-version: 1.0
+// swift-module-flags: -module-name PrivateSwift
+import Swift
+
+public func foo() {}

test/Sema/implementation-only-import-suggestion.swift

@@ -0,0 +1,45 @@
+// RUN: %empty-directory(%t)
+// REQUIRES: VENDOR=apple
+
+/// Expect warnings when building a public client.
+// RUN: %target-swift-frontend -sdk %S/Inputs/public-private-sdk -typecheck -module-cache-path %t %s \
+// RUN:   -F %S/Inputs/public-private-sdk/System/Library/PrivateFrameworks/ \
+// RUN:   -library-level api -verify -D PUBLIC_IMPORTS
+
+/// Expect no warnings when building an SPI client.
+// RUN: %target-swift-frontend -sdk %S/Inputs/public-private-sdk -typecheck -module-cache-path %t %s \
+// RUN:   -F %S/Inputs/public-private-sdk/System/Library/PrivateFrameworks/ \
+// RUN:   -library-level spi -D PUBLIC_IMPORTS
+
+/// Expect no warnings when building a client with some other library level.
+// RUN: %target-swift-frontend -sdk %S/Inputs/public-private-sdk -typecheck -module-cache-path %t %s \
+// RUN:   -F %S/Inputs/public-private-sdk/System/Library/PrivateFrameworks/ \
+// RUN:   -D PUBLIC_IMPORTS
+// RUN: %target-swift-frontend -sdk %S/Inputs/public-private-sdk -typecheck -module-cache-path %t %s \
+// RUN:   -F %S/Inputs/public-private-sdk/System/Library/PrivateFrameworks/ \
+// RUN:   -library-level other -D PUBLIC_IMPORTS
+#if PUBLIC_IMPORTS
+import PublicSwift
+import PrivateSwift // expected-warning{{private module 'PrivateSwift' is imported publicly from the public module 'main'}}
+
+import PublicClang
+import PublicClang_Private // expected-warning{{private module 'PublicClang_Private' is imported publicly from the public module 'main'}}
+import FullyPrivateClang // expected-warning{{private module 'FullyPrivateClang' is imported publicly from the public module 'main'}}
+import main // expected-warning{{'implementation-only-import-suggestion.swift' is part of module 'main'; ignoring import}}
+
+/// Expect no warnings with implementation-only imports.
+// RUN: %target-swift-frontend -sdk %S/Inputs/public-private-sdk -typecheck -module-cache-path %t %s \
+// RUN:   -F %S/Inputs/public-private-sdk/System/Library/PrivateFrameworks/ \
+// RUN:   -library-level api -D IMPL_ONLY_IMPORTS
+#elseif IMPL_ONLY_IMPORTS
+
+@_implementationOnly import PrivateSwift
+@_implementationOnly import PublicClang_Private
+@_implementationOnly import FullyPrivateClang
+
+#endif
+
+/// Test error message on an unknown library level name.
+// RUN: not %target-swift-frontend -typecheck %s -library-level ThatsNotALibraryLevel 2>&1 \
+// RUN:   | %FileCheck %s --check-prefix CHECK-ARG
+// CHECK-ARG: error: unknown library level 'ThatsNotALibraryLevel', expected one of 'api', 'spi' or 'other'