rustc_lint: avoid using TypeckTables::empty for LateContext.
This commit is contained in:
parent
3c5ee3300f
commit
590e07bbc2
@ -76,7 +76,7 @@ fn check_atomic_load_store(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
|
||||
if method == "load" || method == "store";
|
||||
let ordering_arg = if method == "load" { &args[1] } else { &args[2] };
|
||||
if let ExprKind::Path(ref ordering_qpath) = ordering_arg.kind;
|
||||
if let Some(ordering_def_id) = cx.tables().qpath_res(ordering_qpath, ordering_arg.hir_id).opt_def_id();
|
||||
if let Some(ordering_def_id) = cx.qpath_res(ordering_qpath, ordering_arg.hir_id).opt_def_id();
|
||||
then {
|
||||
if method == "load" &&
|
||||
match_ordering_def_path(cx, ordering_def_id, &["Release", "AcqRel"]) {
|
||||
@ -107,12 +107,12 @@ fn check_memory_fence(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
|
||||
if_chain! {
|
||||
if let ExprKind::Call(ref func, ref args) = expr.kind;
|
||||
if let ExprKind::Path(ref func_qpath) = func.kind;
|
||||
if let Some(def_id) = cx.tables().qpath_res(func_qpath, func.hir_id).opt_def_id();
|
||||
if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
|
||||
if ["fence", "compiler_fence"]
|
||||
.iter()
|
||||
.any(|func| match_def_path(cx, def_id, &["core", "sync", "atomic", func]));
|
||||
if let ExprKind::Path(ref ordering_qpath) = &args[0].kind;
|
||||
if let Some(ordering_def_id) = cx.tables().qpath_res(ordering_qpath, args[0].hir_id).opt_def_id();
|
||||
if let Some(ordering_def_id) = cx.qpath_res(ordering_qpath, args[0].hir_id).opt_def_id();
|
||||
if match_ordering_def_path(cx, ordering_def_id, &["Relaxed"]);
|
||||
then {
|
||||
span_lint_and_help(
|
||||
|
@ -192,7 +192,7 @@ fn lint_same_then_else(cx: &LateContext<'_, '_>, blocks: &[&Block<'_>]) {
|
||||
/// Implementation of `IFS_SAME_COND`.
|
||||
fn lint_same_cond(cx: &LateContext<'_, '_>, conds: &[&Expr<'_>]) {
|
||||
let hash: &dyn Fn(&&Expr<'_>) -> u64 = &|expr| -> u64 {
|
||||
let mut h = SpanlessHash::new(cx, cx.tables());
|
||||
let mut h = SpanlessHash::new(cx);
|
||||
h.hash_expr(expr);
|
||||
h.finish()
|
||||
};
|
||||
@ -215,7 +215,7 @@ fn lint_same_cond(cx: &LateContext<'_, '_>, conds: &[&Expr<'_>]) {
|
||||
/// Implementation of `SAME_FUNCTIONS_IN_IF_CONDITION`.
|
||||
fn lint_same_fns_in_if_cond(cx: &LateContext<'_, '_>, conds: &[&Expr<'_>]) {
|
||||
let hash: &dyn Fn(&&Expr<'_>) -> u64 = &|expr| -> u64 {
|
||||
let mut h = SpanlessHash::new(cx, cx.tables());
|
||||
let mut h = SpanlessHash::new(cx);
|
||||
h.hash_expr(expr);
|
||||
h.finish()
|
||||
};
|
||||
@ -251,7 +251,7 @@ fn lint_match_arms<'tcx>(cx: &LateContext<'_, 'tcx>, expr: &Expr<'_>) {
|
||||
|
||||
if let ExprKind::Match(_, ref arms, MatchSource::Normal) = expr.kind {
|
||||
let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
|
||||
let mut h = SpanlessHash::new(cx, cx.tables());
|
||||
let mut h = SpanlessHash::new(cx);
|
||||
h.hash_expr(&arm.body);
|
||||
h.finish()
|
||||
};
|
||||
|
@ -36,7 +36,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DefaultTraitAccess {
|
||||
if let ExprKind::Call(ref path, ..) = expr.kind;
|
||||
if !any_parent_is_automatically_derived(cx.tcx, expr.hir_id);
|
||||
if let ExprKind::Path(ref qpath) = path.kind;
|
||||
if let Some(def_id) = cx.tables().qpath_res(qpath, path.hir_id).opt_def_id();
|
||||
if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
|
||||
if match_def_path(cx, def_id, &paths::DEFAULT_TRAIT_METHOD);
|
||||
then {
|
||||
match qpath {
|
||||
|
@ -75,7 +75,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EvalOrderDependence {
|
||||
if let ExprKind::Path(ref qpath) = lhs.kind {
|
||||
if let QPath::Resolved(_, ref path) = *qpath {
|
||||
if path.segments.len() == 1 {
|
||||
if let def::Res::Local(var) = cx.tables().qpath_res(qpath, lhs.hir_id) {
|
||||
if let def::Res::Local(var) = cx.qpath_res(qpath, lhs.hir_id) {
|
||||
let mut visitor = ReadVisitor {
|
||||
cx,
|
||||
var,
|
||||
@ -309,7 +309,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> {
|
||||
if_chain! {
|
||||
if let QPath::Resolved(None, ref path) = *qpath;
|
||||
if path.segments.len() == 1;
|
||||
if let def::Res::Local(local_id) = self.cx.tables().qpath_res(qpath, expr.hir_id);
|
||||
if let def::Res::Local(local_id) = self.cx.qpath_res(qpath, expr.hir_id);
|
||||
if local_id == self.var;
|
||||
// Check that this is a read, not a write.
|
||||
if !is_in_assignment_position(self.cx, expr);
|
||||
|
@ -88,7 +88,7 @@ fn on_argumentv1_new<'a, 'tcx>(
|
||||
// matches `core::fmt::Display::fmt`
|
||||
if args.len() == 2;
|
||||
if let ExprKind::Path(ref qpath) = args[1].kind;
|
||||
if let Some(did) = cx.tables().qpath_res(qpath, args[1].hir_id).opt_def_id();
|
||||
if let Some(did) = cx.qpath_res(qpath, args[1].hir_id).opt_def_id();
|
||||
if match_def_path(cx, did, &paths::DISPLAY_FMT_METHOD);
|
||||
// check `(arg0,)` in match block
|
||||
if let PatKind::Tuple(ref pats, None) = arms[0].pat.kind;
|
||||
|
@ -108,7 +108,7 @@ fn expr_match(cx: &LateContext<'_, '_>, expr: &Expr<'_>) {
|
||||
ExprKind::Call(expr, ..) => {
|
||||
if_chain! {
|
||||
if let ExprKind::Path(qpath) = &expr.kind;
|
||||
if let Some(path_def_id) = cx.tables().qpath_res(qpath, expr.hir_id).opt_def_id();
|
||||
if let Some(path_def_id) = cx.qpath_res(qpath, expr.hir_id).opt_def_id();
|
||||
if match_def_path(cx, path_def_id, &BEGIN_PANIC) ||
|
||||
match_def_path(cx, path_def_id, &BEGIN_PANIC_FMT);
|
||||
then { }
|
||||
|
@ -107,7 +107,7 @@ impl BorrowVisitor<'_, '_> {
|
||||
..
|
||||
},
|
||||
..,
|
||||
) => self.cx.tables().qpath_res(qpath, expr.hir_id).opt_def_id(),
|
||||
) => self.cx.qpath_res(qpath, expr.hir_id).opt_def_id(),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
@ -343,7 +343,7 @@ impl<'v, 't> RefVisitor<'v, 't> {
|
||||
})
|
||||
{
|
||||
let hir_id = ty.hir_id;
|
||||
match self.cx.tables().qpath_res(qpath, hir_id) {
|
||||
match self.cx.qpath_res(qpath, hir_id) {
|
||||
Res::Def(DefKind::TyAlias | DefKind::Struct, def_id) => {
|
||||
let generics = self.cx.tcx.generics_of(def_id);
|
||||
for _ in generics.params.as_slice() {
|
||||
|
@ -160,10 +160,10 @@ fn reduce_unit_expression<'a>(cx: &LateContext<'_, '_>, expr: &'a hir::Expr<'_>)
|
||||
}
|
||||
}
|
||||
|
||||
fn unit_closure<'a, 'tcx>(
|
||||
cx: &LateContext<'a, 'tcx>,
|
||||
expr: &'a hir::Expr<'a>,
|
||||
) -> Option<(&'tcx hir::Param<'tcx>, &'a hir::Expr<'a>)> {
|
||||
fn unit_closure<'tcx>(
|
||||
cx: &LateContext<'_, 'tcx>,
|
||||
expr: &hir::Expr<'_>,
|
||||
) -> Option<(&'tcx hir::Param<'tcx>, &'tcx hir::Expr<'tcx>)> {
|
||||
if let hir::ExprKind::Closure(_, ref decl, inner_expr_id, _, _) = expr.kind {
|
||||
let body = cx.tcx.hir().body(inner_expr_id);
|
||||
let body_expr = &body.value;
|
||||
|
@ -35,7 +35,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MemDiscriminant {
|
||||
if let ExprKind::Call(ref func, ref func_args) = expr.kind;
|
||||
// is `mem::discriminant`
|
||||
if let ExprKind::Path(ref func_qpath) = func.kind;
|
||||
if let Some(def_id) = cx.tables().qpath_res(func_qpath, func.hir_id).opt_def_id();
|
||||
if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
|
||||
if match_def_path(cx, def_id, &paths::MEM_DISCRIMINANT);
|
||||
// type is non-enum
|
||||
let ty_param = cx.tables().node_substs(func.hir_id).type_at(0);
|
||||
|
@ -162,7 +162,7 @@ fn check_replace_with_uninit(cx: &LateContext<'_, '_>, src: &Expr<'_>, dest: &Ex
|
||||
if let ExprKind::Call(ref repl_func, ref repl_args) = src.kind;
|
||||
if repl_args.is_empty();
|
||||
if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
|
||||
if let Some(repl_def_id) = cx.tables().qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
|
||||
if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
|
||||
then {
|
||||
if cx.tcx.is_diagnostic_item(sym::mem_uninitialized, repl_def_id) {
|
||||
let mut applicability = Applicability::MachineApplicable;
|
||||
@ -198,7 +198,7 @@ fn check_replace_with_default(cx: &LateContext<'_, '_>, src: &Expr<'_>, dest: &E
|
||||
if_chain! {
|
||||
if !in_external_macro(cx.tcx.sess, expr_span);
|
||||
if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
|
||||
if let Some(repl_def_id) = cx.tables().qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
|
||||
if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
|
||||
if match_def_path(cx, repl_def_id, &paths::DEFAULT_TRAIT_METHOD);
|
||||
then {
|
||||
span_lint_and_then(
|
||||
@ -230,7 +230,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MemReplace {
|
||||
// Check that `expr` is a call to `mem::replace()`
|
||||
if let ExprKind::Call(ref func, ref func_args) = expr.kind;
|
||||
if let ExprKind::Path(ref func_qpath) = func.kind;
|
||||
if let Some(def_id) = cx.tables().qpath_res(func_qpath, func.hir_id).opt_def_id();
|
||||
if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
|
||||
if match_def_path(cx, def_id, &paths::MEM_REPLACE);
|
||||
if let [dest, src] = &**func_args;
|
||||
then {
|
||||
|
@ -1824,7 +1824,7 @@ fn lint_expect_fun_call(
|
||||
hir::ExprKind::Lit(_) => true,
|
||||
hir::ExprKind::Call(fun, _) => {
|
||||
if let hir::ExprKind::Path(ref p) = fun.kind {
|
||||
match cx.tables().qpath_res(p, fun.hir_id) {
|
||||
match cx.qpath_res(p, fun.hir_id) {
|
||||
hir::def::Res::Def(hir::def::DefKind::Fn | hir::def::DefKind::AssocFn, def_id) => matches!(
|
||||
cx.tcx.fn_sig(def_id).output().skip_binder().kind,
|
||||
ty::Ref(ty::ReStatic, ..)
|
||||
@ -1844,7 +1844,7 @@ fn lint_expect_fun_call(
|
||||
ty::Ref(ty::ReStatic, ..)
|
||||
)
|
||||
}),
|
||||
hir::ExprKind::Path(ref p) => match cx.tables().qpath_res(p, arg.hir_id) {
|
||||
hir::ExprKind::Path(ref p) => match cx.qpath_res(p, arg.hir_id) {
|
||||
hir::def::Res::Def(hir::def::DefKind::Const | hir::def::DefKind::Static, _) => true,
|
||||
_ => false,
|
||||
},
|
||||
@ -3317,7 +3317,7 @@ fn lint_option_as_ref_deref<'a, 'tcx>(
|
||||
if_chain! {
|
||||
if args.len() == 1;
|
||||
if let hir::ExprKind::Path(qpath) = &args[0].kind;
|
||||
if let hir::def::Res::Local(local_id) = cx.tables().qpath_res(qpath, args[0].hir_id);
|
||||
if let hir::def::Res::Local(local_id) = cx.qpath_res(qpath, args[0].hir_id);
|
||||
if closure_body.params[0].pat.hir_id == local_id;
|
||||
let adj = cx.tables().expr_adjustments(&args[0]).iter().map(|x| &x.kind).collect::<Box<[_]>>();
|
||||
if let [ty::adjustment::Adjust::Deref(None), ty::adjustment::Adjust::Borrow(_)] = *adj;
|
||||
@ -3334,7 +3334,7 @@ fn lint_option_as_ref_deref<'a, 'tcx>(
|
||||
if let hir::ExprKind::Unary(hir::UnOp::UnDeref, ref inner1) = inner.kind;
|
||||
if let hir::ExprKind::Unary(hir::UnOp::UnDeref, ref inner2) = inner1.kind;
|
||||
if let hir::ExprKind::Path(ref qpath) = inner2.kind;
|
||||
if let hir::def::Res::Local(local_id) = cx.tables().qpath_res(qpath, inner2.hir_id);
|
||||
if let hir::def::Res::Local(local_id) = cx.qpath_res(qpath, inner2.hir_id);
|
||||
then {
|
||||
closure_body.params[0].pat.hir_id == local_id
|
||||
} else {
|
||||
|
@ -65,7 +65,7 @@ fn check_expression<'a, 'tcx>(
|
||||
if match_qpath(path, &paths::OPTION_SOME) {
|
||||
if_chain! {
|
||||
if let hir::ExprKind::Path(path) = &args[0].kind;
|
||||
if let Res::Local(ref local) = cx.tables().qpath_res(path, args[0].hir_id);
|
||||
if let Res::Local(ref local) = cx.qpath_res(path, args[0].hir_id);
|
||||
then {
|
||||
if arg_id == *local {
|
||||
return (false, false)
|
||||
|
@ -436,7 +436,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MiscLints {
|
||||
binding != "_result" && // FIXME: #944
|
||||
is_used(cx, expr) &&
|
||||
// don't lint if the declaration is in a macro
|
||||
non_macro_local(cx, cx.tables().qpath_res(qpath, expr.hir_id))
|
||||
non_macro_local(cx, cx.qpath_res(qpath, expr.hir_id))
|
||||
{
|
||||
Some(binding)
|
||||
} else {
|
||||
|
@ -158,7 +158,7 @@ impl QuestionMark {
|
||||
ExprKind::Ret(Some(ref expr)) => Self::expression_returns_none(cx, expr),
|
||||
ExprKind::Path(ref qp) => {
|
||||
if let Res::Def(DefKind::Ctor(def::CtorOf::Variant, def::CtorKind::Const), def_id) =
|
||||
cx.tables().qpath_res(qp, expression.hir_id)
|
||||
cx.qpath_res(qp, expression.hir_id)
|
||||
{
|
||||
return match_def_path(cx, def_id, &paths::OPTION_NONE);
|
||||
}
|
||||
|
@ -111,7 +111,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Regex {
|
||||
if let ExprKind::Call(ref fun, ref args) = expr.kind;
|
||||
if let ExprKind::Path(ref qpath) = fun.kind;
|
||||
if args.len() == 1;
|
||||
if let Some(def_id) = cx.tables().qpath_res(qpath, fun.hir_id).opt_def_id();
|
||||
if let Some(def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
|
||||
then {
|
||||
if match_def_path(cx, def_id, &paths::REGEX_NEW) ||
|
||||
match_def_path(cx, def_id, &paths::REGEX_BUILDER_NEW) {
|
||||
|
@ -26,7 +26,7 @@ fn is_temporary(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
|
||||
match &expr.kind {
|
||||
ExprKind::Struct(..) | ExprKind::Tup(..) => true,
|
||||
ExprKind::Path(qpath) => {
|
||||
if let Res::Def(DefKind::Const, ..) = cx.tables().qpath_res(qpath, expr.hir_id) {
|
||||
if let Res::Def(DefKind::Const, ..) = cx.qpath_res(qpath, expr.hir_id) {
|
||||
true
|
||||
} else {
|
||||
false
|
||||
|
@ -56,7 +56,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ToDigitIsSome {
|
||||
if_chain! {
|
||||
if let [char_arg, radix_arg] = &**to_digit_args;
|
||||
if let hir::ExprKind::Path(to_digits_path) = &to_digits_call.kind;
|
||||
if let to_digits_call_res = cx.tables().qpath_res(to_digits_path, to_digits_call.hir_id);
|
||||
if let to_digits_call_res = cx.qpath_res(to_digits_path, to_digits_call.hir_id);
|
||||
if let Some(to_digits_def_id) = to_digits_call_res.opt_def_id();
|
||||
if match_def_path(cx, to_digits_def_id, &["core", "char", "methods", "<impl char>", "to_digit"]);
|
||||
then {
|
||||
|
@ -37,7 +37,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TraitBounds {
|
||||
return;
|
||||
}
|
||||
let hash = |ty| -> u64 {
|
||||
let mut hasher = SpanlessHash::new(cx, cx.tables());
|
||||
let mut hasher = SpanlessHash::new(cx);
|
||||
hasher.hash_ty(ty);
|
||||
hasher.finish()
|
||||
};
|
||||
|
@ -299,7 +299,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
|
||||
if_chain! {
|
||||
if let ExprKind::Call(ref path_expr, ref args) = e.kind;
|
||||
if let ExprKind::Path(ref qpath) = path_expr.kind;
|
||||
if let Some(def_id) = cx.tables().qpath_res(qpath, path_expr.hir_id).opt_def_id();
|
||||
if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id();
|
||||
if match_def_path(cx, def_id, &paths::TRANSMUTE);
|
||||
then {
|
||||
let from_ty = cx.tables().expr_ty(&args[0]);
|
||||
|
@ -2490,7 +2490,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ImplicitHasherTypeVisitor<'a, 'tcx> {
|
||||
/// Looks for default-hasher-dependent constructors like `HashMap::new`.
|
||||
struct ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
|
||||
cx: &'a LateContext<'a, 'tcx>,
|
||||
body: &'a TypeckTables<'tcx>,
|
||||
maybe_typeck_tables: Option<&'tcx TypeckTables<'tcx>>,
|
||||
target: &'b ImplicitHasherType<'tcx>,
|
||||
suggestions: BTreeMap<Span, String>,
|
||||
}
|
||||
@ -2499,7 +2499,7 @@ impl<'a, 'b, 'tcx> ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
|
||||
fn new(cx: &'a LateContext<'a, 'tcx>, target: &'b ImplicitHasherType<'tcx>) -> Self {
|
||||
Self {
|
||||
cx,
|
||||
body: cx.tables(),
|
||||
maybe_typeck_tables: cx.maybe_typeck_tables(),
|
||||
target,
|
||||
suggestions: BTreeMap::new(),
|
||||
}
|
||||
@ -2510,10 +2510,9 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 't
|
||||
type Map = Map<'tcx>;
|
||||
|
||||
fn visit_body(&mut self, body: &'tcx Body<'_>) {
|
||||
let prev_body = self.body;
|
||||
self.body = self.cx.tcx.body_tables(body.id());
|
||||
let old_maybe_typeck_tables = self.maybe_typeck_tables.replace(self.cx.tcx.body_tables(body.id()));
|
||||
walk_body(self, body);
|
||||
self.body = prev_body;
|
||||
self.maybe_typeck_tables = old_maybe_typeck_tables;
|
||||
}
|
||||
|
||||
fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
|
||||
@ -2522,7 +2521,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 't
|
||||
if let ExprKind::Path(QPath::TypeRelative(ref ty, ref method)) = fun.kind;
|
||||
if let TyKind::Path(QPath::Resolved(None, ty_path)) = ty.kind;
|
||||
then {
|
||||
if !TyS::same_type(self.target.ty(), self.body.expr_ty(e)) {
|
||||
if !TyS::same_type(self.target.ty(), self.maybe_typeck_tables.unwrap().expr_ty(e)) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -98,7 +98,7 @@ impl LateLintPass<'_, '_> for UnnamedAddress {
|
||||
if_chain! {
|
||||
if let ExprKind::Call(ref func, [ref _left, ref _right]) = expr.kind;
|
||||
if let ExprKind::Path(ref func_qpath) = func.kind;
|
||||
if let Some(def_id) = cx.tables().qpath_res(func_qpath, func.hir_id).opt_def_id();
|
||||
if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
|
||||
if match_def_path(cx, def_id, &paths::PTR_EQ) ||
|
||||
match_def_path(cx, def_id, &paths::RC_PTR_EQ) ||
|
||||
match_def_path(cx, def_id, &paths::ARC_PTR_EQ);
|
||||
|
@ -121,7 +121,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UselessConversion {
|
||||
if_chain! {
|
||||
if args.len() == 1;
|
||||
if let ExprKind::Path(ref qpath) = path.kind;
|
||||
if let Some(def_id) = cx.tables().qpath_res(qpath, path.hir_id).opt_def_id();
|
||||
if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
|
||||
let a = cx.tables().expr_ty(e);
|
||||
let b = cx.tables().expr_ty(&args[0]);
|
||||
|
||||
|
@ -262,7 +262,7 @@ pub fn vec_macro<'e>(cx: &LateContext<'_, '_>, expr: &'e hir::Expr<'_>) -> Optio
|
||||
if let hir::ExprKind::Call(ref fun, ref args) = expr.kind;
|
||||
if let hir::ExprKind::Path(ref qpath) = fun.kind;
|
||||
if is_expn_of(fun.span, "vec").is_some();
|
||||
if let Some(fun_def_id) = cx.tables().qpath_res(qpath, fun.hir_id).opt_def_id();
|
||||
if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
|
||||
then {
|
||||
return if match_def_path(cx, fun_def_id, &paths::VEC_FROM_ELEM) && args.len() == 2 {
|
||||
// `vec![elem; size]` case
|
||||
|
@ -22,7 +22,7 @@ use std::hash::Hash;
|
||||
pub struct SpanlessEq<'a, 'tcx> {
|
||||
/// Context used to evaluate constant expressions.
|
||||
cx: &'a LateContext<'a, 'tcx>,
|
||||
tables: &'a TypeckTables<'tcx>,
|
||||
maybe_typeck_tables: Option<&'tcx TypeckTables<'tcx>>,
|
||||
/// If is true, never consider as equal expressions containing function
|
||||
/// calls.
|
||||
ignore_fn: bool,
|
||||
@ -32,16 +32,15 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
|
||||
pub fn new(cx: &'a LateContext<'a, 'tcx>) -> Self {
|
||||
Self {
|
||||
cx,
|
||||
tables: cx.tables(),
|
||||
maybe_typeck_tables: cx.maybe_typeck_tables(),
|
||||
ignore_fn: false,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn ignore_fn(self) -> Self {
|
||||
Self {
|
||||
cx: self.cx,
|
||||
tables: self.cx.tables(),
|
||||
ignore_fn: true,
|
||||
..self
|
||||
}
|
||||
}
|
||||
|
||||
@ -72,14 +71,16 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
|
||||
return false;
|
||||
}
|
||||
|
||||
if let Some(tables) = self.maybe_typeck_tables {
|
||||
if let (Some(l), Some(r)) = (
|
||||
constant_simple(self.cx, self.tables, left),
|
||||
constant_simple(self.cx, self.tables, right),
|
||||
constant_simple(self.cx, tables, left),
|
||||
constant_simple(self.cx, tables, right),
|
||||
) {
|
||||
if l == r {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
match (&left.kind, &right.kind) {
|
||||
(&ExprKind::AddrOf(lb, l_mut, ref le), &ExprKind::AddrOf(rb, r_mut, ref re)) => {
|
||||
@ -271,18 +272,18 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
|
||||
match (left, right) {
|
||||
(&TyKind::Slice(ref l_vec), &TyKind::Slice(ref r_vec)) => self.eq_ty(l_vec, r_vec),
|
||||
(&TyKind::Array(ref lt, ref ll_id), &TyKind::Array(ref rt, ref rl_id)) => {
|
||||
let full_table = self.tables;
|
||||
let old_maybe_typeck_tables = self.maybe_typeck_tables;
|
||||
|
||||
let mut celcx = constant_context(self.cx, self.cx.tcx.body_tables(ll_id.body));
|
||||
self.tables = self.cx.tcx.body_tables(ll_id.body);
|
||||
self.maybe_typeck_tables = Some(self.cx.tcx.body_tables(ll_id.body));
|
||||
let ll = celcx.expr(&self.cx.tcx.hir().body(ll_id.body).value);
|
||||
|
||||
let mut celcx = constant_context(self.cx, self.cx.tcx.body_tables(rl_id.body));
|
||||
self.tables = self.cx.tcx.body_tables(rl_id.body);
|
||||
self.maybe_typeck_tables = Some(self.cx.tcx.body_tables(rl_id.body));
|
||||
let rl = celcx.expr(&self.cx.tcx.hir().body(rl_id.body).value);
|
||||
|
||||
let eq_ty = self.eq_ty(lt, rt);
|
||||
self.tables = full_table;
|
||||
self.maybe_typeck_tables = old_maybe_typeck_tables;
|
||||
eq_ty && ll == rl
|
||||
},
|
||||
(&TyKind::Ptr(ref l_mut), &TyKind::Ptr(ref r_mut)) => {
|
||||
@ -347,15 +348,15 @@ pub fn over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -
|
||||
pub struct SpanlessHash<'a, 'tcx> {
|
||||
/// Context used to evaluate constant expressions.
|
||||
cx: &'a LateContext<'a, 'tcx>,
|
||||
tables: &'a TypeckTables<'tcx>,
|
||||
maybe_typeck_tables: Option<&'tcx TypeckTables<'tcx>>,
|
||||
s: StableHasher,
|
||||
}
|
||||
|
||||
impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
|
||||
pub fn new(cx: &'a LateContext<'a, 'tcx>, tables: &'a TypeckTables<'tcx>) -> Self {
|
||||
pub fn new(cx: &'a LateContext<'a, 'tcx>) -> Self {
|
||||
Self {
|
||||
cx,
|
||||
tables,
|
||||
maybe_typeck_tables: cx.maybe_typeck_tables(),
|
||||
s: StableHasher::new(),
|
||||
}
|
||||
}
|
||||
@ -384,7 +385,9 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
|
||||
|
||||
#[allow(clippy::many_single_char_names, clippy::too_many_lines)]
|
||||
pub fn hash_expr(&mut self, e: &Expr<'_>) {
|
||||
let simple_const = constant_simple(self.cx, self.tables, e);
|
||||
let simple_const = self
|
||||
.maybe_typeck_tables
|
||||
.and_then(|tables| constant_simple(self.cx, tables, e));
|
||||
|
||||
// const hashing may result in the same hash as some unrelated node, so add a sort of
|
||||
// discriminant depending on which path we're choosing next
|
||||
@ -599,7 +602,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
|
||||
self.hash_name(path.ident.name);
|
||||
},
|
||||
}
|
||||
// self.cx.tables.qpath_res(p, id).hash(&mut self.s);
|
||||
// self.maybe_typeck_tables.unwrap().qpath_res(p, id).hash(&mut self.s);
|
||||
}
|
||||
|
||||
pub fn hash_path(&mut self, p: &Path<'_>) {
|
||||
@ -728,9 +731,8 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
|
||||
|
||||
pub fn hash_body(&mut self, body_id: BodyId) {
|
||||
// swap out TypeckTables when hashing a body
|
||||
let old_tables = self.tables;
|
||||
self.tables = self.cx.tcx.body_tables(body_id);
|
||||
let old_maybe_typeck_tables = self.maybe_typeck_tables.replace(self.cx.tcx.body_tables(body_id));
|
||||
self.hash_expr(&self.cx.tcx.hir().body(body_id).value);
|
||||
self.tables = old_tables;
|
||||
self.maybe_typeck_tables = old_maybe_typeck_tables;
|
||||
}
|
||||
}
|
||||
|
@ -347,7 +347,7 @@ fn is_lint_ref_type<'tcx>(cx: &LateContext<'_, 'tcx>, ty: &Ty<'_>) -> bool {
|
||||
) = ty.kind
|
||||
{
|
||||
if let TyKind::Path(ref path) = inner.kind {
|
||||
if let Res::Def(DefKind::Struct, def_id) = cx.tables().qpath_res(path, inner.hir_id) {
|
||||
if let Res::Def(DefKind::Struct, def_id) = cx.qpath_res(path, inner.hir_id) {
|
||||
return match_def_path(cx, def_id, &paths::LINT);
|
||||
}
|
||||
}
|
||||
|
@ -898,7 +898,7 @@ pub fn is_copy<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
|
||||
pub fn is_ctor_or_promotable_const_function(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool {
|
||||
if let ExprKind::Call(ref fun, _) = expr.kind {
|
||||
if let ExprKind::Path(ref qp) = fun.kind {
|
||||
let res = cx.tables().qpath_res(qp, fun.hir_id);
|
||||
let res = cx.qpath_res(qp, fun.hir_id);
|
||||
return match res {
|
||||
def::Res::Def(DefKind::Variant | DefKind::Ctor(..), ..) => true,
|
||||
def::Res::Def(_, def_id) => cx.tcx.is_promotable_const_fn(def_id),
|
||||
@ -914,7 +914,7 @@ pub fn is_ctor_or_promotable_const_function(cx: &LateContext<'_, '_>, expr: &Exp
|
||||
pub fn is_refutable(cx: &LateContext<'_, '_>, pat: &Pat<'_>) -> bool {
|
||||
fn is_enum_variant(cx: &LateContext<'_, '_>, qpath: &QPath<'_>, id: HirId) -> bool {
|
||||
matches!(
|
||||
cx.tables().qpath_res(qpath, id),
|
||||
cx.qpath_res(qpath, id),
|
||||
def::Res::Def(DefKind::Variant, ..) | Res::Def(DefKind::Ctor(def::CtorOf::Variant, _), _)
|
||||
)
|
||||
}
|
||||
@ -1190,7 +1190,7 @@ pub fn match_function_call<'a, 'tcx>(
|
||||
if_chain! {
|
||||
if let ExprKind::Call(ref fun, ref args) = expr.kind;
|
||||
if let ExprKind::Path(ref qpath) = fun.kind;
|
||||
if let Some(fun_def_id) = cx.tables().qpath_res(qpath, fun.hir_id).opt_def_id();
|
||||
if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
|
||||
if match_def_path(cx, fun_def_id, path);
|
||||
then {
|
||||
return Some(&args)
|
||||
@ -1317,7 +1317,7 @@ pub fn is_must_use_func_call(cx: &LateContext<'_, '_>, expr: &Expr<'_>) -> bool
|
||||
let did = match expr.kind {
|
||||
ExprKind::Call(ref path, _) => if_chain! {
|
||||
if let ExprKind::Path(ref qpath) = path.kind;
|
||||
if let def::Res::Def(_, did) = cx.tables().qpath_res(qpath, path.hir_id);
|
||||
if let def::Res::Def(_, did) = cx.qpath_res(qpath, path.hir_id);
|
||||
then {
|
||||
Some(did)
|
||||
} else {
|
||||
|
Loading…
Reference in New Issue
Block a user