AST: Re-baseline NonescapableTypes feature.

Author: tshortli

include/swift/Basic/Features.def

@@ -253,7 +253,7 @@ BASELINE_LANGUAGE_FEATURE(BorrowingSwitch, 432, "Noncopyable type pattern matchi
 BASELINE_LANGUAGE_FEATURE(IsolatedAny, 431, "@isolated(any) function types")
 LANGUAGE_FEATURE(IsolatedAny2, 431, "@isolated(any) function types")
 LANGUAGE_FEATURE(ObjCImplementation, 436, "@objc @implementation extensions")
-LANGUAGE_FEATURE(NonescapableTypes, 446, "Nonescapable types")
+BASELINE_LANGUAGE_FEATURE(NonescapableTypes, 446, "Nonescapable types")
 BASELINE_LANGUAGE_FEATURE(BuiltinEmplaceTypedThrows, 0, "Builtin.emplace typed throws")
 BASELINE_LANGUAGE_FEATURE(MemorySafetyAttributes, 458, "@unsafe attribute")
 BASELINE_LANGUAGE_FEATURE(ValueGenerics, 452, "Value generics feature (integer generics)")

lib/AST/FeatureSet.cpp

@@ -130,74 +130,6 @@ UNINTERESTING_FEATURE(NoExplicitNonIsolated)
 // TODO: Return true for inlinable function bodies with module selectors in them
 UNINTERESTING_FEATURE(ModuleSelector)
 
-static bool usesFeatureNonescapableTypes(Decl *decl) {
-  auto containsNonEscapable =
-      [](SmallVectorImpl<InverseRequirement> &inverseReqs) {
-        auto foundIt =
-            llvm::find_if(inverseReqs, [](InverseRequirement inverseReq) {
-              if (inverseReq.getKind() == InvertibleProtocolKind::Escapable) {
-                return true;
-              }
-              return false;
-            });
-        return foundIt != inverseReqs.end();
-      };
-
-  if (auto *valueDecl = dyn_cast<ValueDecl>(decl)) {
-    if (isa<StructDecl, EnumDecl, ClassDecl>(decl)) {
-      auto *nominalDecl = cast<NominalTypeDecl>(valueDecl);
-      InvertibleProtocolSet inverses;
-      bool anyObject = false;
-      getDirectlyInheritedNominalTypeDecls(nominalDecl, inverses, anyObject);
-      if (inverses.containsEscapable()) {
-        return true;
-      }
-    }
-
-    if (auto proto = dyn_cast<ProtocolDecl>(decl)) {
-      auto reqSig = proto->getRequirementSignature();
-
-      SmallVector<Requirement, 2> reqs;
-      SmallVector<InverseRequirement, 2> inverses;
-      reqSig.getRequirementsWithInverses(proto, reqs, inverses);
-      if (containsNonEscapable(inverses))
-        return true;
-    }
-
-    if (isa<AbstractFunctionDecl>(valueDecl) ||
-        isa<AbstractStorageDecl>(valueDecl)) {
-      if (valueDecl->getInterfaceType().findIf([&](Type type) -> bool {
-            if (auto *nominalDecl = type->getAnyNominal()) {
-              if (isa<StructDecl, EnumDecl, ClassDecl>(nominalDecl))
-                return usesFeatureNonescapableTypes(nominalDecl);
-            }
-            return false;
-          })) {
-        return true;
-      }
-    }
-  }
-
-  if (auto *ext = dyn_cast<ExtensionDecl>(decl)) {
-    if (auto *nominal = ext->getExtendedNominal())
-      if (usesFeatureNonescapableTypes(nominal))
-        return true;
-  }
-
-  if (auto *genCtx = decl->getAsGenericContext()) {
-    if (auto genericSig = genCtx->getGenericSignature()) {
-      SmallVector<Requirement, 2> reqs;
-      SmallVector<InverseRequirement, 2> inverseReqs;
-      genericSig->getRequirementsWithInverses(reqs, inverseReqs);
-      if (containsNonEscapable(inverseReqs)) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
 static bool usesFeatureInlineArrayTypeSugar(Decl *D) {
   return usesTypeMatching(D, [&](Type ty) {
     return isa<InlineArrayType>(ty.getPointer());

test/Concurrency/sending_conditional_suppression.swift

@@ -206,8 +206,7 @@ public struct TestInStruct {
 // Make sure that we emit compiler(>= 5.3) when emitting the suppressing check
 // to make sure we do not fail if we fail to parse sending in the if block.
 
-// CHECK: #if compiler(>=5.3) && $NonescapableTypes // Suppression Count: 24
-// CHECK-NEXT: #if compiler(>=5.3) && $SendingArgsAndResults // Suppression Count: 25
+// CHECK: #if compiler(>=5.3) && $SendingArgsAndResults // Suppression Count: 24
 // CHECK-NEXT: @inlinable public func withCheckedContinuation<T>(isolation: isolated (any _Concurrency.Actor)? = #isolation, function: Swift.String = #function, _ body: (_Concurrency.CheckedContinuation<T, Swift.Never>) -> Swift.Void) async -> sending T {
 // CHECK-NEXT:  fatalError()
 // CHECK-NEXT: }
@@ -216,7 +215,6 @@ public struct TestInStruct {
 // CHECK-NEXT:  fatalError()
 // CHECK-NEXT: }
 // CHECK-NEXT: #endif
-// CHECK-NEXT: #endif
 @inlinable public func withCheckedContinuation<T>(
   isolation: isolated (any _Concurrency.Actor)? = #isolation,
   function: String = #function,
@@ -225,14 +223,14 @@ public struct TestInStruct {
   fatalError()
 }
 
-// CHECK-LABEL: #if compiler(>=5.3) && $SendingArgsAndResults // Suppression Count: 26
+// CHECK-LABEL: #if compiler(>=5.3) && $SendingArgsAndResults // Suppression Count: 25
 // CHECK-NEXT: public var publicGlobal: (sending test.NonSendableKlass) -> ()
 // CHECK-NEXT: #else
 // CHECK-NEXT: public var publicGlobal: (__owned test.NonSendableKlass) -> ()
 // CHECK-NEXT: #endif
 public var publicGlobal: (sending NonSendableKlass) -> () = { x in fatalError() }
 
-// CHECK-LABEL: #if compiler(>=5.3) && $SendingArgsAndResults // Suppression Count: 27
+// CHECK-LABEL: #if compiler(>=5.3) && $SendingArgsAndResults // Suppression Count: 26
 // CHECK-NEXT: @usableFromInline
 // CHECK-NEXT: internal var usableFromInlineGlobal: (sending test.NonSendableKlass) -> ()
 // CHECK-NEXT: #else

test/ModuleInterface/lifetime_dependence_test.swift

@@ -40,7 +40,7 @@ import lifetime_dependence
 // Check that an implicitly dependent variable accessor is guarded by LifetimeDependence.
 //
 // CHECK: extension lifetime_dependence.Container {
-// CHECK-NEXT: #if compiler(>=5.3) && $NonescapableTypes && $LifetimeDependence
+// CHECK-NEXT: #if compiler(>=5.3) && $LifetimeDependence
 // CHECK-NEXT:   public var storage: lifetime_dependence.BufferView {
 
 // CHECK-LABEL: extension Swift.UnsafeMutableBufferPointer where Element : ~Copyable {

test/ModuleInterface/lifetime_underscored_dependence_test.swift

@@ -108,5 +108,5 @@ import lifetime_underscored_dependence
 // Check that an implicitly dependent variable accessor is guarded by LifetimeDependence.
 //
 // CHECK: extension lifetime_underscored_dependence.Container {
-// CHECK-NEXT: #if compiler(>=5.3) && $NonescapableTypes && $LifetimeDependence
+// CHECK-NEXT: #if compiler(>=5.3) && $LifetimeDependence
 // CHECK-NEXT:   public var storage: lifetime_underscored_dependence.BufferView {

test/ModuleInterface/noncopyable_generics.swift

@@ -121,9 +121,7 @@ import NoncopyableGenerics_Misc
 // CHECK-MISC: extension {{.*}}.Outer.InnerVariation2 : Swift.Escapable where D : Swift.Escapable, A : ~Copyable {
 
 // CHECK-MISC: extension {{.*}}.Outer.InnerStruct {
-// CHECK-MISC-NEXT: #if compiler(>=5.3) && $NonescapableTypes
 // CHECK-MISC-NEXT:   public func hello<T>(_ t: T) where T : ~Escapable
-// CHECK-MISC-NEXT:   #endif
 
 // CHECK-MISC: @_preInverseGenerics public func old_swap<T>(_ a: inout T, _ b: inout T) where T : ~Copyable
 
@@ -138,19 +136,11 @@ import NoncopyableGenerics_Misc
 // CHECK-MISC-NEXT: public func referToLoudProperGuarding(_ t: {{.*}}.LoudlyNC<Swift.String>)
 // CHECK-MISC-NEXT: public struct NoCopyPls : ~Swift.Copyable {
 // CHECK-MISC-NEXT: }
-// CHECK-MISC-NEXT: #if compiler(>=5.3) && $NonescapableTypes
 // CHECK-MISC-NEXT: public func substCopyable(_ t: Swift.String?)
-// CHECK-MISC-NEXT: #endif
-// CHECK-MISC-NEXT: #if compiler(>=5.3) && $NonescapableTypes
 // CHECK-MISC-NEXT: public func substGenericCopyable<T>(_ t: T?)
-// CHECK-MISC-NEXT: #endif
 
-// CHECK-MISC-NEXT: #if compiler(>=5.3) && $NonescapableTypes
 // CHECK-MISC-NEXT: public func substNC(_ t: borrowing {{.*}}.NoCopyPls?)
-// CHECK-MISC-NEXT: #endif
-// CHECK-MISC-NEXT: #if compiler(>=5.3) && $NonescapableTypes
 // CHECK-MISC-NEXT: public func substGenericNC<T>(_ t: borrowing T?) where T : ~Copyable
-// CHECK-MISC-NEXT: #endif
 
 // CHECK-MISC:      public protocol Publik : ~Copyable {
 // CHECK-MISC-NEXT: }

test/ModuleInterface/nonescapable_types.swift

@@ -5,39 +5,31 @@
 
 // REQUIRES: swift_feature_LifetimeDependence
 
-// CHECK: #if compiler(>=5.3) && $NonescapableTypes
 // CHECK: public protocol P : ~Escapable {
 // CHECK:   associatedtype A
 // CHECK: }
-// CHECK: #endif
 public protocol P: ~Escapable {
   associatedtype A
 }
 
-// CHECK: #if compiler(>=5.3) && $NonescapableTypes
 // CHECK: public struct X<T> : ~Swift.Escapable where T : ~Escapable {
 // CHECK: }
-// CHECK: #endif
 public struct X<T: ~Escapable>: ~Escapable { }
 
-// CHECK: #if compiler(>=5.3) && $NonescapableTypes
 // CHECK:      extension Test.X {
 // CHECK-NEXT:   func f()
 // CHECK:      }
 extension X where T: Escapable {
   public func f() { }
 }
 
-// CHECK: #if compiler(>=5.3) && $NonescapableTypes
 // CHECK: extension Test.X where T : ~Escapable {
 // CHECK:   public func g(other: borrowing T)
 // CHECK: }
-// CHECK: #endif
 extension X where T: ~Escapable {
   public func g(other: borrowing T) { }
 }
 
-// CHECK: #if compiler(>=5.3) && $NonescapableTypes
 // CHECK: public enum Y<T> : ~Swift.Escapable where T : ~Escapable {
 // CHECK:   case none
 // CHECK:   case some(T)
@@ -49,19 +41,15 @@ public enum Y<T: ~Escapable>: ~Escapable {
 
 extension Y: Escapable where T: Escapable { }
 
-// CHECK: #if compiler(>=5.3) && $NonescapableTypes
 // CHECK: @lifetime(copy y)
 // CHECK: public func derive<T>(_ y: Test.Y<T>) -> Test.Y<T> where T : ~Escapable
-// CHECK: #endif
 @lifetime(copy y)
 public func derive<T : ~Escapable>(_ y: Y<T>) -> Y<T> {
   y
 }
 
-// CHECK: #if compiler(>=5.3) && $NonescapableTypes
 // CHECK: @lifetime(copy x)
 // CHECK: public func derive<T>(_ x: Test.X<T>) -> Test.X<T> where T : ~Escapable
-// CHECK: #endif
 @lifetime(copy x)
 public func derive<T : ~Escapable>(_ x: X<T>) -> X<T> {
   x

test/stdlib/OptionalGeneralizations.swift

@@ -16,46 +16,37 @@ func isCopyable<T: ~Escapable>(_: T.Type) -> Bool { true }
 func isBitwiseCopyable<T: ~Copyable & ~Escapable>(_: T.Type) -> Bool { false }
 func isBitwiseCopyable<T: BitwiseCopyable & ~Escapable>(_: T.Type) -> Bool { true }
 
-#if $NonescapableTypes
 func isEscapable<T: ~Escapable & ~Copyable>(_: T.Type) -> Bool { false }
 func isEscapable<T: ~Copyable>(_: T.Type) -> Bool { true }
-#endif
 
 struct TrivialStruct {}
 struct NoncopyableStruct: ~Copyable {}
 class RegularClass {}
 
-#if $NonescapableTypes
 struct NonescapableStruct: ~Escapable, BitwiseCopyable {}
 struct NoncopyableNonescapableStruct: ~Copyable, ~Escapable {}
 struct NonescapableNontrivialStruct: ~Escapable {
   let foo: RegularClass? = nil
 }
-#endif
 
 suite.test("Copyability") {
   expectTrue(isCopyable(Optional<TrivialStruct>.self))
   expectFalse(isCopyable(Optional<NoncopyableStruct>.self))
   expectTrue(isCopyable(Optional<RegularClass>.self))
-#if $NonescapableTypes
   expectTrue(isCopyable(Optional<NonescapableStruct>.self))
   expectFalse(isCopyable(Optional<NoncopyableNonescapableStruct>.self))
   expectTrue(isCopyable(Optional<NonescapableNontrivialStruct>.self))
-#endif
 }
 
 suite.test("BitwiseCopyability") {
   expectTrue(isBitwiseCopyable(Optional<TrivialStruct>.self))
   expectFalse(isBitwiseCopyable(Optional<NoncopyableStruct>.self))
   expectFalse(isBitwiseCopyable(Optional<RegularClass>.self))
-#if $NonescapableTypes
   expectTrue(isBitwiseCopyable(Optional<NonescapableStruct>.self))
   expectFalse(isBitwiseCopyable(Optional<NoncopyableNonescapableStruct>.self))
   expectFalse(isBitwiseCopyable(Optional<NonescapableNontrivialStruct>.self))
-#endif
 }
 
-#if $NonescapableTypes
 suite.test("Escapability") {
   expectTrue(isEscapable(Optional<TrivialStruct>.self))
   expectTrue(isEscapable(Optional<NoncopyableStruct>.self))
@@ -64,7 +55,6 @@ suite.test("Escapability") {
   expectFalse(isEscapable(Optional<NoncopyableNonescapableStruct>.self))
   expectFalse(isEscapable(Optional<NonescapableNontrivialStruct>.self))
 }
-#endif
 
 func apply<T, U>(
   _ input: T,
@@ -97,7 +87,6 @@ suite.test("expectNotNil()") {
   _ = expectNotNil(opt1(TrivialStruct()))
   _ = expectNotNil(opt1(NoncopyableStruct()))
   _ = expectNotNil(opt1(RegularClass()))
-#if $NonescapableTypes
   @_lifetime(copy t)
   func opt2<T: ~Copyable & ~Escapable>(_ t: consuming T) -> T? { t }
 
@@ -109,15 +98,13 @@ suite.test("expectNotNil()") {
 
   let nent = NonescapableNontrivialStruct()
   _ = expectNotNil(opt2(nent))
-#endif // $NonescapableTypes
 }
 
 suite.test("expectNil()") {
   func opt1<T: ~Copyable>(_ t: consuming T) -> T? { nil }
   expectNil(opt1(TrivialStruct()))
   expectNil(opt1(NoncopyableStruct()))
   expectNil(opt1(RegularClass()))
-#if $NonescapableTypes
   @_lifetime(copy t)
   func opt2<T: ~Copyable & ~Escapable>(_ t: consuming T) -> T? { nil }
 
@@ -129,5 +116,4 @@ suite.test("expectNil()") {
 
   let nent = NonescapableNontrivialStruct()
   expectNil(opt2(nent))
-#endif // $NonescapableTypes
 }