Update object safety to match impl around self as receiver

src/items/traits.md

@@ -75,22 +75,25 @@ Object safe traits can be the base trait of a [trait object]. A trait is
         * Not have any type parameters (although lifetime parameters are allowed),
         * Be a [method] that does not use `Self` except in the type of the receiver.
         * Have a receiver with one of the following types:
+            * `Self` (i.e. `self`)
+                * But unstable feature `unsized_fn_params` is required to dispatch it on a trait object.
             * `&Self` (i.e. `&self`)
             * `&mut Self` (i.e `&mut self`)
             * [`Box<Self>`]
             * [`Rc<Self>`]
             * [`Arc<Self>`]
             * [`Pin<P>`] where `P` is one of the types above
-        * Does not have a `where Self: Sized` bound (receiver type of `Self` (i.e. `self`) implies this).
+        * Does not have a `where Self: Sized` bound
     * Explicitly non-dispatchable functions require:
-        * Have a `where Self: Sized` bound (receiver type of `Self` (i.e. `self`) implies this).
+        * Have a `where Self: Sized` bound
 
 ```rust
 # use std::rc::Rc;
 # use std::sync::Arc;
 # use std::pin::Pin;
 // Examples of object safe methods.
 trait TraitMethods {
+    fn by_value(self: Self);
     fn by_ref(self: &Self) {}
     fn by_ref_mut(self: &mut Self) {}
     fn by_box(self: Box<Self>) {}
@@ -101,7 +104,9 @@ trait TraitMethods {
     fn nested_pin(self: Pin<Arc<Self>>) {}
 }
 # struct S;
-# impl TraitMethods for S {}
+# impl TraitMethods for S {
+#     fn by_value(self) {}
+# }
 # let t: Box<dyn TraitMethods> = Box::new(S);
 ```
 
@@ -110,6 +115,8 @@ trait TraitMethods {
 trait NonDispatchable {
     // Non-methods cannot be dispatched.
     fn foo() where Self: Sized {}
+    // Requires unstable `unsized_fn_params` feature.
+    fn by_value(self);
     // Self type isn't known until runtime.
     fn returns(&self) -> Self where Self: Sized;
     // `other` may be a different concrete type of the receiver.
@@ -120,12 +127,14 @@ trait NonDispatchable {
 
 struct S;
 impl NonDispatchable for S {
+    fn by_value(self) {}
     fn returns(&self) -> Self where Self: Sized { S }
 }
 let obj: Box<dyn NonDispatchable> = Box::new(S);
-obj.returns(); // ERROR: cannot call with Self return
-obj.param(S);  // ERROR: cannot call with Self parameter
-obj.typed(1);  // ERROR: cannot call with generic type
+obj.by_value(); // ERROR: cannot call with Self as receiver
+obj.returns();  // ERROR: cannot call with Self return
+obj.param(S);   // ERROR: cannot call with Self parameter
+obj.typed(1);   // ERROR: cannot call with generic type
 ```
 
 ```rust,compile_fail