diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
index ba84323a4d00a..c8ab8ed681c15 100644
--- a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
@@ -181,11 +181,10 @@ use std::{iter, vec};
use rustc_ast::ptr::P;
use rustc_ast::{
self as ast, BindingMode, ByRef, EnumDef, Expr, GenericArg, GenericParamKind, Generics,
- Mutability, PatKind, TyKind, VariantData,
+ Mutability, PatKind, VariantData,
};
use rustc_attr as attr;
use rustc_expand::base::{Annotatable, ExtCtxt};
-use rustc_session::lint::builtin::BYTE_SLICE_IN_PACKED_STRUCT_WITH_DERIVE;
use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{Span, DUMMY_SP};
use thin_vec::{thin_vec, ThinVec};
@@ -1599,52 +1598,11 @@ impl<'a> TraitDef<'a> {
),
);
if is_packed {
- // In general, fields in packed structs are copied via a
- // block, e.g. `&{self.0}`. The two exceptions are `[u8]`
- // and `str` fields, which cannot be copied and also never
- // cause unaligned references. These exceptions are allowed
- // to handle the `FlexZeroSlice` type in the `zerovec`
- // crate within `icu4x-0.9.0`.
- //
- // Once use of `icu4x-0.9.0` has dropped sufficiently, this
- // exception should be removed.
- let is_simple_path = |ty: &P<ast::Ty>, sym| {
- if let TyKind::Path(None, ast::Path { segments, .. }) = &ty.kind
- && let [seg] = segments.as_slice()
- && seg.ident.name == sym
- && seg.args.is_none()
- {
- true
- } else {
- false
- }
- };
-
- let exception = if let TyKind::Slice(ty) = &struct_field.ty.kind
- && is_simple_path(ty, sym::u8)
- {
- Some("byte")
- } else if is_simple_path(&struct_field.ty, sym::str) {
- Some("string")
- } else {
- None
- };
-
- if let Some(ty) = exception {
- cx.sess.psess.buffer_lint(
- BYTE_SLICE_IN_PACKED_STRUCT_WITH_DERIVE,
- sp,
- ast::CRATE_NODE_ID,
- rustc_lint_defs::BuiltinLintDiag::ByteSliceInPackedStructWithDerive {
- ty: ty.to_string(),
- },
- );
- } else {
- // Wrap the expression in `{...}`, causing a copy.
- field_expr = cx.expr_block(
- cx.block(struct_field.span, thin_vec![cx.stmt_expr(field_expr)]),
- );
- }
+ // Fields in packed structs are wrapped in a block, e.g. `&{self.0}`,
+ // causing a copy instead of a (potentially misaligned) reference.
+ field_expr = cx.expr_block(
+ cx.block(struct_field.span, thin_vec![cx.stmt_expr(field_expr)]),
+ );
}
cx.expr_addr_of(sp, field_expr)
})
diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs
index f665dc7141139..b7f0ed5afce93 100644
--- a/compiler/rustc_feature/src/removed.rs
+++ b/compiler/rustc_feature/src/removed.rs
@@ -82,6 +82,9 @@ declare_features! (
/// Allows the use of `#[derive(Anything)]` as sugar for `#[derive_Anything]`.
(removed, custom_derive, "1.32.0", Some(29644),
Some("subsumed by `#[proc_macro_derive]`")),
+ /// Allows default type parameters to influence type inference.
+ (removed, default_type_parameter_fallback, "CURRENT_RUSTC_VERSION", Some(27336),
+ Some("never properly implemented; requires significant design work")),
/// Allows using `#[doc(keyword = "...")]`.
(removed, doc_keyword, "1.28.0", Some(51315),
Some("merged into `#![feature(rustdoc_internals)]`")),
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 652efa193ea7c..88a4b5a838246 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -431,8 +431,6 @@ declare_features! (
(unstable, custom_test_frameworks, "1.30.0", Some(50297)),
/// Allows declarative macros 2.0 (`macro`).
(unstable, decl_macro, "1.17.0", Some(39412)),
- /// Allows default type parameters to influence type inference.
- (unstable, default_type_parameter_fallback, "1.3.0", Some(27336)),
/// Allows using `#[deprecated_safe]` to deprecate the safeness of a function or trait
(unstable, deprecated_safe, "1.61.0", Some(94978)),
/// Allows having using `suggestion` in the `#[deprecated]` attribute.
diff --git a/compiler/rustc_hir_analysis/src/collect/generics_of.rs b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
index 71a6501de8b98..60e2c2eb30e56 100644
--- a/compiler/rustc_hir_analysis/src/collect/generics_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
@@ -338,8 +338,6 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
if default.is_some() {
match allow_defaults {
Defaults::Allowed => {}
- Defaults::FutureCompatDisallowed
- if tcx.features().default_type_parameter_fallback => {}
Defaults::FutureCompatDisallowed => {
tcx.node_span_lint(
lint::builtin::INVALID_TYPE_PARAM_DEFAULT,
diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
index 196b8fd52d53f..4f3933d461bbd 100644
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -543,7 +543,7 @@ fn register_builtins(store: &mut LintStore) {
);
store.register_removed(
"suspicious_auto_trait_impls",
- "no longer needed, see #93367 \
+ "no longer needed, see issue #93367 \
<https://github.com/rust-lang/rust/issues/93367> for more information",
);
store.register_removed(
@@ -565,6 +565,11 @@ fn register_builtins(store: &mut LintStore) {
"box_pointers",
"it does not detect other kinds of allocations, and existed only for historical reasons",
);
+ store.register_removed(
+ "byte_slice_in_packed_struct_with_derive",
+ "converted into hard error, see issue #107457 \
+ <https://github.com/rust-lang/rust/issues/107457> for more information",
+ )
}
fn register_internals(store: &mut LintStore) {
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index e12ffa4bd9096..ff0bdfcc9d261 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -26,7 +26,6 @@ declare_lint_pass! {
BARE_TRAIT_OBJECTS,
BINDINGS_WITH_VARIANT_NAME,
BREAK_WITH_LABEL_AND_LOOP,
- BYTE_SLICE_IN_PACKED_STRUCT_WITH_DERIVE,
CENUM_IMPL_DROP_CAST,
COHERENCE_LEAK_CHECK,
CONFLICTING_REPR_HINTS,
@@ -1267,7 +1266,7 @@ declare_lint! {
Deny,
"type parameter default erroneously allowed in invalid location",
@future_incompatible = FutureIncompatibleInfo {
- reason: FutureIncompatibilityReason::FutureReleaseErrorDontReportInDeps,
+ reason: FutureIncompatibilityReason::FutureReleaseErrorReportInDeps,
reference: "issue #36887 <https://github.com/rust-lang/rust/issues/36887>",
};
}
@@ -4315,39 +4314,6 @@ declare_lint! {
report_in_external_macro
}
-declare_lint! {
- /// The `byte_slice_in_packed_struct_with_derive` lint detects cases where a byte slice field
- /// (`[u8]`) or string slice field (`str`) is used in a `packed` struct that derives one or
- /// more built-in traits.
- ///
- /// ### Example
- ///
- /// ```rust
- /// #[repr(packed)]
- /// #[derive(Hash)]
- /// struct FlexZeroSlice {
- /// width: u8,
- /// data: [u8],
- /// }
- /// ```
- ///
- /// {{produces}}
- ///
- /// ### Explanation
- ///
- /// This was previously accepted but is being phased out, because fields in packed structs are
- /// now required to implement `Copy` for `derive` to work. Byte slices and string slices are a
- /// temporary exception because certain crates depended on them.
- pub BYTE_SLICE_IN_PACKED_STRUCT_WITH_DERIVE,
- Warn,
- "`[u8]` or `str` used in a packed struct with `derive`",
- @future_incompatible = FutureIncompatibleInfo {
- reason: FutureIncompatibilityReason::FutureReleaseErrorReportInDeps,
- reference: "issue #107457 <https://github.com/rust-lang/rust/issues/107457>",
- };
- report_in_external_macro
-}
-
declare_lint! {
/// The `invalid_macro_export_arguments` lint detects cases where `#[macro_export]` is being used with invalid arguments.
///
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 755f67b3f4fe0..a0d0d80b9572e 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -116,130 +116,130 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
let attrs = self.tcx.hir().attrs(hir_id);
for attr in attrs {
match attr.path().as_slice() {
- [sym::diagnostic, sym::do_not_recommend] => {
+ [sym::diagnostic, sym::do_not_recommend, ..] => {
self.check_do_not_recommend(attr.span, hir_id, target)
}
- [sym::diagnostic, sym::on_unimplemented] => {
+ [sym::diagnostic, sym::on_unimplemented, ..] => {
self.check_diagnostic_on_unimplemented(attr.span, hir_id, target)
}
- [sym::inline] => self.check_inline(hir_id, attr, span, target),
- [sym::coverage] => self.check_coverage(attr, span, target),
- [sym::optimize] => self.check_optimize(hir_id, attr, target),
- [sym::non_exhaustive] => self.check_non_exhaustive(hir_id, attr, span, target),
- [sym::marker] => self.check_marker(hir_id, attr, span, target),
- [sym::target_feature] => {
+ [sym::inline, ..] => self.check_inline(hir_id, attr, span, target),
+ [sym::coverage, ..] => self.check_coverage(attr, span, target),
+ [sym::optimize, ..] => self.check_optimize(hir_id, attr, target),
+ [sym::non_exhaustive, ..] => self.check_non_exhaustive(hir_id, attr, span, target),
+ [sym::marker, ..] => self.check_marker(hir_id, attr, span, target),
+ [sym::target_feature, ..] => {
self.check_target_feature(hir_id, attr, span, target, attrs)
}
- [sym::thread_local] => self.check_thread_local(attr, span, target),
- [sym::track_caller] => {
+ [sym::thread_local, ..] => self.check_thread_local(attr, span, target),
+ [sym::track_caller, ..] => {
self.check_track_caller(hir_id, attr.span, attrs, span, target)
}
- [sym::doc] => self.check_doc_attrs(
+ [sym::doc, ..] => self.check_doc_attrs(
attr,
hir_id,
target,
&mut specified_inline,
&mut doc_aliases,
),
- [sym::no_link] => self.check_no_link(hir_id, attr, span, target),
- [sym::export_name] => self.check_export_name(hir_id, attr, span, target),
- [sym::rustc_layout_scalar_valid_range_start]
- | [sym::rustc_layout_scalar_valid_range_end] => {
+ [sym::no_link, ..] => self.check_no_link(hir_id, attr, span, target),
+ [sym::export_name, ..] => self.check_export_name(hir_id, attr, span, target),
+ [sym::rustc_layout_scalar_valid_range_start, ..]
+ | [sym::rustc_layout_scalar_valid_range_end, ..] => {
self.check_rustc_layout_scalar_valid_range(attr, span, target)
}
- [sym::allow_internal_unstable] => {
+ [sym::allow_internal_unstable, ..] => {
self.check_allow_internal_unstable(hir_id, attr, span, target, attrs)
}
- [sym::debugger_visualizer] => self.check_debugger_visualizer(attr, target),
- [sym::rustc_allow_const_fn_unstable] => {
+ [sym::debugger_visualizer, ..] => self.check_debugger_visualizer(attr, target),
+ [sym::rustc_allow_const_fn_unstable, ..] => {
self.check_rustc_allow_const_fn_unstable(hir_id, attr, span, target)
}
- [sym::rustc_std_internal_symbol] => {
+ [sym::rustc_std_internal_symbol, ..] => {
self.check_rustc_std_internal_symbol(attr, span, target)
}
- [sym::naked] => self.check_naked(hir_id, attr, span, target, attrs),
- [sym::rustc_never_returns_null_ptr] => {
+ [sym::naked, ..] => self.check_naked(hir_id, attr, span, target, attrs),
+ [sym::rustc_never_returns_null_ptr, ..] => {
self.check_applied_to_fn_or_method(hir_id, attr, span, target)
}
- [sym::rustc_legacy_const_generics] => {
+ [sym::rustc_legacy_const_generics, ..] => {
self.check_rustc_legacy_const_generics(hir_id, attr, span, target, item)
}
- [sym::rustc_lint_query_instability] => {
+ [sym::rustc_lint_query_instability, ..] => {
self.check_rustc_lint_query_instability(hir_id, attr, span, target)
}
- [sym::rustc_lint_diagnostics] => {
+ [sym::rustc_lint_diagnostics, ..] => {
self.check_rustc_lint_diagnostics(hir_id, attr, span, target)
}
- [sym::rustc_lint_opt_ty] => self.check_rustc_lint_opt_ty(attr, span, target),
- [sym::rustc_lint_opt_deny_field_access] => {
+ [sym::rustc_lint_opt_ty, ..] => self.check_rustc_lint_opt_ty(attr, span, target),
+ [sym::rustc_lint_opt_deny_field_access, ..] => {
self.check_rustc_lint_opt_deny_field_access(attr, span, target)
}
- [sym::rustc_clean]
- | [sym::rustc_dirty]
- | [sym::rustc_if_this_changed]
- | [sym::rustc_then_this_would_need] => self.check_rustc_dirty_clean(attr),
- [sym::rustc_coinductive]
- | [sym::rustc_must_implement_one_of]
- | [sym::rustc_deny_explicit_impl]
- | [sym::const_trait] => self.check_must_be_applied_to_trait(attr, span, target),
- [sym::cmse_nonsecure_entry] => {
+ [sym::rustc_clean, ..]
+ | [sym::rustc_dirty, ..]
+ | [sym::rustc_if_this_changed, ..]
+ | [sym::rustc_then_this_would_need, ..] => self.check_rustc_dirty_clean(attr),
+ [sym::rustc_coinductive, ..]
+ | [sym::rustc_must_implement_one_of, ..]
+ | [sym::rustc_deny_explicit_impl, ..]
+ | [sym::const_trait, ..] => self.check_must_be_applied_to_trait(attr, span, target),
+ [sym::cmse_nonsecure_entry, ..] => {
self.check_cmse_nonsecure_entry(hir_id, attr, span, target)
}
- [sym::collapse_debuginfo] => self.check_collapse_debuginfo(attr, span, target),
- [sym::must_not_suspend] => self.check_must_not_suspend(attr, span, target),
- [sym::must_use] => self.check_must_use(hir_id, attr, target),
- [sym::rustc_pass_by_value] => self.check_pass_by_value(attr, span, target),
- [sym::rustc_allow_incoherent_impl] => {
+ [sym::collapse_debuginfo, ..] => self.check_collapse_debuginfo(attr, span, target),
+ [sym::must_not_suspend, ..] => self.check_must_not_suspend(attr, span, target),
+ [sym::must_use, ..] => self.check_must_use(hir_id, attr, target),
+ [sym::rustc_pass_by_value, ..] => self.check_pass_by_value(attr, span, target),
+ [sym::rustc_allow_incoherent_impl, ..] => {
self.check_allow_incoherent_impl(attr, span, target)
}
- [sym::rustc_has_incoherent_inherent_impls] => {
+ [sym::rustc_has_incoherent_inherent_impls, ..] => {
self.check_has_incoherent_inherent_impls(attr, span, target)
}
- [sym::ffi_pure] => self.check_ffi_pure(attr.span, attrs, target),
- [sym::ffi_const] => self.check_ffi_const(attr.span, target),
- [sym::rustc_const_unstable]
- | [sym::rustc_const_stable]
- | [sym::unstable]
- | [sym::stable]
- | [sym::rustc_allowed_through_unstable_modules]
- | [sym::rustc_promotable] => self.check_stability_promotable(attr, target),
- [sym::link_ordinal] => self.check_link_ordinal(attr, span, target),
- [sym::rustc_confusables] => self.check_confusables(attr, target),
- [sym::rustc_safe_intrinsic] => {
+ [sym::ffi_pure, ..] => self.check_ffi_pure(attr.span, attrs, target),
+ [sym::ffi_const, ..] => self.check_ffi_const(attr.span, target),
+ [sym::rustc_const_unstable, ..]
+ | [sym::rustc_const_stable, ..]
+ | [sym::unstable, ..]
+ | [sym::stable, ..]
+ | [sym::rustc_allowed_through_unstable_modules, ..]
+ | [sym::rustc_promotable, ..] => self.check_stability_promotable(attr, target),
+ [sym::link_ordinal, ..] => self.check_link_ordinal(attr, span, target),
+ [sym::rustc_confusables, ..] => self.check_confusables(attr, target),
+ [sym::rustc_safe_intrinsic, ..] => {
self.check_rustc_safe_intrinsic(hir_id, attr, span, target)
}
- [sym::cold] => self.check_cold(hir_id, attr, span, target),
- [sym::link] => self.check_link(hir_id, attr, span, target),
- [sym::link_name] => self.check_link_name(hir_id, attr, span, target),
- [sym::link_section] => self.check_link_section(hir_id, attr, span, target),
- [sym::no_mangle] => self.check_no_mangle(hir_id, attr, span, target),
- [sym::deprecated] => self.check_deprecated(hir_id, attr, span, target),
- [sym::macro_use] | [sym::macro_escape] => {
+ [sym::cold, ..] => self.check_cold(hir_id, attr, span, target),
+ [sym::link, ..] => self.check_link(hir_id, attr, span, target),
+ [sym::link_name, ..] => self.check_link_name(hir_id, attr, span, target),
+ [sym::link_section, ..] => self.check_link_section(hir_id, attr, span, target),
+ [sym::no_mangle, ..] => self.check_no_mangle(hir_id, attr, span, target),
+ [sym::deprecated, ..] => self.check_deprecated(hir_id, attr, span, target),
+ [sym::macro_use, ..] | [sym::macro_escape, ..] => {
self.check_macro_use(hir_id, attr, target)
}
- [sym::path] => self.check_generic_attr(hir_id, attr, target, Target::Mod),
- [sym::macro_export] => self.check_macro_export(hir_id, attr, target),
- [sym::ignore] | [sym::should_panic] => {
+ [sym::path, ..] => self.check_generic_attr(hir_id, attr, target, Target::Mod),
+ [sym::macro_export, ..] => self.check_macro_export(hir_id, attr, target),
+ [sym::ignore, ..] | [sym::should_panic, ..] => {
self.check_generic_attr(hir_id, attr, target, Target::Fn)
}
- [sym::automatically_derived] => {
+ [sym::automatically_derived, ..] => {
self.check_generic_attr(hir_id, attr, target, Target::Impl)
}
- [sym::no_implicit_prelude] => {
+ [sym::no_implicit_prelude, ..] => {
self.check_generic_attr(hir_id, attr, target, Target::Mod)
}
- [sym::rustc_object_lifetime_default] => self.check_object_lifetime_default(hir_id),
- [sym::proc_macro] => {
+ [sym::rustc_object_lifetime_default, ..] => self.check_object_lifetime_default(hir_id),
+ [sym::proc_macro, ..] => {
self.check_proc_macro(hir_id, target, ProcMacroKind::FunctionLike)
}
- [sym::proc_macro_attribute] => {
+ [sym::proc_macro_attribute, ..] => {
self.check_proc_macro(hir_id, target, ProcMacroKind::Attribute);
}
- [sym::proc_macro_derive] => {
+ [sym::proc_macro_derive, ..] => {
self.check_generic_attr(hir_id, attr, target, Target::Fn);
self.check_proc_macro(hir_id, target, ProcMacroKind::Derive)
}
- [sym::coroutine] => {
+ [sym::coroutine, ..] => {
self.check_coroutine(attr, target);
}
[
@@ -273,14 +273,16 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
| sym::default_lib_allocator
| sym::start
| sym::custom_mir,
+ ..
] => {}
[name, ..] => {
match BUILTIN_ATTRIBUTE_MAP.get(name) {
// checked below
Some(BuiltinAttribute { type_: AttributeType::CrateLevel, .. }) => {}
Some(_) => {
- // FIXME: differentiate between unstable and internal attributes just like we do with features instead
- // of just accepting `rustc_` attributes by name. That should allow trimming the above list, too.
+ // FIXME: differentiate between unstable and internal attributes just
+ // like we do with features instead of just accepting `rustc_`
+ // attributes by name. That should allow trimming the above list, too.
if !name.as_str().starts_with("rustc_") {
span_bug!(
attr.span,
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 0fa5cde9424b5..c7af21027b8d3 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -48,6 +48,7 @@ pub(crate) enum ImportKind<'a> {
/// `source` in `use prefix::source as target`.
source: Ident,
/// `target` in `use prefix::source as target`.
+ /// It will directly use `source` when the format is `use prefix::source`.
target: Ident,
/// Bindings to which `source` refers to.
source_bindings: PerNS<Cell<Result<NameBinding<'a>, Determinacy>>>,
diff --git a/config.example.toml b/config.example.toml
index 45faa66ec114f..1a7bdc4737fbf 100644
--- a/config.example.toml
+++ b/config.example.toml
@@ -472,7 +472,8 @@
# This is mostly useful for tools; if you have changes to `compiler/` or `library/` they will be ignored.
#
# Set this to "if-unchanged" to only download if the compiler and standard library have not been modified.
-# Set this to `true` to download unconditionally (useful if e.g. you are only changing doc-comments).
+# Set this to `true` to download unconditionally. This is useful if you are working on tools, doc-comments,
+# or library (you will be able to build the standard library without needing to build the compiler).
#download-rustc = false
# Number of codegen units to use for each compiler invocation. A value of 0
diff --git a/library/alloc/src/collections/btree/set.rs b/library/alloc/src/collections/btree/set.rs
index 74b000fd1c40b..973e7c660670c 100644
--- a/library/alloc/src/collections/btree/set.rs
+++ b/library/alloc/src/collections/btree/set.rs
@@ -5,7 +5,7 @@ use core::fmt::{self, Debug};
use core::hash::{Hash, Hasher};
use core::iter::{FusedIterator, Peekable};
use core::mem::ManuallyDrop;
-use core::ops::{BitAnd, BitOr, BitXor, RangeBounds, Sub};
+use core::ops::{BitAnd, BitOr, BitXor, Bound, RangeBounds, Sub};
use super::map::{BTreeMap, Keys};
use super::merge_iter::MergeIterInner;
@@ -1182,6 +1182,178 @@ impl<T, A: Allocator + Clone> BTreeSet<T, A> {
pub const fn is_empty(&self) -> bool {
self.len() == 0
}
+
+ /// Returns a [`Cursor`] pointing at the gap before the smallest element
+ /// greater than the given bound.
+ ///
+ /// Passing `Bound::Included(x)` will return a cursor pointing to the
+ /// gap before the smallest element greater than or equal to `x`.
+ ///
+ /// Passing `Bound::Excluded(x)` will return a cursor pointing to the
+ /// gap before the smallest element greater than `x`.
+ ///
+ /// Passing `Bound::Unbounded` will return a cursor pointing to the
+ /// gap before the smallest element in the set.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(btree_cursors)]
+ ///
+ /// use std::collections::BTreeSet;
+ /// use std::ops::Bound;
+ ///
+ /// let set = BTreeSet::from([1, 2, 3, 4]);
+ ///
+ /// let cursor = set.lower_bound(Bound::Included(&2));
+ /// assert_eq!(cursor.peek_prev(), Some(&1));
+ /// assert_eq!(cursor.peek_next(), Some(&2));
+ ///
+ /// let cursor = set.lower_bound(Bound::Excluded(&2));
+ /// assert_eq!(cursor.peek_prev(), Some(&2));
+ /// assert_eq!(cursor.peek_next(), Some(&3));
+ ///
+ /// let cursor = set.lower_bound(Bound::Unbounded);
+ /// assert_eq!(cursor.peek_prev(), None);
+ /// assert_eq!(cursor.peek_next(), Some(&1));
+ /// ```
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn lower_bound<Q: ?Sized>(&self, bound: Bound<&Q>) -> Cursor<'_, T>
+ where
+ T: Borrow<Q> + Ord,
+ Q: Ord,
+ {
+ Cursor { inner: self.map.lower_bound(bound) }
+ }
+
+ /// Returns a [`CursorMut`] pointing at the gap before the smallest element
+ /// greater than the given bound.
+ ///
+ /// Passing `Bound::Included(x)` will return a cursor pointing to the
+ /// gap before the smallest element greater than or equal to `x`.
+ ///
+ /// Passing `Bound::Excluded(x)` will return a cursor pointing to the
+ /// gap before the smallest element greater than `x`.
+ ///
+ /// Passing `Bound::Unbounded` will return a cursor pointing to the
+ /// gap before the smallest element in the set.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(btree_cursors)]
+ ///
+ /// use std::collections::BTreeSet;
+ /// use std::ops::Bound;
+ ///
+ /// let mut set = BTreeSet::from([1, 2, 3, 4]);
+ ///
+ /// let mut cursor = set.lower_bound_mut(Bound::Included(&2));
+ /// assert_eq!(cursor.peek_prev(), Some(&1));
+ /// assert_eq!(cursor.peek_next(), Some(&2));
+ ///
+ /// let mut cursor = set.lower_bound_mut(Bound::Excluded(&2));
+ /// assert_eq!(cursor.peek_prev(), Some(&2));
+ /// assert_eq!(cursor.peek_next(), Some(&3));
+ ///
+ /// let mut cursor = set.lower_bound_mut(Bound::Unbounded);
+ /// assert_eq!(cursor.peek_prev(), None);
+ /// assert_eq!(cursor.peek_next(), Some(&1));
+ /// ```
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn lower_bound_mut<Q: ?Sized>(&mut self, bound: Bound<&Q>) -> CursorMut<'_, T, A>
+ where
+ T: Borrow<Q> + Ord,
+ Q: Ord,
+ {
+ CursorMut { inner: self.map.lower_bound_mut(bound) }
+ }
+
+ /// Returns a [`Cursor`] pointing at the gap after the greatest element
+ /// smaller than the given bound.
+ ///
+ /// Passing `Bound::Included(x)` will return a cursor pointing to the
+ /// gap after the greatest element smaller than or equal to `x`.
+ ///
+ /// Passing `Bound::Excluded(x)` will return a cursor pointing to the
+ /// gap after the greatest element smaller than `x`.
+ ///
+ /// Passing `Bound::Unbounded` will return a cursor pointing to the
+ /// gap after the greatest element in the set.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(btree_cursors)]
+ ///
+ /// use std::collections::BTreeSet;
+ /// use std::ops::Bound;
+ ///
+ /// let set = BTreeSet::from([1, 2, 3, 4]);
+ ///
+ /// let cursor = set.upper_bound(Bound::Included(&3));
+ /// assert_eq!(cursor.peek_prev(), Some(&3));
+ /// assert_eq!(cursor.peek_next(), Some(&4));
+ ///
+ /// let cursor = set.upper_bound(Bound::Excluded(&3));
+ /// assert_eq!(cursor.peek_prev(), Some(&2));
+ /// assert_eq!(cursor.peek_next(), Some(&3));
+ ///
+ /// let cursor = set.upper_bound(Bound::Unbounded);
+ /// assert_eq!(cursor.peek_prev(), Some(&4));
+ /// assert_eq!(cursor.peek_next(), None);
+ /// ```
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn upper_bound<Q: ?Sized>(&self, bound: Bound<&Q>) -> Cursor<'_, T>
+ where
+ T: Borrow<Q> + Ord,
+ Q: Ord,
+ {
+ Cursor { inner: self.map.upper_bound(bound) }
+ }
+
+ /// Returns a [`CursorMut`] pointing at the gap after the greatest element
+ /// smaller than the given bound.
+ ///
+ /// Passing `Bound::Included(x)` will return a cursor pointing to the
+ /// gap after the greatest element smaller than or equal to `x`.
+ ///
+ /// Passing `Bound::Excluded(x)` will return a cursor pointing to the
+ /// gap after the greatest element smaller than `x`.
+ ///
+ /// Passing `Bound::Unbounded` will return a cursor pointing to the
+ /// gap after the greatest element in the set.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(btree_cursors)]
+ ///
+ /// use std::collections::BTreeSet;
+ /// use std::ops::Bound;
+ ///
+ /// let mut set = BTreeSet::from([1, 2, 3, 4]);
+ ///
+ /// let mut cursor = unsafe { set.upper_bound_mut(Bound::Included(&3)) };
+ /// assert_eq!(cursor.peek_prev(), Some(&3));
+ /// assert_eq!(cursor.peek_next(), Some(&4));
+ ///
+ /// let mut cursor = unsafe { set.upper_bound_mut(Bound::Excluded(&3)) };
+ /// assert_eq!(cursor.peek_prev(), Some(&2));
+ /// assert_eq!(cursor.peek_next(), Some(&3));
+ ///
+ /// let mut cursor = unsafe { set.upper_bound_mut(Bound::Unbounded) };
+ /// assert_eq!(cursor.peek_prev(), Some(&4));
+ /// assert_eq!(cursor.peek_next(), None);
+ /// ```
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub unsafe fn upper_bound_mut<Q: ?Sized>(&mut self, bound: Bound<&Q>) -> CursorMut<'_, T, A>
+ where
+ T: Borrow<Q> + Ord,
+ Q: Ord,
+ {
+ CursorMut { inner: self.map.upper_bound_mut(bound) }
+ }
}
#[stable(feature = "rust1", since = "1.0.0")]
@@ -1816,5 +1988,414 @@ impl<'a, T: Ord> Iterator for Union<'a, T> {
#[stable(feature = "fused", since = "1.26.0")]
impl<T: Ord> FusedIterator for Union<'_, T> {}
+/// A cursor over a `BTreeSet`.
+///
+/// A `Cursor` is like an iterator, except that it can freely seek back-and-forth.
+///
+/// Cursors always point to a gap between two elements in the set, and can
+/// operate on the two immediately adjacent elements.
+///
+/// A `Cursor` is created with the [`BTreeSet::lower_bound`] and [`BTreeSet::upper_bound`] methods.
+#[derive(Clone)]
+#[unstable(feature = "btree_cursors", issue = "107540")]
+pub struct Cursor<'a, K: 'a> {
+ inner: super::map::Cursor<'a, K, SetValZST>,
+}
+
+#[unstable(feature = "btree_cursors", issue = "107540")]
+impl<K: Debug> Debug for Cursor<'_, K> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.write_str("Cursor")
+ }
+}
+
+/// A cursor over a `BTreeSet` with editing operations.
+///
+/// A `Cursor` is like an iterator, except that it can freely seek back-and-forth, and can
+/// safely mutate the set during iteration. This is because the lifetime of its yielded
+/// references is tied to its own lifetime, instead of just the underlying map. This means
+/// cursors cannot yield multiple elements at once.
+///
+/// Cursors always point to a gap between two elements in the set, and can
+/// operate on the two immediately adjacent elements.
+///
+/// A `CursorMut` is created with the [`BTreeSet::lower_bound_mut`] and [`BTreeSet::upper_bound_mut`]
+/// methods.
+#[unstable(feature = "btree_cursors", issue = "107540")]
+pub struct CursorMut<'a, K: 'a, #[unstable(feature = "allocator_api", issue = "32838")] A = Global>
+{
+ inner: super::map::CursorMut<'a, K, SetValZST, A>,
+}
+
+#[unstable(feature = "btree_cursors", issue = "107540")]
+impl<K: Debug, A> Debug for CursorMut<'_, K, A> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.write_str("CursorMut")
+ }
+}
+
+/// A cursor over a `BTreeSet` with editing operations, and which allows
+/// mutating elements.
+///
+/// A `Cursor` is like an iterator, except that it can freely seek back-and-forth, and can
+/// safely mutate the set during iteration. This is because the lifetime of its yielded
+/// references is tied to its own lifetime, instead of just the underlying set. This means
+/// cursors cannot yield multiple elements at once.
+///
+/// Cursors always point to a gap between two elements in the set, and can
+/// operate on the two immediately adjacent elements.
+///
+/// A `CursorMutKey` is created from a [`CursorMut`] with the
+/// [`CursorMut::with_mutable_key`] method.
+///
+/// # Safety
+///
+/// Since this cursor allows mutating elements, you must ensure that the
+/// `BTreeSet` invariants are maintained. Specifically:
+///
+/// * The newly inserted element must be unique in the tree.
+/// * All elements in the tree must remain in sorted order.
+#[unstable(feature = "btree_cursors", issue = "107540")]
+pub struct CursorMutKey<
+ 'a,
+ K: 'a,
+ #[unstable(feature = "allocator_api", issue = "32838")] A = Global,
+> {
+ inner: super::map::CursorMutKey<'a, K, SetValZST, A>,
+}
+
+#[unstable(feature = "btree_cursors", issue = "107540")]
+impl<K: Debug, A> Debug for CursorMutKey<'_, K, A> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.write_str("CursorMutKey")
+ }
+}
+
+impl<'a, K> Cursor<'a, K> {
+ /// Advances the cursor to the next gap, returning the element that it
+ /// moved over.
+ ///
+ /// If the cursor is already at the end of the set then `None` is returned
+ /// and the cursor is not moved.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn next(&mut self) -> Option<&'a K> {
+ self.inner.next().map(|(k, _)| k)
+ }
+
+ /// Advances the cursor to the previous gap, returning the element that it
+ /// moved over.
+ ///
+ /// If the cursor is already at the start of the set then `None` is returned
+ /// and the cursor is not moved.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn prev(&mut self) -> Option<&'a K> {
+ self.inner.prev().map(|(k, _)| k)
+ }
+
+ /// Returns a reference to next element without moving the cursor.
+ ///
+ /// If the cursor is at the end of the set then `None` is returned
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn peek_next(&self) -> Option<&'a K> {
+ self.inner.peek_next().map(|(k, _)| k)
+ }
+
+ /// Returns a reference to the previous element without moving the cursor.
+ ///
+ /// If the cursor is at the start of the set then `None` is returned.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn peek_prev(&self) -> Option<&'a K> {
+ self.inner.peek_prev().map(|(k, _)| k)
+ }
+}
+
+impl<'a, T, A> CursorMut<'a, T, A> {
+ /// Advances the cursor to the next gap, returning the element that it
+ /// moved over.
+ ///
+ /// If the cursor is already at the end of the set then `None` is returned
+ /// and the cursor is not moved.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn next(&mut self) -> Option<&T> {
+ self.inner.next().map(|(k, _)| k)
+ }
+
+ /// Advances the cursor to the previous gap, returning the element that it
+ /// moved over.
+ ///
+ /// If the cursor is already at the start of the set then `None` is returned
+ /// and the cursor is not moved.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn prev(&mut self) -> Option<&T> {
+ self.inner.prev().map(|(k, _)| k)
+ }
+
+ /// Returns a reference to the next element without moving the cursor.
+ ///
+ /// If the cursor is at the end of the set then `None` is returned.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn peek_next(&mut self) -> Option<&T> {
+ self.inner.peek_next().map(|(k, _)| k)
+ }
+
+ /// Returns a reference to the previous element without moving the cursor.
+ ///
+ /// If the cursor is at the start of the set then `None` is returned.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn peek_prev(&mut self) -> Option<&T> {
+ self.inner.peek_prev().map(|(k, _)| k)
+ }
+
+ /// Returns a read-only cursor pointing to the same location as the
+ /// `CursorMut`.
+ ///
+ /// The lifetime of the returned `Cursor` is bound to that of the
+ /// `CursorMut`, which means it cannot outlive the `CursorMut` and that the
+ /// `CursorMut` is frozen for the lifetime of the `Cursor`.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn as_cursor(&self) -> Cursor<'_, T> {
+ Cursor { inner: self.inner.as_cursor() }
+ }
+
+ /// Converts the cursor into a [`CursorMutKey`], which allows mutating
+ /// elements in the tree.
+ ///
+ /// # Safety
+ ///
+ /// Since this cursor allows mutating elements, you must ensure that the
+ /// `BTreeSet` invariants are maintained. Specifically:
+ ///
+ /// * The newly inserted element must be unique in the tree.
+ /// * All elements in the tree must remain in sorted order.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub unsafe fn with_mutable_key(self) -> CursorMutKey<'a, T, A> {
+ CursorMutKey { inner: unsafe { self.inner.with_mutable_key() } }
+ }
+}
+
+impl<'a, T, A> CursorMutKey<'a, T, A> {
+ /// Advances the cursor to the next gap, returning the element that it
+ /// moved over.
+ ///
+ /// If the cursor is already at the end of the set then `None` is returned
+ /// and the cursor is not moved.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn next(&mut self) -> Option<&mut T> {
+ self.inner.next().map(|(k, _)| k)
+ }
+
+ /// Advances the cursor to the previous gap, returning the element that it
+ /// moved over.
+ ///
+ /// If the cursor is already at the start of the set then `None` is returned
+ /// and the cursor is not moved.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn prev(&mut self) -> Option<&mut T> {
+ self.inner.prev().map(|(k, _)| k)
+ }
+
+ /// Returns a reference to the next element without moving the cursor.
+ ///
+ /// If the cursor is at the end of the set then `None` is returned
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn peek_next(&mut self) -> Option<&mut T> {
+ self.inner.peek_next().map(|(k, _)| k)
+ }
+
+ /// Returns a reference to the previous element without moving the cursor.
+ ///
+ /// If the cursor is at the start of the set then `None` is returned.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn peek_prev(&mut self) -> Option<&mut T> {
+ self.inner.peek_prev().map(|(k, _)| k)
+ }
+
+ /// Returns a read-only cursor pointing to the same location as the
+ /// `CursorMutKey`.
+ ///
+ /// The lifetime of the returned `Cursor` is bound to that of the
+ /// `CursorMutKey`, which means it cannot outlive the `CursorMutKey` and that the
+ /// `CursorMutKey` is frozen for the lifetime of the `Cursor`.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn as_cursor(&self) -> Cursor<'_, T> {
+ Cursor { inner: self.inner.as_cursor() }
+ }
+}
+
+impl<'a, T: Ord, A: Allocator + Clone> CursorMut<'a, T, A> {
+ /// Inserts a new element into the set in the gap that the
+ /// cursor is currently pointing to.
+ ///
+ /// After the insertion the cursor will be pointing at the gap before the
+ /// newly inserted element.
+ ///
+ /// # Safety
+ ///
+ /// You must ensure that the `BTreeSet` invariants are maintained.
+ /// Specifically:
+ ///
+ /// * The newly inserted element must be unique in the tree.
+ /// * All elements in the tree must remain in sorted order.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub unsafe fn insert_after_unchecked(&mut self, value: T) {
+ unsafe { self.inner.insert_after_unchecked(value, SetValZST) }
+ }
+
+ /// Inserts a new element into the set in the gap that the
+ /// cursor is currently pointing to.
+ ///
+ /// After the insertion the cursor will be pointing at the gap after the
+ /// newly inserted element.
+ ///
+ /// # Safety
+ ///
+ /// You must ensure that the `BTreeSet` invariants are maintained.
+ /// Specifically:
+ ///
+ /// * The newly inserted element must be unique in the tree.
+ /// * All elements in the tree must remain in sorted order.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub unsafe fn insert_before_unchecked(&mut self, value: T) {
+ unsafe { self.inner.insert_before_unchecked(value, SetValZST) }
+ }
+
+ /// Inserts a new element into the set in the gap that the
+ /// cursor is currently pointing to.
+ ///
+ /// After the insertion the cursor will be pointing at the gap before the
+ /// newly inserted element.
+ ///
+ /// If the inserted element is not greater than the element before the
+ /// cursor (if any), or if it not less than the element after the cursor (if
+ /// any), then an [`UnorderedKeyError`] is returned since this would
+ /// invalidate the [`Ord`] invariant between the elements of the set.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn insert_after(&mut self, value: T) -> Result<(), UnorderedKeyError> {
+ self.inner.insert_after(value, SetValZST)
+ }
+
+ /// Inserts a new element into the set in the gap that the
+ /// cursor is currently pointing to.
+ ///
+ /// After the insertion the cursor will be pointing at the gap after the
+ /// newly inserted element.
+ ///
+ /// If the inserted element is not greater than the element before the
+ /// cursor (if any), or if it not less than the element after the cursor (if
+ /// any), then an [`UnorderedKeyError`] is returned since this would
+ /// invalidate the [`Ord`] invariant between the elements of the set.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn insert_before(&mut self, value: T) -> Result<(), UnorderedKeyError> {
+ self.inner.insert_before(value, SetValZST)
+ }
+
+ /// Removes the next element from the `BTreeSet`.
+ ///
+ /// The element that was removed is returned. The cursor position is
+ /// unchanged (before the removed element).
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn remove_next(&mut self) -> Option<T> {
+ self.inner.remove_next().map(|(k, _)| k)
+ }
+
+ /// Removes the precending element from the `BTreeSet`.
+ ///
+ /// The element that was removed is returned. The cursor position is
+ /// unchanged (after the removed element).
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn remove_prev(&mut self) -> Option<T> {
+ self.inner.remove_prev().map(|(k, _)| k)
+ }
+}
+
+impl<'a, T: Ord, A: Allocator + Clone> CursorMutKey<'a, T, A> {
+ /// Inserts a new element into the set in the gap that the
+ /// cursor is currently pointing to.
+ ///
+ /// After the insertion the cursor will be pointing at the gap before the
+ /// newly inserted element.
+ ///
+ /// # Safety
+ ///
+ /// You must ensure that the `BTreeSet` invariants are maintained.
+ /// Specifically:
+ ///
+ /// * The key of the newly inserted element must be unique in the tree.
+ /// * All elements in the tree must remain in sorted order.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub unsafe fn insert_after_unchecked(&mut self, value: T) {
+ unsafe { self.inner.insert_after_unchecked(value, SetValZST) }
+ }
+
+ /// Inserts a new element into the set in the gap that the
+ /// cursor is currently pointing to.
+ ///
+ /// After the insertion the cursor will be pointing at the gap after the
+ /// newly inserted element.
+ ///
+ /// # Safety
+ ///
+ /// You must ensure that the `BTreeSet` invariants are maintained.
+ /// Specifically:
+ ///
+ /// * The newly inserted element must be unique in the tree.
+ /// * All elements in the tree must remain in sorted order.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub unsafe fn insert_before_unchecked(&mut self, value: T) {
+ unsafe { self.inner.insert_before_unchecked(value, SetValZST) }
+ }
+
+ /// Inserts a new element into the set in the gap that the
+ /// cursor is currently pointing to.
+ ///
+ /// After the insertion the cursor will be pointing at the gap before the
+ /// newly inserted element.
+ ///
+ /// If the inserted element is not greater than the element before the
+ /// cursor (if any), or if it not less than the element after the cursor (if
+ /// any), then an [`UnorderedKeyError`] is returned since this would
+ /// invalidate the [`Ord`] invariant between the elements of the set.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn insert_after(&mut self, value: T) -> Result<(), UnorderedKeyError> {
+ self.inner.insert_after(value, SetValZST)
+ }
+
+ /// Inserts a new element into the set in the gap that the
+ /// cursor is currently pointing to.
+ ///
+ /// After the insertion the cursor will be pointing at the gap after the
+ /// newly inserted element.
+ ///
+ /// If the inserted element is not greater than the element before the
+ /// cursor (if any), or if it not less than the element after the cursor (if
+ /// any), then an [`UnorderedKeyError`] is returned since this would
+ /// invalidate the [`Ord`] invariant between the elements of the set.
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn insert_before(&mut self, value: T) -> Result<(), UnorderedKeyError> {
+ self.inner.insert_before(value, SetValZST)
+ }
+
+ /// Removes the next element from the `BTreeSet`.
+ ///
+ /// The element that was removed is returned. The cursor position is
+ /// unchanged (before the removed element).
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn remove_next(&mut self) -> Option<T> {
+ self.inner.remove_next().map(|(k, _)| k)
+ }
+
+ /// Removes the precending element from the `BTreeSet`.
+ ///
+ /// The element that was removed is returned. The cursor position is
+ /// unchanged (after the removed element).
+ #[unstable(feature = "btree_cursors", issue = "107540")]
+ pub fn remove_prev(&mut self) -> Option<T> {
+ self.inner.remove_prev().map(|(k, _)| k)
+ }
+}
+
+#[unstable(feature = "btree_cursors", issue = "107540")]
+pub use super::map::UnorderedKeyError;
+
#[cfg(test)]
mod tests;
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 268e89c7f6011..c09180e542ff6 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -26,7 +26,8 @@ use crate::core::builder::{
use crate::core::config::{DebuginfoLevel, LlvmLibunwind, RustcLto, TargetSelection};
use crate::utils::exec::command;
use crate::utils::helpers::{
- exe, get_clang_cl_resource_dir, is_debug_info, is_dylib, symlink_dir, t, up_to_date,
+ self, exe, get_clang_cl_resource_dir, get_closest_merge_base_commit, is_debug_info, is_dylib,
+ symlink_dir, t, up_to_date,
};
use crate::{CLang, Compiler, DependencyType, GitRepo, Mode, LLVM_TOOLS};
@@ -114,21 +115,43 @@ impl Step for Std {
const DEFAULT: bool = true;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
- // When downloading stage1, the standard library has already been copied to the sysroot, so
- // there's no need to rebuild it.
- let builder = run.builder;
- run.crate_or_deps("sysroot")
- .path("library")
- .lazy_default_condition(Box::new(|| !builder.download_rustc()))
+ run.crate_or_deps("sysroot").path("library")
}
fn make_run(run: RunConfig<'_>) {
let crates = std_crates_for_run_make(&run);
+ let builder = run.builder;
+
+ // Force compilation of the standard library from source if the `library` is modified. This allows
+ // library team to compile the standard library without needing to compile the compiler with
+ // the `rust.download-rustc=true` option.
+ let force_recompile =
+ if builder.rust_info().is_managed_git_subrepository() && builder.download_rustc() {
+ let closest_merge_commit = get_closest_merge_base_commit(
+ Some(&builder.src),
+ &builder.config.git_config(),
+ &builder.config.stage0_metadata.config.git_merge_commit_email,
+ &[],
+ )
+ .unwrap();
+
+ // Check if `library` has changes (returns false otherwise)
+ !t!(helpers::git(Some(&builder.src))
+ .args(["diff-index", "--quiet", &closest_merge_commit])
+ .arg("--")
+ .arg(builder.src.join("library"))
+ .as_command_mut()
+ .status())
+ .success()
+ } else {
+ false
+ };
+
run.builder.ensure(Std {
compiler: run.builder.compiler(run.builder.top_stage, run.build_triple()),
target: run.target,
crates,
- force_recompile: false,
+ force_recompile,
extra_rust_args: &[],
is_for_mir_opt_tests: false,
});
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index d92bc8456649f..f8953f0ebcfb5 100644
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -12,7 +12,7 @@ use rustc_middle::ty::fast_reject::SimplifiedType;
use rustc_middle::ty::{self, TyCtxt};
use rustc_span::def_id::LOCAL_CRATE;
use rustc_span::hygiene::MacroKind;
-use rustc_span::symbol::{kw, sym, Symbol};
+use rustc_span::symbol::{sym, Symbol};
use thin_vec::{thin_vec, ThinVec};
use {rustc_ast as ast, rustc_hir as hir};
@@ -792,11 +792,7 @@ fn build_macro(
fn filter_non_trait_generics(trait_did: DefId, mut g: clean::Generics) -> clean::Generics {
for pred in &mut g.where_predicates {
match *pred {
- clean::WherePredicate::BoundPredicate {
- ty: clean::Generic(ref s),
- ref mut bounds,
- ..
- } if *s == kw::SelfUpper => {
+ clean::WherePredicate::BoundPredicate { ty: clean::SelfTy, ref mut bounds, .. } => {
bounds.retain(|bound| match bound {
clean::GenericBound::TraitBound(clean::PolyTrait { trait_, .. }, _) => {
trait_.def_id() != trait_did
@@ -812,13 +808,13 @@ fn filter_non_trait_generics(trait_did: DefId, mut g: clean::Generics) -> clean:
clean::WherePredicate::BoundPredicate {
ty:
clean::QPath(box clean::QPathData {
- self_type: clean::Generic(ref s),
+ self_type: clean::Generic(_),
trait_: Some(trait_),
..
}),
bounds,
..
- } => !(bounds.is_empty() || *s == kw::SelfUpper && trait_.def_id() == trait_did),
+ } => !bounds.is_empty() && trait_.def_id() != trait_did,
_ => true,
});
g
@@ -832,9 +828,7 @@ fn separate_supertrait_bounds(
) -> (clean::Generics, Vec<clean::GenericBound>) {
let mut ty_bounds = Vec::new();
g.where_predicates.retain(|pred| match *pred {
- clean::WherePredicate::BoundPredicate { ty: clean::Generic(ref s), ref bounds, .. }
- if *s == kw::SelfUpper =>
- {
+ clean::WherePredicate::BoundPredicate { ty: clean::SelfTy, ref bounds, .. } => {
ty_bounds.extend(bounds.iter().cloned());
false
}
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 324b633e8ea7e..cffadc7c10a91 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -1351,11 +1351,11 @@ pub(crate) fn clean_middle_assoc_item<'tcx>(
let self_arg_ty =
tcx.fn_sig(assoc_item.def_id).instantiate_identity().input(0).skip_binder();
if self_arg_ty == self_ty {
- item.decl.inputs.values[0].type_ = Generic(kw::SelfUpper);
+ item.decl.inputs.values[0].type_ = SelfTy;
} else if let ty::Ref(_, ty, _) = *self_arg_ty.kind() {
if ty == self_ty {
match item.decl.inputs.values[0].type_ {
- BorrowedRef { ref mut type_, .. } => **type_ = Generic(kw::SelfUpper),
+ BorrowedRef { ref mut type_, .. } => **type_ = SelfTy,
_ => unreachable!(),
}
}
@@ -1439,9 +1439,8 @@ pub(crate) fn clean_middle_assoc_item<'tcx>(
if trait_.def_id() != assoc_item.container_id(tcx) {
return true;
}
- match *self_type {
- Generic(ref s) if *s == kw::SelfUpper => {}
- _ => return true,
+ if *self_type != SelfTy {
+ return true;
}
match &assoc.args {
GenericArgs::AngleBracketed { args, constraints } => {
@@ -2228,6 +2227,8 @@ pub(crate) fn clean_middle_ty<'tcx>(
ty::Param(ref p) => {
if let Some(bounds) = cx.impl_trait_bounds.remove(&p.index.into()) {
ImplTrait(bounds)
+ } else if p.name == kw::SelfUpper {
+ SelfTy
} else {
Generic(p.name)
}
diff --git a/src/librustdoc/clean/simplify.rs b/src/librustdoc/clean/simplify.rs
index 739f6eb8cc89d..1d81ae3eb8ba7 100644
--- a/src/librustdoc/clean/simplify.rs
+++ b/src/librustdoc/clean/simplify.rs
@@ -145,7 +145,6 @@ pub(crate) fn sized_bounds(cx: &mut DocContext<'_>, generics: &mut clean::Generi
// should be handled when cleaning associated types.
generics.where_predicates.retain(|pred| {
if let WP::BoundPredicate { ty: clean::Generic(param), bounds, .. } = pred
- && *param != rustc_span::symbol::kw::SelfUpper
&& bounds.iter().any(|b| b.is_sized_bound(cx))
{
sized_params.insert(*param);
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 7d5a16bc7e3d5..4850500a1bfae 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -34,10 +34,9 @@ use thin_vec::ThinVec;
use {rustc_ast as ast, rustc_hir as hir};
pub(crate) use self::ItemKind::*;
-pub(crate) use self::SelfTy::*;
pub(crate) use self::Type::{
Array, BareFunction, BorrowedRef, DynTrait, Generic, ImplTrait, Infer, Primitive, QPath,
- RawPointer, Slice, Tuple,
+ RawPointer, SelfTy, Slice, Tuple,
};
use crate::clean::cfg::Cfg;
use crate::clean::clean_middle_path;
@@ -1384,8 +1383,8 @@ pub(crate) struct FnDecl {
}
impl FnDecl {
- pub(crate) fn self_type(&self) -> Option<SelfTy> {
- self.inputs.values.get(0).and_then(|v| v.to_self())
+ pub(crate) fn receiver_type(&self) -> Option<&Type> {
+ self.inputs.values.get(0).and_then(|v| v.to_receiver())
}
}
@@ -1403,27 +1402,9 @@ pub(crate) struct Argument {
pub(crate) is_const: bool,
}
-#[derive(Clone, PartialEq, Debug)]
-pub(crate) enum SelfTy {
- SelfValue,
- SelfBorrowed(Option<Lifetime>, Mutability),
- SelfExplicit(Type),
-}
-
impl Argument {
- pub(crate) fn to_self(&self) -> Option<SelfTy> {
- if self.name != kw::SelfLower {
- return None;
- }
- if self.type_.is_self_type() {
- return Some(SelfValue);
- }
- match self.type_ {
- BorrowedRef { ref lifetime, mutability, ref type_ } if type_.is_self_type() => {
- Some(SelfBorrowed(lifetime.clone(), mutability))
- }
- _ => Some(SelfExplicit(self.type_.clone())),
- }
+ pub(crate) fn to_receiver(&self) -> Option<&Type> {
+ if self.name == kw::SelfLower { Some(&self.type_) } else { None }
}
}
@@ -1477,6 +1458,8 @@ pub(crate) enum Type {
DynTrait(Vec<PolyTrait>, Option<Lifetime>),
/// A type parameter.
Generic(Symbol),
+ /// The `Self` type.
+ SelfTy,
/// A primitive (aka, builtin) type.
Primitive(PrimitiveType),
/// A function pointer: `extern "ABI" fn(...) -> ...`
@@ -1571,6 +1554,8 @@ impl Type {
// If both sides are generic, this returns true.
(_, Type::Generic(_)) => true,
(Type::Generic(_), _) => false,
+ // `Self` only matches itself.
+ (Type::SelfTy, Type::SelfTy) => true,
// Paths account for both the path itself and its generics.
(Type::Path { path: a }, Type::Path { path: b }) => {
a.def_id() == b.def_id()
@@ -1642,7 +1627,7 @@ impl Type {
pub(crate) fn is_self_type(&self) -> bool {
match *self {
- Generic(name) => name == kw::SelfUpper,
+ SelfTy => true,
_ => false,
}
}
@@ -1700,7 +1685,7 @@ impl Type {
Type::Pat(..) => PrimitiveType::Pat,
RawPointer(..) => PrimitiveType::RawPointer,
QPath(box QPathData { ref self_type, .. }) => return self_type.def_id(cache),
- Generic(_) | Infer | ImplTrait(_) => return None,
+ Generic(_) | SelfTy | Infer | ImplTrait(_) => return None,
};
Primitive(t).def_id(cache)
}
diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs
index 2dd3041ab4c61..68266f3506a01 100644
--- a/src/librustdoc/clean/utils.rs
+++ b/src/librustdoc/clean/utils.rs
@@ -468,7 +468,7 @@ pub(crate) fn resolve_type(cx: &mut DocContext<'_>, path: Path) -> Type {
match path.res {
Res::PrimTy(p) => Primitive(PrimitiveType::from(p)),
Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } if path.segments.len() == 1 => {
- Generic(kw::SelfUpper)
+ Type::SelfTy
}
Res::Def(DefKind::TyParam, _) if path.segments.len() == 1 => Generic(path.segments[0].name),
_ => {
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index bb5ac303ffd63..b5ab6a35fdb9d 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -1006,6 +1006,7 @@ fn fmt_type<'cx>(
match *t {
clean::Generic(name) => f.write_str(name.as_str()),
+ clean::SelfTy => f.write_str("Self"),
clean::Type::Path { ref path } => {
// Paths like `T::Output` and `Self::Output` should be rendered with all segments.
let did = path.def_id();
@@ -1452,29 +1453,22 @@ impl clean::FnDecl {
let last_input_index = self.inputs.values.len().checked_sub(1);
for (i, input) in self.inputs.values.iter().enumerate() {
- if let Some(selfty) = input.to_self() {
+ if let Some(selfty) = input.to_receiver() {
match selfty {
- clean::SelfValue => {
+ clean::SelfTy => {
write!(f, "self")?;
}
- clean::SelfBorrowed(Some(ref lt), mutability) => {
- write!(
- f,
- "{amp}{lifetime} {mutability}self",
- lifetime = lt.print(),
- mutability = mutability.print_with_space(),
- )?;
- }
- clean::SelfBorrowed(None, mutability) => {
- write!(
- f,
- "{amp}{mutability}self",
- mutability = mutability.print_with_space(),
- )?;
+ clean::BorrowedRef { lifetime, mutability, type_: box clean::SelfTy } => {
+ write!(f, "{amp}")?;
+ match lifetime {
+ Some(lt) => write!(f, "{lt} ", lt = lt.print())?,
+ None => {}
+ }
+ write!(f, "{mutability}self", mutability = mutability.print_with_space())?;
}
- clean::SelfExplicit(ref typ) => {
+ _ => {
write!(f, "self: ")?;
- typ.print(cx).fmt(f)?;
+ selfty.print(cx).fmt(f)?;
}
}
} else {
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 9617f0d9a1f25..9074e40a53614 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -58,7 +58,7 @@ use serde::{Serialize, Serializer};
pub(crate) use self::context::*;
pub(crate) use self::span_map::{collect_spans_and_sources, LinkFromSrc};
-use crate::clean::{self, ItemId, RenderedLink, SelfTy};
+use crate::clean::{self, ItemId, RenderedLink};
use crate::error::Error;
use crate::formats::cache::Cache;
use crate::formats::item_type::ItemType;
@@ -1372,21 +1372,20 @@ fn render_deref_methods(
fn should_render_item(item: &clean::Item, deref_mut_: bool, tcx: TyCtxt<'_>) -> bool {
let self_type_opt = match *item.kind {
- clean::MethodItem(ref method, _) => method.decl.self_type(),
- clean::TyMethodItem(ref method) => method.decl.self_type(),
+ clean::MethodItem(ref method, _) => method.decl.receiver_type(),
+ clean::TyMethodItem(ref method) => method.decl.receiver_type(),
_ => None,
};
if let Some(self_ty) = self_type_opt {
- let (by_mut_ref, by_box, by_value) = match self_ty {
- SelfTy::SelfBorrowed(_, mutability)
- | SelfTy::SelfExplicit(clean::BorrowedRef { mutability, .. }) => {
+ let (by_mut_ref, by_box, by_value) = match *self_ty {
+ clean::Type::BorrowedRef { mutability, .. } => {
(mutability == Mutability::Mut, false, false)
}
- SelfTy::SelfExplicit(clean::Type::Path { path }) => {
+ clean::Type::Path { ref path } => {
(false, Some(path.def_id()) == tcx.lang_items().owned_box(), false)
}
- SelfTy::SelfValue => (false, false, true),
+ clean::Type::SelfTy => (false, false, true),
_ => (false, false, false),
};
diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index b3f4d82e054b8..8a2f31f7413e1 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -797,7 +797,11 @@ fn get_index_type_id(
}
}
// Not supported yet
- clean::Type::Pat(..) | clean::Generic(_) | clean::ImplTrait(_) | clean::Infer => None,
+ clean::Type::Pat(..)
+ | clean::Generic(_)
+ | clean::SelfTy
+ | clean::ImplTrait(_)
+ | clean::Infer => None,
}
}
@@ -850,34 +854,70 @@ fn simplify_fn_type<'tcx, 'a>(
// If this argument is a type parameter and not a trait bound or a type, we need to look
// for its bounds.
- if let Type::Generic(arg_s) = *arg {
- // First we check if the bounds are in a `where` predicate...
- let mut type_bounds = Vec::new();
- for where_pred in generics.where_predicates.iter().filter(|g| match g {
- WherePredicate::BoundPredicate { ty: Type::Generic(ty_s), .. } => *ty_s == arg_s,
- _ => false,
- }) {
- let bounds = where_pred.get_bounds().unwrap_or_else(|| &[]);
- for bound in bounds.iter() {
- if let Some(path) = bound.get_trait_path() {
- let ty = Type::Path { path };
- simplify_fn_type(
- self_,
- generics,
- &ty,
- tcx,
- recurse + 1,
- &mut type_bounds,
- rgen,
- is_return,
- cache,
- );
+ match *arg {
+ Type::Generic(arg_s) => {
+ // First we check if the bounds are in a `where` predicate...
+ let mut type_bounds = Vec::new();
+ for where_pred in generics.where_predicates.iter().filter(|g| match g {
+ WherePredicate::BoundPredicate { ty, .. } => *ty == *arg,
+ _ => false,
+ }) {
+ let bounds = where_pred.get_bounds().unwrap_or_else(|| &[]);
+ for bound in bounds.iter() {
+ if let Some(path) = bound.get_trait_path() {
+ let ty = Type::Path { path };
+ simplify_fn_type(
+ self_,
+ generics,
+ &ty,
+ tcx,
+ recurse + 1,
+ &mut type_bounds,
+ rgen,
+ is_return,
+ cache,
+ );
+ }
+ }
+ }
+ // Otherwise we check if the trait bounds are "inlined" like `T: Option<u32>`...
+ if let Some(bound) = generics.params.iter().find(|g| g.is_type() && g.name == arg_s) {
+ for bound in bound.get_bounds().unwrap_or(&[]) {
+ if let Some(path) = bound.get_trait_path() {
+ let ty = Type::Path { path };
+ simplify_fn_type(
+ self_,
+ generics,
+ &ty,
+ tcx,
+ recurse + 1,
+ &mut type_bounds,
+ rgen,
+ is_return,
+ cache,
+ );
+ }
}
}
+ if let Some((idx, _)) = rgen.get(&SimplifiedParam::Symbol(arg_s)) {
+ res.push(RenderType {
+ id: Some(RenderTypeId::Index(*idx)),
+ generics: None,
+ bindings: None,
+ });
+ } else {
+ let idx = -isize::try_from(rgen.len() + 1).unwrap();
+ rgen.insert(SimplifiedParam::Symbol(arg_s), (idx, type_bounds));
+ res.push(RenderType {
+ id: Some(RenderTypeId::Index(idx)),
+ generics: None,
+ bindings: None,
+ });
+ }
}
- // Otherwise we check if the trait bounds are "inlined" like `T: Option<u32>`...
- if let Some(bound) = generics.params.iter().find(|g| g.is_type() && g.name == arg_s) {
- for bound in bound.get_bounds().unwrap_or(&[]) {
+ Type::ImplTrait(ref bounds) => {
+ let mut type_bounds = Vec::new();
+ for bound in bounds {
if let Some(path) = bound.get_trait_path() {
let ty = Type::Path { path };
simplify_fn_type(
@@ -893,84 +933,22 @@ fn simplify_fn_type<'tcx, 'a>(
);
}
}
- }
- if let Some((idx, _)) = rgen.get(&SimplifiedParam::Symbol(arg_s)) {
- res.push(RenderType {
- id: Some(RenderTypeId::Index(*idx)),
- generics: None,
- bindings: None,
- });
- } else {
- let idx = -isize::try_from(rgen.len() + 1).unwrap();
- rgen.insert(SimplifiedParam::Symbol(arg_s), (idx, type_bounds));
- res.push(RenderType {
- id: Some(RenderTypeId::Index(idx)),
- generics: None,
- bindings: None,
- });
- }
- } else if let Type::ImplTrait(ref bounds) = *arg {
- let mut type_bounds = Vec::new();
- for bound in bounds {
- if let Some(path) = bound.get_trait_path() {
- let ty = Type::Path { path };
- simplify_fn_type(
- self_,
- generics,
- &ty,
- tcx,
- recurse + 1,
- &mut type_bounds,
- rgen,
- is_return,
- cache,
- );
+ if is_return && !type_bounds.is_empty() {
+ // In return position, `impl Trait` is a unique thing.
+ res.push(RenderType { id: None, generics: Some(type_bounds), bindings: None });
+ } else {
+ // In parameter position, `impl Trait` is the same as an unnamed generic parameter.
+ let idx = -isize::try_from(rgen.len() + 1).unwrap();
+ rgen.insert(SimplifiedParam::Anonymous(idx), (idx, type_bounds));
+ res.push(RenderType {
+ id: Some(RenderTypeId::Index(idx)),
+ generics: None,
+ bindings: None,
+ });
}
}
- if is_return && !type_bounds.is_empty() {
- // In parameter position, `impl Trait` is a unique thing.
- res.push(RenderType { id: None, generics: Some(type_bounds), bindings: None });
- } else {
- // In parameter position, `impl Trait` is the same as an unnamed generic parameter.
- let idx = -isize::try_from(rgen.len() + 1).unwrap();
- rgen.insert(SimplifiedParam::Anonymous(idx), (idx, type_bounds));
- res.push(RenderType {
- id: Some(RenderTypeId::Index(idx)),
- generics: None,
- bindings: None,
- });
- }
- } else if let Type::Slice(ref ty) = *arg {
- let mut ty_generics = Vec::new();
- simplify_fn_type(
- self_,
- generics,
- &ty,
- tcx,
- recurse + 1,
- &mut ty_generics,
- rgen,
- is_return,
- cache,
- );
- res.push(get_index_type(arg, ty_generics, rgen));
- } else if let Type::Array(ref ty, _) = *arg {
- let mut ty_generics = Vec::new();
- simplify_fn_type(
- self_,
- generics,
- &ty,
- tcx,
- recurse + 1,
- &mut ty_generics,
- rgen,
- is_return,
- cache,
- );
- res.push(get_index_type(arg, ty_generics, rgen));
- } else if let Type::Tuple(ref tys) = *arg {
- let mut ty_generics = Vec::new();
- for ty in tys {
+ Type::Slice(ref ty) => {
+ let mut ty_generics = Vec::new();
simplify_fn_type(
self_,
generics,
@@ -982,15 +960,14 @@ fn simplify_fn_type<'tcx, 'a>(
is_return,
cache,
);
+ res.push(get_index_type(arg, ty_generics, rgen));
}
- res.push(get_index_type(arg, ty_generics, rgen));
- } else if let Type::BareFunction(ref bf) = *arg {
- let mut ty_generics = Vec::new();
- for ty in bf.decl.inputs.values.iter().map(|arg| &arg.type_) {
+ Type::Array(ref ty, _) => {
+ let mut ty_generics = Vec::new();
simplify_fn_type(
self_,
generics,
- ty,
+ &ty,
tcx,
recurse + 1,
&mut ty_generics,
@@ -998,62 +975,11 @@ fn simplify_fn_type<'tcx, 'a>(
is_return,
cache,
);
+ res.push(get_index_type(arg, ty_generics, rgen));
}
- // The search index, for simplicity's sake, represents fn pointers and closures
- // the same way: as a tuple for the parameters, and an associated type for the
- // return type.
- let mut ty_output = Vec::new();
- simplify_fn_type(
- self_,
- generics,
- &bf.decl.output,
- tcx,
- recurse + 1,
- &mut ty_output,
- rgen,
- is_return,
- cache,
- );
- let ty_bindings = vec![(RenderTypeId::AssociatedType(sym::Output), ty_output)];
- res.push(RenderType {
- id: get_index_type_id(&arg, rgen),
- bindings: Some(ty_bindings),
- generics: Some(ty_generics),
- });
- } else if let Type::BorrowedRef { lifetime: _, mutability, ref type_ } = *arg {
- let mut ty_generics = Vec::new();
- if mutability.is_mut() {
- ty_generics.push(RenderType {
- id: Some(RenderTypeId::Mut),
- generics: None,
- bindings: None,
- });
- }
- simplify_fn_type(
- self_,
- generics,
- &type_,
- tcx,
- recurse + 1,
- &mut ty_generics,
- rgen,
- is_return,
- cache,
- );
- res.push(get_index_type(arg, ty_generics, rgen));
- } else {
- // This is not a type parameter. So for example if we have `T, U: Option<T>`, and we're
- // looking at `Option`, we enter this "else" condition, otherwise if it's `T`, we don't.
- //
- // So in here, we can add it directly and look for its own type parameters (so for `Option`,
- // we will look for them but not for `T`).
- let mut ty_generics = Vec::new();
- let mut ty_constraints = Vec::new();
- if let Some(arg_generics) = arg.generic_args() {
- for ty in arg_generics.into_iter().filter_map(|param| match param {
- clean::GenericArg::Type(ty) => Some(ty),
- _ => None,
- }) {
+ Type::Tuple(ref tys) => {
+ let mut ty_generics = Vec::new();
+ for ty in tys {
simplify_fn_type(
self_,
generics,
@@ -1066,94 +992,181 @@ fn simplify_fn_type<'tcx, 'a>(
cache,
);
}
- for constraint in arg_generics.constraints() {
- simplify_fn_constraint(
+ res.push(get_index_type(arg, ty_generics, rgen));
+ }
+ Type::BareFunction(ref bf) => {
+ let mut ty_generics = Vec::new();
+ for ty in bf.decl.inputs.values.iter().map(|arg| &arg.type_) {
+ simplify_fn_type(
self_,
generics,
- &constraint,
+ ty,
tcx,
recurse + 1,
- &mut ty_constraints,
+ &mut ty_generics,
rgen,
is_return,
cache,
);
}
+ // The search index, for simplicity's sake, represents fn pointers and closures
+ // the same way: as a tuple for the parameters, and an associated type for the
+ // return type.
+ let mut ty_output = Vec::new();
+ simplify_fn_type(
+ self_,
+ generics,
+ &bf.decl.output,
+ tcx,
+ recurse + 1,
+ &mut ty_output,
+ rgen,
+ is_return,
+ cache,
+ );
+ let ty_bindings = vec![(RenderTypeId::AssociatedType(sym::Output), ty_output)];
+ res.push(RenderType {
+ id: get_index_type_id(&arg, rgen),
+ bindings: Some(ty_bindings),
+ generics: Some(ty_generics),
+ });
}
- // Every trait associated type on self gets assigned to a type parameter index
- // this same one is used later for any appearances of these types
- //
- // for example, Iterator::next is:
- //
- // trait Iterator {
- // fn next(&mut self) -> Option<Self::Item>
- // }
- //
- // Self is technically just Iterator, but we want to pretend it's more like this:
- //
- // fn next<T>(self: Iterator<Item=T>) -> Option<T>
- if is_self
- && let Type::Path { path } = arg
- && let def_id = path.def_id()
- && let Some(trait_) = cache.traits.get(&def_id)
- && trait_.items.iter().any(|at| at.is_ty_associated_type())
- {
- for assoc_ty in &trait_.items {
- if let clean::ItemKind::TyAssocTypeItem(_generics, bounds) = &*assoc_ty.kind
- && let Some(name) = assoc_ty.name
- {
- let idx = -isize::try_from(rgen.len() + 1).unwrap();
- let (idx, stored_bounds) = rgen
- .entry(SimplifiedParam::AssociatedType(def_id, name))
- .or_insert_with(|| (idx, Vec::new()));
- let idx = *idx;
- if stored_bounds.is_empty() {
- // Can't just pass stored_bounds to simplify_fn_type,
- // because it also accepts rgen as a parameter.
- // Instead, have it fill in this local, then copy it into the map afterward.
- let mut type_bounds = Vec::new();
- for bound in bounds {
- if let Some(path) = bound.get_trait_path() {
- let ty = Type::Path { path };
- simplify_fn_type(
- self_,
- generics,
- &ty,
- tcx,
- recurse + 1,
- &mut type_bounds,
- rgen,
- is_return,
- cache,
- );
- }
- }
- let stored_bounds = &mut rgen
- .get_mut(&SimplifiedParam::AssociatedType(def_id, name))
- .unwrap()
- .1;
+ Type::BorrowedRef { lifetime: _, mutability, ref type_ } => {
+ let mut ty_generics = Vec::new();
+ if mutability.is_mut() {
+ ty_generics.push(RenderType {
+ id: Some(RenderTypeId::Mut),
+ generics: None,
+ bindings: None,
+ });
+ }
+ simplify_fn_type(
+ self_,
+ generics,
+ &type_,
+ tcx,
+ recurse + 1,
+ &mut ty_generics,
+ rgen,
+ is_return,
+ cache,
+ );
+ res.push(get_index_type(arg, ty_generics, rgen));
+ }
+ _ => {
+ // This is not a type parameter. So for example if we have `T, U: Option<T>`, and we're
+ // looking at `Option`, we enter this "else" condition, otherwise if it's `T`, we don't.
+ //
+ // So in here, we can add it directly and look for its own type parameters (so for `Option`,
+ // we will look for them but not for `T`).
+ let mut ty_generics = Vec::new();
+ let mut ty_constraints = Vec::new();
+ if let Some(arg_generics) = arg.generic_args() {
+ for ty in arg_generics.into_iter().filter_map(|param| match param {
+ clean::GenericArg::Type(ty) => Some(ty),
+ _ => None,
+ }) {
+ simplify_fn_type(
+ self_,
+ generics,
+ &ty,
+ tcx,
+ recurse + 1,
+ &mut ty_generics,
+ rgen,
+ is_return,
+ cache,
+ );
+ }
+ for constraint in arg_generics.constraints() {
+ simplify_fn_constraint(
+ self_,
+ generics,
+ &constraint,
+ tcx,
+ recurse + 1,
+ &mut ty_constraints,
+ rgen,
+ is_return,
+ cache,
+ );
+ }
+ }
+ // Every trait associated type on self gets assigned to a type parameter index
+ // this same one is used later for any appearances of these types
+ //
+ // for example, Iterator::next is:
+ //
+ // trait Iterator {
+ // fn next(&mut self) -> Option<Self::Item>
+ // }
+ //
+ // Self is technically just Iterator, but we want to pretend it's more like this:
+ //
+ // fn next<T>(self: Iterator<Item=T>) -> Option<T>
+ if is_self
+ && let Type::Path { path } = arg
+ && let def_id = path.def_id()
+ && let Some(trait_) = cache.traits.get(&def_id)
+ && trait_.items.iter().any(|at| at.is_ty_associated_type())
+ {
+ for assoc_ty in &trait_.items {
+ if let clean::ItemKind::TyAssocTypeItem(_generics, bounds) = &*assoc_ty.kind
+ && let Some(name) = assoc_ty.name
+ {
+ let idx = -isize::try_from(rgen.len() + 1).unwrap();
+ let (idx, stored_bounds) = rgen
+ .entry(SimplifiedParam::AssociatedType(def_id, name))
+ .or_insert_with(|| (idx, Vec::new()));
+ let idx = *idx;
if stored_bounds.is_empty() {
- *stored_bounds = type_bounds;
+ // Can't just pass stored_bounds to simplify_fn_type,
+ // because it also accepts rgen as a parameter.
+ // Instead, have it fill in this local, then copy it into the map afterward.
+ let mut type_bounds = Vec::new();
+ for bound in bounds {
+ if let Some(path) = bound.get_trait_path() {
+ let ty = Type::Path { path };
+ simplify_fn_type(
+ self_,
+ generics,
+ &ty,
+ tcx,
+ recurse + 1,
+ &mut type_bounds,
+ rgen,
+ is_return,
+ cache,
+ );
+ }
+ }
+ let stored_bounds = &mut rgen
+ .get_mut(&SimplifiedParam::AssociatedType(def_id, name))
+ .unwrap()
+ .1;
+ if stored_bounds.is_empty() {
+ *stored_bounds = type_bounds;
+ }
}
+ ty_constraints.push((
+ RenderTypeId::AssociatedType(name),
+ vec![RenderType {
+ id: Some(RenderTypeId::Index(idx)),
+ generics: None,
+ bindings: None,
+ }],
+ ))
}
- ty_constraints.push((
- RenderTypeId::AssociatedType(name),
- vec![RenderType {
- id: Some(RenderTypeId::Index(idx)),
- generics: None,
- bindings: None,
- }],
- ))
}
}
- }
- let id = get_index_type_id(&arg, rgen);
- if id.is_some() || !ty_generics.is_empty() {
- res.push(RenderType {
- id,
- bindings: if ty_constraints.is_empty() { None } else { Some(ty_constraints) },
- generics: if ty_generics.is_empty() { None } else { Some(ty_generics) },
- });
+ let id = get_index_type_id(&arg, rgen);
+ if id.is_some() || !ty_generics.is_empty() {
+ res.push(RenderType {
+ id,
+ bindings: if ty_constraints.is_empty() { None } else { Some(ty_constraints) },
+ generics: if ty_generics.is_empty() { None } else { Some(ty_generics) },
+ });
+ }
}
}
}
diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs
index b56244f2d3b6d..b97d710c007ce 100644
--- a/src/librustdoc/json/conversions.rs
+++ b/src/librustdoc/json/conversions.rs
@@ -578,7 +578,7 @@ impl FromWithTcx<clean::Type> for Type {
fn from_tcx(ty: clean::Type, tcx: TyCtxt<'_>) -> Self {
use clean::Type::{
Array, BareFunction, BorrowedRef, Generic, ImplTrait, Infer, Primitive, QPath,
- RawPointer, Slice, Tuple,
+ RawPointer, SelfTy, Slice, Tuple,
};
match ty {
@@ -588,6 +588,8 @@ impl FromWithTcx<clean::Type> for Type {
traits: bounds.into_tcx(tcx),
}),
Generic(s) => Type::Generic(s.to_string()),
+ // FIXME: add dedicated variant to json Type?
+ SelfTy => Type::Generic("Self".to_owned()),
Primitive(p) => Type::Primitive(p.as_sym().to_string()),
BareFunction(f) => Type::FunctionPointer(Box::new((*f).into_tcx(tcx))),
Tuple(t) => Type::Tuple(t.into_tcx(tcx)),
diff --git a/tests/codegen/issues/issue-122600-ptr-discriminant-update.rs b/tests/codegen/issues/issue-122600-ptr-discriminant-update.rs
new file mode 100644
index 0000000000000..4b520a6206951
--- /dev/null
+++ b/tests/codegen/issues/issue-122600-ptr-discriminant-update.rs
@@ -0,0 +1,19 @@
+//@ compile-flags: -O
+//@ min-llvm-version: 19
+
+#![crate_type = "lib"]
+
+pub enum State {
+ A([u8; 753]),
+ B([u8; 753]),
+}
+
+// CHECK-LABEL: @update
+#[no_mangle]
+pub unsafe fn update(s: *mut State) {
+ // CHECK-NEXT: start:
+ // CHECK-NEXT: store i8
+ // CHECK-NEXT: ret
+ let State::A(v) = s.read() else { std::hint::unreachable_unchecked() };
+ s.write(State::B(v));
+}
diff --git a/tests/rustdoc-js/self-is-not-generic.js b/tests/rustdoc-js/self-is-not-generic.js
new file mode 100644
index 0000000000000..0fdf5b4117d8f
--- /dev/null
+++ b/tests/rustdoc-js/self-is-not-generic.js
@@ -0,0 +1,22 @@
+// exact-check
+
+const EXPECTED = [
+ {
+ 'query': 'A -> A',
+ 'others': [
+ { 'path': 'self_is_not_generic::Thing', 'name': 'from' }
+ ],
+ },
+ {
+ 'query': 'A -> B',
+ 'others': [
+ { 'path': 'self_is_not_generic::Thing', 'name': 'try_from' }
+ ],
+ },
+ {
+ 'query': 'Combine -> Combine',
+ 'others': [
+ { 'path': 'self_is_not_generic::Combine', 'name': 'combine' }
+ ],
+ }
+];
diff --git a/tests/rustdoc-js/self-is-not-generic.rs b/tests/rustdoc-js/self-is-not-generic.rs
new file mode 100644
index 0000000000000..d6a96acb73caf
--- /dev/null
+++ b/tests/rustdoc-js/self-is-not-generic.rs
@@ -0,0 +1,11 @@
+pub trait Combine {
+ fn combine(&self, other: &Self) -> Self;
+}
+
+pub struct Thing;
+
+impl Combine for Thing {
+ fn combine(&self, other: &Self) -> Self {
+ Self
+ }
+}
diff --git a/tests/ui/attributes/check-builtin-attr-ice.rs b/tests/ui/attributes/check-builtin-attr-ice.rs
new file mode 100644
index 0000000000000..9ef5890601f6b
--- /dev/null
+++ b/tests/ui/attributes/check-builtin-attr-ice.rs
@@ -0,0 +1,58 @@
+//! Regression test for #128622.
+//!
+//! PR #128581 introduced an assertion that all builtin attributes are actually checked via
+//! `CheckAttrVisitor` and aren't accidentally usable on completely unrelated HIR nodes.
+//! Unfortunately, the check had correctness problems.
+//!
+//! The match on attribute path segments looked like
+//!
+//! ```rs,ignore
+//! [sym::should_panic] => /* check is implemented */
+//! match BUILTIN_ATTRIBUTE_MAP.get(name) {
+//! // checked below
+//! Some(BuiltinAttribute { type_: AttributeType::CrateLevel, .. }) => {}
+//! Some(_) => {
+//! if !name.as_str().starts_with("rustc_") {
+//! span_bug!(
+//! attr.span,
+//! "builtin attribute {name:?} not handled by `CheckAttrVisitor`"
+//! )
+//! }
+//! }
+//! None => (),
+//! }
+//! ```
+//!
+//! However, it failed to account for edge cases such as an attribute whose:
+//!
+//! 1. path segments *starts* with a builtin attribute such as `should_panic`
+//! 2. which does not start with `rustc_`, and
+//! 3. is also an `AttributeType::Normal` attribute upon registration with the builtin attribute map
+//!
+//! These conditions when all satisfied cause the span bug to be issued for e.g.
+//! `#[should_panic::skip]` because the `[sym::should_panic]` arm is not matched (since it's
+//! `[sym::should_panic, sym::skip]`).
+//!
+//! This test checks that the span bug is not fired for such cases.
+//!
+//! issue: rust-lang/rust#128622
+
+// Notably, `should_panic` is a `AttributeType::Normal` attribute that is checked separately.
+
+struct Foo {
+ #[should_panic::skip]
+ //~^ ERROR failed to resolve
+ pub field: u8,
+
+ #[should_panic::a::b::c]
+ //~^ ERROR failed to resolve
+ pub field2: u8,
+}
+
+fn foo() {}
+
+fn main() {
+ #[deny::skip]
+ //~^ ERROR failed to resolve
+ foo();
+}
diff --git a/tests/ui/attributes/check-builtin-attr-ice.stderr b/tests/ui/attributes/check-builtin-attr-ice.stderr
new file mode 100644
index 0000000000000..5a27da565a857
--- /dev/null
+++ b/tests/ui/attributes/check-builtin-attr-ice.stderr
@@ -0,0 +1,21 @@
+error[E0433]: failed to resolve: use of undeclared crate or module `should_panic`
+ --> $DIR/check-builtin-attr-ice.rs:43:7
+ |
+LL | #[should_panic::skip]
+ | ^^^^^^^^^^^^ use of undeclared crate or module `should_panic`
+
+error[E0433]: failed to resolve: use of undeclared crate or module `should_panic`
+ --> $DIR/check-builtin-attr-ice.rs:47:7
+ |
+LL | #[should_panic::a::b::c]
+ | ^^^^^^^^^^^^ use of undeclared crate or module `should_panic`
+
+error[E0433]: failed to resolve: use of undeclared crate or module `deny`
+ --> $DIR/check-builtin-attr-ice.rs:55:7
+ |
+LL | #[deny::skip]
+ | ^^^^ use of undeclared crate or module `deny`
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/derives/deriving-with-repr-packed.rs b/tests/ui/derives/deriving-with-repr-packed.rs
index 58be451972017..d17b52842cefd 100644
--- a/tests/ui/derives/deriving-with-repr-packed.rs
+++ b/tests/ui/derives/deriving-with-repr-packed.rs
@@ -22,25 +22,22 @@ struct Y(usize);
struct X(Y);
//~^ ERROR cannot move out of `self` which is behind a shared reference
-// This is currently allowed, but will be phased out at some point. From
-// `zerovec` within icu4x-0.9.0.
#[derive(Debug)]
#[repr(packed)]
struct FlexZeroSlice {
width: u8,
data: [u8],
- //~^ WARNING byte slice in a packed struct that derives a built-in trait
- //~^^ this was previously accepted
+ //~^ ERROR cannot move
+ //~| ERROR cannot move
}
-// Again, currently allowed, but will be phased out.
#[derive(Debug)]
#[repr(packed)]
struct WithStr {
width: u8,
data: str,
- //~^ WARNING string slice in a packed struct that derives a built-in trait
- //~^^ this was previously accepted
+ //~^ ERROR cannot move
+ //~| ERROR cannot move
}
fn main() {}
diff --git a/tests/ui/derives/deriving-with-repr-packed.stderr b/tests/ui/derives/deriving-with-repr-packed.stderr
index a8523d25cab9b..321ffb27eeb11 100644
--- a/tests/ui/derives/deriving-with-repr-packed.stderr
+++ b/tests/ui/derives/deriving-with-repr-packed.stderr
@@ -1,32 +1,3 @@
-warning: byte slice in a packed struct that derives a built-in trait
- --> $DIR/deriving-with-repr-packed.rs:31:5
- |
-LL | #[derive(Debug)]
- | ----- in this derive macro expansion
-...
-LL | data: [u8],
- | ^^^^^^^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #107457 <https://github.com/rust-lang/rust/issues/107457>
- = help: consider implementing the trait by hand, or remove the `packed` attribute
- = note: `#[warn(byte_slice_in_packed_struct_with_derive)]` on by default
- = note: this warning originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-warning: string slice in a packed struct that derives a built-in trait
- --> $DIR/deriving-with-repr-packed.rs:41:5
- |
-LL | #[derive(Debug)]
- | ----- in this derive macro expansion
-...
-LL | data: str,
- | ^^^^^^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #107457 <https://github.com/rust-lang/rust/issues/107457>
- = help: consider implementing the trait by hand, or remove the `packed` attribute
- = note: this warning originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-
error[E0507]: cannot move out of `self` which is behind a shared reference
--> $DIR/deriving-with-repr-packed.rs:22:10
|
@@ -47,38 +18,43 @@ LL | struct X(Y);
= note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
= note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-error: aborting due to 1 previous error; 2 warnings emitted
+error[E0161]: cannot move a value of type `[u8]`
+ --> $DIR/deriving-with-repr-packed.rs:29:5
+ |
+LL | data: [u8],
+ | ^^^^^^^^^^ the size of `[u8]` cannot be statically determined
-For more information about this error, try `rustc --explain E0507`.
-Future incompatibility report: Future breakage diagnostic:
-warning: byte slice in a packed struct that derives a built-in trait
- --> $DIR/deriving-with-repr-packed.rs:31:5
+error[E0507]: cannot move out of `self.data` which is behind a shared reference
+ --> $DIR/deriving-with-repr-packed.rs:29:5
|
LL | #[derive(Debug)]
| ----- in this derive macro expansion
...
LL | data: [u8],
- | ^^^^^^^^^^
+ | ^^^^^^^^^^ move occurs because `self.data` has type `[u8]`, which does not implement the `Copy` trait
+ |
+ = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
+ = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0161]: cannot move a value of type `str`
+ --> $DIR/deriving-with-repr-packed.rs:38:5
|
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #107457 <https://github.com/rust-lang/rust/issues/107457>
- = help: consider implementing the trait by hand, or remove the `packed` attribute
- = note: `#[warn(byte_slice_in_packed_struct_with_derive)]` on by default
- = note: this warning originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
+LL | data: str,
+ | ^^^^^^^^^ the size of `str` cannot be statically determined
-Future breakage diagnostic:
-warning: string slice in a packed struct that derives a built-in trait
- --> $DIR/deriving-with-repr-packed.rs:41:5
+error[E0507]: cannot move out of `self.data` which is behind a shared reference
+ --> $DIR/deriving-with-repr-packed.rs:38:5
|
LL | #[derive(Debug)]
| ----- in this derive macro expansion
...
LL | data: str,
- | ^^^^^^^^^
+ | ^^^^^^^^^ move occurs because `self.data` has type `str`, which does not implement the `Copy` trait
|
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #107457 <https://github.com/rust-lang/rust/issues/107457>
- = help: consider implementing the trait by hand, or remove the `packed` attribute
- = note: `#[warn(byte_slice_in_packed_struct_with_derive)]` on by default
- = note: this warning originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
+ = note: `#[derive(Debug)]` triggers a move because taking references to the fields of a packed struct is undefined behaviour
+ = note: this error originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 5 previous errors
+Some errors have detailed explanations: E0161, E0507.
+For more information about an error, try `rustc --explain E0161`.
diff --git a/tests/ui/deriving/deriving-all-codegen.rs b/tests/ui/deriving/deriving-all-codegen.rs
index 6fa4f74f2a508..eab2b4f1f5335 100644
--- a/tests/ui/deriving/deriving-all-codegen.rs
+++ b/tests/ui/deriving/deriving-all-codegen.rs
@@ -73,16 +73,6 @@ impl Copy for PackedManualCopy {}
#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
struct Unsized([u32]);
-// A packed struct with an unsized `[u8]` field. This is currently allowed, but
-// causes a warning and will be phased out at some point.
-#[derive(Debug, Hash)]
-#[repr(packed)]
-struct PackedUnsizedU8([u8]);
-//~^ WARNING byte slice in a packed struct that derives a built-in trait
-//~^^ WARNING byte slice in a packed struct that derives a built-in trait
-//~^^^ this was previously accepted
-//~^^^^ this was previously accepted
-
trait Trait {
type A;
}
diff --git a/tests/ui/deriving/deriving-all-codegen.stderr b/tests/ui/deriving/deriving-all-codegen.stderr
deleted file mode 100644
index 503f0cae73b69..0000000000000
--- a/tests/ui/deriving/deriving-all-codegen.stderr
+++ /dev/null
@@ -1,63 +0,0 @@
-warning: byte slice in a packed struct that derives a built-in trait
- --> $DIR/deriving-all-codegen.rs:80:24
- |
-LL | #[derive(Debug, Hash)]
- | ----- in this derive macro expansion
-LL | #[repr(packed)]
-LL | struct PackedUnsizedU8([u8]);
- | ^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #107457 <https://github.com/rust-lang/rust/issues/107457>
- = help: consider implementing the trait by hand, or remove the `packed` attribute
- = note: `#[warn(byte_slice_in_packed_struct_with_derive)]` on by default
- = note: this warning originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-warning: byte slice in a packed struct that derives a built-in trait
- --> $DIR/deriving-all-codegen.rs:80:24
- |
-LL | #[derive(Debug, Hash)]
- | ---- in this derive macro expansion
-LL | #[repr(packed)]
-LL | struct PackedUnsizedU8([u8]);
- | ^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #107457 <https://github.com/rust-lang/rust/issues/107457>
- = help: consider implementing the trait by hand, or remove the `packed` attribute
- = note: this warning originates in the derive macro `Hash` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-warning: 2 warnings emitted
-
-Future incompatibility report: Future breakage diagnostic:
-warning: byte slice in a packed struct that derives a built-in trait
- --> $DIR/deriving-all-codegen.rs:80:24
- |
-LL | #[derive(Debug, Hash)]
- | ----- in this derive macro expansion
-LL | #[repr(packed)]
-LL | struct PackedUnsizedU8([u8]);
- | ^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #107457 <https://github.com/rust-lang/rust/issues/107457>
- = help: consider implementing the trait by hand, or remove the `packed` attribute
- = note: `#[warn(byte_slice_in_packed_struct_with_derive)]` on by default
- = note: this warning originates in the derive macro `Debug` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-Future breakage diagnostic:
-warning: byte slice in a packed struct that derives a built-in trait
- --> $DIR/deriving-all-codegen.rs:80:24
- |
-LL | #[derive(Debug, Hash)]
- | ---- in this derive macro expansion
-LL | #[repr(packed)]
-LL | struct PackedUnsizedU8([u8]);
- | ^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #107457 <https://github.com/rust-lang/rust/issues/107457>
- = help: consider implementing the trait by hand, or remove the `packed` attribute
- = note: `#[warn(byte_slice_in_packed_struct_with_derive)]` on by default
- = note: this warning originates in the derive macro `Hash` (in Nightly builds, run with -Z macro-backtrace for more info)
-
diff --git a/tests/ui/deriving/deriving-all-codegen.stdout b/tests/ui/deriving/deriving-all-codegen.stdout
index 6b69b57c51619..6503c87099040 100644
--- a/tests/ui/deriving/deriving-all-codegen.stdout
+++ b/tests/ui/deriving/deriving-all-codegen.stdout
@@ -516,26 +516,6 @@ impl ::core::cmp::Ord for Unsized {
}
}
-// A packed struct with an unsized `[u8]` field. This is currently allowed, but
-// causes a warning and will be phased out at some point.
-#[repr(packed)]
-struct PackedUnsizedU8([u8]);
-#[automatically_derived]
-impl ::core::fmt::Debug for PackedUnsizedU8 {
- #[inline]
- fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
- ::core::fmt::Formatter::debug_tuple_field1_finish(f,
- "PackedUnsizedU8", &&self.0)
- }
-}
-#[automatically_derived]
-impl ::core::hash::Hash for PackedUnsizedU8 {
- #[inline]
- fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
- ::core::hash::Hash::hash(&self.0, state)
- }
-}
-
trait Trait {
type A;
}
diff --git a/tests/ui/feature-gates/feature-gate-default_type_parameter_fallback.stderr b/tests/ui/feature-gates/feature-gate-default_type_parameter_fallback.stderr
deleted file mode 100644
index 308de2692930d..0000000000000
--- a/tests/ui/feature-gates/feature-gate-default_type_parameter_fallback.stderr
+++ /dev/null
@@ -1,21 +0,0 @@
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
- --> $DIR/feature-gate-default_type_parameter_fallback.rs:3:8
- |
-LL | fn avg<T=i32>(_: T) {}
- | ^^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
- = note: `#[deny(invalid_type_param_default)]` on by default
-
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
- --> $DIR/feature-gate-default_type_parameter_fallback.rs:8:6
- |
-LL | impl<T=i32> S<T> {}
- | ^^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
-
-error: aborting due to 2 previous errors
-
diff --git a/tests/ui/impl-trait/where-allowed.stderr b/tests/ui/impl-trait/where-allowed.stderr
index f0d259d01de94..1fb69db98c162 100644
--- a/tests/ui/impl-trait/where-allowed.stderr
+++ b/tests/ui/impl-trait/where-allowed.stderr
@@ -433,3 +433,25 @@ error: aborting due to 50 previous errors
Some errors have detailed explanations: E0053, E0118, E0283, E0562, E0599, E0658, E0666.
For more information about an error, try `rustc --explain E0053`.
+Future incompatibility report: Future breakage diagnostic:
+error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+ --> $DIR/where-allowed.rs:239:7
+ |
+LL | impl <T = impl Debug> T {}
+ | ^^^^^^^^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+ = note: `#[deny(invalid_type_param_default)]` on by default
+
+Future breakage diagnostic:
+error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+ --> $DIR/where-allowed.rs:246:36
+ |
+LL | fn in_method_generic_param_default<T = impl Debug>(_: T) {}
+ | ^^^^^^^^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+ = note: `#[deny(invalid_type_param_default)]` on by default
+
diff --git a/tests/ui/issues/issue-26812.rs b/tests/ui/issues/issue-26812.rs
index 3391ea4b350af..e0723e016b381 100644
--- a/tests/ui/issues/issue-26812.rs
+++ b/tests/ui/issues/issue-26812.rs
@@ -1,6 +1,6 @@
-#![feature(default_type_parameter_fallback)]
-
fn avg<T=T::Item>(_: T) {}
//~^ ERROR generic parameters with a default cannot use forward declared identifiers
+//~| ERROR defaults for type parameters
+//~| WARN previously accepted
fn main() {}
diff --git a/tests/ui/issues/issue-26812.stderr b/tests/ui/issues/issue-26812.stderr
index c2a3d4b83d536..4a18b23fd8b13 100644
--- a/tests/ui/issues/issue-26812.stderr
+++ b/tests/ui/issues/issue-26812.stderr
@@ -1,9 +1,30 @@
error[E0128]: generic parameters with a default cannot use forward declared identifiers
- --> $DIR/issue-26812.rs:3:10
+ --> $DIR/issue-26812.rs:1:10
|
LL | fn avg<T=T::Item>(_: T) {}
| ^^^^^^^ defaulted generic parameters cannot be forward declared
-error: aborting due to 1 previous error
+error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+ --> $DIR/issue-26812.rs:1:8
+ |
+LL | fn avg<T=T::Item>(_: T) {}
+ | ^^^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+ = note: `#[deny(invalid_type_param_default)]` on by default
+
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0128`.
+Future incompatibility report: Future breakage diagnostic:
+error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+ --> $DIR/issue-26812.rs:1:8
+ |
+LL | fn avg<T=T::Item>(_: T) {}
+ | ^^^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+ = note: `#[deny(invalid_type_param_default)]` on by default
+
diff --git a/tests/ui/lifetimes/unusual-rib-combinations.stderr b/tests/ui/lifetimes/unusual-rib-combinations.stderr
index e446345aedce5..ebf6f6ca403cb 100644
--- a/tests/ui/lifetimes/unusual-rib-combinations.stderr
+++ b/tests/ui/lifetimes/unusual-rib-combinations.stderr
@@ -72,3 +72,14 @@ error: aborting due to 8 previous errors
Some errors have detailed explanations: E0106, E0214, E0308, E0770.
For more information about an error, try `rustc --explain E0106`.
+Future incompatibility report: Future breakage diagnostic:
+error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+ --> $DIR/unusual-rib-combinations.rs:15:6
+ |
+LL | fn c<T = u8()>() {}
+ | ^^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+ = note: `#[deny(invalid_type_param_default)]` on by default
+
diff --git a/tests/ui/type-inference/unbounded-type-param-in-fn-with-assoc-type.stderr b/tests/ui/type-inference/unbounded-type-param-in-fn-with-assoc-type.stderr
index dc0bea58a70e8..bf8829c09257f 100644
--- a/tests/ui/type-inference/unbounded-type-param-in-fn-with-assoc-type.stderr
+++ b/tests/ui/type-inference/unbounded-type-param-in-fn-with-assoc-type.stderr
@@ -12,3 +12,13 @@ LL | foo::<T, U>();
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0282`.
+Future incompatibility report: Future breakage diagnostic:
+warning: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+ --> $DIR/unbounded-type-param-in-fn-with-assoc-type.rs:3:11
+ |
+LL | fn foo<T, U = u64>() -> (T, U) {
+ | ^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+
diff --git a/tests/ui/feature-gates/feature-gate-default_type_parameter_fallback.rs b/tests/ui/type/default_type_parameter_in_fn_or_impl.rs
similarity index 100%
rename from tests/ui/feature-gates/feature-gate-default_type_parameter_fallback.rs
rename to tests/ui/type/default_type_parameter_in_fn_or_impl.rs
diff --git a/tests/ui/type/default_type_parameter_in_fn_or_impl.stderr b/tests/ui/type/default_type_parameter_in_fn_or_impl.stderr
new file mode 100644
index 0000000000000..a3205cd3c29ca
--- /dev/null
+++ b/tests/ui/type/default_type_parameter_in_fn_or_impl.stderr
@@ -0,0 +1,43 @@
+error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+ --> $DIR/default_type_parameter_in_fn_or_impl.rs:3:8
+ |
+LL | fn avg<T=i32>(_: T) {}
+ | ^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+ = note: `#[deny(invalid_type_param_default)]` on by default
+
+error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+ --> $DIR/default_type_parameter_in_fn_or_impl.rs:8:6
+ |
+LL | impl<T=i32> S<T> {}
+ | ^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+
+error: aborting due to 2 previous errors
+
+Future incompatibility report: Future breakage diagnostic:
+error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+ --> $DIR/default_type_parameter_in_fn_or_impl.rs:3:8
+ |
+LL | fn avg<T=i32>(_: T) {}
+ | ^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+ = note: `#[deny(invalid_type_param_default)]` on by default
+
+Future breakage diagnostic:
+error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+ --> $DIR/default_type_parameter_in_fn_or_impl.rs:8:6
+ |
+LL | impl<T=i32> S<T> {}
+ | ^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+ = note: `#[deny(invalid_type_param_default)]` on by default
+