Fix #99684 through autoref in write! macro with a two-phased borrows retrocompat workaround

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -30,10 +30,10 @@ use super::*;
 
 macro_rules! p {
     (@$lit:literal) => {
-        write!(scoped_cx!(), $lit)?
+        scoped_cx!().write_fmt(format_args!($lit))?
     };
     (@write($($data:expr),+)) => {
-        write!(scoped_cx!(), $($data),+)?
+        scoped_cx!().write_fmt(format_args!($($data),+))?
     };
     (@print($x:expr)) => {
         scoped_cx!() = $x.print(scoped_cx!())?

library/core/src/macros/mod.rs

@@ -515,9 +515,39 @@ macro_rules! r#try {
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "write_macro")]
+#[allow_internal_unstable(autoref)]
 macro_rules! write {
+    // Retrocompat workaround to support two phased borrows:
+    // when `$dst` is made of chaining `.field` (or `.idx`) accesses to a local,
+    // it is guaranteed to be a *place* and thus there is no question of
+    // late-dropping anything inside it.
+    //
+    // Whilst this won't cover *all* the possible syntaxes for places (it
+    // won't handle places with `[…]`-indexing inside them (see
+    // https://github.com/rust-lang/rust/pull/100202#pullrequestreview-1064499226)
+    // qualified paths to `static mut`s, nor macro invocations), it ought to
+    // cover the vast majority of uses in practice, especially regarding
+    // retro-compatibility.
+    (
+        $dst_place:ident $(. $field_or_idx:tt)* ,
+        $($arg:tt)*
+    ) => ({
+        let result =
+            $dst_place $(. $field_or_idx )*
+                .write_fmt($crate::format_args!($($arg)*))
+        ;
+        result
+    });
+
+    // default case: early-dropped `format_args!($($args)*)` while keeping
+    // `$dst` late-dropped.
     ($dst:expr, $($arg:tt)*) => {
-        $dst.write_fmt($crate::format_args!($($arg)*))
+        match $crate::ops::autoref::autoref_mut!($dst) {
+            mut _dst => {
+                let result = _dst.write_fmt($crate::format_args!($($arg)*));
+                result
+            }
+        }
     };
 }
 
@@ -549,13 +579,30 @@ macro_rules! write {
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "writeln_macro")]
-#[allow_internal_unstable(format_args_nl)]
+#[allow_internal_unstable(autoref, format_args_nl)]
 macro_rules! writeln {
     ($dst:expr $(,)?) => {
         $crate::write!($dst, "\n")
     };
+
+    (
+        $dst_place:ident $(. $field_or_idx:tt)* ,
+        $($arg:tt)*
+    ) => ({
+        let result =
+            $dst_place $(. $field_or_idx)*
+                .write_fmt($crate::format_args_nl!($($arg)*))
+        ;
+        result
+    });
+
     ($dst:expr, $($arg:tt)*) => {
-        $dst.write_fmt($crate::format_args_nl!($($arg)*))
+        match $crate::ops::autoref::autoref_mut!($dst) {
+            mut _dst => {
+                let result = _dst.write_fmt($crate::format_args_nl!($($arg)*));
+                result
+            }
+        }
     };
 }
 

library/core/src/ops/autoref.rs

