use rustc_ast as ast;
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::stack::ensure_sufficient_stack;
+use rustc_errors::Diagnostic;
use rustc_errors::ErrorReported;
use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticBuilder, DiagnosticId};
use rustc_hir as hir;
&self,
expr: &'tcx hir::Expr<'tcx>,
expected: Ty<'tcx>,
- extend_err: impl Fn(&mut DiagnosticBuilder<'_>),
+ extend_err: impl Fn(&mut Diagnostic),
) -> Ty<'tcx> {
self.check_expr_meets_expectation_or_error(expr, ExpectHasType(expected), extend_err)
}
&self,
expr: &'tcx hir::Expr<'tcx>,
expected: Expectation<'tcx>,
- extend_err: impl Fn(&mut DiagnosticBuilder<'_>),
+ extend_err: impl Fn(&mut Diagnostic),
) -> Ty<'tcx> {
let expected_ty = expected.to_option(&self).unwrap_or(self.tcx.types.bool);
let mut ty = self.check_expr_with_expectation(expr, expected);
ExprKind::Box(subexpr) => self.check_expr_box(subexpr, expected),
ExprKind::Lit(ref lit) => self.check_lit(&lit, expected),
ExprKind::Binary(op, lhs, rhs) => self.check_binop(expr, op, lhs, rhs),
- ExprKind::Assign(lhs, rhs, ref span) => {
+ ExprKind::Assign(lhs, rhs, span) => {
self.check_expr_assign(expr, expected, lhs, rhs, span)
}
ExprKind::AssignOp(op, lhs, rhs) => self.check_binop_assign(expr, op, lhs, rhs),
.map_or(false, |x| x.iter().any(|adj| matches!(adj.kind, Adjust::Deref(_))))
});
if !is_named {
- self.tcx.sess.emit_err(AddressOfTemporaryTaken { span: oprnd.span })
+ self.tcx.sess.emit_err(AddressOfTemporaryTaken { span: oprnd.span });
}
}
expected: Expectation<'tcx>,
lhs: &'tcx hir::Expr<'tcx>,
rhs: &'tcx hir::Expr<'tcx>,
- span: &Span,
+ span: Span,
) -> Ty<'tcx> {
let expected_ty = expected.coercion_target_type(self, expr.span);
if expected_ty == self.tcx.types.bool {
}
if eq {
err.span_suggestion_verbose(
- *span,
+ span,
"you might have meant to compare for equality",
"==".to_string(),
applicability,
return self.tcx.ty_error();
}
- self.check_lhs_assignable(lhs, "E0070", *span);
+ self.check_lhs_assignable(lhs, "E0070", span);
let lhs_ty = self.check_expr_with_needs(&lhs, Needs::MutPlace);
let rhs_ty = self.check_expr_coercable_to_type(&rhs, lhs_ty, Some(lhs));
self.register_predicates(obligations)
}
// FIXME: Need better diagnostics for `FieldMisMatch` error
- Err(_) => self
- .report_mismatched_types(
+ Err(_) => {
+ self.report_mismatched_types(
&cause,
target_ty,
fru_ty,
FieldMisMatch(variant.name, ident.name),
)
- .emit(),
+ .emit();
+ }
}
}
fru_ty
.collect()
}
_ => {
- return self
- .report_mismatched_types(
- &self.misc(base_expr.span),
- adt_ty,
- base_ty,
- Sorts(ExpectedFound::new(true, adt_ty, base_ty)),
- )
- .emit();
+ self.report_mismatched_types(
+ &self.misc(base_expr.span),
+ adt_ty,
+ base_ty,
+ Sorts(ExpectedFound::new(true, adt_ty, base_ty)),
+ )
+ .emit();
+ return;
}
}
}
_ => {
- return self
- .tcx
+ self.tcx
.sess
.emit_err(FunctionalRecordUpdateOnNonStruct { span: base_expr.span });
+ return;
}
}
} else {
})
.collect(),
_ => {
- return self
- .tcx
+ self.tcx
.sess
.emit_err(FunctionalRecordUpdateOnNonStruct { span: base_expr.span });
+ return;
}
}
};
fn suggest_await_on_field_access(
&self,
- err: &mut DiagnosticBuilder<'_>,
+ err: &mut Diagnostic,
field_ident: Ident,
base: &'tcx hir::Expr<'tcx>,
ty: Ty<'tcx>,
err.emit();
}
- fn point_at_param_definition(&self, err: &mut DiagnosticBuilder<'_>, param: ty::ParamTy) {
+ fn point_at_param_definition(&self, err: &mut Diagnostic, param: ty::ParamTy) {
let generics = self.tcx.generics_of(self.body_id.owner.to_def_id());
let generic_param = generics.type_param(¶m, self.tcx);
if let ty::GenericParamDefKind::Type { synthetic: true, .. } = generic_param.kind {
fn suggest_fields_on_recordish(
&self,
- err: &mut DiagnosticBuilder<'_>,
+ err: &mut Diagnostic,
def: &'tcx ty::AdtDef,
field: Ident,
access_span: Span,
fn maybe_suggest_array_indexing(
&self,
- err: &mut DiagnosticBuilder<'_>,
+ err: &mut Diagnostic,
expr: &hir::Expr<'_>,
base: &hir::Expr<'_>,
field: Ident,
fn suggest_first_deref_field(
&self,
- err: &mut DiagnosticBuilder<'_>,
+ err: &mut Diagnostic,
expr: &hir::Expr<'_>,
base: &hir::Expr<'_>,
field: Ident,
field: Ident,
expr_t: Ty<'tcx>,
id: HirId,
- ) -> DiagnosticBuilder<'_> {
+ ) -> DiagnosticBuilder<'_, ErrorReported> {
let span = field.span;
debug!("no_such_field_err(span: {:?}, field: {:?}, expr_t: {:?})", span, field, expr_t);