Prevent adding tests to extensions to generic types. (#337)

When a test is added to a type extension, we can't see any information
about the type being extended, so we cannot report invalid lexical
contexts such as protocols or non-final classes.

One of the invalid cases is a generic type, because swift-testing does
not know how to realize the type—what generic arguments is it supposed
to pass?

This PR causes the compiler to emit a diagnostic when a generic type
contains a test or suite. **How does it work?**, you ask? Generic types
do not support static stored properties, while non-static types _do_
support them. So we just add a static stored property (of type `Void`,
because the value is unimportant.) In a non-generic type, it will "just
work." In a generic type, a diagnostic is emitted:

> 🛑 Static stored properties not supported in generic types

The diagnostic is non-optimal (it's not fine-tuned for swift-testing)
but it prevents building an invalid test that can't be resolved at
runtime, so it's better than nothing.

This change works with swift-syntax-600 _and_ swift-syntax-510.

### Checklist:

- [x] Code and documentation should follow the style of the [Style
Guide](https://github.com/apple/swift-testing/blob/main/Documentation/StyleGuide.md).
- [x] If public symbols are renamed or modified, DocC references should
be updated.

Author: grynspan

Sources/TestingMacros/SuiteDeclarationMacro.swift

@@ -113,6 +113,10 @@ public struct SuiteDeclarationMacro: MemberMacro, PeerMacro, Sendable {
       return []
     }
 
+    if let genericGuardDecl = makeGenericGuardDecl(guardingAgainst: declaration, in: context) {
+      result.append(genericGuardDecl)
+    }
+
     // Parse the @Suite attribute.
     let attributeInfo = AttributeInfo(byParsing: suiteAttribute, on: declaration, in: context)
 

Sources/TestingMacros/Support/DiagnosticMessage+Diagnosing.swift

@@ -173,9 +173,9 @@ func diagnoseIssuesWithLexicalContext(
 /// Diagnose issues with the lexical context containing a declaration.
 ///
 /// - Parameters:
+///   - lexicalContext: The lexical context to inspect.
 ///   - decl: The declaration to inspect.
 ///   - attribute: The `@Test` or `@Suite` 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`.
@@ -189,3 +189,40 @@ func diagnoseIssuesWithLexicalContext(
     .reduce(into: [], +=)
 }
 #endif
+
+/// Create a declaration that prevents compilation if it is generic.
+///
+/// - Parameters:
+///   - decl: The declaration that should not be generic.
+///   - context: The macro context in which the expression is being parsed.
+///
+/// - Returns: A declaration that will fail to compile if `decl` is generic. The
+///   result declares a static member that should be added to the type
+///   containing `decl`. If `decl` is known not to be contained within a type
+///   extension, the result is `nil`.
+///
+/// This function disables the use of tests and suites inside extensions to
+/// generic types by adding a static property declaration (which generic types
+/// do not support.) This produces a compile-time error (not the perfect
+/// diagnostic to emit, but better than building successfully and failing
+/// silently at runtime.) ([126018850](rdar://126018850))
+func makeGenericGuardDecl(
+  guardingAgainst decl: some DeclSyntaxProtocol,
+  in context: some MacroExpansionContext
+) -> DeclSyntax? {
+#if canImport(SwiftSyntax600)
+  guard context.lexicalContext.lazy.map(\.kind).contains(.extensionDecl) else {
+    // Don't bother emitting a member if the declaration is not in an extension
+    // because we'll already be able to emit a better error.
+    return nil
+  }
+#endif
+  let genericGuardName = if let functionDecl = decl.as(FunctionDeclSyntax.self) {
+    context.makeUniqueName(thunking: functionDecl)
+  } else {
+    context.makeUniqueName("")
+  }
+  return """
+  private static let \(genericGuardName): Void = ()
+  """
+}

Sources/TestingMacros/TestDeclarationMacro.swift

@@ -426,6 +426,10 @@ public struct TestDeclarationMacro: PeerMacro, Sendable {
     }
 #endif
 
+    if typeName != nil, let genericGuardDecl = makeGenericGuardDecl(guardingAgainst: functionDecl, in: context) {
+      result.append(genericGuardDecl)
+    }
+
     // Parse the @Test attribute.
     let attributeInfo = AttributeInfo(byParsing: testAttribute, on: functionDecl, in: context)
     if attributeInfo.hasFunctionArguments != !functionDecl.signature.parameterClause.parameters.isEmpty {