Add a note about scoping differences between *x and *x.deref()

Author: dianne

src/expressions/operator-expr.md

@@ -189,6 +189,34 @@ let y = &mut 9;
 assert_eq!(*y, 11);
 ```
 
+> [!NOTE]
+> The [temporary scopes][temporary scope] of `x` in `*x` and `*std::ops::Deref::deref(&x)` are not always the same in all immutable place expression contexts.
+> Likewise, the temporary scopes of `x` in `*x` and `*std::ops::DerefMut::deref_mut(&mut x)` are not always the same in all mutable place expression contexts.
+>
+> If `*x` has an [extended][temporary lifetime extension] temporary scope, then `x` does as well ([destructors.scope.lifetime-extension.sub-expressions]).
+> However, the same does not apply to `*std::ops::Deref::deref(&x)` or `*std::ops::DerefMut::deref_mut(&mut x)`.
+>
+> For example, this affects automatically reference-counted pointers:
+>
+> ```rust
+> use std::rc::Rc;
+>
+> let rc = Rc::new(());
+> // The reference count starts at 1.
+> assert_eq!(Rc::strong_count(&rc), 1);
+>
+> let ref x = *std::ops::Deref::deref(&rc.clone());
+> // `rc.clone()` increments the reference count, but its result is
+> // dropped at the end of the statement, so the reference count goes
+> // back to 1.
+> assert_eq!(Rc::strong_count(&rc), 1);
+>
+> let ref y = *rc.clone();
+> // In this case, the lifetime of `rc.clone()` is extended to the end
+> // of the block, so the reference count stays at 2.
+> assert_eq!(Rc::strong_count(&rc), 2);
+> ```
+
 r[expr.try]
 ## The try propagation expression