---

yaml
---
r: 347603
b: refs/heads/master
c: fa64e92
h: refs/heads/master
i:
  347601: 55a926f
  347599: 7e7bc85

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 0721847584bca9a91275a79b2ac7b77ce2c84ac4
+refs/heads/master: fa64e920720990b20dabd8125081e4f989f190ba
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/include/swift/AST/Module.h

@@ -843,6 +843,10 @@ class FileUnit : public DeclContext {
     return getParentModule()->getName().str();
   }
 
+  /// If this is a module imported from a parseable interface, return the path
+  /// to the interface file, otherwise an empty StringRef.
+  virtual StringRef getParseableInterface() const { return {}; }
+
   /// Traverse the decls within this file.
   ///
   /// \returns true if traversal was aborted, false if it completed

trunk/include/swift/Serialization/ModuleFormat.h

@@ -643,7 +643,8 @@ namespace input_block {
     IMPORTED_HEADER_CONTENTS,
     MODULE_FLAGS, // [unused]
     SEARCH_PATH,
-    FILE_DEPENDENCY
+    FILE_DEPENDENCY,
+    PARSEABLE_INTERFACE_PATH
   };
 
   using ImportedModuleLayout = BCRecordLayout<
@@ -690,6 +691,12 @@ namespace input_block {
     BCFixed<1>,                    // SDK-relative?
     BCBlob                         // path
   >;
+
+  using ParseableInterfaceLayout = BCRecordLayout<
+    PARSEABLE_INTERFACE_PATH,
+    BCBlob // file path
+  >;
+
 }
 
 /// The record types within the "decls-and-types" block.

trunk/include/swift/Serialization/SerializationOptions.h

