From c6316df19f14702a16c7be3685547def9ff21b21 Mon Sep 17 00:00:00 2001 From: mcarton Date: Thu, 10 Mar 2016 18:13:49 +0100 Subject: [PATCH 1/2] Rustup to 1.9.0-nightly (c9629d61c 2016-03-10) --- src/cyclomatic_complexity.rs | 7 ++++--- src/derive.rs | 2 +- src/eta_reduction.rs | 9 ++++++--- src/mut_reference.rs | 27 +++++++++++++++------------ tests/compile-fail/mut_reference.rs | 25 ++++++++++++++----------- 5 files changed, 40 insertions(+), 30 deletions(-) diff --git a/src/cyclomatic_complexity.rs b/src/cyclomatic_complexity.rs index b1b578af759..bc13576fe3b 100644 --- a/src/cyclomatic_complexity.rs +++ b/src/cyclomatic_complexity.rs @@ -124,13 +124,14 @@ impl<'a, 'b, 'tcx> Visitor<'a> for CCHelper<'b, 'tcx> { ExprCall(ref callee, _) => { walk_expr(self, e); let ty = self.tcx.node_id_to_type(callee.id); - if let ty::TyBareFn(_, ty) = ty.sty { - if ty.sig.skip_binder().output.diverges() { + match ty.sty { + ty::TyFnDef(_, _, ty) | ty::TyFnPtr(ty) if ty.sig.skip_binder().output.diverges() => { self.divergence += 1; } + _ => (), } } - ExprClosure(..) => {} + ExprClosure(..) => (), ExprBinary(op, _, _) => { walk_expr(self, e); match op.node { diff --git a/src/derive.rs b/src/derive.rs index 8bdcb4b0167..380ff0a30f9 100644 --- a/src/derive.rs +++ b/src/derive.rs @@ -155,7 +155,7 @@ fn check_copy_clone<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, item: &Item, trait_ref TypeVariants::TyArray(_, size) if size > 32 => { return; } - TypeVariants::TyBareFn(..) => { + TypeVariants::TyFnPtr(..) => { return; } TypeVariants::TyTuple(ref tys) if tys.len() > 12 => { diff --git a/src/eta_reduction.rs b/src/eta_reduction.rs index e28411cc79c..6335f3f1398 100644 --- a/src/eta_reduction.rs +++ b/src/eta_reduction.rs @@ -58,11 +58,14 @@ fn check_closure(cx: &LateContext, expr: &Expr) { return; } let fn_ty = cx.tcx.expr_ty(caller); - if let ty::TyBareFn(_, fn_ty) = fn_ty.sty { + match fn_ty.sty { // Is it an unsafe function? They don't implement the closure traits - if fn_ty.unsafety == Unsafety::Unsafe { - return; + ty::TyFnDef(_, _, fn_ty) | ty::TyFnPtr(fn_ty) => { + if fn_ty.unsafety == Unsafety::Unsafe { + return; + } } + _ => (), } for (ref a1, ref a2) in decl.inputs.iter().zip(args) { if let PatKind::Ident(_, ident, _) = a1.pat.node { diff --git a/src/mut_reference.rs b/src/mut_reference.rs index 0e5b038f27d..707ce8efaeb 100644 --- a/src/mut_reference.rs +++ b/src/mut_reference.rs @@ -53,21 +53,24 @@ impl LateLintPass for UnnecessaryMutPassed { } fn check_arguments(cx: &LateContext, arguments: &[P], type_definition: &TyS, name: &str) { - if let TypeVariants::TyBareFn(_, ref fn_type) = type_definition.sty { - let parameters = &fn_type.sig.skip_binder().inputs; - for (argument, parameter) in arguments.iter().zip(parameters.iter()) { - match parameter.sty { - TypeVariants::TyRef(_, TypeAndMut {mutbl: MutImmutable, ..}) | - TypeVariants::TyRawPtr(TypeAndMut {mutbl: MutImmutable, ..}) => { - if let ExprAddrOf(MutMutable, _) = argument.node { - span_lint(cx, - UNNECESSARY_MUT_PASSED, - argument.span, - &format!("The function/method \"{}\" doesn't need a mutable reference", name)); + match type_definition.sty { + TypeVariants::TyFnDef(_, _, ref fn_type) | TypeVariants::TyFnPtr(ref fn_type) => { + let parameters = &fn_type.sig.skip_binder().inputs; + for (argument, parameter) in arguments.iter().zip(parameters.iter()) { + match parameter.sty { + TypeVariants::TyRef(_, TypeAndMut {mutbl: MutImmutable, ..}) | + TypeVariants::TyRawPtr(TypeAndMut {mutbl: MutImmutable, ..}) => { + if let ExprAddrOf(MutMutable, _) = argument.node { + span_lint(cx, + UNNECESSARY_MUT_PASSED, + argument.span, + &format!("The function/method \"{}\" doesn't need a mutable reference", name)); + } } + _ => {} } - _ => {} } } + _ => (), } } diff --git a/tests/compile-fail/mut_reference.rs b/tests/compile-fail/mut_reference.rs index 7480add8e68..1d81ed14e4e 100644 --- a/tests/compile-fail/mut_reference.rs +++ b/tests/compile-fail/mut_reference.rs @@ -3,12 +3,8 @@ #![allow(unused_variables)] -fn takes_an_immutable_reference(a: &i32) { -} - - -fn takes_a_mutable_reference(a: &mut i32) { -} +fn takes_an_immutable_reference(a: &i32) {} +fn takes_a_mutable_reference(a: &mut i32) {} struct MyStruct; @@ -24,23 +20,30 @@ impl MyStruct { fn main() { // Functions takes_an_immutable_reference(&mut 42); //~ERROR The function/method "takes_an_immutable_reference" doesn't need a mutable reference - + let foo: fn(&i32) = takes_an_immutable_reference; + foo(&mut 42); //~ERROR The function/method "foo" doesn't need a mutable reference + // Methods let my_struct = MyStruct; my_struct.takes_an_immutable_reference(&mut 42); //~ERROR The function/method "takes_an_immutable_reference" doesn't need a mutable reference - + // No error - + // Functions takes_an_immutable_reference(&42); + let foo: fn(&i32) = takes_an_immutable_reference; + foo(&42); + takes_a_mutable_reference(&mut 42); + let foo: fn(&mut i32) = takes_a_mutable_reference; + foo(&mut 42); + let a = &mut 42; takes_an_immutable_reference(a); - + // Methods my_struct.takes_an_immutable_reference(&42); my_struct.takes_a_mutable_reference(&mut 42); my_struct.takes_an_immutable_reference(a); - } From 74412d9574139e6e7fb41da4b21ae83413f5213f Mon Sep 17 00:00:00 2001 From: mcarton Date: Fri, 11 Mar 2016 14:19:28 +0100 Subject: [PATCH 2/2] Bump to 0.0.50 --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 8ee5e8ab346..853815e049f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "clippy" -version = "0.0.49" +version = "0.0.50" authors = [ "Manish Goregaokar ", "Andre Bogus ",