Skip to content

Commit 5f66b0d

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 5d0930c commit 5f66b0d

File tree

7 files changed

+77
-78
lines changed

7 files changed

+77
-78
lines changed

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

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

275275
fn print_expr_binary(
276276
&mut self,
277-
op: ast::BinOp,
277+
op: ast::BinOpKind,
278278
lhs: &ast::Expr,
279279
rhs: &ast::Expr,
280280
fixup: FixupContext,
281281
) {
282-
let binop_prec = op.node.precedence();
282+
let binop_prec = op.precedence();
283283
let left_prec = lhs.precedence();
284284
let right_prec = rhs.precedence();
285285

286-
let (mut left_needs_paren, right_needs_paren) = match op.node.fixity() {
286+
let (mut left_needs_paren, right_needs_paren) = match op.fixity() {
287287
Fixity::Left => (left_prec < binop_prec, right_prec <= binop_prec),
288288
Fixity::Right => (left_prec <= binop_prec, right_prec < binop_prec),
289289
Fixity::None => (left_prec <= binop_prec, right_prec <= binop_prec),
290290
};
291291

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

313313
self.print_expr_cond_paren(lhs, left_needs_paren, fixup.leftmost_subexpression());
314314
self.space();
315-
self.word_space(op.node.as_str());
315+
self.word_space(op.as_str());
316316
self.print_expr_cond_paren(rhs, right_needs_paren, fixup.subsequent_subexpression());
317317
}
318318

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

‎compiler/rustc_hir_pretty/src/lib.rs

+6-6
Original file line numberDiff line numberDiff line change
@@ -1295,18 +1295,18 @@ impl<'a> State<'a> {
12951295
self.print_call_post(base_args)
12961296
}
12971297

1298-
fn print_expr_binary(&mut self, op: hir::BinOp, lhs: &hir::Expr<'_>, rhs: &hir::Expr<'_>) {
1299-
let binop_prec = op.node.precedence();
1298+
fn print_expr_binary(&mut self, op: hir::BinOpKind, lhs: &hir::Expr<'_>, rhs: &hir::Expr<'_>) {
1299+
let binop_prec = op.precedence();
13001300
let left_prec = lhs.precedence();
13011301
let right_prec = rhs.precedence();
13021302

1303-
let (mut left_needs_paren, right_needs_paren) = match op.node.fixity() {
1303+
let (mut left_needs_paren, right_needs_paren) = match op.fixity() {
13041304
Fixity::Left => (left_prec < binop_prec, right_prec <= binop_prec),
13051305
Fixity::Right => (left_prec <= binop_prec, right_prec < binop_prec),
13061306
Fixity::None => (left_prec <= binop_prec, right_prec <= binop_prec),
13071307
};
13081308

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

13221322
self.print_expr_cond_paren(lhs, left_needs_paren);
13231323
self.space();
1324-
self.word_space(op.node.as_str());
1324+
self.word_space(op.as_str());
13251325
self.print_expr_cond_paren(rhs, right_needs_paren);
13261326
}
13271327

@@ -1471,7 +1471,7 @@ impl<'a> State<'a> {
14711471
self.print_expr_method_call(segment, receiver, args);
14721472
}
14731473
hir::ExprKind::Binary(op, lhs, rhs) => {
1474-
self.print_expr_binary(op, lhs, rhs);
1474+
self.print_expr_binary(op.node, lhs, rhs);
14751475
}
14761476
hir::ExprKind::Unary(op, expr) => {
14771477
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
@@ -3477,9 +3477,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
34773477
lhs_ty: Ty<'tcx>,
34783478
rhs_expr: &'tcx hir::Expr<'tcx>,
34793479
lhs_expr: &'tcx hir::Expr<'tcx>,
3480-
op: hir::BinOp,
3480+
op: hir::BinOpKind,
34813481
) {
3482-
match op.node {
3482+
match op {
34833483
hir::BinOpKind::Eq => {
34843484
if let Some(partial_eq_def_id) = self.infcx.tcx.lang_items().eq_trait()
34853485
&& 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 path = None;
@@ -412,7 +414,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
412414
.lookup_op_method(
413415
(lhs_expr, lhs_deref_ty),
414416
Some((rhs_expr, rhs_ty)),
415-
lang_item_for_binop(self.tcx, op, is_assign),
417+
lang_item_for_binop(self.tcx, op.node, is_assign),
416418
op.span,
417419
expected,
418420
)
@@ -446,7 +448,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
446448
.lookup_op_method(
447449
(lhs_expr, lhs_adjusted_ty),
448450
Some((rhs_expr, rhs_adjusted_ty)),
449-
lang_item_for_binop(self.tcx, op, is_assign),
451+
lang_item_for_binop(self.tcx, op.node, is_assign),
450452
op.span,
451453
expected,
452454
)
@@ -504,7 +506,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
504506
self.lookup_op_method(
505507
(lhs_expr, lhs_ty),
506508
Some((rhs_expr, rhs_ty)),
507-
lang_item_for_binop(self.tcx, op, is_assign),
509+
lang_item_for_binop(self.tcx, op.node, is_assign),
508510
op.span,
509511
expected,
510512
)
@@ -598,7 +600,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
598600
.lookup_op_method(
599601
(lhs_expr, lhs_ty),
600602
Some((rhs_expr, rhs_ty)),
601-
lang_item_for_binop(self.tcx, op, is_assign),
603+
lang_item_for_binop(self.tcx, op.node, is_assign),
602604
op.span,
603605
expected,
604606
)
@@ -992,12 +994,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
992994

993995
fn lang_item_for_binop(
994996
tcx: TyCtxt<'_>,
995-
op: hir::BinOp,
997+
op: hir::BinOpKind,
996998
is_assign: IsAssign,
997999
) -> (Symbol, Option<hir::def_id::DefId>) {
9981000
let lang = tcx.lang_items();
9991001
if is_assign == IsAssign::Yes {
1000-
match op.node {
1002+
match op {
10011003
hir::BinOpKind::Add => (sym::add_assign, lang.add_assign_trait()),
10021004
hir::BinOpKind::Sub => (sym::sub_assign, lang.sub_assign_trait()),
10031005
hir::BinOpKind::Mul => (sym::mul_assign, lang.mul_assign_trait()),
@@ -1016,11 +1018,11 @@ fn lang_item_for_binop(
10161018
| hir::BinOpKind::Ne
10171019
| hir::BinOpKind::And
10181020
| hir::BinOpKind::Or => {
1019-
bug!("impossible assignment operation: {}=", op.node.as_str())
1021+
bug!("impossible assignment operation: {}=", op.as_str())
10201022
}
10211023
}
10221024
} else {
1023-
match op.node {
1025+
match op {
10241026
hir::BinOpKind::Add => (sym::add, lang.add_trait()),
10251027
hir::BinOpKind::Sub => (sym::sub, lang.sub_trait()),
10261028
hir::BinOpKind::Mul => (sym::mul, lang.mul_trait()),
@@ -1077,8 +1079,8 @@ enum BinOpCategory {
10771079
}
10781080

10791081
impl BinOpCategory {
1080-
fn from(op: hir::BinOp) -> BinOpCategory {
1081-
match op.node {
1082+
fn from(op: hir::BinOpKind) -> BinOpCategory {
1083+
match op {
10821084
hir::BinOpKind::Shl | hir::BinOpKind::Shr => BinOpCategory::Shift,
10831085

10841086
hir::BinOpKind::Add
@@ -1134,7 +1136,7 @@ fn deref_ty_if_possible(ty: Ty<'_>) -> Ty<'_> {
11341136
/// Reason #2 is the killer. I tried for a while to always use
11351137
/// overloaded logic and just check the types in constants/codegen after
11361138
/// the fact, and it worked fine, except for SIMD types. -nmatsakis
1137-
fn is_builtin_binop<'tcx>(lhs: Ty<'tcx>, rhs: Ty<'tcx>, op: hir::BinOp) -> bool {
1139+
fn is_builtin_binop<'tcx>(lhs: Ty<'tcx>, rhs: Ty<'tcx>, op: hir::BinOpKind) -> bool {
11381140
// Special-case a single layer of referencing, so that things like `5.0 + &6.0f32` work.
11391141
// (See https://github.com/rust-lang/rust/issues/57447.)
11401142
let (lhs, rhs) = (deref_ty_if_possible(lhs), deref_ty_if_possible(rhs));

‎compiler/rustc_lint/src/types.rs

+21-24
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ use rustc_middle::ty::{
1414
};
1515
use rustc_session::{declare_lint, declare_lint_pass, impl_lint_pass};
1616
use rustc_span::def_id::LocalDefId;
17-
use rustc_span::{Span, Symbol, source_map, sym};
17+
use rustc_span::{Span, Symbol, sym};
1818
use tracing::debug;
1919
use {rustc_ast as ast, rustc_hir as hir};
2020

@@ -223,7 +223,7 @@ impl TypeLimits {
223223
fn lint_nan<'tcx>(
224224
cx: &LateContext<'tcx>,
225225
e: &'tcx hir::Expr<'tcx>,
226-
binop: hir::BinOp,
226+
binop: hir::BinOpKind,
227227
l: &'tcx hir::Expr<'tcx>,
228228
r: &'tcx hir::Expr<'tcx>,
229229
) {
@@ -262,19 +262,19 @@ fn lint_nan<'tcx>(
262262
InvalidNanComparisons::EqNe { suggestion }
263263
}
264264

265-
let lint = match binop.node {
265+
let lint = match binop {
266266
hir::BinOpKind::Eq | hir::BinOpKind::Ne if is_nan(cx, l) => {
267267
eq_ne(e, l, r, |l_span, r_span| InvalidNanComparisonsSuggestion::Spanful {
268268
nan_plus_binop: l_span.until(r_span),
269269
float: r_span.shrink_to_hi(),
270-
neg: (binop.node == hir::BinOpKind::Ne).then(|| r_span.shrink_to_lo()),
270+
neg: (binop == hir::BinOpKind::Ne).then(|| r_span.shrink_to_lo()),
271271
})
272272
}
273273
hir::BinOpKind::Eq | hir::BinOpKind::Ne if is_nan(cx, r) => {
274274
eq_ne(e, l, r, |l_span, r_span| InvalidNanComparisonsSuggestion::Spanful {
275275
nan_plus_binop: l_span.shrink_to_hi().to(r_span),
276276
float: l_span.shrink_to_hi(),
277-
neg: (binop.node == hir::BinOpKind::Ne).then(|| l_span.shrink_to_lo()),
277+
neg: (binop == hir::BinOpKind::Ne).then(|| l_span.shrink_to_lo()),
278278
})
279279
}
280280
hir::BinOpKind::Lt | hir::BinOpKind::Le | hir::BinOpKind::Gt | hir::BinOpKind::Ge
@@ -560,11 +560,11 @@ impl<'tcx> LateLintPass<'tcx> for TypeLimits {
560560
}
561561
}
562562
hir::ExprKind::Binary(binop, ref l, ref r) => {
563-
if is_comparison(binop) {
564-
if !check_limits(cx, binop, l, r) {
563+
if is_comparison(binop.node) {
564+
if !check_limits(cx, binop.node, l, r) {
565565
cx.emit_span_lint(UNUSED_COMPARISONS, e.span, UnusedComparisons);
566566
} else {
567-
lint_nan(cx, e, binop, l, r);
567+
lint_nan(cx, e, binop.node, l, r);
568568
let cmpop = ComparisonOp::BinOp(binop.node);
569569
lint_wide_pointer(cx, e, cmpop, l, r);
570570
lint_fn_pointer(cx, e, cmpop, l, r);
@@ -591,8 +591,8 @@ impl<'tcx> LateLintPass<'tcx> for TypeLimits {
591591
_ => {}
592592
};
593593

594-
fn is_valid<T: PartialOrd>(binop: hir::BinOp, v: T, min: T, max: T) -> bool {
595-
match binop.node {
594+
fn is_valid<T: PartialOrd>(binop: hir::BinOpKind, v: T, min: T, max: T) -> bool {
595+
match binop {
596596
hir::BinOpKind::Lt => v > min && v <= max,
597597
hir::BinOpKind::Le => v >= min && v < max,
598598
hir::BinOpKind::Gt => v >= min && v < max,
@@ -602,22 +602,19 @@ impl<'tcx> LateLintPass<'tcx> for TypeLimits {
602602
}
603603
}
604604

605-
fn rev_binop(binop: hir::BinOp) -> hir::BinOp {
606-
source_map::respan(
607-
binop.span,
608-
match binop.node {
609-
hir::BinOpKind::Lt => hir::BinOpKind::Gt,
610-
hir::BinOpKind::Le => hir::BinOpKind::Ge,
611-
hir::BinOpKind::Gt => hir::BinOpKind::Lt,
612-
hir::BinOpKind::Ge => hir::BinOpKind::Le,
613-
_ => return binop,
614-
},
615-
)
605+
fn rev_binop(binop: hir::BinOpKind) -> hir::BinOpKind {
606+
match binop {
607+
hir::BinOpKind::Lt => hir::BinOpKind::Gt,
608+
hir::BinOpKind::Le => hir::BinOpKind::Ge,
609+
hir::BinOpKind::Gt => hir::BinOpKind::Lt,
610+
hir::BinOpKind::Ge => hir::BinOpKind::Le,
611+
_ => binop,
612+
}
616613
}
617614

618615
fn check_limits(
619616
cx: &LateContext<'_>,
620-
binop: hir::BinOp,
617+
binop: hir::BinOpKind,
621618
l: &hir::Expr<'_>,
622619
r: &hir::Expr<'_>,
623620
) -> bool {
@@ -659,9 +656,9 @@ impl<'tcx> LateLintPass<'tcx> for TypeLimits {
659656
}
660657
}
661658

662-
fn is_comparison(binop: hir::BinOp) -> bool {
659+
fn is_comparison(binop: hir::BinOpKind) -> bool {
663660
matches!(
664-
binop.node,
661+
binop,
665662
hir::BinOpKind::Eq
666663
| hir::BinOpKind::Lt
667664
| hir::BinOpKind::Le

0 commit comments

Comments
 (0)