OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Replace some trivial struct_span_err!s in typeck.

Browse Source
This commit is contained in:
jumbatm 2020-08-27 20:09:22 +10:00
parent 93eaf15646
commit 57edf88b40
10 changed files with 255 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
compiler/rustc_typeck/Cargo.toml
View File

@ -11,6 +11,7 @@ doctest = false
[dependencies]
rustc_arena = { path = "../rustc_arena" }
tracing = "0.1"
rustc_macros = { path = "../rustc_macros" }
rustc_middle = { path = "../rustc_middle" }
rustc_attr = { path = "../rustc_attr" }
rustc_data_structures = { path = "../rustc_data_structures" }

9
compiler/rustc_typeck/src/astconv/generics.rs
View File

@ -1,6 +1,7 @@
use crate::astconv::{
AstConv, ExplicitLateBound, GenericArgCountMismatch, GenericArgCountResult, GenericArgPosition,
};
use crate::errors::AssocTypeBindingNotAllowed;
use rustc_ast::ast::ParamKindOrd;
use rustc_errors::{pluralize, struct_span_err, DiagnosticId, ErrorReported};
use rustc_hir as hir;
@ -544,13 +545,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
/// Emits an error regarding forbidden type binding associations
pub fn prohibit_assoc_ty_binding(tcx: TyCtxt<'_>, span: Span) {
let mut err = struct_span_err!(
tcx.sess,
span,
E0229,
"associated type bindings are not allowed here"
);
err.span_label(span, "associated type not allowed here").emit();
tcx.sess.emit_err(AssocTypeBindingNotAllowed { span });
}
/// Prohibits explicit lifetime arguments if late-bound lifetime parameters

57
compiler/rustc_typeck/src/astconv/mod.rs
View File

@ -7,6 +7,10 @@ mod generics;
use crate::bounds::Bounds;
use crate::collect::PlaceholderHirTyCollector;
use crate::errors::{
AmbiguousLifetimeBound, MultipleRelaxedDefaultBounds, TraitObjectDeclaredWithNoTraits,
TypeofReservedKeywordUsed, ValueOfAssociatedStructAlreadySpecified,
};
use crate::middle::resolve_lifetime as rl;
use crate::require_c_abi_if_c_variadic;
use rustc_ast::util::lev_distance::find_best_match_for_name;
@ -684,14 +688,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
if unbound.is_none() {
unbound = Some(&ptr.trait_ref);
} else {
struct_span_err!(
tcx.sess,
span,
E0203,
"type parameter has more than one relaxed default \
bound, only one is supported"
)
.emit();
tcx.sess.emit_err(MultipleRelaxedDefaultBounds { span });
}
}
}
@ -927,18 +924,12 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
dup_bindings
.entry(assoc_ty.def_id)
.and_modify(|prev_span| {
struct_span_err!(
self.tcx().sess,
binding.span,
E0719,
"the value of the associated type `{}` (from trait `{}`) \
is already specified",
binding.item_name,
tcx.def_path_str(assoc_ty.container.id())
)
.span_label(binding.span, "re-bound here")
.span_label(*prev_span, format!("`{}` bound here first", binding.item_name))
.emit();
self.tcx().sess.emit_err(ValueOfAssociatedStructAlreadySpecified {
span: binding.span,
prev_span: *prev_span,
item_name: binding.item_name,
def_path: tcx.def_path_str(assoc_ty.container.id()),
});
})
.or_insert(binding.span);
}
@ -1051,13 +1042,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
}
if regular_traits.is_empty() && auto_traits.is_empty() {
struct_span_err!(
tcx.sess,
span,
E0224,
"at least one trait is required for an object type"
)
.emit();
tcx.sess.emit_err(TraitObjectDeclaredWithNoTraits { span });
return tcx.ty_error();
}
@ -2059,15 +2044,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
self.normalize_ty(ast_ty.span, array_ty)
}
hir::TyKind::Typeof(ref _e) => {
struct_span_err!(
tcx.sess,
ast_ty.span,
E0516,
"`typeof` is a reserved keyword but unimplemented"
)
.span_label(ast_ty.span, "reserved keyword")
.emit();
tcx.sess.emit_err(TypeofReservedKeywordUsed { span: ast_ty.span });
tcx.ty_error()
}
hir::TyKind::Infer => {
@ -2283,13 +2260,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
// error.
let r = derived_region_bounds[0];
if derived_region_bounds[1..].iter().any(|r1| r != *r1) {
struct_span_err!(
tcx.sess,
span,
E0227,
"ambiguous lifetime bound, explicit lifetime bound required"
)
.emit();
tcx.sess.emit_err(AmbiguousLifetimeBound { span });
}
Some(r)
}

