[Serialization] Add -swift-compiler-version option to swiftmodules

Author: xedin

Diff for: include/swift/AST/FileUnit.h

@@ -345,6 +345,11 @@ class FileUnit : public DeclContext, public ASTAllocated<FileUnit> {
     return {};
   }
 
+  /// Returns the version of the Swift compiler used to create this module.
+  virtual llvm::VersionTuple getSwiftCompilerVersion() const {
+    return {};
+  }
+
   SWIFT_DEBUG_DUMPER(dumpDisplayDecls());
   SWIFT_DEBUG_DUMPER(dumpTopLevelDecls());
 

Diff for: include/swift/Serialization/SerializedModuleLoader.h

@@ -539,6 +539,8 @@ class SerializedASTFile final : public LoadedFile {
 
   virtual StringRef getPublicModuleName() const override;
 
+  virtual llvm::VersionTuple getSwiftCompilerVersion() const override;
+
   ValueDecl *getMainDecl() const override;
 
   bool hasEntryPoint() const override;

Diff for: include/swift/Serialization/Validation.h

@@ -131,6 +131,7 @@ class ExtendedValidationInfo {
   StringRef ExportAsName;
   StringRef PublicModuleName;
   CXXStdlibKind CXXStdlib;
+  llvm::VersionTuple SwiftCompilerVersion;
   struct {
     unsigned ArePrivateImportsEnabled : 1;
     unsigned IsSIB : 1;
@@ -250,6 +251,16 @@ class ExtendedValidationInfo {
 
   CXXStdlibKind getCXXStdlibKind() const { return CXXStdlib; }
   void setCXXStdlibKind(CXXStdlibKind kind) { CXXStdlib = kind; }
+
+  llvm::VersionTuple getSwiftCompilerVersion() const {
+    return SwiftCompilerVersion;
+  }
+  void setSwiftCompilerVersion(StringRef version) {
+    llvm::VersionTuple compilerVersion;
+    if (compilerVersion.tryParse(version))
+      return;
+    SwiftCompilerVersion = compilerVersion;
+  }
 };
 
 struct SearchPath {

Diff for: lib/Serialization/ModuleFile.cpp

@@ -1409,3 +1409,7 @@ StringRef SerializedASTFile::getExportedModuleName() const {
 StringRef SerializedASTFile::getPublicModuleName() const {
   return File.getPublicModuleName();
 }
+
+llvm::VersionTuple SerializedASTFile::getSwiftCompilerVersion() const {
+  return File.getSwiftCompilerVersion();
+}

Diff for: lib/Serialization/ModuleFile.h

@@ -603,6 +603,10 @@ class ModuleFile
     return Core->UserModuleVersion;
   }
 
+  llvm::VersionTuple getSwiftCompilerVersion() const {
+    return Core->SwiftCompilerVersion;
+  }
+
   ArrayRef<StringRef> getAllowableClientNames() const {
     return Core->AllowableClientNames;
   }

Diff for: lib/Serialization/ModuleFileSharedCore.cpp

@@ -214,6 +214,9 @@ static bool readOptionsBlock(llvm::BitstreamCursor &cursor,
     case options_block::PUBLIC_MODULE_NAME:
       extendedInfo.setPublicModuleName(blobData);
       break;
+    case options_block::SWIFT_COMPILER_VERSION:
+      extendedInfo.setSwiftCompilerVersion(blobData);
+      break;
     default:
       // Unknown options record, possibly for use by a future version of the
       // module format.
@@ -1496,6 +1499,7 @@ ModuleFileSharedCore::ModuleFileSharedCore(
       ModulePackageName = extInfo.getModulePackageName();
       ModuleExportAsName = extInfo.getExportAsName();
       PublicModuleName = extInfo.getPublicModuleName();
+      SwiftCompilerVersion = extInfo.getSwiftCompilerVersion();
 
       hasValidControlBlock = true;
       break;

Diff for: lib/Serialization/ModuleFileSharedCore.h

@@ -103,6 +103,12 @@ class ModuleFileSharedCore {
   /// Name to use in public facing diagnostics and documentation.
   StringRef PublicModuleName;
 
+  /// The version of the Swift compiler used to produce swiftinterface
+  /// this module is based on or build the module itself. This is
+  /// the most precise version possible - a compiler tag or version
+  /// if this is a development compiler.
+  llvm::VersionTuple SwiftCompilerVersion;
+
   /// \c true if this module has incremental dependency information.
   bool HasIncrementalInfo = false;
 

Diff for: lib/Serialization/ModuleFormat.h

@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 897; // Builtin.FixedArray
+const uint16_t SWIFTMODULE_VERSION_MINOR = 898; // swift-compiler-version
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -966,6 +966,7 @@ namespace options_block {
     SERIALIZE_PACKAGE_ENABLED,
     CXX_STDLIB_KIND,
     PUBLIC_MODULE_NAME,
+    SWIFT_COMPILER_VERSION,
   };
 
   using SDKPathLayout = BCRecordLayout<
@@ -1066,6 +1067,11 @@ namespace options_block {
     PUBLIC_MODULE_NAME,
     BCBlob
   >;
+
+    using SwiftCompilerVersionLayout = BCRecordLayout<
+    SWIFT_COMPILER_VERSION,
+    BCBlob // version tuple
+  >;
 }
 
 /// The record types within the input block.

Diff for: lib/Serialization/Serialization.cpp

@@ -864,6 +864,7 @@ void Serializer::writeBlockInfoBlock() {
   BLOCK_RECORD(options_block, SERIALIZE_PACKAGE_ENABLED);
   BLOCK_RECORD(options_block, CXX_STDLIB_KIND);
   BLOCK_RECORD(options_block, PUBLIC_MODULE_NAME);
+  BLOCK_RECORD(options_block, SWIFT_COMPILER_VERSION);
 
   BLOCK(INPUT_BLOCK);
   BLOCK_RECORD(input_block, IMPORTED_MODULE);
@@ -1139,6 +1140,10 @@ void Serializer::writeHeader() {
         PublicModuleName.emit(ScratchRecord, publicModuleName.str());
       }
 
+      llvm::VersionTuple compilerVersion = M->getSwiftCompilerVersion();
+      options_block::SwiftCompilerVersionLayout SwiftCompilerVersion(Out);
+      SwiftCompilerVersion.emit(ScratchRecord, compilerVersion.getAsString());
+
       if (M->isConcurrencyChecked()) {
         options_block::IsConcurrencyCheckedLayout IsConcurrencyChecked(Out);
         IsConcurrencyChecked.emit(ScratchRecord);

Diff for: lib/Serialization/SerializedModuleLoader.cpp

@@ -1035,6 +1035,7 @@ LoadedFile *SerializedModuleLoaderBase::loadAST(
       M.setPackageName(Ctx.getIdentifier(loadedModuleFile->getModulePackageName()));
     }
     M.setUserModuleVersion(loadedModuleFile->getUserModuleVersion());
+    M.setSwiftCompilerVersion(loadedModuleFile->getSwiftCompilerVersion());
     for (auto name: loadedModuleFile->getAllowableClientNames()) {
       M.addAllowableClientName(Ctx.getIdentifier(name));
     }

Diff for: test/CAS/embedded-Xcc.swift

@@ -20,10 +20,10 @@
 
 // RUN: llvm-bcanalyzer --dump %t/Test.swiftmodule | %FileCheck %s
 
-// CHECK: <XCC abbrevid=6/> blob data = '-cc1'
-// CHECK: <XCC abbrevid=6/> blob data = '-D'
-// CHECK: <XCC abbrevid=6/> blob data = 'TEST=1'
-// CHECK-NOT: <XCC abbrevid=6/> blob data = '--target=
+// CHECK: <XCC abbrevid=7/> blob data = '-cc1'
+// CHECK: <XCC abbrevid=7/> blob data = '-D'
+// CHECK: <XCC abbrevid=7/> blob data = 'TEST=1'
+// CHECK-NOT: <XCC abbrevid=7/> blob data = '--target=
 
 //--- main.swift
 public func test() {}

Diff for: test/ModuleInterface/swift-compiler-version-option.swift

@@ -0,0 +1,25 @@
+// RUN: %empty-directory(%t)
+
+/// Build the libraries.
+// RUN: %target-swift-frontend %s \
+// RUN:   -emit-module-path %t/Lib.swiftmodule \
+// RUN:   -emit-module-interface-path %t/Lib.swiftinterface \
+// RUN:   -enable-library-evolution -swift-version 6 \
+// RUN:   -swift-compiler-version 6.0.0.1
+
+// RUN: %target-swift-typecheck-module-from-interface(%t/Lib.swiftinterface)
+
+/// Check option in swiftinterface
+// RUN: cat %t/Lib.swiftinterface | %FileCheck --check-prefix=CHECK-OPTION %s
+// CHECK-OPTION: swift-module-flags:
+// CHECK-SAME-OPTION: -swift-compiler-version 6.0.0.1
+
+/// Check option in swiftmodule
+// RUN: llvm-bcanalyzer --dump %t/Lib.swiftmodule | %FileCheck --check-prefix=CHECK-MODULE-OPTION %s
+// CHECK-MODULE-OPTION: <OPTIONS_BLOCK
+// CHECK-MODULE-OPTION: <SWIFT_COMPILER_VERSION abbrevid={{.*}}/> blob data = '6.0.0.1'
+// CHECK-MODULE-OPTION: </OPTIONS_BLOCK>
+
+public struct S {
+    public var test: Int = 42
+}