Constrain the DeclReferenceExprSyntax special case a bit

Sources/TestingMacros/Support/ConditionArgumentParsing.swift

@@ -321,10 +321,20 @@ private final class _ContextInserter<C, M>: SyntaxRewriter where C: MacroExpansi
     //
     // These sorts of expressions are relatively rare, so we'll allow the bug
     // for the sake of better diagnostics in the common case.
-    if let memberAccessExpr = node.parent?.as(MemberAccessExprSyntax.self),
+    if node.argumentNames == nil,
+       let memberAccessExpr = node.parent?.as(MemberAccessExprSyntax.self),
        ExprSyntax(node) == memberAccessExpr.base,
        let functionCallExpr = memberAccessExpr.parent?.as(FunctionCallExprSyntax.self),
        ExprSyntax(memberAccessExpr) == functionCallExpr.calledExpression {
+      // If the base name is an identifier and its first character is uppercase,
+      // it is presumably a type name or module name, so don't expand it. (This
+      // isn't a great heuristic, but it hopefully minimizes the module name
+      // problem above.)
+      if case .identifier = node.baseName.tokenKind,
+         let firstCharacter = node.baseName.textWithoutBackticks.first, firstCharacter.isUppercase {
+        return ExprSyntax(node)
+      }
+
       return _rewrite(
         MemberAccessExprSyntax(
           base: node.trimmed,

Tests/TestingTests/Support/CartesianProductTests.swift

@@ -31,9 +31,8 @@ struct CartesianProductTests {
     // Test the size of the product is correct.
     let (c1, c2, product) = computeCartesianProduct()
     #expect(product.underestimatedCount == c1.underestimatedCount * c2.underestimatedCount)
-    let productCount = Array(product).count
-    #expect(productCount == c1.count * c2.count)
-    #expect(productCount == 26 * 100)
+    #expect(Array(product).count == c1.count * c2.count)
+    #expect(Array(product).count == 26 * 100)
   }
 
   @Test("First element is correct")
@@ -59,9 +58,8 @@ struct CartesianProductTests {
 
     // NOTE: we need to break out the tuple elements because tuples aren't
     // directly equatable.
-    let productArray = Array(product)
-    #expect(productArray.map(\.0) == possibleValues.map(\.0))
-    #expect(productArray.map(\.1) == possibleValues.map(\.1))
+    #expect(Array(product).map(\.0) == possibleValues.map(\.0))
+    #expect(Array(product).map(\.1) == possibleValues.map(\.1))
   }
 
   @Test("Cartesian product with empty first input is empty")