From 246a80c32cca2c5e07f205cbcd327c3b2d9b4db1 Mon Sep 17 00:00:00 2001
From: Nikolai Vazquez <hello@nikolaivazquez.com>
Date: Tue, 7 Jun 2022 14:53:59 -0400
Subject: [PATCH 1/8] Inline Windows `OsStrExt::encode_wide`
User crates currently produce much more code than necessary because the
optimizer fails to make assumptions about this method.
---
library/std/src/os/windows/ffi.rs | 1 +
1 file changed, 1 insertion(+)
diff --git a/library/std/src/os/windows/ffi.rs b/library/std/src/os/windows/ffi.rs
index a9493a94cac26..96bab59d3f8d7 100644
--- a/library/std/src/os/windows/ffi.rs
+++ b/library/std/src/os/windows/ffi.rs
@@ -129,6 +129,7 @@ pub trait OsStrExt: Sealed {
#[stable(feature = "rust1", since = "1.0.0")]
impl OsStrExt for OsStr {
+ #[inline]
fn encode_wide(&self) -> EncodeWide<'_> {
self.as_inner().inner.encode_wide()
}
From da11ff348ac785d10c0a2b7834dc196cd218a247 Mon Sep 17 00:00:00 2001
From: Nick Cameron <nrc@ncameron.org>
Date: Mon, 13 Jun 2022 09:29:55 +0100
Subject: [PATCH 2/8] core::any: replace some unstable generic types with impl
Trait
Signed-off-by: Nick Cameron <nrc@ncameron.org>
---
library/core/src/any.rs | 35 +++++++++++++++--------------------
1 file changed, 15 insertions(+), 20 deletions(-)
diff --git a/library/core/src/any.rs b/library/core/src/any.rs
index 866419ac34b11..f20c497a183b2 100644
--- a/library/core/src/any.rs
+++ b/library/core/src/any.rs
@@ -125,7 +125,7 @@
//! impl dyn MyTrait + '_ {
//! /// Get a reference to a field of the implementing struct.
//! pub fn get_context_by_ref<T: ?Sized + 'static>(&self) -> Option<&T> {
-//! request_ref::<T, _>(self)
+//! request_ref::<T>(self)
//! }
//! }
//!
@@ -799,7 +799,7 @@ pub trait Provider {
/// impl Provider for SomeConcreteType {
/// fn provide<'a>(&'a self, demand: &mut Demand<'a>) {
/// demand.provide_ref::<str>(&self.field)
- /// .provide_value::<i32, _>(|| self.num_field);
+ /// .provide_value::<i32>(|| self.num_field);
/// }
/// }
/// ```
@@ -817,17 +817,16 @@ pub trait Provider {
/// # #![feature(provide_any)]
/// use std::any::{Provider, request_value};
///
-/// fn get_string<P: Provider>(provider: &P) -> String {
-/// request_value::<String, _>(provider).unwrap()
+/// fn get_string(provider: &impl Provider) -> String {
+/// request_value::<String>(provider).unwrap()
/// }
/// ```
#[unstable(feature = "provide_any", issue = "96024")]
-pub fn request_value<'a, T, P>(provider: &'a P) -> Option<T>
+pub fn request_value<'a, T>(provider: &'a (impl Provider + ?Sized)) -> Option<T>
where
T: 'static,
- P: Provider + ?Sized,
{
- request_by_type_tag::<'a, tags::Value<T>, P>(provider)
+ request_by_type_tag::<'a, tags::Value<T>>(provider)
}
/// Request a reference from the `Provider`.
@@ -840,24 +839,22 @@ where
/// # #![feature(provide_any)]
/// use std::any::{Provider, request_ref};
///
-/// fn get_str<P: Provider>(provider: &P) -> &str {
-/// request_ref::<str, _>(provider).unwrap()
+/// fn get_str(provider: &impl Provider) -> &str {
+/// request_ref::<str>(provider).unwrap()
/// }
/// ```
#[unstable(feature = "provide_any", issue = "96024")]
-pub fn request_ref<'a, T, P>(provider: &'a P) -> Option<&'a T>
+pub fn request_ref<'a, T>(provider: &'a (impl Provider + ?Sized)) -> Option<&'a T>
where
T: 'static + ?Sized,
- P: Provider + ?Sized,
{
- request_by_type_tag::<'a, tags::Ref<tags::MaybeSizedValue<T>>, P>(provider)
+ request_by_type_tag::<'a, tags::Ref<tags::MaybeSizedValue<T>>>(provider)
}
/// Request a specific value by tag from the `Provider`.
-fn request_by_type_tag<'a, I, P>(provider: &'a P) -> Option<I::Reified>
+fn request_by_type_tag<'a, I>(provider: &'a (impl Provider + ?Sized)) -> Option<I::Reified>
where
I: tags::Type<'a>,
- P: Provider + ?Sized,
{
let mut tagged = TaggedOption::<'a, I>(None);
provider.provide(tagged.as_demand());
@@ -896,17 +893,16 @@ impl<'a> Demand<'a> {
///
/// impl Provider for SomeConcreteType {
/// fn provide<'a>(&'a self, demand: &mut Demand<'a>) {
- /// demand.provide_value::<String, _>(|| self.field.clone());
+ /// demand.provide_value::<String>(|| self.field.clone());
/// }
/// }
/// ```
#[unstable(feature = "provide_any", issue = "96024")]
- pub fn provide_value<T, F>(&mut self, fulfil: F) -> &mut Self
+ pub fn provide_value<T>(&mut self, fulfil: impl FnOnce() -> T) -> &mut Self
where
T: 'static,
- F: FnOnce() -> T,
{
- self.provide_with::<tags::Value<T>, F>(fulfil)
+ self.provide_with::<tags::Value<T>>(fulfil)
}
/// Provide a reference, note that the referee type must be bounded by `'static`,
@@ -944,10 +940,9 @@ impl<'a> Demand<'a> {
}
/// Provide a value with the given `Type` tag, using a closure to prevent unnecessary work.
- fn provide_with<I, F>(&mut self, fulfil: F) -> &mut Self
+ fn provide_with<I>(&mut self, fulfil: impl FnOnce() -> I::Reified) -> &mut Self
where
I: tags::Type<'a>,
- F: FnOnce() -> I::Reified,
{
if let Some(res @ TaggedOption(None)) = self.0.downcast_mut::<I>() {
res.0 = Some(fulfil());
From a1634642e079d4517e31a75fa002ea0496148cda Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 4 Jul 2022 23:44:41 +0000
Subject: [PATCH 3/8] Deny floats even when adt_const_params is enabled
---
.../src/transform/check_consts/qualifs.rs | 2 +-
.../src/thir/pattern/const_to_pat.rs | 57 ++++++------
.../src/traits/structural_match.rs | 22 ++++-
compiler/rustc_typeck/src/check/wfcheck.rs | 86 +++++++++++--------
.../float-generic.adt_const_params.stderr | 11 +++
src/test/ui/const-generics/float-generic.rs | 12 +++
.../float-generic.simple.stderr | 11 +++
7 files changed, 135 insertions(+), 66 deletions(-)
create mode 100644 src/test/ui/const-generics/float-generic.adt_const_params.stderr
create mode 100644 src/test/ui/const-generics/float-generic.rs
create mode 100644 src/test/ui/const-generics/float-generic.simple.stderr
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs b/compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs
index 6e5a0c813ac20..0aa7b117b89ba 100644
--- a/compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs
+++ b/compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs
@@ -226,7 +226,7 @@ impl Qualif for CustomEq {
// because that component may be part of an enum variant (e.g.,
// `Option::<NonStructuralMatchTy>::Some`), in which case some values of this type may be
// structural-match (`Option::None`).
- traits::search_for_structural_match_violation(cx.body.span, cx.tcx, ty).is_some()
+ traits::search_for_structural_match_violation(cx.body.span, cx.tcx, ty, true).is_some()
}
fn in_adt_inherently<'tcx>(
diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
index f22f3f61a01f2..e32e0b11ba497 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
@@ -120,32 +120,37 @@ impl<'a, 'tcx> ConstToPat<'a, 'tcx> {
}
fn search_for_structural_match_violation(&self, ty: Ty<'tcx>) -> Option<String> {
- traits::search_for_structural_match_violation(self.span, self.tcx(), ty).map(|non_sm_ty| {
- with_no_trimmed_paths!(match non_sm_ty.kind {
- traits::NonStructuralMatchTyKind::Adt(adt) => self.adt_derive_msg(adt),
- traits::NonStructuralMatchTyKind::Dynamic => {
- "trait objects cannot be used in patterns".to_string()
- }
- traits::NonStructuralMatchTyKind::Opaque => {
- "opaque types cannot be used in patterns".to_string()
- }
- traits::NonStructuralMatchTyKind::Closure => {
- "closures cannot be used in patterns".to_string()
- }
- traits::NonStructuralMatchTyKind::Generator => {
- "generators cannot be used in patterns".to_string()
- }
- traits::NonStructuralMatchTyKind::Param => {
- bug!("use of a constant whose type is a parameter inside a pattern")
- }
- traits::NonStructuralMatchTyKind::Projection => {
- bug!("use of a constant whose type is a projection inside a pattern")
- }
- traits::NonStructuralMatchTyKind::Foreign => {
- bug!("use of a value of a foreign type inside a pattern")
- }
- })
- })
+ traits::search_for_structural_match_violation(self.span, self.tcx(), ty, true).map(
+ |non_sm_ty| {
+ with_no_trimmed_paths!(match non_sm_ty.kind {
+ traits::NonStructuralMatchTyKind::Adt(adt) => self.adt_derive_msg(adt),
+ traits::NonStructuralMatchTyKind::Dynamic => {
+ "trait objects cannot be used in patterns".to_string()
+ }
+ traits::NonStructuralMatchTyKind::Opaque => {
+ "opaque types cannot be used in patterns".to_string()
+ }
+ traits::NonStructuralMatchTyKind::Closure => {
+ "closures cannot be used in patterns".to_string()
+ }
+ traits::NonStructuralMatchTyKind::Generator => {
+ "generators cannot be used in patterns".to_string()
+ }
+ traits::NonStructuralMatchTyKind::Float => {
+ "floating-point numbers cannot be used in patterns".to_string()
+ }
+ traits::NonStructuralMatchTyKind::Param => {
+ bug!("use of a constant whose type is a parameter inside a pattern")
+ }
+ traits::NonStructuralMatchTyKind::Projection => {
+ bug!("use of a constant whose type is a projection inside a pattern")
+ }
+ traits::NonStructuralMatchTyKind::Foreign => {
+ bug!("use of a value of a foreign type inside a pattern")
+ }
+ })
+ },
+ )
}
fn type_marked_structural(&self, ty: Ty<'tcx>) -> bool {
diff --git a/compiler/rustc_trait_selection/src/traits/structural_match.rs b/compiler/rustc_trait_selection/src/traits/structural_match.rs
index 94ca138b9d20d..6c0b83fbd0304 100644
--- a/compiler/rustc_trait_selection/src/traits/structural_match.rs
+++ b/compiler/rustc_trait_selection/src/traits/structural_match.rs
@@ -26,6 +26,7 @@ pub enum NonStructuralMatchTyKind<'tcx> {
Closure,
Generator,
Projection,
+ Float,
}
/// This method traverses the structure of `ty`, trying to find an
@@ -53,12 +54,16 @@ pub enum NonStructuralMatchTyKind<'tcx> {
/// For more background on why Rust has this requirement, and issues
/// that arose when the requirement was not enforced completely, see
/// Rust RFC 1445, rust-lang/rust#61188, and rust-lang/rust#62307.
+///
+/// The floats_allowed flag is used to deny constants in floating point
pub fn search_for_structural_match_violation<'tcx>(
span: Span,
tcx: TyCtxt<'tcx>,
ty: Ty<'tcx>,
+ floats_allowed: bool,
) -> Option<NonStructuralMatchTy<'tcx>> {
- ty.visit_with(&mut Search { tcx, span, seen: FxHashSet::default() }).break_value()
+ ty.visit_with(&mut Search { tcx, span, seen: FxHashSet::default(), floats_allowed })
+ .break_value()
}
/// This method returns true if and only if `adt_ty` itself has been marked as
@@ -119,6 +124,8 @@ struct Search<'tcx> {
/// Tracks ADTs previously encountered during search, so that
/// we will not recur on them again.
seen: FxHashSet<hir::def_id::DefId>,
+
+ floats_allowed: bool,
}
impl<'tcx> Search<'tcx> {
@@ -192,13 +199,24 @@ impl<'tcx> TypeVisitor<'tcx> for Search<'tcx> {
// for empty array.
return ControlFlow::CONTINUE;
}
- ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str | ty::Never => {
+ ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Str | ty::Never => {
// These primitive types are always structural match.
//
// `Never` is kind of special here, but as it is not inhabitable, this should be fine.
return ControlFlow::CONTINUE;
}
+ ty::Float(_) => {
+ if self.floats_allowed {
+ return ControlFlow::CONTINUE;
+ } else {
+ return ControlFlow::Break(NonStructuralMatchTy {
+ ty,
+ kind: NonStructuralMatchTyKind::Float,
+ });
+ }
+ }
+
ty::Array(..) | ty::Slice(_) | ty::Ref(..) | ty::Tuple(..) => {
// First check all contained types and then tell the caller to continue searching.
return ty.super_visit_with(self);
diff --git a/compiler/rustc_typeck/src/check/wfcheck.rs b/compiler/rustc_typeck/src/check/wfcheck.rs
index f93f567fb2054..5621cf2e1a4b5 100644
--- a/compiler/rustc_typeck/src/check/wfcheck.rs
+++ b/compiler/rustc_typeck/src/check/wfcheck.rs
@@ -824,50 +824,62 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) {
}
if let Some(non_structural_match_ty) =
- traits::search_for_structural_match_violation(param.span, tcx, ty)
+ traits::search_for_structural_match_violation(param.span, tcx, ty, false)
{
// We use the same error code in both branches, because this is really the same
// issue: we just special-case the message for type parameters to make it
// clearer.
- if let ty::Param(_) = ty.peel_refs().kind() {
- // Const parameters may not have type parameters as their types,
- // because we cannot be sure that the type parameter derives `PartialEq`
- // and `Eq` (just implementing them is not enough for `structural_match`).
- struct_span_err!(
- tcx.sess,
- hir_ty.span,
- E0741,
- "`{}` is not guaranteed to `#[derive(PartialEq, Eq)]`, so may not be \
- used as the type of a const parameter",
- ty,
- )
- .span_label(
- hir_ty.span,
- format!("`{}` may not derive both `PartialEq` and `Eq`", ty),
- )
- .note(
- "it is not currently possible to use a type parameter as the type of a \
- const parameter",
- )
- .emit();
- } else {
- let mut diag = struct_span_err!(
- tcx.sess,
- hir_ty.span,
- E0741,
- "`{}` must be annotated with `#[derive(PartialEq, Eq)]` to be used as \
- the type of a const parameter",
- non_structural_match_ty.ty,
- );
-
- if ty == non_structural_match_ty.ty {
- diag.span_label(
+ match ty.peel_refs().kind() {
+ ty::Param(_) => {
+ // Const parameters may not have type parameters as their types,
+ // because we cannot be sure that the type parameter derives `PartialEq`
+ // and `Eq` (just implementing them is not enough for `structural_match`).
+ struct_span_err!(
+ tcx.sess,
hir_ty.span,
- format!("`{ty}` doesn't derive both `PartialEq` and `Eq`"),
- );
+ E0741,
+ "`{ty}` is not guaranteed to `#[derive(PartialEq, Eq)]`, so may not be \
+ used as the type of a const parameter",
+ )
+ .span_label(
+ hir_ty.span,
+ format!("`{ty}` may not derive both `PartialEq` and `Eq`"),
+ )
+ .note(
+ "it is not currently possible to use a type parameter as the type of a \
+ const parameter",
+ )
+ .emit();
+ }
+ ty::Float(_) => {
+ struct_span_err!(
+ tcx.sess,
+ hir_ty.span,
+ E0741,
+ "`{ty}` is forbidden as the type of a const generic parameter",
+ )
+ .note("floats do not derive `Eq` or `Ord`, which are required for const parameters")
+ .emit();
}
+ _ => {
+ let mut diag = struct_span_err!(
+ tcx.sess,
+ hir_ty.span,
+ E0741,
+ "`{}` must be annotated with `#[derive(PartialEq, Eq)]` to be used as \
+ the type of a const parameter",
+ non_structural_match_ty.ty,
+ );
- diag.emit();
+ if ty == non_structural_match_ty.ty {
+ diag.span_label(
+ hir_ty.span,
+ format!("`{ty}` doesn't derive both `PartialEq` and `Eq`"),
+ );
+ }
+
+ diag.emit();
+ }
}
}
} else {
diff --git a/src/test/ui/const-generics/float-generic.adt_const_params.stderr b/src/test/ui/const-generics/float-generic.adt_const_params.stderr
new file mode 100644
index 0000000000000..fef5ef0d1facf
--- /dev/null
+++ b/src/test/ui/const-generics/float-generic.adt_const_params.stderr
@@ -0,0 +1,11 @@
+error[E0741]: `f32` is forbidden as the type of a const generic parameter
+ --> $DIR/float-generic.rs:5:17
+ |
+LL | fn foo<const F: f32>() {}
+ | ^^^
+ |
+ = note: floats do not derive `Eq` or `Ord`, which are required for const parameters
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0741`.
diff --git a/src/test/ui/const-generics/float-generic.rs b/src/test/ui/const-generics/float-generic.rs
new file mode 100644
index 0000000000000..b72059b5b1c6a
--- /dev/null
+++ b/src/test/ui/const-generics/float-generic.rs
@@ -0,0 +1,12 @@
+// revisions: simple adt_const_params
+#![cfg_attr(adt_const_params, feature(adt_const_params))]
+#![cfg_attr(adt_const_params, allow(incomplete_features))]
+
+fn foo<const F: f32>() {}
+//~^ ERROR `f32` is forbidden as the type of a const generic parameter
+
+const C: f32 = 1.0;
+
+fn main() {
+ foo::<C>();
+}
diff --git a/src/test/ui/const-generics/float-generic.simple.stderr b/src/test/ui/const-generics/float-generic.simple.stderr
new file mode 100644
index 0000000000000..89ca36b0f6314
--- /dev/null
+++ b/src/test/ui/const-generics/float-generic.simple.stderr
@@ -0,0 +1,11 @@
+error: `f32` is forbidden as the type of a const generic parameter
+ --> $DIR/float-generic.rs:5:17
+ |
+LL | fn foo<const F: f32>() {}
+ | ^^^
+ |
+ = note: the only supported types are integers, `bool` and `char`
+ = help: more complex types are supported with `#![feature(adt_const_params)]`
+
+error: aborting due to previous error
+
From 12d11e9a35ccb380388c0568ed1d8735d89f51c3 Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Mon, 11 Jul 2022 11:36:15 +0900
Subject: [PATCH 4/8] implement `is_accessible_span`
---
.../rustc_borrowck/src/diagnostics/conflict_errors.rs | 2 +-
compiler/rustc_borrowck/src/diagnostics/mod.rs | 9 +--------
.../rustc_const_eval/src/transform/check_consts/ops.rs | 2 +-
compiler/rustc_errors/src/lib.rs | 2 +-
compiler/rustc_mir_build/src/thir/pattern/check_match.rs | 2 +-
compiler/rustc_resolve/src/diagnostics.rs | 2 +-
compiler/rustc_span/src/source_map.rs | 7 +++++++
compiler/rustc_typeck/src/check/demand.rs | 4 ++--
.../structured_errors/wrong_number_of_generic_args.rs | 2 +-
9 files changed, 16 insertions(+), 16 deletions(-)
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index b9cfc3732dc7c..ed628f35148ef 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -309,7 +309,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
));
// Check first whether the source is accessible (issue #87060)
- if self.infcx.tcx.sess.source_map().span_to_snippet(deref_target).is_ok() {
+ if self.infcx.tcx.sess.source_map().is_accessible_span(deref_target) {
err.span_note(deref_target, "deref defined here");
}
}
diff --git a/compiler/rustc_borrowck/src/diagnostics/mod.rs b/compiler/rustc_borrowck/src/diagnostics/mod.rs
index 6fea6941085ce..3ecf259935a59 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mod.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mod.rs
@@ -975,14 +975,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
if self.fn_self_span_reported.insert(fn_span) {
err.span_note(
// Check whether the source is accessible
- if self
- .infcx
- .tcx
- .sess
- .source_map()
- .span_to_snippet(self_arg.span)
- .is_ok()
- {
+ if self.infcx.tcx.sess.source_map().is_accessible_span(self_arg.span) {
self_arg.span
} else {
fn_call_span
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/ops.rs b/compiler/rustc_const_eval/src/transform/check_consts/ops.rs
index 17376e59e09cc..631a646b2bcb7 100644
--- a/compiler/rustc_const_eval/src/transform/check_consts/ops.rs
+++ b/compiler/rustc_const_eval/src/transform/check_consts/ops.rs
@@ -299,7 +299,7 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
err.note(&format!("attempting to deref into `{}`", deref_target_ty));
// Check first whether the source is accessible (issue #87060)
- if tcx.sess.source_map().span_to_snippet(deref_target).is_ok() {
+ if tcx.sess.source_map().is_accessible_span(deref_target) {
err.span_note(deref_target, "deref defined here");
}
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index ffe4ecebb2e36..f4624c0763603 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -1558,7 +1558,7 @@ pub fn add_elided_lifetime_in_path_suggestion(
insertion_span: Span,
) {
diag.span_label(path_span, format!("expected lifetime parameter{}", pluralize!(n)));
- if source_map.span_to_snippet(insertion_span).is_err() {
+ if !source_map.is_accessible_span(insertion_span) {
// Do not try to suggest anything if generated by a proc-macro.
return;
}
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index 61ac3d14e50e2..f3d0002563f0e 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -432,7 +432,7 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
"`let` bindings require an \"irrefutable pattern\", like a `struct` or \
an `enum` with only one variant",
);
- if self.tcx.sess.source_map().span_to_snippet(span).is_ok() {
+ if self.tcx.sess.source_map().is_accessible_span(span) {
let semi_span = span.shrink_to_hi().with_lo(span.hi() - BytePos(1));
let start_span = span.shrink_to_lo();
let end_span = semi_span.shrink_to_lo();
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 18ffe9528f565..eb2de140441db 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -1650,7 +1650,7 @@ impl<'a> Resolver<'a> {
fn binding_description(&self, b: &NameBinding<'_>, ident: Ident, from_prelude: bool) -> String {
let res = b.res();
- if b.span.is_dummy() || self.session.source_map().span_to_snippet(b.span).is_err() {
+ if b.span.is_dummy() || !self.session.source_map().is_accessible_span(b.span) {
// These already contain the "built-in" prefix or look bad with it.
let add_built_in =
!matches!(b.res(), Res::NonMacroAttr(..) | Res::PrimTy(..) | Res::ToolMod);
diff --git a/compiler/rustc_span/src/source_map.rs b/compiler/rustc_span/src/source_map.rs
index 227127aed50d7..66ed32dced69e 100644
--- a/compiler/rustc_span/src/source_map.rs
+++ b/compiler/rustc_span/src/source_map.rs
@@ -597,6 +597,13 @@ impl SourceMap {
local_begin.sf.src.is_some() && local_end.sf.src.is_some()
}
+ pub fn is_accessible_span(&self, sp: Span) -> bool {
+ self.span_to_source(sp, |src, start_index, end_index| {
+ Ok(src.get(start_index..end_index).is_some())
+ })
+ .map_or(false, |is_accessible| is_accessible)
+ }
+
/// Returns the source snippet as `String` corresponding to the given `Span`.
pub fn span_to_snippet(&self, sp: Span) -> Result<String, SpanSnippetError> {
self.span_to_source(sp, |src, start_index, end_index| {
diff --git a/compiler/rustc_typeck/src/check/demand.rs b/compiler/rustc_typeck/src/check/demand.rs
index 53ca027bb57f5..af30526b35a7e 100644
--- a/compiler/rustc_typeck/src/check/demand.rs
+++ b/compiler/rustc_typeck/src/check/demand.rs
@@ -760,7 +760,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if let Some(call_span) =
iter::successors(Some(expr.span), |s| s.parent_callsite())
.find(|&s| sp.contains(s))
- && sm.span_to_snippet(call_span).is_ok()
+ && sm.is_accessible_span(call_span)
{
return Some((
sp.with_hi(call_span.lo()),
@@ -773,7 +773,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
return None;
}
if sp.contains(expr.span)
- && sm.span_to_snippet(expr.span).is_ok()
+ && sm.is_accessible_span(expr.span)
{
return Some((
sp.with_hi(expr.span.lo()),
diff --git a/compiler/rustc_typeck/src/structured_errors/wrong_number_of_generic_args.rs b/compiler/rustc_typeck/src/structured_errors/wrong_number_of_generic_args.rs
index 72a32dade4eef..23af72bf56271 100644
--- a/compiler/rustc_typeck/src/structured_errors/wrong_number_of_generic_args.rs
+++ b/compiler/rustc_typeck/src/structured_errors/wrong_number_of_generic_args.rs
@@ -812,7 +812,7 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
/// Builds the `type defined here` message.
fn show_definition(&self, err: &mut Diagnostic) {
let mut spans: MultiSpan = if let Some(def_span) = self.tcx.def_ident_span(self.def_id) {
- if self.tcx.sess.source_map().span_to_snippet(def_span).is_ok() {
+ if self.tcx.sess.source_map().is_accessible_span(def_span) {
def_span.into()
} else {
return;
From 680fef4d0455449d2226f8b9a4b266cc5c82ccc0 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 11 Jul 2022 06:53:01 +0000
Subject: [PATCH 5/8] Mention similarly named associated type even if it's not
clearly in supertrait
---
compiler/rustc_typeck/src/astconv/errors.rs | 56 ++++++++++++++++++-
src/test/ui/resolve/issue-55673.rs | 12 ++++
src/test/ui/resolve/issue-55673.stderr | 9 +++
src/test/ui/traits/issue-59029-1.stderr | 4 +-
.../not_well_formed.stderr | 2 +-
5 files changed, 78 insertions(+), 5 deletions(-)
create mode 100644 src/test/ui/resolve/issue-55673.rs
create mode 100644 src/test/ui/resolve/issue-55673.stderr
diff --git a/compiler/rustc_typeck/src/astconv/errors.rs b/compiler/rustc_typeck/src/astconv/errors.rs
index d111008e82c83..c873cf27e42c5 100644
--- a/compiler/rustc_typeck/src/astconv/errors.rs
+++ b/compiler/rustc_typeck/src/astconv/errors.rs
@@ -164,10 +164,62 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
suggested_name,
Applicability::MaybeIncorrect,
);
- } else {
- err.span_label(span, format!("associated type `{}` not found", assoc_name));
+ return err.emit();
}
+ // If we didn't find a good item in the supertraits (or couldn't get
+ // the supertraits), like in ItemCtxt, then look more generally from
+ // all visible traits. If there's one clear winner, just suggest that.
+
+ let visible_traits: Vec<_> = self
+ .tcx()
+ .all_traits()
+ .filter(|trait_def_id| {
+ let viz = self.tcx().visibility(*trait_def_id);
+ if let Some(def_id) = self.item_def_id() {
+ viz.is_accessible_from(def_id, self.tcx())
+ } else {
+ viz.is_visible_locally()
+ }
+ })
+ .collect();
+
+ let wider_candidate_names: Vec<_> = visible_traits
+ .iter()
+ .flat_map(|trait_def_id| {
+ self.tcx().associated_items(*trait_def_id).in_definition_order()
+ })
+ .filter_map(
+ |item| if item.kind == ty::AssocKind::Type { Some(item.name) } else { None },
+ )
+ .collect();
+
+ if let (Some(suggested_name), true) = (
+ find_best_match_for_name(&wider_candidate_names, assoc_name.name, None),
+ assoc_name.span != DUMMY_SP,
+ ) {
+ if let [best_trait] = visible_traits
+ .iter()
+ .filter(|trait_def_id| {
+ self.tcx()
+ .associated_items(*trait_def_id)
+ .filter_by_name_unhygienic(suggested_name)
+ .any(|item| item.kind == ty::AssocKind::Type)
+ })
+ .collect::<Vec<_>>()[..]
+ {
+ err.span_label(
+ assoc_name.span,
+ format!(
+ "there is a similarly named associated type `{suggested_name}` in the trait `{}`",
+ self.tcx().def_path_str(*best_trait)
+ ),
+ );
+ return err.emit();
+ }
+ }
+
+ err.span_label(span, format!("associated type `{}` not found", assoc_name));
err.emit()
}
diff --git a/src/test/ui/resolve/issue-55673.rs b/src/test/ui/resolve/issue-55673.rs
new file mode 100644
index 0000000000000..0436bd397424c
--- /dev/null
+++ b/src/test/ui/resolve/issue-55673.rs
@@ -0,0 +1,12 @@
+trait Foo {
+ type Bar;
+}
+
+fn foo<T: Foo>()
+where
+ T::Baa: std::fmt::Debug,
+ //~^ ERROR associated type `Baa` not found for `T`
+{
+}
+
+fn main() {}
diff --git a/src/test/ui/resolve/issue-55673.stderr b/src/test/ui/resolve/issue-55673.stderr
new file mode 100644
index 0000000000000..39318f959056f
--- /dev/null
+++ b/src/test/ui/resolve/issue-55673.stderr
@@ -0,0 +1,9 @@
+error[E0220]: associated type `Baa` not found for `T`
+ --> $DIR/issue-55673.rs:7:8
+ |
+LL | T::Baa: std::fmt::Debug,
+ | ^^^ there is a similarly named associated type `Bar` in the trait `Foo`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0220`.
diff --git a/src/test/ui/traits/issue-59029-1.stderr b/src/test/ui/traits/issue-59029-1.stderr
index 53cdb8b1baf4c..203a89285306d 100644
--- a/src/test/ui/traits/issue-59029-1.stderr
+++ b/src/test/ui/traits/issue-59029-1.stderr
@@ -2,13 +2,13 @@ error[E0220]: associated type `Res` not found for `Self`
--> $DIR/issue-59029-1.rs:5:52
|
LL | trait MkSvc<Target, Req> = Svc<Target> where Self::Res: Svc<Req>;
- | ^^^ associated type `Res` not found
+ | ^^^ there is a similarly named associated type `Res` in the trait `Svc`
error[E0220]: associated type `Res` not found for `Self`
--> $DIR/issue-59029-1.rs:5:52
|
LL | trait MkSvc<Target, Req> = Svc<Target> where Self::Res: Svc<Req>;
- | ^^^ associated type `Res` not found
+ | ^^^ there is a similarly named associated type `Res` in the trait `Svc`
error: aborting due to 2 previous errors
diff --git a/src/test/ui/type-alias-impl-trait/not_well_formed.stderr b/src/test/ui/type-alias-impl-trait/not_well_formed.stderr
index 91c1d031e4e5e..c36b95f47e837 100644
--- a/src/test/ui/type-alias-impl-trait/not_well_formed.stderr
+++ b/src/test/ui/type-alias-impl-trait/not_well_formed.stderr
@@ -2,7 +2,7 @@ error[E0220]: associated type `Assoc` not found for `V`
--> $DIR/not_well_formed.rs:9:29
|
LL | type Foo<V> = impl Trait<V::Assoc>;
- | ^^^^^ associated type `Assoc` not found
+ | ^^^^^ there is a similarly named associated type `Assoc` in the trait `TraitWithAssoc`
error: aborting due to previous error
From f2d8af10c24324f85a6ad82d3f8595ce4bd7ce95 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sat, 9 Jul 2022 18:39:51 +0000
Subject: [PATCH 6/8] Do not mention private Self types from other crates
---
.../src/traits/error_reporting/mod.rs | 22 +++++++++++++++++--
src/test/ui/suggestions/auxiliary/meow.rs | 11 ++++++++++
src/test/ui/suggestions/issue-99080.rs | 16 ++++++++++++++
src/test/ui/suggestions/issue-99080.stderr | 20 +++++++++++++++++
.../assoc-fn-bound-root-obligation.stderr | 1 -
5 files changed, 67 insertions(+), 3 deletions(-)
create mode 100644 src/test/ui/suggestions/auxiliary/meow.rs
create mode 100644 src/test/ui/suggestions/issue-99080.rs
create mode 100644 src/test/ui/suggestions/issue-99080.stderr
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
index aa1c91362891b..7ac3815179a39 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
@@ -1805,8 +1805,26 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
|| self.tcx.is_builtin_derive(def_id)
})
.filter_map(|def_id| self.tcx.impl_trait_ref(def_id))
- // Avoid mentioning type parameters.
- .filter(|trait_ref| !matches!(trait_ref.self_ty().kind(), ty::Param(_)))
+ .filter(|trait_ref| {
+ let self_ty = trait_ref.self_ty();
+ // Avoid mentioning type parameters.
+ if let ty::Param(_) = self_ty.kind() {
+ false
+ }
+ // Avoid mentioning types that are private to another crate
+ else if let ty::Adt(def, _) = self_ty.peel_refs().kind() {
+ // FIXME(compiler-errors): This could be generalized, both to
+ // be more granular, and probably look past other `#[fundamental]`
+ // types, too.
+ match self.tcx.visibility(def.did()) {
+ ty::Visibility::Public => true,
+ ty::Visibility::Restricted(def_id) => def_id.is_local(),
+ ty::Visibility::Invisible => false,
+ }
+ } else {
+ true
+ }
+ })
.collect();
return report(normalized_impl_candidates, err);
}
diff --git a/src/test/ui/suggestions/auxiliary/meow.rs b/src/test/ui/suggestions/auxiliary/meow.rs
new file mode 100644
index 0000000000000..115df70a69060
--- /dev/null
+++ b/src/test/ui/suggestions/auxiliary/meow.rs
@@ -0,0 +1,11 @@
+pub trait Meow {
+ fn meow(&self) {}
+}
+
+pub struct GlobalMeow;
+
+impl Meow for GlobalMeow {}
+
+pub(crate) struct PrivateMeow;
+
+impl Meow for PrivateMeow {}
diff --git a/src/test/ui/suggestions/issue-99080.rs b/src/test/ui/suggestions/issue-99080.rs
new file mode 100644
index 0000000000000..91f574f35b80b
--- /dev/null
+++ b/src/test/ui/suggestions/issue-99080.rs
@@ -0,0 +1,16 @@
+// aux-build:meow.rs
+
+extern crate meow;
+
+use meow::Meow;
+
+fn needs_meow<T: Meow>(t: T) {}
+
+fn main() {
+ needs_meow(1usize);
+ //~^ ERROR the trait bound `usize: Meow` is not satisfied
+}
+
+struct LocalMeow;
+
+impl Meow for LocalMeow {}
diff --git a/src/test/ui/suggestions/issue-99080.stderr b/src/test/ui/suggestions/issue-99080.stderr
new file mode 100644
index 0000000000000..d1908dd9d0d86
--- /dev/null
+++ b/src/test/ui/suggestions/issue-99080.stderr
@@ -0,0 +1,20 @@
+error[E0277]: the trait bound `usize: Meow` is not satisfied
+ --> $DIR/issue-99080.rs:10:16
+ |
+LL | needs_meow(1usize);
+ | ---------- ^^^^^^ the trait `Meow` is not implemented for `usize`
+ | |
+ | required by a bound introduced by this call
+ |
+ = help: the following other types implement trait `Meow`:
+ GlobalMeow
+ LocalMeow
+note: required by a bound in `needs_meow`
+ --> $DIR/issue-99080.rs:7:18
+ |
+LL | fn needs_meow<T: Meow>(t: T) {}
+ | ^^^^ required by this bound in `needs_meow`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/src/test/ui/traits/bound/assoc-fn-bound-root-obligation.stderr b/src/test/ui/traits/bound/assoc-fn-bound-root-obligation.stderr
index 115539a6dc28d..6ce57b6263e41 100644
--- a/src/test/ui/traits/bound/assoc-fn-bound-root-obligation.stderr
+++ b/src/test/ui/traits/bound/assoc-fn-bound-root-obligation.stderr
@@ -15,7 +15,6 @@ LL | s.strip_suffix(b'\n').unwrap_or(s)
&'c &'b str
[char; N]
char
- pattern::MultiCharEqPattern<C>
= note: required because of the requirements on the impl of `Pattern<'_>` for `u8`
error: aborting due to previous error
From 913023b6b475ac5caed060771526e0777a13ae94 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 11 Jul 2022 07:06:18 +0000
Subject: [PATCH 7/8] Use Visibility::is_accessible_from to make suggestion
more specific
---
.../src/traits/error_reporting/mod.rs | 12 +++++++-----
1 file changed, 7 insertions(+), 5 deletions(-)
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
index 7ac3815179a39..34f4a9f790266 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
@@ -673,6 +673,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
if !self.report_similar_impl_candidates(
impl_candidates,
trait_ref,
+ obligation.cause.body_id,
&mut err,
) {
// This is *almost* equivalent to
@@ -707,6 +708,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
self.report_similar_impl_candidates(
impl_candidates,
trait_ref,
+ obligation.cause.body_id,
&mut err,
);
}
@@ -1353,6 +1355,7 @@ trait InferCtxtPrivExt<'hir, 'tcx> {
&self,
impl_candidates: Vec<ImplCandidate<'tcx>>,
trait_ref: ty::PolyTraitRef<'tcx>,
+ body_id: hir::HirId,
err: &mut Diagnostic,
) -> bool;
@@ -1735,6 +1738,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
&self,
impl_candidates: Vec<ImplCandidate<'tcx>>,
trait_ref: ty::PolyTraitRef<'tcx>,
+ body_id: hir::HirId,
err: &mut Diagnostic,
) -> bool {
let report = |mut candidates: Vec<TraitRef<'tcx>>, err: &mut Diagnostic| {
@@ -1816,11 +1820,9 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
// FIXME(compiler-errors): This could be generalized, both to
// be more granular, and probably look past other `#[fundamental]`
// types, too.
- match self.tcx.visibility(def.did()) {
- ty::Visibility::Public => true,
- ty::Visibility::Restricted(def_id) => def_id.is_local(),
- ty::Visibility::Invisible => false,
- }
+ self.tcx
+ .visibility(def.did())
+ .is_accessible_from(body_id.owner.to_def_id(), self.tcx)
} else {
true
}
From 018155c3a218b819b70d1dc57b08fe3bc7b2ec3c Mon Sep 17 00:00:00 2001
From: Takayuki Maeda <takoyaki0316@gmail.com>
Date: Mon, 11 Jul 2022 16:51:19 +0900
Subject: [PATCH 8/8] rename a method
---
compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs | 2 +-
compiler/rustc_borrowck/src/diagnostics/mod.rs | 2 +-
compiler/rustc_const_eval/src/transform/check_consts/ops.rs | 2 +-
compiler/rustc_errors/src/lib.rs | 2 +-
compiler/rustc_mir_build/src/thir/pattern/check_match.rs | 2 +-
compiler/rustc_resolve/src/diagnostics.rs | 2 +-
compiler/rustc_span/src/source_map.rs | 2 +-
compiler/rustc_typeck/src/check/demand.rs | 4 ++--
.../src/structured_errors/wrong_number_of_generic_args.rs | 2 +-
9 files changed, 10 insertions(+), 10 deletions(-)
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index ed628f35148ef..687ff0fb50580 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -309,7 +309,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
));
// Check first whether the source is accessible (issue #87060)
- if self.infcx.tcx.sess.source_map().is_accessible_span(deref_target) {
+ if self.infcx.tcx.sess.source_map().is_span_accessible(deref_target) {
err.span_note(deref_target, "deref defined here");
}
}
diff --git a/compiler/rustc_borrowck/src/diagnostics/mod.rs b/compiler/rustc_borrowck/src/diagnostics/mod.rs
index 3ecf259935a59..a3094a34ad7f3 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mod.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mod.rs
@@ -975,7 +975,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
if self.fn_self_span_reported.insert(fn_span) {
err.span_note(
// Check whether the source is accessible
- if self.infcx.tcx.sess.source_map().is_accessible_span(self_arg.span) {
+ if self.infcx.tcx.sess.source_map().is_span_accessible(self_arg.span) {
self_arg.span
} else {
fn_call_span
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/ops.rs b/compiler/rustc_const_eval/src/transform/check_consts/ops.rs
index 631a646b2bcb7..1d083b0bf8268 100644
--- a/compiler/rustc_const_eval/src/transform/check_consts/ops.rs
+++ b/compiler/rustc_const_eval/src/transform/check_consts/ops.rs
@@ -299,7 +299,7 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
err.note(&format!("attempting to deref into `{}`", deref_target_ty));
// Check first whether the source is accessible (issue #87060)
- if tcx.sess.source_map().is_accessible_span(deref_target) {
+ if tcx.sess.source_map().is_span_accessible(deref_target) {
err.span_note(deref_target, "deref defined here");
}
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index f4624c0763603..e59a74e380ae3 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -1558,7 +1558,7 @@ pub fn add_elided_lifetime_in_path_suggestion(
insertion_span: Span,
) {
diag.span_label(path_span, format!("expected lifetime parameter{}", pluralize!(n)));
- if !source_map.is_accessible_span(insertion_span) {
+ if !source_map.is_span_accessible(insertion_span) {
// Do not try to suggest anything if generated by a proc-macro.
return;
}
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index f3d0002563f0e..75fd156ebfdf3 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -432,7 +432,7 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
"`let` bindings require an \"irrefutable pattern\", like a `struct` or \
an `enum` with only one variant",
);
- if self.tcx.sess.source_map().is_accessible_span(span) {
+ if self.tcx.sess.source_map().is_span_accessible(span) {
let semi_span = span.shrink_to_hi().with_lo(span.hi() - BytePos(1));
let start_span = span.shrink_to_lo();
let end_span = semi_span.shrink_to_lo();
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index eb2de140441db..a75ca3a8a2e72 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -1650,7 +1650,7 @@ impl<'a> Resolver<'a> {
fn binding_description(&self, b: &NameBinding<'_>, ident: Ident, from_prelude: bool) -> String {
let res = b.res();
- if b.span.is_dummy() || !self.session.source_map().is_accessible_span(b.span) {
+ if b.span.is_dummy() || !self.session.source_map().is_span_accessible(b.span) {
// These already contain the "built-in" prefix or look bad with it.
let add_built_in =
!matches!(b.res(), Res::NonMacroAttr(..) | Res::PrimTy(..) | Res::ToolMod);
diff --git a/compiler/rustc_span/src/source_map.rs b/compiler/rustc_span/src/source_map.rs
index 66ed32dced69e..afbb88e923360 100644
--- a/compiler/rustc_span/src/source_map.rs
+++ b/compiler/rustc_span/src/source_map.rs
@@ -597,7 +597,7 @@ impl SourceMap {
local_begin.sf.src.is_some() && local_end.sf.src.is_some()
}
- pub fn is_accessible_span(&self, sp: Span) -> bool {
+ pub fn is_span_accessible(&self, sp: Span) -> bool {
self.span_to_source(sp, |src, start_index, end_index| {
Ok(src.get(start_index..end_index).is_some())
})
diff --git a/compiler/rustc_typeck/src/check/demand.rs b/compiler/rustc_typeck/src/check/demand.rs
index af30526b35a7e..34876a0748fac 100644
--- a/compiler/rustc_typeck/src/check/demand.rs
+++ b/compiler/rustc_typeck/src/check/demand.rs
@@ -760,7 +760,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if let Some(call_span) =
iter::successors(Some(expr.span), |s| s.parent_callsite())
.find(|&s| sp.contains(s))
- && sm.is_accessible_span(call_span)
+ && sm.is_span_accessible(call_span)
{
return Some((
sp.with_hi(call_span.lo()),
@@ -773,7 +773,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
return None;
}
if sp.contains(expr.span)
- && sm.is_accessible_span(expr.span)
+ && sm.is_span_accessible(expr.span)
{
return Some((
sp.with_hi(expr.span.lo()),
diff --git a/compiler/rustc_typeck/src/structured_errors/wrong_number_of_generic_args.rs b/compiler/rustc_typeck/src/structured_errors/wrong_number_of_generic_args.rs
index 23af72bf56271..f1caa2a1ca068 100644
--- a/compiler/rustc_typeck/src/structured_errors/wrong_number_of_generic_args.rs
+++ b/compiler/rustc_typeck/src/structured_errors/wrong_number_of_generic_args.rs
@@ -812,7 +812,7 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
/// Builds the `type defined here` message.
fn show_definition(&self, err: &mut Diagnostic) {
let mut spans: MultiSpan = if let Some(def_span) = self.tcx.def_ident_span(self.def_id) {
- if self.tcx.sess.source_map().is_accessible_span(def_span) {
+ if self.tcx.sess.source_map().is_span_accessible(def_span) {
def_span.into()
} else {
return;