Skip to content

Commit d0fe5b5

Browse files
nnethercotennethercote
committed
Use BinOpKind instead of BinOp for function args where possible.
Because it's nice to avoid passing in unnecessary data.
1 parent c012eef commit d0fe5b5

File tree

7 files changed

+73
-71
lines changed

7 files changed

+73
-71
lines changed

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

+6-6
Original file line numberDiff line numberDiff line change
@@ -270,22 +270,22 @@ impl<'a> State<'a> {
270270

271271
fn print_expr_binary(
272272
&mut self,
273-
op: ast::BinOp,
273+
op: ast::BinOpKind,
274274
lhs: &ast::Expr,
275275
rhs: &ast::Expr,
276276
fixup: FixupContext,
277277
) {
278-
let binop_prec = op.node.precedence();
278+
let binop_prec = op.precedence();
279279
let left_prec = lhs.precedence();
280280
let right_prec = rhs.precedence();
281281

282-
let (mut left_needs_paren, right_needs_paren) = match op.node.fixity() {
282+
let (mut left_needs_paren, right_needs_paren) = match op.fixity() {
283283
Fixity::Left => (left_prec < binop_prec, right_prec <= binop_prec),
284284
Fixity::Right => (left_prec <= binop_prec, right_prec < binop_prec),
285285
Fixity::None => (left_prec <= binop_prec, right_prec <= binop_prec),
286286
};
287287

288-
match (&lhs.kind, op.node) {
288+
match (&lhs.kind, op) {
289289
// These cases need parens: `x as i32 < y` has the parser thinking that `i32 < y` is
290290
// the beginning of a path type. It starts trying to parse `x as (i32 < y ...` instead
291291
// of `(x as i32) < ...`. We need to convince it _not_ to do that.
@@ -308,7 +308,7 @@ impl<'a> State<'a> {
308308

309309
self.print_expr_cond_paren(lhs, left_needs_paren, fixup.leftmost_subexpression());
310310
self.space();
311-
self.word_space(op.node.as_str());
311+
self.word_space(op.as_str());
312312
self.print_expr_cond_paren(rhs, right_needs_paren, fixup.subsequent_subexpression());
313313
}
314314

@@ -406,7 +406,7 @@ impl<'a> State<'a> {
406406
self.print_expr_method_call(seg, receiver, args, fixup);
407407
}
408408
ast::ExprKind::Binary(op, lhs, rhs) => {
409-
self.print_expr_binary(*op, lhs, rhs, fixup);
409+
self.print_expr_binary(op.node, lhs, rhs, fixup);
410410
}
411411
ast::ExprKind::Unary(op, expr) => {
412412
self.print_expr_unary(*op, expr, fixup);

‎compiler/rustc_hir_pretty/src/lib.rs

+6-6
Original file line numberDiff line numberDiff line change
@@ -1286,18 +1286,18 @@ impl<'a> State<'a> {
12861286
self.print_call_post(base_args)
12871287
}
12881288

1289-
fn print_expr_binary(&mut self, op: hir::BinOp, lhs: &hir::Expr<'_>, rhs: &hir::Expr<'_>) {
1290-
let binop_prec = op.node.precedence();
1289+
fn print_expr_binary(&mut self, op: hir::BinOpKind, lhs: &hir::Expr<'_>, rhs: &hir::Expr<'_>) {
1290+
let binop_prec = op.precedence();
12911291
let left_prec = lhs.precedence();
12921292
let right_prec = rhs.precedence();
12931293

1294-
let (mut left_needs_paren, right_needs_paren) = match op.node.fixity() {
1294+
let (mut left_needs_paren, right_needs_paren) = match op.fixity() {
12951295
Fixity::Left => (left_prec < binop_prec, right_prec <= binop_prec),
12961296
Fixity::Right => (left_prec <= binop_prec, right_prec < binop_prec),
12971297
Fixity::None => (left_prec <= binop_prec, right_prec <= binop_prec),
12981298
};
12991299

1300-
match (&lhs.kind, op.node) {
1300+
match (&lhs.kind, op) {
13011301
// These cases need parens: `x as i32 < y` has the parser thinking that `i32 < y` is
13021302
// the beginning of a path type. It starts trying to parse `x as (i32 < y ...` instead
13031303
// of `(x as i32) < ...`. We need to convince it _not_ to do that.
@@ -1312,7 +1312,7 @@ impl<'a> State<'a> {
13121312

13131313
self.print_expr_cond_paren(lhs, left_needs_paren);
13141314
self.space();
1315-
self.word_space(op.node.as_str());
1315+
self.word_space(op.as_str());
13161316
self.print_expr_cond_paren(rhs, right_needs_paren);
13171317
}
13181318

@@ -1461,7 +1461,7 @@ impl<'a> State<'a> {
14611461
self.print_expr_method_call(segment, receiver, args);
14621462
}
14631463
hir::ExprKind::Binary(op, lhs, rhs) => {
1464-
self.print_expr_binary(op, lhs, rhs);
1464+
self.print_expr_binary(op.node, lhs, rhs);
14651465
}
14661466
hir::ExprKind::Unary(op, expr) => {
14671467
self.print_expr_unary(op, expr);

‎compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -3407,9 +3407,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
34073407
lhs_ty: Ty<'tcx>,
34083408
rhs_expr: &'tcx hir::Expr<'tcx>,
34093409
lhs_expr: &'tcx hir::Expr<'tcx>,
3410-
op: hir::BinOp,
3410+
op: hir::BinOpKind,
34113411
) {
3412-
match op.node {
3412+
match op {
34133413
hir::BinOpKind::Eq => {
34143414
if let Some(partial_eq_def_id) = self.infcx.tcx.lang_items().eq_trait()
34153415
&& self

‎compiler/rustc_hir_typeck/src/op.rs

+29-27
Original file line numberDiff line numberDiff line change
@@ -36,21 +36,23 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
3636
let (lhs_ty, rhs_ty, return_ty) =
3737
self.check_overloaded_binop(expr, lhs, rhs, op, IsAssign::Yes, expected);
3838

39-
let ty =
40-
if !lhs_ty.is_ty_var() && !rhs_ty.is_ty_var() && is_builtin_binop(lhs_ty, rhs_ty, op) {
41-
self.enforce_builtin_binop_types(lhs.span, lhs_ty, rhs.span, rhs_ty, op);
42-
self.tcx.types.unit
43-
} else {
44-
return_ty
45-
};
39+
let ty = if !lhs_ty.is_ty_var()
40+
&& !rhs_ty.is_ty_var()
41+
&& is_builtin_binop(lhs_ty, rhs_ty, op.node)
42+
{
43+
self.enforce_builtin_binop_types(lhs.span, lhs_ty, rhs.span, rhs_ty, op.node);
44+
self.tcx.types.unit
45+
} else {
46+
return_ty
47+
};
4648

4749
self.check_lhs_assignable(lhs, E0067, op.span, |err| {
4850
if let Some(lhs_deref_ty) = self.deref_once_mutably_for_diagnostic(lhs_ty) {
4951
if self
5052
.lookup_op_method(
5153
(lhs, lhs_deref_ty),
5254
Some((rhs, rhs_ty)),
53-
lang_item_for_binop(self.tcx, op, IsAssign::Yes),
55+
lang_item_for_binop(self.tcx, op.node, IsAssign::Yes),
5456
op.span,
5557
expected,
5658
)
@@ -62,7 +64,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
6264
.lookup_op_method(
6365
(lhs, lhs_ty),
6466
Some((rhs, rhs_ty)),
65-
lang_item_for_binop(self.tcx, op, IsAssign::Yes),
67+
lang_item_for_binop(self.tcx, op.node, IsAssign::Yes),
6668
op.span,
6769
expected,
6870
)
@@ -101,7 +103,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
101103
expr.hir_id, expr, op, lhs_expr, rhs_expr
102104
);
103105

104-
match BinOpCategory::from(op) {
106+
match BinOpCategory::from(op.node) {
105107
BinOpCategory::Shortcircuit => {
106108
// && and || are a simple case.
107109
self.check_expr_coercible_to_type(lhs_expr, tcx.types.bool, None);
@@ -140,14 +142,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
140142
// can't pin this down to a specific impl.
141143
if !lhs_ty.is_ty_var()
142144
&& !rhs_ty.is_ty_var()
143-
&& is_builtin_binop(lhs_ty, rhs_ty, op)
145+
&& is_builtin_binop(lhs_ty, rhs_ty, op.node)
144146
{
145147
let builtin_return_ty = self.enforce_builtin_binop_types(
146148
lhs_expr.span,
147149
lhs_ty,
148150
rhs_expr.span,
149151
rhs_ty,
150-
op,
152+
op.node,
151153
);
152154
self.demand_eqtype(expr.span, builtin_return_ty, return_ty);
153155
builtin_return_ty
@@ -164,7 +166,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
164166
lhs_ty: Ty<'tcx>,
165167
rhs_span: Span,
166168
rhs_ty: Ty<'tcx>,
167-
op: hir::BinOp,
169+
op: hir::BinOpKind,
168170
) -> Ty<'tcx> {
169171
debug_assert!(is_builtin_binop(lhs_ty, rhs_ty, op));
170172

@@ -245,7 +247,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
245247
let result = self.lookup_op_method(
246248
(lhs_expr, lhs_ty),
247249
Some((rhs_expr, rhs_ty_var)),
248-
lang_item_for_binop(self.tcx, op, is_assign),
250+
lang_item_for_binop(self.tcx, op.node, is_assign),
249251
op.span,
250252
expected,
251253
);
@@ -256,7 +258,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
256258
rhs_ty_var,
257259
Some(lhs_expr),
258260
|err, ty| {
259-
self.suggest_swapping_lhs_and_rhs(err, ty, lhs_ty, rhs_expr, lhs_expr, op);
261+
self.suggest_swapping_lhs_and_rhs(err, ty, lhs_ty, rhs_expr, lhs_expr, op.node);
260262
},
261263
);
262264
let rhs_ty = self.resolve_vars_with_obligations(rhs_ty);
@@ -305,7 +307,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
305307
Ty::new_misc_error(self.tcx)
306308
}
307309
Err(errors) => {
308-
let (_, trait_def_id) = lang_item_for_binop(self.tcx, op, is_assign);
310+
let (_, trait_def_id) = lang_item_for_binop(self.tcx, op.node, is_assign);
309311
let missing_trait = trait_def_id
310312
.map(|def_id| with_no_trimmed_paths!(self.tcx.def_path_str(def_id)));
311313
let (mut err, output_def_id) = match is_assign {
@@ -407,7 +409,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
407409
.lookup_op_method(
408410
(lhs_expr, lhs_deref_ty),
409411
Some((rhs_expr, rhs_ty)),
410-
lang_item_for_binop(self.tcx, op, is_assign),
412+
lang_item_for_binop(self.tcx, op.node, is_assign),
411413
op.span,
412414
expected,
413415
)
@@ -441,7 +443,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
441443
.lookup_op_method(
442444
(lhs_expr, lhs_adjusted_ty),
443445
Some((rhs_expr, rhs_adjusted_ty)),
444-
lang_item_for_binop(self.tcx, op, is_assign),
446+
lang_item_for_binop(self.tcx, op.node, is_assign),
445447
op.span,
446448
expected,
447449
)
@@ -497,7 +499,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
497499
self.lookup_op_method(
498500
(lhs_expr, lhs_ty),
499501
Some((rhs_expr, rhs_ty)),
500-
lang_item_for_binop(self.tcx, op, is_assign),
502+
lang_item_for_binop(self.tcx, op.node, is_assign),
501503
op.span,
502504
expected,
503505
)
@@ -591,7 +593,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
591593
.lookup_op_method(
592594
(lhs_expr, lhs_ty),
593595
Some((rhs_expr, rhs_ty)),
594-
lang_item_for_binop(self.tcx, op, is_assign),
596+
lang_item_for_binop(self.tcx, op.node, is_assign),
595597
op.span,
596598
expected,
597599
)
@@ -971,12 +973,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
971973

972974
fn lang_item_for_binop(
973975
tcx: TyCtxt<'_>,
974-
op: hir::BinOp,
976+
op: hir::BinOpKind,
975977
is_assign: IsAssign,
976978
) -> (Symbol, Option<hir::def_id::DefId>) {
977979
let lang = tcx.lang_items();
978980
if is_assign == IsAssign::Yes {
979-
match op.node {
981+
match op {
980982
hir::BinOpKind::Add => (sym::add_assign, lang.add_assign_trait()),
981983
hir::BinOpKind::Sub => (sym::sub_assign, lang.sub_assign_trait()),
982984
hir::BinOpKind::Mul => (sym::mul_assign, lang.mul_assign_trait()),
@@ -995,11 +997,11 @@ fn lang_item_for_binop(
995997
| hir::BinOpKind::Ne
996998
| hir::BinOpKind::And
997999
| hir::BinOpKind::Or => {
998-
bug!("impossible assignment operation: {}=", op.node.as_str())
1000+
bug!("impossible assignment operation: {}=", op.as_str())
9991001
}
10001002
}
10011003
} else {
1002-
match op.node {
1004+
match op {
10031005
hir::BinOpKind::Add => (sym::add, lang.add_trait()),
10041006
hir::BinOpKind::Sub => (sym::sub, lang.sub_trait()),
10051007
hir::BinOpKind::Mul => (sym::mul, lang.mul_trait()),
@@ -1056,8 +1058,8 @@ enum BinOpCategory {
10561058
}
10571059

10581060
impl BinOpCategory {
1059-
fn from(op: hir::BinOp) -> BinOpCategory {
1060-
match op.node {
1061+
fn from(op: hir::BinOpKind) -> BinOpCategory {
1062+
match op {
10611063
hir::BinOpKind::Shl | hir::BinOpKind::Shr => BinOpCategory::Shift,
10621064

10631065
hir::BinOpKind::Add
@@ -1113,7 +1115,7 @@ fn deref_ty_if_possible(ty: Ty<'_>) -> Ty<'_> {
11131115
/// Reason #2 is the killer. I tried for a while to always use
11141116
/// overloaded logic and just check the types in constants/codegen after
11151117
/// the fact, and it worked fine, except for SIMD types. -nmatsakis
1116-
fn is_builtin_binop<'tcx>(lhs: Ty<'tcx>, rhs: Ty<'tcx>, op: hir::BinOp) -> bool {
1118+
fn is_builtin_binop<'tcx>(lhs: Ty<'tcx>, rhs: Ty<'tcx>, op: hir::BinOpKind) -> bool {
11171119
// Special-case a single layer of referencing, so that things like `5.0 + &6.0f32` work.
11181120
// (See https://github.com/rust-lang/rust/issues/57447.)
11191121
let (lhs, rhs) = (deref_ty_if_possible(lhs), deref_ty_if_possible(rhs));

‎compiler/rustc_lint/src/types.rs

+17-17
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@ use rustc_middle::ty::{
1212
};
1313
use rustc_session::{declare_lint, declare_lint_pass, impl_lint_pass};
1414
use rustc_span::def_id::LocalDefId;
15-
use rustc_span::{Span, Symbol, source_map, sym};
15+
use rustc_span::{Span, Symbol, sym};
1616
use tracing::debug;
1717
use {rustc_ast as ast, rustc_hir as hir};
1818

@@ -221,7 +221,7 @@ impl TypeLimits {
221221
fn lint_nan<'tcx>(
222222
cx: &LateContext<'tcx>,
223223
e: &'tcx hir::Expr<'tcx>,
224-
binop: hir::BinOp,
224+
binop: hir::BinOpKind,
225225
l: &'tcx hir::Expr<'tcx>,
226226
r: &'tcx hir::Expr<'tcx>,
227227
) {
@@ -260,19 +260,19 @@ fn lint_nan<'tcx>(
260260
InvalidNanComparisons::EqNe { suggestion }
261261
}
262262

263-
let lint = match binop.node {
263+
let lint = match binop {
264264
hir::BinOpKind::Eq | hir::BinOpKind::Ne if is_nan(cx, l) => {
265265
eq_ne(e, l, r, |l_span, r_span| InvalidNanComparisonsSuggestion::Spanful {
266266
nan_plus_binop: l_span.until(r_span),
267267
float: r_span.shrink_to_hi(),
268-
neg: (binop.node == hir::BinOpKind::Ne).then(|| r_span.shrink_to_lo()),
268+
neg: (binop == hir::BinOpKind::Ne).then(|| r_span.shrink_to_lo()),
269269
})
270270
}
271271
hir::BinOpKind::Eq | hir::BinOpKind::Ne if is_nan(cx, r) => {
272272
eq_ne(e, l, r, |l_span, r_span| InvalidNanComparisonsSuggestion::Spanful {
273273
nan_plus_binop: l_span.shrink_to_hi().to(r_span),
274274
float: l_span.shrink_to_hi(),
275-
neg: (binop.node == hir::BinOpKind::Ne).then(|| l_span.shrink_to_lo()),
275+
neg: (binop == hir::BinOpKind::Ne).then(|| l_span.shrink_to_lo()),
276276
})
277277
}
278278
hir::BinOpKind::Lt | hir::BinOpKind::Le | hir::BinOpKind::Gt | hir::BinOpKind::Ge
@@ -526,11 +526,11 @@ impl<'tcx> LateLintPass<'tcx> for TypeLimits {
526526
}
527527
}
528528
hir::ExprKind::Binary(binop, ref l, ref r) => {
529-
if is_comparison(binop) {
530-
if !check_limits(cx, binop, l, r) {
529+
if is_comparison(binop.node) {
530+
if !check_limits(cx, binop.node, l, r) {
531531
cx.emit_span_lint(UNUSED_COMPARISONS, e.span, UnusedComparisons);
532532
} else {
533-
lint_nan(cx, e, binop, l, r);
533+
lint_nan(cx, e, binop.node, l, r);
534534
let cmpop = ComparisonOp::BinOp(binop.node);
535535
lint_wide_pointer(cx, e, cmpop, l, r);
536536
lint_fn_pointer(cx, e, cmpop, l, r);
@@ -558,8 +558,8 @@ impl<'tcx> LateLintPass<'tcx> for TypeLimits {
558558
_ => {}
559559
};
560560

561-
fn is_valid<T: PartialOrd>(binop: hir::BinOp, v: T, min: T, max: T) -> bool {
562-
match binop.node {
561+
fn is_valid<T: PartialOrd>(binop: hir::BinOpKind, v: T, min: T, max: T) -> bool {
562+
match binop {
563563
hir::BinOpKind::Lt => v > min && v <= max,
564564
hir::BinOpKind::Le => v >= min && v < max,
565565
hir::BinOpKind::Gt => v >= min && v < max,
@@ -569,19 +569,19 @@ impl<'tcx> LateLintPass<'tcx> for TypeLimits {
569569
}
570570
}
571571

572-
fn rev_binop(binop: hir::BinOp) -> hir::BinOp {
573-
source_map::respan(binop.span, match binop.node {
572+
fn rev_binop(binop: hir::BinOpKind) -> hir::BinOpKind {
573+
match binop {
574574
hir::BinOpKind::Lt => hir::BinOpKind::Gt,
575575
hir::BinOpKind::Le => hir::BinOpKind::Ge,
576576
hir::BinOpKind::Gt => hir::BinOpKind::Lt,
577577
hir::BinOpKind::Ge => hir::BinOpKind::Le,
578-
_ => return binop,
579-
})
578+
_ => binop,
579+
}
580580
}
581581

582582
fn check_limits(
583583
cx: &LateContext<'_>,
584-
binop: hir::BinOp,
584+
binop: hir::BinOpKind,
585585
l: &hir::Expr<'_>,
586586
r: &hir::Expr<'_>,
587587
) -> bool {
@@ -623,9 +623,9 @@ impl<'tcx> LateLintPass<'tcx> for TypeLimits {
623623
}
624624
}
625625

626-
fn is_comparison(binop: hir::BinOp) -> bool {
626+
fn is_comparison(binop: hir::BinOpKind) -> bool {
627627
matches!(
628-
binop.node,
628+
binop,
629629
hir::BinOpKind::Eq
630630
| hir::BinOpKind::Lt
631631
| hir::BinOpKind::Le

0 commit comments

Comments
 (0)