diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs
index dedb3035cedb3..f616d81603775 100644
--- a/src/librustc/ty/layout.rs
+++ b/src/librustc/ty/layout.rs
@@ -782,8 +782,8 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
present_first @ Some(_) => present_first,
// Uninhabited because it has no variants, or only absent ones.
None if def.is_enum() => return tcx.layout_raw(param_env.and(tcx.types.never)),
- // if it's a struct, still compute a layout so that we can still compute the
- // field offsets
+ // If it's a struct, still compute a layout so that we can still compute the
+ // field offsets.
None => Some(VariantIdx::new(0)),
};
@@ -1990,7 +1990,15 @@ where
{
fn for_variant(this: TyLayout<'tcx>, cx: &C, variant_index: VariantIdx) -> TyLayout<'tcx> {
let details = match this.variants {
- Variants::Single { index } if index == variant_index => this.details,
+ Variants::Single { index }
+ // If all variants but one are uninhabited, the variant layout is the enum layout.
+ if index == variant_index &&
+ // Don't confuse variants of uninhabited enums with the enum itself.
+ // For more details see https://github.com/rust-lang/rust/issues/69763.
+ this.fields != FieldPlacement::Union(0) =>
+ {
+ this.details
+ }
Variants::Single { index } => {
// Deny calling for_variant more than once for non-Single enums.
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index 338ff45a4ac7a..d622d6fbe2c1f 100644
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -554,24 +554,26 @@ bitflags! {
/// Does this have [ConstKind::Placeholder]?
const HAS_CT_PLACEHOLDER = 1 << 8;
+ /// `true` if there are "names" of regions and so forth
+ /// that are local to a particular fn/inferctxt
+ const HAS_FREE_LOCAL_REGIONS = 1 << 9;
+
/// `true` if there are "names" of types and regions and so forth
/// that are local to a particular fn
const HAS_FREE_LOCAL_NAMES = TypeFlags::HAS_TY_PARAM.bits
- | TypeFlags::HAS_RE_PARAM.bits
| TypeFlags::HAS_CT_PARAM.bits
| TypeFlags::HAS_TY_INFER.bits
- | TypeFlags::HAS_RE_INFER.bits
| TypeFlags::HAS_CT_INFER.bits
| TypeFlags::HAS_TY_PLACEHOLDER.bits
- | TypeFlags::HAS_RE_PLACEHOLDER.bits
- | TypeFlags::HAS_CT_PLACEHOLDER.bits;
+ | TypeFlags::HAS_CT_PLACEHOLDER.bits
+ | TypeFlags::HAS_FREE_LOCAL_REGIONS.bits;
/// Does this have [Projection] or [UnnormalizedProjection]?
- const HAS_TY_PROJECTION = 1 << 9;
+ const HAS_TY_PROJECTION = 1 << 10;
/// Does this have [Opaque]?
- const HAS_TY_OPAQUE = 1 << 10;
+ const HAS_TY_OPAQUE = 1 << 11;
/// Does this have [ConstKind::Unevaluated]?
- const HAS_CT_PROJECTION = 1 << 11;
+ const HAS_CT_PROJECTION = 1 << 12;
/// Could this type be normalized further?
const HAS_PROJECTION = TypeFlags::HAS_TY_PROJECTION.bits
@@ -580,21 +582,21 @@ bitflags! {
/// Present if the type belongs in a local type context.
/// Set for placeholders and inference variables that are not "Fresh".
- const KEEP_IN_LOCAL_TCX = 1 << 12;
+ const KEEP_IN_LOCAL_TCX = 1 << 13;
/// Is an error type reachable?
- const HAS_TY_ERR = 1 << 13;
+ const HAS_TY_ERR = 1 << 14;
/// Does this have any region that "appears free" in the type?
/// Basically anything but [ReLateBound] and [ReErased].
- const HAS_FREE_REGIONS = 1 << 14;
+ const HAS_FREE_REGIONS = 1 << 15;
/// Does this have any [ReLateBound] regions? Used to check
/// if a global bound is safe to evaluate.
- const HAS_RE_LATE_BOUND = 1 << 15;
+ const HAS_RE_LATE_BOUND = 1 << 16;
/// Does this have any [ReErased] regions?
- const HAS_RE_ERASED = 1 << 16;
+ const HAS_RE_ERASED = 1 << 17;
/// Flags representing the nominal content of a type,
/// computed by FlagsComputation. If you add a new nominal
@@ -608,6 +610,7 @@ bitflags! {
| TypeFlags::HAS_TY_PLACEHOLDER.bits
| TypeFlags::HAS_RE_PLACEHOLDER.bits
| TypeFlags::HAS_CT_PLACEHOLDER.bits
+ | TypeFlags::HAS_FREE_LOCAL_REGIONS.bits
| TypeFlags::HAS_TY_PROJECTION.bits
| TypeFlags::HAS_TY_OPAQUE.bits
| TypeFlags::HAS_CT_PROJECTION.bits
diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs
index 76b9aed831482..e265a2f8257fb 100644
--- a/src/librustc/ty/sty.rs
+++ b/src/librustc/ty/sty.rs
@@ -1743,42 +1743,42 @@ impl RegionKind {
}
}
- pub fn keep_in_local_tcx(&self) -> bool {
- if let ty::ReVar(..) = self { true } else { false }
- }
-
pub fn type_flags(&self) -> TypeFlags {
let mut flags = TypeFlags::empty();
- if self.keep_in_local_tcx() {
- flags = flags | TypeFlags::KEEP_IN_LOCAL_TCX;
- }
-
match *self {
ty::ReVar(..) => {
flags = flags | TypeFlags::HAS_FREE_REGIONS;
+ flags = flags | TypeFlags::HAS_FREE_LOCAL_REGIONS;
flags = flags | TypeFlags::HAS_RE_INFER;
+ flags = flags | TypeFlags::KEEP_IN_LOCAL_TCX;
}
ty::RePlaceholder(..) => {
flags = flags | TypeFlags::HAS_FREE_REGIONS;
+ flags = flags | TypeFlags::HAS_FREE_LOCAL_REGIONS;
flags = flags | TypeFlags::HAS_RE_PLACEHOLDER;
}
- ty::ReLateBound(..) => {
- flags = flags | TypeFlags::HAS_RE_LATE_BOUND;
- }
ty::ReEarlyBound(..) => {
flags = flags | TypeFlags::HAS_FREE_REGIONS;
+ flags = flags | TypeFlags::HAS_FREE_LOCAL_REGIONS;
flags = flags | TypeFlags::HAS_RE_PARAM;
}
- ty::ReEmpty(_) | ty::ReStatic | ty::ReFree { .. } | ty::ReScope { .. } => {
+ ty::ReFree { .. } | ty::ReScope { .. } => {
flags = flags | TypeFlags::HAS_FREE_REGIONS;
+ flags = flags | TypeFlags::HAS_FREE_LOCAL_REGIONS;
}
- ty::ReErased => {
- flags = flags | TypeFlags::HAS_RE_ERASED;
+ ty::ReEmpty(_) | ty::ReStatic => {
+ flags = flags | TypeFlags::HAS_FREE_REGIONS;
}
ty::ReClosureBound(..) => {
flags = flags | TypeFlags::HAS_FREE_REGIONS;
}
+ ty::ReLateBound(..) => {
+ flags = flags | TypeFlags::HAS_RE_LATE_BOUND;
+ }
+ ty::ReErased => {
+ flags = flags | TypeFlags::HAS_RE_ERASED;
+ }
}
debug!("type_flags({:?}) = {:?}", self, flags);
diff --git a/src/librustc_lint/types.rs b/src/librustc_lint/types.rs
index b5c0296e297e0..4949c93d45eed 100644
--- a/src/librustc_lint/types.rs
+++ b/src/librustc_lint/types.rs
@@ -1032,10 +1032,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for VariantSizeDifferences {
let ty = cx.tcx.erase_regions(&t);
let layout = match cx.layout_of(ty) {
Ok(layout) => layout,
- Err(ty::layout::LayoutError::Unknown(_)) => return,
- Err(err @ ty::layout::LayoutError::SizeOverflow(_)) => {
- bug!("failed to get layout for `{}`: {}", t, err);
- }
+ Err(ty::layout::LayoutError::Unknown(_))
+ | Err(ty::layout::LayoutError::SizeOverflow(_)) => return,
};
let (variants, tag) = match layout.variants {
layout::Variants::Multiple {
diff --git a/src/librustc_mir/interpret/operand.rs b/src/librustc_mir/interpret/operand.rs
index 75452b9395b50..bb71ea047bd7a 100644
--- a/src/librustc_mir/interpret/operand.rs
+++ b/src/librustc_mir/interpret/operand.rs
@@ -355,7 +355,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>> {
let base = match op.try_as_mplace(self) {
Ok(mplace) => {
- // The easy case
+ // We can reuse the mplace field computation logic for indirect operands.
let field = self.mplace_field(mplace, field)?;
return Ok(field.into());
}
diff --git a/src/librustc_mir/interpret/place.rs b/src/librustc_mir/interpret/place.rs
index a4815b9696ebb..856c654980ab7 100644
--- a/src/librustc_mir/interpret/place.rs
+++ b/src/librustc_mir/interpret/place.rs
@@ -410,14 +410,6 @@ where
stride * field
}
layout::FieldPlacement::Union(count) => {
- // This is a narrow bug-fix for rust-lang/rust#69191: if we are
- // trying to access absent field of uninhabited variant, then
- // signal UB (but don't ICE the compiler).
- // FIXME temporary hack to work around incoherence between
- // layout computation and MIR building
- if field >= count as u64 && base.layout.abi == layout::Abi::Uninhabited {
- throw_ub!(Unreachable);
- }
assert!(
field < count as u64,
"Tried to access field {} of union {:#?} with {} fields",
diff --git a/src/librustc_mir/transform/inline.rs b/src/librustc_mir/transform/inline.rs
index b6802505df73f..7cdebf6267075 100644
--- a/src/librustc_mir/transform/inline.rs
+++ b/src/librustc_mir/transform/inline.rs
@@ -25,6 +25,8 @@ const HINT_THRESHOLD: usize = 100;
const INSTR_COST: usize = 5;
const CALL_PENALTY: usize = 25;
+const LANDINGPAD_PENALTY: usize = 50;
+const RESUME_PENALTY: usize = 45;
const UNKNOWN_SIZE_COST: usize = 10;
@@ -328,6 +330,7 @@ impl Inliner<'tcx> {
if ty.needs_drop(tcx, param_env) {
cost += CALL_PENALTY;
if let Some(unwind) = unwind {
+ cost += LANDINGPAD_PENALTY;
work_list.push(unwind);
}
} else {
@@ -343,7 +346,7 @@ impl Inliner<'tcx> {
threshold = 0;
}
- TerminatorKind::Call { func: Operand::Constant(ref f), .. } => {
+ TerminatorKind::Call { func: Operand::Constant(ref f), cleanup, .. } => {
if let ty::FnDef(def_id, _) = f.literal.ty.kind {
// Don't give intrinsics the extra penalty for calls
let f = tcx.fn_sig(def_id);
@@ -352,9 +355,21 @@ impl Inliner<'tcx> {
} else {
cost += CALL_PENALTY;
}
+ } else {
+ cost += CALL_PENALTY;
+ }
+ if cleanup.is_some() {
+ cost += LANDINGPAD_PENALTY;
+ }
+ }
+ TerminatorKind::Assert { cleanup, .. } => {
+ cost += CALL_PENALTY;
+
+ if cleanup.is_some() {
+ cost += LANDINGPAD_PENALTY;
}
}
- TerminatorKind::Assert { .. } => cost += CALL_PENALTY,
+ TerminatorKind::Resume => cost += RESUME_PENALTY,
_ => cost += INSTR_COST,
}
diff --git a/src/librustc_resolve/diagnostics.rs b/src/librustc_resolve/diagnostics.rs
index 63fbc800ff706..7571dabcf7ef4 100644
--- a/src/librustc_resolve/diagnostics.rs
+++ b/src/librustc_resolve/diagnostics.rs
@@ -1,4 +1,5 @@
use std::cmp::Reverse;
+use std::ptr;
use log::debug;
use rustc::bug;
@@ -918,50 +919,81 @@ impl<'a> Resolver<'a> {
err.emit();
}
- crate fn report_privacy_error(&self, privacy_error: &PrivacyError<'_>) {
- let PrivacyError { ident, binding, .. } = *privacy_error;
- let session = &self.session;
- let mk_struct_span_error = |is_constructor| {
- let mut descr = binding.res().descr().to_string();
- if is_constructor {
- descr += " constructor";
- }
- if binding.is_import() {
- descr += " import";
- }
-
- let mut err =
- struct_span_err!(session, ident.span, E0603, "{} `{}` is private", descr, ident);
-
- err.span_label(ident.span, &format!("this {} is private", descr));
- err.span_note(
- session.source_map().def_span(binding.span),
- &format!("the {} `{}` is defined here", descr, ident),
- );
-
- err
- };
-
- let mut err = if let NameBindingKind::Res(
+ /// If the binding refers to a tuple struct constructor with fields,
+ /// returns the span of its fields.
+ fn ctor_fields_span(&self, binding: &NameBinding<'_>) -> Option<Span> {
+ if let NameBindingKind::Res(
Res::Def(DefKind::Ctor(CtorOf::Struct, CtorKind::Fn), ctor_def_id),
_,
) = binding.kind
{
let def_id = (&*self).parent(ctor_def_id).expect("no parent for a constructor");
if let Some(fields) = self.field_names.get(&def_id) {
- let mut err = mk_struct_span_error(true);
let first_field = fields.first().expect("empty field list in the map");
- err.span_label(
- fields.iter().fold(first_field.span, |acc, field| acc.to(field.span)),
- "a constructor is private if any of the fields is private",
- );
- err
- } else {
- mk_struct_span_error(false)
+ return Some(fields.iter().fold(first_field.span, |acc, field| acc.to(field.span)));
}
- } else {
- mk_struct_span_error(false)
- };
+ }
+ None
+ }
+
+ crate fn report_privacy_error(&self, privacy_error: &PrivacyError<'_>) {
+ let PrivacyError { ident, binding, .. } = *privacy_error;
+
+ let res = binding.res();
+ let ctor_fields_span = self.ctor_fields_span(binding);
+ let plain_descr = res.descr().to_string();
+ let nonimport_descr =
+ if ctor_fields_span.is_some() { plain_descr + " constructor" } else { plain_descr };
+ let import_descr = nonimport_descr.clone() + " import";
+ let get_descr =
+ |b: &NameBinding<'_>| if b.is_import() { &import_descr } else { &nonimport_descr };
+
+ // Print the primary message.
+ let descr = get_descr(binding);
+ let mut err =
+ struct_span_err!(self.session, ident.span, E0603, "{} `{}` is private", descr, ident);
+ err.span_label(ident.span, &format!("this {} is private", descr));
+ if let Some(span) = ctor_fields_span {
+ err.span_label(span, "a constructor is private if any of the fields is private");
+ }
+
+ // Print the whole import chain to make it easier to see what happens.
+ let first_binding = binding;
+ let mut next_binding = Some(binding);
+ let mut next_ident = ident;
+ while let Some(binding) = next_binding {
+ let name = next_ident;
+ next_binding = match binding.kind {
+ _ if res == Res::Err => None,
+ NameBindingKind::Import { binding, import, .. } => match import.kind {
+ _ if binding.span.is_dummy() => None,
+ ImportKind::Single { source, .. } => {
+ next_ident = source;
+ Some(binding)
+ }
+ ImportKind::Glob { .. } | ImportKind::MacroUse => Some(binding),
+ ImportKind::ExternCrate { .. } => None,
+ },
+ _ => None,
+ };
+
+ let first = ptr::eq(binding, first_binding);
+ let descr = get_descr(binding);
+ let msg = format!(
+ "{and_refers_to}the {item} `{name}`{which} is defined here{dots}",
+ and_refers_to = if first { "" } else { "...and refers to " },
+ item = descr,
+ name = name,
+ which = if first { "" } else { " which" },
+ dots = if next_binding.is_some() { "..." } else { "" },
+ );
+ let def_span = self.session.source_map().def_span(binding.span);
+ let mut note_span = MultiSpan::from_span(def_span);
+ if !first && binding.vis == ty::Visibility::Public {
+ note_span.push_span_label(def_span, "consider importing it directly".into());
+ }
+ err.span_note(note_span, &msg);
+ }
err.emit();
}
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index 05d0f20645033..1ad4fb78e0820 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -2188,11 +2188,8 @@ impl<'a> Resolver<'a> {
Applicability::MaybeIncorrect,
)),
)
- } else if !ident.is_reserved() {
- (format!("maybe a missing crate `{}`?", ident), None)
} else {
- // the parser will already have complained about the keyword being used
- return PathResult::NonModule(PartialRes::new(Res::Err));
+ (format!("maybe a missing crate `{}`?", ident), None)
}
} else if i == 0 {
(format!("use of undeclared type or module `{}`", ident), None)
diff --git a/src/librustc_target/abi/mod.rs b/src/librustc_target/abi/mod.rs
index 2f8bbd66c322b..afa30e7e632a7 100644
--- a/src/librustc_target/abi/mod.rs
+++ b/src/librustc_target/abi/mod.rs
@@ -660,7 +660,10 @@ impl FieldPlacement {
pub fn offset(&self, i: usize) -> Size {
match *self {
- FieldPlacement::Union(_) => Size::ZERO,
+ FieldPlacement::Union(count) => {
+ assert!(i < count, "tried to access field {} of union with {} fields", i, count);
+ Size::ZERO
+ }
FieldPlacement::Array { stride, count } => {
let i = i as u64;
assert!(i < count);
diff --git a/src/libstd/sys_common/wtf8.rs b/src/libstd/sys_common/wtf8.rs
index 7509e1ee35dee..498950e682101 100644
--- a/src/libstd/sys_common/wtf8.rs
+++ b/src/libstd/sys_common/wtf8.rs
@@ -599,24 +599,16 @@ impl Wtf8 {
#[inline]
fn final_lead_surrogate(&self) -> Option<u16> {
- let len = self.len();
- if len < 3 {
- return None;
- }
- match self.bytes[(len - 3)..] {
- [0xED, b2 @ 0xA0..=0xAF, b3] => Some(decode_surrogate(b2, b3)),
+ match self.bytes {
+ [.., 0xED, b2 @ 0xA0..=0xAF, b3] => Some(decode_surrogate(b2, b3)),
_ => None,
}
}
#[inline]
fn initial_trail_surrogate(&self) -> Option<u16> {
- let len = self.len();
- if len < 3 {
- return None;
- }
- match self.bytes[..3] {
- [0xED, b2 @ 0xB0..=0xBF, b3] => Some(decode_surrogate(b2, b3)),
+ match self.bytes {
+ [0xED, b2 @ 0xB0..=0xBF, b3, ..] => Some(decode_surrogate(b2, b3)),
_ => None,
}
}
diff --git a/src/test/rustdoc-ui/issue-61732.rs b/src/test/rustdoc-ui/issue-61732.rs
index d4835c092248e..4bd8efeaa3b97 100644
--- a/src/test/rustdoc-ui/issue-61732.rs
+++ b/src/test/rustdoc-ui/issue-61732.rs
@@ -1,4 +1,4 @@
// This previously triggered an ICE.
pub(in crate::r#mod) fn main() {}
-//~^ ERROR expected module, found unresolved item
+//~^ ERROR failed to resolve: maybe a missing crate `r#mod`
diff --git a/src/test/rustdoc-ui/issue-61732.stderr b/src/test/rustdoc-ui/issue-61732.stderr
index 6c8ba48864df0..8213422491120 100644
--- a/src/test/rustdoc-ui/issue-61732.stderr
+++ b/src/test/rustdoc-ui/issue-61732.stderr
@@ -1,11 +1,11 @@
-error[E0577]: expected module, found unresolved item `crate::r#mod`
- --> $DIR/issue-61732.rs:3:8
+error[E0433]: failed to resolve: maybe a missing crate `r#mod`?
+ --> $DIR/issue-61732.rs:3:15
|
LL | pub(in crate::r#mod) fn main() {}
- | ^^^^^^^^^^^^ not a module
+ | ^^^^^ maybe a missing crate `r#mod`?
error: Compilation failed, aborting rustdoc
error: aborting due to 2 previous errors
-For more information about this error, try `rustc --explain E0577`.
+For more information about this error, try `rustc --explain E0433`.
diff --git a/src/test/ui/imports/issue-55884-2.stderr b/src/test/ui/imports/issue-55884-2.stderr
index f16d2adb3656e..490c08446b5a8 100644
--- a/src/test/ui/imports/issue-55884-2.stderr
+++ b/src/test/ui/imports/issue-55884-2.stderr
@@ -4,11 +4,26 @@ error[E0603]: struct import `ParseOptions` is private
LL | pub use parser::ParseOptions;
| ^^^^^^^^^^^^ this struct import is private
|
-note: the struct import `ParseOptions` is defined here
+note: the struct import `ParseOptions` is defined here...
--> $DIR/issue-55884-2.rs:9:9
|
LL | use ParseOptions;
| ^^^^^^^^^^^^
+note: ...and refers to the struct import `ParseOptions` which is defined here...
+ --> $DIR/issue-55884-2.rs:12:9
+ |
+LL | pub use parser::ParseOptions;
+ | ^^^^^^^^^^^^^^^^^^^^ consider importing it directly
+note: ...and refers to the struct import `ParseOptions` which is defined here...
+ --> $DIR/issue-55884-2.rs:6:13
+ |
+LL | pub use options::*;
+ | ^^^^^^^^^^ consider importing it directly
+note: ...and refers to the struct `ParseOptions` which is defined here
+ --> $DIR/issue-55884-2.rs:2:5
+ |
+LL | pub struct ParseOptions {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^ consider importing it directly
error: aborting due to previous error
diff --git a/src/test/ui/imports/reexports.stderr b/src/test/ui/imports/reexports.stderr
index 7b0d63574ec8e..d63fbc7ec6781 100644
--- a/src/test/ui/imports/reexports.stderr
+++ b/src/test/ui/imports/reexports.stderr
@@ -16,11 +16,16 @@ error[E0603]: module import `foo` is private
LL | use b::a::foo::S;
| ^^^ this module import is private
|
-note: the module import `foo` is defined here
+note: the module import `foo` is defined here...
--> $DIR/reexports.rs:21:17
|
LL | pub use super::foo; // This is OK since the value `foo` is visible enough.
| ^^^^^^^^^^
+note: ...and refers to the module `foo` which is defined here
+ --> $DIR/reexports.rs:16:5
+ |
+LL | mod foo {
+ | ^^^^^^^
error[E0603]: module import `foo` is private
--> $DIR/reexports.rs:34:15
@@ -28,11 +33,16 @@ error[E0603]: module import `foo` is private
LL | use b::b::foo::S as T;
| ^^^ this module import is private
|
-note: the module import `foo` is defined here
+note: the module import `foo` is defined here...
--> $DIR/reexports.rs:26:17
|
LL | pub use super::*; // This is also OK since the value `foo` is visible enough.
| ^^^^^^^^
+note: ...and refers to the module `foo` which is defined here
+ --> $DIR/reexports.rs:16:5
+ |
+LL | mod foo {
+ | ^^^^^^^
warning: glob import doesn't reexport anything because no candidate is public enough
--> $DIR/reexports.rs:9:17
diff --git a/src/test/ui/keyword/extern/keyword-extern-as-identifier-use.rs b/src/test/ui/keyword/extern/keyword-extern-as-identifier-use.rs
index b07de3e341c41..a46ce67d40d5a 100644
--- a/src/test/ui/keyword/extern/keyword-extern-as-identifier-use.rs
+++ b/src/test/ui/keyword/extern/keyword-extern-as-identifier-use.rs
@@ -1,3 +1,4 @@
use extern::foo; //~ ERROR expected identifier, found keyword `extern`
+ //~| ERROR unresolved import `r#extern`
fn main() {}
diff --git a/src/test/ui/keyword/extern/keyword-extern-as-identifier-use.stderr b/src/test/ui/keyword/extern/keyword-extern-as-identifier-use.stderr
index 05802f2d36710..edbb36452b6ce 100644
--- a/src/test/ui/keyword/extern/keyword-extern-as-identifier-use.stderr
+++ b/src/test/ui/keyword/extern/keyword-extern-as-identifier-use.stderr
@@ -9,5 +9,12 @@ help: you can escape reserved keywords to use them as identifiers
LL | use r#extern::foo;
| ^^^^^^^^
-error: aborting due to previous error
+error[E0432]: unresolved import `r#extern`
+ --> $DIR/keyword-extern-as-identifier-use.rs:1:5
+ |
+LL | use extern::foo;
+ | ^^^^^^ maybe a missing crate `r#extern`?
+
+error: aborting due to 2 previous errors
+For more information about this error, try `rustc --explain E0432`.
diff --git a/src/test/ui/lint/issue-69485-var-size-diffs-too-large.rs b/src/test/ui/lint/issue-69485-var-size-diffs-too-large.rs
new file mode 100644
index 0000000000000..49d489d916837
--- /dev/null
+++ b/src/test/ui/lint/issue-69485-var-size-diffs-too-large.rs
@@ -0,0 +1,10 @@
+// build-fail
+// only-x86_64
+
+fn main() {
+ Bug::V([0; !0]); //~ ERROR is too big for the current
+}
+
+enum Bug {
+ V([u8; !0]),
+}
diff --git a/src/test/ui/lint/issue-69485-var-size-diffs-too-large.stderr b/src/test/ui/lint/issue-69485-var-size-diffs-too-large.stderr
new file mode 100644
index 0000000000000..d31ce9cfe0c2b
--- /dev/null
+++ b/src/test/ui/lint/issue-69485-var-size-diffs-too-large.stderr
@@ -0,0 +1,8 @@
+error: the type `[u8; 18446744073709551615]` is too big for the current architecture
+ --> $DIR/issue-69485-var-size-diffs-too-large.rs:5:12
+ |
+LL | Bug::V([0; !0]);
+ | ^^^^^^^
+
+error: aborting due to previous error
+
diff --git a/src/test/ui/privacy/privacy2.stderr b/src/test/ui/privacy/privacy2.stderr
index 719dc27ccf4d6..b10c3a5265971 100644
--- a/src/test/ui/privacy/privacy2.stderr
+++ b/src/test/ui/privacy/privacy2.stderr
@@ -10,11 +10,16 @@ error[E0603]: function import `foo` is private
LL | use bar::glob::foo;
| ^^^ this function import is private
|
-note: the function import `foo` is defined here
+note: the function import `foo` is defined here...
--> $DIR/privacy2.rs:10:13
|
LL | use foo;
| ^^^
+note: ...and refers to the function `foo` which is defined here
+ --> $DIR/privacy2.rs:14:1
+ |
+LL | pub fn foo() {}
+ | ^^^^^^^^^^^^ consider importing it directly
error: requires `sized` lang_item
diff --git a/src/test/ui/resolve/raw-ident-in-path.rs b/src/test/ui/resolve/raw-ident-in-path.rs
new file mode 100644
index 0000000000000..1bcbef5943741
--- /dev/null
+++ b/src/test/ui/resolve/raw-ident-in-path.rs
@@ -0,0 +1,5 @@
+// Regression test for issue #63882.
+
+type A = crate::r#break; //~ ERROR cannot find type `r#break` in module `crate`
+
+fn main() {}
diff --git a/src/test/ui/resolve/raw-ident-in-path.stderr b/src/test/ui/resolve/raw-ident-in-path.stderr
new file mode 100644
index 0000000000000..f2efcbc8e8586
--- /dev/null
+++ b/src/test/ui/resolve/raw-ident-in-path.stderr
@@ -0,0 +1,9 @@
+error[E0412]: cannot find type `r#break` in module `crate`
+ --> $DIR/raw-ident-in-path.rs:3:17
+ |
+LL | type A = crate::r#break;
+ | ^^^^^^^ not found in `crate`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0412`.
diff --git a/src/test/ui/shadowed/shadowed-use-visibility.stderr b/src/test/ui/shadowed/shadowed-use-visibility.stderr
index cd8ec13794c6f..2244f3a46b266 100644
--- a/src/test/ui/shadowed/shadowed-use-visibility.stderr
+++ b/src/test/ui/shadowed/shadowed-use-visibility.stderr
@@ -4,11 +4,16 @@ error[E0603]: module import `bar` is private
LL | use foo::bar::f as g;
| ^^^ this module import is private
|
-note: the module import `bar` is defined here
+note: the module import `bar` is defined here...
--> $DIR/shadowed-use-visibility.rs:4:9
|
LL | use foo as bar;
| ^^^^^^^^^^
+note: ...and refers to the module `foo` which is defined here
+ --> $DIR/shadowed-use-visibility.rs:1:1
+ |
+LL | mod foo {
+ | ^^^^^^^
error[E0603]: module import `f` is private
--> $DIR/shadowed-use-visibility.rs:15:10
@@ -16,11 +21,16 @@ error[E0603]: module import `f` is private
LL | use bar::f::f;
| ^ this module import is private
|
-note: the module import `f` is defined here
+note: the module import `f` is defined here...
--> $DIR/shadowed-use-visibility.rs:11:9
|
LL | use foo as f;
| ^^^^^^^^
+note: ...and refers to the module `foo` which is defined here
+ --> $DIR/shadowed-use-visibility.rs:1:1
+ |
+LL | mod foo {
+ | ^^^^^^^
error: aborting due to 2 previous errors