Adopt lexicalContext from swift-syntax-6.0.0.

This PR conditionally adopts the new `lexicalContext` member of
`MacroExpansionContext` added in swiftlang/swift-syntax#1554.
If the SwiftSyntax600 pseudo-module is available, then this member should be
available for use and can be used to perform additional diagnostics for tests
and to get the names of their containing types.

With this PR, if built against an older toolchain (5.11 or earlier), the old
hacky "is there leading whitespace?" mechanism is still used.

A future PR will recursively perform suite-level diagnostics on the lexical
contexts containing tests and suites, so that a test cannot be (easily) inserted
into a type that cannot be used as a suite.

Resolves rdar://109439578.

Author: grynspan

Sources/TestingMacros/SuiteDeclarationMacro.swift

@@ -21,7 +21,9 @@ public struct SuiteDeclarationMacro: MemberMacro, PeerMacro, Sendable {
     providingMembersOf declaration: some DeclGroupSyntax,
     in context: some MacroExpansionContext
   ) throws -> [DeclSyntax] {
-    _diagnoseIssues(with: declaration, suiteAttribute: node, in: context)
+    guard _diagnoseIssues(with: declaration, suiteAttribute: node, in: context) else {
+      return []
+    }
     return _createTestContainerDecls(for: declaration, suiteAttribute: node, in: context)
   }
 
@@ -33,7 +35,7 @@ public struct SuiteDeclarationMacro: MemberMacro, PeerMacro, Sendable {
     // The peer macro expansion of this macro is only used to diagnose misuses
     // on symbols that are not decl groups.
     if declaration.asProtocol((any DeclGroupSyntax).self) == nil {
-      _diagnoseIssues(with: declaration, suiteAttribute: node, in: context)
+      _ = _diagnoseIssues(with: declaration, suiteAttribute: node, in: context)
     }
     return []
   }
@@ -44,23 +46,31 @@ public struct SuiteDeclarationMacro: MemberMacro, PeerMacro, Sendable {
   ///   - declaration: The type declaration to diagnose.
   ///   - suiteAttribute: The `@Suite` attribute applied to `declaration`.
   ///   - context: The macro context in which the expression is being parsed.
+  ///
+  /// - Returns: Whether or not macro expansion should continue (i.e. stopping
+  ///   if a fatal error was diagnosed.)
   private static func _diagnoseIssues(
     with declaration: some SyntaxProtocol,
     suiteAttribute: AttributeSyntax,
     in context: some MacroExpansionContext
-  ) {
+  ) -> Bool {
     var diagnostics = [DiagnosticMessage]()
     defer {
-      diagnostics.forEach(context.diagnose)
+      context.diagnose(diagnostics)
     }
 
     // The @Suite attribute is only supported on type declarations, all of which
     // are DeclGroupSyntax types.
     guard let declaration = declaration.asProtocol((any DeclGroupSyntax).self) else {
       diagnostics.append(.attributeNotSupported(suiteAttribute, on: declaration))
-      return
+      return false
     }
 
+#if canImport(SwiftSyntax600)
+    // Check if the lexical context is appropriate for a suite or test.
+    diagnostics += diagnoseIssuesWithLexicalContext(containing: declaration, attribute: suiteAttribute, in: context)
+#endif
+
     // Generic suites are not supported.
     if let genericClause = declaration.asProtocol((any WithGenericParametersSyntax).self)?.genericParameterClause {
       diagnostics.append(.genericDeclarationNotSupported(declaration, whenUsing: suiteAttribute, becauseOf: genericClause))
@@ -115,6 +125,8 @@ public struct SuiteDeclarationMacro: MemberMacro, PeerMacro, Sendable {
         diagnostics.append(.availabilityAttributeNotSupported(noasyncAttribute, on: declaration, whenUsing: suiteAttribute))
       }
     }
+
+    return !diagnostics.lazy.map(\.severity).contains(.error)
   }
 
   /// Create a declaration for a type that conforms to the `__TestContainer`

Sources/TestingMacros/Support/Additions/FunctionDeclSyntaxAdditions.swift

@@ -94,9 +94,17 @@ extension FunctionDeclSyntax {
       if signature.effectSpecifiers?.asyncSpecifier != nil {
         selector += "WithCompletionHandler"
         colonToken = .colonToken()
-      } else if signature.effectSpecifiers?.throwsSpecifier != nil {
-        selector += "AndReturnError"
-        colonToken = .colonToken()
+      } else {
+        let hasThrowsSpecifier: Bool
+#if canImport(SwiftSyntax600)
+        hasThrowsSpecifier = signature.effectSpecifiers?.throwsClause != nil
+#else
+        hasThrowsSpecifier = signature.effectSpecifiers?.throwsSpecifier != nil
+#endif
+        if hasThrowsSpecifier {
+          selector += "AndReturnError"
+          colonToken = .colonToken()
+        }
       }
       return ObjCSelectorPieceListSyntax {
         ObjCSelectorPieceSyntax(name: .identifier(selector), colon: colonToken)

Sources/TestingMacros/Support/TagConstraints.swift renamed to Sources/TestingMacros/Support/DiagnosticMessage+Diagnosing.swift

@@ -87,3 +87,24 @@ func diagnoseIssuesWithTags(in traitExprs: [ExprSyntax], addedTo attribute: Attr
     }
   }
 }
+
+#if canImport(SwiftSyntax600)
+/// Diagnose issues with the lexical context containing a declaration.
+///
+/// - Parameters:
+///   - decl: The declaration to inspect.
+///   - testAttribute: The `@Test` attribute applied to `decl`.
+///   - context: The macro context in which the expression is being parsed.
+///
+/// - Returns: An array of zero or more diagnostic messages related to the
+///   lexical context containing `decl`.
+func diagnoseIssuesWithLexicalContext(
+  containing decl: some DeclSyntaxProtocol,
+  attribute: AttributeSyntax,
+  in context: some MacroExpansionContext
+) -> [DiagnosticMessage] {
+  context.lexicalContext
+    .filter { !$0.isProtocol((any DeclGroupSyntax).self) }
+    .map { .containingNodeUnsupported($0, whenUsing: attribute) }
+}
+#endif

Sources/TestingMacros/Support/DiagnosticMessage.swift

@@ -225,6 +225,27 @@ struct DiagnosticMessage: SwiftDiagnostics.DiagnosticMessage {
     )
   }
 
