use rustc_span::symbol::sym;
use rustc_span::Span;
use rustc_trait_selection::infer::InferCtxtExt;
-use rustc_trait_selection::traits::error_reporting::report_object_safety_error;
/// Reifies a cast check to be checked once we have full type information for
/// a function context.
debug!(" -> CoercionCast");
fcx.typeck_results.borrow_mut().set_coercion_cast(self.expr.hir_id.local_id);
}
- Err(ty::error::TypeError::ObjectUnsafeCoercion(did)) => {
- self.report_object_unsafe_cast(&fcx, did);
- }
Err(_) => {
match self.do_check(fcx) {
Ok(k) => {
};
}
}
-
- fn report_object_unsafe_cast(&self, fcx: &FnCtxt<'a, 'tcx>, did: DefId) {
- let violations = fcx.tcx.object_safety_violations(did);
- let mut err = report_object_safety_error(fcx.tcx, self.cast_span, did, violations);
- err.note(&format!("required by cast to type '{}'", fcx.ty_to_string(self.cast_ty)));
- err.emit();
- }
-
/// Checks a cast, and report an error if one exists. In some cases, this
/// can return Ok and create type errors in the fcx rather than returning
/// directly. coercion-cast is handled in check instead of here.
}
};
- match terr {
- // Ignore msg for object safe coercion
- // since E0038 message will be printed
- TypeError::ObjectUnsafeCoercion(_) => {}
- _ => {
- let mut label_or_note = |span: Span, msg: &str| {
- if (prefer_label && is_simple_error) || &[span] == diag.span.primary_spans() {
- diag.span_label(span, msg);
- } else {
- diag.span_note(span, msg);
- }
- };
- if let Some((sp, msg)) = secondary_span {
- if swap_secondary_and_primary {
- let terr = if let Some(infer::ValuePairs::Terms(infer::ExpectedFound {
- expected,
- ..
- })) = values
- {
- format!("expected this to be `{}`", expected)
- } else {
- terr.to_string()
- };
- label_or_note(sp, &terr);
- label_or_note(span, &msg);
- } else {
- label_or_note(span, &terr.to_string());
- label_or_note(sp, &msg);
- }
- } else {
- label_or_note(span, &terr.to_string());
- }
+ let mut label_or_note = |span: Span, msg: &str| {
+ if (prefer_label && is_simple_error) || &[span] == diag.span.primary_spans() {
+ diag.span_label(span, msg);
+ } else {
+ diag.span_note(span, msg);
}
};
+ if let Some((sp, msg)) = secondary_span {
+ if swap_secondary_and_primary {
+ let terr = if let Some(infer::ValuePairs::Terms(infer::ExpectedFound {
+ expected,
+ ..
+ })) = values
+ {
+ format!("expected this to be `{}`", expected)
+ } else {
+ terr.to_string()
+ };
+ label_or_note(sp, &terr);
+ label_or_note(span, &msg);
+ } else {
+ label_or_note(span, &terr.to_string());
+ label_or_note(sp, &msg);
+ }
+ } else {
+ label_or_note(span, &terr.to_string());
+ }
+
if let Some((expected, found)) = expected_found {
let (expected_label, found_label, exp_found) = match exp_found {
Mismatch::Variable(ef) => (
);
}
}
- TypeError::ObjectUnsafeCoercion(_) => {
- diag.note_unsuccessful_coercion(found, expected);
- }
_ => {
debug!(
"note_type_err: exp_found={:?}, expected={:?} found={:?}",
TypeError::IntrinsicCast => {
Error0308("cannot coerce intrinsics to function pointers")
}
- TypeError::ObjectUnsafeCoercion(did) => Error0038(did),
_ => Error0308("mismatched types"),
},
}
CyclicConst(ty::Const<'tcx>),
ProjectionMismatched(ExpectedFound<DefId>),
ExistentialMismatch(ExpectedFound<&'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>>),
- ObjectUnsafeCoercion(DefId),
ConstMismatch(ExpectedFound<ty::Const<'tcx>>),
IntrinsicCast,
f,
"cannot coerce functions with `#[target_feature]` to safe function pointers"
),
- ObjectUnsafeCoercion(_) => write!(f, "coercion to object-unsafe trait object"),
}
}
}
| ProjectionMismatched(_)
| ExistentialMismatch(_)
| ConstMismatch(_)
- | IntrinsicCast
- | ObjectUnsafeCoercion(_) => true,
+ | IntrinsicCast => true,
}
}
}