Assuming `self` or `cls` parameter is positional-only

I'm interested in guidance from the typing community relating to a question that came up in a recent pyright bug report.

The issue has to do with the self parameter in an instance method and the cls parameter in a class method — whether a type checker should assume that they are implicitly positional-only parameters. In particular, the discussion was about method declarations within a protocol class.

PEP 570 makes a reference to this topic in its introductory section:

One special case of this situation is the self parameter for class methods: it is undesirable that a caller can bind by keyword to the name self when calling the method from the class.

But PEP 570 doesn't provide any specific guidance about self or cls in its specification section. PEP 544 (which introduced protocols) is also silent on the topic.

Pyright currently assumes that self and cls are not positional-only parameters (unless explicitly followed by a / parameter marker or named with double underscores). This assumption affects protocol matching — and more generally, subtype compatibility evaluation for callables.

@AlexWaygood is proposing that the first parameter of instance and class methods should always be considered position-only parameters.

This raises some questions in my mind:

1. Is this a safe assumption? Does anyone know of a situation where self or cls are used as keyword arguments?
2. Does this apply only to protocol methods, or does it apply generally to methods in any class?
3. Should it be considered a type checker error if someone attempts to use a keyword argument to target the first parameter of an instance or class method? It works at runtime.

class Foo:
    def bar(self): pass

Foo.bar(self=Foo())

5. Does the cls exemption apply only to explicit class methods, or does it also apply to __new__ and __init_subclass__?

Comienza leyendo PEP 570 y PEP 544; después, revisa el informe de error de Pyright enlazado y la discusión del issue. Determina si self y cls deben tratarse como solo posicionales en métodos, protocolos, new y init_subclass. Se considera terminado cuando se haya llegado a una directriz documentada de la comunidad o a una decisión sobre la especificación.