the current conformance suite simultaneously also requires that callable assignability behave as if it de-sugars to f(*, v1: int, **kwargs: object). That addition to the conformance suite was justified by this call, which is allowed by pyright and pyrefly:

class TD2(TD1):
    v2: int

def _(td2: TD2):
    f(**td2)

I'm looking at what (I think) is the corresponding section of the conformance suite, and the function has an extra parameter corresponding to the extra key in TD2:

class TD1(TypedDict):
    v1: Required[int]
    v2: NotRequired[str]


class TD2(TD1):
    v3: Required[str]


def func2(v3: str, **kwargs: Unpack[TD1]) -> None: ...


def func3() -> None:
    func2(**td2)  # OK

If you delete the v3 parameter from func2, mypy does error (https://mypy-play.net/?gist=4d52cf2dbdaf2e4ecee1e2b54bc3d138), although pyright and pyrefly don't. So the conformance suite doesn't seem inconsistent to me, although pyright and pyrefly's implementations are (and arguably don't conform to the spirit of what's being tested).

With that said, I'd be fine with modifying the conformance test to also allow a consistent **kwargs: object interpretation.

@rchen152 Sorry I wasn't clearer -- I wasn't saying that the conformance suite contains that example, just that pyright and pyrefly do allow it. What the conformance suite does contain is the requirement (added in #1918) that a callable that doesn't accept *kwargs is not assignable to a callable that accepts **kwargs: Unpack[TD] (this assertion). The prose justification for that requirement that was added to the spec is the case of unpacking **td2 to **kwargs: Unpack[TD], even though that call is not tested in the conformance suite. So this is the contradiction I see in the current conformance suite: it simultaneously requires that calls to f act as if f does not accept **kwargs, and that assignability of f to other callable types act as if f does accept **kwargs. I don't think we should specify or require this contradiction.

Relatedly, I think that the spec now has a lot of complex cases and language around assignability of callables using **kwargs: Unpack[TD]. I believe that all of that can and should be replaced by a much simpler specification that outlines how to transform **kwargs: Unpack[TD] into a "normal" signature, and then simply specify that all assignability (and call evaluation) rules follow from that transformation.

@davidhalter Yes, I think that's defensible. I think that a type-checker which consistently implemented that approach should not allow the **td2 call either, nor should it implement the assignability error in the func7 assertion I linked above. Because that interpretation says that the signature of f is simply (*, v1: int), in which case its callable type should be equivalent to the callable type of a function defined explicitly as def _(*, v1: int).

Thanks both for the reviews!