@@ -0,0 +1,46 @@
+#![allow(missing_docs, missing_debug_implementations)]
+// Poor man's `k#autoref` operator.
+//
+// See https://github.com/rust-lang/rust/issues/99684
+// and https://rust-lang.zulipchat.com/#narrow/stream/213817-t-lang/topic/Desired.20behavior.20of.20.60write!.60.20is.20unimplementable
+// for some more context about this idea.
+//
+// Right now we polyfill this idea, by reducing support to `&mut`-autoref-only
+// (effectively "just" preventing an unnecessary `&mut` level of indirection
+// from being applied for a thing already behind a `&mut …`), which happens to
+// work for `&mut`-based `.write_fmt()` methods, and some cases of `&`-based
+// `.write_fmt()` —the whole duck-typed design / API of `write!` is asking for
+// trouble—, but won't work for a `self`-based `.write_fmt()`, as pointed out
+// here: https://github.com/rust-lang/rust/pull/100202#pullrequestreview-1064499226
+//
+// Finally, in order to reduce the chances of name conflicts as much as
+// possible, the method name is a bit mangled, and to prevent usage of this
+// method in stable-rust, an unstable const generic parameter that needs to be
+// turbofished is added to it as well.
+
+/// The unstable const generic parameter achieving the "unstable seal" effect.
+#[unstable(feature = "autoref", issue = "none")]
+#[derive(Eq, PartialEq)]
+pub struct UnstableMethodSeal;
+
+#[unstable(feature = "autoref", issue = "none")]
+pub trait AutoRef {
+    #[unstable(feature = "autoref", issue = "none")]
+    #[inline(always)]
+    fn __rustc_unstable_auto_ref_mut_helper<const _SEAL: UnstableMethodSeal>(
+        &mut self,
+    ) -> &mut Self {
+        self
+    }
+}
+
+#[unstable(feature = "autoref", issue = "none")]
+impl<T: ?Sized> AutoRef for T {}
+
+#[unstable(feature = "autoref", issue = "none")]
+#[allow_internal_unstable(autoref)]
+#[rustc_macro_transparency = "semitransparent"]
+pub macro autoref_mut($x:expr) {{
+    use $crate::ops::autoref::AutoRef as _;
+    $x.__rustc_unstable_auto_ref_mut_helper::<{ $crate::ops::autoref::UnstableMethodSeal }>()
+}}

library/core/src/ops/mod.rs

@@ -139,6 +139,9 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 
 mod arith;
+#[doc(hidden)]
+#[unstable(feature = "autoref", issue = "none")]
+pub mod autoref;
 mod bit;
 mod control_flow;
 mod deref;

src/test/ui/macros/format-args-temporaries-in-write.rs

@@ -1,50 +1,53 @@
-// check-fail
+// check-pass
+#![crate_type = "lib"]
 
 use std::fmt::{self, Display};
 
 struct Mutex;
 
 impl Mutex {
-    fn lock(&self) -> MutexGuard {
-        MutexGuard(self)
+    /// Dependent item with (potential) drop glue to disable NLL.
+    fn lock(&self) -> impl '_ + Display {
+        42
     }
 }
 
-struct MutexGuard<'a>(&'a Mutex);
+struct Stderr();
 
-impl<'a> Drop for MutexGuard<'a> {
-    fn drop(&mut self) {
-        // Empty but this is a necessary part of the repro. Otherwise borrow
-        // checker is fine with 'a dangling at the time that MutexGuard goes out
-        // of scope.
-    }
-}
-
-struct Out;
-
-impl Out {
-    fn write_fmt(&self, _args: fmt::Arguments) {}
-}
-
-impl<'a> Display for MutexGuard<'a> {
-    fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result {
-        Ok(())
-    }
+impl Stderr {
+    /// A "lending" `write_fmt` method. See:
+    /// https://docs.rs/async-std/1.12.0/async_std/io/prelude/trait.WriteExt.html#method.write_fmt
+    fn write_fmt(&mut self, _args: fmt::Arguments) -> &() { &() }
 }
 
-fn main() {
-    // FIXME(dtolnay): We actually want both of these to work. I think it's
-    // sadly unimplementable today though.
+fn early_drop_for_format_args_temporaries() {
+    let mut out = Stderr();
 
     let _write = {
         let mutex = Mutex;
-        write!(Out, "{}", mutex.lock()) /* no semicolon */
-        //~^ ERROR `mutex` does not live long enough
+        write!(out, "{}", mutex.lock()) /* no semicolon */
     };
 
     let _writeln = {
         let mutex = Mutex;
-        writeln!(Out, "{}", mutex.lock()) /* no semicolon */
-        //~^ ERROR `mutex` does not live long enough
+        writeln!(out, "{}", mutex.lock()) /* no semicolon */
     };
 }
+
+fn late_drop_for_receiver() {
+    let mutex = Mutex;
+    drop(write!(&mut Stderr(), "{}", mutex.lock()));
+    drop(writeln!(&mut Stderr(), "{}", mutex.lock()));
+}
+
+fn two_phased_borrows_retrocompat(w: (&mut Stderr, i32)) {
+    write!(w.0, "{}", w.1);
+    writeln!(w.0, "{}", w.1);
+    struct Struct<W> {
+        w: W,
+        len: i32
+    }
+    let s = (Struct { w: (w.0, ), len: w.1 }, );
+    write!(s.0.w.0, "{}", s.0.len);
+    writeln!(s.0.w.0, "{}", s.0.len);
+}