Merge pull request swiftlang#85839 from swiftlang/jepa-release2

[6.3][NFC] "SwiftVersion" → "LanguageMode" in `DiagnosticEngine::warnUntilSwiftVersion`, etc.

Author: AnthonyLatsis

include/swift/AST/ASTContext.h

@@ -1554,9 +1554,9 @@ class ASTContext final {
   ///
   /// This is usually the check you want; for example, when introducing
   /// a new language feature which is only visible in Swift 5, you would
-  /// check for isSwiftVersionAtLeast(5).
-  bool isSwiftVersionAtLeast(unsigned major, unsigned minor = 0) const {
-    return LangOpts.isSwiftVersionAtLeast(major, minor);
+  /// check for isLanguageModeAtLeast(5).
+  bool isLanguageModeAtLeast(unsigned major, unsigned minor = 0) const {
+    return LangOpts.isLanguageModeAtLeast(major, minor);
   }
 
   /// Check whether it's important to respect access control restrictions

include/swift/AST/DiagnosticEngine.h

@@ -388,8 +388,8 @@ namespace swift {
     ///
     /// This helps stage in fixes for stricter diagnostics as warnings
     /// until the next major language version.
-    InFlightDiagnostic &limitBehaviorUntilSwiftVersion(
-        DiagnosticBehavior limit, unsigned majorVersion);
+    InFlightDiagnostic &limitBehaviorUntilLanguageMode(DiagnosticBehavior limit,
+                                                       unsigned majorVersion);
 
     /// Limits the diagnostic behavior to \c limit accordingly if
     /// preconcurrency applies. Otherwise, the behavior limit only applies
@@ -412,7 +412,7 @@ namespace swift {
         return limitBehavior(limit);
       }
 
-      return limitBehaviorUntilSwiftVersion(limit, languageMode);
+      return limitBehaviorUntilLanguageMode(limit, languageMode);
     }
 
     /// Limit the diagnostic behavior to warning until the next future
@@ -424,19 +424,19 @@ namespace swift {
     ///
     /// This helps stage in fixes for stricter diagnostics as warnings
     /// until the next major language version.
-    InFlightDiagnostic &warnUntilFutureSwiftVersion();
+    InFlightDiagnostic &warnUntilFutureLanguageMode();
 
-    InFlightDiagnostic &warnUntilFutureSwiftVersionIf(bool shouldLimit) {
+    InFlightDiagnostic &warnUntilFutureLanguageModeIf(bool shouldLimit) {
       if (!shouldLimit)
         return *this;
-      return warnUntilFutureSwiftVersion();
+      return warnUntilFutureLanguageMode();
     }
 
     /// Limit the diagnostic behavior to warning until the specified version.
     ///
     /// This helps stage in fixes for stricter diagnostics as warnings
     /// until the next major language version.
-    InFlightDiagnostic &warnUntilSwiftVersion(unsigned majorVersion);
+    InFlightDiagnostic &warnUntilLanguageMode(unsigned majorVersion);
 
     /// Limit the diagnostic behavior to warning if the context is a
     /// swiftinterface.
@@ -453,10 +453,10 @@ namespace swift {
     ///
     /// This helps stage in fixes for stricter diagnostics as warnings
     /// until the next major language version.
-    InFlightDiagnostic &warnUntilSwiftVersionIf(bool shouldLimit,
+    InFlightDiagnostic &warnUntilLanguageModeIf(bool shouldLimit,
                                                 unsigned majorVersion) {
       if (!shouldLimit) return *this;
-      return warnUntilSwiftVersion(majorVersion);
+      return warnUntilLanguageMode(majorVersion);
     }
 
     /// Wraps this diagnostic in another diagnostic. That is, \p wrapper will be
@@ -887,7 +887,7 @@ namespace swift {
     version::Version languageVersion;
 
     /// The stats reporter used to keep track of Swift 6 errors
-    /// diagnosed via \c warnUntilSwiftVersion(6).
+    /// diagnosed via \c warnUntilLanguageMode(6).
     UnifiedStatsReporter *statsReporter = nullptr;
 
     /// Whether we are actively pretty-printing a declaration as part of

include/swift/Basic/Feature.h

@@ -82,7 +82,7 @@ struct Feature {
 
   /// Get the major language version in which this feature was introduced, or
   /// \c None if it does not have such a version.
-  std::optional<unsigned> getLanguageVersion() const;
+  std::optional<unsigned> getLanguageMode() const;
 };
 
 #define LANGUAGE_FEATURE(FeatureName, SENumber, Description)                   \

include/swift/Basic/Features.def

@@ -50,8 +50,8 @@
 // Swift compiler.
 //
 // OPTIONAL_LANGUAGE_FEATURE is the same as LANGUAGE_FEATURE, but describes
-// accepted features that can be enabled independently of language version and
-// are not scheduled to be enabled in some specific language version. Examples
+// accepted features that can be enabled independently of language mode and
+// are not scheduled to be enabled in some specific language mode. Examples
 // of optional language features include strict memory safety checking (SE-0458)
 // and Embedded Swift.
 //===----------------------------------------------------------------------===//
@@ -82,11 +82,11 @@
       defined(UPCOMING_FEATURE)
 #    error ambiguous defines when including Features.def
 #  elif defined(SUPPRESSIBLE_LANGUAGE_FEATURE)
-#    define SUPPRESSIBLE_UPCOMING_FEATURE(FeatureName, SENumber, Version) \
+#    define SUPPRESSIBLE_UPCOMING_FEATURE(FeatureName, SENumber, LanguageMode) \
        SUPPRESSIBLE_LANGUAGE_FEATURE(FeatureName, SENumber, #FeatureName)
 #  else
-#    define SUPPRESSIBLE_UPCOMING_FEATURE(FeatureName, SENumber, Version) \
-       UPCOMING_FEATURE(FeatureName, SENumber, Version)
+#    define SUPPRESSIBLE_UPCOMING_FEATURE(FeatureName, SENumber, LanguageMode) \
+       UPCOMING_FEATURE(FeatureName, SENumber, LanguageMode)
 #  endif
 #endif
 
@@ -136,10 +136,10 @@
 // feature is disabled.
 #ifndef MIGRATABLE_UPCOMING_FEATURE
   #if defined(UPCOMING_FEATURE)
-    #define MIGRATABLE_UPCOMING_FEATURE(FeatureName, SENumber, Version)         \
-      UPCOMING_FEATURE(FeatureName, SENumber, Version)
+    #define MIGRATABLE_UPCOMING_FEATURE(FeatureName, SENumber, LanguageMode)   \
+      UPCOMING_FEATURE(FeatureName, SENumber, LanguageMode)
   #else
-    #define MIGRATABLE_UPCOMING_FEATURE(FeatureName, SENumber, Version)         \
+    #define MIGRATABLE_UPCOMING_FEATURE(FeatureName, SENumber, LanguageMode)   \
       LANGUAGE_FEATURE(FeatureName, SENumber, #FeatureName)
   #endif
 #endif
@@ -161,7 +161,7 @@
 #endif
 
 #ifndef UPCOMING_FEATURE
-  #define UPCOMING_FEATURE(FeatureName, SENumber, Version)                     \
+  #define UPCOMING_FEATURE(FeatureName, SENumber, LanguageMode)                \
     LANGUAGE_FEATURE(FeatureName, SENumber, #FeatureName)
 #endif
 

include/swift/Basic/LangOptions.h

@@ -745,8 +745,8 @@ namespace swift {
     ///
     /// This is usually the check you want; for example, when introducing
     /// a new language feature which is only visible in Swift 5, you would
-    /// check for isSwiftVersionAtLeast(5).
-    bool isSwiftVersionAtLeast(unsigned major, unsigned minor = 0) const {
+    /// check for isLanguageModeAtLeast(5).
+    bool isLanguageModeAtLeast(unsigned major, unsigned minor = 0) const {
       return EffectiveLanguageVersion.isVersionAtLeast(major, minor);
     }
 

lib/AST/ASTContext.cpp

@@ -4182,7 +4182,7 @@ AnyFunctionType::Param swift::computeSelfParam(AbstractFunctionDecl *AFD,
     // NOTE: it's important that we check if it's a convenience init only after
     // confirming it's not semantically final, or else there can be a request
     // evaluator cycle to determine the init kind for actors, which are final.
-    if (Ctx.isSwiftVersionAtLeast(5)) {
+    if (Ctx.isLanguageModeAtLeast(5)) {
       if (wantDynamicSelf)
         if (auto *classDecl = selfTy->getClassOrBoundGenericClass())
           if (!classDecl->isSemanticallyFinal() && CD->isConvenienceInit())

lib/AST/ASTVerifier.cpp

@@ -2194,7 +2194,7 @@ class Verifier : public ASTWalker {
     void verifyChecked(OptionalTryExpr *E) {
       PrettyStackTraceExpr debugStack(Ctx, "verifying OptionalTryExpr", E);
 
-      if (Ctx.LangOpts.isSwiftVersionAtLeast(5)) {
+      if (Ctx.isLanguageModeAtLeast(5)) {
         checkSameType(E->getType(), E->getSubExpr()->getType(),
                       "OptionalTryExpr and sub-expression");
       }

lib/AST/Decl.cpp

@@ -1231,9 +1231,8 @@ bool Decl::preconcurrency() const {
 
   // Variables declared in top-level code are @_predatesConcurrency
   if (const VarDecl *var = dyn_cast<VarDecl>(this)) {
-    const LangOptions &langOpts = getASTContext().LangOpts;
-    return !langOpts.isSwiftVersionAtLeast(6) && var->isTopLevelGlobal() &&
-           var->getDeclContext()->isAsyncContext();
+    return !getASTContext().isLanguageModeAtLeast(6) &&
+           var->isTopLevelGlobal() && var->getDeclContext()->isAsyncContext();
   }
 
   return false;
@@ -2835,7 +2834,7 @@ static bool isDefaultInitializable(const TypeRepr *typeRepr, ASTContext &ctx) {
     return true;
 
   // Also support the desugared 'Optional<T>' spelling.
-  if (!ctx.isSwiftVersionAtLeast(5)) {
+  if (!ctx.isLanguageModeAtLeast(5)) {
     if (typeRepr->isSimpleUnqualifiedIdentifier(ctx.Id_Void)) {
       return true;
     }
@@ -3016,7 +3015,7 @@ static bool deferMatchesEnclosingAccess(const FuncDecl *defer) {
   assert(defer->isDeferBody());
 
   // In Swift 6+, then yes.
-  if (defer->getASTContext().isSwiftVersionAtLeast(6))
+  if (defer->getASTContext().isLanguageModeAtLeast(6))
     return true;
 
   // If the defer is part of a function that is a member of an actor or
@@ -3090,7 +3089,7 @@ static bool isDirectToStorageAccess(const DeclContext *UseDC,
     // In Swift 5 and later, the access must also be a member access on 'self'.
     if (!isAccessOnSelf &&
         var->getDeclContext()->isTypeContext() &&
-        var->getASTContext().isSwiftVersionAtLeast(5))
+        var->getASTContext().isLanguageModeAtLeast(5))
       return false;
 
     // As a special case, 'read' and 'modify' coroutines with forced static
@@ -4058,7 +4057,7 @@ bool swift::conflicting(ASTContext &ctx,
     // Prior to Swift 5, we permitted redeclarations of variables as different
     // declarations if the variable was declared in an extension of a generic
     // type. Make sure we maintain this behaviour in versions < 5.
-    if (!ctx.isSwiftVersionAtLeast(5)) {
+    if (!ctx.isLanguageModeAtLeast(5)) {
       if ((sig1.IsVariable && sig1.InExtensionOfGenericType) ||
           (sig2.IsVariable && sig2.InExtensionOfGenericType)) {
         if (wouldConflictInSwift5)
@@ -4082,7 +4081,7 @@ bool swift::conflicting(ASTContext &ctx,
   // Swift 5, a variable not in an extension of a generic type got a null
   // overload type instead of a function type as it does now, so we really
   // follow that behaviour and warn if there's going to be a conflict in future.
-  if (!ctx.isSwiftVersionAtLeast(5)) {
+  if (!ctx.isLanguageModeAtLeast(5)) {
     auto swift4Sig1Type = sig1.IsVariable && !sig1.InExtensionOfGenericType
                               ? CanType()
                               : sig1Type;
@@ -12207,8 +12206,8 @@ ActorIsolation swift::getActorIsolationOfContext(
     if (dcToUse->isAsyncContext() ||
         ctx.LangOpts.StrictConcurrencyLevel >= StrictConcurrency::Complete) {
       if (Type mainActor = ctx.getMainActorType())
-        return ActorIsolation::forGlobalActor(mainActor)
-            .withPreconcurrency(!ctx.isSwiftVersionAtLeast(6));
+        return ActorIsolation::forGlobalActor(mainActor).withPreconcurrency(
+            !ctx.isLanguageModeAtLeast(6));
     }
   }
 

lib/AST/DiagnosticEngine.cpp

@@ -459,8 +459,8 @@ InFlightDiagnostic::limitBehavior(DiagnosticBehavior limit) {
 }
 
 InFlightDiagnostic &
-InFlightDiagnostic::limitBehaviorUntilSwiftVersion(
-    DiagnosticBehavior limit, unsigned majorVersion) {
+InFlightDiagnostic::limitBehaviorUntilLanguageMode(DiagnosticBehavior limit,
+                                                   unsigned majorVersion) {
   if (!Engine->languageVersion.isVersionAtLeast(majorVersion)) {
     // If the behavior limit is a warning or less, wrap the diagnostic
     // in a message that this will become an error in a later Swift
@@ -487,14 +487,14 @@ InFlightDiagnostic::limitBehaviorUntilSwiftVersion(
   return *this;
 }
 
-InFlightDiagnostic &InFlightDiagnostic::warnUntilFutureSwiftVersion() {
+InFlightDiagnostic &InFlightDiagnostic::warnUntilFutureLanguageMode() {
   using namespace version;
-  return warnUntilSwiftVersion(Version::getFutureMajorLanguageVersion());
+  return warnUntilLanguageMode(Version::getFutureMajorLanguageVersion());
 }
 
 InFlightDiagnostic &
-InFlightDiagnostic::warnUntilSwiftVersion(unsigned majorVersion) {
-  return limitBehaviorUntilSwiftVersion(DiagnosticBehavior::Warning,
+InFlightDiagnostic::warnUntilLanguageMode(unsigned majorVersion) {
+  return limitBehaviorUntilLanguageMode(DiagnosticBehavior::Warning,
                                         majorVersion);
 }
 

lib/AST/NameLookup.cpp

@@ -610,7 +610,7 @@ static void recordShadowedDeclsAfterTypeMatch(
       // This is due to the fact that in Swift 4, we only gave custom overload
       // types to properties in extensions of generic types, otherwise we
       // used the null type.
-      if (!ctx.isSwiftVersionAtLeast(5) && isa<ValueDecl>(firstDecl)) {
+      if (!ctx.isLanguageModeAtLeast(5) && isa<ValueDecl>(firstDecl)) {
         auto secondSig = cast<ValueDecl>(secondDecl)->getOverloadSignature();
         auto firstSig = cast<ValueDecl>(firstDecl)->getOverloadSignature();
         if (firstSig.IsVariable && secondSig.IsVariable)