Skip to content

Commit 1c43cab

Browse files
Dylan-DPCDylan-DPC
authored
Rollup merge of #100232 - cjgillot:no-desugar-methodcall, r=nagisa
Do not consider method call receiver as an argument in AST. Fixes #73663
2 parents 32bd147 + 69205db commit 1c43cab

File tree

20 files changed

+109
-57
lines changed

20 files changed

+109
-57
lines changed

‎compiler/rustc_ast/src/ast.rs

+5-6
Original file line numberDiff line numberDiff line change
@@ -1338,14 +1338,13 @@ pub enum ExprKind {
13381338
///
13391339
/// The `PathSegment` represents the method name and its generic arguments
13401340
/// (within the angle brackets).
1341-
/// The first element of the vector of an `Expr` is the expression that evaluates
1342-
/// to the object on which the method is being called on (the receiver),
1343-
/// and the remaining elements are the rest of the arguments.
1344-
/// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as
1345-
/// `ExprKind::MethodCall(PathSegment { foo, [Bar, Baz] }, [x, a, b, c, d])`.
1341+
/// The standalone `Expr` is the receiver expression.
1342+
/// The vector of `Expr` is the arguments.
1343+
/// `x.foo::<Bar, Baz>(a, b, c, d)` is represented as
1344+
/// `ExprKind::MethodCall(PathSegment { foo, [Bar, Baz] }, x, [a, b, c, d])`.
13461345
/// This `Span` is the span of the function, without the dot and receiver
13471346
/// (e.g. `foo(a, b)` in `x.foo(a, b)`
1348-
MethodCall(PathSegment, Vec<P<Expr>>, Span),
1347+
MethodCall(PathSegment, P<Expr>, Vec<P<Expr>>, Span),
13491348
/// A tuple (e.g., `(a, b, c, d)`).
13501349
Tup(Vec<P<Expr>>),
13511350
/// A binary operation (e.g., `a + b`, `a * b`).

‎compiler/rustc_ast/src/mut_visit.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -1302,10 +1302,11 @@ pub fn noop_visit_expr<T: MutVisitor>(
13021302
vis.visit_expr(f);
13031303
visit_exprs(args, vis);
13041304
}
1305-
ExprKind::MethodCall(PathSegment { ident, id, args }, exprs, span) => {
1305+
ExprKind::MethodCall(PathSegment { ident, id, args }, receiver, exprs, span) => {
13061306
vis.visit_ident(ident);
13071307
vis.visit_id(id);
13081308
visit_opt(args, |args| vis.visit_generic_args(args));
1309+
vis.visit_expr(receiver);
13091310
visit_exprs(exprs, vis);
13101311
vis.visit_span(span);
13111312
}

‎compiler/rustc_ast/src/util/parser.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -396,9 +396,9 @@ pub fn contains_exterior_struct_lit(value: &ast::Expr) -> bool {
396396
contains_exterior_struct_lit(&x)
397397
}
398398

399-
ast::ExprKind::MethodCall(.., ref exprs, _) => {
399+
ast::ExprKind::MethodCall(_, ref receiver, _, _) => {
400400
// X { y: 1 }.bar(...)
401-
contains_exterior_struct_lit(&exprs[0])
401+
contains_exterior_struct_lit(&receiver)
402402
}
403403

404404
_ => false,

‎compiler/rustc_ast/src/visit.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -813,8 +813,9 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) {
813813
visitor.visit_expr(callee_expression);
814814
walk_list!(visitor, visit_expr, arguments);
815815
}
816-
ExprKind::MethodCall(ref segment, ref arguments, _span) => {
816+
ExprKind::MethodCall(ref segment, ref receiver, ref arguments, _span) => {
817817
visitor.visit_path_segment(expression.span, segment);
818+
visitor.visit_expr(receiver);
818819
walk_list!(visitor, visit_expr, arguments);
819820
}
820821
ExprKind::Binary(_, ref left_expression, ref right_expression) => {

‎compiler/rustc_ast_lowering/src/expr.rs

+4-2
Original file line numberDiff line numberDiff line change
@@ -62,15 +62,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
6262
hir::ExprKind::Call(f, self.lower_exprs(args))
6363
}
6464
}
65-
ExprKind::MethodCall(ref seg, ref args, span) => {
65+
ExprKind::MethodCall(ref seg, ref receiver, ref args, span) => {
6666
let hir_seg = self.arena.alloc(self.lower_path_segment(
6767
e.span,
6868
seg,
6969
ParamMode::Optional,
7070
ParenthesizedGenericArgs::Err,
7171
ImplTraitContext::Disallowed(ImplTraitPosition::Path),
7272
));
73-
let args = self.lower_exprs(args);
73+
let args = self.arena.alloc_from_iter(
74+
[&*receiver].into_iter().chain(args.iter()).map(|x| self.lower_expr_mut(x)),
75+
);
7476
hir::ExprKind::MethodCall(hir_seg, args, self.lower_span(span))
7577
}
7678
ExprKind::Binary(binop, ref lhs, ref rhs) => {

‎compiler/rustc_ast_pretty/src/pprust/state/expr.rs

+9-5
Original file line numberDiff line numberDiff line change
@@ -193,9 +193,13 @@ impl<'a> State<'a> {
193193
self.print_call_post(args)
194194
}
195195

196-
fn print_expr_method_call(&mut self, segment: &ast::PathSegment, args: &[P<ast::Expr>]) {
197-
let base_args = &args[1..];
198-
self.print_expr_maybe_paren(&args[0], parser::PREC_POSTFIX);
196+
fn print_expr_method_call(
197+
&mut self,
198+
segment: &ast::PathSegment,
199+
receiver: &ast::Expr,
200+
base_args: &[P<ast::Expr>],
201+
) {
202+
self.print_expr_maybe_paren(receiver, parser::PREC_POSTFIX);
199203
self.word(".");
200204
self.print_ident(segment.ident);
201205
if let Some(ref args) = segment.args {
@@ -303,8 +307,8 @@ impl<'a> State<'a> {
303307
ast::ExprKind::Call(ref func, ref args) => {
304308
self.print_expr_call(func, &args);
305309
}
306-
ast::ExprKind::MethodCall(ref segment, ref args, _) => {
307-
self.print_expr_method_call(segment, &args);
310+
ast::ExprKind::MethodCall(ref segment, ref receiver, ref args, _) => {
311+
self.print_expr_method_call(segment, &receiver, &args);
308312
}
309313
ast::ExprKind::Binary(op, ref lhs, ref rhs) => {
310314
self.print_expr_binary(op, lhs, rhs);

‎compiler/rustc_builtin_macros/src/assert/context.rs

+10-11
Original file line numberDiff line numberDiff line change
@@ -240,8 +240,8 @@ impl<'cx, 'a> Context<'cx, 'a> {
240240
self.manage_cond_expr(prefix);
241241
self.manage_cond_expr(suffix);
242242
}
243-
ExprKind::MethodCall(_, ref mut local_exprs, _) => {
244-
for local_expr in local_exprs.iter_mut().skip(1) {
243+
ExprKind::MethodCall(_, _,ref mut local_exprs, _) => {
244+
for local_expr in local_exprs.iter_mut() {
245245
self.manage_cond_expr(local_expr);
246246
}
247247
}
@@ -377,14 +377,12 @@ impl<'cx, 'a> Context<'cx, 'a> {
377377
id: DUMMY_NODE_ID,
378378
ident: Ident::new(sym::try_capture, self.span),
379379
},
380-
vec![
381-
expr_paren(self.cx, self.span, self.cx.expr_addr_of(self.span, wrapper)),
382-
expr_addr_of_mut(
383-
self.cx,
384-
self.span,
385-
self.cx.expr_path(Path::from_ident(capture)),
386-
),
387-
],
380+
expr_paren(self.cx, self.span, self.cx.expr_addr_of(self.span, wrapper)),
381+
vec![expr_addr_of_mut(
382+
self.cx,
383+
self.span,
384+
self.cx.expr_path(Path::from_ident(capture)),
385+
)],
388386
self.span,
389387
))
390388
.add_trailing_semicolon();
@@ -442,10 +440,11 @@ fn expr_addr_of_mut(cx: &ExtCtxt<'_>, sp: Span, e: P<Expr>) -> P<Expr> {
442440
fn expr_method_call(
443441
cx: &ExtCtxt<'_>,
444442
path: PathSegment,
443+
receiver: P<Expr>,
445444
args: Vec<P<Expr>>,
446445
span: Span,
447446
) -> P<Expr> {
448-
cx.expr(span, ExprKind::MethodCall(path, args, span))
447+
cx.expr(span, ExprKind::MethodCall(path, receiver, args, span))
449448
}
450449

451450
fn expr_paren(cx: &ExtCtxt<'_>, sp: Span, e: P<Expr>) -> P<Expr> {

‎compiler/rustc_lint/src/unused.rs

+1-2
Original file line numberDiff line numberDiff line change
@@ -608,8 +608,7 @@ trait UnusedDelimLint {
608608
ref call_or_other => {
609609
let (args_to_check, ctx) = match *call_or_other {
610610
Call(_, ref args) => (&args[..], UnusedDelimsCtx::FunctionArg),
611-
// first "argument" is self (which sometimes needs delims)
612-
MethodCall(_, ref args, _) => (&args[1..], UnusedDelimsCtx::MethodArg),
611+
MethodCall(_, _, ref args, _) => (&args[..], UnusedDelimsCtx::MethodArg),
613612
// actual catch-all arm
614613
_ => {
615614
return;

‎compiler/rustc_parse/src/parser/expr.rs

+7-5
Original file line numberDiff line numberDiff line change
@@ -850,7 +850,7 @@ impl<'a> Parser<'a> {
850850
ExprKind::Index(_, _) => "indexing",
851851
ExprKind::Try(_) => "`?`",
852852
ExprKind::Field(_, _) => "a field access",
853-
ExprKind::MethodCall(_, _, _) => "a method call",
853+
ExprKind::MethodCall(_, _, _, _) => "a method call",
854854
ExprKind::Call(_, _) => "a function call",
855855
ExprKind::Await(_) => "`.await`",
856856
ExprKind::Err => return Ok(with_postfix),
@@ -1280,12 +1280,14 @@ impl<'a> Parser<'a> {
12801280

12811281
if self.check(&token::OpenDelim(Delimiter::Parenthesis)) {
12821282
// Method call `expr.f()`
1283-
let mut args = self.parse_paren_expr_seq()?;
1284-
args.insert(0, self_arg);
1285-
1283+
let args = self.parse_paren_expr_seq()?;
12861284
let fn_span = fn_span_lo.to(self.prev_token.span);
12871285
let span = lo.to(self.prev_token.span);
1288-
Ok(self.mk_expr(span, ExprKind::MethodCall(segment, args, fn_span), AttrVec::new()))
1286+
Ok(self.mk_expr(
1287+
span,
1288+
ExprKind::MethodCall(segment, self_arg, args, fn_span),
1289+
AttrVec::new(),
1290+
))
12891291
} else {
12901292
// Field access `expr.f`
12911293
if let Some(args) = segment.args {

‎compiler/rustc_resolve/src/late.rs

+2-3
Original file line numberDiff line numberDiff line change
@@ -3796,9 +3796,8 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
37963796
ExprKind::Field(ref subexpression, _) => {
37973797
self.resolve_expr(subexpression, Some(expr));
37983798
}
3799-
ExprKind::MethodCall(ref segment, ref arguments, _) => {
3800-
let mut arguments = arguments.iter();
3801-
self.resolve_expr(arguments.next().unwrap(), Some(expr));
3799+
ExprKind::MethodCall(ref segment, ref receiver, ref arguments, _) => {
3800+
self.resolve_expr(receiver, Some(expr));
38023801
for argument in arguments {
38033802
self.resolve_expr(argument, None);
38043803
}

‎src/test/ui-fulldeps/pprust-expr-roundtrip.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -74,10 +74,10 @@ fn iter_exprs(depth: usize, f: &mut dyn FnMut(P<Expr>)) {
7474
2 => {
7575
let seg = PathSegment::from_ident(Ident::from_str("x"));
7676
iter_exprs(depth - 1, &mut |e| {
77-
g(ExprKind::MethodCall(seg.clone(), vec![e, make_x()], DUMMY_SP))
77+
g(ExprKind::MethodCall(seg.clone(), e, vec![make_x()], DUMMY_SP))
7878
});
7979
iter_exprs(depth - 1, &mut |e| {
80-
g(ExprKind::MethodCall(seg.clone(), vec![make_x(), e], DUMMY_SP))
80+
g(ExprKind::MethodCall(seg.clone(), make_x(), vec![e], DUMMY_SP))
8181
});
8282
}
8383
3..=8 => {

‎src/test/ui/cfg/cfg-method-receiver.rs

+12
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
macro_rules! cbor_map {
2+
($key:expr) => {
3+
$key.signum();
4+
//~^ ERROR can't call method `signum` on ambiguous numeric type `{integer}` [E0689]
5+
};
6+
}
7+
8+
fn main() {
9+
cbor_map! { #[cfg(test)] 4};
10+
//~^ ERROR attributes on expressions are experimental
11+
//~| ERROR removing an expression is not supported in this position
12+
}

‎src/test/ui/cfg/cfg-method-receiver.stderr

+34
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
error[E0658]: attributes on expressions are experimental
2+
--> $DIR/cfg-method-receiver.rs:9:17
3+
|
4+
LL | cbor_map! { #[cfg(test)] 4};
5+
| ^^^^^^^^^^^^
6+
|
7+
= note: see issue #15701 <https://github.com/rust-lang/rust/issues/15701> for more information
8+
= help: add `#![feature(stmt_expr_attributes)]` to the crate attributes to enable
9+
10+
error: removing an expression is not supported in this position
11+
--> $DIR/cfg-method-receiver.rs:9:17
12+
|
13+
LL | cbor_map! { #[cfg(test)] 4};
14+
| ^^^^^^^^^^^^
15+
16+
error[E0689]: can't call method `signum` on ambiguous numeric type `{integer}`
17+
--> $DIR/cfg-method-receiver.rs:3:14
18+
|
19+
LL | $key.signum();
20+
| ^^^^^^
21+
...
22+
LL | cbor_map! { #[cfg(test)] 4};
23+
| --------------------------- in this macro invocation
24+
|
25+
= note: this error originates in the macro `cbor_map` (in Nightly builds, run with -Z macro-backtrace for more info)
26+
help: you must specify a concrete type for this numeric value, like `i32`
27+
|
28+
LL | cbor_map! { #[cfg(test)] 4_i32};
29+
| ~~~~~
30+
31+
error: aborting due to 3 previous errors
32+
33+
Some errors have detailed explanations: E0658, E0689.
34+
For more information about an error, try `rustc --explain E0658`.

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

+2-3
Original file line numberDiff line numberDiff line change
@@ -61,9 +61,8 @@ impl EarlyLintPass for DoubleParens {
6161
}
6262
}
6363
},
64-
ExprKind::MethodCall(_, ref params, _) => {
65-
if params.len() == 2 {
66-
let param = &params[1];
64+
ExprKind::MethodCall(_, _, ref params, _) => {
65+
if let [ref param] = params[..] {
6766
if let ExprKind::Paren(_) = param.kind {
6867
span_lint(cx, DOUBLE_PARENS, param.span, msg);
6968
}

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

+2-2
Original file line numberDiff line numberDiff line change
@@ -37,9 +37,9 @@ declare_lint_pass!(OptionEnvUnwrap => [OPTION_ENV_UNWRAP]);
3737
impl EarlyLintPass for OptionEnvUnwrap {
3838
fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
3939
if_chain! {
40-
if let ExprKind::MethodCall(path_segment, args, _) = &expr.kind;
40+
if let ExprKind::MethodCall(path_segment, receiver, _, _) = &expr.kind;
4141
if matches!(path_segment.ident.name, sym::expect | sym::unwrap);
42-
if let ExprKind::Call(caller, _) = &args[0].kind;
42+
if let ExprKind::Call(caller, _) = &receiver.kind;
4343
if is_direct_expn_of(caller.span, "option_env").is_some();
4444
then {
4545
span_lint_and_help(

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

+2-2
Original file line numberDiff line numberDiff line change
@@ -109,12 +109,12 @@ impl EarlyLintPass for Precedence {
109109
let mut arg = operand;
110110

111111
let mut all_odd = true;
112-
while let ExprKind::MethodCall(path_segment, args, _) = &arg.kind {
112+
while let ExprKind::MethodCall(path_segment, receiver, _, _) = &arg.kind {
113113
let path_segment_str = path_segment.ident.name.as_str();
114114
all_odd &= ALLOWED_ODD_FUNCTIONS
115115
.iter()
116116
.any(|odd_function| **odd_function == *path_segment_str);
117-
arg = args.first().expect("A method always has a receiver.");
117+
arg = receiver;
118118
}
119119

120120
if_chain! {

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

+1-1
Original file line numberDiff line numberDiff line change
@@ -595,7 +595,7 @@ fn ident_difference_expr_with_base_location(
595595
| (Unary(_, _), Unary(_, _))
596596
| (Binary(_, _, _), Binary(_, _, _))
597597
| (Tup(_), Tup(_))
598-
| (MethodCall(_, _, _), MethodCall(_, _, _))
598+
| (MethodCall(_, _, _, _), MethodCall(_, _, _, _))
599599
| (Call(_, _), Call(_, _))
600600
| (ConstBlock(_), ConstBlock(_))
601601
| (Array(_), Array(_))

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

+2-3
Original file line numberDiff line numberDiff line change
@@ -30,11 +30,10 @@ declare_clippy_lint! {
3030
declare_lint_pass!(UnusedRounding => [UNUSED_ROUNDING]);
3131

3232
fn is_useless_rounding(expr: &Expr) -> Option<(&str, String)> {
33-
if let ExprKind::MethodCall(name_ident, args, _) = &expr.kind
33+
if let ExprKind::MethodCall(name_ident, receiver, _, _) = &expr.kind
3434
&& let method_name = name_ident.ident.name.as_str()
3535
&& (method_name == "ceil" || method_name == "round" || method_name == "floor")
36-
&& !args.is_empty()
37-
&& let ExprKind::Lit(spanned) = &args[0].kind
36+
&& let ExprKind::Lit(spanned) = &receiver.kind
3837
&& let LitKind::Float(symbol, ty) = spanned.kind {
3938
let f = symbol.as_str().parse::<f64>().unwrap();
4039
let f_str = symbol.to_string() + if let LitFloatType::Suffixed(ty) = ty {

‎src/tools/clippy/clippy_utils/src/ast_utils.rs

+3-1
Original file line numberDiff line numberDiff line change
@@ -147,7 +147,9 @@ pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
147147
(Array(l), Array(r)) | (Tup(l), Tup(r)) => over(l, r, |l, r| eq_expr(l, r)),
148148
(Repeat(le, ls), Repeat(re, rs)) => eq_expr(le, re) && eq_expr(&ls.value, &rs.value),
149149
(Call(lc, la), Call(rc, ra)) => eq_expr(lc, rc) && over(la, ra, |l, r| eq_expr(l, r)),
150-
(MethodCall(lc, la, _), MethodCall(rc, ra, _)) => eq_path_seg(lc, rc) && over(la, ra, |l, r| eq_expr(l, r)),
150+
(MethodCall(lc, ls, la, _), MethodCall(rc, rs, ra, _)) => {
151+
eq_path_seg(lc, rc) && eq_expr(ls, rs) && over(la, ra, |l, r| eq_expr(l, r))
152+
},
151153
(Binary(lo, ll, lr), Binary(ro, rl, rr)) => lo.node == ro.node && eq_expr(ll, rl) && eq_expr(lr, rr),
152154
(Unary(lo, l), Unary(ro, r)) => mem::discriminant(lo) == mem::discriminant(ro) && eq_expr(l, r),
153155
(Lit(l), Lit(r)) => l.kind == r.kind,

‎src/tools/rustfmt/src/chains.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -145,7 +145,7 @@ impl ChainItemKind {
145145

146146
fn from_ast(context: &RewriteContext<'_>, expr: &ast::Expr) -> (ChainItemKind, Span) {
147147
let (kind, span) = match expr.kind {
148-
ast::ExprKind::MethodCall(ref segment, ref expressions, _) => {
148+
ast::ExprKind::MethodCall(ref segment, ref receiver, ref expressions, _) => {
149149
let types = if let Some(ref generic_args) = segment.args {
150150
if let ast::GenericArgs::AngleBracketed(ref data) = **generic_args {
151151
data.args
@@ -163,7 +163,7 @@ impl ChainItemKind {
163163
} else {
164164
vec![]
165165
};
166-
let span = mk_sp(expressions[0].span.hi(), expr.span.hi());
166+
let span = mk_sp(receiver.span.hi(), expr.span.hi());
167167
let kind = ChainItemKind::MethodCall(segment.clone(), types, expressions.clone());
168168
(kind, span)
169169
}
@@ -253,7 +253,7 @@ impl ChainItem {
253253
format!("::<{}>", type_list.join(", "))
254254
};
255255
let callee_str = format!(".{}{}", rewrite_ident(context, method_name), type_str);
256-
rewrite_call(context, &callee_str, &args[1..], span, shape)
256+
rewrite_call(context, &callee_str, &args, span, shape)
257257
}
258258
}
259259

@@ -400,8 +400,8 @@ impl Chain {
400400
// is a try! macro, we'll convert it to shorthand when the option is set.
401401
fn pop_expr_chain(expr: &ast::Expr, context: &RewriteContext<'_>) -> Option<ast::Expr> {
402402
match expr.kind {
403-
ast::ExprKind::MethodCall(_, ref expressions, _) => {
404-
Some(Self::convert_try(&expressions[0], context))
403+
ast::ExprKind::MethodCall(_, ref receiver, _, _) => {
404+
Some(Self::convert_try(&receiver, context))
405405
}
406406
ast::ExprKind::Field(ref subexpr, _)
407407
| ast::ExprKind::Try(ref subexpr)

0 commit comments

Comments
 (0)