From 35589738a113fb03b9f69689c91ed3102022c8fd Mon Sep 17 00:00:00 2001 From: Sergio Benitez Date: Mon, 4 Sep 2017 19:41:08 -0700 Subject: [PATCH] Update lints for latest nightly. --- codegen/build.rs | 4 ++-- codegen/src/lints/mod.rs | 18 ++++++++++++------ codegen/src/lints/utils.rs | 21 ++++++++++++--------- 3 files changed, 26 insertions(+), 17 deletions(-) diff --git a/codegen/build.rs b/codegen/build.rs index cd097465..875f3990 100644 --- a/codegen/build.rs +++ b/codegen/build.rs @@ -8,8 +8,8 @@ use yansi::Color::{Red, Yellow, Blue, White}; use version_check::{supports_features, is_min_version, is_min_date}; // Specifies the minimum nightly version needed to compile Rocket's codegen. -const MIN_DATE: &'static str = "2017-08-10"; -const MIN_VERSION: &'static str = "1.21.0-nightly"; +const MIN_DATE: &'static str = "2017-09-01"; +const MIN_VERSION: &'static str = "1.22.0-nightly"; fn main() { let ok_channel = supports_features(); diff --git a/codegen/src/lints/mod.rs b/codegen/src/lints/mod.rs index 784599d4..07e25d34 100644 --- a/codegen/src/lints/mod.rs +++ b/codegen/src/lints/mod.rs @@ -37,13 +37,15 @@ struct InstanceInfo { enum Receiver { Instance(DefId, Span), Call(NodeId, Span), + Relative(Span), } impl Receiver { /// Returns the span associated with the receiver. pub fn span(&self) -> Span { + use self::Receiver::*; match *self { - Receiver::Instance(_, sp) | Receiver::Call(_, sp) => sp + Instance(_, sp) | Call(_, sp) | Relative(sp) => sp } } } @@ -142,9 +144,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for RocketLint { // the receiver in the type table we've constructed. If it's there, we use // it, if not, we use the call as the receiver. fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { - /// Fetches the top-level `Receiver` instance given that a method call - /// was made to the receiver `rexpr`. Top-level here means "the - /// original". We search the `instance_vars` table to retrieve it. + // Fetches the top-level `Receiver` instance given that a method call + // was made to the receiver `rexpr`. Top-level here means "the + // original". We search the `instance_vars` table to retrieve it. let instance_for = |lint: &mut RocketLint, rexpr: &Expr| -> Option { match rexpr.node { ExprPath(QPath::Resolved(_, ref p)) => { @@ -152,8 +154,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for RocketLint { .and_then(|id| lint.instance_vars.get(&id)) .map(|recvr| recvr.clone()) } + ExprPath(QPath::TypeRelative(_, _)) => { + Some(Receiver::Relative(rexpr.span)) + } ExprCall(ref c, ..) => Some(Receiver::Call(c.id, rexpr.span)), - _ => unreachable!() + _ => panic!("Unexpected node: {:?}", rexpr.node) } }; @@ -256,7 +261,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for RocketLint { // Collect all of the `State` types and spans into `tys` and `spans`. let mut ty_and_spans: Vec<(Ty<'static>, Span)> = vec![]; - if let Some(sig) = cx.tables.liberated_fn_sigs.get(&fn_id) { + let fn_hir_id = cx.tcx.hir.node_to_hir_id(fn_id); + if let Some(sig) = cx.tables.liberated_fn_sigs().get(fn_hir_id) { for (i, input_ty) in sig.inputs().iter().enumerate() { let def_id = match input_ty.ty_to_def_id() { Some(id) => id, diff --git a/codegen/src/lints/utils.rs b/codegen/src/lints/utils.rs index 989208e2..11e0cd3a 100644 --- a/codegen/src/lints/utils.rs +++ b/codegen/src/lints/utils.rs @@ -46,8 +46,9 @@ pub fn match_def_path(tcx: ty::TyCtxt, def_id: DefId, path: &[&str]) -> bool { /// Check if the method call given in `expr` belongs to given type. pub fn is_impl_method(cx: &LateContext, expr: &Expr, path: &[&str]) -> bool { - cx.tables.type_dependent_defs - .get(&expr.id) + let hir_id = cx.tcx.hir.node_to_hir_id(expr.id); + cx.tables.type_dependent_defs() + .get(hir_id) .and_then(|callee| cx.tcx.impl_of_method(callee.def_id())) .map(|trt_id| match_def_path(cx.tcx, trt_id, path)) .unwrap_or(false) @@ -82,7 +83,8 @@ pub fn rocket_method_call<'e>(method: &str, pub fn is_rocket_start_call(cx: &LateContext, expr: &Expr) -> bool { if let ExprCall(ref expr, ..) = expr.node { if let ExprPath(ref qpath) = expr.node { - let def_id = cx.tables.qpath_def(qpath, expr.id).def_id(); + let hir_id = cx.tcx.hir.node_to_hir_id(expr.id); + let def_id = cx.tables.qpath_def(qpath, hir_id).def_id(); if match_def_path(cx.tcx, def_id, ROCKET_IGNITE_FN) { return true; } else if match_def_path(cx.tcx, def_id, ROCKET_IGNITE_STATIC) { @@ -116,7 +118,8 @@ pub fn extract_mount_fn_def_ids(cx: &LateContext, expr: &Expr) -> Vec { if let ExprAddrOf(_, ref expr) = args[0].node { // path to info_struct if let ExprPath(ref qpath) = expr.node { - let def = cx.tables.qpath_def(qpath, expr.id); + let hir_id = cx.tcx.hir.node_to_hir_id(expr.id); + let def = cx.tables.qpath_def(qpath, hir_id); output.push(def.def_id()); } } @@ -167,11 +170,11 @@ pub fn msg_and_help<'a, T: LintContext<'a>>(cx: &T, note: &str, help_sp: Option, help: &str) { - let mut b = cx.struct_span_lint(lint, msg_sp, msg); - b.note(note); + // Be conservative. If we don't know the receiver, don't emit the warning. if let Some(span) = help_sp { - b.span_help(span, help); + cx.struct_span_lint(lint, msg_sp, msg) + .note(note) + .span_help(span, help) + .emit() } - - b.emit(); }