+#if canImport(SwiftSyntax600)
+  /// Create a diagnostic message stating that the given attribute cannot be
+  /// used within a lexical context.
+  ///
+  /// - Parameters:
+  ///   - node: The lexical context preventing the use of `attribute`.
+  ///   - attribute: The `@Test` or `@Suite` attribute.
+  ///
+  /// - Returns: A diagnostic message.
+  static func containingNodeUnsupported(_ node: some SyntaxProtocol, whenUsing attribute: AttributeSyntax) -> Self {
+    // It would be great if the diagnostic pointed to the containing lexical
+    // context that was unsupported, but that node may be synthesized and does
+    // not have reliable location information.
+    Self(
+      syntax: Syntax(attribute),
+      message: "The @\(attribute.attributeNameText) attribute cannot be applied within \(_kindString(for: node, includeA: true)).",
+      severity: .error
+    )
+  }
+#endif
+
   /// Create a diagnostic message stating that the given attribute has no effect
   /// when applied to the given extension declaration.
   ///
@@ -406,7 +427,6 @@ extension MacroExpansionContext {
   ///   - message: The diagnostic message to emit. The `node` and `position`
   ///     arguments to `Diagnostic.init()` are derived from the message's
   ///     `syntax` property.
-  ///   - fixIts: Any Fix-Its to apply.
   func diagnose(_ message: DiagnosticMessage) {
     diagnose(
       Diagnostic(
@@ -418,6 +438,16 @@ extension MacroExpansionContext {
     )
   }
 
+  /// Emit a sequence of diagnostic messages.
+  ///
+  /// - Parameters:
+  ///   - messages: The diagnostic messages to emit.
+  func diagnose(_ messages: some Sequence<DiagnosticMessage>) {
+    for message in messages {
+      diagnose(message)
+    }
+  }
+
   /// Emit a diagnostic message for debugging purposes during development of the
   /// testing library.
   ///

Sources/TestingMacros/TestDeclarationMacro.swift

@@ -21,7 +21,9 @@ public struct TestDeclarationMacro: PeerMacro, Sendable {
     providingPeersOf declaration: some DeclSyntaxProtocol,
     in context: some MacroExpansionContext
   ) throws -> [DeclSyntax] {
-    _diagnoseIssues(with: declaration, testAttribute: node, in: context)
+    guard _diagnoseIssues(with: declaration, testAttribute: node, in: context) else {
+      return []
+    }
 
     guard let function = declaration.as(FunctionDeclSyntax.self) else {
       return []
@@ -45,6 +47,17 @@ public struct TestDeclarationMacro: PeerMacro, Sendable {
     testAttribute: AttributeSyntax,
     in context: some MacroExpansionContext
   ) -> TypeSyntax? {
+#if canImport(SwiftSyntax600)
+    let types = context.lexicalContext
+      .compactMap { $0.asProtocol((any DeclGroupSyntax).self) }
+      .map(\.type)
+      .reversed()
+    if types.isEmpty {
+      return nil
+    }
+    let typeName = types.map(\.trimmedDescription).joined(separator: ".")
+    return "\(raw: typeName)"
+#else
     // Find the beginning of the first attribute on the declaration, including
     // those embedded in #if statements, to account for patterns like
     // `@MainActor @Test func` where there's a space ahead of @Test, but the
@@ -79,6 +92,7 @@ public struct TestDeclarationMacro: PeerMacro, Sendable {
       return TypeSyntax(IdentifierTypeSyntax(name: .keyword(.Self)))
     }
     return nil
+#endif
   }
 
   /// Diagnose issues with a `@Test` declaration.
@@ -87,22 +101,30 @@ public struct TestDeclarationMacro: PeerMacro, Sendable {
   ///   - declaration: The function declaration to diagnose.
   ///   - testAttribute: The `@Test` attribute applied to `declaration`.
   ///   - context: The macro context in which the expression is being parsed.
+  ///
+  /// - Returns: Whether or not macro expansion should continue (i.e. stopping
+  ///   if a fatal error was diagnosed.)
   private static func _diagnoseIssues(
     with declaration: some DeclSyntaxProtocol,
     testAttribute: AttributeSyntax,
     in context: some MacroExpansionContext
-  ) {
+  ) -> Bool {
     var diagnostics = [DiagnosticMessage]()
     defer {
-      diagnostics.forEach(context.diagnose)
+      context.diagnose(diagnostics)
     }
 
     // The @Test attribute is only supported on function declarations.
     guard let function = declaration.as(FunctionDeclSyntax.self) else {
       diagnostics.append(.attributeNotSupported(testAttribute, on: declaration))
-      return
+      return false
     }
 
+#if canImport(SwiftSyntax600)
+    // Check if the lexical context is appropriate for a suite or test.
+    diagnostics += diagnoseIssuesWithLexicalContext(containing: declaration, attribute: testAttribute, in: context)
+#endif
+
     // Only one @Test attribute is supported.
     let suiteAttributes = function.attributes(named: "Test", in: context)
     if suiteAttributes.count > 1 {
@@ -144,6 +166,8 @@ public struct TestDeclarationMacro: PeerMacro, Sendable {
         }
       }
     }
+
+    return !diagnostics.lazy.map(\.severity).contains(.error)
   }
 
   /// Create a function call parameter list used to call a function from its
@@ -406,6 +430,11 @@ public struct TestDeclarationMacro: PeerMacro, Sendable {
   ) -> [DeclSyntax] {
     var result = [DeclSyntax]()
 
+#if canImport(SwiftSyntax600)
+    // Get the name of the type containing the function for passing to the test
+    // factory function later.
+    let typealiasExpr: ExprSyntax = typeName.map { "\($0).self" } ?? "nil"
+#else
     // We cannot directly refer to Self here because it will end up being
     // resolved as the __TestContainer type we generate. Create a uniquely-named
     // reference to Self outside the context of the generated type, and use it
@@ -415,7 +444,7 @@ public struct TestDeclarationMacro: PeerMacro, Sendable {
     // inside a static computed property instead of a typealias (where covariant
     // Self is disallowed.)
     //
-    // This "typealias" will not be necessary when rdar://105470382 is resolved.
+    // This "typealias" is not necessary when swift-syntax-6.0.0 is available.
     var typealiasExpr: ExprSyntax = "nil"
     if let typeName {
       let typealiasName = context.makeUniqueName(thunking: functionDecl)
@@ -430,6 +459,7 @@ public struct TestDeclarationMacro: PeerMacro, Sendable {
 
       typealiasExpr = "\(typealiasName)"
     }
+#endif
 
     // Parse the @Test attribute.
     let attributeInfo = AttributeInfo(byParsing: testAttribute, on: functionDecl, in: context)

Tests/TestingMacrosTests/TestDeclarationMacroTests.swift

@@ -67,7 +67,6 @@ struct TestDeclarationMacroTests {
       "@Test enum E {}":
         "Attribute 'Test' cannot be applied to an enumeration",
 
-
       // Availability
       "@available(*, unavailable) @Suite struct S {}":
         "Attribute 'Suite' cannot be applied to this structure because it has been marked '@available(*, unavailable)'",
@@ -117,6 +116,26 @@ struct TestDeclarationMacroTests {
     }
   }
 
+#if canImport(SwiftSyntax600)
+  @Test("Error diagnostics emitted for invalid lexical contexts",
+    arguments: [
+      "struct S { func f() { @Test func f() {} } }":
+        "The @Test attribute cannot be applied within a function.",
+      "struct S { func f() { @Suite struct S { } } }":
+        "The @Suite attribute cannot be applied within a function.",
+    ]
+  )
+  func invalidLexicalContext(input: String, expectedMessage: String) throws {
+    let (_, diagnostics) = try parse(input)
+
+    #expect(diagnostics.count > 0)
+    for diagnostic in diagnostics {
+      #expect(diagnostic.diagMessage.severity == .error)
+      #expect(diagnostic.message == expectedMessage)
+    }
+  }
+#endif
+
   @Test("Warning diagnostics emitted on API misuse",
     arguments: [
       // return types
@@ -189,13 +208,9 @@ struct TestDeclarationMacroTests {
     }
   }
 
-  @Test("Different kinds of functions are handled correctly",
-    arguments: [
+  static var functionTypeInputs: [(String, String?, String?)] {
+    var result: [(String, String?, String?)] = [
       ("@Test func f() {}", nil, nil),
-      ("struct S {\n\t@Test func f() {} }", "Self", "let"),
-      ("struct S {\n\t@Test mutating func f() {} }", "Self", "var"),
-      ("struct S {\n\t@Test static func f() {} }", "Self", nil),
-      ("final class S {\n\t@Test class func f() {} }", "Self", nil),
       ("@Test @available(*, noasync) @MainActor func f() {}", nil, "MainActor.run"),
       ("@Test @_unavailableFromAsync @MainActor func f() {}", nil, "MainActor.run"),
       ("@Test @available(*, noasync) func f() {}", nil, "__requiringTry"),
@@ -220,7 +235,27 @@ struct TestDeclarationMacroTests {
         nil
       ),
     ]
-  )
+
+#if canImport(SwiftSyntax600)
+    result += [
+      ("struct S_NAME {\n\t@Test func f() {} }", "S_NAME", "let"),
+      ("struct S_NAME {\n\t@Test mutating func f() {} }", "S_NAME", "var"),
+      ("struct S_NAME {\n\t@Test static func f() {} }", "S_NAME", nil),
+      ("final class C_NAME {\n\t@Test class func f() {} }", "C_NAME", nil),
+    ]
+#else
+    result += [
+      ("struct S {\n\t@Test func f() {} }", "Self", "let"),
+      ("struct S {\n\t@Test mutating func f() {} }", "Self", "var"),
+      ("struct S {\n\t@Test static func f() {} }", "Self", nil),
+      ("final class C {\n\t@Test class func f() {} }", "Self", nil),
+    ]
+#endif
+
+    return result
+  }
+
+  @Test("Different kinds of functions are handled correctly", arguments: functionTypeInputs)
   func differentFunctionTypes(input: String, expectedTypeName: String?, otherCode: String?) throws {
     let (output, _) = try parse(input)
 

Tests/TestingMacrosTests/TestSupport/Parse.swift

@@ -35,8 +35,17 @@ func parse(_ sourceCode: String, activeMacros activeMacroNames: [String] = [], r
   }
   let operatorTable = OperatorTable.standardOperators
   let originalSyntax = try operatorTable.foldAll(Parser.parse(source: sourceCode))
+#if canImport(SwiftSyntax600)
+  let context = BasicMacroExpansionContext(lexicalContext: [], expansionDiscriminator: "", sourceFiles: [:])
+  let syntax = try operatorTable.foldAll(
+    originalSyntax.expand(macros: activeMacros) { syntax in
+      BasicMacroExpansionContext(sharingWith: context, lexicalContext: syntax.allMacroLexicalContexts())
+    }
+  )
+#else
   let context = BasicMacroExpansionContext(expansionDiscriminator: "", sourceFiles: [:])
   let syntax = try operatorTable.foldAll(originalSyntax.expand(macros: activeMacros, in: context))
+#endif
   var sourceCode = String(describing: syntax.formatted().trimmed)
   if removeWhitespace {
     sourceCode = sourceCode.filter { !$0.isWhitespace }