---

yaml
---
r: 152708
b: refs/heads/try2
c: f5e513b
h: refs/heads/master
v: v3

Author: Jakub Wieczorek

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 2563481ca93877551116b11cde3cc7e21f1d6048
+refs/heads/try2: f5e513b2b2dd173f16b84f0531fc3628d62beb4d
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/guide-unsafe.md

@@ -192,8 +192,6 @@ As an example, we give a reimplementation of owned boxes by wrapping
 reimplementation is as safe as the `Box` type.
 
 ```
-#![feature(unsafe_destructor)]
-
 extern crate libc;
 use libc::{c_void, size_t, malloc, free};
 use std::mem;
@@ -244,12 +242,10 @@ impl<T: Send> Unique<T> {
 // A key ingredient for safety, we associate a destructor with
 // Unique<T>, making the struct manage the raw pointer: when the
 // struct goes out of scope, it will automatically free the raw pointer.
-//
 // NB: This is an unsafe destructor, because rustc will not normally
-// allow destructors to be associated with parameterized types, due to
+// allow destructors to be associated with parametrized types, due to
 // bad interaction with managed boxes. (With the Send restriction,
-// we don't have this problem.) Note that the `#[unsafe_destructor]`
-// feature gate is required to use unsafe destructors.
+// we don't have this problem.)
 #[unsafe_destructor]
 impl<T: Send> Drop for Unique<T> {
     fn drop(&mut self) {

branches/try2/src/doc/rust.md

@@ -1940,13 +1940,12 @@ interpreted:
   enum representation in C is undefined, and this may be incorrect when the C
   code is compiled with certain flags.
 - `simd` - on certain tuple structs, derive the arithmetic operators, which
-  lower to the target's SIMD instructions, if any; the `simd` feature gate
-  is necessary to use this attribute.
+  lower to the target's SIMD instructions, if any.
 - `static_assert` - on statics whose type is `bool`, terminates compilation
   with an error if it is not initialized to `true`.
 - `unsafe_destructor` - allow implementations of the "drop" language item
   where the type it is implemented for does not implement the "send" language
-  item; the `unsafe_destructor` feature gate is needed to use this attribute
+  item.
 - `unsafe_no_drop_flag` - on structs, remove the flag that prevents
   destructors from being run twice. Destructors might be run multiple times on
   the same object with this attribute.

branches/try2/src/liballoc/lib.rs

@@ -69,8 +69,7 @@
        html_root_url = "http://doc.rust-lang.org/")]
 
 #![no_std]
-#![feature(phase, unsafe_destructor)]
-#![allow(unknown_features)] // NOTE: remove after a stage0 snap
+#![feature(phase)]
 
 #[phase(plugin, link)]
 extern crate core;

branches/try2/src/libarena/lib.rs

@@ -27,10 +27,7 @@
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/")]
-
-#![feature(unsafe_destructor)]
 #![allow(missing_doc)]
-#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 
 use std::cell::{Cell, RefCell};
 use std::cmp;

branches/try2/src/libcollections/lib.rs

@@ -22,9 +22,7 @@
        html_playground_url = "http://play.rust-lang.org/")]
 
 #![feature(macro_rules, managed_boxes, default_type_params, phase, globs)]
-#![feature(unsafe_destructor)]
 #![no_std]
-#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 
 #[phase(plugin, link)] extern crate core;
 extern crate alloc;

branches/try2/src/libcore/lib.rs

@@ -55,9 +55,8 @@
        html_playground_url = "http://play.rust-lang.org/")]
 
 #![no_std]
-#![feature(globs, macro_rules, managed_boxes, phase, simd, unsafe_destructor)]
+#![feature(globs, macro_rules, managed_boxes, phase, simd)]
 #![deny(missing_doc)]
-#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 
 #[cfg(test)] extern crate realcore = "core";
 #[cfg(test)] extern crate libc;

branches/try2/src/libnative/lib.rs

@@ -52,17 +52,15 @@
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/")]
-
 #![deny(unused_result, unused_must_use)]
 #![allow(non_camel_case_types)]
 #![allow(deprecated)]
-#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 #![feature(default_type_params)]
 
 // NB this crate explicitly does *not* allow glob imports, please seriously
 //    consider whether they're needed before adding that feature here (the
 //    answer is that you don't need them)
-#![feature(macro_rules, unsafe_destructor)]
+#![feature(macro_rules)]
 
 extern crate alloc;
 extern crate libc;

branches/try2/src/librustc/front/feature_gate.rs

@@ -50,7 +50,6 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("log_syntax", Active),
     ("trace_macros", Active),
     ("concat_idents", Active),
-    ("unsafe_destructor", Active),
 
     ("simd", Active),
     ("default_type_params", Active),
