!ident.char_at(0).is_lowercase() && !ident.contains_char('_')
}
+ fn to_camel_case(s: &str) -> String {
+ s.split('_').flat_map(|word| word.chars().enumerate().map(|(i, c)|
+ if i == 0 { c.to_uppercase() }
+ else { c }
+ )).collect()
+ }
+
fn check_case(cx: &Context, sort: &str, ident: ast::Ident, span: Span) {
+ let s = token::get_ident(ident);
+
if !is_camel_case(ident) {
cx.span_lint(
NonCamelCaseTypes, span,
- format!("{} `{}` should have a camel case identifier",
- sort, token::get_ident(ident)).as_slice());
+ format!("{} `{}` should have a camel case name such as `{}`",
+ sort, s, to_camel_case(s.get())).as_slice());
}
}
})
}
+ fn to_snake_case(str: &str) -> String {
+ let mut words = vec![];
+ for s in str.split('_') {
+ let mut buf = String::new();
+ if s.is_empty() { continue; }
+ for ch in s.chars() {
+ if !buf.is_empty() && ch.is_uppercase() {
+ words.push(buf);
+ buf = String::new();
+ }
+ buf.push_char(ch.to_lowercase());
+ }
+ words.push(buf);
+ }
+ words.connect("_")
+ }
+
+ let s = token::get_ident(ident);
+
if !is_snake_case(ident) {
cx.span_lint(NonSnakeCaseFunctions, span,
- format!("{} `{}` should have a snake case identifier",
- sort, token::get_ident(ident)).as_slice());
+ format!("{} `{}` should have a snake case name such as `{}`",
+ sort, s, to_snake_case(s.get())).as_slice());
}
}
// upper/lowercase)
if s.get().chars().any(|c| c.is_lowercase()) {
cx.span_lint(NonUppercaseStatics, it.span,
- "static constant should have an uppercase identifier");
+ format!("static constant `{}` should have an uppercase name \
+ such as `{}`", s.get(),
+ s.get().chars().map(|c| c.to_uppercase())
+ .collect::<String>().as_slice()).as_slice());
}
}
_ => {}
let s = token::get_ident(ident);
if s.get().chars().any(|c| c.is_lowercase()) {
cx.span_lint(NonUppercasePatternStatics, path.span,
- "static constant in pattern should be all caps");
+ format!("static constant in pattern `{}` should have an uppercase \
+ name such as `{}`", s.get(),
+ s.get().chars().map(|c| c.to_uppercase())
+ .collect::<String>().as_slice()).as_slice());
}
}
_ => {}
#![forbid(non_camel_case_types)]
#![allow(dead_code)]
-struct foo { //~ ERROR type `foo` should have a camel case identifier
+struct foo { //~ ERROR type `foo` should have a camel case name such as `Foo`
bar: int,
}
-enum foo2 { //~ ERROR type `foo2` should have a camel case identifier
+enum foo2 { //~ ERROR type `foo2` should have a camel case name such as `Foo2`
Bar
}
-struct foo3 { //~ ERROR type `foo3` should have a camel case identifier
+struct foo3 { //~ ERROR type `foo3` should have a camel case name such as `Foo3`
bar: int
}
-type foo4 = int; //~ ERROR type `foo4` should have a camel case identifier
+type foo4 = int; //~ ERROR type `foo4` should have a camel case name such as `Foo4`
enum Foo5 {
- bar //~ ERROR variant `bar` should have a camel case identifier
+ bar //~ ERROR variant `bar` should have a camel case name such as `Bar`
}
-trait foo6 { //~ ERROR trait `foo6` should have a camel case identifier
+trait foo6 { //~ ERROR trait `foo6` should have a camel case name such as `Foo6`
}
fn main() { }
impl Foo {
fn Foo_Method() {}
- //~^ ERROR method `Foo_Method` should have a snake case identifier
+ //~^ ERROR method `Foo_Method` should have a snake case name such as `foo_method`
// Don't allow two underscores in a row
fn foo__method(&self) {}
- //~^ ERROR method `foo__method` should have a snake case identifier
+ //~^ ERROR method `foo__method` should have a snake case name such as `foo_method`
pub fn xyZ(&mut self) {}
- //~^ ERROR method `xyZ` should have a snake case identifier
+ //~^ ERROR method `xyZ` should have a snake case name such as `xy_z`
}
trait X {
fn ABC();
- //~^ ERROR trait method `ABC` should have a snake case identifier
+ //~^ ERROR trait method `ABC` should have a snake case name such as `a_b_c`
fn a_b_C(&self) {}
- //~^ ERROR trait method `a_b_C` should have a snake case identifier
+ //~^ ERROR trait method `a_b_C` should have a snake case name such as `a_b_c`
fn something__else(&mut self);
- //~^ ERROR trait method `something__else` should have a snake case identifier
+ //~^ ERROR trait method `something__else` should have a snake case name such as `something_else`
}
impl X for Foo {
}
fn Cookie() {}
-//~^ ERROR function `Cookie` should have a snake case identifier
+//~^ ERROR function `Cookie` should have a snake case name such as `cookie`
pub fn bi_S_Cuit() {}
-//~^ ERROR function `bi_S_Cuit` should have a snake case identifier
+//~^ ERROR function `bi_S_Cuit` should have a snake case name such as `bi_s_cuit`
fn main() { }