src/librustc_lint/bad_style.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use rustc::hir::def::Def;
  12 use rustc::ty;
  13 use lint::{LateContext, LintContext, LintArray};
  14 use lint::{LintPass, LateLintPass};
  15
  16 use syntax::abi::Abi;
  17 use syntax::ast;
  18 use syntax::attr;
  19 use syntax_pos::Span;
  20
  21 use rustc::hir::{self, PatKind};
  22 use rustc::hir::intravisit::FnKind;
  23
  24 #[derive(PartialEq)]
  25 pub enum MethodLateContext {
  26     TraitAutoImpl,
  27     TraitImpl,
  28     PlainImpl,
  29 }
  30
  31 pub fn method_context(cx: &LateContext, id: ast::NodeId) -> MethodLateContext {
  32     let def_id = cx.tcx.hir.local_def_id(id);
  33     let item = cx.tcx.associated_item(def_id);
  34     match item.container {
  35         ty::TraitContainer(..) => MethodLateContext::TraitAutoImpl,
  36         ty::ImplContainer(cid) => {
  37             match cx.tcx.impl_trait_ref(cid) {
  38                 Some(_) => MethodLateContext::TraitImpl,
  39                 None => MethodLateContext::PlainImpl,
  40             }
  41         }
  42     }
  43 }
  44
  45 declare_lint! {
  46     pub NON_CAMEL_CASE_TYPES,
  47     Warn,
  48     "types, variants, traits and type parameters should have camel case names"
  49 }
  50
  51 #[derive(Copy, Clone)]
  52 pub struct NonCamelCaseTypes;
  53
  54 impl NonCamelCaseTypes {
  55     fn check_case(&self, cx: &LateContext, sort: &str, name: ast::Name, span: Span) {
  56         fn char_has_case(c: char) -> bool {
  57             c.is_lowercase() || c.is_uppercase()
  58         }
  59
  60         fn is_camel_case(name: ast::Name) -> bool {
  61             let name = name.as_str();
  62             if name.is_empty() {
  63                 return true;
  64             }
  65             let name = name.trim_matches('_');
  66
  67             // start with a non-lowercase letter rather than non-uppercase
  68             // ones (some scripts don't have a concept of upper/lowercase)
  69             !name.is_empty() && !name.chars().next().unwrap().is_lowercase() &&
  70                 !name.contains("__") && !name.chars().collect::<Vec<_>>().windows(2).any(|pair| {
  71                     // contains a capitalisable character followed by, or preceded by, an underscore
  72                     char_has_case(pair[0]) && pair[1] == '_' ||
  73                     char_has_case(pair[1]) && pair[0] == '_'
  74                 })
  75         }
  76
  77         fn to_camel_case(s: &str) -> String {
  78             s.trim_matches('_')
  79                 .split('_')
  80                 .map(|word| {
  81                     word.chars().enumerate().map(|(i, c)| if i == 0 {
  82                         c.to_uppercase().collect::<String>()
  83                     } else {
  84                         c.to_lowercase().collect()
  85                     })
  86                     .collect::<Vec<_>>()
  87                     .concat()
  88                 })
  89                 .filter(|x| !x.is_empty())
  90                 .collect::<Vec<_>>()
  91                 .iter().fold((String::new(), None), |(acc, prev): (String, Option<&String>), next| {
  92                     // separate two components with an underscore if their boundary cannot
  93                     // be distinguished using a uppercase/lowercase case distinction
  94                     let join = if let Some(prev) = prev {
  95                                     let l = prev.chars().last().unwrap();
  96                                     let f = next.chars().next().unwrap();
  97                                     !char_has_case(l) && !char_has_case(f)
  98                                 } else { false };
  99                     (acc + if join { "_" } else { "" } + next, Some(next))
 100                 }).0
 101         }
 102
 103         if !is_camel_case(name) {
 104             let c = to_camel_case(&name.as_str());
 105             let m = if c.is_empty() {
 106                 format!("{} `{}` should have a camel case name such as `CamelCase`", sort, name)
 107             } else {
 108                 format!("{} `{}` should have a camel case name such as `{}`", sort, name, c)
 109             };
 110             cx.span_lint(NON_CAMEL_CASE_TYPES, span, &m);
 111         }
 112     }
 113 }
 114
 115 impl LintPass for NonCamelCaseTypes {
 116     fn get_lints(&self) -> LintArray {
 117         lint_array!(NON_CAMEL_CASE_TYPES)
 118     }
 119 }
 120
 121 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonCamelCaseTypes {
 122     fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
 123         let has_repr_c = it.attrs
 124             .iter()
 125             .any(|attr| {
 126                 attr::find_repr_attrs(cx.tcx.sess.diagnostic(), attr)
 127                     .iter()
 128                     .any(|r| r == &attr::ReprC)
 129             });
 130
 131         if has_repr_c {
 132             return;
 133         }
 134
 135         match it.node {
 136             hir::ItemTy(..) |
 137             hir::ItemEnum(..) |
 138             hir::ItemStruct(..) |
 139             hir::ItemUnion(..) => self.check_case(cx, "type", it.name, it.span),
 140             hir::ItemTrait(..) => self.check_case(cx, "trait", it.name, it.span),
 141             _ => (),
 142         }
 143     }
 144
 145     fn check_variant(&mut self, cx: &LateContext, v: &hir::Variant, _: &hir::Generics) {
 146         self.check_case(cx, "variant", v.node.name, v.span);
 147     }
 148
 149     fn check_generic_param(&mut self, cx: &LateContext, param: &hir::GenericParam) {
 150         if let hir::GenericParam::Type(ref gen) = *param {
 151             if gen.synthetic.is_none() {
 152                 self.check_case(cx, "type parameter", gen.name, gen.span);
 153             }
 154         }
 155     }
 156 }
 157
 158 declare_lint! {
 159     pub NON_SNAKE_CASE,
 160     Warn,
 161     "variables, methods, functions, lifetime parameters and modules should have snake case names"
 162 }
 163
 164 #[derive(Copy, Clone)]
 165 pub struct NonSnakeCase;
 166
 167 impl NonSnakeCase {
 168     fn to_snake_case(mut str: &str) -> String {
 169         let mut words = vec![];
 170         // Preserve leading underscores
 171         str = str.trim_left_matches(|c: char| {
 172             if c == '_' {
 173                 words.push(String::new());
 174                 true
 175             } else {
 176                 false
 177             }
 178         });
 179         for s in str.split('_') {
 180             let mut last_upper = false;
 181             let mut buf = String::new();
 182             if s.is_empty() {
 183                 continue;
 184             }
 185             for ch in s.chars() {
 186                 if !buf.is_empty() && buf != "'" && ch.is_uppercase() && !last_upper {
 187                     words.push(buf);
 188                     buf = String::new();
 189                 }
 190                 last_upper = ch.is_uppercase();
 191                 buf.extend(ch.to_lowercase());
 192             }
 193             words.push(buf);
 194         }
 195         words.join("_")
 196     }
 197
 198     fn check_snake_case(&self, cx: &LateContext, sort: &str, name: &str, span: Option<Span>) {
 199         fn is_snake_case(ident: &str) -> bool {
 200             if ident.is_empty() {
 201                 return true;
 202             }
 203             let ident = ident.trim_left_matches('\'');
 204             let ident = ident.trim_matches('_');
 205
 206             let mut allow_underscore = true;
 207             ident.chars().all(|c| {
 208                 allow_underscore = match c {
 209                     '_' if !allow_underscore => return false,
 210                     '_' => false,
 211                     // It would be more obvious to use `c.is_lowercase()`,
 212                     // but some characters do not have a lowercase form
 213                     c if !c.is_uppercase() => true,
 214                     _ => return false,
 215                 };
 216                 true
 217             })
 218         }
 219
 220         if !is_snake_case(name) {
 221             let sc = NonSnakeCase::to_snake_case(name);
 222             let msg = if sc != name {
 223                 format!("{} `{}` should have a snake case name such as `{}`",
 224                         sort,
 225                         name,
 226                         sc)
 227             } else {
 228                 format!("{} `{}` should have a snake case name", sort, name)
 229             };
 230             match span {
 231                 Some(span) => cx.span_lint(NON_SNAKE_CASE, span, &msg),
 232                 None => cx.lint(NON_SNAKE_CASE, &msg),
 233             }
 234         }
 235     }
 236 }
 237
 238 impl LintPass for NonSnakeCase {
 239     fn get_lints(&self) -> LintArray {
 240         lint_array!(NON_SNAKE_CASE)
 241     }
 242 }
 243
 244 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase {
 245     fn check_crate(&mut self, cx: &LateContext, cr: &hir::Crate) {
 246         let attr_crate_name = attr::find_by_name(&cr.attrs, "crate_name")
 247             .and_then(|at| at.value_str().map(|s| (at, s)));
 248         if let Some(ref name) = cx.tcx.sess.opts.crate_name {
 249             self.check_snake_case(cx, "crate", name, None);
 250         } else if let Some((attr, name)) = attr_crate_name {
 251             self.check_snake_case(cx, "crate", &name.as_str(), Some(attr.span));
 252         }
 253     }
 254
 255     fn check_generic_param(&mut self, cx: &LateContext, param: &hir::GenericParam) {
 256         if let hir::GenericParam::Lifetime(ref ld) = *param {
 257             self.check_snake_case(
 258                 cx,
 259                 "lifetime",
 260                 &ld.lifetime.name.name().as_str(),
 261                 Some(ld.lifetime.span)
 262             );
 263         }
 264     }
 265
 266     fn check_fn(&mut self,
 267                 cx: &LateContext,
 268                 fk: FnKind,
 269                 _: &hir::FnDecl,
 270                 _: &hir::Body,
 271                 span: Span,
 272                 id: ast::NodeId) {
 273         match fk {
 274             FnKind::Method(name, ..) => {
 275                 match method_context(cx, id) {
 276                     MethodLateContext::PlainImpl => {
 277                         self.check_snake_case(cx, "method", &name.as_str(), Some(span))
 278                     }
 279                     MethodLateContext::TraitAutoImpl => {
 280                         self.check_snake_case(cx, "trait method", &name.as_str(), Some(span))
 281                     }
 282                     _ => (),
 283                 }
 284             }
 285             FnKind::ItemFn(name, _, _, _, abi, _, attrs) => {
 286                 // Skip foreign-ABI #[no_mangle] functions (Issue #31924)
 287                 if abi != Abi::Rust && attr::find_by_name(attrs, "no_mangle").is_some() {
 288                     return;
 289                 }
 290                 self.check_snake_case(cx, "function", &name.as_str(), Some(span))
 291             }
 292             FnKind::Closure(_) => (),
 293         }
 294     }
 295
 296     fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
 297         if let hir::ItemMod(_) = it.node {
 298             self.check_snake_case(cx, "module", &it.name.as_str(), Some(it.span));
 299         }
 300     }
 301
 302     fn check_trait_item(&mut self, cx: &LateContext, item: &hir::TraitItem) {
 303         if let hir::TraitItemKind::Method(_, hir::TraitMethod::Required(ref names)) = item.node {
 304             self.check_snake_case(cx,
 305                                   "trait method",
 306                                   &item.name.as_str(),
 307                                   Some(item.span));
 308             for name in names {
 309                 self.check_snake_case(cx, "variable", &name.node.as_str(), Some(name.span));
 310             }
 311         }
 312     }
 313
 314     fn check_pat(&mut self, cx: &LateContext, p: &hir::Pat) {
 315         if let &PatKind::Binding(_, _, ref path1, _) = &p.node {
 316             self.check_snake_case(cx, "variable", &path1.node.as_str(), Some(p.span));
 317         }
 318     }
 319
 320     fn check_struct_def(&mut self,
 321                         cx: &LateContext,
 322                         s: &hir::VariantData,
 323                         _: ast::Name,
 324                         _: &hir::Generics,
 325                         _: ast::NodeId) {
 326         for sf in s.fields() {
 327             self.check_snake_case(cx, "structure field", &sf.name.as_str(), Some(sf.span));
 328         }
 329     }
 330 }
 331
 332 declare_lint! {
 333     pub NON_UPPER_CASE_GLOBALS,
 334     Warn,
 335     "static constants should have uppercase identifiers"
 336 }
 337
 338 #[derive(Copy, Clone)]
 339 pub struct NonUpperCaseGlobals;
 340
 341 impl NonUpperCaseGlobals {
 342     fn check_upper_case(cx: &LateContext, sort: &str, name: ast::Name, span: Span) {
 343         if name.as_str().chars().any(|c| c.is_lowercase()) {
 344             let uc = NonSnakeCase::to_snake_case(&name.as_str()).to_uppercase();
 345             if name != &*uc {
 346                 cx.span_lint(NON_UPPER_CASE_GLOBALS,
 347                              span,
 348                              &format!("{} `{}` should have an upper case name such as `{}`",
 349                                       sort,
 350                                       name,
 351                                       uc));
 352             } else {
 353                 cx.span_lint(NON_UPPER_CASE_GLOBALS,
 354                              span,
 355                              &format!("{} `{}` should have an upper case name", sort, name));
 356             }
 357         }
 358     }
 359 }
 360
 361 impl LintPass for NonUpperCaseGlobals {
 362     fn get_lints(&self) -> LintArray {
 363         lint_array!(NON_UPPER_CASE_GLOBALS)
 364     }
 365 }
 366
 367 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonUpperCaseGlobals {
 368     fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
 369         match it.node {
 370             hir::ItemStatic(..) => {
 371                 if attr::find_by_name(&it.attrs, "no_mangle").is_some() {
 372                     return;
 373                 }
 374                 NonUpperCaseGlobals::check_upper_case(cx, "static variable", it.name, it.span);
 375             }
 376             hir::ItemConst(..) => {
 377                 NonUpperCaseGlobals::check_upper_case(cx, "constant", it.name, it.span);
 378             }
 379             _ => {}
 380         }
 381     }
 382
 383     fn check_trait_item(&mut self, cx: &LateContext, ti: &hir::TraitItem) {
 384         match ti.node {
 385             hir::TraitItemKind::Const(..) => {
 386                 NonUpperCaseGlobals::check_upper_case(cx, "associated constant", ti.name, ti.span);
 387             }
 388             _ => {}
 389         }
 390     }
 391
 392     fn check_impl_item(&mut self, cx: &LateContext, ii: &hir::ImplItem) {
 393         match ii.node {
 394             hir::ImplItemKind::Const(..) => {
 395                 NonUpperCaseGlobals::check_upper_case(cx, "associated constant", ii.name, ii.span);
 396             }
 397             _ => {}
 398         }
 399     }
 400
 401     fn check_pat(&mut self, cx: &LateContext, p: &hir::Pat) {
 402         // Lint for constants that look like binding identifiers (#7526)
 403         if let PatKind::Path(hir::QPath::Resolved(None, ref path)) = p.node {
 404             if let Def::Const(..) = path.def {
 405                 if path.segments.len() == 1 {
 406                     NonUpperCaseGlobals::check_upper_case(cx,
 407                                                           "constant in pattern",
 408                                                           path.segments[0].name,
 409                                                           path.span);
 410                 }
 411             }
 412         }
 413     }
 414 }