From e6ab222b814f20375041a5dd39e7605eed079c70 Mon Sep 17 00:00:00 2001 From: Cameron Steffen Date: Tue, 6 Jul 2021 11:51:15 -0500 Subject: [PATCH] Refactor format macro parsing --- clippy_lints/src/explicit_write.rs | 44 ++--- clippy_lints/src/format.rs | 192 +++++++------------- clippy_lints/src/methods/expect_fun_call.rs | 72 ++------ clippy_utils/src/higher.rs | 108 ++++++++++- clippy_utils/src/paths.rs | 4 - 5 files changed, 203 insertions(+), 217 deletions(-) diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs index da4936ff2..eaea70a42 100644 --- a/clippy_lints/src/explicit_write.rs +++ b/clippy_lints/src/explicit_write.rs @@ -1,9 +1,9 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg}; +use clippy_utils::higher::FormatArgsExpn; use clippy_utils::{is_expn_of, match_function_call, paths}; use if_chain::if_chain; -use rustc_ast::ast::LitKind; use rustc_errors::Applicability; -use rustc_hir::{BorrowKind, Expr, ExprKind}; +use rustc_hir::{Expr, ExprKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::sym; @@ -34,29 +34,26 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { if_chain! { // match call to unwrap - if let ExprKind::MethodCall(unwrap_fun, _, unwrap_args, _) = expr.kind; + if let ExprKind::MethodCall(unwrap_fun, _, [write_call], _) = expr.kind; if unwrap_fun.ident.name == sym::unwrap; // match call to write_fmt - if !unwrap_args.is_empty(); - if let ExprKind::MethodCall(write_fun, _, write_args, _) = - unwrap_args[0].kind; + if let ExprKind::MethodCall(write_fun, _, [write_recv, write_arg], _) = write_call.kind; if write_fun.ident.name == sym!(write_fmt); // match calls to std::io::stdout() / std::io::stderr () - if !write_args.is_empty(); - if let Some(dest_name) = if match_function_call(cx, &write_args[0], &paths::STDOUT).is_some() { + if let Some(dest_name) = if match_function_call(cx, write_recv, &paths::STDOUT).is_some() { Some("stdout") - } else if match_function_call(cx, &write_args[0], &paths::STDERR).is_some() { + } else if match_function_call(cx, write_recv, &paths::STDERR).is_some() { Some("stderr") } else { None }; + if let Some(format_args) = FormatArgsExpn::parse(write_arg); then { - let write_span = unwrap_args[0].span; let calling_macro = // ordering is important here, since `writeln!` uses `write!` internally - if is_expn_of(write_span, "writeln").is_some() { + if is_expn_of(write_call.span, "writeln").is_some() { Some("writeln") - } else if is_expn_of(write_span, "write").is_some() { + } else if is_expn_of(write_call.span, "write").is_some() { Some("write") } else { None @@ -70,7 +67,8 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite { // We need to remove the last trailing newline from the string because the // underlying `fmt::write` function doesn't know whether `println!` or `print!` was // used. - if let Some(mut write_output) = write_output_string(write_args) { + if let [write_output] = *format_args.format_string_symbols { + let mut write_output = write_output.to_string(); if write_output.ends_with('\n') { write_output.pop(); } @@ -129,23 +127,3 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite { } } } - -// Extract the output string from the given `write_args`. -fn write_output_string(write_args: &[Expr<'_>]) -> Option { - if_chain! { - // Obtain the string that should be printed - if write_args.len() > 1; - if let ExprKind::Call(_, output_args) = write_args[1].kind; - if !output_args.is_empty(); - if let ExprKind::AddrOf(BorrowKind::Ref, _, output_string_expr) = output_args[0].kind; - if let ExprKind::Array(string_exprs) = output_string_expr.kind; - // we only want to provide an automatic suggestion for simple (non-format) strings - if string_exprs.len() == 1; - if let ExprKind::Lit(ref lit) = string_exprs[0].kind; - if let LitKind::Str(ref write_output, _) = lit.node; - then { - return Some(write_output.to_string()) - } - } - None -} diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs index de1b3ffec..ca3490d8e 100644 --- a/clippy_lints/src/format.rs +++ b/clippy_lints/src/format.rs @@ -1,18 +1,16 @@ -use clippy_utils::diagnostics::span_lint_and_then; -use clippy_utils::paths; -use clippy_utils::source::{snippet, snippet_opt}; +use clippy_utils::diagnostics::span_lint_and_sugg; +use clippy_utils::higher::FormatExpn; +use clippy_utils::last_path_segment; +use clippy_utils::source::{snippet_opt, snippet_with_applicability}; use clippy_utils::sugg::Sugg; -use clippy_utils::ty::is_type_diagnostic_item; -use clippy_utils::{is_expn_of, last_path_segment, match_def_path, match_function_call}; use if_chain::if_chain; -use rustc_ast::ast::LitKind; use rustc_errors::Applicability; -use rustc_hir::{Arm, BorrowKind, Expr, ExprKind, MatchSource, PatKind}; -use rustc_lint::{LateContext, LateLintPass, LintContext}; +use rustc_hir::{BorrowKind, Expr, ExprKind, QPath}; +use rustc_lint::{LateContext, LateLintPass}; +use rustc_middle::ty; use rustc_session::{declare_lint_pass, declare_tool_lint}; -use rustc_span::source_map::Span; -use rustc_span::sym; use rustc_span::symbol::kw; +use rustc_span::{sym, Span}; declare_clippy_lint! { /// **What it does:** Checks for the use of `format!("string literal with no @@ -45,131 +43,78 @@ declare_lint_pass!(UselessFormat => [USELESS_FORMAT]); impl<'tcx> LateLintPass<'tcx> for UselessFormat { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { - let span = match is_expn_of(expr.span, "format") { - Some(s) if !s.from_expansion() => s, + let FormatExpn { call_site, format_args } = match FormatExpn::parse(expr) { + Some(e) if !e.call_site.from_expansion() => e, _ => return, }; - // Operate on the only argument of `alloc::fmt::format`. - if let Some(sugg) = on_new_v1(cx, expr) { - span_useless_format(cx, span, "consider using `.to_string()`", sugg); - } else if let Some(sugg) = on_new_v1_fmt(cx, expr) { - span_useless_format(cx, span, "consider using `.to_string()`", sugg); - } + let mut applicability = Applicability::MachineApplicable; + if format_args.value_args.is_empty() { + if_chain! { + if let [e] = &*format_args.format_string_parts; + if let ExprKind::Lit(lit) = &e.kind; + if let Some(s_src) = snippet_opt(cx, lit.span); + then { + // Simulate macro expansion, converting {{ and }} to { and }. + let s_expand = s_src.replace("{{", "{").replace("}}", "}"); + let sugg = format!("{}.to_string()", s_expand); + span_useless_format(cx, call_site, sugg, applicability); + } + } + } else if let [value] = *format_args.value_args { + if_chain! { + if format_args.format_string_symbols == [kw::Empty]; + if match cx.typeck_results().expr_ty(value).peel_refs().kind() { + ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(sym::string_type, adt.did), + ty::Str => true, + _ => false, + }; + if format_args.args.iter().all(|e| is_display_arg(e)); + if format_args.fmt_expr.map_or(true, |e| check_unformatted(e)); + then { + let is_new_string = match value.kind { + ExprKind::Binary(..) => true, + ExprKind::MethodCall(path, ..) => path.ident.name.as_str() == "to_string", + _ => false, + }; + let sugg = if is_new_string { + snippet_with_applicability(cx, value.span, "..", &mut applicability).into_owned() + } else { + let sugg = Sugg::hir_with_applicability(cx, value, "", &mut applicability); + format!("{}.to_string()", sugg.maybe_par()) + }; + span_useless_format(cx, call_site, sugg, applicability); + } + } + }; } } -fn span_useless_format(cx: &T, span: Span, help: &str, mut sugg: String) { - let to_replace = span.source_callsite(); - +fn span_useless_format(cx: &LateContext<'_>, span: Span, mut sugg: String, mut applicability: Applicability) { // The callsite span contains the statement semicolon for some reason. - let snippet = snippet(cx, to_replace, ".."); - if snippet.ends_with(';') { + if snippet_with_applicability(cx, span, "..", &mut applicability).ends_with(';') { sugg.push(';'); } - span_lint_and_then(cx, USELESS_FORMAT, span, "useless use of `format!`", |diag| { - diag.span_suggestion( - to_replace, - help, - sugg, - Applicability::MachineApplicable, // snippet - ); - }); + span_lint_and_sugg( + cx, + USELESS_FORMAT, + span, + "useless use of `format!`", + "consider using `.to_string()`", + sugg, + applicability, + ); } -fn on_argumentv1_new<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) -> Option { +fn is_display_arg(expr: &Expr<'_>) -> bool { if_chain! { - if let ExprKind::AddrOf(BorrowKind::Ref, _, format_args) = expr.kind; - if let ExprKind::Array(elems) = arms[0].body.kind; - if elems.len() == 1; - if let Some(args) = match_function_call(cx, &elems[0], &paths::FMT_ARGUMENTV1_NEW); - // matches `core::fmt::Display::fmt` - if args.len() == 2; - if let ExprKind::Path(ref qpath) = args[1].kind; - 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(pats, None) = arms[0].pat.kind; - if pats.len() == 1; - then { - let ty = cx.typeck_results().pat_ty(pats[0]).peel_refs(); - if *ty.kind() != rustc_middle::ty::Str && !is_type_diagnostic_item(cx, ty, sym::string_type) { - return None; - } - if let ExprKind::Lit(ref lit) = format_args.kind { - if let LitKind::Str(ref s, _) = lit.node { - return Some(format!("{:?}.to_string()", s.as_str())); - } - } else { - let sugg = Sugg::hir(cx, format_args, ""); - if let ExprKind::MethodCall(path, _, _, _) = format_args.kind { - if path.ident.name == sym!(to_string) { - return Some(format!("{}", sugg)); - } - } else if let ExprKind::Binary(..) = format_args.kind { - return Some(format!("{}", sugg)); - } - return Some(format!("{}.to_string()", sugg.maybe_par())); - } - } + if let ExprKind::Call(_, [_, fmt]) = expr.kind; + if let ExprKind::Path(QPath::Resolved(_, path)) = fmt.kind; + if let [.., t, _] = path.segments; + if t.ident.name.as_str() == "Display"; + then { true } else { false } } - None -} - -fn on_new_v1<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option { - if_chain! { - if let Some(args) = match_function_call(cx, expr, &paths::FMT_ARGUMENTS_NEW_V1); - if args.len() == 2; - // Argument 1 in `new_v1()` - if let ExprKind::AddrOf(BorrowKind::Ref, _, arr) = args[0].kind; - if let ExprKind::Array(pieces) = arr.kind; - if pieces.len() == 1; - if let ExprKind::Lit(ref lit) = pieces[0].kind; - if let LitKind::Str(ref s, _) = lit.node; - // Argument 2 in `new_v1()` - if let ExprKind::AddrOf(BorrowKind::Ref, _, arg1) = args[1].kind; - if let ExprKind::Match(matchee, arms, MatchSource::Normal) = arg1.kind; - if arms.len() == 1; - if let ExprKind::Tup(tup) = matchee.kind; - then { - // `format!("foo")` expansion contains `match () { () => [], }` - if tup.is_empty() { - if let Some(s_src) = snippet_opt(cx, lit.span) { - // Simulate macro expansion, converting {{ and }} to { and }. - let s_expand = s_src.replace("{{", "{").replace("}}", "}"); - return Some(format!("{}.to_string()", s_expand)); - } - } else if s.as_str().is_empty() { - return on_argumentv1_new(cx, &tup[0], arms); - } - } - } - None -} - -fn on_new_v1_fmt<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option { - if_chain! { - if let Some(args) = match_function_call(cx, expr, &paths::FMT_ARGUMENTS_NEW_V1_FORMATTED); - if args.len() == 3; - if check_unformatted(&args[2]); - // Argument 1 in `new_v1_formatted()` - if let ExprKind::AddrOf(BorrowKind::Ref, _, arr) = args[0].kind; - if let ExprKind::Array(pieces) = arr.kind; - if pieces.len() == 1; - if let ExprKind::Lit(ref lit) = pieces[0].kind; - if let LitKind::Str(symbol, _) = lit.node; - if symbol == kw::Empty; - // Argument 2 in `new_v1_formatted()` - if let ExprKind::AddrOf(BorrowKind::Ref, _, arg1) = args[1].kind; - if let ExprKind::Match(matchee, arms, MatchSource::Normal) = arg1.kind; - if arms.len() == 1; - if let ExprKind::Tup(tup) = matchee.kind; - then { - return on_argumentv1_new(cx, &tup[0], arms); - } - } - None } /// Checks if the expression matches @@ -186,10 +131,9 @@ fn on_new_v1_fmt<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option) -> bool { if_chain! { if let ExprKind::AddrOf(BorrowKind::Ref, _, expr) = expr.kind; - if let ExprKind::Array(exprs) = expr.kind; - if exprs.len() == 1; + if let ExprKind::Array([expr]) = expr.kind; // struct `core::fmt::rt::v1::Argument` - if let ExprKind::Struct(_, fields, _) = exprs[0].kind; + if let ExprKind::Struct(_, fields, _) = expr.kind; if let Some(format_field) = fields.iter().find(|f| f.ident.name == sym::format); // struct `core::fmt::rt::v1::FormatSpec` if let ExprKind::Struct(_, fields, _) = format_field.expr.kind; diff --git a/clippy_lints/src/methods/expect_fun_call.rs b/clippy_lints/src/methods/expect_fun_call.rs index 03cb41697..f8ee31a00 100644 --- a/clippy_lints/src/methods/expect_fun_call.rs +++ b/clippy_lints/src/methods/expect_fun_call.rs @@ -1,8 +1,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg; -use clippy_utils::is_expn_of; -use clippy_utils::source::{snippet, snippet_with_applicability}; +use clippy_utils::higher::FormatExpn; +use clippy_utils::source::snippet_with_applicability; use clippy_utils::ty::is_type_diagnostic_item; -use if_chain::if_chain; use rustc_errors::Applicability; use rustc_hir as hir; use rustc_lint::LateContext; @@ -94,27 +93,6 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_span: Spa } } - fn generate_format_arg_snippet( - cx: &LateContext<'_>, - a: &hir::Expr<'_>, - applicability: &mut Applicability, - ) -> Vec { - if_chain! { - if let hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, format_arg) = a.kind; - if let hir::ExprKind::Match(format_arg_expr, _, _) = format_arg.kind; - if let hir::ExprKind::Tup(format_arg_expr_tup) = format_arg_expr.kind; - - then { - format_arg_expr_tup - .iter() - .map(|a| snippet_with_applicability(cx, a.span, "..", applicability).into_owned()) - .collect() - } else { - unreachable!() - } - } - } - fn is_call(node: &hir::ExprKind<'_>) -> bool { match node { hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, expr) => { @@ -150,36 +128,22 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_span: Spa let mut applicability = Applicability::MachineApplicable; //Special handling for `format!` as arg_root - if_chain! { - if let hir::ExprKind::Block(block, None) = &arg_root.kind; - if block.stmts.len() == 1; - if let hir::StmtKind::Local(local) = &block.stmts[0].kind; - if let Some(arg_root) = &local.init; - if let hir::ExprKind::Call(inner_fun, inner_args) = arg_root.kind; - if is_expn_of(inner_fun.span, "format").is_some() && inner_args.len() == 1; - if let hir::ExprKind::Call(_, format_args) = &inner_args[0].kind; - then { - let fmt_spec = &format_args[0]; - let fmt_args = &format_args[1]; - - let mut args = vec![snippet(cx, fmt_spec.span, "..").into_owned()]; - - args.extend(generate_format_arg_snippet(cx, fmt_args, &mut applicability)); - - let sugg = args.join(", "); - - span_lint_and_sugg( - cx, - EXPECT_FUN_CALL, - span_replace_word, - &format!("use of `{}` followed by a function call", name), - "try this", - format!("unwrap_or_else({} panic!({}))", closure_args, sugg), - applicability, - ); - - return; - } + if let Some(format_expn) = FormatExpn::parse(arg_root) { + let span = match *format_expn.format_args.value_args { + [] => format_expn.format_args.format_string_span, + [.., last] => format_expn.format_args.format_string_span.to(last.span), + }; + let sugg = snippet_with_applicability(cx, span, "..", &mut applicability); + span_lint_and_sugg( + cx, + EXPECT_FUN_CALL, + span_replace_word, + &format!("use of `{}` followed by a function call", name), + "try this", + format!("unwrap_or_else({} panic!({}))", closure_args, sugg), + applicability, + ); + return; } let mut arg_root_snippet: Cow<'_, _> = snippet_with_applicability(cx, arg_root.span, "..", &mut applicability); diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs index 8be36756b..5ffd88f41 100644 --- a/clippy_utils/src/higher.rs +++ b/clippy_utils/src/higher.rs @@ -5,11 +5,11 @@ use crate::{is_expn_of, match_def_path, paths}; use if_chain::if_chain; -use rustc_ast::ast; +use rustc_ast::ast::{self, LitKind}; use rustc_hir as hir; use rustc_hir::{BorrowKind, Expr, ExprKind, StmtKind, UnOp}; use rustc_lint::LateContext; -use rustc_span::source_map::Span; +use rustc_span::{sym, ExpnKind, Span, Symbol}; /// Converts a hir binary operator to the corresponding `ast` type. #[must_use] @@ -266,3 +266,107 @@ pub fn extract_assert_macro_args<'tcx>(e: &'tcx Expr<'tcx>) -> Option { + /// Span of `format!(..)` + pub call_site: Span, + /// Inner `format_args!` expansion + pub format_args: FormatArgsExpn<'tcx>, +} + +impl FormatExpn<'tcx> { + /// Parses an expanded `format!` invocation + pub fn parse(expr: &'tcx Expr<'tcx>) -> Option { + if_chain! { + if let ExprKind::Block(block, _) = expr.kind; + if let [stmt] = block.stmts; + if let StmtKind::Local(local) = stmt.kind; + if let Some(init) = local.init; + if let ExprKind::Call(_, [format_args]) = init.kind; + let expn_data = expr.span.ctxt().outer_expn_data(); + if let ExpnKind::Macro { name: sym::format, .. } = expn_data.kind; + if let Some(format_args) = FormatArgsExpn::parse(format_args); + then { + Some(FormatExpn { + call_site: expn_data.call_site, + format_args, + }) + } else { + None + } + } + } +} + +/// A parsed `format_args!` expansion +pub struct FormatArgsExpn<'tcx> { + /// Span of the first argument, the format string + pub format_string_span: Span, + /// Values passed after the format string + pub value_args: Vec<&'tcx Expr<'tcx>>, + + /// String literal expressions which represent the format string split by "{}" + pub format_string_parts: &'tcx [Expr<'tcx>], + /// Symbols corresponding to [`format_string_parts`] + pub format_string_symbols: Vec, + /// Expressions like `ArgumentV1::new(arg0, Debug::fmt)` + pub args: &'tcx [Expr<'tcx>], + /// The final argument passed to `Arguments::new_v1_formatted`, if applicable + pub fmt_expr: Option<&'tcx Expr<'tcx>>, +} + +impl FormatArgsExpn<'tcx> { + /// Parses an expanded `format_args!` or `format_args_nl!` invocation + pub fn parse(expr: &'tcx Expr<'tcx>) -> Option { + if_chain! { + if let ExpnKind::Macro { name, .. } = expr.span.ctxt().outer_expn_data().kind; + let name = name.as_str(); + if name.ends_with("format_args") || name.ends_with("format_args_nl"); + if let ExprKind::Call(_, args) = expr.kind; + if let Some((strs_ref, args, fmt_expr)) = match args { + // Arguments::new_v1 + [strs_ref, args] => Some((strs_ref, args, None)), + // Arguments::new_v1_formatted + [strs_ref, args, fmt_expr] => Some((strs_ref, args, Some(fmt_expr))), + _ => None, + }; + if let ExprKind::AddrOf(BorrowKind::Ref, _, strs_arr) = strs_ref.kind; + if let ExprKind::Array(format_string_parts) = strs_arr.kind; + if let Some(format_string_symbols) = format_string_parts + .iter() + .map(|e| { + if let ExprKind::Lit(lit) = &e.kind { + if let LitKind::Str(symbol, _style) = lit.node { + return Some(symbol); + } + } + None + }) + .collect(); + if let ExprKind::AddrOf(BorrowKind::Ref, _, args) = args.kind; + if let ExprKind::Match(args, [arm], _) = args.kind; + if let ExprKind::Tup(value_args) = args.kind; + if let Some(value_args) = value_args + .iter() + .map(|e| match e.kind { + ExprKind::AddrOf(_, _, e) => Some(e), + _ => None, + }) + .collect(); + if let ExprKind::Array(args) = arm.body.kind; + then { + Some(FormatArgsExpn { + format_string_span: strs_ref.span, + value_args, + format_string_parts, + format_string_symbols, + args, + fmt_expr, + }) + } else { + None + } + } + } +} diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs index 9ebfbd6b4..c960eec30 100644 --- a/clippy_utils/src/paths.rs +++ b/clippy_utils/src/paths.rs @@ -38,7 +38,6 @@ pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "defa pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"]; pub const DEREF_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "Deref", "deref"]; pub const DIR_BUILDER: [&str; 3] = ["std", "fs", "DirBuilder"]; -pub const DISPLAY_FMT_METHOD: [&str; 4] = ["core", "fmt", "Display", "fmt"]; pub const DISPLAY_TRAIT: [&str; 3] = ["core", "fmt", "Display"]; pub const DOUBLE_ENDED_ITERATOR: [&str; 4] = ["core", "iter", "traits", "DoubleEndedIterator"]; pub const DROP: [&str; 3] = ["core", "mem", "drop"]; @@ -50,9 +49,6 @@ pub const F32_EPSILON: [&str; 4] = ["core", "f32", "", "EPSILON"]; pub const F64_EPSILON: [&str; 4] = ["core", "f64", "", "EPSILON"]; pub const FILE: [&str; 3] = ["std", "fs", "File"]; pub const FILE_TYPE: [&str; 3] = ["std", "fs", "FileType"]; -pub const FMT_ARGUMENTS_NEW_V1: [&str; 4] = ["core", "fmt", "Arguments", "new_v1"]; -pub const FMT_ARGUMENTS_NEW_V1_FORMATTED: [&str; 4] = ["core", "fmt", "Arguments", "new_v1_formatted"]; -pub const FMT_ARGUMENTV1_NEW: [&str; 4] = ["core", "fmt", "ArgumentV1", "new"]; pub const FROM_FROM: [&str; 4] = ["core", "convert", "From", "from"]; pub const FROM_ITERATOR: [&str; 5] = ["core", "iter", "traits", "collect", "FromIterator"]; pub const FROM_ITERATOR_METHOD: [&str; 6] = ["core", "iter", "traits", "collect", "FromIterator", "from_iter"];