Skip to content

Commit c60bae7

Browse files
TaKO8KiTaKO8Ki
committed
suggest a float literal when dividing a floating-point type by {integer}
fix a message implement a rustfix-applicable suggestion implement `suggest_floating_point_literal` add `ObligationCauseCode::BinOp` remove duplicate code fix function names in uitests use `Diagnostic` instead of `DiagnosticBuilder`
1 parent 12b71ed commit c60bae7

File tree

12 files changed

+543
-18
lines changed

12 files changed

+543
-18
lines changed

‎compiler/rustc_middle/src/traits/mod.rs‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -368,6 +368,11 @@ pub enum ObligationCauseCode<'tcx> {
368368

369369
/// From `match_impl`. The cause for us having to match an impl, and the DefId we are matching against.
370370
MatchImpl(ObligationCause<'tcx>, DefId),
371+
372+
BinOp {
373+
rhs_span: Option<Span>,
374+
is_lit: bool,
375+
},
371376
}
372377

373378
/// The 'location' at which we try to perform HIR-based wf checking.

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

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -501,6 +501,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
501501
err.span_label(enclosing_scope_span, s.as_str());
502502
}
503503

504+
self.suggest_floating_point_literal(&obligation, &mut err, &trait_ref);
504505
self.suggest_dereferences(&obligation, &mut err, trait_predicate);
505506
self.suggest_fn_call(&obligation, &mut err, trait_predicate);
506507
self.suggest_remove_reference(&obligation, &mut err, trait_predicate);

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

Lines changed: 35 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -174,6 +174,13 @@ pub trait InferCtxtExt<'tcx> {
174174
trait_pred: ty::PolyTraitPredicate<'tcx>,
175175
span: Span,
176176
);
177+
178+
fn suggest_floating_point_literal(
179+
&self,
180+
obligation: &PredicateObligation<'tcx>,
181+
err: &mut Diagnostic,
182+
trait_ref: &ty::PolyTraitRef<'tcx>,
183+
);
177184
}
178185

179186
fn predicate_constraint(generics: &hir::Generics<'_>, pred: String) -> (Span, String) {
@@ -1910,8 +1917,9 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
19101917
| ObligationCauseCode::AwaitableExpr(_)
19111918
| ObligationCauseCode::ForLoopIterator
19121919
| ObligationCauseCode::QuestionMark
1920+
| ObligationCauseCode::CheckAssociatedTypeBounds { .. }
19131921
| ObligationCauseCode::LetElse
1914-
| ObligationCauseCode::CheckAssociatedTypeBounds { .. } => {}
1922+
| ObligationCauseCode::BinOp { .. } => {}
19151923
ObligationCauseCode::SliceOrArrayElem => {
19161924
err.note("slice and array elements must have `Sized` type");
19171925
}
@@ -2497,6 +2505,32 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
24972505
}
24982506
}
24992507
}
2508+
2509+
fn suggest_floating_point_literal(
2510+
&self,
2511+
obligation: &PredicateObligation<'tcx>,
2512+
err: &mut Diagnostic,
2513+
trait_ref: &ty::PolyTraitRef<'tcx>,
2514+
) {
2515+
let rhs_span = match obligation.cause.code() {
2516+
ObligationCauseCode::BinOp { rhs_span: Some(span), is_lit } if *is_lit => span,
2517+
_ => return,
2518+
};
2519+
match (
2520+
trait_ref.skip_binder().self_ty().kind(),
2521+
trait_ref.skip_binder().substs.type_at(1).kind(),
2522+
) {
2523+
(ty::Float(_), ty::Infer(InferTy::IntVar(_))) => {
2524+
err.span_suggestion_verbose(
2525+
rhs_span.shrink_to_hi(),
2526+
"consider using a floating-point literal by writing it with `.0`",
2527+
String::from(".0"),
2528+
Applicability::MaybeIncorrect,
2529+
);
2530+
}
2531+
_ => {}
2532+
}
2533+
}
25002534
}
25012535

25022536
/// Collect all the returned expressions within the input expression.

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

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -438,6 +438,30 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
438438
)
439439
}
440440