29
compiler/rustc_typeck/src/check/compare_method.rs
View File

@ -1,3 +1,4 @@
use crate::errors::LifetimesOrBoundsMismatchOnTrait;
use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticId, ErrorReported};
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res};
@ -366,24 +367,18 @@ fn check_region_bounds_on_impl_item<'tcx>(
let item_kind = assoc_item_kind_str(impl_m);
let def_span = tcx.sess.source_map().guess_head_span(span);
let span = tcx.hir().get_generics(impl_m.def_id).map(|g| g.span).unwrap_or(def_span);
let mut err = struct_span_err!(
tcx.sess,
span,
E0195,
"lifetime parameters or bounds on {} `{}` do not match the trait declaration",
item_kind,
impl_m.ident,
);
err.span_label(span, &format!("lifetimes do not match {} in trait", item_kind));
if let Some(sp) = tcx.hir().span_if_local(trait_m.def_id) {
let generics_span = if let Some(sp) = tcx.hir().span_if_local(trait_m.def_id) {
let def_sp = tcx.sess.source_map().guess_head_span(sp);
let sp = tcx.hir().get_generics(trait_m.def_id).map(|g| g.span).unwrap_or(def_sp);
err.span_label(
sp,
&format!("lifetimes in impl do not match this {} in trait", item_kind),
);
}
err.emit();
Some(tcx.hir().get_generics(trait_m.def_id).map(|g| g.span).unwrap_or(def_sp))
} else {
None
};
tcx.sess.emit_err(LifetimesOrBoundsMismatchOnTrait {
span,
item_kind,
ident: impl_m.ident,
generics_span,
});
return Err(ErrorReported);
}

69
compiler/rustc_typeck/src/check/expr.rs
View File

@ -14,8 +14,13 @@ use crate::check::Expectation::{self, ExpectCastableToType, ExpectHasType, NoExp
use crate::check::FnCtxt;
use crate::check::Needs;
use crate::check::TupleArgumentsFlag::DontTupleArguments;
use crate::errors::{
FieldMultiplySpecifiedInInitializer, FunctionalRecordUpdateOnNonStruct,
YieldExprOutsideOfGenerator,
};
use crate::type_error_struct;
use crate::errors::{AddressOfTemporaryTaken, ReturnStmtOutsideOfFnBody, StructExprNonExhaustive};
use rustc_ast as ast;
use rustc_ast::util::lev_distance::find_best_match_for_name;
use rustc_data_structures::fx::FxHashMap;
@ -439,14 +444,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
})
});
if !is_named {
struct_span_err!(
self.tcx.sess,
oprnd.span,
E0745,
"cannot take address of a temporary"
)
.span_label(oprnd.span, "temporary value")
.emit();
self.tcx.sess.emit_err(AddressOfTemporaryTaken { span: oprnd.span })
}
}
@ -665,13 +663,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
expr: &'tcx hir::Expr<'tcx>,
) -> Ty<'tcx> {
if self.ret_coercion.is_none() {
struct_span_err!(
self.tcx.sess,
expr.span,
E0572,
"return statement outside of function body",
)
.emit();
self.tcx.sess.emit_err(ReturnStmtOutsideOfFnBody { span: expr.span });
} else if let Some(ref e) = expr_opt {
if self.ret_coercion_span.borrow().is_none() {
*self.ret_coercion_span.borrow_mut() = Some(e.span);
@ -740,6 +732,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
expr_span: &Span,
) {
if !lhs.is_syntactic_place_expr() {
// FIXME: Make this use SessionDiagnostic once error codes can be dynamically set.
let mut err = self.tcx.sess.struct_span_err_with_code(
*expr_span,
"invalid left-hand side of assignment",
@ -1120,14 +1113,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Prohibit struct expressions when non-exhaustive flag is set.
let adt = adt_ty.ty_adt_def().expect("`check_struct_path` returned non-ADT type");
if !adt.did.is_local() && variant.is_field_list_non_exhaustive() {
struct_span_err!(
self.tcx.sess,
expr.span,
E0639,
"cannot create non-exhaustive {} using struct expression",
adt.variant_descr()
)
.emit();
self.tcx
.sess
.emit_err(StructExprNonExhaustive { span: expr.span, what: adt.variant_descr() });
}
let error_happened = self.check_expr_struct_fields(
@ -1165,13 +1153,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
.insert(expr.hir_id, fru_field_types);
}
_ => {
struct_span_err!(
self.tcx.sess,
base_expr.span,
E0436,
"functional record update syntax requires a struct"
)
.emit();
self.tcx
.sess
.emit_err(FunctionalRecordUpdateOnNonStruct { span: base_expr.span });
}
}
}
@ -1234,18 +1218,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
} else {
error_happened = true;
if let Some(prev_span) = seen_fields.get(&ident) {
let mut err = struct_span_err!(
self.tcx.sess,
field.ident.span,
E0062,
"field `{}` specified more than once",
ident
);
err.span_label(field.ident.span, "used more than once");
err.span_label(*prev_span, format!("first use of `{}`", ident));
err.emit();
tcx.sess.emit_err(FieldMultiplySpecifiedInInitializer {
span: field.ident.span,
prev_span: *prev_span,
ident,
});
} else {
self.report_unknown_field(adt_ty, variant, field, ast_fields, kind_name, span);
}
@ -1876,13 +1853,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
self.tcx.mk_unit()
}
_ => {
struct_span_err!(
self.tcx.sess,
expr.span,
E0627,
"yield expression outside of generator literal"
)
.emit();
self.tcx.sess.emit_err(YieldExprOutsideOfGenerator { span: expr.span });
self.tcx.mk_unit()
}
}

