Skip to content

Commit b44197a

Browse files
borsbors
committed
Auto merge of #101261 - TaKO8Ki:separate-receiver-from-arguments-in-hir, r=cjgillot
Separate the receiver from arguments in HIR Related to #100232 cc `@cjgillot`
2 parents 2dc703f + 9cde34e commit b44197a

File tree

140 files changed

+815
-720
lines changed

Some content is hidden

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

140 files changed

+815
-720
lines changed

‎compiler/rustc_ast_lowering/src/expr.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -68,10 +68,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
6868
ParenthesizedGenericArgs::Err,
6969
ImplTraitContext::Disallowed(ImplTraitPosition::Path),
7070
));
71-
let args = self.arena.alloc_from_iter(
72-
[&*receiver].into_iter().chain(args.iter()).map(|x| self.lower_expr_mut(x)),
73-
);
74-
hir::ExprKind::MethodCall(hir_seg, args, self.lower_span(span))
71+
let receiver = self.lower_expr(receiver);
72+
let args =
73+
self.arena.alloc_from_iter(args.iter().map(|x| self.lower_expr_mut(x)));
74+
hir::ExprKind::MethodCall(hir_seg, receiver, args, self.lower_span(span))
7575
}
7676
ExprKind::Binary(binop, ref lhs, ref rhs) => {
7777
let binop = self.lower_binop(binop);

‎compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

+4-8
Original file line numberDiff line numberDiff line change
@@ -711,8 +711,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
711711
Applicability::MachineApplicable,
712712
);
713713
self.suggested = true;
714-
} else if let hir::ExprKind::MethodCall(_path, args @ [_, ..], sp) = expr.kind
715-
&& let hir::ExprKind::Index(val, index) = args[0].kind
714+
} else if let hir::ExprKind::MethodCall(_path, receiver, _, sp) = expr.kind
715+
&& let hir::ExprKind::Index(val, index) = receiver.kind
716716
&& expr.span == self.assign_span
717717
{
718718
// val[index].path(args..);
@@ -724,7 +724,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
724724
".get_mut(".to_string(),
725725
),
726726
(
727-
index.span.shrink_to_hi().with_hi(args[0].span.hi()),
727+
index.span.shrink_to_hi().with_hi(receiver.span.hi()),
728728
").map(|val| val".to_string(),
729729
),
730730
(sp.shrink_to_hi(), ")".to_string()),
@@ -911,11 +911,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
911911
[
912912
Expr {
913913
kind:
914-
MethodCall(
915-
path_segment,
916-
_args,
917-
span,
918-
),
914+
MethodCall(path_segment, _, _, span),
919915
hir_id,
920916
..
921917
},

‎compiler/rustc_borrowck/src/diagnostics/region_errors.rs

+3-4
Original file line numberDiff line numberDiff line change
@@ -900,14 +900,13 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
900900
let mut closure_span = None::<rustc_span::Span>;
901901
match expr.kind {
902902
hir::ExprKind::MethodCall(.., args, _) => {
903-
// only the first closre parameter of the method. args[0] is MethodCall PathSegment
904-
for i in 1..args.len() {
903+
for arg in args {
905904
if let hir::ExprKind::Closure(hir::Closure {
906905
capture_clause: hir::CaptureBy::Ref,
907906
..
908-
}) = args[i].kind
907+
}) = arg.kind
909908
{
910-
closure_span = Some(args[i].span.shrink_to_lo());
909+
closure_span = Some(arg.span.shrink_to_lo());
911910
break;
912911
}
913912
}

‎compiler/rustc_hir/src/hir.rs

+6-6
Original file line numberDiff line numberDiff line change
@@ -1876,19 +1876,19 @@ pub enum ExprKind<'hir> {
18761876
///
18771877
/// The `PathSegment` represents the method name and its generic arguments
18781878
/// (within the angle brackets).
1879-
/// The first element of the `&[Expr]` is the expression that evaluates
1879+
/// The `&Expr` is the expression that evaluates
18801880
/// to the object on which the method is being called on (the receiver),
1881-
/// and the remaining elements are the rest of the arguments.
1881+
/// and the `&[Expr]` is the rest of the arguments.
18821882
/// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as
1883-
/// `ExprKind::MethodCall(PathSegment { foo, [Bar, Baz] }, [x, a, b, c, d], span)`.
1883+
/// `ExprKind::MethodCall(PathSegment { foo, [Bar, Baz] }, x, [a, b, c, d], span)`.
18841884
/// The final `Span` represents the span of the function and arguments
18851885
/// (e.g. `foo::<Bar, Baz>(a, b, c, d)` in `x.foo::<Bar, Baz>(a, b, c, d)`
18861886
///
18871887
/// To resolve the called method to a `DefId`, call [`type_dependent_def_id`] with
18881888
/// the `hir_id` of the `MethodCall` node itself.
18891889
///
18901890
/// [`type_dependent_def_id`]: ../../rustc_middle/ty/struct.TypeckResults.html#method.type_dependent_def_id
1891-
MethodCall(&'hir PathSegment<'hir>, &'hir [Expr<'hir>], Span),
1891+
MethodCall(&'hir PathSegment<'hir>, &'hir Expr<'hir>, &'hir [Expr<'hir>], Span),
18921892
/// A tuple (e.g., `(a, b, c, d)`).
18931893
Tup(&'hir [Expr<'hir>]),
18941894
/// A binary operation (e.g., `a + b`, `a * b`).
@@ -3492,8 +3492,8 @@ mod size_asserts {
34923492
// These are in alphabetical order, which is easy to maintain.
34933493
static_assert_size!(Block<'_>, 48);
34943494
static_assert_size!(Body<'_>, 32);
3495-
static_assert_size!(Expr<'_>, 56);
3496-
static_assert_size!(ExprKind<'_>, 40);
3495+
static_assert_size!(Expr<'_>, 64);
3496+
static_assert_size!(ExprKind<'_>, 48);
34973497
static_assert_size!(FnDecl<'_>, 40);
34983498
static_assert_size!(ForeignItem<'_>, 72);
34993499
static_assert_size!(ForeignItemKind<'_>, 40);

‎compiler/rustc_hir/src/intravisit.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -1094,8 +1094,9 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>)
10941094
visitor.visit_expr(callee_expression);
10951095
walk_list!(visitor, visit_expr, arguments);
10961096
}
1097-
ExprKind::MethodCall(ref segment, arguments, _) => {
1097+
ExprKind::MethodCall(ref segment, receiver, arguments, _) => {
10981098
visitor.visit_path_segment(expression.span, segment);
1099+
visitor.visit_expr(receiver);
10991100
walk_list!(visitor, visit_expr, arguments);
11001101
}
11011102
ExprKind::Binary(_, ref left_expression, ref right_expression) => {

‎compiler/rustc_hir_pretty/src/lib.rs

+12-7
Original file line numberDiff line numberDiff line change
@@ -1181,9 +1181,14 @@ impl<'a> State<'a> {
11811181
self.print_call_post(args)
11821182
}
11831183

1184-
fn print_expr_method_call(&mut self, segment: &hir::PathSegment<'_>, args: &[hir::Expr<'_>]) {
1185-
let base_args = &args[1..];
1186-
self.print_expr_maybe_paren(&args[0], parser::PREC_POSTFIX);
1184+
fn print_expr_method_call(
1185+
&mut self,
1186+
segment: &hir::PathSegment<'_>,
1187+
receiver: &hir::Expr<'_>,
1188+
args: &[hir::Expr<'_>],
1189+
) {
1190+
let base_args = args;
1191+
self.print_expr_maybe_paren(&receiver, parser::PREC_POSTFIX);
11871192
self.word(".");
11881193
self.print_ident(segment.ident);
11891194

@@ -1394,8 +1399,8 @@ impl<'a> State<'a> {
13941399
hir::ExprKind::Call(func, args) => {
13951400
self.print_expr_call(func, args);
13961401
}
1397-
hir::ExprKind::MethodCall(segment, args, _) => {
1398-
self.print_expr_method_call(segment, args);
1402+
hir::ExprKind::MethodCall(segment, receiver, args, _) => {
1403+
self.print_expr_method_call(segment, receiver, args);
13991404
}
14001405
hir::ExprKind::Binary(op, lhs, rhs) => {
14011406
self.print_expr_binary(op, lhs, rhs);
@@ -2393,9 +2398,9 @@ fn contains_exterior_struct_lit(value: &hir::Expr<'_>) -> bool {
23932398
contains_exterior_struct_lit(x)
23942399
}
23952400

2396-
hir::ExprKind::MethodCall(.., exprs, _) => {
2401+
hir::ExprKind::MethodCall(_, receiver, ..) => {
23972402
// `X { y: 1 }.bar(...)`
2398-
contains_exterior_struct_lit(&exprs[0])
2403+
contains_exterior_struct_lit(receiver)
23992404
}
24002405

24012406
_ => false,

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

+5-5
Original file line numberDiff line numberDiff line change
@@ -901,7 +901,7 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> {
901901
}
902902
}
903903
}
904-
hir::ExprKind::MethodCall(segment, _, _) => {
904+
hir::ExprKind::MethodCall(segment, ..) => {
905905
if let Some(def_id) = self.typeck_results.type_dependent_def_id(expr.hir_id) {
906906
let generics = tcx.generics_of(def_id);
907907
let insertable: Option<_> = try {
@@ -1132,7 +1132,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindInferSourceVisitor<'a, 'tcx> {
11321132
let generic_args = &generics.own_substs_no_defaults(tcx, substs)
11331133
[generics.own_counts().lifetimes..];
11341134
let span = match expr.kind {
1135-
ExprKind::MethodCall(path, _, _) => path.ident.span,
1135+
ExprKind::MethodCall(path, ..) => path.ident.span,
11361136
_ => expr.span,
11371137
};
11381138

@@ -1181,20 +1181,20 @@ impl<'a, 'tcx> Visitor<'tcx> for FindInferSourceVisitor<'a, 'tcx> {
11811181
})
11821182
.any(|generics| generics.has_impl_trait())
11831183
};
1184-
if let ExprKind::MethodCall(path, args, span) = expr.kind
1184+
if let ExprKind::MethodCall(path, receiver, args, span) = expr.kind
11851185
&& let Some(substs) = self.node_substs_opt(expr.hir_id)
11861186
&& substs.iter().any(|arg| self.generic_arg_contains_target(arg))
11871187
&& let Some(def_id) = self.typeck_results.type_dependent_def_id(expr.hir_id)
11881188
&& self.infcx.tcx.trait_of_item(def_id).is_some()
11891189
&& !has_impl_trait(def_id)
11901190
{
11911191
let successor =
1192-
args.get(1).map_or_else(|| (")", span.hi()), |arg| (", ", arg.span.lo()));
1192+
args.get(0).map_or_else(|| (")", span.hi()), |arg| (", ", arg.span.lo()));
11931193
let substs = self.infcx.resolve_vars_if_possible(substs);
11941194
self.update_infer_source(InferSource {
11951195
span: path.ident.span,
11961196
kind: InferSourceKind::FullyQualifiedMethodCall {
1197-
receiver: args.first().unwrap(),
1197+
receiver,
11981198
successor,
11991199
substs,
12001200
def_id,

‎compiler/rustc_lint/src/array_into_iter.rs

+1-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, args, _) = &expr.kind {
64+
if let hir::ExprKind::MethodCall(call, receiver_arg, ..) = &expr.kind {
6565
if call.ident.name != sym::into_iter {
6666
return;
6767
}
@@ -75,7 +75,6 @@ impl<'tcx> LateLintPass<'tcx> for ArrayIntoIter {
7575
};
7676

7777
// As this is a method call expression, we have at least one argument.
78-
let receiver_arg = &args[0];
7978
let receiver_ty = cx.typeck_results().expr_ty(receiver_arg);
8079
let adjustments = cx.typeck_results().expr_adjustments(receiver_arg);
8180

‎compiler/rustc_lint/src/builtin.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -2412,13 +2412,13 @@ impl<'tcx> LateLintPass<'tcx> for InvalidValue {
24122412
_ => {}
24132413
}
24142414
}
2415-
} else if let hir::ExprKind::MethodCall(_, ref args, _) = expr.kind {
2415+
} else if let hir::ExprKind::MethodCall(_, receiver, ..) = expr.kind {
24162416
// Find problematic calls to `MaybeUninit::assume_init`.
24172417
let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?;
24182418
if cx.tcx.is_diagnostic_item(sym::assume_init, def_id) {
24192419
// This is a call to *some* method named `assume_init`.
24202420
// See if the `self` parameter is one of the dangerous constructors.
2421-
if let hir::ExprKind::Call(ref path_expr, _) = args[0].kind {
2421+
if let hir::ExprKind::Call(ref path_expr, _) = receiver.kind {
24222422
if let hir::ExprKind::Path(ref qpath) = path_expr.kind {
24232423
let def_id = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id()?;
24242424
match cx.tcx.get_diagnostic_name(def_id) {

‎compiler/rustc_lint/src/internal.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ fn typeck_results_of_method_fn<'tcx>(
5151
expr: &Expr<'_>,
5252
) -> Option<(Span, DefId, ty::subst::SubstsRef<'tcx>)> {
5353
match expr.kind {
54-
ExprKind::MethodCall(segment, _, _)
54+
ExprKind::MethodCall(segment, ..)
5555
if let Some(def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) =>
5656
{
5757
Some((segment.ident.span, def_id, cx.typeck_results().node_substs(expr.hir_id)))

‎compiler/rustc_lint/src/methods.rs

+10-8
Original file line numberDiff line numberDiff line change
@@ -44,9 +44,13 @@ fn in_macro(span: Span) -> bool {
4444

4545
fn first_method_call<'tcx>(
4646
expr: &'tcx Expr<'tcx>,
47-
) -> Option<(&'tcx PathSegment<'tcx>, &'tcx [Expr<'tcx>])> {
48-
if let ExprKind::MethodCall(path, args, _) = &expr.kind {
49-
if args.iter().any(|e| e.span.from_expansion()) { None } else { Some((path, *args)) }
47+
) -> Option<(&'tcx PathSegment<'tcx>, &'tcx Expr<'tcx>)> {
48+
if let ExprKind::MethodCall(path, receiver, args, ..) = &expr.kind {
49+
if args.iter().any(|e| e.span.from_expansion()) || receiver.span.from_expansion() {
50+
None
51+
} else {
52+
Some((path, *receiver))
53+
}
5054
} else {
5155
None
5256
}
@@ -59,15 +63,13 @@ impl<'tcx> LateLintPass<'tcx> for TemporaryCStringAsPtr {
5963
}
6064

6165
match first_method_call(expr) {
62-
Some((path, args)) if path.ident.name == sym::as_ptr => {
63-
let unwrap_arg = &args[0];
66+
Some((path, unwrap_arg)) if path.ident.name == sym::as_ptr => {
6467
let as_ptr_span = path.ident.span;
6568
match first_method_call(unwrap_arg) {
66-
Some((path, args))
69+
Some((path, receiver))
6770
if path.ident.name == sym::unwrap || path.ident.name == sym::expect =>
6871
{
69-
let source_arg = &args[0];
70-
lint_cstring_as_ptr(cx, as_ptr_span, source_arg, unwrap_arg);
72+
lint_cstring_as_ptr(cx, as_ptr_span, receiver, unwrap_arg);
7173
}
7274
_ => return,
7375
}

‎compiler/rustc_lint/src/noop_method_call.rs

+1-2
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,7 @@ declare_lint_pass!(NoopMethodCall => [NOOP_METHOD_CALL]);
4141
impl<'tcx> LateLintPass<'tcx> for NoopMethodCall {
4242
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
4343
// We only care about method calls.
44-
let ExprKind::MethodCall(call, elements, _) = &expr.kind else {
44+
let ExprKind::MethodCall(call, receiver, ..) = &expr.kind else {
4545
return
4646
};
4747
// We only care about method calls corresponding to the `Clone`, `Deref` and `Borrow`
@@ -81,7 +81,6 @@ impl<'tcx> LateLintPass<'tcx> for NoopMethodCall {
8181
) {
8282
return;
8383
}
84-
let receiver = &elements[0];
8584
let receiver_ty = cx.typeck_results().expr_ty(receiver);
8685
let expr_ty = cx.typeck_results().expr_ty_adjusted(expr);
8786
if receiver_ty != expr_ty {

‎compiler/rustc_lint/src/types.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -1458,7 +1458,7 @@ impl InvalidAtomicOrdering {
14581458
sym::AtomicI64,
14591459
sym::AtomicI128,
14601460
];
1461-
if let ExprKind::MethodCall(ref method_path, args, _) = &expr.kind
1461+
if let ExprKind::MethodCall(ref method_path, _, args, _) = &expr.kind
14621462
&& recognized_names.contains(&method_path.ident.name)
14631463
&& let Some(m_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
14641464
&& let Some(impl_did) = cx.tcx.impl_of_method(m_def_id)
@@ -1494,8 +1494,8 @@ impl InvalidAtomicOrdering {
14941494
fn check_atomic_load_store(cx: &LateContext<'_>, expr: &Expr<'_>) {
14951495
if let Some((method, args)) = Self::inherent_atomic_method_call(cx, expr, &[sym::load, sym::store])
14961496
&& let Some((ordering_arg, invalid_ordering)) = match method {
1497-
sym::load => Some((&args[1], sym::Release)),
1498-
sym::store => Some((&args[2], sym::Acquire)),
1497+
sym::load => Some((&args[0], sym::Release)),
1498+
sym::store => Some((&args[1], sym::Acquire)),
14991499
_ => None,
15001500
}
15011501
&& let Some(ordering) = Self::match_ordering(cx, ordering_arg)
@@ -1536,8 +1536,8 @@ impl InvalidAtomicOrdering {
15361536
else {return };
15371537

15381538
let fail_order_arg = match method {
1539-
sym::fetch_update => &args[2],
1540-
sym::compare_exchange | sym::compare_exchange_weak => &args[4],
1539+
sym::fetch_update => &args[1],
1540+
sym::compare_exchange | sym::compare_exchange_weak => &args[3],
15411541
_ => return,
15421542
};
15431543

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

+7-3
Original file line numberDiff line numberDiff line change
@@ -261,15 +261,19 @@ impl<'tcx> Cx<'tcx> {
261261

262262
let kind = match expr.kind {
263263
// Here comes the interesting stuff:
264-
hir::ExprKind::MethodCall(segment, ref args, fn_span) => {
264+
hir::ExprKind::MethodCall(segment, receiver, ref args, fn_span) => {
265265
// Rewrite a.b(c) into UFCS form like Trait::b(a, c)
266266
let expr = self.method_callee(expr, segment.ident.span, None);
267267
// When we apply adjustments to the receiver, use the span of
268268
// the overall method call for better diagnostics. args[0]
269269
// is guaranteed to exist, since a method call always has a receiver.
270-
let old_adjustment_span = self.adjustment_span.replace((args[0].hir_id, expr_span));
270+
let old_adjustment_span =
271+
self.adjustment_span.replace((receiver.hir_id, expr_span));
271272
info!("Using method span: {:?}", expr.span);
272-
let args = self.mirror_exprs(args);
273+
let args = std::iter::once(receiver)
274+
.chain(args.iter())
275+
.map(|expr| self.mirror_expr(expr))
276+
.collect();
273277
self.adjustment_span = old_adjustment_span;
274278
ExprKind::Call {
275279
ty: expr.ty,

‎compiler/rustc_passes/src/liveness.rs

+3-2
Original file line numberDiff line numberDiff line change
@@ -1039,9 +1039,10 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
10391039
self.propagate_through_expr(&f, succ)
10401040
}
10411041

1042-
hir::ExprKind::MethodCall(.., ref args, _) => {
1042+
hir::ExprKind::MethodCall(.., receiver, ref args, _) => {
10431043
let succ = self.check_is_ty_uninhabited(expr, succ);
1044-
self.propagate_through_exprs(args, succ)
1044+
let succ = self.propagate_through_exprs(args, succ);
1045+
self.propagate_through_expr(receiver, succ)
10451046
}
10461047

10471048
hir::ExprKind::Tup(ref exprs) => self.propagate_through_exprs(exprs, succ),

‎compiler/rustc_save_analysis/src/dump_visitor.rs

+5-1
Original file line numberDiff line numberDiff line change
@@ -803,6 +803,7 @@ impl<'tcx> DumpVisitor<'tcx> {
803803
&mut self,
804804
ex: &'tcx hir::Expr<'tcx>,
805805
seg: &'tcx hir::PathSegment<'tcx>,
806+
receiver: &'tcx hir::Expr<'tcx>,
806807
args: &'tcx [hir::Expr<'tcx>],
807808
) {
808809
debug!("process_method_call {:?} {:?}", ex, ex.span);
@@ -823,6 +824,7 @@ impl<'tcx> DumpVisitor<'tcx> {
823824
}
824825

825826
// walk receiver and args
827+
self.visit_expr(receiver);
826828
walk_list!(self, visit_expr, args);
827829
}
828830

@@ -1343,7 +1345,9 @@ impl<'tcx> Visitor<'tcx> for DumpVisitor<'tcx> {
13431345
let res = self.save_ctxt.get_path_res(hir_expr.hir_id);
13441346
self.process_struct_lit(ex, path, fields, adt.variant_of_res(res), *rest)
13451347
}
1346-
hir::ExprKind::MethodCall(ref seg, args, _) => self.process_method_call(ex, seg, args),
1348+
hir::ExprKind::MethodCall(ref seg, receiver, args, _) => {
1349+
self.process_method_call(ex, seg, receiver, args)
1350+
}
13471351
hir::ExprKind::Field(ref sub_ex, _) => {
13481352
self.visit_expr(&sub_ex);
13491353

0 commit comments

Comments
 (0)