441+
pub(in super::super) fn normalize_op_associated_types_in_as_infer_ok<T>(
442+
&self,
443+
span: Span,
444+
value: T,
445+
opt_input_expr: Option<&hir::Expr<'_>>,
446+
) -> InferOk<'tcx, T>
447+
where
448+
T: TypeFoldable<'tcx>,
449+
{
450+
self.inh.partially_normalize_associated_types_in(
451+
ObligationCause::new(
452+
span,
453+
self.body_id,
454+
traits::BinOp {
455+
rhs_span: opt_input_expr.map(|expr| expr.span),
456+
is_lit: opt_input_expr
457+
.map_or(false, |expr| matches!(expr.kind, ExprKind::Lit(_))),
458+
},
459+
),
460+
self.param_env,
461+
value,
462+
)
463+
}
464+
441465
pub fn require_type_meets(
442466
&self,
443467
ty: Ty<'tcx>,

‎compiler/rustc_typeck/src/check/method/mod.rs‎

Lines changed: 119 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -333,15 +333,57 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
333333
)
334334
}
335335

336+
pub(super) fn obligation_for_op_method(
337+
&self,
338+
span: Span,
339+
trait_def_id: DefId,
340+
self_ty: Ty<'tcx>,
341+
opt_input_type: Option<Ty<'tcx>>,
342+
opt_input_expr: Option<&'tcx hir::Expr<'tcx>>,
343+
) -> (traits::Obligation<'tcx, ty::Predicate<'tcx>>, &'tcx ty::List<ty::subst::GenericArg<'tcx>>)
344+
{
345+
// Construct a trait-reference `self_ty : Trait<input_tys>`
346+
let substs = InternalSubsts::for_item(self.tcx, trait_def_id, |param, _| {
347+
match param.kind {
348+
GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => {}
349+
GenericParamDefKind::Type { .. } => {
350+
if param.index == 0 {
351+
return self_ty.into();
352+
} else if let Some(input_type) = opt_input_type {
353+
return input_type.into();
354+
}
355+
}
356+
}
357+
self.var_for_def(span, param)
358+
});
359+
360+
let trait_ref = ty::TraitRef::new(trait_def_id, substs);
361+
362+
// Construct an obligation
363+
let poly_trait_ref = ty::Binder::dummy(trait_ref);
364+
(
365+
traits::Obligation::new(
366+
traits::ObligationCause::new(
367+
span,
368+
self.body_id,
369+
traits::BinOp {
370+
rhs_span: opt_input_expr.map(|expr| expr.span),
371+
is_lit: opt_input_expr
372+
.map_or(false, |expr| matches!(expr.kind, hir::ExprKind::Lit(_))),
373+
},
374+
),
375+
self.param_env,
376+
poly_trait_ref.without_const().to_predicate(self.tcx),
377+
),
378+
substs,
379+
)
380+
}
381+
336382
/// `lookup_method_in_trait` is used for overloaded operators.
337383
/// It does a very narrow slice of what the normal probe/confirm path does.
338384
/// In particular, it doesn't really do any probing: it simply constructs
339385
/// an obligation for a particular trait with the given self type and checks
340386
/// whether that trait is implemented.
341-
//
342-
// FIXME(#18741): it seems likely that we can consolidate some of this
343-
// code with the other method-lookup code. In particular, the second half
344-
// of this method is basically the same as confirmation.
345387
#[instrument(level = "debug", skip(self, span, opt_input_types))]
346388
pub(super) fn lookup_method_in_trait(
347389
&self,
@@ -358,7 +400,57 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
358400

359401
let (obligation, substs) =
360402
self.obligation_for_method(span, trait_def_id, self_ty, opt_input_types);
403+
self.construct_obligation_for_trait(
404+
span,
405+
m_name,
406+
trait_def_id,
407+
obligation,
408+
substs,
409+
None,
410+
false,
411+
)
412+
}
361413

