Make -import-underlying-module automatically export that module.

That's how everything behaved anyway. Might as well make it explicit and
stop special-casing it.

I've left in compatibility for modules built with older compilers so that
people using the OS toolchains aren't immediately unable to debug their apps.
As soon as we change the module format in a more significant way, I can take
this out.

Groundwork for rdar://problem/21254367; see next commit.

Swift SVN r29437

Author: jrose-apple

include/swift/Serialization/ModuleFile.h

@@ -85,7 +85,7 @@ class ModuleFile : public LazyMemberLoader {
     const StringRef RawPath;
 
   private:
-    const unsigned IsExported : 1;
+    unsigned IsExported : 1;
     const unsigned IsHeader : 1;
     const unsigned IsScoped : 1;
 
@@ -109,6 +109,8 @@ class ModuleFile : public LazyMemberLoader {
     bool isHeader() const { return IsHeader; }
     bool isScoped() const { return IsScoped; }
 
+    void forceExported() { IsExported = true; }
+
     std::string getPrettyPrintedPath() const;
   };
 
@@ -307,6 +309,8 @@ class ModuleFile : public LazyMemberLoader {
     /// Whether this module file comes from a framework.
     unsigned IsFramework : 1;
 
+    /// THIS SETTING IS OBSOLETE BUT IS STILL USED BY OLDER MODULES.
+    ///
     /// Whether this module has a shadowed module that's part of its public
     /// interface.
     unsigned HasUnderlyingModule : 1;

include/swift/Serialization/ModuleFormat.h

@@ -499,7 +499,7 @@ namespace input_block {
 
   using ModuleFlagsLayout = BCRecordLayout<
     MODULE_FLAGS,
-    BCFixed<1> // has underlying module?
+    BCFixed<1> // has underlying module? [[UNUSED]]
   >;
 
   using SearchPathLayout = BCRecordLayout<

include/swift/Serialization/SerializationOptions.h

@@ -35,7 +35,6 @@ namespace swift {
     ArrayRef<std::string> ExtraClangOptions;
 
     bool AutolinkForceLoad = false;
-    bool HasUnderlyingModule = false;
     bool SerializeAllSIL = false;
     bool SerializeOptionsForDebugging = false;
     bool IsSIB = false;

lib/Frontend/Frontend.cpp

@@ -298,7 +298,8 @@ void CompilerInstance::performSema() {
     SmallVector<ImportPair, 4> additionalImports;
 
     if (underlying)
-      additionalImports.push_back({ { /*accessPath=*/{}, underlying }, {} });
+      additionalImports.push_back({ { /*accessPath=*/{}, underlying },
+                                    SourceFile::ImportFlags::Exported });
     if (importedHeaderModule)
       additionalImports.push_back({ { /*accessPath=*/{}, importedHeaderModule },
                                     SourceFile::ImportFlags::Exported });

lib/Serialization/ModuleFile.cpp

@@ -1067,6 +1067,11 @@ Status ModuleFile::associateWithFileContext(FileUnit *file,
       continue;
     }
 
+    // This is for backwards-compatibility with modules that still rely on the
+    // "HasUnderlyingModule" flag.
+    if (Bits.HasUnderlyingModule && module == ShadowedModule)
+      dependency.forceExported();
+
     if (scopePath.empty()) {
       dependency.Import = { {}, module };
     } else {
@@ -1082,9 +1087,6 @@ Status ModuleFile::associateWithFileContext(FileUnit *file,
     return error(Status::MissingDependency);
   }
 
-  if (Bits.HasUnderlyingModule)
-    (void)getModule(FileContext->getParentModule()->getName());
-
   if (Bits.HasEntryPoint) {
     FileContext->getParentModule()->registerEntryPointFile(FileContext,
                                                            SourceLoc(),
@@ -1171,24 +1173,14 @@ void ModuleFile::getImportedModules(
     SmallVectorImpl<Module::ImportedModule> &results,
     Module::ImportFilter filter) {
   PrettyModuleFileDeserialization stackEntry(*this);
-  bool includeShadowedModule = (filter != Module::ImportFilter::Private &&
-                                ShadowedModule && Bits.HasUnderlyingModule);
 
   for (auto &dep : Dependencies) {
     if (filter != Module::ImportFilter::All &&
         (filter == Module::ImportFilter::Public) ^ dep.isExported())
       continue;
     assert(dep.isLoaded());
     results.push_back(dep.Import);
-
-    // FIXME: Do we want a way to limit re-exports?
-    if (includeShadowedModule && dep.Import.first.empty() &&
-        dep.Import.second == ShadowedModule)
-      includeShadowedModule = false;
   }
-
-  if (includeShadowedModule)
-    results.push_back({ {}, ShadowedModule });
 }
 
 void ModuleFile::getImportDecls(SmallVectorImpl<Decl *> &Results) {

lib/Serialization/Serialization.cpp

@@ -724,8 +724,6 @@ void Serializer::writeInputBlock(const SerializationOptions &options) {
     LinkLibrary.emit(ScratchRecord, serialization::LibraryKind::Library,
                      options.AutolinkForceLoad, options.ModuleLinkName);
   }
-
-  ModuleFlags.emit(ScratchRecord, options.HasUnderlyingModule);
 }
 
 /// Translate AST default argument kind to the Serialization enum values, which

tools/driver/frontend_main.cpp

@@ -700,7 +700,6 @@ static bool performCompile(CompilerInstance &Instance,
           Invocation.getClangImporterOptions().ExtraArgs;
       if (!IRGenOpts.ForceLoadSymbolName.empty())
         serializationOpts.AutolinkForceLoad = true;
-      serializationOpts.HasUnderlyingModule = opts.ImportUnderlyingModule;
 
       // Options contain information about the developer's computer,
       // so only serialize them if the module isn't going to be shipped to