---

yaml
---
r: 65264
b: refs/heads/master
c: b5ab101
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 3d61931fcac13aadc88ece7e48567f7ff503fba5
+refs/heads/master: b5ab1012f1f5786f550e511ba1302a22c85fcd71
 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,69 +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 relevant = match field.node.kind {
-                ast::named_field(_, vis) => vis != ast::private,
-                ast::unnamed_field => false,
-            };
-
-            if relevant {
-                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) => {
-                    if m.vis == ast::private {
-                        has_doc = true;
-                    } else {
-                        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(),
@@ -1060,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) {

trunk/src/libsyntax/parse/lexer.rs

@@ -247,7 +247,8 @@ fn consume_whitespace_and_comments(rdr: @mut StringReader)
 }
 
 pub fn is_line_non_doc_comment(s: &str) -> bool {
-    s.trim_right().all(|ch| ch == '/')
+    let s = s.trim_right();
+    s.len() > 3 && s.all(|ch| ch == '/')
 }
 
 // PRECONDITION: rdr.curr is not whitespace
@@ -268,7 +269,7 @@ fn consume_any_line_comment(rdr: @mut StringReader)
                     str::push_char(&mut acc, rdr.curr);
                     bump(rdr);
                 }
-                // but comments with only "/"s are not
+                // but comments with only more "/"s are not
                 if !is_line_non_doc_comment(acc) {
                     return Some(TokenAndSpan{
                         tok: token::DOC_COMMENT(rdr.interner.intern(acc)),
@@ -891,4 +892,10 @@ mod test {
         let id = env.interner.intern("abc");
         assert_eq!(tok, token::LIFETIME(id));
     }
+
+    #[test] fn line_doc_comments() {
+        assert!(!is_line_non_doc_comment("///"));
+        assert!(!is_line_non_doc_comment("/// blah"));
+        assert!(is_line_non_doc_comment("////"));
+    }
 }