X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Fdoc.rs;h=a3278159ef575b0b2776056abcc5c9b184a690e9;hb=f5831523d335bc57a6371806b2ea1978942ac490;hp=9ed09d96e1b0055308b8240a053a91ac90916499;hpb=47be6927239cc8dabeb59764581fc4ac73327f22;p=rust.git diff --git a/clippy_lints/src/doc.rs b/clippy_lints/src/doc.rs index 9ed09d96e1b..a3278159ef5 100644 --- a/clippy_lints/src/doc.rs +++ b/clippy_lints/src/doc.rs @@ -1,10 +1,20 @@ +// Copyright 2014-2018 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass}; +use crate::rustc::{declare_tool_lint, lint_array}; +use crate::syntax::ast; +use crate::syntax::source_map::{BytePos, Span}; +use crate::syntax_pos::Pos; +use crate::utils::span_lint; use itertools::Itertools; use pulldown_cmark; -use rustc::lint::*; -use syntax::ast; -use syntax::codemap::{BytePos, Span}; -use syntax_pos::Pos; -use utils::span_lint; use url::Url; /// **What it does:** Checks for the presence of `_`, `::` or camel-case words @@ -12,7 +22,7 @@ /// /// **Why is this bad?** *Rustdoc* supports markdown formatting, `_`, `::` and /// camel-case probably indicates some code which should be included between -/// ticks. `_` can also be used for empasis in markdown, this lint tries to +/// ticks. `_` can also be used for emphasis in markdown, this lint tries to /// consider that. /// /// **Known problems:** Lots of bad docs won’t be fixed, what the lint checks @@ -21,13 +31,13 @@ /// **Examples:** /// ```rust /// /// Do something with the foo_bar parameter. See also -/// that::other::module::foo. +/// /// that::other::module::foo. /// // ^ `foo_bar` and `that::other::module::foo` should be ticked. /// fn doit(foo_bar) { .. } /// ``` -declare_lint! { +declare_clippy_lint! { pub DOC_MARKDOWN, - Warn, + pedantic, "presence of `_`, `::` or camel-case outside backticks in documentation" } @@ -38,9 +48,7 @@ pub struct Doc { impl Doc { pub fn new(valid_idents: Vec) -> Self { - Self { - valid_idents: valid_idents, - } + Self { valid_idents } } } @@ -51,11 +59,11 @@ fn get_lints(&self) -> LintArray { } impl EarlyLintPass for Doc { - fn check_crate(&mut self, cx: &EarlyContext, krate: &ast::Crate) { + fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &ast::Crate) { check_attrs(cx, &self.valid_idents, &krate.attrs); } - fn check_item(&mut self, cx: &EarlyContext, item: &ast::Item) { + fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) { check_attrs(cx, &self.valid_idents, &item.attrs); } } @@ -66,7 +74,7 @@ struct Parser<'a> { impl<'a> Parser<'a> { fn new(parser: pulldown_cmark::Parser<'a>) -> Self { - Self { parser: parser } + Self { parser } } } @@ -85,7 +93,7 @@ fn next(&mut self) -> Option { /// `syntax::parse::lexer::comments::strip_doc_comment_decoration` because we /// need to keep track of /// the spans but this function is inspired from the later. -#[allow(cast_possible_truncation)] +#[allow(clippy::cast_possible_truncation)] pub fn strip_doc_comment_decoration(comment: &str, span: Span) -> (String, Vec<(usize, Span)>) { // one-line comments lose their prefix const ONELINERS: &[&str] = &["///!", "///", "//!", "//"]; @@ -96,9 +104,7 @@ pub fn strip_doc_comment_decoration(comment: &str, span: Span) -> (String, Vec<( doc.push('\n'); return ( doc.to_owned(), - vec![ - (doc.len(), span.with_lo(span.lo() + BytePos(prefix.len() as u32))), - ], + vec![(doc.len(), span.with_lo(span.lo() + BytePos(prefix.len() as u32)))], ); } } @@ -138,7 +144,7 @@ pub fn strip_doc_comment_decoration(comment: &str, span: Span) -> (String, Vec<( panic!("not a doc-comment: {}", comment); } -pub fn check_attrs<'a>(cx: &EarlyContext, valid_idents: &[String], attrs: &'a [ast::Attribute]) { +pub fn check_attrs<'a>(cx: &EarlyContext<'_>, valid_idents: &[String], attrs: &'a [ast::Attribute]) { let mut doc = String::new(); let mut spans = vec![]; @@ -150,11 +156,9 @@ pub fn check_attrs<'a>(cx: &EarlyContext, valid_idents: &[String], attrs: &'a [a spans.extend_from_slice(¤t_spans); doc.push_str(¤t); } - } else if let Some(name) = attr.name() { + } else if attr.name() == "doc" { // ignore mix of sugared and non-sugared doc - if name == "doc" { - return; - } + return; } } @@ -187,7 +191,7 @@ pub fn check_attrs<'a>(cx: &EarlyContext, valid_idents: &[String], attrs: &'a [a } fn check_doc<'a, Events: Iterator)>>( - cx: &EarlyContext, + cx: &EarlyContext<'_>, valid_idents: &[String], docs: Events, spans: &[(usize, Span)], @@ -204,10 +208,9 @@ fn check_doc<'a, Events: Iterator)>>( End(CodeBlock(_)) | End(Code) => in_code = false, Start(Link(link, _)) => in_link = Some(link), End(Link(_, _)) => in_link = None, - Start(_tag) | End(_tag) => (), // We don't care about other tags + Start(_tag) | End(_tag) => (), // We don't care about other tags Html(_html) | InlineHtml(_html) => (), // HTML is weird, just ignore it - SoftBreak => (), - HardBreak => (), + SoftBreak | HardBreak => (), FootnoteReference(text) | Text(text) => { if Some(&text) == in_link.as_ref() { // Probably a link of the form `` @@ -234,7 +237,7 @@ fn check_doc<'a, Events: Iterator)>>( } } -fn check_text(cx: &EarlyContext, valid_idents: &[String], text: &str, span: Span) { +fn check_text(cx: &EarlyContext<'_>, valid_idents: &[String], text: &str, span: Span) { for word in text.split_whitespace() { // Trim punctuation as in `some comment (see foo::bar).` // ^^ @@ -257,7 +260,7 @@ fn check_text(cx: &EarlyContext, valid_idents: &[String], text: &str, span: Span } } -fn check_word(cx: &EarlyContext, word: &str, span: Span) { +fn check_word(cx: &EarlyContext<'_>, word: &str, span: Span) { /// Checks if a string is camel-case, ie. contains at least two uppercase /// letter (`Clippy` is /// ok) and one lower-case letter (`NASA` is ok). Plural are also excluded @@ -267,14 +270,11 @@ fn is_camel_case(s: &str) -> bool { return false; } - let s = if s.ends_with('s') { - &s[..s.len() - 1] - } else { - s - }; + let s = if s.ends_with('s') { &s[..s.len() - 1] } else { s }; - s.chars().all(char::is_alphanumeric) && s.chars().filter(|&c| c.is_uppercase()).take(2).count() > 1 && - s.chars().filter(|&c| c.is_lowercase()).take(1).count() > 0 + s.chars().all(char::is_alphanumeric) + && s.chars().filter(|&c| c.is_uppercase()).take(2).count() > 1 + && s.chars().filter(|&c| c.is_lowercase()).take(1).count() > 0 } fn has_underscore(s: &str) -> bool { @@ -284,10 +284,12 @@ fn has_underscore(s: &str) -> bool { if let Ok(url) = Url::parse(word) { // try to get around the fact that `foo::bar` parses as a valid URL if !url.cannot_be_a_base() { - span_lint(cx, - DOC_MARKDOWN, - span, - "you should put bare URLs between `<`/`>` or make a proper Markdown link"); + span_lint( + cx, + DOC_MARKDOWN, + span, + "you should put bare URLs between `<`/`>` or make a proper Markdown link", + ); return; }