Treat @_unavailableInEmbedded like other availability attributes during macro expansion.

This PR adds support for mapping `@_unavailableInEmbedded` to a condition trait
like we do with `@available()` etc.

Author: grynspan

Sources/Testing/Traits/ConditionTrait+Macro.swift

@@ -124,4 +124,28 @@ extension Trait where Self == ConditionTrait {
       sourceLocation: sourceLocation
     )
   }
+
+  /// Create a trait controlling availability of a test based on an
+  /// `@available(*, unavailable)` attribute applied to it.
+  ///
+  /// - Parameters:
+  ///   - message: The `message` parameter of the availability attribute.
+  ///   - sourceLocation: The source location of the test.
+  ///
+  /// - Returns: A trait.
+  ///
+  /// - Warning: This function is used to implement the `@Test` macro. Do not
+  ///   call it directly.
+  public static func __unavailableInEmbedded(sourceLocation: SourceLocation) -> Self {
+#if hasFeature(Embedded)
+    let isEmbedded = true
+#else
+    let isEmbedded = false
+#endif
+    return Self(
+      kind: .unconditional(!isEmbedded),
+      comments: ["Marked @_unavailableInEmbedded"],
+      sourceLocation: sourceLocation
+    )
+  }
 }

Sources/TestingMacros/Support/Additions/WithAttributesSyntaxAdditions.swift

@@ -114,6 +114,17 @@ extension WithAttributesSyntax {
       }.first { $0.attributeNameText == "_unavailableFromAsync" }
   }
 
+  /// The first `@_unavailableInEmbedded` attribute on this instance, if any.
+  var noembeddedAttribute: AttributeSyntax? {
+    availability(when: .noasync).first?.attribute ?? attributes.lazy
+      .compactMap { attribute in
+        if case let .attribute(attribute) = attribute {
+          return attribute
+        }
+        return nil
+      }.first { $0.attributeNameText == "_unavailableInEmbedded" }
+  }
+
   /// Find all attributes on this node, if any, with the given name.
   ///
   /// - Parameters:

Sources/TestingMacros/Support/AvailabilityGuards.swift

@@ -140,6 +140,24 @@ private func _createAvailabilityTraitExpr(
   }
 }
 
+/// Create an expression that contains a test trait for symbols that are
+/// unavailable in Embedded Swift.
+///
+/// - Parameters:
+///   - attribute: The `@_unavailableInEmbedded` attribute.
+///   - context: The macro context in which the expression is being parsed.
+///
+/// - Returns: An instance of `ExprSyntax` representing an instance of
+///   ``Trait`` that can be used to prevent a test from running in Embedded
+///   Swift.
+private func _createNoEmbeddedAvailabilityTraitExpr(
+  from attribute: AttributeSyntax,
+  in context: some MacroExpansionContext
+) -> ExprSyntax {
+  let sourceLocationExpr = createSourceLocationExpr(of: attribute, context: context)
+  return ".__unavailableInEmbedded(sourceLocation: \(sourceLocationExpr))"
+}
+
 /// Create an expression that contains test traits for availability (i.e.
 /// `.enabled(if: ...)`).
 ///
@@ -169,6 +187,10 @@ func createAvailabilityTraitExprs(
     _createAvailabilityTraitExpr(from: availability, when: .obsoleted, in: context)
   }
 
+  if let noembeddedAttribute = decl.noembeddedAttribute {
+    result += [_createNoEmbeddedAvailabilityTraitExpr(from: noembeddedAttribute, in: context)]
+  }
+
   return result
 }
 
@@ -290,5 +312,16 @@ func createSyntaxNode(
     }
   }
 
+  // Handle Embedded Swift.
+  if decl.noembeddedAttribute != nil {
+    result = """
+      #if !hasFeature(Embedded)
+      \(result)
+      #else
+      \(exitStatement)
+      #endif
+      """
+  }
+
   return result
 }

Tests/TestingTests/RunnerTests.swift

@@ -819,6 +819,25 @@ final class RunnerTests: XCTestCase {
     await fulfillment(of: [testStarted], timeout: 0.0)
   }
 
+  @Suite(.hidden) struct UnavailableInEmbeddedTests {
+    @Test(.hidden)
+    @_unavailableInEmbedded
+    func embedded() {}
+  }
+
+  func testUnavailableInEmbeddedAttribute() async throws {
+    let testStarted = expectation(description: "Test started")
+    testStarted.expectedFulfillmentCount = 3
+    var configuration = Configuration()
+    configuration.eventHandler = { event, _ in
+      if case .testStarted = event.kind {
+        testStarted.fulfill()
+      }
+    }
+    await runTest(for: UnavailableInEmbeddedTests.self, configuration: configuration)
+    await fulfillment(of: [testStarted], timeout: 0.0)
+  }
+
 #if !SWT_NO_GLOBAL_ACTORS
   @TaskLocal static var isMainActorIsolationEnforced = false