@@ -221,17 +220,6 @@ impl<'a> Visitor<()> for Context<'a> {
                 }
             }
 
-            ast::ItemImpl(..) => {
-                if attr::contains_name(i.attrs.as_slice(),
-                                       "unsafe_destructor") {
-                    self.gate_feature("unsafe_destructor",
-                                      i.span,
-                                      "`#[unsafe_destructor]` allows too \
-                                       many unsafe patterns and may be \
-                                       removed in the future");
-                }
-            }
-
             _ => {}
         }
 

branches/try2/src/librustc/lib.rs

@@ -29,9 +29,8 @@ This API is completely unstable and subject to change.
       html_root_url = "http://doc.rust-lang.org/")]
 
 #![allow(deprecated)]
-#![allow(unknown_features)] // NOTE: remove after a stage0 snap
-#![feature(macro_rules, globs, struct_variant, managed_boxes, quote)]
-#![feature(default_type_params, phase, unsafe_destructor)]
+#![feature(macro_rules, globs, struct_variant, managed_boxes, quote,
+           default_type_params, phase)]
 
 extern crate arena;
 extern crate debug;

branches/try2/src/librustc/middle/check_match.rs

@@ -750,12 +750,15 @@ fn check_local(cx: &mut MatchCheckCtxt, loc: &Local) {
         LocalFor => "`for` loop"
     };
 
-    let mut spans = vec![];
-    find_refutable(cx, &*loc.pat, &mut spans);
-
-    for span in spans.iter() {
-        cx.tcx.sess.span_err(*span,
-                             format!("refutable pattern in {} binding", name).as_slice());
+    match is_refutable(cx, loc.pat) {
+        Some(pat) => {
+            let msg = format!(
+                "refutable pattern in {} binding: {} not covered",
+                name, pat_to_str(&*pat)
+            );
+            cx.tcx.sess.span_err(loc.pat.span, msg.as_slice());
+        },
+        None => ()
     }
 
     // Check legality of move bindings.
@@ -769,67 +772,27 @@ fn check_fn(cx: &mut MatchCheckCtxt,
             sp: Span) {
     visit::walk_fn(cx, kind, decl, body, sp, ());
     for input in decl.inputs.iter() {
-        let mut spans = vec![];
-        find_refutable(cx, &*input.pat, &mut spans);
-
-        for span in spans.iter() {
-            cx.tcx.sess.span_err(*span,
-                                 "refutable pattern in function argument");
+        match is_refutable(cx, input.pat) {
+            Some(pat) => {
+                let msg = format!(
+                    "refutable pattern in function argument: {} not covered",
+                    pat_to_str(&*pat)
+                );
+                cx.tcx.sess.span_err(input.pat.span, msg.as_slice());
+            },
+            None => ()
         }
     }
 }
 
-fn find_refutable(cx: &MatchCheckCtxt, pat: &Pat, spans: &mut Vec<Span>) {
-    macro_rules! this_pattern {
-        () => {
-            {
-                spans.push(pat.span);
-                return
-            }
-        }
-    }
-    let opt_def = cx.tcx.def_map.borrow().find_copy(&pat.id);
-    match opt_def {
-      Some(DefVariant(enum_id, _, _)) => {
-        if ty::enum_variants(cx.tcx, enum_id).len() != 1u {
-            this_pattern!()
-        }
-      }
-      Some(DefStatic(..)) => this_pattern!(),
-      _ => ()
-    }
-
-    match pat.node {
-      PatBox(ref sub) | PatRegion(ref sub) | PatIdent(_, _, Some(ref sub)) => {
-        find_refutable(cx, &**sub, spans)
-      }
-      PatWild | PatWildMulti | PatIdent(_, _, None) => {}
-      PatLit(lit) => {
-          match lit.node {
-            ExprLit(lit) => {
-                match lit.node {
-                    LitNil => {}    // `()`
-                    _ => this_pattern!(),
-                }
-            }
-            _ => this_pattern!(),
-          }
-      }
-      PatRange(_, _) => { this_pattern!() }
-      PatStruct(_, ref fields, _) => {
-          for f in fields.iter() {
-              find_refutable(cx, &*f.pat, spans);
-          }
-      }
-      PatTup(ref elts) | PatEnum(_, Some(ref elts))=> {
-          for elt in elts.iter() {
-              find_refutable(cx, &**elt, spans)
-          }
-      }
-      PatEnum(_,_) => {}
-      PatVec(..) => { this_pattern!() }
-      PatMac(_) => cx.tcx.sess.bug("unexpanded macro"),
-    }
+fn is_refutable(cx: &MatchCheckCtxt, pat: Gc<Pat>) -> Option<Gc<Pat>> {
+    let pats = vec!(vec!(pat));
+    is_useful(cx, &pats, [wild()])
+        .useful()
+        .map(|pats| {
+            assert_eq!(pats.len(), 1);
+            pats.get(0).clone()
+        })
 }
 
 // Legality of move bindings checking

branches/try2/src/librustrt/lib.rs

@@ -15,12 +15,10 @@
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/")]
-
-#![feature(macro_rules, phase, globs, thread_local, managed_boxes, asm)]
-#![feature(linkage, unsafe_destructor)]
+#![feature(macro_rules, phase, globs, thread_local, managed_boxes, asm,
+           linkage)]
 #![no_std]
 #![experimental]
-#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 
 #[phase(plugin, link)] extern crate core;
 extern crate alloc;

branches/try2/src/librustuv/lib.rs

@@ -40,7 +40,7 @@ via `close` and `delete` methods.
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 
-#![feature(macro_rules, unsafe_destructor)]
+#![feature(macro_rules)]
 #![deny(unused_result, unused_must_use)]
 #![allow(visible_private_types)]
 

branches/try2/src/libstd/lib.rs

@@ -103,16 +103,14 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/",
        html_playground_url = "http://play.rust-lang.org/")]
