Mirrors/rust-clippy
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-clippy synced 2024-11-28 07:30:57 +00:00
Code Issues Projects Releases Packages Wiki Activity

hir naming, removed lookup, match full path

Browse source
This commit is contained in:
llogiq 2015-09-05 13:15:18 +02:00
parent cd91110ec0
commit b90e4c7bd5
2 changed files with 18 additions and 35 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/consts.rs
View file

@ -154,8 +154,8 @@ impl PartialOrd for Constant {
fn lit_to_constant(lit: &Lit_) -> Constant {
match *lit {
LitStr(ref is, style) => ConstantStr(is.to_string(), style),
LitBinary(ref blob) => ConstantBinary(blob.clone()),
LitByte(b) => ConstantByte(b),
LitByteStr(ref s) => ConstantBinary(s.clone()),
LitChar(c) => ConstantChar(c),
LitInt(value, ty) => ConstantInt(value, ty),
LitFloat(ref is, ty) => ConstantFloat(is.to_string(), ty.into()),

51
src/minmax.rs
View file

@ -1,11 +1,10 @@
use rustc::lint::{Context, LintPass, LintArray};
use rustc_front::hir::*;
use syntax::codemap::Spanned;
use syntax::ptr::P;
use std::cmp::PartialOrd;
use std::cmp::Ordering::*;
use consts::{Constant, constant};
use consts::{Constant, constant_simple};
use utils::{match_path, span_lint};
use self::MinMax::{Min, Max};
@ -22,8 +21,8 @@ impl LintPass for MinMaxPass {
}
fn check_expr(&mut self, cx: &Context, expr: &Expr) {
if let Some((outer_max, outer_c, oe)) = min_max(cx, expr) {
if let Some((inner_max, inner_c, _)) = min_max(cx, oe) {
if let Some((outer_max, outer_c, oe)) = min_max(expr) {
if let Some((inner_max, inner_c, _)) = min_max(oe) {
if outer_max == inner_max { return; }
match (outer_max, outer_c.partial_cmp(&inner_c)) {
(_, None) | (Max, Some(Less)) | (Min, Some(Greater)) => (),
@ -43,47 +42,31 @@ enum MinMax {
Max,
}
fn min_max<'e>(cx: &Context, expr: &'e Expr) ->
Option<(MinMax, Constant, &'e Expr)> {
match expr.node {
ExprMethodCall(Spanned{node: ref ident, ..}, _, ref args) => {
let name = ident.name;
if name == "min" {
fetch_const(cx, args, Min)
fn min_max(expr: &Expr) -> Option<(MinMax, Constant, &Expr)> {
if let ExprCall(ref path, ref args) = expr.node {
if let ExprPath(None, ref path) = path.node {
if match_path(path, &["std", "cmp", "min"]) {
fetch_const(args, Min)
} else {
if name == "max" {
fetch_const(cx, args, Max)
if match_path(path, &["std", "cmp", "max"]) {
fetch_const(args, Max)
} else {
None
}
}
},
ExprCall(ref path, ref args) => {
if let &ExprPath(None, ref path) = &path.node {
if match_path(path, &["min"]) {
fetch_const(cx, args, Min)
} else {
if match_path(path, &["max"]) {
fetch_const(cx, args, Max)
} else {
None
}
}
} else { None }
},
_ => None,
}
} else { None }
} else { None }
}
fn fetch_const<'e>(cx: &Context, args: &'e Vec<P<Expr>>, m: MinMax) ->
Option<(MinMax, Constant, &'e Expr)> {
fn fetch_const(args: &[P<Expr>], m: MinMax) ->
Option<(MinMax, Constant, &Expr)> {
if args.len() != 2 { return None }
if let Some((c, _)) = constant(cx, &args[0]) {
if let None = constant(cx, &args[1]) { // otherwise ignore
if let Some(c) = constant_simple(&args[0]) {
if let None = constant_simple(&args[1]) { // otherwise ignore
Some((m, c, &args[1]))
} else { None }
} else {
if let Some((c, _)) = constant(cx, &args[1]) {
if let Some(c) = constant_simple(&args[1]) {
Some((m, c, &args[0]))
} else { None }
}