47
compiler/rustc_typeck/src/check/intrinsic.rs
View File

@ -1,6 +1,10 @@
//! Type-checking for the rust-intrinsic and platform-intrinsic
//! intrinsics that the compiler exposes.
use crate::errors::{
SimdShuffleMissingLength, UnrecognizedAtomicOperation, UnrecognizedIntrinsicFunction,
WrongNumberOfTypeArgumentsToInstrinsic,
};
use crate::require_same_types;
use rustc_errors::struct_span_err;
@ -41,17 +45,11 @@ fn equate_intrinsic_type<'tcx>(
_ => bug!(),
};
struct_span_err!(
tcx.sess,
tcx.sess.emit_err(WrongNumberOfTypeArgumentsToInstrinsic {
span,
E0094,
"intrinsic has wrong number of type \
parameters: found {}, expected {}",
i_n_tps,
n_tps
)
.span_label(span, format!("expected {} type parameter", n_tps))
.emit();
found: i_n_tps,
expected: n_tps,
});
return;
}
@ -146,15 +144,7 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
| "umin" => (1, vec![tcx.mk_mut_ptr(param(0)), param(0)], param(0)),
"fence" | "singlethreadfence" => (0, Vec::new(), tcx.mk_unit()),
op => {
struct_span_err!(
tcx.sess,
it.span,
E0092,
"unrecognized atomic operation function: `{}`",
op
)
.span_label(it.span, "unrecognized atomic operation")
.emit();
tcx.sess.emit_err(UnrecognizedAtomicOperation { span: it.span, op });
return;
}
};
@ -380,15 +370,7 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
sym::nontemporal_store => (1, vec![tcx.mk_mut_ptr(param(0)), param(0)], tcx.mk_unit()),
other => {
struct_span_err!(
tcx.sess,
it.span,
E0093,
"unrecognized intrinsic function: `{}`",
other,
)
.span_label(it.span, "unrecognized intrinsic")
.emit();
tcx.sess.emit_err(UnrecognizedIntrinsicFunction { span: it.span, name: other });
return;
}
};
@ -468,14 +450,7 @@ pub fn check_platform_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>)
(2, params, param(1))
}
Err(_) => {
struct_span_err!(
tcx.sess,
it.span,
E0439,
"invalid `simd_shuffle`, needs length: `{}`",
name
)
.emit();
tcx.sess.emit_err(SimdShuffleMissingLength { span: it.span, name });
return;
}
}

11
compiler/rustc_typeck/src/check/method/probe.rs
View File

