mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Format code

Browse Source
This commit is contained in:
Mateusz Mikuła 2018-05-22 10:21:42 +02:00 committed by Mateusz Mikuła
parent e4b954ea92
commit 3c6503eb4b
11 changed files with 134 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
build.rs
View File

@ -13,12 +13,12 @@
//! This build script was originally taken from the Rocket web framework:
//! https://github.com/SergioBenitez/Rocket
extern crate rustc_version;
extern crate ansi_term;
extern crate rustc_version;
use std::env;
use rustc_version::{version_meta, version_meta_for, Channel, Version, VersionMeta};
use ansi_term::Colour::Red;
use rustc_version::{version_meta, version_meta_for, Channel, Version, VersionMeta};
use std::env;
fn main() {
check_rustc_version();
@ -31,42 +31,48 @@ fn main() {
fn check_rustc_version() {
let string = include_str!("min_version.txt");
let min_version_meta = version_meta_for(string)
.expect("Could not parse version string in min_version.txt");
let current_version_meta = version_meta()
.expect("Could not retrieve current rustc version information from ENV");
let min_version_meta = version_meta_for(string).expect("Could not parse version string in min_version.txt");
let current_version_meta = version_meta().expect("Could not retrieve current rustc version information from ENV");
let min_version = min_version_meta.clone().semver;
let min_date_str = min_version_meta.clone().commit_date
let min_date_str = min_version_meta
.clone()
.commit_date
.expect("min_version.txt does not contain a rustc commit date");
// Dev channel (rustc built from git) does not have any date or commit information in rustc -vV
// `current_version_meta.commit_date` would crash, so we return early here.
if current_version_meta.channel == Channel::Dev {
return
return;
}
let current_version = current_version_meta.clone().semver;
let current_date_str = current_version_meta.clone().commit_date
let current_date_str = current_version_meta
.clone()
.commit_date
.expect("current rustc version information does not contain a rustc commit date");
let print_version_err = |version: &Version, date: &str| {
eprintln!("> {} {}. {} {}.\n",
"Installed rustc version is:",
format!("{} ({})", version, date),
"Minimum required rustc version:",
format!("{} ({})", min_version, min_date_str));
eprintln!(
"> {} {}. {} {}.\n",
"Installed rustc version is:",
format!("{} ({})", version, date),
"Minimum required rustc version:",
format!("{} ({})", min_version, min_date_str)
);
};
if !correct_channel(&current_version_meta) {
eprintln!("\n{} {}",
Red.bold().paint("error:"),
"clippy requires a nightly version of Rust.");
eprintln!(
"\n{} {}",
Red.bold().paint("error:"),
"clippy requires a nightly version of Rust."
);
print_version_err(&current_version, &*current_date_str);
eprintln!("{}{}{}",
"See the README (",
"https://github.com/rust-lang-nursery/rust-clippy#usage",
") for more information.");
eprintln!(
"{}{}{}",
"See the README (", "https://github.com/rust-lang-nursery/rust-clippy#usage", ") for more information."
);
panic!("Aborting compilation due to incompatible compiler.")
}
@ -74,13 +80,15 @@ fn check_rustc_version() {
let min_date = str_to_ymd(&min_date_str).unwrap();
if current_date < min_date {
eprintln!("\n{} {}",
Red.bold().paint("error:"),
"clippy does not support this version of rustc nightly.");
eprintln!("> {}{}{}",
"Use `",
"rustup update",
"` or your preferred method to update Rust.");
eprintln!(
"\n{} {}",
Red.bold().paint("error:"),
"clippy does not support this version of rustc nightly."
);
eprintln!(
"> {}{}{}",
"Use `", "rustup update", "` or your preferred method to update Rust."
);
print_version_err(&current_version, &*current_date_str);
panic!("Aborting compilation due to incompatible compiler.")
}
@ -88,12 +96,8 @@ fn check_rustc_version() {
fn correct_channel(version_meta: &VersionMeta) -> bool {
match version_meta.channel {
Channel::Stable | Channel::Beta => {
false
},
Channel::Nightly | Channel::Dev => {
true
}
Channel::Stable | Channel::Beta => false,
Channel::Nightly | Channel::Dev => true,
}
}
@ -101,7 +105,7 @@ fn correct_channel(version_meta: &VersionMeta) -> bool {
fn str_to_ymd(ymd: &str) -> Option<u32> {
let ymd: Vec<u32> = ymd.split("-").filter_map(|s| s.parse::<u32>().ok()).collect();
if ymd.len() != 3 {
return None
return None;
}
let (y, m, d) = (ymd[0], ymd[1], ymd[2]);

5
clippy_lints/src/approx_const.rs
View File

@ -1,5 +1,5 @@
use rustc::lint::*;
use rustc::hir::*;
use rustc::lint::*;
use std::f64::consts as f64;
use syntax::ast::{FloatTy, Lit, LitKind};
use syntax::symbol;
@ -90,8 +90,7 @@ fn check_known_consts(cx: &LateContext, e: &Expr, s: &symbol::Symbol, module: &s
&format!(
"approximate value of `{}::consts::{}` found. \
Consider using it directly",
module,
&name
module, &name
),
);
return;

26
clippy_lints/src/arithmetic.rs
View File

@ -57,19 +57,19 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic {
match expr.node {
hir::ExprBinary(ref op, ref l, ref r) => {
match op.node {
hir::BiAnd |
hir::BiOr |
hir::BiBitAnd |
hir::BiBitOr |
hir::BiBitXor |
hir::BiShl |
hir::BiShr |
hir::BiEq |
hir::BiLt |
hir::BiLe |
hir::BiNe |
hir::BiGe |
hir::BiGt => return,
hir::BiAnd
| hir::BiOr
| hir::BiBitAnd
| hir::BiBitOr
| hir::BiBitXor
| hir::BiShl
| hir::BiShr
| hir::BiEq
| hir::BiLt
| hir::BiLe
| hir::BiNe
| hir::BiGe
| hir::BiGt => return,
_ => (),
}
let (l_ty, r_ty) = (cx.tables.expr_ty(l), cx.tables.expr_ty(r));

6
clippy_lints/src/array_indexing.rs
View File

@ -1,10 +1,10 @@
use consts::{constant, Constant};
use rustc::hir;
use rustc::lint::*;
use rustc::ty;
use rustc::hir;
use syntax::ast::RangeLimits;
use utils::{self, higher};
use utils::higher::Range;
use consts::{constant, Constant};
use utils::{self, higher};
/// **What it does:** Checks for out of bounds array indexing with a constant
/// index.

74
clippy_lints/src/assign_ops.rs
View File

@ -95,24 +95,28 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
MISREFACTORED_ASSIGN_OP,
expr.span,
"variable appears on both sides of an assignment operation",
|db| if let (Some(snip_a), Some(snip_r)) =
(snippet_opt(cx, assignee.span), snippet_opt(cx, rhs_other.span))
{
let a = &sugg::Sugg::hir(cx, assignee, "..");
let r = &sugg::Sugg::hir(cx, rhs, "..");
let long = format!("{} = {}", snip_a, sugg::make_binop(higher::binop(op.node), a, r));
db.span_suggestion(
expr.span,
&format!("Did you mean {} = {} {} {} or {}? Consider replacing it with",
snip_a, snip_a, op.node.as_str(), snip_r,
long),
format!("{} {}= {}", snip_a, op.node.as_str(), snip_r)
);
db.span_suggestion(
expr.span,
"or",
long
);
|db| {
if let (Some(snip_a), Some(snip_r)) =
(snippet_opt(cx, assignee.span), snippet_opt(cx, rhs_other.span))
{
let a = &sugg::Sugg::hir(cx, assignee, "..");
let r = &sugg::Sugg::hir(cx, rhs, "..");
let long =
format!("{} = {}", snip_a, sugg::make_binop(higher::binop(op.node), a, r));
db.span_suggestion(
expr.span,
&format!(
"Did you mean {} = {} {} {} or {}? Consider replacing it with",
snip_a,
snip_a,
op.node.as_str(),
snip_r,
long
),
format!("{} {}= {}", snip_a, op.node.as_str(), snip_r),
);
db.span_suggestion(expr.span, "or", long);
}
},
);
};
@ -189,14 +193,16 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
ASSIGN_OP_PATTERN,
expr.span,
"manual implementation of an assign operation",
|db| if let (Some(snip_a), Some(snip_r)) =
(snippet_opt(cx, assignee.span), snippet_opt(cx, rhs.span))
{
db.span_suggestion(
expr.span,
"replace it with",
format!("{} {}= {}", snip_a, op.node.as_str(), snip_r),
);
|db| {
if let (Some(snip_a), Some(snip_r)) =
(snippet_opt(cx, assignee.span), snippet_opt(cx, rhs.span))
{
db.span_suggestion(
expr.span,
"replace it with",
format!("{} {}= {}", snip_a, op.node.as_str(), snip_r),
);
}
},
);
}
@ -205,7 +211,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
let mut visitor = ExprVisitor {
assignee,
counter: 0,
cx
cx,
};
walk_expr(&mut visitor, e);
@ -218,13 +224,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
// a = b commutative_op a
if SpanlessEq::new(cx).ignore_fn().eq_expr(assignee, r) {
match op.node {
hir::BiAdd |
hir::BiMul |
hir::BiAnd |
hir::BiOr |
hir::BiBitXor |
hir::BiBitAnd |
hir::BiBitOr => {
hir::BiAdd
| hir::BiMul
| hir::BiAnd
| hir::BiOr
| hir::BiBitXor
| hir::BiBitAnd
| hir::BiBitOr => {
lint(assignee, l);
},
_ => {},

27
clippy_lints/src/attrs.rs
View File

@ -1,13 +1,16 @@
//! checks for attributes
use reexport::*;
use rustc::lint::*;
use rustc::hir::*;
use rustc::lint::*;
use rustc::ty::{self, TyCtxt};
use semver::Version;
use syntax::ast::{Attribute, AttrStyle, Lit, LitKind, MetaItemKind, NestedMetaItem, NestedMetaItemKind};
use syntax::ast::{AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem, NestedMetaItemKind};
use syntax::codemap::Span;
use utils::{in_macro, last_line_of_span, match_def_path, opt_def_id, paths, snippet_opt, span_lint, span_lint_and_then, without_block_comments};
use utils::{
in_macro, last_line_of_span, match_def_path, opt_def_id, paths, snippet_opt, span_lint, span_lint_and_then,
without_block_comments,
};
/// **What it does:** Checks for items annotated with `#[inline(always)]`,
/// unless the annotated function is empty or simply panics.
@ -118,7 +121,12 @@ pub struct AttrPass;
impl LintPass for AttrPass {
fn get_lints(&self) -> LintArray {
lint_array!(INLINE_ALWAYS, DEPRECATED_SEMVER, USELESS_ATTRIBUTE, EMPTY_LINE_AFTER_OUTER_ATTR)
lint_array!(
INLINE_ALWAYS,
DEPRECATED_SEMVER,
USELESS_ATTRIBUTE,
EMPTY_LINE_AFTER_OUTER_ATTR
)
}
}
@ -170,11 +178,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AttrPass {
"useless lint attribute",
|db| {
sugg = sugg.replacen("#[", "#![", 1);
db.span_suggestion(
line_span,
"if you just forgot a `!`, use",
sugg,
);
db.span_suggestion(line_span, "if you just forgot a `!`, use", sugg);
},
);
}
@ -234,10 +238,7 @@ fn is_relevant_block(tcx: TyCtxt, tables: &ty::TypeckTables, block: &Block) -> b
StmtExpr(ref expr, _) | StmtSemi(ref expr, _) => is_relevant_expr(tcx, tables, expr),
}
} else {
block
.expr
.as_ref()
.map_or(false, |e| is_relevant_expr(tcx, tables, e))
block.expr.as_ref().map_or(false, |e| is_relevant_expr(tcx, tables, e))
}
}

27
src/driver.rs
View File

@ -6,16 +6,16 @@
extern crate clippy_lints;
extern crate getopts;
extern crate rustc;
extern crate rustc_codegen_utils;
extern crate rustc_driver;
extern crate rustc_errors;
extern crate rustc_plugin;
extern crate rustc_codegen_utils;
extern crate syntax;
use rustc_driver::{driver, Compilation, CompilerCalls, RustcDefaultCalls};
use rustc_codegen_utils::codegen_backend::CodegenBackend;
use rustc::session::{config, Session};
use rustc::session::config::{ErrorOutputType, Input};
use rustc::session::{config, Session};
use rustc_codegen_utils::codegen_backend::CodegenBackend;
use rustc_driver::{driver, Compilation, CompilerCalls, RustcDefaultCalls};
use std::path::PathBuf;
use std::process::Command;
use syntax::ast;
@ -43,8 +43,7 @@ impl<'a> CompilerCalls<'a> for ClippyCompilerCalls {
descriptions: &rustc_errors::registry::Registry,
output: ErrorOutputType,
) -> Compilation {
self.default
.early_callback(matches, sopts, cfg, descriptions, output)
self.default.early_callback(matches, sopts, cfg, descriptions, output)
}
fn no_input(
&mut self,
@ -55,8 +54,7 @@ impl<'a> CompilerCalls<'a> for ClippyCompilerCalls {
ofile: &Option<PathBuf>,
descriptions: &rustc_errors::registry::Registry,
) -> Option<(Input, Option<PathBuf>)> {
self.default
.no_input(matches, sopts, cfg, odir, ofile, descriptions)
self.default.no_input(matches, sopts, cfg, odir, ofile, descriptions)
}
fn late_callback(
&mut self,
@ -118,7 +116,7 @@ impl<'a> CompilerCalls<'a> for ClippyCompilerCalls {
}
old(state);
});
control.compilation_done.stop = Compilation::Stop;
}
@ -185,15 +183,18 @@ pub fn main() {
// this check ensures that dependencies are built but not linted and the final
// crate is
// linted but not built
let clippy_enabled = env::var("CLIPPY_TESTS")
.ok()
.map_or(false, |val| val == "true")
let clippy_enabled = env::var("CLIPPY_TESTS").ok().map_or(false, |val| val == "true")
|| orig_args.iter().any(|s| s == "--emit=dep-info,metadata");
if clippy_enabled {
args.extend_from_slice(&["--cfg".to_owned(), r#"feature="cargo-clippy""#.to_owned()]);
if let Ok(extra_args) = env::var("CLIPPY_ARGS") {
args.extend(extra_args.split("__CLIPPY_HACKERY__").filter(|s| !s.is_empty()).map(str::to_owned));
args.extend(
extra_args
.split("__CLIPPY_HACKERY__")
.filter(|s| !s.is_empty())
.map(str::to_owned),
);
}
}

4
src/lib.rs
View File

@ -15,7 +15,9 @@ pub fn plugin_registrar(reg: &mut Registry) {
reg.sess.lint_store.with_read_lock(|lint_store| {
for (lint, _, _) in lint_store.get_lint_groups() {
reg.sess
.struct_warn("the clippy plugin is being deprecated, please use cargo clippy or rls with the clippy feature")
.struct_warn(
"the clippy plugin is being deprecated, please use cargo clippy or rls with the clippy feature",
)
.emit();
if lint == "clippy" {
// cargo clippy run on a crate that also uses the plugin

7
tests/compile-test.rs
View File

@ -3,8 +3,8 @@
extern crate compiletest_rs as compiletest;
extern crate test;
use std::path::{Path, PathBuf};
use std::env::{set_var, var};
use std::path::{Path, PathBuf};
fn clippy_driver_path() -> PathBuf {
if let Some(path) = option_env!("CLIPPY_DRIVER_PATH") {
@ -43,10 +43,7 @@ fn config(dir: &'static str, mode: &'static str) -> compiletest::Config {
config.run_lib_path = rustc_lib_path();
config.compile_lib_path = rustc_lib_path();
}
config.target_rustcflags = Some(format!(
"-L {0} -L {0}/deps -Dwarnings",
host_libs().display()
));
config.target_rustcflags = Some(format!("-L {0} -L {0}/deps -Dwarnings", host_libs().display()));
config.mode = cfg_mode;
config.build_base = if rustc_test_suite().is_some() {

5
tests/versioncheck.rs
View File

@ -7,10 +7,7 @@ fn check_that_clippy_lints_has_the_same_version_as_clippy() {
let clippy_meta = cargo_metadata::metadata(None).expect("could not obtain cargo metadata");
std::env::set_current_dir(std::env::current_dir().unwrap().join("clippy_lints")).unwrap();
let clippy_lints_meta = cargo_metadata::metadata(None).expect("could not obtain cargo metadata");
assert_eq!(
clippy_lints_meta.packages[0].version,
clippy_meta.packages[0].version
);
assert_eq!(clippy_lints_meta.packages[0].version, clippy_meta.packages[0].version);
for package in &clippy_meta.packages[0].dependencies {
if package.name == "clippy_lints" {
assert_eq!(

6
tests/without_block_comments.rs
View File

@ -7,9 +7,7 @@ fn test_lines_without_block_comments() {
println!("result: {:?}", result);
assert!(result.is_empty());
let result = without_block_comments(
vec!["", "/*", "", "*/", "#[crate_type = \"lib\"]", "/*", "", "*/", ""]
);
let result = without_block_comments(vec!["", "/*", "", "*/", "#[crate_type = \"lib\"]", "/*", "", "*/", ""]);
assert_eq!(result, vec!["", "#[crate_type = \"lib\"]", ""]);
let result = without_block_comments(vec!["/* rust", "", "*/"]);
@ -18,7 +16,7 @@ fn test_lines_without_block_comments() {
let result = without_block_comments(vec!["/* one-line comment */"]);
assert!(result.is_empty());
let result = without_block_comments(vec!["/* nested", "/* multi-line", "comment", "*/", "test", "*/"]);
let result = without_block_comments(vec!["/* nested", "/* multi-line", "comment", "*/", "test", "*/"]);
assert!(result.is_empty());
let result = without_block_comments(vec!["/* nested /* inline /* comment */ test */ */"]);