414+
pub(super) fn lookup_op_method_in_trait(
415+
&self,
416+
span: Span,
417+
m_name: Ident,
418+
trait_def_id: DefId,
419+
self_ty: Ty<'tcx>,
420+
opt_input_type: Option<Ty<'tcx>>,
421+
opt_input_expr: Option<&'tcx hir::Expr<'tcx>>,
422+
) -> Option<InferOk<'tcx, MethodCallee<'tcx>>> {
423+
let (obligation, substs) = self.obligation_for_op_method(
424+
span,
425+
trait_def_id,
426+
self_ty,
427+
opt_input_type,
428+
opt_input_expr,
429+
);
430+
self.construct_obligation_for_trait(
431+
span,
432+
m_name,
433+
trait_def_id,
434+
obligation,
435+
substs,
436+
opt_input_expr,
437+
true,
438+
)
439+
}
440+
441+
// FIXME(#18741): it seems likely that we can consolidate some of this
442+
// code with the other method-lookup code. In particular, the second half
443+
// of this method is basically the same as confirmation.
444+
fn construct_obligation_for_trait(
445+
&self,
446+
span: Span,
447+
m_name: Ident,
448+
trait_def_id: DefId,
449+
obligation: traits::PredicateObligation<'tcx>,
450+
substs: &'tcx ty::List<ty::subst::GenericArg<'tcx>>,
451+
opt_input_expr: Option<&'tcx hir::Expr<'tcx>>,
452+
is_op: bool,
453+
) -> Option<InferOk<'tcx, MethodCallee<'tcx>>> {
362454
debug!(?obligation);
363455

364456
// Now we want to know if this can be matched
@@ -395,8 +487,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
395487
let fn_sig = self.replace_bound_vars_with_fresh_vars(span, infer::FnCall, fn_sig).0;
396488
let fn_sig = fn_sig.subst(self.tcx, substs);
397489

398-
let InferOk { value, obligations: o } =
399-
self.normalize_associated_types_in_as_infer_ok(span, fn_sig);
490+
let InferOk { value, obligations: o } = if is_op {
491+
self.normalize_op_associated_types_in_as_infer_ok(span, fn_sig, opt_input_expr)
492+
} else {
493+
self.normalize_associated_types_in_as_infer_ok(span, fn_sig)
494+
};
400495
let fn_sig = {
401496
obligations.extend(o);
402497
value
@@ -412,16 +507,31 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
412507
// any late-bound regions appearing in its bounds.
413508
let bounds = self.tcx.predicates_of(def_id).instantiate(self.tcx, substs);
414509

415-
let InferOk { value, obligations: o } =
416-
self.normalize_associated_types_in_as_infer_ok(span, bounds);
510+
let InferOk { value, obligations: o } = if is_op {
511+
self.normalize_op_associated_types_in_as_infer_ok(span, bounds, opt_input_expr)
512+
} else {
513+
self.normalize_associated_types_in_as_infer_ok(span, bounds)
514+
};
417515
let bounds = {
418516
obligations.extend(o);
419517
value
420518
};
421519

422520
assert!(!bounds.has_escaping_bound_vars());
423521

424-
let cause = traits::ObligationCause::misc(span, self.body_id);
522+
let cause = if is_op {
523+
ObligationCause::new(
524+
span,
525+
self.body_id,
526+
traits::BinOp {
527+
rhs_span: opt_input_expr.map(|expr| expr.span),
528+
is_lit: opt_input_expr
529+
.map_or(false, |expr| matches!(expr.kind, hir::ExprKind::Lit(_))),
530+
},
531+
)
532+
} else {
533+
traits::ObligationCause::misc(span, self.body_id)
534+
};
425535
obligations.extend(traits::predicates_for_generics(cause.clone(), self.param_env, bounds));
426536

427537
// Also add an obligation for the method type being well-formed.

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

Lines changed: 30 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -201,7 +201,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
201201
span: rhs_expr.span,
202202
});
203203

204-
let result = self.lookup_op_method(lhs_ty, &[rhs_ty_var], Op::Binary(op, is_assign));
204+
let result = self.lookup_op_method(
205+
lhs_ty,
206+
Some(rhs_ty_var),
207+
Some(rhs_expr),
208+
Op::Binary(op, is_assign),
209+
);
205210

