Skip to content

Commit 4d8b66a

Browse files
borsbors
committed
Auto merge of #92787 - camsteffen:methodcall-span, r=Mark-Simulacrum
Remove a `Span` from `hir::ExprKind::MethodCall` It's just a copy of `MethodCall.0.ident.span`.
2 parents 84e9189 + b117335 commit 4d8b66a

File tree

112 files changed

+211
-220
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

112 files changed

+211
-220
lines changed

‎compiler/rustc_ast_lowering/src/expr.rs

+1-6
Original file line numberDiff line numberDiff line change
@@ -56,12 +56,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
5656
ImplTraitContext::disallowed(),
5757
));
5858
let args = self.lower_exprs(args);
59-
hir::ExprKind::MethodCall(
60-
hir_seg,
61-
self.lower_span(seg.ident.span),
62-
args,
63-
self.lower_span(span),
64-
)
59+
hir::ExprKind::MethodCall(hir_seg, args, self.lower_span(span))
6560
}
6661
ExprKind::Binary(binop, ref lhs, ref rhs) => {
6762
let binop = self.lower_binop(binop);

‎compiler/rustc_hir/src/hir.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -1669,21 +1669,21 @@ pub enum ExprKind<'hir> {
16691669
Call(&'hir Expr<'hir>, &'hir [Expr<'hir>]),
16701670
/// A method call (e.g., `x.foo::<'static, Bar, Baz>(a, b, c, d)`).
16711671
///
1672-
/// The `PathSegment`/`Span` represent the method name and its generic arguments
1672+
/// The `PathSegment` represents the method name and its generic arguments
16731673
/// (within the angle brackets).
1674-
/// The first element of the vector of `Expr`s is the expression that evaluates
1674+
/// The first element of the `&[Expr]` is the expression that evaluates
16751675
/// to the object on which the method is being called on (the receiver),
16761676
/// and the remaining elements are the rest of the arguments.
16771677
/// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as
1678-
/// `ExprKind::MethodCall(PathSegment { foo, [Bar, Baz] }, [x, a, b, c, d])`.
1678+
/// `ExprKind::MethodCall(PathSegment { foo, [Bar, Baz] }, [x, a, b, c, d], span)`.
16791679
/// The final `Span` represents the span of the function and arguments
16801680
/// (e.g. `foo::<Bar, Baz>(a, b, c, d)` in `x.foo::<Bar, Baz>(a, b, c, d)`
16811681
///
16821682
/// To resolve the called method to a `DefId`, call [`type_dependent_def_id`] with
16831683
/// the `hir_id` of the `MethodCall` node itself.
16841684
///
16851685
/// [`type_dependent_def_id`]: ../ty/struct.TypeckResults.html#method.type_dependent_def_id
1686-
MethodCall(&'hir PathSegment<'hir>, Span, &'hir [Expr<'hir>], Span),
1686+
MethodCall(&'hir PathSegment<'hir>, &'hir [Expr<'hir>], Span),
16871687
/// A tuple (e.g., `(a, b, c, d)`).
16881688
Tup(&'hir [Expr<'hir>]),
16891689
/// A binary operation (e.g., `a + b`, `a * b`).
@@ -3257,7 +3257,7 @@ impl<'hir> Node<'hir> {
32573257
#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
32583258
mod size_asserts {
32593259
rustc_data_structures::static_assert_size!(super::Block<'static>, 48);
3260-
rustc_data_structures::static_assert_size!(super::Expr<'static>, 64);
3260+
rustc_data_structures::static_assert_size!(super::Expr<'static>, 56);
32613261
rustc_data_structures::static_assert_size!(super::Pat<'static>, 88);
32623262
rustc_data_structures::static_assert_size!(super::QPath<'static>, 24);
32633263
rustc_data_structures::static_assert_size!(super::Ty<'static>, 80);

‎compiler/rustc_hir/src/intravisit.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1149,7 +1149,7 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>)
11491149
visitor.visit_expr(callee_expression);
11501150
walk_list!(visitor, visit_expr, arguments);
11511151
}
1152-
ExprKind::MethodCall(ref segment, _, arguments, _) => {
1152+
ExprKind::MethodCall(ref segment, arguments, _) => {
11531153
visitor.visit_path_segment(expression.span, segment);
11541154
walk_list!(visitor, visit_expr, arguments);
11551155
}

‎compiler/rustc_hir_pretty/src/lib.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1427,7 +1427,7 @@ impl<'a> State<'a> {
14271427
hir::ExprKind::Call(ref func, ref args) => {
14281428
self.print_expr_call(&func, args);
14291429
}
1430-
hir::ExprKind::MethodCall(ref segment, _, ref args, _) => {
1430+
hir::ExprKind::MethodCall(ref segment, ref args, _) => {
14311431
self.print_expr_method_call(segment, args);
14321432
}
14331433
hir::ExprKind::Binary(op, ref lhs, ref rhs) => {

‎compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -121,8 +121,8 @@ impl<'a, 'tcx> Visitor<'tcx> for FindHirNodeVisitor<'a, 'tcx> {
121121
}
122122
}
123123
}
124-
if let ExprKind::MethodCall(_, call_span, exprs, _) = expr.kind {
125-
if call_span == self.target_span
124+
if let ExprKind::MethodCall(segment, exprs, _) = expr.kind {
125+
if segment.ident.span == self.target_span
126126
&& Some(self.target)
127127
== self.infcx.in_progress_typeck_results.and_then(|typeck_results| {
128128
typeck_results
@@ -531,7 +531,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
531531
// 3 | let _ = x.sum() as f64;
532532
// | ^^^ cannot infer type for `S`
533533
span
534-
} else if let Some(ExprKind::MethodCall(_, call_span, _, _)) =
534+
} else if let Some(ExprKind::MethodCall(segment, ..)) =
535535
local_visitor.found_method_call.map(|e| &e.kind)
536536
{
537537
// Point at the call instead of the whole expression:
@@ -542,7 +542,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
542542
// | ^^^^^^^ cannot infer type
543543
// |
544544
// = note: cannot resolve `<_ as std::ops::Try>::Ok == _`
545-
if span.contains(*call_span) { *call_span } else { span }
545+
if span.contains(segment.ident.span) { segment.ident.span } else { span }
546546
} else {
547547
span
548548
};
@@ -709,7 +709,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
709709
};
710710
err.span_label(pattern.span, msg);
711711
} else if let Some(e) = local_visitor.found_method_call {
712-
if let ExprKind::MethodCall(segment, _, exprs, _) = &e.kind {
712+
if let ExprKind::MethodCall(segment, exprs, _) = &e.kind {
713713
// Suggest impl candidates:
714714
//
715715
// error[E0283]: type annotations needed

‎compiler/rustc_lint/src/array_into_iter.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -61,7 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for ArrayIntoIter {
6161
}
6262

6363
// We only care about method call expressions.
64-
if let hir::ExprKind::MethodCall(call, span, args, _) = &expr.kind {
64+
if let hir::ExprKind::MethodCall(call, args, _) = &expr.kind {
6565
if call.ident.name != sym::into_iter {
6666
return;
6767
}
@@ -119,7 +119,7 @@ impl<'tcx> LateLintPass<'tcx> for ArrayIntoIter {
119119
// to an array or to a slice.
120120
_ => bug!("array type coerced to something other than array or slice"),
121121
};
122-
cx.struct_span_lint(ARRAY_INTO_ITER, *span, |lint| {
122+
cx.struct_span_lint(ARRAY_INTO_ITER, call.ident.span, |lint| {
123123
let mut diag = lint.build(&format!(
124124
"this method call resolves to `<&{} as IntoIterator>::into_iter` \
125125
(due to backwards compatibility), \

‎compiler/rustc_lint/src/builtin.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -2494,7 +2494,7 @@ impl<'tcx> LateLintPass<'tcx> for InvalidValue {
24942494
_ => {}
24952495
}
24962496
}
2497-
} else if let hir::ExprKind::MethodCall(_, _, ref args, _) = expr.kind {
2497+
} else if let hir::ExprKind::MethodCall(_, ref args, _) = expr.kind {
24982498
// Find problematic calls to `MaybeUninit::assume_init`.
24992499
let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
25002500
if cx.tcx.is_diagnostic_item(sym::assume_init, def_id) {

‎compiler/rustc_lint/src/methods.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,7 @@ fn in_macro(span: Span) -> bool {
4444
fn first_method_call<'tcx>(
4545
expr: &'tcx Expr<'tcx>,
4646
) -> Option<(&'tcx PathSegment<'tcx>, &'tcx [Expr<'tcx>])> {
47-
if let ExprKind::MethodCall(path, _, args, _) = &expr.kind {
47+
if let ExprKind::MethodCall(path, args, _) = &expr.kind {
4848
if args.iter().any(|e| e.span.from_expansion()) { None } else { Some((path, *args)) }
4949
} else {
5050
None

‎compiler/rustc_lint/src/noop_method_call.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -40,7 +40,7 @@ declare_lint_pass!(NoopMethodCall => [NOOP_METHOD_CALL]);
4040
impl<'tcx> LateLintPass<'tcx> for NoopMethodCall {
4141
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
4242
// We only care about method calls.
43-
let ExprKind::MethodCall(call, _, elements, _) = &expr.kind else {
43+
let ExprKind::MethodCall(call, elements, _) = &expr.kind else {
4444
return
4545
};
4646
// We only care about method calls corresponding to the `Clone`, `Deref` and `Borrow`

‎compiler/rustc_lint/src/types.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1464,7 +1464,7 @@ impl InvalidAtomicOrdering {
14641464
sym::AtomicI128,
14651465
];
14661466
if_chain! {
1467-
if let ExprKind::MethodCall(ref method_path, _, args, _) = &expr.kind;
1467+
if let ExprKind::MethodCall(ref method_path, args, _) = &expr.kind;
14681468
if recognized_names.contains(&method_path.ident.name);
14691469
if let Some(m_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
14701470
if let Some(impl_did) = cx.tcx.impl_of_method(m_def_id);

‎compiler/rustc_mir_build/src/thir/cx/expr.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -163,9 +163,9 @@ impl<'tcx> Cx<'tcx> {
163163

164164
let kind = match expr.kind {
165165
// Here comes the interesting stuff:
166-
hir::ExprKind::MethodCall(_, method_span, ref args, fn_span) => {
166+
hir::ExprKind::MethodCall(segment, ref args, fn_span) => {
167167
// Rewrite a.b(c) into UFCS form like Trait::b(a, c)
168-
let expr = self.method_callee(expr, method_span, None);
168+
let expr = self.method_callee(expr, segment.ident.span, None);
169169
// When we apply adjustments to the receiver, use the span of
170170
// the overall method call for better diagnostics. args[0]
171171
// is guaranteed to exist, since a method call always has a receiver.

‎compiler/rustc_privacy/src/lib.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -1203,9 +1203,9 @@ impl<'tcx> Visitor<'tcx> for TypePrivacyVisitor<'tcx> {
12031203
return;
12041204
}
12051205
}
1206-
hir::ExprKind::MethodCall(_, span, _, _) => {
1206+
hir::ExprKind::MethodCall(segment, ..) => {
12071207
// Method calls have to be checked specially.
1208-
self.span = span;
1208+
self.span = segment.ident.span;
12091209
if let Some(def_id) = self.typeck_results().type_dependent_def_id(expr.hir_id) {
12101210
if self.visit(self.tcx.type_of(def_id)).is_break() {
12111211
return;

‎compiler/rustc_save_analysis/src/dump_visitor.rs

+1-3
Original file line numberDiff line numberDiff line change
@@ -1363,9 +1363,7 @@ impl<'tcx> Visitor<'tcx> for DumpVisitor<'tcx> {
13631363
let res = self.save_ctxt.get_path_res(hir_expr.hir_id);
13641364
self.process_struct_lit(ex, path, fields, adt.variant_of_res(res), *rest)
13651365
}
1366-
hir::ExprKind::MethodCall(ref seg, _, args, _) => {
1367-
self.process_method_call(ex, seg, args)
1368-
}
1366+
hir::ExprKind::MethodCall(ref seg, args, _) => self.process_method_call(ex, seg, args),
13691367
hir::ExprKind::Field(ref sub_ex, _) => {
13701368
self.visit_expr(&sub_ex);
13711369

‎compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs

+4-1
Original file line numberDiff line numberDiff line change
@@ -2322,7 +2322,10 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
23222322
if let Some(Node::Expr(hir::Expr {
23232323
kind:
23242324
hir::ExprKind::Call(hir::Expr { span, .. }, _)
2325-
| hir::ExprKind::MethodCall(_, span, ..),
2325+
| hir::ExprKind::MethodCall(
2326+
hir::PathSegment { ident: Ident { span, .. }, .. },
2327+
..,
2328+
),
23262329
..
23272330
})) = hir.find(call_hir_id)
23282331
{

‎compiler/rustc_typeck/src/check/demand.rs

+8-7
Original file line numberDiff line numberDiff line change
@@ -464,14 +464,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
464464
let expr_parent = self.tcx.hir().get_parent_node(*expr_hir_id);
465465
let hir = self.tcx.hir().find(expr_parent);
466466
let closure_params_len = closure_fn_decl.inputs.len();
467-
let (method_path, method_span, method_expr) = match (hir, closure_params_len) {
467+
let (method_path, method_expr) = match (hir, closure_params_len) {
468468
(
469469
Some(Node::Expr(hir::Expr {
470-
kind: hir::ExprKind::MethodCall(path, span, expr, _),
470+
kind: hir::ExprKind::MethodCall(segment, expr, _),
471471
..
472472
})),
473473
1,
474-
) => (path, span, expr),
474+
) => (segment, expr),
475475
_ => return None,
476476
};
477477

@@ -483,10 +483,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
483483
|| self_ty.starts_with("std::option::Option")
484484
|| self_ty.starts_with("std::result::Result"))
485485
&& (name == sym::map || name == sym::and_then);
486-
match (is_as_ref_able, self.sess().source_map().span_to_snippet(*method_span)) {
486+
match (is_as_ref_able, self.sess().source_map().span_to_snippet(method_path.ident.span)) {
487487
(true, Ok(src)) => {
488488
let suggestion = format!("as_ref().{}", src);
489-
Some((*method_span, "consider using `as_ref` instead", suggestion))
489+
Some((method_path.ident.span, "consider using `as_ref` instead", suggestion))
490490
}
491491
_ => None,
492492
}
@@ -643,8 +643,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
643643
};
644644
if self.can_coerce(ref_ty, expected) {
645645
let mut sugg_sp = sp;
646-
if let hir::ExprKind::MethodCall(ref segment, sp, ref args, _) = expr.kind {
647-
let clone_trait = self.tcx.require_lang_item(LangItem::Clone, Some(sp));
646+
if let hir::ExprKind::MethodCall(ref segment, ref args, _) = expr.kind {
647+
let clone_trait =
648+
self.tcx.require_lang_item(LangItem::Clone, Some(segment.ident.span));
648649
if let ([arg], Some(true), sym::clone) = (
649650
&args[..],
650651
self.typeck_results.borrow().type_dependent_def_id(expr.hir_id).map(

‎compiler/rustc_typeck/src/check/expr.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -230,8 +230,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
230230
// we skip issuing a warning because it is autogenerated code.
231231
ExprKind::Call(..) if expr.span.is_desugaring(DesugaringKind::TryBlock) => {}
232232
ExprKind::Call(callee, _) => self.warn_if_unreachable(expr.hir_id, callee.span, "call"),
233-
ExprKind::MethodCall(_, ref span, _, _) => {
234-
self.warn_if_unreachable(expr.hir_id, *span, "call")
233+
ExprKind::MethodCall(segment, ..) => {
234+
self.warn_if_unreachable(expr.hir_id, segment.ident.span, "call")
235235
}
236236
_ => self.warn_if_unreachable(expr.hir_id, expr.span, "expression"),
237237
}
@@ -306,8 +306,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
306306
}
307307
ExprKind::Block(body, _) => self.check_block_with_expected(&body, expected),
308308
ExprKind::Call(callee, args) => self.check_call(expr, &callee, args, expected),
309-
ExprKind::MethodCall(segment, span, args, _) => {
310-
self.check_method_call(expr, segment, span, args, expected)
309+
ExprKind::MethodCall(segment, args, _) => {
310+
self.check_method_call(expr, segment, args, expected)
311311
}
312312
ExprKind::Cast(e, t) => self.check_expr_cast(e, t, expr),
313313
ExprKind::Type(e, t) => {
@@ -1097,14 +1097,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
10971097
&self,
10981098
expr: &'tcx hir::Expr<'tcx>,
10991099
segment: &hir::PathSegment<'_>,
1100-
span: Span,
11011100
args: &'tcx [hir::Expr<'tcx>],
11021101
expected: Expectation<'tcx>,
11031102
) -> Ty<'tcx> {
11041103
let rcvr = &args[0];
11051104
let rcvr_t = self.check_expr(&rcvr);
11061105
// no need to check for bot/err -- callee does that
11071106
let rcvr_t = self.structurally_resolved_type(args[0].span, rcvr_t);
1107+
let span = segment.ident.span;
11081108

11091109
let method = match self.lookup_method(rcvr_t, segment, span, expr, rcvr, args) {
11101110
Ok(method) => {

‎compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -964,7 +964,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
964964
if found != self.tcx.types.unit {
965965
return;
966966
}
967-
if let ExprKind::MethodCall(path_segment, _, [rcvr, ..], _) = expr.kind {
967+
if let ExprKind::MethodCall(path_segment, [rcvr, ..], _) = expr.kind {
968968
if self
969969
.typeck_results
970970
.borrow()

‎compiler/rustc_typeck/src/check/fn_ctxt/checks.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -148,8 +148,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
148148
hir::ExprKind::Call(hir::Expr { span, .. }, args) => {
149149
(*span, *span, &args[..], None)
150150
}
151-
hir::ExprKind::MethodCall(path_segment, span, args, _) => (
152-
*span,
151+
hir::ExprKind::MethodCall(path_segment, args, _) => (
152+
path_segment.ident.span,
153153
// `sp` doesn't point at the whole `foo.bar()`, only at `bar`.
154154
path_segment
155155
.args
@@ -161,7 +161,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
161161
.source_map()
162162
.next_point(tcx.sess.source_map().next_point(arg.span()))
163163
})
164-
.unwrap_or(*span),
164+
.unwrap_or(path_segment.ident.span),
165165
&args[1..], // Skip the receiver.
166166
None, // methods are never ctors
167167
),

‎compiler/rustc_typeck/src/check/generator_interior/drop_ranges/cfg_build.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -345,7 +345,7 @@ impl<'a, 'tcx> Visitor<'tcx> for DropRangeVisitor<'a, 'tcx> {
345345

346346
self.handle_uninhabited_return(expr);
347347
}
348-
ExprKind::MethodCall(_, _, exprs, _) => {
348+
ExprKind::MethodCall(_, exprs, _) => {
349349
for expr in exprs {
350350
self.visit_expr(expr);
351351
}

‎src/librustdoc/html/render/span_map.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -130,7 +130,7 @@ impl<'tcx> Visitor<'tcx> for SpanMapVisitor<'tcx> {
130130
}
131131

132132
fn visit_expr(&mut self, expr: &'tcx rustc_hir::Expr<'tcx>) {
133-
if let ExprKind::MethodCall(segment, method_span, _, _) = expr.kind {
133+
if let ExprKind::MethodCall(segment, ..) = expr.kind {
134134
if let Some(hir_id) = segment.hir_id {
135135
let hir = self.tcx.hir();
136136
let body_id = hir.enclosing_body_owner(hir_id);
@@ -141,7 +141,7 @@ impl<'tcx> Visitor<'tcx> for SpanMapVisitor<'tcx> {
141141
});
142142
if let Some(def_id) = typeck_results.type_dependent_def_id(expr.hir_id) {
143143
self.matches.insert(
144-
method_span,
144+
segment.ident.span,
145145
match hir.span_if_local(def_id) {
146146
Some(span) => LinkFromSrc::Local(clean::Span::new(span)),
147147
None => LinkFromSrc::External(def_id),

‎src/librustdoc/scrape_examples.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -150,7 +150,7 @@ where
150150
return;
151151
}
152152
}
153-
hir::ExprKind::MethodCall(_, _, _, span) => {
153+
hir::ExprKind::MethodCall(_, _, span) => {
154154
let types = tcx.typeck(ex.hir_id.owner);
155155
let def_id = if let Some(def_id) = types.type_dependent_def_id(ex.hir_id) {
156156
def_id

‎src/tools/clippy/clippy_lints/src/blocks_in_if_conditions.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -59,7 +59,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ExVisitor<'a, 'tcx> {
5959
// do not lint if the closure is called using an iterator (see #1141)
6060
if_chain! {
6161
if let Some(parent) = get_parent_expr(self.cx, expr);
62-
if let ExprKind::MethodCall(_, _, [self_arg, ..], _) = &parent.kind;
62+
if let ExprKind::MethodCall(_, [self_arg, ..], _) = &parent.kind;
6363
let caller = self.cx.typeck_results().expr_ty(self_arg);
6464
if let Some(iter_id) = self.cx.tcx.get_diagnostic_item(sym::Iterator);
6565
if implements_trait(self.cx, caller, iter_id, &[]);

‎src/tools/clippy/clippy_lints/src/booleans.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -259,7 +259,7 @@ fn simplify_not(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
259259
))
260260
})
261261
},
262-
ExprKind::MethodCall(path, _, args, _) if args.len() == 1 => {
262+
ExprKind::MethodCall(path, args, _) if args.len() == 1 => {
263263
let type_of_receiver = cx.typeck_results().expr_ty(&args[0]);
264264
if !is_type_diagnostic_item(cx, type_of_receiver, sym::Option)
265265
&& !is_type_diagnostic_item(cx, type_of_receiver, sym::Result)

0 commit comments

Comments
 (0)