@ -4,6 +4,7 @@ use super::NoMatchData;
use super::{CandidateSource, ImplSource, TraitSource};
use crate::check::FnCtxt;
use crate::errors::MethodCallOnUnknownType;
use crate::hir::def::DefKind;
use crate::hir::def_id::DefId;
@ -11,7 +12,6 @@ use rustc_ast as ast;
use rustc_ast::util::lev_distance::{find_best_match_for_name, lev_distance};
use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::sync::Lrc;
use rustc_errors::struct_span_err;
use rustc_hir as hir;
use rustc_hir::def::Namespace;
use rustc_infer::infer::canonical::OriginalQueryValues;
@ -376,14 +376,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// so we do a future-compat lint here for the 2015 edition
// (see https://github.com/rust-lang/rust/issues/46906)
if self.tcx.sess.rust_2018() {
struct_span_err!(
self.tcx.sess,
span,
E0699,
"the type of this value must be known to call a method on a raw pointer on \
it"
)
.emit();
self.tcx.sess.emit_err(MethodCallOnUnknownType { span });
} else {
self.tcx.struct_span_lint_hir(
lint::builtin::TYVAR_BEHIND_RAW_POINTER,

29
compiler/rustc_typeck/src/coherence/builtin.rs
View File

@ -1,6 +1,7 @@
//! Check properties that are required by built-in traits and set
//! up data structures required by type-checking/codegen.
use crate::errors::{CopyImplOnNonAdt, CopyImplOnTypeWithDtor, DropImplOnWrongItem};
use rustc_errors::struct_span_err;
use rustc_hir as hir;
use rustc_hir::def_id::{DefId, LocalDefId};
@ -58,14 +59,7 @@ fn visit_implementation_of_drop(tcx: TyCtxt<'_>, impl_did: LocalDefId) {
_ => bug!("expected Drop impl item"),
};
struct_span_err!(
tcx.sess,
sp,
E0120,
"the `Drop` trait may only be implemented for structs, enums, and unions",
)
.span_label(sp, "must be a struct, enum, or union")
.emit();
tcx.sess.emit_err(DropImplOnWrongItem { span: sp });
}
fn visit_implementation_of_copy(tcx: TyCtxt<'_>, impl_did: LocalDefId) {
@ -108,25 +102,10 @@ fn visit_implementation_of_copy(tcx: TyCtxt<'_>, impl_did: LocalDefId) {
let span =
if let ItemKind::Impl { self_ty, .. } = item.kind { self_ty.span } else { span };
struct_span_err!(
tcx.sess,
span,
E0206,
"the trait `Copy` may not be implemented for this type"
)
.span_label(span, "type is not a structure or enumeration")
.emit();
tcx.sess.emit_err(CopyImplOnNonAdt { span });
}
Err(CopyImplementationError::HasDestructor) => {
struct_span_err!(
tcx.sess,
span,
E0184,
"the trait `Copy` may not be implemented for this type; the \
type has a destructor"
)
.span_label(span, "Copy not allowed on types with destructors")
.emit();
tcx.sess.emit_err(CopyImplOnTypeWithDtor { span });
}
}
}

11
compiler/rustc_typeck/src/collect/type_of.rs
View File

@ -1,5 +1,6 @@
use crate::errors::AssocTypeOnInherentImpl;
use rustc_data_structures::fx::FxHashSet;
use rustc_errors::{struct_span_err, Applicability, ErrorReported, StashKey};
use rustc_errors::{Applicability, ErrorReported, StashKey};
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res};
use rustc_hir::def_id::{DefId, LocalDefId};
@ -627,11 +628,5 @@ fn infer_placeholder_type(
}
fn report_assoc_ty_on_inherent_impl(tcx: TyCtxt<'_>, span: Span) {
struct_span_err!(
tcx.sess,
span,
E0202,
"associated types are not yet supported in inherent impls (see #8995)"
)
.emit();
tcx.sess.emit_err(AssocTypeOnInherentImpl { span });
}

187
compiler/rustc_typeck/src/errors.rs
View File