@@ -33,6 +33,7 @@ namespace swift {
     StringRef GroupInfoPath;
     StringRef ImportedHeader;
     StringRef ModuleLinkName;
+    StringRef ParseableInterface;
     ArrayRef<std::string> ExtraClangOptions;
 
     /// Describes a single-file dependency for this module, along with the

trunk/include/swift/Serialization/SerializedModuleLoader.h

@@ -198,6 +198,11 @@ class SerializedASTFile final : public LoadedFile {
   friend class ModuleFile;
 
   ModuleFile &File;
+
+  /// The parseable interface this module was generated from if any.
+  /// Used for debug info.
+  std::string ParseableInterface;
+
   bool IsSIB;
 
   ~SerializedASTFile() = default;
@@ -294,6 +299,13 @@ class SerializedASTFile final : public LoadedFile {
 
   virtual const clang::Module *getUnderlyingClangModule() const override;
 
+  /// If this is a module imported from a parseable interface, return the path
+  /// to the interface file, otherwise an empty StringRef.
+  virtual StringRef getParseableInterface() const override {
+    return ParseableInterface;
+  }
+  void setParseableInterface(StringRef PI) { ParseableInterface = PI; }
+  
   virtual bool getAllGenericSignatures(
                    SmallVectorImpl<GenericSignature*> &genericSignatures)
                 override;

trunk/include/swift/Serialization/Validation.h

@@ -92,6 +92,7 @@ struct ValidationInfo {
 class ExtendedValidationInfo {
   SmallVector<StringRef, 4> ExtraClangImporterOpts;
   StringRef SDKPath;
+  StringRef ParseableInterface;
   struct {
     unsigned ArePrivateImportsEnabled : 1;
     unsigned IsSIB : 1;
@@ -113,6 +114,8 @@ class ExtendedValidationInfo {
   void addExtraClangImporterOption(StringRef option) {
     ExtraClangImporterOpts.push_back(option);
   }
+  StringRef getParseableInterface() const { return ParseableInterface; }
+  void setParseableInterface(StringRef PI) { ParseableInterface = PI; }
 
   bool isSIB() const { return Bits.IsSIB; }
   void setIsSIB(bool val) {

trunk/lib/AST/Module.cpp

@@ -1157,6 +1157,10 @@ StringRef ModuleDecl::getModuleFilename() const {
   // per-file names. Modules can consist of more than one file.
   StringRef Result;
   for (auto F : getFiles()) {
+    Result = F->getParseableInterface();
+    if (!Result.empty())
+      return Result;
+
     if (auto SF = dyn_cast<SourceFile>(F)) {
       if (!Result.empty())
         return StringRef();

trunk/lib/Frontend/Frontend.cpp

@@ -124,9 +124,8 @@ CompilerInvocation::getParseableInterfaceOutputPathForWholeModule() const {
       .SupplementaryOutputs.ParseableInterfaceOutputPath;
 }
 
-SerializationOptions
-CompilerInvocation::computeSerializationOptions(const SupplementaryOutputPaths &outs,
-                                                bool moduleIsPublic) {
+SerializationOptions CompilerInvocation::computeSerializationOptions(
+    const SupplementaryOutputPaths &outs, bool moduleIsPublic) {
   const FrontendOptions &opts = getFrontendOptions();
 
   SerializationOptions serializationOpts;

trunk/lib/Frontend/ParseableInterfaceModuleLoader.cpp

@@ -582,6 +582,12 @@ class swift::ParseableInterfaceBuilder {
       std::string OutPathStr = OutPath;
       SerializationOpts.OutputPath = OutPathStr.c_str();
       SerializationOpts.ModuleLinkName = FEOpts.ModuleLinkName;
+
+      // Record any non-SDK parseable interface files for the debug info.
+      StringRef SDKPath = SubInstance.getASTContext().SearchPathOpts.SDKPath;
+      if (!getRelativeDepPath(InPath, SDKPath))
+        SerializationOpts.ParseableInterface = InPath;
+
       SmallVector<FileDependency, 16> Deps;
       if (collectDepsForSerialization(SubInstance, Deps,
             FEOpts.SerializeModuleInterfaceDependencyHashes)) {

trunk/lib/IRGen/IRGenDebugInfo.cpp

@@ -191,14 +191,13 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
 
 private:
   static StringRef getFilenameFromDC(const DeclContext *DC) {
-    if (auto LF = dyn_cast<LoadedFile>(DC))
+    if (auto *LF = dyn_cast<LoadedFile>(DC))
       return LF->getFilename();
-    if (auto SF = dyn_cast<SourceFile>(DC))
+    if (auto *SF = dyn_cast<SourceFile>(DC))
       return SF->getFilename();
-    else if (auto M = dyn_cast<ModuleDecl>(DC))
+    if (auto *M = dyn_cast<ModuleDecl>(DC))
       return M->getModuleFilename();
-    else
-      return StringRef();
+    return {};
   }
 
   using DebugLoc = SILLocation::DebugLoc;
@@ -717,7 +716,6 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
     ModuleDecl *M = IM.second;
     if (Optional<ASTSourceDescriptor> ModuleDesc = getClangModule(*M))
       return getOrCreateModule(*ModuleDesc, ModuleDesc->getModuleOrNull());
-
     StringRef Path = getFilenameFromDC(M);
     StringRef Name = M->getName().str();
     return getOrCreateModule(M, TheCU, Name, Path);

trunk/lib/Serialization/ModuleFile.cpp

@@ -1335,6 +1335,11 @@ ModuleFile::ModuleFile(
           SearchPaths.push_back({blobData, isFramework, isSystem});
           break;
         }
+        case input_block::PARSEABLE_INTERFACE_PATH: {
+          if (extInfo)
+            extInfo->setParseableInterface(blobData);
+          break;
+        }
         default:
           // Unknown input kind, possibly for use by a future version of the
           // module format.

trunk/lib/Serialization/Serialization.cpp

@@ -834,6 +834,7 @@ void Serializer::writeBlockInfoBlock() {
   BLOCK_RECORD(input_block, MODULE_FLAGS);
   BLOCK_RECORD(input_block, SEARCH_PATH);
   BLOCK_RECORD(input_block, FILE_DEPENDENCY);
+  BLOCK_RECORD(input_block, PARSEABLE_INTERFACE_PATH);
 
   BLOCK(DECLS_AND_TYPES_BLOCK);
 #define RECORD(X) BLOCK_RECORD(decls_block, X);
@@ -1060,6 +1061,7 @@ void Serializer::writeInputBlock(const SerializationOptions &options) {
   input_block::ImportedHeaderContentsLayout ImportedHeaderContents(Out);
   input_block::SearchPathLayout SearchPath(Out);
   input_block::FileDependencyLayout FileDependency(Out);
+  input_block::ParseableInterfaceLayout ParseableInterface(Out);
 
   if (options.SerializeOptionsForDebugging) {
     const SearchPathOptions &searchPathOpts = M->getASTContext().SearchPathOpts;
@@ -1081,6 +1083,9 @@ void Serializer::writeInputBlock(const SerializationOptions &options) {
                         dep.getPath());
   }
 
+  if (!options.ParseableInterface.empty())
+    ParseableInterface.emit(ScratchRecord, options.ParseableInterface);
+
   ModuleDecl::ImportFilter allImportFilter;
   allImportFilter |= ModuleDecl::ImportFilterKind::Public;
   allImportFilter |= ModuleDecl::ImportFilterKind::Private;

trunk/lib/Serialization/SerializedModuleLoader.cpp

@@ -400,6 +400,7 @@ FileUnit *SerializedModuleLoaderBase::loadAST(
     // We've loaded the file. Now try to bring it into the AST.
     auto fileUnit = new (Ctx) SerializedASTFile(M, *loadedModuleFile,
                                                 extendedInfo.isSIB());
+    fileUnit->setParseableInterface(extendedInfo.getParseableInterface());
     M.addFile(*fileUnit);
     if (extendedInfo.isTestable())
       M.setTestingEnabled();

trunk/test/DebugInfo/ParseableInterfaceImports.swift

@@ -0,0 +1,22 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend-typecheck %S/basic.swift \
+// RUN:    -emit-parseable-module-interface-path %t/basic.swiftinterface
+// RUN: %target-swift-frontend -emit-ir -module-name Foo %s -I %t -g -o - \
+// RUN:    | %FileCheck %s
+// RUN: %target-swift-frontend -emit-ir -module-name Foo %s -I %t -g -o - \
+// RUN:    -sdk %t | %FileCheck %s --check-prefix=SDK
+
+import basic
+
+// CHECK: !DIModule(scope: null, name: "basic", includePath: "
+// CHECK-SAME:      basic.swiftinterface"
+
+// We don;t record any parseable interfaces from the SDK.
+// They're in the SDK after all.
+// SDK:   !DIModule(scope: null, name: "basic", includePath: "
+// SDK-SAME:        basic{{.*}}.swiftmodule"
+
+
+func markUsed<T>(_ t: T) {}
+markUsed(basic.foo(1, 2))
+

trunk/validation-test/ParseableInterface/verify_stdlib.swift

@@ -0,0 +1,7 @@
+// Note that this test should still "pass" when Swift.swiftinterface has not
+// been generated.
+
+// RUN: %empty-directory(%t)
+// RUN: not ls %platform-module-dir/Swift.swiftmodule/%target-cpu.swiftinterface || %target-swift-frontend -build-module-from-parseable-interface %platform-module-dir/Swift.swiftmodule/%target-cpu.swiftinterface -parse-stdlib -o %t/Swift.swiftmodule
+
+// REQUIRES: nonexecutable_test