d647696c1f
So, some context for this, well, more a story. I'm not used to scripting, I've never really scripted anything, even if it's a valuable skill. I just never really needed it. Now, `@flip1995` correctly suggested using a script for this in `rust-clippy#7813`...
And I decided to write a script using nushell because why not? This was a mistake... I spend way more time on this than I would like to admit. It has definitely been more than 4 hours. It shouldn't take that long, but me being new to scripting and nushell just wasn't a good mixture... Anyway, here is the script that creates another script which adds the versions. Fun...
Just execute this on the `gh-pages` branch and the resulting `replacer.sh` in `clippy_lints` and it should all work.
```nu
mv v0.0.212 rust-1.00.0;
mv beta rust-1.57.0;
mv master rust-1.58.0;
let paths = (open ./rust-1.58.0/lints.json | select id id_span | flatten | select id path);
let versions = (
ls | where name =~ "rust-" | select name | format {name}/lints.json |
each { open $it | select id | insert version $it | str substring "5,11" version} |
group-by id | rotate counter-clockwise id version |
update version {get version | first 1} | flatten | select id version);
$paths | each { |row|
let version = ($versions | where id == ($row.id) | format {version})
let idu = ($row.id | str upcase)
$"sed -i '0,/($idu),/{s/pub ($idu),/#[clippy::version = "($version)"]\n pub ($idu),/}' ($row.path)"
} | str collect ";" | str find-replace --all '1.00.0' 'pre 1.29.0' | save "replacer.sh";
```
And this still has some problems, but at this point I just want to be done -.-
104 lines
3.7 KiB
Rust
104 lines
3.7 KiB
Rust
use clippy_utils::diagnostics::span_lint_and_sugg;
|
|
use clippy_utils::sugg::Sugg;
|
|
use clippy_utils::ty::is_type_diagnostic_item;
|
|
use if_chain::if_chain;
|
|
use rustc_errors::Applicability;
|
|
use rustc_hir::{def, Expr, ExprKind, PrimTy, QPath, TyKind};
|
|
use rustc_lint::{LateContext, LateLintPass};
|
|
use rustc_middle::ty::Ty;
|
|
use rustc_session::{declare_lint_pass, declare_tool_lint};
|
|
use rustc_span::symbol::sym;
|
|
|
|
declare_clippy_lint! {
|
|
/// ### What it does
|
|
///
|
|
/// Checks for function invocations of the form `primitive::from_str_radix(s, 10)`
|
|
///
|
|
/// ### Why is this bad?
|
|
///
|
|
/// This specific common use case can be rewritten as `s.parse::<primitive>()`
|
|
/// (and in most cases, the turbofish can be removed), which reduces code length
|
|
/// and complexity.
|
|
///
|
|
/// ### Known problems
|
|
///
|
|
/// This lint may suggest using (&<expression>).parse() instead of <expression>.parse() directly
|
|
/// in some cases, which is correct but adds unnecessary complexity to the code.
|
|
///
|
|
/// ### Example
|
|
/// ```ignore
|
|
/// let input: &str = get_input();
|
|
/// let num = u16::from_str_radix(input, 10)?;
|
|
/// ```
|
|
/// Use instead:
|
|
/// ```ignore
|
|
/// let input: &str = get_input();
|
|
/// let num: u16 = input.parse()?;
|
|
/// ```
|
|
#[clippy::version = "1.52.0"]
|
|
pub FROM_STR_RADIX_10,
|
|
style,
|
|
"from_str_radix with radix 10"
|
|
}
|
|
|
|
declare_lint_pass!(FromStrRadix10 => [FROM_STR_RADIX_10]);
|
|
|
|
impl LateLintPass<'tcx> for FromStrRadix10 {
|
|
fn check_expr(&mut self, cx: &LateContext<'tcx>, exp: &Expr<'tcx>) {
|
|
if_chain! {
|
|
if let ExprKind::Call(maybe_path, arguments) = &exp.kind;
|
|
if let ExprKind::Path(QPath::TypeRelative(ty, pathseg)) = &maybe_path.kind;
|
|
|
|
// check if the first part of the path is some integer primitive
|
|
if let TyKind::Path(ty_qpath) = &ty.kind;
|
|
let ty_res = cx.qpath_res(ty_qpath, ty.hir_id);
|
|
if let def::Res::PrimTy(prim_ty) = ty_res;
|
|
if matches!(prim_ty, PrimTy::Int(_) | PrimTy::Uint(_));
|
|
|
|
// check if the second part of the path indeed calls the associated
|
|
// function `from_str_radix`
|
|
if pathseg.ident.name.as_str() == "from_str_radix";
|
|
|
|
// check if the second argument is a primitive `10`
|
|
if arguments.len() == 2;
|
|
if let ExprKind::Lit(lit) = &arguments[1].kind;
|
|
if let rustc_ast::ast::LitKind::Int(10, _) = lit.node;
|
|
|
|
then {
|
|
let expr = if let ExprKind::AddrOf(_, _, expr) = &arguments[0].kind {
|
|
let ty = cx.typeck_results().expr_ty(expr);
|
|
if is_ty_stringish(cx, ty) {
|
|
expr
|
|
} else {
|
|
&arguments[0]
|
|
}
|
|
} else {
|
|
&arguments[0]
|
|
};
|
|
|
|
let sugg = Sugg::hir_with_applicability(
|
|
cx,
|
|
expr,
|
|
"<string>",
|
|
&mut Applicability::MachineApplicable
|
|
).maybe_par();
|
|
|
|
span_lint_and_sugg(
|
|
cx,
|
|
FROM_STR_RADIX_10,
|
|
exp.span,
|
|
"this call to `from_str_radix` can be replaced with a call to `str::parse`",
|
|
"try",
|
|
format!("{}.parse::<{}>()", sugg, prim_ty.name_str()),
|
|
Applicability::MaybeIncorrect
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Checks if a Ty is `String` or `&str`
|
|
fn is_ty_stringish(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
|
|
is_type_diagnostic_item(cx, ty, sym::String) || is_type_diagnostic_item(cx, ty, sym::str)
|
|
}
|