Fix format-args-temporaries test (fail->pass) & add 2φ-borrows regression tests

Author: danielhenrymantilla

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);
+}