Permit inferring Self for unannotated self (#1860)

Co-authored-by: Carl Meyer <[email protected]>

Author: hauntsaninja

docs/spec/annotations.rst

@@ -32,14 +32,10 @@ functions with no annotations, but this behavior is not required.
 It is recommended but not required that checked functions have
 annotations for all arguments and the return type.  For a checked
 function, the default annotation for arguments and for the return type
-is ``Any``.  An exception is the first argument of instance and
-class methods. If it is not annotated, then it is assumed to have the
-type of the containing class for instance methods, and a type object
-type corresponding to the containing class object for class methods.
-For example, in class ``A`` the first argument of an instance method
-has the implicit type ``A``. In a class method, the precise type of
-the first argument cannot be represented using the available type
-notation.
+is ``Any``. An exception to the above is the first argument of
+instance and class methods (conventionally named ``self`` or ``cls``),
+which type checkers should assume to have an appropriate type, as per
+:ref:`annotating-methods`.
 
 (Note that the return type of ``__init__`` ought to be annotated with
 ``-> None``.  The reason for this is subtle.  If ``__init__`` assumed
@@ -358,10 +354,14 @@ types cannot be specified::
 Annotating instance and class methods
 -------------------------------------
 
-In most cases the first argument of class and instance methods
-does not need to be annotated, and it is assumed to have the
-type of the containing class for instance methods, and a type object
-type corresponding to the containing class object for class methods.
+In most cases the first argument of instance and class methods
+(conventionally named ``self`` or ``cls``) does not need to be annotated.
+
+If the argument is not annotated, then for instance methods it may be
+inferred to have either the type of the containing class, or the type :ref:`Self
+<self>`. For class methods it may be inferred to have either the type object
+type corresponding to the containing class object, or ``type[Self]``.
+
 In addition, the first argument in an instance method can be annotated
 with a type variable. In this case the return type may use the same
 type variable, thus making that method a generic function. For example::