-
-#![feature(macro_rules, globs, managed_boxes)]
-#![feature(linkage, default_type_params, phase, unsafe_destructor)]
+#![feature(macro_rules, globs, managed_boxes,
+           linkage, default_type_params, phase)]
 
 // Don't link to std. We are std.
 #![no_std]
 
 #![allow(deprecated)]
 #![deny(missing_doc)]
-#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 
 // When testing libstd, bring in libuv as the I/O backend so tests can print
 // things and all of the std::io tests have an I/O interface to run on top

branches/try2/src/libsync/lib.rs

@@ -26,11 +26,10 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/",
        html_playground_url = "http://play.rust-lang.org/")]
+#![feature(phase, globs, macro_rules)]
 
-#![feature(phase, globs, macro_rules, unsafe_destructor)]
 #![deny(missing_doc)]
 #![no_std]
-#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 
 #[phase(plugin, link)] extern crate core;
 extern crate alloc;

branches/try2/src/libsyntax/lib.rs

@@ -27,10 +27,9 @@ This API is completely unstable and subject to change.
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/")]
 
-#![feature(macro_rules, globs, managed_boxes, default_type_params, phase)]
-#![feature(quote, unsafe_destructor)]
+#![feature(macro_rules, globs, managed_boxes, default_type_params, phase,
+           quote)]
 #![allow(deprecated)]
-#![allow(unknown_features)] // NOTE: remove after a stage0 snap
 
 extern crate serialize;
 extern crate term;

branches/try2/src/libsyntax/parse/parser.rs

@@ -706,16 +706,6 @@ impl<'a> Parser<'a> {
                 let lo = span.lo + BytePos(1);
                 self.replace_token(token::GT, lo, span.hi)
             }
-            token::BINOPEQ(token::SHR) => {
-                let span = self.span;
-                let lo = span.lo + BytePos(1);
-                self.replace_token(token::GE, lo, span.hi)
-            }
-            token::GE => {
-                let span = self.span;
-                let lo = span.lo + BytePos(1);
-                self.replace_token(token::EQ, lo, span.hi)
-            }
             _ => {
                 let gt_str = Parser::token_to_str(&token::GT);
                 let this_token_str = self.this_token_to_str();
@@ -736,9 +726,7 @@ impl<'a> Parser<'a> {
         let mut first = true;
         let mut v = Vec::new();
         while self.token != token::GT
-            && self.token != token::BINOP(token::SHR)
-            && self.token != token::GE
-            && self.token != token::BINOPEQ(token::SHR) {
+            && self.token != token::BINOP(token::SHR) {
             match sep {
               Some(ref t) => {
                 if first { first = false; }

branches/try2/src/test/auxiliary/issue-2526.rs

@@ -11,8 +11,6 @@
 #![crate_id="issue_2526#0.2"]
 #![crate_type = "lib"]
 
-#![feature(unsafe_destructor)]
-
 struct arc_destruct<T> {
   _data: int,
 }

branches/try2/src/test/bench/task-perf-alloc-unwind.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(managed_boxes, unsafe_destructor)]
+#![feature(managed_boxes)]
 
 extern crate collections;
 extern crate time;

branches/try2/src/test/compile-fail/borrowck-borrowed-uniq-rvalue-2.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(unsafe_destructor)]
-
 extern crate debug;
 
 struct defer<'a> {

branches/try2/src/test/compile-fail/no-send-res-ports.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(managed_boxes, unsafe_destructor)]
+#![feature(managed_boxes)]
 
 extern crate debug;
 

branches/try2/src/test/compile-fail/pinned-deep-copy.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(managed_boxes, unsafe_destructor)]
+#![feature(managed_boxes)]
 
 extern crate debug;