@ -1,6 +1,66 @@
//! Errors emitted by typeck.
use rustc_macros::SessionDiagnostic;
use rustc_span::{symbol::Ident, Span };
use rustc_span::{symbol::Ident, Span, Symbol};
#[derive(SessionDiagnostic)]
#[error = "E0062"]
pub struct FieldMultiplySpecifiedInInitializer {
#[message = "field `{ident}` specified more than once"]
#[label = "used more than once"]
pub span: Span,
#[label = "first use of `{ident}`"]
pub prev_span: Span,
pub ident: Ident,
}
#[derive(SessionDiagnostic)]
#[error = "E0092"]
pub struct UnrecognizedAtomicOperation<'a> {
#[message = "unrecognized atomic operation function: `{op}`"]
#[label = "unrecognized atomic operation"]
pub span: Span,
pub op: &'a str,
}
#[derive(SessionDiagnostic)]
#[error = "E0094"]
pub struct WrongNumberOfTypeArgumentsToInstrinsic {
#[message = "intrinsic has wrong number of type \
parameters: found {found}, expected {expected}"]
#[label = "expected {expected} type parameter"]
pub span: Span,
pub found: usize,
pub expected: usize,
}
#[derive(SessionDiagnostic)]
#[error = "E0093"]
pub struct UnrecognizedIntrinsicFunction {
#[message = "unrecognized intrinsic function: `{name}`"]
#[label = "unrecognized intrinsic"]
pub span: Span,
pub name: Symbol,
}
#[derive(SessionDiagnostic)]
#[error = "E0195"]
pub struct LifetimesOrBoundsMismatchOnTrait {
#[message = "lifetime parameters or bounds on {item_kind} `{ident}` do not match the trait declaration"]
#[label = "lifetimes do not match {item_kind} in trait"]
pub span: Span,
#[label = "lifetimes in impl do not match this {item_kind} in trait"]
pub generics_span: Option<Span>,
pub item_kind: &'static str,
pub ident: Ident,
}
#[derive(SessionDiagnostic)]
#[error = "E0120"]
pub struct DropImplOnWrongItem {
#[message = "the `Drop` trait may only be implemented for structs, enums, and unions"]
#[label = "must be a struct, enum, or union"]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error = "E0124"]
@ -12,3 +72,128 @@ pub struct FieldAlreadyDeclared {
#[label = "`{field_name}` first declared here"]
pub prev_span: Span,
}
#[derive(SessionDiagnostic)]
#[error = "E0184"]
pub struct CopyImplOnTypeWithDtor {
#[message = "the trait `Copy` may not be implemented for this type; the \
type has a destructor"]
#[label = "Copy not allowed on types with destructors"]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error = "E0202"]
pub struct AssocTypeOnInherentImpl {
#[message = "associated types are not yet supported in inherent impls (see #8995)"]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error = "E0203"]
pub struct MultipleRelaxedDefaultBounds {
#[message = "type parameter has more than one relaxed default bound, only one is supported"]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error = "E0206"]
pub struct CopyImplOnNonAdt {
#[message = "the trait `Copy` may not be implemented for this type"]
#[label = "type is not a structure or enumeration"]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error = "E0224"]
pub struct TraitObjectDeclaredWithNoTraits {
#[message = "at least one trait is required for an object type"]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error = "E0227"]
pub struct AmbiguousLifetimeBound {
#[message = "ambiguous lifetime bound, explicit lifetime bound required"]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error = "E0229"]
pub struct AssocTypeBindingNotAllowed {
#[message = "associated type bindings are not allowed here"]
#[label = "associated type not allowed here"]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error = "E0439"]
pub struct SimdShuffleMissingLength {
#[message = "invalid `simd_shuffle`, needs length: `{name}`"]
pub span: Span,
pub name: Symbol,
}
#[derive(SessionDiagnostic)]
#[error = "E0436"]
pub struct FunctionalRecordUpdateOnNonStruct {
#[message = "functional record update syntax requires a struct"]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error = "E0516"]
pub struct TypeofReservedKeywordUsed {
#[message = "`typeof` is a reserved keyword but unimplemented"]
#[label = "reserved keyword"]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error = "E0572"]
pub struct ReturnStmtOutsideOfFnBody {
#[message = "return statement outside of function body"]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error = "E0627"]
pub struct YieldExprOutsideOfGenerator {
#[message = "yield expression outside of generator literal"]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error = "E0639"]
pub struct StructExprNonExhaustive {
#[message = "cannot create non-exhaustive {what} using struct expression"]
pub span: Span,
pub what: &'static str,
}
#[derive(SessionDiagnostic)]
#[error = "E0699"]
pub struct MethodCallOnUnknownType {
#[message = "the type of this value must be known to call a method on a raw pointer on it"]
pub span: Span,
}
#[derive(SessionDiagnostic)]
#[error = "E0719"]
pub struct ValueOfAssociatedStructAlreadySpecified {
#[message = "the value of the associated type `{item_name}` (from trait `{def_path}`) is already specified"]
#[label = "re-bound here"]
pub span: Span,
#[label = "`{item_name}` bound here first"]
pub prev_span: Span,
pub item_name: Ident,
pub def_path: String,
}
#[derive(SessionDiagnostic)]
#[error = "E0745"]
pub struct AddressOfTemporaryTaken {
#[message = "cannot take address of a temporary"]
#[label = "temporary value"]
pub span: Span,
}