}
}
- pub fn report_and_explain_type_error_with_code(&self,
- origin: TypeOrigin,
- values: Option<ValuePairs<'tcx>>,
- terr: &TypeError<'tcx>,
- message: &str,
- code: &str)
- -> DiagnosticBuilder<'tcx>
+ pub fn note_type_err(&self,
+ diag: &mut DiagnosticBuilder<'tcx>,
+ origin: TypeOrigin,
+ values: Option<ValuePairs<'tcx>>,
+ terr: &TypeError<'tcx>)
{
let expected_found = match values {
None => None,
Some(values) => match self.values_str(&values) {
Some((expected, found)) => Some((expected, found)),
- None => return self.tcx.sess.diagnostic().struct_dummy() /* derived error */
+ None => {
+ // Derived error. Cancel the emitter.
+ self.tcx.sess.diagnostic().cancel(diag);
+ return
+ }
}
};
let span = origin.span();
- let mut err = self.tcx.sess.struct_span_err_with_code(
- span, message, code);
let mut is_simple_error = false;
};
if !is_simple_error || check_old_school() {
- err.note_expected_found(&"type", &expected, &found);
+ diag.note_expected_found(&"type", &expected, &found);
}
}
if !is_simple_error && check_old_school() {
- err.span_note(span, &format!("{}", terr));
+ diag.span_note(span, &format!("{}", terr));
} else {
- err.span_label(span, &terr);
+ diag.span_label(span, &terr);
}
- self.note_error_origin(&mut err, &origin);
- self.check_and_note_conflicting_crates(&mut err, terr, span);
- self.tcx.note_and_explain_type_err(&mut err, terr, span);
-
- err
+ self.note_error_origin(diag, &origin);
+ self.check_and_note_conflicting_crates(diag, terr, span);
+ self.tcx.note_and_explain_type_err(diag, terr, span);
}
pub fn report_and_explain_type_error(&self,
-> DiagnosticBuilder<'tcx>
{
// FIXME: do we want to use a different error code for each origin?
- let failure_str = trace.origin.as_failure_str();
- type_err!(self, trace.origin, Some(trace.values), terr, E0308, "{}", failure_str)
+ let mut diag = struct_span_err!(
+ self.tcx.sess, trace.origin.span(), E0308,
+ "{}", trace.origin.as_failure_str()
+ );
+ self.note_type_err(&mut diag, trace.origin, Some(trace.values), terr);
+ diag
}
/// Returns a string of the form "expected `{}`, found `{}`".
debug!("sub_types failed: impl ty {:?}, trait ty {:?}",
impl_fty,
trait_fty);
- let values = Some(infer::ValuePairs::Types(ExpectedFound {
- expected: trait_fty,
- found: impl_fty
- }));
- type_err!(infcx, origin, values, terr, E0053,
- "method `{}` has an incompatible type for trait",
- trait_m.name).emit();
+
+ let mut diag = struct_span_err!(
+ tcx.sess, origin.span(), E0053,
+ "method `{}` has an incompatible type for trait", trait_m.name
+ );
+ infcx.note_type_err(
+ &mut diag, origin,
+ Some(infer::ValuePairs::Types(ExpectedFound {
+ expected: trait_fty,
+ found: impl_fty
+ })), &terr
+ );
+ diag.emit();
return
}
debug!("checking associated const for compatibility: impl ty {:?}, trait ty {:?}",
impl_ty,
trait_ty);
- let values = Some(infer::ValuePairs::Types(ExpectedFound {
- expected: trait_ty,
- found: impl_ty
- }));
- type_err!(infcx, origin, values, terr, E0326,
- "implemented const `{}` has an incompatible type for \
- trait", trait_c.name).emit();
+ let mut diag = struct_span_err!(
+ tcx.sess, origin.span(), E0326,
+ "implemented const `{}` has an incompatible type for trait",
+ trait_c.name
+ );
+ infcx.note_type_err(
+ &mut diag, origin,
+ Some(infer::ValuePairs::Types(ExpectedFound {
+ expected: trait_ty,
+ found: impl_ty
+ })), &terr
+ );
+ diag.emit();
}
});
}