nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-05-14 02:49:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make a lint instead

Browse Source
This commit is contained in:
Guillaume Gomez 2017-07-16 00:17:35 +02:00
parent b68a03bded
commit 1cebf98e4c
8 changed files with 71 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/librustc/hir/mod.rs
View File

@ -892,6 +892,13 @@ impl Decl_ {
DeclItem(_) => &[]
}
}
pub fn is_local(&self) -> bool {
match *self {
Decl_::DeclLocal(_) => true,
_ => false,
}
}
}
/// represents one arm of a 'match'

40
src/librustc_lint/builtin.rs
View File

@ -722,6 +722,46 @@ impl EarlyLintPass for IllegalFloatLiteralPattern {
}
}
declare_lint! {
pub UNUSED_DOC_COMMENT,
Warn,
"detects doc comments that aren't used by rustdoc"
}
#[derive(Copy, Clone)]
pub struct UnusedDocComment;
impl LintPass for UnusedDocComment {
fn get_lints(&self) -> LintArray {
lint_array![UNUSED_DOC_COMMENT]
}
}
impl UnusedDocComment {
fn warn_if_doc<'a, 'tcx,
I: Iterator<Item=&'a ast::Attribute>,
C: LintContext<'tcx>>(&self, mut attrs: I, cx: &C) {
if let Some(attr) = attrs.find(|a| a.is_value_str() && a.check_name("doc")) {
cx.struct_span_lint(UNUSED_DOC_COMMENT, attr.span, "doc comment not used by rustdoc")
.emit();
}
}
}
impl EarlyLintPass for UnusedDocComment {
fn check_local(&mut self, cx: &EarlyContext, decl: &ast::Local) {
self.warn_if_doc(decl.attrs.iter(), cx);
}
fn check_arm(&mut self, cx: &EarlyContext, arm: &ast::Arm) {
self.warn_if_doc(arm.attrs.iter(), cx);
}
fn check_expr(&mut self, cx: &EarlyContext, expr: &ast::Expr) {
self.warn_if_doc(expr.attrs.iter(), cx);
}
}
declare_lint! {
pub UNCONDITIONAL_RECURSION,
Warn,

1
src/librustc_lint/lib.rs
View File

@ -111,6 +111,7 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
UnusedImportBraces,
AnonymousParameters,
IllegalFloatLiteralPattern,
UnusedDocComment,
);
add_early_builtin_with_new!(sess,

7
src/libsyntax/ast.rs
View File

@ -718,6 +718,13 @@ impl Stmt {
};
self
}
pub fn is_item(&self) -> bool {
match self.node {
StmtKind::Local(_) => true,
_ => false,
}
}
}
impl fmt::Debug for Stmt {

32
src/libsyntax/parse/parser.rs
View File

@ -2420,12 +2420,6 @@ impl<'a> Parser<'a> {
expr.map(|mut expr| {
attrs.extend::<Vec<_>>(expr.attrs.into());
expr.attrs = attrs;
if if let Some(ref doc) = expr.attrs.iter().find(|x| x.is_sugared_doc) {
self.span_fatal_err(doc.span, Error::UselessDocComment).emit();
true
} else { false } {
return expr;
}
match expr.node {
ExprKind::If(..) | ExprKind::IfLet(..) => {
if !expr.attrs.is_empty() {
@ -3110,9 +3104,6 @@ impl<'a> Parser<'a> {
// `else` token already eaten
pub fn parse_else_expr(&mut self) -> PResult<'a, P<Expr>> {
if self.prev_token_kind == PrevTokenKind::DocComment {
return Err(self.span_fatal_err(self.span, Error::UselessDocComment));
}
if self.eat_keyword(keywords::If) {
return self.parse_if_expr(ThinVec::new());
} else {
@ -3126,9 +3117,6 @@ impl<'a> Parser<'a> {
span_lo: Span,
mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
// Parse: `for <src_pat> in <src_expr> <src_loop_block>`
if let Some(doc) = attrs.iter().find(|x| x.is_sugared_doc) {
self.span_fatal_err(doc.span, Error::UselessDocComment).emit();
}
let pat = self.parse_pat()?;
self.expect_keyword(keywords::In)?;
@ -3144,9 +3132,6 @@ impl<'a> Parser<'a> {
pub fn parse_while_expr(&mut self, opt_ident: Option<ast::SpannedIdent>,
span_lo: Span,
mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
if let Some(doc) = attrs.iter().find(|x| x.is_sugared_doc) {
self.span_fatal_err(doc.span, Error::UselessDocComment).emit();
}
if self.token.is_keyword(keywords::Let) {
return self.parse_while_let_expr(opt_ident, span_lo, attrs);
}
@ -3175,9 +3160,6 @@ impl<'a> Parser<'a> {
pub fn parse_loop_expr(&mut self, opt_ident: Option<ast::SpannedIdent>,
span_lo: Span,
mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
if let Some(doc) = attrs.iter().find(|x| x.is_sugared_doc) {
self.span_fatal_err(doc.span, Error::UselessDocComment).emit();
}
let (iattrs, body) = self.parse_inner_attrs_and_block()?;
attrs.extend(iattrs);
let span = span_lo.to(body.span);
@ -3188,9 +3170,6 @@ impl<'a> Parser<'a> {
pub fn parse_catch_expr(&mut self, span_lo: Span, mut attrs: ThinVec<Attribute>)
-> PResult<'a, P<Expr>>
{
if let Some(doc) = attrs.iter().find(|x| x.is_sugared_doc) {
self.span_fatal_err(doc.span, Error::UselessDocComment).emit();
}
let (iattrs, body) = self.parse_inner_attrs_and_block()?;
attrs.extend(iattrs);
Ok(self.mk_expr(span_lo.to(body.span), ExprKind::Catch(body), attrs))
@ -3198,9 +3177,6 @@ impl<'a> Parser<'a> {
// `match` token already eaten
fn parse_match_expr(&mut self, mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
if let Some(doc) = attrs.iter().find(|x| x.is_sugared_doc) {
self.span_fatal_err(doc.span, Error::UselessDocComment).emit();
}
let match_span = self.prev_span;
let lo = self.prev_span;
let discriminant = self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL,
@ -3238,9 +3214,6 @@ impl<'a> Parser<'a> {
maybe_whole!(self, NtArm, |x| x);
let attrs = self.parse_outer_attributes()?;
if let Some(doc) = attrs.iter().find(|x| x.is_sugared_doc) {
self.span_fatal_err(doc.span, Error::UselessDocComment).emit();
}
let pats = self.parse_pats()?;
let guard = if self.eat_keyword(keywords::If) {
Some(self.parse_expr()?)
@ -3695,9 +3668,6 @@ impl<'a> Parser<'a> {
/// Parse a local variable declaration
fn parse_local(&mut self, attrs: ThinVec<Attribute>) -> PResult<'a, P<Local>> {
if let Some(doc) = attrs.iter().find(|x| x.is_sugared_doc) {
self.span_fatal_err(doc.span, Error::UselessDocComment).emit();
}
let lo = self.span;
let pat = self.parse_pat()?;
@ -4187,8 +4157,6 @@ impl<'a> Parser<'a> {
stmts.push(stmt);
} else if self.token == token::Eof {
break;
} else if let token::DocComment(_) = self.token {
return Err(self.span_fatal_err(self.span, Error::UselessDocComment));
} else {
// Found only `;` or `}`.
continue;

28
src/test/compile-fail/useless_comment.rs
View File

@ -8,19 +8,23 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
fn foo3() -> i32 {
let mut x = 12;
/// z //~ ERROR E0585
while x < 1 {
/// x //~ ERROR E0585
//~^ ERROR attributes on non-item statements and expressions are experimental
x += 1;
#![deny(unused_doc_comment)]
fn foo() {
/// a //~ ERROR unused doc comment
let x = 12;
/// b //~ ERROR unused doc comment
match x {
/// c //~ ERROR unused doc comment
1 => {},
_ => {}
}
/// d //~ ERROR E0585
return x;
/// foo //~ ERROR unused doc comment
unsafe {}
}
fn main() {
/// e //~ ERROR E0585
foo3();
}
foo();
}

25
src/test/compile-fail/useless_comment2.rs
View File

@ -1,25 +0,0 @@
// Copyright 2017 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.
fn foo() {
/// a //~ ERROR E0585
let x = 12;
/// b //~ ERROR E0585
match x {
/// c //~ ERROR E0585
1 => {},
_ => {}
}
}
fn main() {
foo();
}

22
src/test/compile-fail/useless_comment3.rs
View File

@ -1,22 +0,0 @@
// Copyright 2017 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.
fn foo() {
let x = 13;
/// x //~ ERROR E0585
if x == 12 {
/// y
println!("hello");
}
}
fn main() {
foo();
}