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 -.-
99 lines
3.6 KiB
Rust
99 lines
3.6 KiB
Rust
use clippy_utils::diagnostics::span_lint_and_sugg;
|
|
use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
|
|
use clippy_utils::ty::is_type_diagnostic_item;
|
|
use clippy_utils::{is_lang_ctor, path_to_local_id};
|
|
use if_chain::if_chain;
|
|
use rustc_errors::Applicability;
|
|
use rustc_hir::LangItem::{ResultErr, ResultOk};
|
|
use rustc_hir::{Expr, ExprKind, PatKind};
|
|
use rustc_lint::LintContext;
|
|
use rustc_lint::{LateContext, LateLintPass};
|
|
use rustc_middle::lint::in_external_macro;
|
|
use rustc_session::{declare_lint_pass, declare_tool_lint};
|
|
use rustc_span::symbol::sym;
|
|
|
|
declare_clippy_lint! {
|
|
/// ### What it does
|
|
///
|
|
/// Finds patterns that reimplement `Option::ok_or`.
|
|
///
|
|
/// ### Why is this bad?
|
|
///
|
|
/// Concise code helps focusing on behavior instead of boilerplate.
|
|
///
|
|
/// ### Examples
|
|
/// ```rust
|
|
/// let foo: Option<i32> = None;
|
|
/// foo.map_or(Err("error"), |v| Ok(v));
|
|
/// ```
|
|
///
|
|
/// Use instead:
|
|
/// ```rust
|
|
/// let foo: Option<i32> = None;
|
|
/// foo.ok_or("error");
|
|
/// ```
|
|
#[clippy::version = "1.49.0"]
|
|
pub MANUAL_OK_OR,
|
|
pedantic,
|
|
"finds patterns that can be encoded more concisely with `Option::ok_or`"
|
|
}
|
|
|
|
declare_lint_pass!(ManualOkOr => [MANUAL_OK_OR]);
|
|
|
|
impl LateLintPass<'_> for ManualOkOr {
|
|
fn check_expr(&mut self, cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<'tcx>) {
|
|
if in_external_macro(cx.sess(), scrutinee.span) {
|
|
return;
|
|
}
|
|
|
|
if_chain! {
|
|
if let ExprKind::MethodCall(method_segment, _, args, _) = scrutinee.kind;
|
|
if method_segment.ident.name == sym!(map_or);
|
|
if args.len() == 3;
|
|
let method_receiver = &args[0];
|
|
let ty = cx.typeck_results().expr_ty(method_receiver);
|
|
if is_type_diagnostic_item(cx, ty, sym::Option);
|
|
let or_expr = &args[1];
|
|
if is_ok_wrapping(cx, &args[2]);
|
|
if let ExprKind::Call(Expr { kind: ExprKind::Path(err_path), .. }, &[ref err_arg]) = or_expr.kind;
|
|
if is_lang_ctor(cx, err_path, ResultErr);
|
|
if let Some(method_receiver_snippet) = snippet_opt(cx, method_receiver.span);
|
|
if let Some(err_arg_snippet) = snippet_opt(cx, err_arg.span);
|
|
if let Some(indent) = indent_of(cx, scrutinee.span);
|
|
then {
|
|
let reindented_err_arg_snippet =
|
|
reindent_multiline(err_arg_snippet.into(), true, Some(indent + 4));
|
|
span_lint_and_sugg(
|
|
cx,
|
|
MANUAL_OK_OR,
|
|
scrutinee.span,
|
|
"this pattern reimplements `Option::ok_or`",
|
|
"replace with",
|
|
format!(
|
|
"{}.ok_or({})",
|
|
method_receiver_snippet,
|
|
reindented_err_arg_snippet
|
|
),
|
|
Applicability::MachineApplicable,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn is_ok_wrapping(cx: &LateContext<'_>, map_expr: &Expr<'_>) -> bool {
|
|
if let ExprKind::Path(ref qpath) = map_expr.kind {
|
|
if is_lang_ctor(cx, qpath, ResultOk) {
|
|
return true;
|
|
}
|
|
}
|
|
if_chain! {
|
|
if let ExprKind::Closure(_, _, body_id, ..) = map_expr.kind;
|
|
let body = cx.tcx.hir().body(body_id);
|
|
if let PatKind::Binding(_, param_id, ..) = body.params[0].pat.kind;
|
|
if let ExprKind::Call(Expr { kind: ExprKind::Path(ok_path), .. }, &[ref ok_arg]) = body.value.kind;
|
|
if is_lang_ctor(cx, ok_path, ResultOk);
|
|
then { path_to_local_id(ok_arg, param_id) } else { false }
|
|
}
|
|
}
|