---

yaml
---
r: 152143
b: refs/heads/try2
c: 16f15ce
h: refs/heads/master
i:
  152141: 14d7dad
  152139: 5bc8f26
  152135: 11de71b
  152127: 320b8a7
v: v3

Author: Ryman

[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: 36c2c56277b368e5200fc4a7e8ed6752562ce030
+refs/heads/try2: 16f15ce391b2b463d37ff7f5e764c7f55c33cc5d
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcollections/bitv.rs

@@ -12,11 +12,11 @@
 
 
 use std::cmp;
-use std::fmt;
 use std::iter::RandomAccessIterator;
 use std::iter::{Enumerate, Repeat, Map, Zip};
 use std::ops;
 use std::slice;
+use std::string::String;
 use std::uint;
 
 #[deriving(Clone)]
@@ -526,6 +526,25 @@ impl Bitv {
         Vec::from_fn(self.nbits, |i| self[i])
     }
 
+    /**
+     * Converts `self` to a string.
+     *
+     * The resulting string has the same length as `self`, and each
+     * character is either '0' or '1'.
+     */
+     pub fn to_str(&self) -> String {
+        let mut rs = String::new();
+        for i in self.iter() {
+            if i {
+                rs.push_char('1');
+            } else {
+                rs.push_char('0');
+            }
+        };
+        rs
+     }
+
+
     /**
      * Compare a bitvector to a vector of `bool`.
      *
@@ -585,15 +604,6 @@ impl ops::Index<uint,bool> for Bitv {
     }
 }
 
-impl fmt::Show for Bitv {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        for bit in self.iter() {
-            try!(write!(fmt, "{}", if bit { 1 } else { 0 }));
-        }
-        Ok(())
-    }
-}
-
 #[inline]
 fn iterate_bits(base: uint, bits: uint, f: |uint| -> bool) -> bool {
     if bits == 0 {
@@ -817,21 +827,6 @@ impl cmp::Eq for BitvSet {
     fn ne(&self, other: &BitvSet) -> bool { !self.eq(other) }
 }
 
-impl fmt::Show for BitvSet {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(fmt, r"\{"));
-        let mut first = true;
-        for n in self.iter() {
-            if !first {
-                try!(write!(fmt, ", "));
-            }
-            try!(write!(fmt, "{}", n));
-            first = false;
-        }
-        write!(fmt, r"\}")
-    }
-}
-
 impl Container for BitvSet {
     #[inline]
     fn len(&self) -> uint { self.size }
@@ -1634,16 +1629,6 @@ mod tests {
         assert!(!v.none());
     }
 
-    #[test]
-    fn test_bitv_set_show() {
-        let mut s = BitvSet::new();
-        s.insert(1);
-        s.insert(10);
-        s.insert(50);
-        s.insert(2);
-        assert_eq!("{1, 2, 10, 50}".to_string(), s.to_str());
-    }
-
     fn rng() -> rand::IsaacRng {
         let seed = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
         rand::SeedableRng::from_seed(seed)

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

@@ -83,6 +83,7 @@ pub enum Lint {
     NonCamelCaseTypes,
     NonUppercaseStatics,
     NonUppercasePatternStatics,
+    NonSnakeCaseFunctions,
     UppercaseVariables,
     UnnecessaryParens,
     TypeLimits,
@@ -220,6 +221,13 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
          default: Warn
      }),
 
+    ("non_snake_case_functions",
+     LintSpec {
+         lint: NonSnakeCaseFunctions,
+         desc: "methods and functions should have snake case names",
+         default: Warn
+     }),
+
     ("uppercase_variables",
      LintSpec {
          lint: UppercaseVariables,
@@ -1342,6 +1350,30 @@ fn check_item_non_camel_case_types(cx: &Context, it: &ast::Item) {
     }
 }
 
+fn check_snake_case(cx: &Context, sort: &str, ident: ast::Ident, span: Span) {
+    fn is_snake_case(ident: ast::Ident) -> bool {
+        let ident = token::get_ident(ident);
+        assert!(!ident.get().is_empty());
+        let ident = ident.get().trim_chars('_');
+
+        let mut allow_underscore = true;
+        ident.chars().all(|c| {
+            allow_underscore = match c {
+                c if c.is_lowercase() || c.is_digit() => true,
+                '_' if allow_underscore => false,
+                _ => return false,
+            };
+            true
+        })
+    }
+
+    if !is_snake_case(ident) {
+        cx.span_lint(NonSnakeCaseFunctions, span,
+                    format!("{} `{}` should have a snake case identifier",
+                            sort, token::get_ident(ident)).as_slice());
+    }
+}
+
 fn check_item_non_uppercase_statics(cx: &Context, it: &ast::Item) {
     match it.node {
         // only check static constants
@@ -1618,7 +1650,27 @@ fn check_missing_doc_item(cx: &Context, it: &ast::Item) {
                             desc);
 }
 
+#[deriving(Eq)]
+enum MethodContext {
+    TraitDefaultImpl,
+    TraitImpl,
+    PlainImpl
+}
+
 fn check_missing_doc_method(cx: &Context, m: &ast::Method) {
+    // If the method is an impl for a trait, don't doc.
+    if method_context(cx, m) == TraitImpl { return; }
+
+    // Otherwise, doc according to privacy. This will also check
+    // doc for default methods defined on traits.
+    check_missing_doc_attrs(cx,
+                            Some(m.id),
+                            m.attrs.as_slice(),
+                            m.span,
+                            "a method");
+}
+
+fn method_context(cx: &Context, m: &ast::Method) -> MethodContext {
     let did = ast::DefId {
         krate: ast::LOCAL_CRATE,
         node: m.id
@@ -1628,25 +1680,16 @@ fn check_missing_doc_method(cx: &Context, m: &ast::Method) {
         None => cx.tcx.sess.span_bug(m.span, "missing method descriptor?!"),
         Some(md) => {
             match md.container {
-                // Always check default methods defined on traits.
-                ty::TraitContainer(..) => {}
-                // For methods defined on impls, it depends on whether
-                // it is an implementation for a trait or is a plain
-                // impl.
+                ty::TraitContainer(..) => TraitDefaultImpl,
                 ty::ImplContainer(cid) => {
                     match ty::impl_trait_ref(cx.tcx, cid) {
-                        Some(..) => return, // impl for trait: don't doc
-                        None => {} // plain impl: doc according to privacy
+                        Some(..) => TraitImpl,
+                        None => PlainImpl
                     }
                 }
             }
         }
     }
-    check_missing_doc_attrs(cx,
-                            Some(m.id),
-                            m.attrs.as_slice(),
-                            m.span,
-                            "a method");
 }
 
 fn check_missing_doc_ty_method(cx: &Context, tm: &ast::TypeMethod) {
@@ -1889,26 +1932,36 @@ impl<'a> Visitor<()> for Context<'a> {
         }
 
         match *fk {
-            visit::FkMethod(_, _, m) => {
+            visit::FkMethod(ident, _, m) => {
                 self.with_lint_attrs(m.attrs.as_slice(), |cx| {
                     check_missing_doc_method(cx, m);
                     check_attrs_usage(cx, m.attrs.as_slice());
 
+                    match method_context(cx, m) {
+                        PlainImpl => check_snake_case(cx, "method", ident, span),
+                        TraitDefaultImpl => check_snake_case(cx, "trait method", ident, span),
+                        _ => (),
+                    }
+
                     cx.visit_ids(|v| {
                         v.visit_fn(fk, decl, body, span, id, ());
                     });
                     recurse(cx);
                 })
+            },
+            visit::FkItemFn(ident, _, _, _) => {
+                check_snake_case(self, "function", ident, span);
+                recurse(self);
             }
             _ => recurse(self),
         }
     }
 
-
     fn visit_ty_method(&mut self, t: &ast::TypeMethod, _: ()) {
         self.with_lint_attrs(t.attrs.as_slice(), |cx| {
             check_missing_doc_ty_method(cx, t);
             check_attrs_usage(cx, t.attrs.as_slice());
+            check_snake_case(cx, "trait method", t.ident, t.span);
 
             visit::walk_ty_method(cx, t, ());
         })

branches/try2/src/test/compile-fail/lint-non-snake-case-functions.rs

@@ -0,0 +1,51 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![deny(non_snake_case_functions)]
+#![allow(dead_code)]
+
+struct Foo;
+
+impl Foo {
+    fn Foo_Method() {}
+    //~^ ERROR method `Foo_Method` should have a snake case identifier
+
+    // Don't allow two underscores in a row
+    fn foo__method(&self) {}
+    //~^ ERROR method `foo__method` should have a snake case identifier
+
+    pub fn xyZ(&mut self) {}
+    //~^ ERROR method `xyZ` should have a snake case identifier
+}
+
+trait X {
+    fn ABC();
+    //~^ ERROR trait method `ABC` should have a snake case identifier
+
+    fn a_b_C(&self) {}
+    //~^ ERROR trait method `a_b_C` should have a snake case identifier
+
+    fn something__else(&mut self);
+    //~^ ERROR trait method `something__else` should have a snake case identifier
+}
+
+impl X for Foo {
+    // These errors should be caught at the trait definition not the impl
+    fn ABC() {}
+    fn something__else(&mut self) {}
+}
+
+fn Cookie() {}
+//~^ ERROR function `Cookie` should have a snake case identifier
+
+pub fn bi_S_Cuit() {}
+//~^ ERROR function `bi_S_Cuit` should have a snake case identifier
+
+fn main() { }