Permit inferring Self for unannotated self

docs/spec/annotations.rst

@@ -27,14 +27,10 @@ general type possible, or ignored, by any type checker.
 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
@@ -354,9 +350,16 @@ 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.
+(conventionally named ``self`` or ``cls``) does not need to be annotated.
+
+If the argument is not annotated, then for instance methods it is
+assumed to have the type of the containing class or :ref:`Self
+<self>`, and for class methods the type object type corresponding to
+the containing class object or ``type[Self]``. 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.
+
 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::