From e46620af45ecf1f6388dc29f5a4b5f0954cf6dd8 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Tue, 13 Jan 2015 00:27:28 -0800
Subject: [PATCH 1/2] std: Deprecate `finally` module

No in-tree users. Ugly interface. Closes #14332.
---
 src/libcore/finally.rs         |  2 +-
 src/test/run-pass/backtrace.rs | 38 +++++++++++++++++++++++++++++++++-
 2 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/src/libcore/finally.rs b/src/libcore/finally.rs
index a21ec892dd7..65d2a9e7b7e 100644
--- a/src/libcore/finally.rs
+++ b/src/libcore/finally.rs
@@ -32,7 +32,7 @@
 //! # }
 //! ```
 
-#![unstable]
+#![deprecated = "this was an unsightly interface. just implement Drop"]
 
 use ops::{Drop, FnMut, FnOnce};
 
diff --git a/src/test/run-pass/backtrace.rs b/src/test/run-pass/backtrace.rs
index da5fa19f816..5050b7c466e 100644
--- a/src/test/run-pass/backtrace.rs
+++ b/src/test/run-pass/backtrace.rs
@@ -12,11 +12,47 @@
 // ignore-windows FIXME #13259
 
 #![feature(unboxed_closures)]
+#![feature(unsafe_destructor)]
 
 use std::os;
 use std::io::process::Command;
-use std::finally::Finally;
 use std::str;
+use std::ops::{Drop, FnMut, FnOnce};
+
+pub trait Finally<T> {
+    fn finally<F>(&mut self, dtor: F) -> T where F: FnMut();
+}
+
+impl<T, F> Finally<T> for F where F: FnMut() -> T {
+    fn finally<G>(&mut self, mut dtor: G) -> T where G: FnMut() {
+        try_finally(&mut (), self, |_, f| (*f)(), |_| dtor())
+    }
+}
+
+pub fn try_finally<T, U, R, F, G>(mutate: &mut T, drop: U, try_fn: F, finally_fn: G) -> R where
+    F: FnOnce(&mut T, U) -> R,
+    G: FnMut(&mut T),
+{
+    let f = Finallyalizer {
+        mutate: mutate,
+        dtor: finally_fn,
+    };
+    try_fn(&mut *f.mutate, drop)
+}
+
+struct Finallyalizer<'a, A:'a, F> where F: FnMut(&mut A) {
+    mutate: &'a mut A,
+    dtor: F,
+}
+
+#[unsafe_destructor]
+impl<'a, A, F> Drop for Finallyalizer<'a, A, F> where F: FnMut(&mut A) {
+    #[inline]
+    fn drop(&mut self) {
+        (self.dtor)(self.mutate);
+    }
+}
+
 
 #[inline(never)]
 fn foo() {

From f0fe4bb11404b2834bc3160683c220861142f955 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Tue, 13 Jan 2015 15:44:33 -0800
Subject: [PATCH 2/2] Address feedback

---
 src/libcore/finally.rs         |  6 ++++-
 src/test/run-pass/backtrace.rs | 49 +++++++---------------------------
 2 files changed, 14 insertions(+), 41 deletions(-)

diff --git a/src/libcore/finally.rs b/src/libcore/finally.rs
index 65d2a9e7b7e..4c2a2ff1086 100644
--- a/src/libcore/finally.rs
+++ b/src/libcore/finally.rs
@@ -32,7 +32,11 @@
 //! # }
 //! ```
 
-#![deprecated = "this was an unsightly interface. just implement Drop"]
+#![deprecated = "It is unclear if this module is more robust than implementing \
+                 Drop on a custom type, and this module is being removed with no \
+                 replacement. Use a custom Drop implementation to regain existing \
+                 functionality."]
+#![allow(deprecated)]
 
 use ops::{Drop, FnMut, FnOnce};
 
diff --git a/src/test/run-pass/backtrace.rs b/src/test/run-pass/backtrace.rs
index 5050b7c466e..320ad0bf4d1 100644
--- a/src/test/run-pass/backtrace.rs
+++ b/src/test/run-pass/backtrace.rs
@@ -19,41 +19,6 @@ use std::io::process::Command;
 use std::str;
 use std::ops::{Drop, FnMut, FnOnce};
 
-pub trait Finally<T> {
-    fn finally<F>(&mut self, dtor: F) -> T where F: FnMut();
-}
-
-impl<T, F> Finally<T> for F where F: FnMut() -> T {
-    fn finally<G>(&mut self, mut dtor: G) -> T where G: FnMut() {
-        try_finally(&mut (), self, |_, f| (*f)(), |_| dtor())
-    }
-}
-
-pub fn try_finally<T, U, R, F, G>(mutate: &mut T, drop: U, try_fn: F, finally_fn: G) -> R where
-    F: FnOnce(&mut T, U) -> R,
-    G: FnMut(&mut T),
-{
-    let f = Finallyalizer {
-        mutate: mutate,
-        dtor: finally_fn,
-    };
-    try_fn(&mut *f.mutate, drop)
-}
-
-struct Finallyalizer<'a, A:'a, F> where F: FnMut(&mut A) {
-    mutate: &'a mut A,
-    dtor: F,
-}
-
-#[unsafe_destructor]
-impl<'a, A, F> Drop for Finallyalizer<'a, A, F> where F: FnMut(&mut A) {
-    #[inline]
-    fn drop(&mut self) {
-        (self.dtor)(self.mutate);
-    }
-}
-
-
 #[inline(never)]
 fn foo() {
     let _v = vec![1i, 2, 3];
@@ -64,11 +29,15 @@ fn foo() {
 
 #[inline(never)]
 fn double() {
-    (|&mut:| {
-        panic!("once");
-    }).finally(|| {
-        panic!("twice");
-    })
+    struct Double;
+
+    impl Drop for Double {
+        fn drop(&mut self) { panic!("twice") }
+    }
+
+    let _d = Double;
+
+    panic!("once");
 }
 
 fn runtest(me: &str) {