Refactor a bit and add a unit test

Author: grynspan

Sources/TestingMacros/PragmaMacro.swift

@@ -34,3 +34,46 @@ public struct PragmaMacro: PeerMacro, Sendable {
     .disabled
   }
 }
+
+/// Get all pragma attributes (`@__testing`) associated with a syntax node.
+///
+/// - Parameters:
+///   - node: The syntax node to inspect.
+///
+/// - Returns: The set of pragma attributes strings associated with `node`.
+///
+/// Attributes conditionally applied with `#if` are ignored.
+func pragmas(on node: some WithAttributesSyntax) -> [AttributeSyntax] {
+  node.attributes
+    .compactMap { attribute in
+      if case let .attribute(attribute) = attribute {
+        return attribute
+      }
+      return nil
+    }.filter { attribute in
+      attribute.attributeNameText == "__testing"
+    }
+}
+
+/// Get all "semantics" attributed to a syntax node using the
+/// `@__testing(semantics:)` attribute.
+///
+/// - Parameters:
+///   - node: The syntax node to inspect.
+///
+/// - Returns: The set of "semantics" strings associated with `node`.
+///
+/// Attributes conditionally applied with `#if` are ignored.
+func semantics(of node: some WithAttributesSyntax) -> [String] {
+  pragmas(on: node)
+    .compactMap { attribute in
+      if case let .argumentList(arguments) = attribute.arguments {
+        return arguments
+      }
+      return nil
+    }.filter { arguments in
+      arguments.first?.label?.textWithoutBackticks == "semantics"
+    }.flatMap { argument in
+      argument.compactMap { $0.expression.as(StringLiteralExprSyntax.self)?.representedLiteralValue }
+    }
+}

Sources/TestingMacros/Support/Additions/MacroExpansionContextAdditions.swift

@@ -91,25 +91,13 @@ extension MacroExpansionContext {
   ///   testing library. It may be modified or removed in a future update.
   var areWarningsSuppressed: Bool {
 #if DEBUG
-    for lexicalContext in self.lexicalContext {
-      guard let lexicalContext = lexicalContext.asProtocol((any WithAttributesSyntax).self) else {
-        continue
-      }
-      for attribute in lexicalContext.attributes {
-        if case let .attribute(attribute) = attribute,
-           attribute.attributeNameText == "__testing",
-           case let .argumentList(arguments) = attribute.arguments {
-          return arguments.contains { argument in
-            guard let argument = arguments.first?.expression.as(StringLiteralExprSyntax.self) else {
-              return false
-            }
-            return argument.representedLiteralValue == "nomacrowarnings"
-          }
-        }
-      }
-    }
-#endif
+    return lexicalContext
+      .compactMap { $0.asProtocol((any WithAttributesSyntax).self) }
+      .flatMap { semantics(of: $0) }
+      .contains("nomacrowarnings")
+#else
     return false
+#endif
   }
 
   /// Emit a diagnostic message.

Tests/TestingMacrosTests/PragmaMacroTests.swift

@@ -0,0 +1,29 @@
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 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 Swift project authors
+//
+
+import Testing
+@testable import TestingMacros
+
+import SwiftParser
+import SwiftSyntax
+
+@Suite("PragmaMacro Tests")
+struct PragmaMacroTests {
+  @Test func findSemantics() throws {
+    let node = """
+      @__testing(semantics: "abc123")
+      @__testing(semantics: "def456")
+      let x = 0
+    """ as DeclSyntax
+    let nodeWithAttributes = try #require(node.asProtocol((any WithAttributesSyntax).self))
+    let semantics = semantics(of: nodeWithAttributes)
+    #expect(semantics == ["abc123", "def456"])
+  }
+}