Revise text on built-in macro lifetime extension

In particular, let's break apart the items for `pin!` and
`format_args!` so we can be specific about which argument positions
are extending expressions.

Let's drop the section that talks about these macros creating
temporaries.  They do, but that's an internal detail.  The important
part as it pertains to this rule is that these argument positions are
extending expressions, which means that a borrow in this position is
extending, which means that "the operand of any extending borrow
expression has its temporary scope extended".

Author: traviscross

src/destructors.md

@@ -487,19 +487,16 @@ expression which is one of the following:
 * The final expression of an extending [block expression] except for an [async block expression].
 * The final expression of an extending [`if`] expression's consequent, `else if`, or `else` block.
 * An arm expression of an extending [`match`] expression.
-* The argument(s) to an extending [`pin!`] or [`format_args!`] [macro invocation] expression.
+* The argument to an extending [`pin!`] [macro invocation] expression.
+* Any arguments following the format string to the [`format_args!`] [macro invocation] expression.
 
 So the borrow expressions in `&mut 0`, `(&1, &mut 2)`, and `Some(&mut 3)`
 are all extending expressions. The borrows in `&0 + &1` and `f(&mut 0)` are not.
 
-r[destructors.scope.lifetime-extension.exprs.borrow]
+r[destructors.scope.lifetime-extension.exprs.borrows]
 The operand of any extending borrow expression has its temporary scope
 extended.
 
-r[destructors.scope.lifetime-extension.exprs.macros]
-The built-in macros [`pin!`] and [`format_args!`] create temporaries.
-Any extending [`pin!`] or [`format_args!`] [macro invocation] expression has an extended temporary scope.
-
 > [!NOTE]
 > `rustc` does not treat [array repeat operands] of extending [array] expressions as extending expressions. Whether it should is an open question.
 >
@@ -513,6 +510,7 @@ Here are some examples where expressions have extended temporary scopes:
 # use core::sync::atomic::{AtomicU64, Ordering::Relaxed};
 # use std::pin::pin;
 # static X: AtomicU64 = AtomicU64::new(0);
+# #[derive(Debug)]
 # struct S;
 # impl Drop for S { fn drop(&mut self) { X.fetch_add(1, Relaxed); } }
 # const fn temp() -> S { S }
@@ -538,6 +536,9 @@ let x = match () { _ => &temp() }; // `match` arm expression.
 # x;
 let x = pin!(&temp()); // Argument to `pin!`.
 # x;
+# // TODO: This needs <https://github.com/rust-lang/rust/pull/145882>.
+let x = format_args!("{:?}", &temp()); // Argument to `format_args!`.
+# x;
 //
 // All of the temporaries above are still live here.
 # assert_eq!(0, X.load(Relaxed));
@@ -668,13 +669,12 @@ There is one additional case to be aware of: when a panic reaches a [non-unwindi
 [tuple indexing expression]: expressions/tuple-expr.md#tuple-indexing-expressions
 
 [`for`]: expressions/loop-expr.md#iterator-loops
+[`format_args!`]: core::format_args
 [`if let`]: expressions/if-expr.md#if-let-patterns
 [`if`]: expressions/if-expr.md#if-expressions
 [`let` statement]: statements.md#let-statements
 [`loop`]: expressions/loop-expr.md#infinite-loops
 [`match`]: expressions/match-expr.md
+[`pin!`]: std::pin::pin
 [`while let`]: expressions/loop-expr.md#while-let-patterns
 [`while`]: expressions/loop-expr.md#predicate-loops
-
-[`pin!`]: std::pin::pin
-[`format_args!`]: core::format_args