Auto merge of #95931 - matthiaskrgr:rollup-1c5zhit, r=matthiaskrgr
Rollup of 7 pull requests Successful merges: - #95743 (Update binary_search example to instead redirect to partition_point) - #95771 (Update linker-plugin-lto.md to 1.60) - #95861 (Note that CI tests Windows 10) - #95875 (bootstrap: show available paths help text for aliased subcommands) - #95876 (Add a note for unsatisfied `~const Drop` bounds) - #95907 (address fixme for diagnostic variable name) - #95917 (thin_box test: import from std, not alloc) Failed merges: r? `@ghost` `@rustbot` modify labels: rollup
This commit is contained in:
bors
commit
43998d5441
@ -347,8 +347,7 @@ pub fn prefix_string(self, tcx: TyCtxt<'_>) -> Cow<'static, str> {
|
||||
impl<'tcx> TyCtxt<'tcx> {
|
||||
pub fn note_and_explain_type_err(
|
||||
self,
|
||||
// FIXME(eddyb) rename this since it's no longer a `DiagnosticBuilder`.
|
||||
db: &mut Diagnostic,
|
||||
diag: &mut Diagnostic,
|
||||
err: &TypeError<'tcx>,
|
||||
cause: &ObligationCause<'tcx>,
|
||||
sp: Span,
|
||||
@ -360,12 +359,12 @@ pub fn note_and_explain_type_err(
|
||||
ArgumentSorts(values, _) | Sorts(values) => {
|
||||
match (values.expected.kind(), values.found.kind()) {
|
||||
(ty::Closure(..), ty::Closure(..)) => {
|
||||
db.note("no two closures, even if identical, have the same type");
|
||||
db.help("consider boxing your closure and/or using it as a trait object");
|
||||
diag.note("no two closures, even if identical, have the same type");
|
||||
diag.help("consider boxing your closure and/or using it as a trait object");
|
||||
}
|
||||
(ty::Opaque(..), ty::Opaque(..)) => {
|
||||
// Issue #63167
|
||||
db.note("distinct uses of `impl Trait` result in different opaque types");
|
||||
diag.note("distinct uses of `impl Trait` result in different opaque types");
|
||||
}
|
||||
(ty::Float(_), ty::Infer(ty::IntVar(_)))
|
||||
if let Ok(
|
||||
@ -374,7 +373,7 @@ pub fn note_and_explain_type_err(
|
||||
) = self.sess.source_map().span_to_snippet(sp) =>
|
||||
{
|
||||
if snippet.chars().all(|c| c.is_digit(10) || c == '-' || c == '_') {
|
||||
db.span_suggestion(
|
||||
diag.span_suggestion(
|
||||
sp,
|
||||
"use a float literal",
|
||||
format!("{}.0", snippet),
|
||||
@ -386,30 +385,30 @@ pub fn note_and_explain_type_err(
|
||||
let generics = self.generics_of(body_owner_def_id);
|
||||
let e_span = self.def_span(generics.type_param(expected, self).def_id);
|
||||
if !sp.contains(e_span) {
|
||||
db.span_label(e_span, "expected type parameter");
|
||||
diag.span_label(e_span, "expected type parameter");
|
||||
}
|
||||
let f_span = self.def_span(generics.type_param(found, self).def_id);
|
||||
if !sp.contains(f_span) {
|
||||
db.span_label(f_span, "found type parameter");
|
||||
diag.span_label(f_span, "found type parameter");
|
||||
}
|
||||
db.note(
|
||||
diag.note(
|
||||
"a type parameter was expected, but a different one was found; \
|
||||
you might be missing a type parameter or trait bound",
|
||||
);
|
||||
db.note(
|
||||
diag.note(
|
||||
"for more information, visit \
|
||||
https://doc.rust-lang.org/book/ch10-02-traits.html\
|
||||
#traits-as-parameters",
|
||||
);
|
||||
}
|
||||
(ty::Projection(_), ty::Projection(_)) => {
|
||||
db.note("an associated type was expected, but a different one was found");
|
||||
diag.note("an associated type was expected, but a different one was found");
|
||||
}
|
||||
(ty::Param(p), ty::Projection(proj)) | (ty::Projection(proj), ty::Param(p)) => {
|
||||
let generics = self.generics_of(body_owner_def_id);
|
||||
let p_span = self.def_span(generics.type_param(p, self).def_id);
|
||||
if !sp.contains(p_span) {
|
||||
db.span_label(p_span, "this type parameter");
|
||||
diag.span_label(p_span, "this type parameter");
|
||||
}
|
||||
let hir = self.hir();
|
||||
let mut note = true;
|
||||
@ -444,14 +443,14 @@ pub fn note_and_explain_type_err(
|
||||
note = !suggest_constraining_type_param(
|
||||
self,
|
||||
generics,
|
||||
db,
|
||||
diag,
|
||||
&format!("{}", proj.self_ty()),
|
||||
&path,
|
||||
None,
|
||||
);
|
||||
}
|
||||
if note {
|
||||
db.note("you might be missing a type parameter or trait bound");
|
||||
diag.note("you might be missing a type parameter or trait bound");
|
||||
}
|
||||
}
|
||||
(ty::Param(p), ty::Dynamic(..) | ty::Opaque(..))
|
||||
@ -459,11 +458,11 @@ pub fn note_and_explain_type_err(
|
||||
let generics = self.generics_of(body_owner_def_id);
|
||||
let p_span = self.def_span(generics.type_param(p, self).def_id);
|
||||
if !sp.contains(p_span) {
|
||||
db.span_label(p_span, "this type parameter");
|
||||
diag.span_label(p_span, "this type parameter");
|
||||
}
|
||||
db.help("type parameters must be constrained to match other types");
|
||||
if self.sess.teach(&db.get_code().unwrap()) {
|
||||
db.help(
|
||||
diag.help("type parameters must be constrained to match other types");
|
||||
if self.sess.teach(&diag.get_code().unwrap()) {
|
||||
diag.help(
|
||||
"given a type parameter `T` and a method `foo`:
|
||||
```
|
||||
trait Trait<T> { fn foo(&self) -> T; }
|
||||
@ -489,7 +488,7 @@ fn foo(&self, x: T) -> T { x }
|
||||
```",
|
||||
);
|
||||
}
|
||||
db.note(
|
||||
diag.note(
|
||||
"for more information, visit \
|
||||
https://doc.rust-lang.org/book/ch10-02-traits.html\
|
||||
#traits-as-parameters",
|
||||
@ -499,9 +498,9 @@ fn foo(&self, x: T) -> T { x }
|
||||
let generics = self.generics_of(body_owner_def_id);
|
||||
let p_span = self.def_span(generics.type_param(p, self).def_id);
|
||||
if !sp.contains(p_span) {
|
||||
db.span_label(p_span, "this type parameter");
|
||||
diag.span_label(p_span, "this type parameter");
|
||||
}
|
||||
db.help(&format!(
|
||||
diag.help(&format!(
|
||||
"every closure has a distinct type and so could not always match the \
|
||||
caller-chosen type of parameter `{}`",
|
||||
p
|
||||
@ -511,12 +510,12 @@ fn foo(&self, x: T) -> T { x }
|
||||
let generics = self.generics_of(body_owner_def_id);
|
||||
let p_span = self.def_span(generics.type_param(p, self).def_id);
|
||||
if !sp.contains(p_span) {
|
||||
db.span_label(p_span, "this type parameter");
|
||||
diag.span_label(p_span, "this type parameter");
|
||||
}
|
||||
}
|
||||
(ty::Projection(proj_ty), _) => {
|
||||
self.expected_projection(
|
||||
db,
|
||||
diag,
|
||||
proj_ty,
|
||||
values,
|
||||
body_owner_def_id,
|
||||
@ -529,19 +528,19 @@ fn foo(&self, x: T) -> T { x }
|
||||
values.found, values.expected,
|
||||
);
|
||||
if !(self.suggest_constraining_opaque_associated_type(
|
||||
db,
|
||||
diag,
|
||||
&msg,
|
||||
proj_ty,
|
||||
values.expected,
|
||||
) || self.suggest_constraint(
|
||||
db,
|
||||
diag,
|
||||
&msg,
|
||||
body_owner_def_id,
|
||||
proj_ty,
|
||||
values.expected,
|
||||
)) {
|
||||
db.help(&msg);
|
||||
db.note(
|
||||
diag.help(&msg);
|
||||
diag.note(
|
||||
"for more information, visit \
|
||||
https://doc.rust-lang.org/book/ch19-03-advanced-traits.html",
|
||||
);
|
||||
@ -560,7 +559,7 @@ fn foo(&self, x: T) -> T { x }
|
||||
CyclicTy(ty) => {
|
||||
// Watch out for various cases of cyclic types and try to explain.
|
||||
if ty.is_closure() || ty.is_generator() {
|
||||
db.note(
|
||||
diag.note(
|
||||
"closures cannot capture themselves or take themselves as argument;\n\
|
||||
this error may be the result of a recent compiler bug-fix,\n\
|
||||
see issue #46062 <https://github.com/rust-lang/rust/issues/46062>\n\
|
||||
@ -574,10 +573,10 @@ fn foo(&self, x: T) -> T { x }
|
||||
.iter()
|
||||
.filter(|attr| attr.has_name(sym::target_feature))
|
||||
.map(|attr| attr.span);
|
||||
db.note(
|
||||
diag.note(
|
||||
"functions with `#[target_feature]` can only be coerced to `unsafe` function pointers"
|
||||
);
|
||||
db.span_labels(target_spans, "`#[target_feature]` added here");
|
||||
diag.span_labels(target_spans, "`#[target_feature]` added here");
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
@ -585,8 +584,7 @@ fn foo(&self, x: T) -> T { x }
|
||||
|
||||
fn suggest_constraint(
|
||||
self,
|
||||
// FIXME(eddyb) rename this since it's no longer a `DiagnosticBuilder`.
|
||||
db: &mut Diagnostic,
|
||||
diag: &mut Diagnostic,
|
||||
msg: &str,
|
||||
body_owner_def_id: DefId,
|
||||
proj_ty: &ty::ProjectionTy<'tcx>,
|
||||
@ -623,7 +621,7 @@ fn suggest_constraint(
|
||||
}
|
||||
|
||||
if self.constrain_generic_bound_associated_type_structured_suggestion(
|
||||
db,
|
||||
diag,
|
||||
&trait_ref,
|
||||
pred.bounds,
|
||||
&assoc,
|
||||
@ -642,7 +640,7 @@ fn suggest_constraint(
|
||||
{
|
||||
// This is type param `A` in `<A as T>::Foo`.
|
||||
return self.constrain_generic_bound_associated_type_structured_suggestion(
|
||||
db,
|
||||
diag,
|
||||
&trait_ref,
|
||||
param.bounds,
|
||||
&assoc,
|
||||
@ -673,8 +671,7 @@ fn suggest_constraint(
|
||||
/// fn that returns the type.
|
||||
fn expected_projection(
|
||||
self,
|
||||
// FIXME(eddyb) rename this since it's no longer a `DiagnosticBuilder`.
|
||||
db: &mut Diagnostic,
|
||||
diag: &mut Diagnostic,
|
||||
proj_ty: &ty::ProjectionTy<'tcx>,
|
||||
values: &ExpectedFound<Ty<'tcx>>,
|
||||
body_owner_def_id: DefId,
|
||||
@ -712,7 +709,7 @@ fn expected_projection(
|
||||
// want the more general suggestion later in this method about "consider constraining
|
||||
// the associated type or calling a method that returns the associated type".
|
||||
let point_at_assoc_fn = self.point_at_methods_that_satisfy_associated_type(
|
||||
db,
|
||||
diag,
|
||||
assoc.container.id(),
|
||||
current_method_ident,
|
||||
proj_ty.item_def_id,
|
||||
@ -720,33 +717,36 @@ fn expected_projection(
|
||||
);
|
||||
// Possibly suggest constraining the associated type to conform to the
|
||||
// found type.
|
||||
if self.suggest_constraint(db, &msg, body_owner_def_id, proj_ty, values.found)
|
||||
if self.suggest_constraint(diag, &msg, body_owner_def_id, proj_ty, values.found)
|
||||
|| point_at_assoc_fn
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
self.suggest_constraining_opaque_associated_type(db, &msg, proj_ty, values.found);
|
||||
self.suggest_constraining_opaque_associated_type(diag, &msg, proj_ty, values.found);
|
||||
|
||||
if self.point_at_associated_type(db, body_owner_def_id, values.found) {
|
||||
if self.point_at_associated_type(diag, body_owner_def_id, values.found) {
|
||||
return;
|
||||
}
|
||||
|
||||
if !impl_comparison {
|
||||
// Generic suggestion when we can't be more specific.
|
||||
if callable_scope {
|
||||
db.help(&format!("{} or calling a method that returns `{}`", msg, values.expected));
|
||||
diag.help(&format!(
|
||||
"{} or calling a method that returns `{}`",
|
||||
msg, values.expected
|
||||
));
|
||||
} else {
|
||||
db.help(&msg);
|
||||
diag.help(&msg);
|
||||
}
|
||||
db.note(
|
||||
diag.note(
|
||||
"for more information, visit \
|
||||
https://doc.rust-lang.org/book/ch19-03-advanced-traits.html",
|
||||
);
|
||||
}
|
||||
if self.sess.teach(&db.get_code().unwrap()) {
|
||||
db.help(
|
||||
if self.sess.teach(&diag.get_code().unwrap()) {
|
||||
diag.help(
|
||||
"given an associated type `T` and a method `foo`:
|
||||
```
|
||||
trait Trait {
|
||||
@ -769,8 +769,7 @@ fn foo(&self) -> Self::T { String::new() }
|
||||
/// a return type. This can occur when dealing with `TryStream` (#71035).
|
||||
fn suggest_constraining_opaque_associated_type(
|
||||
self,
|
||||
// FIXME(eddyb) rename this since it's no longer a `DiagnosticBuilder`.
|
||||
db: &mut Diagnostic,
|
||||
diag: &mut Diagnostic,
|
||||
msg: &str,
|
||||
proj_ty: &ty::ProjectionTy<'tcx>,
|
||||
ty: Ty<'tcx>,
|
||||
@ -790,7 +789,7 @@ fn suggest_constraining_opaque_associated_type(
|
||||
let (trait_ref, assoc_substs) = proj_ty.trait_ref_and_own_substs(self);
|
||||
|
||||
self.constrain_generic_bound_associated_type_structured_suggestion(
|
||||
db,
|
||||
diag,
|
||||
&trait_ref,
|
||||
opaque_hir_ty.bounds,
|
||||
assoc,
|
||||
@ -806,8 +805,7 @@ fn suggest_constraining_opaque_associated_type(
|
||||
|
||||
fn point_at_methods_that_satisfy_associated_type(
|
||||
self,
|
||||
// FIXME(eddyb) rename this since it's no longer a `DiagnosticBuilder`.
|
||||
db: &mut Diagnostic,
|
||||
diag: &mut Diagnostic,
|
||||
assoc_container_id: DefId,
|
||||
current_method_ident: Option<Symbol>,
|
||||
proj_ty_item_def_id: DefId,
|
||||
@ -854,7 +852,7 @@ fn point_at_methods_that_satisfy_associated_type(
|
||||
for (sp, label) in methods.into_iter() {
|
||||
span.push_span_label(sp, label);
|
||||
}
|
||||
db.span_help(span, &msg);
|
||||
diag.span_help(span, &msg);
|
||||
return true;
|
||||
}
|
||||
false
|
||||
@ -862,8 +860,7 @@ fn point_at_methods_that_satisfy_associated_type(
|
||||
|
||||
fn point_at_associated_type(
|
||||
self,
|
||||
// FIXME(eddyb) rename this since it's no longer a `DiagnosticBuilder`.
|
||||
db: &mut Diagnostic,
|
||||
diag: &mut Diagnostic,
|
||||
body_owner_def_id: DefId,
|
||||
found: Ty<'tcx>,
|
||||
) -> bool {
|
||||
@ -887,7 +884,7 @@ fn point_at_associated_type(
|
||||
if let hir::Defaultness::Default { has_value: true } = item.defaultness
|
||||
{
|
||||
if self.type_of(item.id.def_id) == found {
|
||||
db.span_label(
|
||||
diag.span_label(
|
||||
item.span,
|
||||
"associated type defaults can't be assumed inside the \
|
||||
trait defining them",
|
||||
@ -907,7 +904,7 @@ trait defining them",
|
||||
for item in &items[..] {
|
||||
if let hir::AssocItemKind::Type = item.kind {
|
||||
if self.type_of(item.id.def_id) == found {
|
||||
db.span_label(item.span, "expected this associated type");
|
||||
diag.span_label(item.span, "expected this associated type");
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -927,8 +924,7 @@ trait defining them",
|
||||
/// type is defined on a supertrait of the one present in the bounds.
|
||||
fn constrain_generic_bound_associated_type_structured_suggestion(
|
||||
self,
|
||||
// FIXME(eddyb) rename this since it's no longer a `DiagnosticBuilder`.
|
||||
db: &mut Diagnostic,
|
||||
diag: &mut Diagnostic,
|
||||
trait_ref: &ty::TraitRef<'tcx>,
|
||||
bounds: hir::GenericBounds<'_>,
|
||||
assoc: &ty::AssocItem,
|
||||
@ -958,15 +954,21 @@ fn constrain_generic_bound_associated_type_structured_suggestion(
|
||||
_ => return false,
|
||||
};
|
||||
|
||||
self.constrain_associated_type_structured_suggestion(db, span, assoc, assoc_substs, ty, msg)
|
||||
self.constrain_associated_type_structured_suggestion(
|
||||
diag,
|
||||
span,
|
||||
assoc,
|
||||
assoc_substs,
|
||||
ty,
|
||||
msg,
|
||||
)
|
||||
}
|
||||
|
||||
/// Given a span corresponding to a bound, provide a structured suggestion to set an
|
||||
/// associated type to a given type `ty`.
|
||||
fn constrain_associated_type_structured_suggestion(
|
||||
self,
|
||||
// FIXME(eddyb) rename this since it's no longer a `DiagnosticBuilder`.
|
||||
db: &mut Diagnostic,
|
||||
diag: &mut Diagnostic,
|
||||
span: Span,
|
||||
assoc: &ty::AssocItem,
|
||||
assoc_substs: &[ty::GenericArg<'tcx>],
|
||||
@ -984,7 +986,7 @@ fn constrain_associated_type_structured_suggestion(
|
||||
let item_args = self.format_generic_args(assoc_substs);
|
||||
(span.shrink_to_hi(), format!("<{}{} = {}>", assoc.ident(self), item_args, ty))
|
||||
};
|
||||
db.span_suggestion_verbose(span, msg, sugg, MaybeIncorrect);
|
||||
diag.span_suggestion_verbose(span, msg, sugg, MaybeIncorrect);
|
||||
return true;
|
||||
}
|
||||
false
|
||||
|
||||
@ -1875,8 +1875,7 @@ impl<'tcx> LifetimeContext<'_, 'tcx> {
|
||||
/// Returns whether to add `'static` lifetime to the suggested lifetime list.
|
||||
crate fn report_elision_failure(
|
||||
&mut self,
|
||||
// FIXME(eddyb) rename this since it's no longer a `DiagnosticBuilder`.
|
||||
db: &mut Diagnostic,
|
||||
diag: &mut Diagnostic,
|
||||
params: &[ElisionFailureInfo],
|
||||
) -> bool {
|
||||
let mut m = String::new();
|
||||
@ -1891,7 +1890,7 @@ impl<'tcx> LifetimeContext<'_, 'tcx> {
|
||||
let ElisionFailureInfo { parent, index, lifetime_count: n, have_bound_regions, span } =
|
||||
info;
|
||||
|
||||
db.span_label(span, "");
|
||||
diag.span_label(span, "");
|
||||
let help_name = if let Some(ident) =
|
||||
parent.and_then(|body| self.tcx.hir().body(body).params[index].pat.simple_ident())
|
||||
{
|
||||
@ -1923,27 +1922,27 @@ impl<'tcx> LifetimeContext<'_, 'tcx> {
|
||||
}
|
||||
|
||||
if len == 0 {
|
||||
db.help(
|
||||
diag.help(
|
||||
"this function's return type contains a borrowed value, \
|
||||
but there is no value for it to be borrowed from",
|
||||
);
|
||||
true
|
||||
} else if elided_len == 0 {
|
||||
db.help(
|
||||
diag.help(
|
||||
"this function's return type contains a borrowed value with \
|
||||
an elided lifetime, but the lifetime cannot be derived from \
|
||||
the arguments",
|
||||
);
|
||||
true
|
||||
} else if elided_len == 1 {
|
||||
db.help(&format!(
|
||||
diag.help(&format!(
|
||||
"this function's return type contains a borrowed value, \
|
||||
but the signature does not say which {} it is borrowed from",
|
||||
m
|
||||
));
|
||||
false
|
||||
} else {
|
||||
db.help(&format!(
|
||||
diag.help(&format!(
|
||||
"this function's return type contains a borrowed value, \
|
||||
but the signature does not say whether it is borrowed from {}",
|
||||
m
|
||||
|
||||
@ -440,6 +440,13 @@ fn report_selection_error(
|
||||
}
|
||||
}
|
||||
|
||||
if Some(trait_ref.def_id()) == tcx.lang_items().drop_trait()
|
||||
&& predicate_is_const
|
||||
{
|
||||
err.note("`~const Drop` was renamed to `~const Destruct`");
|
||||
err.note("See <https://github.com/rust-lang/rust/pull/94901> for more details");
|
||||
}
|
||||
|
||||
let explanation = if let ObligationCauseCode::MainFunctionType =
|
||||
obligation.cause.code()
|
||||
{
|
||||
|
||||
@ -2593,14 +2593,15 @@ unsafe fn rotate_right_inner(&mut self, k: usize) {
|
||||
/// ```
|
||||
///
|
||||
/// If you want to insert an item to a sorted deque, while maintaining
|
||||
/// sort order:
|
||||
/// sort order, consider using [`partition_point`]:
|
||||
///
|
||||
/// ```
|
||||
/// use std::collections::VecDeque;
|
||||
///
|
||||
/// let mut deque: VecDeque<_> = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into();
|
||||
/// let num = 42;
|
||||
/// let idx = deque.binary_search(&num).unwrap_or_else(|x| x);
|
||||
/// let idx = deque.partition_point(|&x| x < num);
|
||||
/// // The above is equivalent to `let idx = deque.binary_search(&num).unwrap_or_else(|x| x);`
|
||||
/// deque.insert(idx, num);
|
||||
/// assert_eq!(deque, &[0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
|
||||
/// ```
|
||||
@ -2744,6 +2745,19 @@ pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, mut f: F) -> Result<usize
|
||||
/// assert!(deque.iter().take(i).all(|&x| x < 5));
|
||||
/// assert!(deque.iter().skip(i).all(|&x| !(x < 5)));
|
||||
/// ```
|
||||
///
|
||||
/// If you want to insert an item to a sorted deque, while maintaining
|
||||
/// sort order:
|
||||
///
|
||||
/// ```
|
||||
/// use std::collections::VecDeque;
|
||||
///
|
||||
/// let mut deque: VecDeque<_> = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into();
|
||||
/// let num = 42;
|
||||
/// let idx = deque.partition_point(|&x| x < num);
|
||||
/// deque.insert(idx, num);
|
||||
/// assert_eq!(deque, &[0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
|
||||
/// ```
|
||||
#[stable(feature = "vecdeque_binary_search", since = "1.54.0")]
|
||||
pub fn partition_point<P>(&self, mut pred: P) -> usize
|
||||
where
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
use alloc::boxed::ThinBox;
|
||||
use core::mem::size_of;
|
||||
use std::boxed::ThinBox;
|
||||
|
||||
#[test]
|
||||
fn want_niche_optimization() {
|
||||
|
||||
@ -2331,12 +2331,13 @@ pub fn strip_suffix<P: SlicePattern<Item = T> + ?Sized>(&self, suffix: &P) -> Op
|
||||
/// ```
|
||||
///
|
||||
/// If you want to insert an item to a sorted vector, while maintaining
|
||||
/// sort order:
|
||||
/// sort order, consider using [`partition_point`]:
|
||||
///
|
||||
/// ```
|
||||
/// let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
|
||||
/// let num = 42;
|
||||
/// let idx = s.binary_search(&num).unwrap_or_else(|x| x);
|
||||
/// let idx = s.partition_point(|&x| x < num);
|
||||
/// // The above is equivalent to `let idx = s.binary_search(&num).unwrap_or_else(|x| x);`
|
||||
/// s.insert(idx, num);
|
||||
/// assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
|
||||
/// ```
|
||||
@ -3743,6 +3744,17 @@ pub fn is_sorted_by_key<F, K>(&self, f: F) -> bool
|
||||
/// assert!(v[..i].iter().all(|&x| x < 5));
|
||||
/// assert!(v[i..].iter().all(|&x| !(x < 5)));
|
||||
/// ```
|
||||
///
|
||||
/// If you want to insert an item to a sorted vector, while maintaining
|
||||
/// sort order:
|
||||
///
|
||||
/// ```
|
||||
/// let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
|
||||
/// let num = 42;
|
||||
/// let idx = s.partition_point(|&x| x < num);
|
||||
/// s.insert(idx, num);
|
||||
/// assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
|
||||
/// ```
|
||||
#[stable(feature = "partition_point", since = "1.52.0")]
|
||||
#[must_use]
|
||||
pub fn partition_point<P>(&self, mut pred: P) -> usize
|
||||
|
||||
@ -621,9 +621,9 @@ macro_rules! describe {
|
||||
|
||||
pub fn get_help(build: &Build, subcommand: &str) -> Option<String> {
|
||||
let kind = match subcommand {
|
||||
"build" => Kind::Build,
|
||||
"doc" => Kind::Doc,
|
||||
"test" => Kind::Test,
|
||||
"build" | "b" => Kind::Build,
|
||||
"doc" | "d" => Kind::Doc,
|
||||
"test" | "t" => Kind::Test,
|
||||
"bench" => Kind::Bench,
|
||||
"dist" => Kind::Dist,
|
||||
"install" => Kind::Install,
|
||||
|
||||
@ -136,7 +136,7 @@ able to get around this problem by setting `-Clinker=lld-link` in RUSTFLAGS
|
||||
```sh
|
||||
rustup toolchain install --profile minimal nightly
|
||||
MINOR_VERSION=$(rustc +nightly --version | cut -d . -f 2)
|
||||
LOWER_BOUND=44
|
||||
LOWER_BOUND=61
|
||||
|
||||
llvm_version() {
|
||||
toolchain="$1"
|
||||
@ -179,5 +179,19 @@ The following table shows known good combinations of toolchain versions.
|
||||
| Rust 1.44 | Clang 9 |
|
||||
| Rust 1.45 | Clang 10 |
|
||||
| Rust 1.46 | Clang 10 |
|
||||
| Rust 1.47 | Clang 11 |
|
||||
| Rust 1.48 | Clang 11 |
|
||||
| Rust 1.49 | Clang 11 |
|
||||
| Rust 1.50 | Clang 11 |
|
||||
| Rust 1.51 | Clang 11 |
|
||||
| Rust 1.52 | Clang 12 |
|
||||
| Rust 1.53 | Clang 12 |
|
||||
| Rust 1.54 | Clang 12 |
|
||||
| Rust 1.55 | Clang 12 |
|
||||
| Rust 1.56 | Clang 13 |
|
||||
| Rust 1.57 | Clang 13 |
|
||||
| Rust 1.58 | Clang 13 |
|
||||
| Rust 1.59 | Clang 13 |
|
||||
| Rust 1.60 | Clang 14 |
|
||||
|
||||
Note that the compatibility policy for this feature might change in the future.
|
||||
|
||||
@ -31,18 +31,20 @@ All tier 1 targets with host tools support the full standard library.
|
||||
target | notes
|
||||
-------|-------
|
||||
`aarch64-unknown-linux-gnu` | ARM64 Linux (kernel 4.2, glibc 2.17+) [^missing-stack-probes]
|
||||
`i686-pc-windows-gnu` | 32-bit MinGW (Windows 7+)
|
||||
`i686-pc-windows-msvc` | 32-bit MSVC (Windows 7+)
|
||||
`i686-pc-windows-gnu` | 32-bit MinGW (Windows 7+) [^windows-support]
|
||||
`i686-pc-windows-msvc` | 32-bit MSVC (Windows 7+) [^windows-support]
|
||||
`i686-unknown-linux-gnu` | 32-bit Linux (kernel 2.6.32+, glibc 2.11+)
|
||||
`x86_64-apple-darwin` | 64-bit macOS (10.7+, Lion+)
|
||||
`x86_64-pc-windows-gnu` | 64-bit MinGW (Windows 7+)
|
||||
`x86_64-pc-windows-msvc` | 64-bit MSVC (Windows 7+)
|
||||
`x86_64-pc-windows-gnu` | 64-bit MinGW (Windows 7+) [^windows-support]
|
||||
`x86_64-pc-windows-msvc` | 64-bit MSVC (Windows 7+) [^windows-support]
|
||||
`x86_64-unknown-linux-gnu` | 64-bit Linux (kernel 2.6.32+, glibc 2.11+)
|
||||
|
||||
[^missing-stack-probes]: Stack probes support is missing on
|
||||
`aarch64-unknown-linux-gnu`, but it's planned to be implemented in the near
|
||||
future. The implementation is tracked on [issue #77071][77071].
|
||||
|
||||
[^windows-support]: Only Windows 10 currently undergoes automated testing. Earlier versions of Windows rely on testing and support from the community.
|
||||
|
||||
[77071]: https://github.com/rust-lang/rust/issues/77071
|
||||
|
||||
## Tier 1
|
||||
|
||||
@ -302,23 +302,13 @@ fn clean(&self, cx: &mut DocContext<'_>) -> Option<WherePredicate> {
|
||||
|
||||
impl<'a> Clean<Option<WherePredicate>> for ty::PolyTraitPredicate<'a> {
|
||||
fn clean(&self, cx: &mut DocContext<'_>) -> Option<WherePredicate> {
|
||||
// `T: ~const Drop` is not equivalent to `T: Drop`, and we don't currently document `~const` bounds
|
||||
// because of its experimental status, so just don't show these.
|
||||
// `T: ~const Destruct` is hidden because `T: Destruct` is a no-op.
|
||||
if self.skip_binder().constness == ty::BoundConstness::ConstIfConst
|
||||
&& [cx.tcx.lang_items().drop_trait(), cx.tcx.lang_items().destruct_trait()]
|
||||
.iter()
|
||||
.any(|tr| *tr == Some(self.skip_binder().def_id()))
|
||||
&& Some(self.skip_binder().def_id()) == cx.tcx.lang_items().destruct_trait()
|
||||
{
|
||||
return None;
|
||||
}
|
||||
|
||||
#[cfg(bootstrap)]
|
||||
{
|
||||
// FIXME: remove `lang_items().drop_trait()` from above logic,
|
||||
// as well as the comment about `~const Drop` because it was renamed to `Destruct`.
|
||||
}
|
||||
|
||||
let poly_trait_ref = self.map_bound(|pred| pred.trait_ref);
|
||||
Some(WherePredicate::BoundPredicate {
|
||||
ty: poly_trait_ref.skip_binder().self_ty().clean(cx),
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
// Test that we do not currently display `~const` in rustdoc
|
||||
// as that syntax is currently provisional; `~const Drop` has
|
||||
// as that syntax is currently provisional; `~const Destruct` has
|
||||
// no effect on stable code so it should be hidden as well.
|
||||
//
|
||||
// To future blessers: make sure that `const_trait_impl` is
|
||||
@ -8,6 +8,8 @@
|
||||
#![feature(const_trait_impl)]
|
||||
#![crate_name = "foo"]
|
||||
|
||||
use std::marker::Destruct;
|
||||
|
||||
pub struct S<T>(T);
|
||||
|
||||
// @!has foo/trait.Tr.html '//pre[@class="rust trait"]/code/a[@class="trait"]' '~const'
|
||||
@ -20,22 +22,36 @@ pub trait Tr<T> {
|
||||
// @!has - '//div[@id="method.a"]/h4[@class="code-header"]/span[@class="where"]' '~const'
|
||||
// @has - '//div[@id="method.a"]/h4[@class="code-header"]/span[@class="where fmt-newline"]' ': Clone'
|
||||
#[default_method_body_is_const]
|
||||
fn a<A: ~const Clone>() where Option<A>: ~const Clone {}
|
||||
fn a<A: ~const Clone + ~const Destruct>()
|
||||
where
|
||||
Option<A>: ~const Clone + ~const Destruct,
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
// @!has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]' '~const'
|
||||
// @has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/a[@class="trait"]' 'Clone'
|
||||
// @!has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/span[@class="where"]' '~const'
|
||||
// @has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/span[@class="where fmt-newline"]' ': Clone'
|
||||
impl<T: ~const Clone> const Tr<T> for T where Option<T>: ~const Clone {
|
||||
fn a<A: ~const Clone>() where Option<A>: ~const Clone {}
|
||||
impl<T: ~const Clone + ~const Destruct> const Tr<T> for T
|
||||
where
|
||||
Option<T>: ~const Clone + ~const Destruct,
|
||||
{
|
||||
fn a<A: ~const Clone + ~const Destruct>()
|
||||
where
|
||||
Option<A>: ~const Clone + ~const Destruct,
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
// @!has foo/fn.foo.html '//pre[@class="rust fn"]/code/a[@class="trait"]' '~const'
|
||||
// @has - '//pre[@class="rust fn"]/code/a[@class="trait"]' 'Clone'
|
||||
// @!has - '//pre[@class="rust fn"]/code/span[@class="where fmt-newline"]' '~const'
|
||||
// @has - '//pre[@class="rust fn"]/code/span[@class="where fmt-newline"]' ': Clone'
|
||||
pub const fn foo<F: ~const Clone>() where Option<F>: ~const Clone {
|
||||
pub const fn foo<F: ~const Clone + ~const Destruct>()
|
||||
where
|
||||
Option<F>: ~const Clone + ~const Destruct,
|
||||
{
|
||||
F::a()
|
||||
}
|
||||
|
||||
@ -44,7 +60,10 @@ impl<T> S<T> {
|
||||
// @has - '//section[@id="method.foo"]/h4[@class="code-header"]/a[@class="trait"]' 'Clone'
|
||||
// @!has - '//section[@id="method.foo"]/h4[@class="code-header"]/span[@class="where"]' '~const'
|
||||
// @has - '//section[@id="method.foo"]/h4[@class="code-header"]/span[@class="where fmt-newline"]' ': Clone'
|
||||
pub const fn foo<B: ~const Clone>() where B: ~const Clone {
|
||||
pub const fn foo<B: ~const Clone + ~const Destruct>()
|
||||
where
|
||||
B: ~const Clone + ~const Destruct,
|
||||
{
|
||||
B::a()
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user