---

yaml
---
r: 65262
b: refs/heads/master
c: 2f69bb9
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: c6581325ac38ce3f96cb7a0ea0aad35feed173c1
+refs/heads/master: 2f69bb9ba9d622ccab77840c08f4562a10b44c29
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/doc/rust.md

@@ -2435,10 +2435,11 @@ match x {
 }
 ~~~~
 
-Patterns that bind variables default to binding to a copy of the matched value. This can be made
-explicit using the ```copy``` keyword, changed to bind to a borrowed pointer by using the ```ref```
-keyword, or to a mutable borrowed pointer using ```ref mut```, or the value can be moved into
-the new binding using ```move```.
+Patterns that bind variables default to binding to a copy or move of the matched value
+(depending on the matched value's type).
+This can be made explicit using the ```copy``` keyword,
+changed to bind to a borrowed pointer by using the ```ref``` keyword,
+or to a mutable borrowed pointer using ```ref mut```.
 
 A pattern that's just an identifier,
 like `Nil` in the previous answer,

trunk/src/librustc/middle/lint.rs

@@ -82,9 +82,6 @@ pub enum lint {
     dead_assignment,
     unused_mut,
     unnecessary_allocation,
-
-    missing_struct_doc,
-    missing_trait_doc,
 }
 
 pub fn level_to_str(lv: level) -> &'static str {
@@ -255,20 +252,6 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         desc: "detects unnecessary allocations that can be eliminated",
         default: warn
     }),
-
-    ("missing_struct_doc",
-     LintSpec {
-        lint: missing_struct_doc,
-        desc: "detects missing documentation for structs",
-        default: allow
-    }),
-
-    ("missing_trait_doc",
-     LintSpec {
-        lint: missing_trait_doc,
-        desc: "detects missing documentation for traits",
-        default: allow
-    }),
 ];
 
 /*
@@ -969,58 +952,6 @@ fn lint_unnecessary_allocations(cx: @mut Context) -> visit::vt<()> {
     })
 }
 
-fn lint_missing_struct_doc(cx: @mut Context) -> visit::vt<()> {
-    visit::mk_simple_visitor(@visit::SimpleVisitor {
-        visit_struct_field: |field| {
-            let mut has_doc = false;
-            for field.node.attrs.each |attr| {
-                if attr.node.is_sugared_doc {
-                    has_doc = true;
-                    break;
-                }
-            }
-            if !has_doc {
-                cx.span_lint(missing_struct_doc, field.span, "missing documentation \
-                                                              for a field.");
-            }
-        },
-        .. *visit::default_simple_visitor()
-    })
-}
-
-fn lint_missing_trait_doc(cx: @mut Context) -> visit::vt<()> {
-    visit::mk_simple_visitor(@visit::SimpleVisitor {
-        visit_trait_method: |method| {
-            let mut has_doc = false;
-            let span = match copy *method {
-                ast::required(m) => {
-                    for m.attrs.each |attr| {
-                        if attr.node.is_sugared_doc {
-                            has_doc = true;
-                            break;
-                        }
-                    }
-                    m.span
-                },
-                ast::provided(m) => {
-                    for m.attrs.each |attr| {
-                        if attr.node.is_sugared_doc {
-                            has_doc = true;
-                            break;
-                        }
-                    }
-                    m.span
-                }
-            };
-            if !has_doc {
-                cx.span_lint(missing_trait_doc, span, "missing documentation \
-                                                        for a method.");
-            }
-        },
-        .. *visit::default_simple_visitor()
-    })
-}
-
 pub fn check_crate(tcx: ty::ctxt, crate: @ast::crate) {
     let cx = @mut Context {
         dict: @get_lint_dict(),
@@ -1049,8 +980,6 @@ pub fn check_crate(tcx: ty::ctxt, crate: @ast::crate) {
     cx.add_lint(lint_unused_mut(cx));
     cx.add_lint(lint_session(cx));
     cx.add_lint(lint_unnecessary_allocations(cx));
-    cx.add_lint(lint_missing_struct_doc(cx));
-    cx.add_lint(lint_missing_trait_doc(cx));
 
     // type inference doesn't like this being declared below, we need to tell it
     // what the type of this first function is...

trunk/src/libstd/cell.rs

@@ -21,24 +21,11 @@ Similar to a mutable option type, but friendlier.
 */
 
 #[mutable]
-#[deriving(Clone)]
+#[deriving(Clone, DeepClone, Eq)]
 pub struct Cell<T> {
     priv value: Option<T>
 }
 
-impl<T: DeepClone> DeepClone for Cell<T> {
-    fn deep_clone(&self) -> Cell<T> {
-        Cell{value: self.value.deep_clone()}
-    }
-}
-
-impl<T:cmp::Eq> cmp::Eq for Cell<T> {
-    fn eq(&self, other: &Cell<T>) -> bool {
-        (self.value) == (other.value)
-    }
-    fn ne(&self, other: &Cell<T>) -> bool { !self.eq(other) }
-}
-
 /// Creates a new full cell with the given value.
 pub fn Cell<T>(value: T) -> Cell<T> {
     Cell { value: Some(value) }

trunk/src/libstd/option.rs

@@ -54,21 +54,12 @@ use clone::DeepClone;
 #[cfg(test)] use str;
 
 /// The option type
-#[deriving(Clone, Eq)]
+#[deriving(Clone, DeepClone, Eq)]
 pub enum Option<T> {
     None,
     Some(T),
 }
 
-impl<T: DeepClone> DeepClone for Option<T> {
-    fn deep_clone(&self) -> Option<T> {
-        match *self {
-            Some(ref x) => Some(x.deep_clone()),
-            None => None
-        }
-    }
-}
-
 impl<T:Ord> Ord for Option<T> {
     fn lt(&self, other: &Option<T>) -> bool {
         match (self, other) {