Merge pull request #11955 from DougGregor/rexported-module-cleanup

Minor cleanups for the work to handle re-exported modules

Author: DougGregor

include/swift/ClangImporter/ClangImporter.h

@@ -323,8 +323,8 @@ ImportDecl *createImportDecl(ASTContext &Ctx, DeclContext *DC, ClangNode ClangN,
 ///
 /// This routine is used for various hacks that are only permitted within
 /// overlays of imported modules, e.g., Objective-C bridging conformances.
-bool isInOverlayModuleForImportedModule(DeclContext *overlayDC,
-                                        DeclContext *importedDC);
+bool isInOverlayModuleForImportedModule(const DeclContext *overlayDC,
+                                        const DeclContext *importedDC);
 
 } // end namespace swift
 

include/swift/ClangImporter/ClangModule.h

@@ -56,6 +56,11 @@ class ClangModuleUnit final : public LoadedFile {
   /// Returns the Swift module that overlays this Clang module.
   ModuleDecl *getAdapterModule() const;
 
+  /// Retrieve the "exported" name of the module, which is usually the module
+  /// name, but might be the name of the public module through which this
+  /// (private) module is re-exported.
+  std::string getExportedModuleName() const;
+
   virtual bool isSystemModule() const override;
 
   virtual void lookupValue(ModuleDecl::AccessPathTy accessPath,

lib/ClangImporter/ClangImporter.cpp

@@ -2861,6 +2861,13 @@ clang::ASTContext &ClangModuleUnit::getClangASTContext() const {
   return owner.getClangASTContext();
 }
 
+std::string ClangModuleUnit::getExportedModuleName() const {
+  if (clangModule && !clangModule->ExportAsModule.empty())
+    return clangModule->ExportAsModule;
+
+  return getParentModule()->getName().str();
+}
+
 ModuleDecl *ClangModuleUnit::getAdapterModule() const {
   if (!clangModule)
     return nullptr;
@@ -3325,8 +3332,8 @@ importName(const clang::NamedDecl *D,
     getDeclName();
 }
 
-bool swift::isInOverlayModuleForImportedModule(DeclContext *overlayDC,
-                                               DeclContext *importedDC) {
+bool swift::isInOverlayModuleForImportedModule(const DeclContext *overlayDC,
+                                               const DeclContext *importedDC) {
   overlayDC = overlayDC->getModuleScopeContext();
   importedDC = importedDC->getModuleScopeContext();
 

lib/Serialization/Deserialization.cpp

@@ -24,6 +24,7 @@
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/ClangImporter/ClangImporter.h"
+#include "swift/ClangImporter/ClangModule.h"
 #include "swift/Serialization/BCReadingExtras.h"
 #include "swift/Serialization/SerializedModuleLoader.h"
 #include "swift/Basic/Defer.h"
@@ -1098,6 +1099,23 @@ getActualCtorInitializerKind(uint8_t raw) {
   return None;
 }
 
+/// Determine whether the two modules are re-exported to the same module.
+static bool reExportedToSameModule(const ModuleDecl *fromModule,
+                                   const ModuleDecl *toModule) {
+  auto fromClangModule
+    = dyn_cast<ClangModuleUnit>(fromModule->getFiles().front());
+  if (!fromClangModule)
+    return false;
+
+  auto toClangModule
+  = dyn_cast<ClangModuleUnit>(toModule->getFiles().front());
+  if (!toClangModule)
+    return false;
+
+  return fromClangModule->getExportedModuleName() ==
+    toClangModule->getExportedModuleName();
+}
+
 /// Remove values from \p values that don't match the expected type or module.
 ///
 /// Any of \p expectedTy, \p expectedModule, or \p expectedGenericSig can be
@@ -1130,7 +1148,8 @@ static void filterValues(Type expectedTy, ModuleDecl *expectedModule,
     // FIXME: Should be able to move a value from an extension in a derived
     // module to the original definition in a base module.
     if (expectedModule && !value->hasClangNode() &&
-        value->getModuleContext() != expectedModule)
+        value->getModuleContext() != expectedModule &&
+        !reExportedToSameModule(value->getModuleContext(), expectedModule))
       return true;
 
     // If we're expecting a member within a constrained extension with a

lib/Serialization/ModuleFile.cpp

@@ -21,9 +21,9 @@
 #include "swift/AST/USRGeneration.h"
 #include "swift/Basic/Range.h"
 #include "swift/ClangImporter/ClangImporter.h"
+#include "swift/ClangImporter/ClangModule.h"
 #include "swift/Serialization/BCReadingExtras.h"
 #include "swift/Serialization/SerializedModuleLoader.h"
-#include "clang/Basic/Module.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/OnDiskHashTable.h"
@@ -1562,18 +1562,20 @@ void ModuleFile::loadExtensions(NominalTypeDecl *nominal) {
   }
 
   if (nominal->getParent()->isModuleScopeContext()) {
-    Identifier moduleName = nominal->getParentModule()->getName();
+    auto parentModule = nominal->getParentModule();
+    StringRef moduleName = parentModule->getName().str();
 
     // If the originating module is a private module whose interface is
     // re-exported via public module, check the name of the public module.
-    if (auto clangModule
-          = nominal->getParentModule()->findUnderlyingClangModule()) {
-      if (!clangModule->ExportAsModule.empty())
-        moduleName = getContext().getIdentifier(clangModule->ExportAsModule);
+    std::string exportedModuleName;
+    if (auto clangModuleUnit =
+            dyn_cast<ClangModuleUnit>(parentModule->getFiles().front())) {
+      exportedModuleName = clangModuleUnit->getExportedModuleName();
+      moduleName = exportedModuleName;
     }
 
     for (auto item : *iter) {
-      if (item.first != moduleName.str())
+      if (item.first != moduleName)
         continue;
       Expected<Decl *> declOrError = getDeclChecked(item.second);
       if (!declOrError) {

lib/Serialization/Serialization.cpp

@@ -37,7 +37,6 @@
 #include "swift/ClangImporter/ClangModule.h"
 #include "swift/Serialization/SerializationOptions.h"
 
-#include "clang/Basic/Module.h"
 // FIXME: We're just using CompilerInstance::createOutputFile.
 // This API should be sunk down to LLVM.
 #include "clang/Frontend/CompilerInstance.h"
@@ -533,13 +532,14 @@ IdentifierID Serializer::addModuleRef(const ModuleDecl *M) {
 
   // If we're referring to a member of a private module that will be
   // re-exported via a public module, record the public module's name.
-  if (auto clangModule = M->findUnderlyingClangModule()) {
-    if (!clangModule->ExportAsModule.empty()) {
-      auto publicModuleName =
-        M->getASTContext().getIdentifier(clangModule->ExportAsModule);
-      return addDeclBaseNameRef(publicModuleName);
-    }
+  if (auto clangModuleUnit =
+        dyn_cast<ClangModuleUnit>(M->getFiles().front())) {
+    auto exportedModuleName =
+        M->getASTContext().getIdentifier(
+                                 clangModuleUnit->getExportedModuleName());
+    return addDeclBaseNameRef(exportedModuleName);
   }
+
   assert(!M->getName().empty());
   return addDeclBaseNameRef(M->getName());
 }

test/ClangImporter/Inputs/privateframeworks/overlay/SomeKit.swift

@@ -1,9 +1,49 @@
 @_exported import SomeKit
+import Foundation
 
 extension SKWidget {
   public func extensionMethod() -> ExtensionType { return ExtensionType() }
 
   public struct ExtensionType { }
 }
 
+extension SKWidget.ExtensionType {
+  public func foo() { }
+}
+
+extension NSObject {
+  public func doSomethingElse(_: SKWidget) { }
+}
 
+extension SKWidget.Error {
+  public func getCode(from widget: SKWidget) -> SKWidget.Error.Code {
+    return widget.getCurrentError()
+  }
+}
+
+extension SKWidget.Error.Code {
+  public var isBoom: Bool {
+    return self == .boom
+  }
+}
+
+public protocol HasAnObject {
+  var anObject: NSObject { get set }
+}
+
+extension SKWidget : HasAnObject { }
+
+@inline(__always)
+public func inlineWidgetOperations(_ widget: SKWidget) {
+  widget.extensionMethod().foo()
+  widget.someObjCMethod()
+  widget.someObjCExtensionMethod()
+  widget.doSomething(with: widget)
+  widget.doSomethingElse(widget)
+  let obj = widget.anObject
+  widget.anObject = obj
+  _ = SKWidget.Error(.boom).getCode(from: widget).isBoom
+  var hao: HasAnObject = widget
+  someKitGlobalFunc()
+  hao.anObject = widget
+}

test/ClangImporter/Inputs/privateframeworks/withoutprivate/SomeKit.framework/Headers/SKWidget.h

@@ -1,4 +1,26 @@
 @import ObjectiveC;
 
 @interface SKWidget : NSObject
+- (void)someObjCMethod;
 @end
+
+@interface SKWidget(ObjCAPI)
+- (void)someObjCExtensionMethod;
+@property (readwrite,strong,nonnull) NSObject *anObject;
+@end
+
+@interface NSObject (SKWidget)
+- (void)doSomethingWithWidget:(nonnull SKWidget *)widget;
+@end
+
+extern NSString * _Nonnull const SKWidgetErrorDomain;
+typedef enum __attribute__((ns_error_domain(SKWidgetErrorDomain))) __attribute__((swift_name("SKWidget.Error"))) SKWidgetErrorCode : NSInteger {
+  SKWidgetErrorNone = 0,
+  SKWidgetErrorBoom = 1
+} SKWidgetErrorCode;
+
+@interface SKWidget(Erroneous)
+- (SKWidgetErrorCode)getCurrentError;
+@end
+
+extern void someKitGlobalFunc(void);

test/ClangImporter/Inputs/privateframeworks/withprivate/SomeKitCore.framework/Headers/SKWidget.h

@@ -1,4 +1,27 @@
 @import ObjectiveC;
+@import Foundation;
 
 @interface SKWidget : NSObject
+- (void)someObjCMethod;
 @end
+
+@interface SKWidget(ObjCAPI)
+- (void)someObjCExtensionMethod;
+@property (readwrite,strong,nonnull) NSObject *anObject;
+@end
+
+@interface NSObject (SKWidget)
+- (void)doSomethingWithWidget:(nonnull SKWidget *)widget;
+@end
+
+extern NSString * _Nonnull const SKWidgetErrorDomain;
+typedef enum __attribute__((ns_error_domain(SKWidgetErrorDomain))) __attribute__((swift_name("SKWidget.Error"))) SKWidgetErrorCode : NSInteger {
+  SKWidgetErrorNone = 0,
+  SKWidgetErrorBoom = 1
+} SKWidgetErrorCode;
+
+@interface SKWidget(Erroneous)
+- (SKWidgetErrorCode)getCurrentError;
+@end
+
+extern void someKitGlobalFunc(void);

test/ClangImporter/private_frameworks.swift

@@ -1,20 +1,46 @@
 // RUN: rm -rf %t
 // RUN: mkdir -p %t
 
+// FIXME: BEGIN -enable-source-import hackaround
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource) -emit-module -o %t %clang-importer-sdk-path/swift-modules/CoreGraphics.swift
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -emit-module -o %t %clang-importer-sdk-path/swift-modules/Foundation.swift
+// FIXME: END -enable-source-import hackaround
+
 // Build the overlay with private frameworks.
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-module -F %S/Inputs/privateframeworks/withprivate -o %t %S/Inputs/privateframeworks/overlay/SomeKit.swift
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -emit-module -F %S/Inputs/privateframeworks/withprivate -o %t %S/Inputs/privateframeworks/overlay/SomeKit.swift
+
+// Use the overlay with private frameworks.
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -emit-sil -o /dev/null -F %S/Inputs/privateframeworks/withprivate %s -verify
+
+// Use the overlay without private frameworks.
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -emit-sil -o /dev/null -F %S/Inputs/privateframeworks/withoutprivate -I %t %s
+
+// Build the overlay with public frameworks.
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -emit-module -F %S/Inputs/privateframeworks/withoutprivate -o %t %S/Inputs/privateframeworks/overlay/SomeKit.swift
 
 // Use the overlay with private frameworks.
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -F %S/Inputs/privateframeworks/withprivate -I %t %s -verify
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -emit-sil -o /dev/null -F %S/Inputs/privateframeworks/withprivate %s -verify
 
 // Use the overlay without private frameworks.
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -F %S/Inputs/privateframeworks/withoutprivate -I %t %s -verify
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -emit-sil -o /dev/null -F %S/Inputs/privateframeworks/withoutprivate -I %t %s
 
 // REQUIRES: objc_interop
 
 import SomeKit
 
 func testWidget(widget: SKWidget) {
-  _ = widget.extensionMethod()
+  _ = widget.someObjCMethod()
+  _ = widget.someObjCExtensionMethod()
+
+  let ext = widget.extensionMethod()
+  ext.foo()
+
+  widget.doSomethingElse(widget)
+  inlineWidgetOperations(widget)
+}
+
+func testError(widget: SKWidget) {
+  let c: SKWidget.Error.Code = SKWidget.Error(.boom).getCode(from: widget)
+  if c.isBoom { }
 }