-use rustc::hir::intravisit as visit;
-use rustc::hir::{self, *};
-use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
-use rustc::middle::expr_use_visitor::*;
-use rustc::middle::mem_categorization::{cmt_, Categorization};
use rustc::ty::layout::LayoutOf;
use rustc::ty::{self, Ty};
-use rustc::util::nodemap::HirIdSet;
-use rustc::{declare_tool_lint, impl_lint_pass};
-use syntax::source_map::Span;
+use rustc_hir::intravisit as visit;
+use rustc_hir::HirIdSet;
+use rustc_hir::{self, *};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::source_map::Span;
+use rustc_typeck::expr_use_visitor::*;
use crate::utils::span_lint;
&mut self,
cx: &LateContext<'a, 'tcx>,
_: visit::FnKind<'tcx>,
- _: &'tcx FnDecl,
- body: &'tcx Body,
+ _: &'tcx FnDecl<'_>,
+ body: &'tcx Body<'_>,
_: Span,
hir_id: HirId,
) {
let parent_node = cx.tcx.hir().find(parent_id);
if let Some(Node::Item(item)) = parent_node {
- if let ItemKind::Impl(_, _, _, _, Some(..), _, _) = item.kind {
+ if let ItemKind::Impl { of_trait: Some(_), .. } = item.kind {
return;
}
}
};
let fn_def_id = cx.tcx.hir().local_def_id(hir_id);
- let region_scope_tree = &cx.tcx.region_scope_tree(fn_def_id);
- ExprUseVisitor::new(&mut v, cx.tcx, fn_def_id, cx.param_env, region_scope_tree, cx.tables).consume_body(body);
+ cx.tcx.infer_ctxt().enter(|infcx| {
+ ExprUseVisitor::new(&mut v, &infcx, fn_def_id, cx.param_env, cx.tables).consume_body(body);
+ });
for node in v.set {
span_lint(
}
// TODO: Replace with Map::is_argument(..) when it's fixed
-fn is_argument(map: &hir::map::Map<'_>, id: HirId) -> bool {
+fn is_argument(map: &rustc::hir::map::Map<'_>, id: HirId) -> bool {
match map.find(id) {
Some(Node::Binding(_)) => (),
_ => return false,
}
impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
- fn consume(&mut self, cmt: &cmt_<'tcx>, mode: ConsumeMode) {
- if let Categorization::Local(lid) = cmt.cat {
- if let ConsumeMode::Move = mode {
- // moved out or in. clearly can't be localized
- self.set.remove(&lid);
- }
- }
- let map = &self.cx.tcx.hir();
- if let Categorization::Local(lid) = cmt.cat {
- if let Some(Node::Binding(_)) = map.find(cmt.hir_id) {
- if self.set.contains(&lid) {
- // let y = x where x is known
- // remove x, insert y
- self.set.insert(cmt.hir_id);
+ fn consume(&mut self, cmt: &Place<'tcx>, mode: ConsumeMode) {
+ if cmt.projections.is_empty() {
+ if let PlaceBase::Local(lid) = cmt.base {
+ if let ConsumeMode::Move = mode {
+ // moved out or in. clearly can't be localized
self.set.remove(&lid);
}
+ let map = &self.cx.tcx.hir();
+ if let Some(Node::Binding(_)) = map.find(cmt.hir_id) {
+ if self.set.contains(&lid) {
+ // let y = x where x is known
+ // remove x, insert y
+ self.set.insert(cmt.hir_id);
+ self.set.remove(&lid);
+ }
+ }
}
}
}
- fn borrow(&mut self, cmt: &cmt_<'tcx>, _: ty::BorrowKind) {
- if let Categorization::Local(lid) = cmt.cat {
- self.set.remove(&lid);
+ fn borrow(&mut self, cmt: &Place<'tcx>, _: ty::BorrowKind) {
+ if cmt.projections.is_empty() {
+ if let PlaceBase::Local(lid) = cmt.base {
+ self.set.remove(&lid);
+ }
}
}
- fn mutate(&mut self, cmt: &cmt_<'tcx>) {
- let map = &self.cx.tcx.hir();
- if is_argument(map, cmt.hir_id) {
- // Skip closure arguments
- let parent_id = map.get_parent_node(cmt.hir_id);
- if let Some(Node::Expr(..)) = map.find(map.get_parent_node(parent_id)) {
- return;
- }
+ fn mutate(&mut self, cmt: &Place<'tcx>) {
+ if cmt.projections.is_empty() {
+ let map = &self.cx.tcx.hir();
+ if is_argument(map, cmt.hir_id) {
+ // Skip closure arguments
+ let parent_id = map.get_parent_node(cmt.hir_id);
+ if let Some(Node::Expr(..)) = map.find(map.get_parent_node(parent_id)) {
+ return;
+ }
- if is_non_trait_box(cmt.ty) && !self.is_large_box(cmt.ty) {
- self.set.insert(cmt.hir_id);
+ if is_non_trait_box(cmt.ty) && !self.is_large_box(cmt.ty) {
+ self.set.insert(cmt.hir_id);
+ }
+ return;
}
- return;
}
}
}
fn is_large_box(&self, ty: Ty<'tcx>) -> bool {
// Large types need to be boxed to avoid stack overflows.
if ty.is_box() {
- self.cx.layout_of(ty.boxed_ty()).ok().map_or(0, |l| l.size.bytes()) > self.too_large_for_stack
+ self.cx.layout_of(ty.boxed_ty()).map_or(0, |l| l.size.bytes()) > self.too_large_for_stack
} else {
false
}