ModuleInterface: Use --implicit-check-not in features.swift test.

Author: tshortli

test/ModuleInterface/features.swift

@@ -2,14 +2,24 @@
 
 // RUN: %target-swift-emit-module-interface(%t/FeatureTest.swiftinterface) %s -module-name FeatureTest -disable-availability-checking
 // RUN: %target-swift-typecheck-module-from-interface(%t/FeatureTest.swiftinterface) -module-name FeatureTest -disable-availability-checking
-// RUN: %FileCheck %s < %t/FeatureTest.swiftinterface
+// RUN: %FileCheck %s \
+// RUN:   --implicit-check-not "\$AsyncAwait" \
+// RUN:   --implicit-check-not "\$Actors" \
+// RUN:   --implicit-check-not "\$MarkerProtocol" \
+// RUN:   --implicit-check-not "\$Sendable" \
+// RUN:   --implicit-check-not "\$InheritActorContext" \
+// RUN:   < %t/FeatureTest.swiftinterface
 
 // REQUIRES: concurrency
 
 // Ensure that when we emit a Swift interface that makes use of new features,
 // the uses of those features are guarded by appropriate #if's that allow older
 // compilers to skip over the uses of newer features.
 
+// Some feature gaurds are retired when the first compiler that supports the
+// feature is old enough. The --implicit-check-not arguments to FileCheck above
+// verify that those guards no longer pollute the emitted interface.
+
 // CHECK: #if compiler(>=5.3) && $SpecializeAttributeWithAvailability
 // CHECK: @_specialize(exported: true, kind: full, availability: macOS, introduced: 12; where T == Swift.Int)
 // CHECK: public func specializeWithAvailability<T>(_ t: T)
@@ -20,7 +30,6 @@
 public func specializeWithAvailability<T>(_ t: T) {
 }
 
-// CHECK-NOT: #if compiler(>=5.3) && $Actors
 // CHECK:      public actor MyActor
 // CHECK:        @_semantics("defaultActor") nonisolated final public var unownedExecutor: _Concurrency.UnownedSerialExecutor {
 // CHECK-NEXT:     get
@@ -29,16 +38,13 @@ public func specializeWithAvailability<T>(_ t: T) {
 public actor MyActor {
 }
 
-// CHECK-NOT: #if compiler(>=5.3) && $Actors
 // CHECK:     extension FeatureTest.MyActor
 public extension MyActor {
-  // CHECK-NOT: $Actors
   // CHECK:     testFunc
   func testFunc() async { }
   // CHECK: }
 }
 
-// CHECK-NOT: #if compiler(>=5.3) && $AsyncAwait
 // CHECK:     globalAsync
 public func globalAsync() async { }
 
@@ -50,7 +56,6 @@ public func globalAsync() async { }
 // CHECK-NEXT: }
 @_marker public protocol MP2: MP { }
 
-// CHECK-NOT: #if compiler(>=5.3) && $MarkerProtocol
 // CHECK:      public protocol MP3 : AnyObject, FeatureTest.MP {
 // CHECK-NEXT: }
 public protocol MP3: AnyObject, MP { }
@@ -63,14 +68,12 @@ extension MP2 {
 
 // CHECK: class OldSchool : FeatureTest.MP {
 public class OldSchool: MP {
-  // CHECK-NOT: #if compiler(>=5.3) && $AsyncAwait
   // CHECK:     takeClass()
   public func takeClass() async { }
 }
 
 // CHECK: class OldSchool2 : FeatureTest.MP {
 public class OldSchool2: MP {
-  // CHECK-NOT: #if compiler(>=5.3) && $AsyncAwait
   // CHECK:     takeClass()
   public func takeClass() async { }
 }
@@ -110,41 +113,32 @@ public struct IsRP: RP {
 // CHECK-NEXT: public func acceptsRP
 public func acceptsRP<T: RP>(_: T) { }
 
-// CHECK-NOT: #if compiler(>=5.3) && $MarkerProtocol
 // CHECK:     extension Swift.Array : FeatureTest.MP where Element : FeatureTest.MP {
 extension Array: FeatureTest.MP where Element : FeatureTest.MP { }
 // CHECK: }
 
-// CHECK-NOT: #if compiler(>=5.3) && $MarkerProtocol
 // CHECK:     extension FeatureTest.OldSchool : Swift.UnsafeSendable {
 extension OldSchool: UnsafeSendable { }
 // CHECK-NEXT: }
 
 
-// CHECK-NOT: #if compiler(>=5.3) && $AsyncAwait
 // CHECK:     func runSomethingSomewhere
 public func runSomethingSomewhere(body: () async -> Void) { }
 
-// CHECK-NOT: #if compiler(>=5.3) && $Sendable
-// CHECK:     func runSomethingConcurrently(body: @Sendable () -> 
+// CHECK:     func runSomethingConcurrently(body: @Sendable () ->
 public func runSomethingConcurrently(body: @Sendable () -> Void) { }
 
-// CHECK-NOT: #if compiler(>=5.3) && $Actors
 // CHECK:     func stage
 public func stage(with actor: MyActor) { }
 
-// CHECK-NOT: #if compiler(>=5.3) && $AsyncAwait && $Sendable && $InheritActorContext
 // CHECK:     func asyncIsh
 public func asyncIsh(@_inheritActorContext operation: @Sendable @escaping () async -> Void) { }
 
-// CHECK-NOT: #if compiler(>=5.3) && $AsyncAwait
 // CHECK:     #if compiler(>=5.3) && $UnsafeInheritExecutor
 // CHECK:     @_unsafeInheritExecutor public func unsafeInheritExecutor() async
 @_unsafeInheritExecutor
 public func unsafeInheritExecutor() async {}
 
-// CHECK-NOT: #if compiler(>=5.3) && $AsyncAwait
-// CHECK-NOT: #if $UnsafeInheritExecutor
 // CHECK:     #elseif compiler(>=5.3) && $SpecializeAttributeWithAvailability
 // CHECK:     @_specialize{{.*}}
 // CHECK:     public func multipleSuppressible<T>(value: T) async