From f552f170db6da0133fb5452ea22cf80551dbc875 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Tue, 3 Jan 2017 09:19:17 -0800 Subject: [PATCH] Rustup to rustc 1.16.0-nightly (468227129 2017-01-03): Fix various type errors for rustup --- clippy_lints/src/attrs.rs | 4 ++-- clippy_lints/src/cyclomatic_complexity.rs | 2 +- clippy_lints/src/functions.rs | 2 +- clippy_lints/src/len_zero.rs | 2 +- clippy_lints/src/lifetimes.rs | 2 +- clippy_lints/src/methods.rs | 19 +++++++++++-------- clippy_lints/src/missing_doc.rs | 6 +++--- clippy_lints/src/ptr.rs | 2 +- clippy_lints/src/types.rs | 12 ++++++------ 9 files changed, 27 insertions(+), 24 deletions(-) diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs index df6ef64a7..7fdd8d212 100644 --- a/clippy_lints/src/attrs.rs +++ b/clippy_lints/src/attrs.rs @@ -172,8 +172,8 @@ fn is_relevant_impl(cx: &LateContext, item: &ImplItem) -> bool { fn is_relevant_trait(cx: &LateContext, item: &TraitItem) -> bool { match item.node { - MethodTraitItem(_, None) => true, - MethodTraitItem(_, Some(eid)) => is_relevant_expr(cx, cx.tcx.map.expr(eid)), + TraitItemKind::Method(_, None) => true, + TraitItemKind::Method(_, Some(eid)) => is_relevant_expr(cx, cx.tcx.map.expr(eid)), _ => false, } } diff --git a/clippy_lints/src/cyclomatic_complexity.rs b/clippy_lints/src/cyclomatic_complexity.rs index 897a578f1..34cd40a8f 100644 --- a/clippy_lints/src/cyclomatic_complexity.rs +++ b/clippy_lints/src/cyclomatic_complexity.rs @@ -106,7 +106,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CyclomaticComplexity { } fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { - if let MethodTraitItem(_, Some(eid)) = item.node { + if let TraitItemKind::Method(_, Some(eid)) = item.node { self.check(cx, cx.tcx.map.expr(eid), item.span); } } diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs index 5ad676e57..eb666dcc5 100644 --- a/clippy_lints/src/functions.rs +++ b/clippy_lints/src/functions.rs @@ -106,7 +106,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Functions { } fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::TraitItem) { - if let hir::MethodTraitItem(ref sig, eid) = item.node { + if let hir::TraitItemKind::Method(ref sig, eid) = item.node { // don't lint extern functions decls, it's not their fault if sig.abi == Abi::Rust { self.check_arg_number(cx, &sig.decl, item.span); diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs index 22835b488..ff19a59b5 100644 --- a/clippy_lints/src/len_zero.rs +++ b/clippy_lints/src/len_zero.rs @@ -90,7 +90,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LenZero { fn check_trait_items(cx: &LateContext, item: &Item, trait_items: &[TraitItem]) { fn is_named_self(item: &TraitItem, name: &str) -> bool { &*item.name.as_str() == name && - if let MethodTraitItem(ref sig, _) = item.node { + if let TraitItemKind::Method(ref sig, _) = item.node { if sig.decl.has_self() { sig.decl.inputs.len() == 1 } else { diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs index fa0afd90d..2a258ff5d 100644 --- a/clippy_lints/src/lifetimes.rs +++ b/clippy_lints/src/lifetimes.rs @@ -70,7 +70,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LifetimePass { } fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { - if let MethodTraitItem(ref sig, _) = item.node { + if let TraitItemKind::Method(ref sig, _) = item.node { check_fn_inner(cx, &sig.decl, &sig.generics, item.span); } } diff --git a/clippy_lints/src/methods.rs b/clippy_lints/src/methods.rs index 591b395fe..6d9860d92 100644 --- a/clippy_lints/src/methods.rs +++ b/clippy_lints/src/methods.rs @@ -1,7 +1,6 @@ use rustc::hir; use rustc::lint::*; use rustc::middle::const_val::ConstVal; -use rustc::middle::const_qualif::ConstQualif; use rustc::ty; use rustc::hir::def::Def; use rustc_const_eval::EvalHint::ExprTypeChecked; @@ -638,7 +637,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { let item = cx.tcx.map.expect_item(parent); if_let_chain! {[ let hir::ImplItemKind::Method(ref sig, _) = implitem.node, - let Some(explicit_self) = sig.decl.inputs.get(0).and_then(hir::Arg::to_self), + let Some(first_arg) = sig.decl.inputs.get(0), let hir::ItemImpl(_, _, _, None, _, _) = item.node, ], { // check missing trait implementations @@ -646,7 +645,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { if &*name.as_str() == method_name && sig.decl.inputs.len() == n_args && out_type.matches(&sig.decl.output) && - self_kind.matches(&explicit_self, false) { + self_kind.matches(&first_arg, false) { span_lint(cx, SHOULD_IMPLEMENT_TRAIT, implitem.span, &format!( "defining a method called `{}` on this type; consider implementing \ the `{}` trait or choosing a less ambiguous name", name, trait_name)); @@ -752,11 +751,12 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir: ) { // don't lint for constant values // FIXME: can we `expect` here instead of match? - if let Some(qualif) = cx.tcx.const_qualif_map.borrow().get(&arg.id) { - if !qualif.contains(ConstQualif::NOT_CONST) { - return; - } + let promotable = cx.tcx().rvalue_promotable_to_static.borrow() + .get(&arg.id).cloned().unwrap_or(true); + if !promotable { + return; } + // (path, fn_has_argument, methods, suffix) let know_types: &[(&[_], _, &[_], _)] = &[(&paths::BTREEMAP_ENTRY, false, &["or_insert"], "with"), @@ -1347,7 +1347,10 @@ enum SelfKind { } impl SelfKind { - fn matches(self, slf: &hir::ExplicitSelf, allow_value_for_ref: bool) -> bool { + fn matches(self, slf: &hir::Arg, allow_value_for_ref: bool) -> bool { + if !slf.has_self() { + return self == No; + } match (self, &slf.node) { (SelfKind::Value, &hir::SelfKind::Value(_)) | (SelfKind::Ref, &hir::SelfKind::Region(_, hir::Mutability::MutImmutable)) | diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs index 70696ea39..d5be44e8c 100644 --- a/clippy_lints/src/missing_doc.rs +++ b/clippy_lints/src/missing_doc.rs @@ -136,9 +136,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, trait_item: &'tcx hir::TraitItem) { let desc = match trait_item.node { - hir::ConstTraitItem(..) => "an associated constant", - hir::MethodTraitItem(..) => "a trait method", - hir::TypeTraitItem(..) => "an associated type", + hir::TraitItemKind::Const(..) => "an associated constant", + hir::TraitItemKind::Method(..) => "a trait method", + hir::TraitItemKind::Type(..) => "an associated type", }; self.check_missing_docs_attrs(cx, &trait_item.attrs, trait_item.span, desc); diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs index 2f74390cc..0b7bf3c30 100644 --- a/clippy_lints/src/ptr.rs +++ b/clippy_lints/src/ptr.rs @@ -73,7 +73,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PointerPass { } fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { - if let MethodTraitItem(ref sig, _) = item.node { + if let TraitItemKind::Method(ref sig, _) = item.node { check_fn(cx, &sig.decl, item.id); } } diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index 9912c5249..327e638d9 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -87,9 +87,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypePass { fn check_trait_item(&mut self, cx: &LateContext, item: &TraitItem) { match item.node { - ConstTraitItem(ref ty, _) | - TypeTraitItem(_, Some(ref ty)) => check_ty(cx, ty), - MethodTraitItem(ref sig, _) => check_fn_decl(cx, &sig.decl), + TraitItemKind::Const(ref ty, _) | + TraitItemKind::Type(_, Some(ref ty)) => check_ty(cx, ty), + TraitItemKind::Method(ref sig, _) => check_fn_decl(cx, &sig.decl), _ => (), } } @@ -624,9 +624,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeComplexityPass { fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { match item.node { - ConstTraitItem(ref ty, _) | - TypeTraitItem(_, Some(ref ty)) => self.check_type(cx, ty), - MethodTraitItem(MethodSig { ref decl, .. }, None) => self.check_fndecl(cx, decl), + TraitItemKind::Const(ref ty, _) | + TraitItemKind::Type(_, Some(ref ty)) => self.check_type(cx, ty), + TraitItemKind::Method(MethodSig { ref decl, .. }, None) => self.check_fndecl(cx, decl), // methods with default impl are covered by check_fn _ => (), }