snapshot

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -6735,6 +6735,11 @@ ERROR(availability_isolated_any_only_version_newer, none,
       "%0 %1 or newer",
       (StringRef, llvm::VersionTuple))
 
+ERROR(availability_noncopyable_generics_only_version_newer, none,
+      "runtime support for '~' suppressions on generic parameters is only available in "
+      "%0 %1 or newer",
+      (StringRef, llvm::VersionTuple))
+
 ERROR(availability_variadic_type_only_version_newer, none,
       "parameter packs in generic types are only available in %0 %1 or newer",
       (StringRef, llvm::VersionTuple))

include/swift/AST/FeatureAvailability.def

@@ -71,6 +71,8 @@ FEATURE(SwiftExceptionPersonality,                      (6, 0))
 // Metadata support for @isolated(any) function types
 FEATURE(IsolatedAny,                                    (6, 0))
 
+FEATURE(NoncopyableGenerics,                            (6, 0))
+
 FEATURE(TaskExecutor,                                   FUTURE)
 FEATURE(Differentiation,                                FUTURE)
 FEATURE(InitRawStructMetadata,                          FUTURE)

include/swift/Sema/CheckAvailability.h

@@ -0,0 +1,27 @@
+//===--- CheckAvailability.h - CheckAvailability ----------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SEMA_CHECKAVAILABILITY_H
+#define SWIFT_SEMA_CHECKAVAILABILITY_H
+
+namespace swift {
+class NominalOrBoundGenericNominalType;
+
+/// NoncopyableGenerics, which is the generics system for inverses, does not
+/// always require the runtime metadata that is only availabile in Swift 6.
+///
+/// \returns true if the given type needs the newer runtime.
+bool requiresNoncopyableGenericsAvailabilityCheck(
+    NominalOrBoundGenericNominalType *type);
+}
+
+#endif //SWIFT_SEMA_CheckAVAILABILITY_H

lib/IRGen/GenReflection.cpp

@@ -26,6 +26,7 @@
 #include "swift/IRGen/Linking.h"
 #include "swift/RemoteInspection/MetadataSourceBuilder.h"
 #include "swift/RemoteInspection/Records.h"
+#include "swift/Sema/CheckAvailability.h"
 #include "swift/SIL/SILModule.h"
 
 #include "ConstantBuilder.h"
@@ -227,17 +228,11 @@ getRuntimeVersionThatSupportsDemanglingType(CanType type) {
     }
 
     // Any nominal type that has an inverse requirement in its generic signature
-    // uses NoncopyableGenerics. Since inverses are mangled into symbols,
-    // a Swift 6.0+ runtime is needed to demangle them.
+    // uses NoncopyableGenerics. We can support some cases where the type has
+    // bound generic arguments that conform to all invertible protocols.
     if (auto nominalTy = dyn_cast<NominalOrBoundGenericNominalType>(t)) {
-      auto *nom = nominalTy->getDecl();
-      if (auto sig = nom->getGenericSignature()) {
-        SmallVector<InverseRequirement, 2> inverses;
-        SmallVector<Requirement, 2> reqs;
-        sig->getRequirementsWithInverses(reqs, inverses);
-        if (!inverses.empty())
-          return addRequirement(Swift_6_0);
-      }
+      if (requiresNoncopyableGenericsAvailabilityCheck(nominalTy))
+        return addRequirement(Swift_6_0);
     }
 
     return false;

lib/Sema/TypeCheckAvailability.cpp

@@ -38,6 +38,7 @@
 #include "swift/Parse/Lexer.h"
 #include "swift/Parse/Parser.h"
 #include "swift/Sema/IDETypeChecking.h"
+#include "swift/Sema/CheckAvailability.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/SaveAndRestore.h"
@@ -3023,6 +3024,60 @@ static bool diagnoseIsolatedAnyAvailability(
       ReferenceDC);
 }
 
+static bool diagnoseNoncopyableGenericsAvailability(
+    SourceRange ReferenceRange, const DeclContext *ReferenceDC) {
+  return TypeChecker::checkAvailability(
+      ReferenceRange,
+      ReferenceDC->getASTContext().getNoncopyableGenericsAvailability(),
+      diag::availability_noncopyable_generics_only_version_newer,
+      ReferenceDC);
+}
+
+static bool inverseGenericsOldRuntimeCompatable(BoundGenericType *boundTy) {
+  for (auto arg : boundTy->getGenericArgs()) {
+    if (arg->hasTypeParameter() || arg->hasUnboundGenericType())
+      return false;
+
+    // Make sure the argument conforms to all known invertible protocols.
+    for (auto ip : InvertibleProtocolSet::allKnown()) {
+      switch (ip) {
+      case InvertibleProtocolKind::Copyable:
+        if (arg->isNoncopyable())
+          return false;
+      case InvertibleProtocolKind::Escapable:
+        if (!arg->isEscapable())
+          return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool swift::requiresNoncopyableGenericsAvailabilityCheck(
+    NominalOrBoundGenericNominalType *nominalTy) {
+  auto *nom = nominalTy->getDecl();
+  if (auto sig = nom->getGenericSignature()) {
+    SmallVector<InverseRequirement, 2> inverses;
+    SmallVector<Requirement, 2> reqs;
+    sig->getRequirementsWithInverses(reqs, inverses);
+    if (!inverses.empty()) {
+      // If the nominal is a bound generic type, and all arguments are
+      // conform to all invertible protocols, then older runtimes that will
+      // not check for those conformances don't actually need to, since we
+      // have already checked it now.
+      if (auto boundTy = dyn_cast<BoundGenericType>(nominalTy)) {
+        if (!inverseGenericsOldRuntimeCompatable(boundTy))
+          return true;
+      } else {
+        // It's generic, not bound, and has an inverse on a generic
+        // parameter, so we need the appropriate runtime.
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 static bool checkTypeMetadataAvailabilityInternal(CanType type,
                                                   SourceRange refLoc,
                                                   const DeclContext *refDC) {
@@ -3033,6 +3088,9 @@ static bool checkTypeMetadataAvailabilityInternal(CanType type,
       auto isolation = fnType->getIsolation();
       if (isolation.isErased())
         return diagnoseIsolatedAnyAvailability(refLoc, refDC);
+    } else if (auto nominalTy = dyn_cast<NominalOrBoundGenericNominalType>(type)) {
+      if (requiresNoncopyableGenericsAvailabilityCheck(nominalTy))
+        return diagnoseNoncopyableGenericsAvailability(refLoc, refDC);
     }
     return false;
   });