[cxx-interop] add 'upcoming-swift' compat version

This version will be used to gate new source breaking changes for C++ interoperability

Author: hyp

include/swift/Basic/LangOptions.h

@@ -310,6 +310,10 @@ namespace swift {
     /// disabled because it is not complete.
     bool EnableCXXInterop = false;
 
+    /// The C++ interoperability source compatibility version. Defaults
+    /// to the Swift language version.
+    version::Version cxxInteropCompatVersion;
+
     bool CForeignReferenceTypes = false;
 
     /// Imports getters and setters as computed properties.
@@ -655,6 +659,13 @@ namespace swift {
       return EffectiveLanguageVersion.isVersionAtLeast(major, minor);
     }
 
+    /// Whether the C++ interoperability compatibility version is at least
+    /// 'major'.
+    bool isCxxInteropCompatVersionAtLeast(unsigned major,
+                                          unsigned minor = 0) const {
+      return cxxInteropCompatVersion.isVersionAtLeast(major, minor);
+    }
+
     /// Determine whether the given feature is enabled.
     bool hasFeature(Feature feature) const;
 

include/swift/Basic/Version.h

@@ -175,6 +175,11 @@ StringRef getCurrentCompilerTag();
 /// depending on the vendor.
 StringRef getCurrentCompilerSerializationTag();
 
+/// Retrieves the value of the upcoming C++ interoperability compatibility
+/// version that's going to be presented as some new concrete version to the
+/// users.
+unsigned getUpcomingCxxInteropCompatVersion();
+
 } // end namespace version
 } // end namespace swift
 

lib/Basic/Version.cpp

@@ -306,5 +306,9 @@ StringRef getCurrentCompilerSerializationTag() {
 #endif
 }
 
+unsigned getUpcomingCxxInteropCompatVersion() {
+  return SWIFT_VERSION_MAJOR + 1;
+}
+
 } // end namespace version
 } // end namespace swift

lib/ClangImporter/ImporterImpl.h

@@ -589,6 +589,17 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
     return Instance.get();
   }
 
+  /// Whether the C++ interoperability compatibility version is at least
+  /// 'major'.
+  ///
+  /// Use the
+  /// `isCxxInteropCompatVersionAtLeast(version::getUpcomingCxxInteropCompatVersion())`
+  /// check when making a source breaking C++ interop change.
+  bool isCxxInteropCompatVersionAtLeast(unsigned major,
+                                        unsigned minor = 0) const {
+    return SwiftContext.LangOpts.isCxxInteropCompatVersionAtLeast(major, minor);
+  }
+
 private:
   /// The Importer may be configured to load modules of a different OS Version
   /// than the underlying Swift compilation. This is the `TargetOptions`

lib/Frontend/CompilerInvocation.cpp

@@ -486,15 +486,20 @@ enum class CxxCompatMode {
   off
 };
 
-static CxxCompatMode validateCxxInteropCompatibilityMode(StringRef mode) {
+static std::pair<CxxCompatMode, version::Version>
+validateCxxInteropCompatibilityMode(StringRef mode) {
   if (mode == "off")
-    return CxxCompatMode::off;
+    return {CxxCompatMode::off, {}};
   if (mode == "default")
-    return CxxCompatMode::enabled;
-  // FIXME: Drop swift-5.9.
+    return {CxxCompatMode::enabled, {}};
+  if (mode == "upcoming-swift")
+    return {CxxCompatMode::enabled,
+            version::Version({version::getUpcomingCxxInteropCompatVersion()})};
+  // Swift-5.9 corresponds to the Swift 5 language mode when
+  // Swift 5 is the default language version.
   if (mode == "swift-5.9")
-    return CxxCompatMode::enabled;
-  return CxxCompatMode::invalid;
+    return {CxxCompatMode::enabled, version::Version({5})};
+  return {CxxCompatMode::invalid, {}};
 }
 
 static void diagnoseCxxInteropCompatMode(Arg *verArg, ArgList &Args,
@@ -1066,16 +1071,29 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     }
 
     auto interopCompatMode = validateCxxInteropCompatibilityMode(A->getValue());
-    Opts.EnableCXXInterop |= (interopCompatMode == CxxCompatMode::enabled);
+    Opts.EnableCXXInterop |=
+        (interopCompatMode.first == CxxCompatMode::enabled);
+    if (Opts.EnableCXXInterop) {
+      Opts.cxxInteropCompatVersion = interopCompatMode.second;
+      // The default is tied to the current language version.
+      if (Opts.cxxInteropCompatVersion.empty())
+        Opts.cxxInteropCompatVersion =
+            Opts.EffectiveLanguageVersion.asMajorVersion();
+    }
 
-    if (interopCompatMode == CxxCompatMode::invalid)
+    if (interopCompatMode.first == CxxCompatMode::invalid)
       diagnoseCxxInteropCompatMode(A, Args, Diags);
   }
-  
+
   if (Args.hasArg(OPT_enable_experimental_cxx_interop)) {
     Diags.diagnose(SourceLoc(), diag::enable_interop_flag_deprecated);
     Diags.diagnose(SourceLoc(), diag::swift_will_maintain_compat);
     Opts.EnableCXXInterop |= true;
+    // Using the deprecated option only forces the 'swift-5.9' compat
+    // mode.
+    if (Opts.cxxInteropCompatVersion.empty())
+      Opts.cxxInteropCompatVersion =
+          validateCxxInteropCompatibilityMode("swift-5.9").second;
   }
 
   Opts.EnableObjCInterop =

test/Interop/Cxx/driver/invalid-interop-compat-mode.swift

@@ -2,8 +2,8 @@
 // RUN: split-file %s %t
 // RUN: not %target-swift-frontend -typecheck -I %t/Inputs  %t/test.swift  -cxx-interoperability-mode=swift-5.8 2>&1 | %FileCheck %s
 
-// Note: swift-5.9 is still supported, but will be removed.
 // RUN: %target-swift-frontend -typecheck -I %t/Inputs  %t/test.swift  -cxx-interoperability-mode=swift-5.9
+// RUN: %target-swift-frontend -typecheck -I %t/Inputs  %t/test.swift  -cxx-interoperability-mode=upcoming-swift
 
 //--- Inputs/module.modulemap
 module Test {