Merge pull request swiftlang#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) {