Feat: Add predicate-based Subject and sugar syntax

[MathieuTricoire]

Motivation

When using ConditionalInterceptor.Subject it's currently only possible to target .all, .services, or .methods.
This makes it difficult to express common cases like "apply this interceptor to all methods except a small set" without manually listing every included method or service. For example applying authentication everywhere except health check and authentication services.

Modifications

• Refactored the internal representation of ConditionalInterceptor.Subject to store a single predicate closure instead of an enum of cases.
  This simplifies the matching mechanism: every variant is now expressed as a predicate over MethodDescriptor.
• Re-implemented existing subjects (.all, .services, .methods) as convenience "sugar" static functions that construct the appropriate predicate.
• Added new subjects:
  • .only(services:methods:) — applies only to the given services and/or methods.
  • .allExcluding(services:methods:) — applies to all except the given services and/or methods.
  • .allMatching(_:) — applies to all methods satisfying a user-provided predicate.

Result

Users can now express inclusion/exclusion rules more naturally:

.apply(requestCounterInterceptor, to: .only(services: countedServices, methods: countedMethods))
.apply(credentialsInterceptor, to: .allExcluding(services: [CredentialsService.descriptor], methods: []))
.apply(specialInterceptor, to: .allMatching { $0.method == "special" })

Fixes #14

[MathieuTricoire]

Should I add something like @available(*, introduced: 2.2) to the new ConditionalInterceptor.Subject static functions?
Should I set the ServiceDescriptor extension in Tests/GRPCCoreTests/Call/ConditionalInterceptorTests.swift only available for 2.2?

[glbrntt]

I left a couple of small notes but otherwise this looks great.

[glbrntt]

You can use trailing closure syntax here (and in other places):

Suggested change

	Self(predicate: { descriptor in
	services.contains(descriptor.service)
	})
	Self { descriptor in
	services.contains(descriptor.service)
	}

[glbrntt]

The Swift API Design Guidelines recommend naming closure parameters:

Suggested change

	_ predicate: @Sendable @escaping (MethodDescriptor) -> Bool
	_ predicate: @Sendable @escaping (_ descriptor: MethodDescriptor) -> Bool

This is nice because tooling can take advantage of it to suggest the parameter name.

[glbrntt]

Nice note 👍

[glbrntt]

Can you annotate this with @available(gRPCSwift 2.2, *)?

[glbrntt]

Can you annotate this with @available(gRPCSwift 2.2, *)?

[MathieuTricoire]

I updated the PR Result section, the correct API for .allExcluding is:

.apply(credentialsInterceptor, to: .allExcluding(services: [CredentialsService.descriptor], methods: []))

[glbrntt]

Looks great, thanks very much @MathieuTricoire!

[MathieuTricoire]

There was an issue in CI: https://github.com/grpc/grpc-swift-2/actions/runs/17046668344/job/48324929547
I don't really understand why, seems related to closure in @Test? I took the opportunity to change syntax for something more idiomatic. I'll see if I can have a look at it tomorrow.

[glbrntt]

There was an issue in CI: https://github.com/grpc/grpc-swift-2/actions/runs/17046668344/job/48324929547 I don't really understand why, seems related to closure in @Test? I took the opportunity to change syntax for something more idiomatic. I'll see if I can have a look at it tomorrow.

Agh, Swift 6.0 only. I'd try adding type annotations to the closure to see if that helps.

[glbrntt]

Give it's fine on 6.1+ and newer, I think it's fine in this instance to compile out that test case on Swift 6.0:

Suggested change

	),
	(
	.allMatching { (_ descriptor: MethodDescriptor) -> Bool in
	descriptor.method == "baz"
	},
	[.fooBaz, .barBaz],
	[.fooBar, .barFoo]
	),
	] as [(ConditionalInterceptor<any Sendable>.Subject, [MethodDescriptor], [MethodDescriptor])]
	),
	#if compiler(>=6.1)
	(
	.allMatching { (_ descriptor: MethodDescriptor) -> Bool in
	descriptor.method == "baz"
	},
	[.fooBaz, .barBaz],
	[.fooBar, .barFoo]
	),
	#endif
	] as [(ConditionalInterceptor<any Sendable>.Subject, [MethodDescriptor], [MethodDescriptor])]

