5fa961b951
Specifically, change `Ty` from this: ``` pub type Ty<'tcx> = &'tcx TyS<'tcx>; ``` to this ``` pub struct Ty<'tcx>(Interned<'tcx, TyS<'tcx>>); ``` There are two benefits to this. - It's now a first class type, so we can define methods on it. This means we can move a lot of methods away from `TyS`, leaving `TyS` as a barely-used type, which is appropriate given that it's not meant to be used directly. - The uniqueness requirement is now explicit, via the `Interned` type. E.g. the pointer-based `Eq` and `Hash` comes from `Interned`, rather than via `TyS`, which wasn't obvious at all. Much of this commit is boring churn. The interesting changes are in these files: - compiler/rustc_middle/src/arena.rs - compiler/rustc_middle/src/mir/visit.rs - compiler/rustc_middle/src/ty/context.rs - compiler/rustc_middle/src/ty/mod.rs Specifically: - Most mentions of `TyS` are removed. It's very much a dumb struct now; `Ty` has all the smarts. - `TyS` now has `crate` visibility instead of `pub`. - `TyS::make_for_test` is removed in favour of the static `BOOL_TY`, which just works better with the new structure. - The `Eq`/`Ord`/`Hash` impls are removed from `TyS`. `Interned`s impls of `Eq`/`Hash` now suffice. `Ord` is now partly on `Interned` (pointer-based, for the `Equal` case) and partly on `TyS` (contents-based, for the other cases). - There are many tedious sigil adjustments, i.e. adding or removing `*` or `&`. They seem to be unavoidable.
82 lines
2.5 KiB
Rust
82 lines
2.5 KiB
Rust
use clippy_utils::source::snippet_with_applicability;
|
|
use clippy_utils::ty::is_type_diagnostic_item;
|
|
use if_chain::if_chain;
|
|
use rustc_ast::ast;
|
|
use rustc_errors::Applicability;
|
|
use rustc_hir as hir;
|
|
use rustc_lint::LateContext;
|
|
use rustc_middle::ty::{self, Ty};
|
|
use rustc_span::symbol::sym;
|
|
|
|
pub(super) fn derefs_to_slice<'tcx>(
|
|
cx: &LateContext<'tcx>,
|
|
expr: &'tcx hir::Expr<'tcx>,
|
|
ty: Ty<'tcx>,
|
|
) -> Option<&'tcx hir::Expr<'tcx>> {
|
|
fn may_slice<'a>(cx: &LateContext<'a>, ty: Ty<'a>) -> bool {
|
|
match ty.kind() {
|
|
ty::Slice(_) => true,
|
|
ty::Adt(def, _) if def.is_box() => may_slice(cx, ty.boxed_ty()),
|
|
ty::Adt(..) => is_type_diagnostic_item(cx, ty, sym::Vec),
|
|
ty::Array(_, size) => size.try_eval_usize(cx.tcx, cx.param_env).is_some(),
|
|
ty::Ref(_, inner, _) => may_slice(cx, *inner),
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
if let hir::ExprKind::MethodCall(path, [self_arg, ..], _) = &expr.kind {
|
|
if path.ident.name == sym::iter && may_slice(cx, cx.typeck_results().expr_ty(self_arg)) {
|
|
Some(self_arg)
|
|
} else {
|
|
None
|
|
}
|
|
} else {
|
|
match ty.kind() {
|
|
ty::Slice(_) => Some(expr),
|
|
ty::Adt(def, _) if def.is_box() && may_slice(cx, ty.boxed_ty()) => Some(expr),
|
|
ty::Ref(_, inner, _) => {
|
|
if may_slice(cx, *inner) {
|
|
Some(expr)
|
|
} else {
|
|
None
|
|
}
|
|
},
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(super) fn get_hint_if_single_char_arg(
|
|
cx: &LateContext<'_>,
|
|
arg: &hir::Expr<'_>,
|
|
applicability: &mut Applicability,
|
|
) -> Option<String> {
|
|
if_chain! {
|
|
if let hir::ExprKind::Lit(lit) = &arg.kind;
|
|
if let ast::LitKind::Str(r, style) = lit.node;
|
|
let string = r.as_str();
|
|
if string.chars().count() == 1;
|
|
then {
|
|
let snip = snippet_with_applicability(cx, arg.span, string, applicability);
|
|
let ch = if let ast::StrStyle::Raw(nhash) = style {
|
|
let nhash = nhash as usize;
|
|
// for raw string: r##"a"##
|
|
&snip[(nhash + 2)..(snip.len() - 1 - nhash)]
|
|
} else {
|
|
// for regular string: "a"
|
|
&snip[1..(snip.len() - 1)]
|
|
};
|
|
|
|
let hint = format!("'{}'", match ch {
|
|
"'" => "\\'" ,
|
|
r"\" => "\\\\",
|
|
_ => ch,
|
|
});
|
|
|
|
Some(hint)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
}
|