206211
// see `NB` above
207212
let rhs_ty = self.check_expr_coercable_to_type(rhs_expr, rhs_ty_var, Some(lhs_expr));
@@ -382,6 +387,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
382387
lhs_expr.span,
383388
lhs_ty,
384389
rhs_ty,
390+
rhs_expr,
385391
op,
386392
is_assign,
387393
);
@@ -390,6 +396,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
390396
rhs_expr.span,
391397
rhs_ty,
392398
lhs_ty,
399+
lhs_expr,
393400
op,
394401
is_assign,
395402
);
@@ -400,7 +407,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
400407
};
401408
if let Ref(_, rty, _) = lhs_ty.kind() {
402409
if self.infcx.type_is_copy_modulo_regions(self.param_env, *rty, lhs_expr.span)
403-
&& self.lookup_op_method(*rty, &[rhs_ty], Op::Binary(op, is_assign)).is_ok()
410+
&& self
411+
.lookup_op_method(
412+
*rty,
413+
Some(rhs_ty),
414+
Some(rhs_expr),
415+
Op::Binary(op, is_assign),
416+
)
417+
.is_ok()
404418
{
405419
if let Ok(lstring) = source_map.span_to_snippet(lhs_expr.span) {
406420
let msg = &format!(
@@ -443,7 +457,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
443457
let needs_bound = self
444458
.lookup_op_method(
445459
eraser.fold_ty(lhs_ty),
446-
&[eraser.fold_ty(rhs_ty)],
460+
Some(eraser.fold_ty(rhs_ty)),
461+
Some(rhs_expr),
447462
Op::Binary(op, is_assign),
448463
)
449464
.is_ok();
@@ -487,6 +502,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
487502
span: Span,
488503
ty: Ty<'tcx>,
489504
other_ty: Ty<'tcx>,
505+
other_expr: &'tcx hir::Expr<'tcx>,
490506
op: hir::BinOp,
491507
is_assign: IsAssign,
492508
) -> bool /* did we suggest to call a function because of missing parentheses? */ {
@@ -513,7 +529,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
513529
};
514530

515531
if self
516-
.lookup_op_method(fn_sig.output(), &[other_ty], Op::Binary(op, is_assign))
532+
.lookup_op_method(
533+
fn_sig.output(),
534+
Some(other_ty),
535+
Some(other_expr),
536+
Op::Binary(op, is_assign),
537+
)
517538
.is_ok()
518539
{
519540
let (variable_snippet, applicability) = if !fn_sig.inputs().is_empty() {
@@ -631,7 +652,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
631652
op: hir::UnOp,
632653
) -> Ty<'tcx> {
633654
assert!(op.is_by_value());
634-
match self.lookup_op_method(operand_ty, &[], Op::Unary(op, ex.span)) {
655+
match self.lookup_op_method(operand_ty, None, None, Op::Unary(op, ex.span)) {
635656
Ok(method) => {
636657
self.write_method_call(ex.hir_id, method);
637658
method.sig.output()
@@ -705,7 +726,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
705726
fn lookup_op_method(
706727
&self,
707728
lhs_ty: Ty<'tcx>,
708-
other_tys: &[Ty<'tcx>],
729+
other_ty: Option<Ty<'tcx>>,
730+
other_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
709731
op: Op,
710732
) -> Result<MethodCallee<'tcx>, Vec<FulfillmentError<'tcx>>> {
711733
let lang = self.tcx.lang_items();
@@ -791,7 +813,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
791813

792814
let opname = Ident::with_dummy_span(opname);
793815
let method = trait_did.and_then(|trait_did| {
794-
self.lookup_method_in_trait(span, opname, trait_did, lhs_ty, Some(other_tys))
816+
self.lookup_op_method_in_trait(span, opname, trait_did, lhs_ty, other_ty, other_ty_expr)
795817
});
796818

797819
match (method, trait_did) {
@@ -803,7 +825,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
803825
(None, None) => Err(vec![]),
804826
(None, Some(trait_did)) => {
805827
let (obligation, _) =
806-
self.obligation_for_method(span, trait_did, lhs_ty, Some(other_tys));
828+
self.obligation_for_op_method(span, trait_did, lhs_ty, other_ty, other_ty_expr);
807829
let mut fulfill = <dyn TraitEngine<'_>>::new(self.tcx);
808830
fulfill.register_predicate_obligation(self, obligation);
809831
Err(fulfill.select_where_possible(&self.infcx))

0 commit comments

Comments
 (0)