[MathieuTricoire]

What do you think about moving the allMatching case into its own test? (As it seems the issue is about the closure in @Test)

It also made me notice that the current test is annotated with @available(gRPCSwift 2.0, *) while the new subjects are available from 2.2. I wouldn’t expect that to be the cause of the error, but it does feel odd to test 2.2 APIs inside a test marked 2.0? Or are we ok with that?

Proposal: split the tests by availability, like this (Let me know how you would name the functions and tests):

@Suite("ConditionalInterceptor")
struct ConditionalInterceptorTests {
  @Test(
    "Applies to all, services and methods",
    arguments: [
      (
        .all,
        [.fooBar, .fooBaz, .barFoo, .barBaz],
        []
      ),
      (
        .services([ServiceDescriptor(package: "pkg", service: "foo")]),
        [.fooBar, .fooBaz],
        [.barFoo, .barBaz]
      ),
      (
        .methods([.barFoo]),
        [.barFoo],
        [.fooBar, .fooBaz, .barBaz]
      ),
    ] as [(ConditionalInterceptor<any Sendable>.Subject, [MethodDescriptor], [MethodDescriptor])]
  )
  @available(gRPCSwift 2.0, *)
  func appliesTo(
    target: ConditionalInterceptor<any Sendable>.Subject,
    applicableMethods: [MethodDescriptor],
    notApplicableMethods: [MethodDescriptor]
  ) {
    for applicableMethod in applicableMethods {
      #expect(target.applies(to: applicableMethod))
    }

    for notApplicableMethod in notApplicableMethods {
      #expect(!target.applies(to: notApplicableMethod))
    }
  }

  @Test(
    "Applies to only and allExcluding",
    arguments: [
      (
        .only(services: [.foo], methods: [.barFoo]),
        [.fooBar, .fooBaz, .barFoo],
        [.barBaz]
      ),
      (
        .allExcluding(services: [.foo], methods: [.barFoo]),
        [.barBaz],
        [.fooBar, .fooBaz, .barFoo]
      ),
    ] as [(ConditionalInterceptor<any Sendable>.Subject, [MethodDescriptor], [MethodDescriptor])]
  )
  @available(gRPCSwift 2.2, *)
  func appliesToOnlyAndAllExcluding(
    target: ConditionalInterceptor<any Sendable>.Subject,
    applicableMethods: [MethodDescriptor],
    notApplicableMethods: [MethodDescriptor]
  ) {
    for applicableMethod in applicableMethods {
      #expect(target.applies(to: applicableMethod))
    }

    for notApplicableMethod in notApplicableMethods {
      #expect(!target.applies(to: notApplicableMethod))
    }
  }

  @Test("Applies to all matching")
  @available(gRPCSwift 2.2, *)
  func appliesToAllMatching() {
    let target = ConditionalInterceptor<any Sendable>.Subject.allMatching { descriptor in
      descriptor.method == "baz"
    }
    let applicableMethods: [MethodDescriptor] = [.fooBaz, .barBaz]
    let notApplicableMethods: [MethodDescriptor] = [.fooBar, .barFoo]

    for applicableMethod in applicableMethods {
      #expect(target.applies(to: applicableMethod))
    }

    for notApplicableMethod in notApplicableMethods {
      #expect(!target.applies(to: notApplicableMethod))
    }
  }
}

[glbrntt]

I'm fine with that. The availability in tests doesn't matter much to be honest.

[glbrntt]

FWIW: the Check generated code (pull_request) job is fixed on main so if you update your branch with the base branch the job should pass.