[Sema] Report public imports of private modules

Intro the concept of library access or distribution level to identify
layers of libraries and report public imports of private libraries from
public ones.

rdar://62934005

Author: xymus

Diff for: 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))
 

Diff for: include/swift/AST/DiagnosticsSema.def

@@ -2834,6 +2834,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", ())

Diff for: 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) {

Diff for: 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 *,

Diff for: 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,

Diff for: 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 =

Diff for: 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">;

Diff for: lib/AST/Module.cpp

@@ -2246,6 +2246,49 @@ 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 path from System/Library/PrivateFrameworks/?
+  auto fromPrivateFrameworks = [&](StringRef path) -> bool {
+    auto sep = llvm::sys::path::get_separator();
+    auto privateFrameworksPath = llvm::Twine(ctx.SearchPathOpts.SDKPath) +
+      sep + "System" + sep + "Library" + sep + "PrivateFrameworks" + sep;
+    return hasPrefix(path, privateFrameworksPath.str());
+  };
+
+  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;

Diff for: 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,

Diff for: 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) {

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

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

Diff for: 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 *
+}

Diff for: 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 *
+}

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

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

Diff for: 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() {}

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

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

Diff for: 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 * }
+}

Diff for: 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() {}

Diff for: test/Sema/implementation-only-import-suggestion.swift

@@ -0,0 +1,44 @@
+// RUN: %empty-directory(%t)
+
+/// 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'