[serialization] Diagnose loading modules from older Swifts.

...with a better message than the generic "older version of the
compiler" one, when we know it's actually a different version of
Swift proper.

This still uses the same internal module version numbers to check
if the module is compatible; the presentation of language versions
is a diagnostic thing only.

Speaking of module version numbers, this deliberately does NOT
increment VERSION_MINOR; it's implemented in a backwards-compatible
way.

This will only work going forwards, of course; all existing modules
don't have a short version string, and I don't feel comfortable
assuming all older modules we might encounter are "Swift 2.2".

rdar://problem/25680392

Author: jrose-apple

include/swift/AST/DiagnosticsSema.def

@@ -429,6 +429,9 @@ ERROR(serialization_malformed_module,Fatal,
 ERROR(serialization_module_too_new,Fatal,
       "module file was created by a newer version of the compiler: %0",
       (StringRef))
+ERROR(serialization_module_language_version_mismatch,Fatal,
+      "module compiled with Swift %0 cannot be imported in Swift %1: %2",
+      (StringRef, StringRef, StringRef))
 ERROR(serialization_module_too_old,Fatal,
       "module file was created by an older version of the compiler; "
       "rebuild %0 and try again: %1",

include/swift/Basic/Version.h

@@ -19,11 +19,12 @@
 #ifndef SWIFT_BASIC_VERSION_H
 #define SWIFT_BASIC_VERSION_H
 
-#include <string>
 
+#include "swift/Basic/LLVM.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include <string>
 
 namespace swift {
 
@@ -50,7 +51,7 @@ namespace version {
 /// a: [0 - 999]
 /// b: [0 - 999]
 class Version {
-  llvm::SmallVector<uint64_t, 5> Components;
+  SmallVector<uint64_t, 5> Components;
 public:
   /// Create the empty compiler version - this always compares greater
   /// or equal to any other CompilerVersion, as in the case of building Swift
@@ -60,11 +61,7 @@ class Version {
   /// Create a version from a string in source code.
   ///
   /// Must include only groups of digits separated by a dot.
-  Version(const llvm::StringRef VersionString, SourceLoc Loc,
-                  DiagnosticEngine *Diags);
-
-  /// Return a printable string representation of the version.
-  std::string str() const;
+  Version(StringRef VersionString, SourceLoc Loc, DiagnosticEngine *Diags);
 
   /// Return a string to be used as an internal preprocessor define.
   ///
@@ -91,17 +88,16 @@ class Version {
   }
 
   /// Parse a version in the form used by the _compiler_version \#if condition.
-  static Version parseCompilerVersionString(llvm::StringRef VersionString,
+  static Version parseCompilerVersionString(StringRef VersionString,
                                             SourceLoc Loc,
                                             DiagnosticEngine *Diags);
 
   /// Parse a generic version string of the format [0-9]+(.[0-9]+)*
   ///
   /// Version components can be any unsigned 64-bit number.
-  static llvm::Optional<Version> parseVersionString(
-    llvm::StringRef VersionString,
-    SourceLoc Loc,
-    DiagnosticEngine *Diags);
+  static Optional<Version> parseVersionString(StringRef VersionString,
+                                              SourceLoc Loc,
+                                              DiagnosticEngine *Diags);
 
   /// Returns a version from the currently defined SWIFT_COMPILER_VERSION.
   ///
@@ -116,6 +112,8 @@ class Version {
 
 bool operator>=(const Version &lhs, const Version &rhs);
 
+raw_ostream &operator<<(raw_ostream &os, const Version &version);
+
 /// Retrieves the numeric {major, minor} Swift version.
 std::pair<unsigned, unsigned> getSwiftNumericVersion();
 

include/swift/Serialization/ModuleFile.h

@@ -350,7 +350,8 @@ class ModuleFile : public LazyMemberLoader {
   /// Constructs a new module and validates it.
   ModuleFile(std::unique_ptr<llvm::MemoryBuffer> moduleInputBuffer,
              std::unique_ptr<llvm::MemoryBuffer> moduleDocInputBuffer,
-             bool isFramework, serialization::ExtendedValidationInfo *extInfo);
+             bool isFramework, serialization::ValidationInfo &info,
+             serialization::ExtendedValidationInfo *extInfo);
 
 public:
   /// Change the status of the current module. Default argument marks the module
@@ -479,15 +480,16 @@ class ModuleFile : public LazyMemberLoader {
   /// \param[out] extInfo Optionally, extra info serialized about the module.
   /// \returns Whether the module was successfully loaded, or what went wrong
   ///          if it was not.
-  static Status
+  static serialization::ValidationInfo
   load(std::unique_ptr<llvm::MemoryBuffer> moduleInputBuffer,
        std::unique_ptr<llvm::MemoryBuffer> moduleDocInputBuffer,
        bool isFramework, std::unique_ptr<ModuleFile> &theModule,
        serialization::ExtendedValidationInfo *extInfo = nullptr) {
+    serialization::ValidationInfo info;
     theModule.reset(new ModuleFile(std::move(moduleInputBuffer),
                                    std::move(moduleDocInputBuffer),
-                                   isFramework, extInfo));
-    return theModule->getStatus();
+                                   isFramework, info, extInfo));
+    return info;
   }
 
   // Out of line to avoid instantiation OnDiskChainedHashTable here.
@@ -597,17 +599,6 @@ class ModuleFile : public LazyMemberLoader {
     return ModuleInputBuffer->getBufferIdentifier();
   }
 
-  /// Returns the module name as stored in the serialized data.
-  StringRef getModuleName() const {
-    return Name;
-  }
-
-  /// Returns the target triple the module was compiled for,
-  /// as stored in the serialized data.
-  StringRef getTargetTriple() const {
-    return TargetTriple;
-  }
-
   /// AST-verify imported decls.
   ///
   /// Has no effect in NDEBUG builds.

include/swift/Serialization/ModuleFormat.h

@@ -415,6 +415,7 @@ namespace control_block {
     METADATA, // ID
     BCFixed<16>, // Module format major version
     BCFixed<16>, // Module format minor version
+    BCVBR<8>, // length of "short version string" in the blob
     BCBlob // misc. version information
   >;
 

include/swift/Serialization/Validation.h

@@ -70,6 +70,7 @@ bool isSerializedAST(StringRef data);
 struct ValidationInfo {
   StringRef name = {};
   StringRef targetTriple = {};
+  StringRef shortVersion = {};
   size_t bytes = 0;
   Status status = Status::Malformed;
 };

lib/Basic/Version.cpp

@@ -260,15 +260,13 @@ Version Version::getCurrentLanguageVersion() {
   return currentVersion.getValue();
 }
 
-std::string Version::str() const {
-  std::string VersionString;
-  llvm::raw_string_ostream OS(VersionString);
-  for (auto i = Components.begin(); i != Components.end(); i++) {
-    OS << *i;
-    if (i != Components.end() - 1)
-      OS << '.';
-  }
-  return OS.str();
+raw_ostream &operator<<(raw_ostream &os, const Version &version) {
+  if (version.empty())
+    return os;
+  os << version[0];
+  for (size_t i = 1, e = version.size(); i != e; ++i)
+    os << '.' << version[i];
+  return os;
 }
 
 std::string Version::preprocessorDefinition() const {

lib/Serialization/ModuleFile.cpp

@@ -190,6 +190,11 @@ validateControlBlock(llvm::BitstreamCursor &cursor,
         }
       }
 
+      // This field was added later; be resilient against its absence.
+      if (scratch.size() > 2) {
+        result.shortVersion = blobData.slice(0, scratch[2]);
+      }
+
       versionSeen = true;
       break;
     }
@@ -743,7 +748,7 @@ static bool isTargetTooNew(const llvm::Triple &moduleTarget,
 ModuleFile::ModuleFile(
     std::unique_ptr<llvm::MemoryBuffer> moduleInputBuffer,
     std::unique_ptr<llvm::MemoryBuffer> moduleDocInputBuffer,
-    bool isFramework,
+    bool isFramework, serialization::ValidationInfo &info,
     serialization::ExtendedValidationInfo *extInfo)
     : ModuleInputBuffer(std::move(moduleInputBuffer)),
       ModuleDocInputBuffer(std::move(moduleDocInputBuffer)),
@@ -775,7 +780,7 @@ ModuleFile::ModuleFile(
     case CONTROL_BLOCK_ID: {
       cursor.EnterSubBlock(CONTROL_BLOCK_ID);
 
-      auto info = validateControlBlock(cursor, scratch, extInfo);
+      info = validateControlBlock(cursor, scratch, extInfo);
       if (info.status != Status::Valid) {
         error(info.status);
         return;

lib/Serialization/Serialization.cpp

@@ -26,6 +26,7 @@
 #include "swift/Basic/STLExtras.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/Timer.h"
+#include "swift/Basic/Version.h"
 #include "swift/ClangImporter/ClangImporter.h"
 #include "swift/ClangImporter/ClangModule.h"
 #include "swift/Serialization/SerializationOptions.h"
@@ -54,6 +55,7 @@
 using namespace swift;
 using namespace swift::serialization;
 using namespace llvm::support;
+using swift::version::Version;
 using llvm::BCBlockRAII;
 
 /// Used for static_assert.
@@ -571,15 +573,14 @@ void Serializer::writeHeader(const SerializationOptions &options) {
 
     ModuleName.emit(ScratchRecord, M->getName().str());
 
-    // FIXME: put a real version in here.
-#ifdef LLVM_VERSION_INFO
-# define EXTRA_VERSION_STRING PACKAGE_STRING LLVM_VERSION_INFO
-#else
-# define EXTRA_VERSION_STRING PACKAGE_STRING
-#endif
+    SmallString<32> versionStringBuf;
+    llvm::raw_svector_ostream versionString(versionStringBuf);
+    versionString << Version::getCurrentLanguageVersion();
+    size_t shortVersionStringLength = versionString.tell();
+    versionString << '/' << version::getSwiftFullVersion();
     Metadata.emit(ScratchRecord,
-                  VERSION_MAJOR, VERSION_MINOR, EXTRA_VERSION_STRING);
-#undef EXTRA_VERSION_STRING
+                  VERSION_MAJOR, VERSION_MINOR, shortVersionStringLength,
+                  versionString.str());
 
     Target.emit(ScratchRecord, M->getASTContext().LangOpts.Target.str());
 
@@ -619,15 +620,10 @@ void Serializer::writeDocHeader() {
     control_block::MetadataLayout Metadata(Out);
     control_block::TargetLayout Target(Out);
 
-    // FIXME: put a real version in here.
-#ifdef LLVM_VERSION_INFO
-# define EXTRA_VERSION_STRING PACKAGE_STRING LLVM_VERSION_INFO
-#else
-# define EXTRA_VERSION_STRING PACKAGE_STRING
-#endif
     Metadata.emit(ScratchRecord,
-                  VERSION_MAJOR, VERSION_MINOR, EXTRA_VERSION_STRING);
-#undef EXTRA_VERSION_STRING
+                  VERSION_MAJOR, VERSION_MINOR,
+                  /*short version string length*/0,
+                  version::getSwiftFullVersion());
 
     Target.emit(ScratchRecord, M->getASTContext().LangOpts.Target.str());
   }

lib/Serialization/SerializedModuleLoader.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/Basic/STLExtras.h"
 #include "swift/Basic/SourceManager.h"
+#include "swift/Basic/Version.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
@@ -163,11 +164,12 @@ FileUnit *SerializedModuleLoader::loadAST(
 
   serialization::ExtendedValidationInfo extendedInfo;
   std::unique_ptr<ModuleFile> loadedModuleFile;
-  serialization::Status err = ModuleFile::load(std::move(moduleInputBuffer),
-                                               std::move(moduleDocInputBuffer),
-                                               isFramework, loadedModuleFile,
-                                               &extendedInfo);
-  if (err == serialization::Status::Valid) {
+  serialization::ValidationInfo loadInfo =
+      ModuleFile::load(std::move(moduleInputBuffer),
+                       std::move(moduleDocInputBuffer),
+                       isFramework, loadedModuleFile,
+                       &extendedInfo);
+  if (loadInfo.status == serialization::Status::Valid) {
     Ctx.bumpGeneration();
 
     M.setResilienceStrategy(extendedInfo.getResilienceStrategy());
@@ -180,9 +182,9 @@ FileUnit *SerializedModuleLoader::loadAST(
       M.setTestingEnabled();
 
     auto diagLocOrInvalid = diagLoc.getValueOr(SourceLoc());
-    err = loadedModuleFile->associateWithFileContext(fileUnit,
-                                                     diagLocOrInvalid);
-    if (err == serialization::Status::Valid) {
+    loadInfo.status =
+        loadedModuleFile->associateWithFileContext(fileUnit, diagLocOrInvalid);
+    if (loadInfo.status == serialization::Status::Valid) {
       LoadedModuleFiles.emplace_back(std::move(loadedModuleFile),
                                      Ctx.getCurrentGeneration());
       return fileUnit;
@@ -195,15 +197,36 @@ FileUnit *SerializedModuleLoader::loadAST(
   if (!diagLoc)
     return nullptr;
 
-  switch (loadedModuleFile->getStatus()) {
+  auto diagnoseDifferentLanguageVersion = [&](StringRef shortVersion) -> bool {
+    if (shortVersion.empty())
+      return false;
+
+    SmallString<32> versionBuf;
+    llvm::raw_svector_ostream versionString(versionBuf);
+    versionString << version::Version::getCurrentLanguageVersion();
+    if (versionString.str() == shortVersion)
+      return false;
+
+    Ctx.Diags.diagnose(*diagLoc,
+                       diag::serialization_module_language_version_mismatch,
+                       loadInfo.shortVersion, versionString.str(),
+                       moduleBufferID);
+    return true;
+  };
+
+  switch (loadInfo.status) {
   case serialization::Status::Valid:
     llvm_unreachable("At this point we know loading has failed");
 
   case serialization::Status::FormatTooNew:
+    if (diagnoseDifferentLanguageVersion(loadInfo.shortVersion))
+      break;
     Ctx.Diags.diagnose(*diagLoc, diag::serialization_module_too_new,
                        moduleBufferID);
     break;
   case serialization::Status::FormatTooOld:
+    if (diagnoseDifferentLanguageVersion(loadInfo.shortVersion))
+      break;
     Ctx.Diags.diagnose(*diagLoc, diag::serialization_module_too_old,
                        M.getName(), moduleBufferID);
     break;
@@ -288,7 +311,7 @@ FileUnit *SerializedModuleLoader::loadAST(
     if (Ctx.LangOpts.DebuggerSupport)
       diagKind = diag::serialization_name_mismatch_repl;
     Ctx.Diags.diagnose(*diagLoc, diagKind,
-                       loadedModuleFile->getModuleName(), M.getName());
+                       loadInfo.name, M.getName());
     break;
   }
 
@@ -299,13 +322,12 @@ FileUnit *SerializedModuleLoader::loadAST(
     if (Ctx.LangOpts.DebuggerSupport)
       diagKind = diag::serialization_target_incompatible_repl;
     Ctx.Diags.diagnose(*diagLoc, diagKind,
-                       loadedModuleFile->getTargetTriple(), moduleBufferID);
+                       loadInfo.targetTriple, moduleBufferID);
     break;
   }
 
   case serialization::Status::TargetTooNew: {
-    StringRef moduleTargetTriple = loadedModuleFile->getTargetTriple();
-    llvm::Triple moduleTarget(llvm::Triple::normalize(moduleTargetTriple));
+    llvm::Triple moduleTarget(llvm::Triple::normalize(loadInfo.targetTriple));
 
     StringRef osName;
     unsigned major, minor, micro;

test/DebugInfo/ASTSection_linker.swift

@@ -17,6 +17,7 @@
 // REQUIRES: OS=macosx
 
 // CHECK: Loaded module ASTSection from
+// CHECK: - Swift Version: {{.+}}.{{.+}}
 // CHECK: - Target: {{.+}}-{{.+}}-{{.+}}
 // CHECK: - SDK path: /fake/sdk/path{{$}}
 // CHECK: - -Xcc options: -working-directory {{.+}} -DA -DB