Simplify printing operator lang item paths in error message
This commit is contained in:
Michael Goulet
parent
00c9d3d2ee
commit
d0746e8863
1 changed files with 109 additions and 150 deletions
|
|
@ -11,6 +11,7 @@ use rustc_infer::traits::ObligationCauseCode;
|
|||
use rustc_middle::ty::adjustment::{
|
||||
Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability,
|
||||
};
|
||||
use rustc_middle::ty::print::with_no_trimmed_paths;
|
||||
use rustc_middle::ty::{
|
||||
self, Ty, TyCtxt, TypeFolder, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitor,
|
||||
};
|
||||
|
|
@ -313,7 +314,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
|||
// error types are considered "builtin"
|
||||
Err(_) if lhs_ty.references_error() || rhs_ty.references_error() => self.tcx.ty_error(),
|
||||
Err(errors) => {
|
||||
let (mut err, missing_trait, use_output) = match is_assign {
|
||||
let (_, item) = lang_item_for_op(self.tcx, Op::Binary(op, is_assign), op.span);
|
||||
let missing_trait =
|
||||
item.map(|def_id| with_no_trimmed_paths!(self.tcx.def_path_str(def_id)));
|
||||
let (mut err, use_output) = match is_assign {
|
||||
IsAssign::Yes => {
|
||||
let mut err = struct_span_err!(
|
||||
self.tcx.sess,
|
||||
|
|
@ -327,112 +331,60 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
|||
lhs_expr.span,
|
||||
format!("cannot use `{}=` on type `{}`", op.node.as_str(), lhs_ty),
|
||||
);
|
||||
let missing_trait = match op.node {
|
||||
hir::BinOpKind::Add => Some("std::ops::AddAssign"),
|
||||
hir::BinOpKind::Sub => Some("std::ops::SubAssign"),
|
||||
hir::BinOpKind::Mul => Some("std::ops::MulAssign"),
|
||||
hir::BinOpKind::Div => Some("std::ops::DivAssign"),
|
||||
hir::BinOpKind::Rem => Some("std::ops::RemAssign"),
|
||||
hir::BinOpKind::BitAnd => Some("std::ops::BitAndAssign"),
|
||||
hir::BinOpKind::BitXor => Some("std::ops::BitXorAssign"),
|
||||
hir::BinOpKind::BitOr => Some("std::ops::BitOrAssign"),
|
||||
hir::BinOpKind::Shl => Some("std::ops::ShlAssign"),
|
||||
hir::BinOpKind::Shr => Some("std::ops::ShrAssign"),
|
||||
_ => None,
|
||||
};
|
||||
self.note_unmet_impls_on_type(&mut err, errors);
|
||||
(err, missing_trait, false)
|
||||
(err, false)
|
||||
}
|
||||
IsAssign::No => {
|
||||
let (message, missing_trait, use_output) = match op.node {
|
||||
hir::BinOpKind::Add => (
|
||||
format!("cannot add `{rhs_ty}` to `{lhs_ty}`"),
|
||||
Some("std::ops::Add"),
|
||||
true,
|
||||
),
|
||||
hir::BinOpKind::Sub => (
|
||||
format!("cannot subtract `{rhs_ty}` from `{lhs_ty}`"),
|
||||
Some("std::ops::Sub"),
|
||||
true,
|
||||
),
|
||||
hir::BinOpKind::Mul => (
|
||||
format!("cannot multiply `{lhs_ty}` by `{rhs_ty}`"),
|
||||
Some("std::ops::Mul"),
|
||||
true,
|
||||
),
|
||||
hir::BinOpKind::Div => (
|
||||
format!("cannot divide `{lhs_ty}` by `{rhs_ty}`"),
|
||||
Some("std::ops::Div"),
|
||||
true,
|
||||
),
|
||||
hir::BinOpKind::Rem => (
|
||||
format!("cannot mod `{lhs_ty}` by `{rhs_ty}`"),
|
||||
Some("std::ops::Rem"),
|
||||
true,
|
||||
),
|
||||
hir::BinOpKind::BitAnd => (
|
||||
format!("no implementation for `{lhs_ty} & {rhs_ty}`"),
|
||||
Some("std::ops::BitAnd"),
|
||||
true,
|
||||
),
|
||||
hir::BinOpKind::BitXor => (
|
||||
format!("no implementation for `{lhs_ty} ^ {rhs_ty}`"),
|
||||
Some("std::ops::BitXor"),
|
||||
true,
|
||||
),
|
||||
hir::BinOpKind::BitOr => (
|
||||
format!("no implementation for `{lhs_ty} | {rhs_ty}`"),
|
||||
Some("std::ops::BitOr"),
|
||||
true,
|
||||
),
|
||||
hir::BinOpKind::Shl => (
|
||||
format!("no implementation for `{lhs_ty} << {rhs_ty}`"),
|
||||
Some("std::ops::Shl"),
|
||||
true,
|
||||
),
|
||||
hir::BinOpKind::Shr => (
|
||||
format!("no implementation for `{lhs_ty} >> {rhs_ty}`"),
|
||||
Some("std::ops::Shr"),
|
||||
true,
|
||||
),
|
||||
hir::BinOpKind::Eq | hir::BinOpKind::Ne => (
|
||||
format!(
|
||||
"binary operation `{}` cannot be applied to type `{}`",
|
||||
op.node.as_str(),
|
||||
lhs_ty
|
||||
),
|
||||
Some("std::cmp::PartialEq"),
|
||||
false,
|
||||
),
|
||||
hir::BinOpKind::Lt
|
||||
| hir::BinOpKind::Le
|
||||
| hir::BinOpKind::Gt
|
||||
| hir::BinOpKind::Ge => (
|
||||
format!(
|
||||
"binary operation `{}` cannot be applied to type `{}`",
|
||||
op.node.as_str(),
|
||||
lhs_ty
|
||||
),
|
||||
Some("std::cmp::PartialOrd"),
|
||||
false,
|
||||
),
|
||||
_ => (
|
||||
format!(
|
||||
"binary operation `{}` cannot be applied to type `{}`",
|
||||
op.node.as_str(),
|
||||
lhs_ty
|
||||
),
|
||||
None,
|
||||
false,
|
||||
let message = match op.node {
|
||||
hir::BinOpKind::Add => {
|
||||
format!("cannot add `{rhs_ty}` to `{lhs_ty}`")
|
||||
}
|
||||
hir::BinOpKind::Sub => {
|
||||
format!("cannot subtract `{rhs_ty}` from `{lhs_ty}`")
|
||||
}
|
||||
hir::BinOpKind::Mul => {
|
||||
format!("cannot multiply `{lhs_ty}` by `{rhs_ty}`")
|
||||
}
|
||||
hir::BinOpKind::Div => {
|
||||
format!("cannot divide `{lhs_ty}` by `{rhs_ty}`")
|
||||
}
|
||||
hir::BinOpKind::Rem => {
|
||||
format!("cannot mod `{lhs_ty}` by `{rhs_ty}`")
|
||||
}
|
||||
hir::BinOpKind::BitAnd => {
|
||||
format!("no implementation for `{lhs_ty} & {rhs_ty}`")
|
||||
}
|
||||
hir::BinOpKind::BitXor => {
|
||||
format!("no implementation for `{lhs_ty} ^ {rhs_ty}`")
|
||||
}
|
||||
hir::BinOpKind::BitOr => {
|
||||
format!("no implementation for `{lhs_ty} | {rhs_ty}`")
|
||||
}
|
||||
hir::BinOpKind::Shl => {
|
||||
format!("no implementation for `{lhs_ty} << {rhs_ty}`")
|
||||
}
|
||||
hir::BinOpKind::Shr => {
|
||||
format!("no implementation for `{lhs_ty} >> {rhs_ty}`")
|
||||
}
|
||||
_ => format!(
|
||||
"binary operation `{}` cannot be applied to type `{}`",
|
||||
op.node.as_str(),
|
||||
lhs_ty
|
||||
),
|
||||
};
|
||||
let use_output = item.map_or(false, |def_id| {
|
||||
self.tcx.associated_item_def_ids(def_id).iter().any(|item_def_id| {
|
||||
self.tcx.opt_associated_item(*item_def_id).unwrap().name
|
||||
== sym::Output
|
||||
})
|
||||
});
|
||||
let mut err = struct_span_err!(self.tcx.sess, op.span, E0369, "{message}");
|
||||
if !lhs_expr.span.eq(&rhs_expr.span) {
|
||||
err.span_label(lhs_expr.span, lhs_ty.to_string());
|
||||
err.span_label(rhs_expr.span, rhs_ty.to_string());
|
||||
}
|
||||
self.note_unmet_impls_on_type(&mut err, errors);
|
||||
(err, missing_trait, use_output)
|
||||
(err, use_output)
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -773,64 +725,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
|||
op: Op,
|
||||
expected: Expectation<'tcx>,
|
||||
) -> Result<MethodCallee<'tcx>, Vec<FulfillmentError<'tcx>>> {
|
||||
let lang = self.tcx.lang_items();
|
||||
|
||||
let span = match op {
|
||||
Op::Binary(op, _) => op.span,
|
||||
Op::Unary(_, span) => span,
|
||||
};
|
||||
let (opname, trait_did) = if let Op::Binary(op, IsAssign::Yes) = op {
|
||||
match op.node {
|
||||
hir::BinOpKind::Add => (sym::add_assign, lang.add_assign_trait()),
|
||||
hir::BinOpKind::Sub => (sym::sub_assign, lang.sub_assign_trait()),
|
||||
hir::BinOpKind::Mul => (sym::mul_assign, lang.mul_assign_trait()),
|
||||
hir::BinOpKind::Div => (sym::div_assign, lang.div_assign_trait()),
|
||||
hir::BinOpKind::Rem => (sym::rem_assign, lang.rem_assign_trait()),
|
||||
hir::BinOpKind::BitXor => (sym::bitxor_assign, lang.bitxor_assign_trait()),
|
||||
hir::BinOpKind::BitAnd => (sym::bitand_assign, lang.bitand_assign_trait()),
|
||||
hir::BinOpKind::BitOr => (sym::bitor_assign, lang.bitor_assign_trait()),
|
||||
hir::BinOpKind::Shl => (sym::shl_assign, lang.shl_assign_trait()),
|
||||
hir::BinOpKind::Shr => (sym::shr_assign, lang.shr_assign_trait()),
|
||||
hir::BinOpKind::Lt
|
||||
| hir::BinOpKind::Le
|
||||
| hir::BinOpKind::Ge
|
||||
| hir::BinOpKind::Gt
|
||||
| hir::BinOpKind::Eq
|
||||
| hir::BinOpKind::Ne
|
||||
| hir::BinOpKind::And
|
||||
| hir::BinOpKind::Or => {
|
||||
span_bug!(span, "impossible assignment operation: {}=", op.node.as_str())
|
||||
}
|
||||
}
|
||||
} else if let Op::Binary(op, IsAssign::No) = op {
|
||||
match op.node {
|
||||
hir::BinOpKind::Add => (sym::add, lang.add_trait()),
|
||||
hir::BinOpKind::Sub => (sym::sub, lang.sub_trait()),
|
||||
hir::BinOpKind::Mul => (sym::mul, lang.mul_trait()),
|
||||
hir::BinOpKind::Div => (sym::div, lang.div_trait()),
|
||||
hir::BinOpKind::Rem => (sym::rem, lang.rem_trait()),
|
||||
hir::BinOpKind::BitXor => (sym::bitxor, lang.bitxor_trait()),
|
||||
hir::BinOpKind::BitAnd => (sym::bitand, lang.bitand_trait()),
|
||||
hir::BinOpKind::BitOr => (sym::bitor, lang.bitor_trait()),
|
||||
hir::BinOpKind::Shl => (sym::shl, lang.shl_trait()),
|
||||
hir::BinOpKind::Shr => (sym::shr, lang.shr_trait()),
|
||||
hir::BinOpKind::Lt => (sym::lt, lang.partial_ord_trait()),
|
||||
hir::BinOpKind::Le => (sym::le, lang.partial_ord_trait()),
|
||||
hir::BinOpKind::Ge => (sym::ge, lang.partial_ord_trait()),
|
||||
hir::BinOpKind::Gt => (sym::gt, lang.partial_ord_trait()),
|
||||
hir::BinOpKind::Eq => (sym::eq, lang.eq_trait()),
|
||||
hir::BinOpKind::Ne => (sym::ne, lang.eq_trait()),
|
||||
hir::BinOpKind::And | hir::BinOpKind::Or => {
|
||||
span_bug!(span, "&& and || are not overloadable")
|
||||
}
|
||||
}
|
||||
} else if let Op::Unary(hir::UnOp::Not, _) = op {
|
||||
(sym::not, lang.not_trait())
|
||||
} else if let Op::Unary(hir::UnOp::Neg, _) = op {
|
||||
(sym::neg, lang.neg_trait())
|
||||
} else {
|
||||
bug!("lookup_op_method: op not supported: {:?}", op)
|
||||
};
|
||||
let (opname, trait_did) = lang_item_for_op(self.tcx, op, span);
|
||||
|
||||
debug!(
|
||||
"lookup_op_method(lhs_ty={:?}, op={:?}, opname={:?}, trait_did={:?})",
|
||||
|
|
@ -891,6 +790,66 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
|||
}
|
||||
}
|
||||
|
||||
fn lang_item_for_op(
|
||||
tcx: TyCtxt<'_>,
|
||||
op: Op,
|
||||
span: Span,
|
||||
) -> (rustc_span::Symbol, Option<hir::def_id::DefId>) {
|
||||
let lang = tcx.lang_items();
|
||||
if let Op::Binary(op, IsAssign::Yes) = op {
|
||||
match op.node {
|
||||
hir::BinOpKind::Add => (sym::add_assign, lang.add_assign_trait()),
|
||||
hir::BinOpKind::Sub => (sym::sub_assign, lang.sub_assign_trait()),
|
||||
hir::BinOpKind::Mul => (sym::mul_assign, lang.mul_assign_trait()),
|
||||
hir::BinOpKind::Div => (sym::div_assign, lang.div_assign_trait()),
|
||||
hir::BinOpKind::Rem => (sym::rem_assign, lang.rem_assign_trait()),
|
||||
hir::BinOpKind::BitXor => (sym::bitxor_assign, lang.bitxor_assign_trait()),
|
||||
hir::BinOpKind::BitAnd => (sym::bitand_assign, lang.bitand_assign_trait()),
|
||||
hir::BinOpKind::BitOr => (sym::bitor_assign, lang.bitor_assign_trait()),
|
||||
hir::BinOpKind::Shl => (sym::shl_assign, lang.shl_assign_trait()),
|
||||
hir::BinOpKind::Shr => (sym::shr_assign, lang.shr_assign_trait()),
|
||||
hir::BinOpKind::Lt
|
||||
| hir::BinOpKind::Le
|
||||
| hir::BinOpKind::Ge
|
||||
| hir::BinOpKind::Gt
|
||||
| hir::BinOpKind::Eq
|
||||
| hir::BinOpKind::Ne
|
||||
| hir::BinOpKind::And
|
||||
| hir::BinOpKind::Or => {
|
||||
span_bug!(span, "impossible assignment operation: {}=", op.node.as_str())
|
||||
}
|
||||
}
|
||||
} else if let Op::Binary(op, IsAssign::No) = op {
|
||||
match op.node {
|
||||
hir::BinOpKind::Add => (sym::add, lang.add_trait()),
|
||||
hir::BinOpKind::Sub => (sym::sub, lang.sub_trait()),
|
||||
hir::BinOpKind::Mul => (sym::mul, lang.mul_trait()),
|
||||
hir::BinOpKind::Div => (sym::div, lang.div_trait()),
|
||||
hir::BinOpKind::Rem => (sym::rem, lang.rem_trait()),
|
||||
hir::BinOpKind::BitXor => (sym::bitxor, lang.bitxor_trait()),
|
||||
hir::BinOpKind::BitAnd => (sym::bitand, lang.bitand_trait()),
|
||||
hir::BinOpKind::BitOr => (sym::bitor, lang.bitor_trait()),
|
||||
hir::BinOpKind::Shl => (sym::shl, lang.shl_trait()),
|
||||
hir::BinOpKind::Shr => (sym::shr, lang.shr_trait()),
|
||||
hir::BinOpKind::Lt => (sym::lt, lang.partial_ord_trait()),
|
||||
hir::BinOpKind::Le => (sym::le, lang.partial_ord_trait()),
|
||||
hir::BinOpKind::Ge => (sym::ge, lang.partial_ord_trait()),
|
||||
hir::BinOpKind::Gt => (sym::gt, lang.partial_ord_trait()),
|
||||
hir::BinOpKind::Eq => (sym::eq, lang.eq_trait()),
|
||||
hir::BinOpKind::Ne => (sym::ne, lang.eq_trait()),
|
||||
hir::BinOpKind::And | hir::BinOpKind::Or => {
|
||||
span_bug!(span, "&& and || are not overloadable")
|
||||
}
|
||||
}
|
||||
} else if let Op::Unary(hir::UnOp::Not, _) = op {
|
||||
(sym::not, lang.not_trait())
|
||||
} else if let Op::Unary(hir::UnOp::Neg, _) = op {
|
||||
(sym::neg, lang.neg_trait())
|
||||
} else {
|
||||
bug!("lookup_op_method: op not supported: {:?}", op)
|
||||
}
|
||||
}
|
||||
|
||||
// Binary operator categories. These categories summarize the behavior
|
||||
// with respect to the builtin operations supported.
|
||||
enum BinOpCategory {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue