[Frontend/Serialization] Narrow -swift-compiler-version to -interface-compiler-version

It might be unexpected to future users that `-swift-compiler-version`
would produce a version aligned to .swiftinterface instead of one used
to build the .swiftmodule file. To avoid this possible confusion, let's
scope down the version to `-interface-compiler-version` flag and
`SWIFT_INTERFACE_COMPILER_VERSION` option in the module.

Author: xedin

include/swift/AST/FileUnit.h

@@ -345,8 +345,9 @@ 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 {
+  /// Returns the version of the Swift compiler used to create generate
+  /// .swiftinterface file if this file is produced from one.
+  virtual llvm::VersionTuple getSwiftInterfaceCompilerVersion() const {
     return {};
   }
 

include/swift/AST/Module.h

@@ -254,8 +254,9 @@ class ModuleDecl
 
   mutable Identifier PublicModuleName;
 
-  /// Indicates that version of the Swift compiler this module was built with.
-  mutable llvm::VersionTuple SwiftCompilerVersion;
+  /// Indicates a version of the Swift compiler used to generate 
+  /// .swiftinterface file that this module was produced from (if any).
+  mutable llvm::VersionTuple InterfaceCompilerVersion;
 
 public:
   /// Produces the components of a given module's full name in reverse order.
@@ -521,13 +522,13 @@ class ModuleDecl
     PublicModuleName = name;
   }
 
-  /// The version of the Swift compiler this module was built with.
-  llvm::VersionTuple getSwiftCompilerVersion() const {
-    return SwiftCompilerVersion;
+  /// See \c InterfaceCompilerVersion
+  llvm::VersionTuple getSwiftInterfaceCompilerVersion() const {
+    return InterfaceCompilerVersion;
   }
 
-  void setSwiftCompilerVersion(llvm::VersionTuple version) {
-    SwiftCompilerVersion = version;
+  void setSwiftInterfaceCompilerVersion(llvm::VersionTuple version) {
+    InterfaceCompilerVersion = version;
   }
 
   /// Retrieve the actual module name of an alias used for this module (if any).

include/swift/Frontend/FrontendOptions.h

@@ -111,8 +111,8 @@ class FrontendOptions {
   llvm::VersionTuple UserModuleVersion;
 
   /// The Swift compiler version number that would be used to synthesize
-  /// swiftinterface files and subsequently swiftmodules.
-  llvm::VersionTuple SwiftCompilerVersion;
+  /// swiftinterface files and subsequently their swiftmodules.
+  llvm::VersionTuple SwiftInterfaceCompilerVersion;
 
   /// A set of modules allowed to import this module.
   std::set<std::string> AllowableClients;

include/swift/Option/Options.td

@@ -303,10 +303,10 @@ def package_description_version: Separate<["-"], "package-description-version">,
   HelpText<"The version number to be applied on the input for the PackageDescription availability kind">,
   MetaVarName<"<vers>">;
 
-def swift_compiler_version : Separate<["-"], "swift-compiler-version">,
+def swiftinterface_compiler_version : Separate<["-"], "interface-compiler-version">,
   Flags<[FrontendOption, HelpHidden]>,
-  HelpText<"The version of the Swift compiler used to build swift interface and module">,
-  MetaVarName<"<compvers>">;
+  HelpText<"The version of the Swift compiler used to generate a .swiftinterface file">,
+  MetaVarName<"<intcvers>">;
 
 def tools_directory : Separate<["-"], "tools-directory">,
   Flags<[FrontendOption, NoInteractiveOption, DoesNotAffectIncrementalBuild,

include/swift/Serialization/SerializedModuleLoader.h

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

include/swift/Serialization/Validation.h

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

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -299,18 +299,11 @@ bool ArgsToFrontendOptionsConverter::convert(
   if (const Arg *A = Args.getLastArg(OPT_public_module_name))
     Opts.PublicModuleName = A->getValue();
 
-  if (auto A = Args.getLastArg(OPT_swift_compiler_version)) {
-    if (Opts.SwiftCompilerVersion.tryParse(A->getValue())) {
+  if (auto A = Args.getLastArg(OPT_swiftinterface_compiler_version)) {
+    if (Opts.SwiftInterfaceCompilerVersion.tryParse(A->getValue())) {
       Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value,
                      A->getAsString(Args), A->getValue());
     }
-  // If swiftinterface doesn't have a flag, let's not set the version
-  // to the current compiler version here. This helps us to identify
-  // swiftmodules built from swiftinterface generated before introduction
-  // of `-swift-compiler-version` flag.
-  } else if (Opts.InputMode !=
-             FrontendOptions::ParseInputMode::SwiftModuleInterface) {
-    Opts.SwiftCompilerVersion.tryParse(version::getCompilerVersion());
   }
 
   // This must be called after computing module name, module abi name,

lib/Frontend/Frontend.cpp

@@ -1490,8 +1490,8 @@ ModuleDecl *CompilerInstance::getMainModule() const {
       MainModule->setSerializePackageEnabled();
 
     if (auto compilerVersion =
-            Invocation.getFrontendOptions().SwiftCompilerVersion) {
-      MainModule->setSwiftCompilerVersion(compilerVersion);
+            Invocation.getFrontendOptions().SwiftInterfaceCompilerVersion) {
+      MainModule->setSwiftInterfaceCompilerVersion(compilerVersion);
     }
 
     // Register the main module with the AST context.

lib/Frontend/ModuleInterfaceSupport.cpp

@@ -124,7 +124,7 @@ static void printToolVersionAndFlagsComment(raw_ostream &out,
         !Opts.PackageFlags.IgnorableFlags.empty())
       ignorableFlags.push_back(Opts.PackageFlags.IgnorableFlags);
 
-    ignorableFlags.push_back("-swift-compiler-version");
+    ignorableFlags.push_back("-interface-compiler-version");
     ignorableFlags.push_back(version::getCompilerVersion());
 
     if (!ignorableFlags.empty()) {

lib/Serialization/ModuleFile.cpp

@@ -1410,6 +1410,6 @@ StringRef SerializedASTFile::getPublicModuleName() const {
   return File.getPublicModuleName();
 }
 
-llvm::VersionTuple SerializedASTFile::getSwiftCompilerVersion() const {
-  return File.getSwiftCompilerVersion();
+llvm::VersionTuple SerializedASTFile::getSwiftInterfaceCompilerVersion() const {
+  return File.getSwiftInterfaceCompilerVersion();
 }