mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Auto merge of #96877 - matthiaskrgr:rollup-evlh6ot, r=matthiaskrgr

Browse source 
Rollup of 6 pull requests

Successful merges:

 - #95483 (Improve floating point documentation)
 - #96008 (Warn on unused `#[doc(hidden)]` attributes on trait impl items)
 - #96841 (Revert "Implement [OsStr]::join", which was merged without FCP.)
 - #96844 (Actually fix ICE from #96583)
 - #96854 (Some subst cleanup)
 - #96858 (Remove unused param from search.js::checkPath)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2022-05-09 17:23:34 +00:00
commit 0dd7e10282
37 changed files with 471 additions and 214 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

48
compiler/rustc_middle/src/ty/subst.rs
View file

@ -10,7 +10,7 @@ use rustc_data_structures::intern::{Interned, WithStableHash};
use rustc_hir::def_id::DefId;
use rustc_macros::HashStable;
use rustc_serialize::{self, Decodable, Encodable};
use rustc_span::{Span, DUMMY_SP};
use rustc_span::DUMMY_SP;
use smallvec::SmallVec;
use core::intrinsics;
@ -498,34 +498,14 @@ impl<'tcx> TypeFoldable<'tcx> for &'tcx ty::List<Ty<'tcx>> {
}
}
///////////////////////////////////////////////////////////////////////////
// Public trait `Subst`
//
// Just call `foo.subst(tcx, substs)` to perform a substitution across
// `foo`. Or use `foo.subst_spanned(tcx, substs, Some(span))` when
// there is more information available (for better errors).
// Just call `foo.subst(tcx, substs)` to perform a substitution across `foo`.
pub trait Subst<'tcx>: Sized {
fn subst(self, tcx: TyCtxt<'tcx>, substs: &[GenericArg<'tcx>]) -> Self {
self.subst_spanned(tcx, substs, None)
}
fn subst_spanned(
self,
tcx: TyCtxt<'tcx>,
substs: &[GenericArg<'tcx>],
span: Option<Span>,
) -> Self;
fn subst(self, tcx: TyCtxt<'tcx>, substs: &[GenericArg<'tcx>]) -> Self;
}
impl<'tcx, T: TypeFoldable<'tcx>> Subst<'tcx> for T {
fn subst_spanned(
self,
tcx: TyCtxt<'tcx>,
substs: &[GenericArg<'tcx>],
span: Option<Span>,
) -> T {
let mut folder = SubstFolder { tcx, substs, span, binders_passed: 0 };
fn subst(self, tcx: TyCtxt<'tcx>, substs: &[GenericArg<'tcx>]) -> T {
let mut folder = SubstFolder { tcx, substs, binders_passed: 0 };
self.fold_with(&mut folder)
}
}
@ -537,9 +517,6 @@ struct SubstFolder<'a, 'tcx> {
tcx: TyCtxt<'tcx>,
substs: &'a [GenericArg<'tcx>],
/// The location for which the substitution is performed, if available.
span: Option<Span>,
/// Number of region binders we have passed through while doing the substitution
binders_passed: u32,
}
@ -571,13 +548,12 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {
match rk {
Some(GenericArgKind::Lifetime(lt)) => self.shift_region_through_binders(lt),
_ => {
let span = self.span.unwrap_or(DUMMY_SP);
let msg = format!(
"Region parameter out of range \
when substituting in region {} (index={})",
data.name, data.index
);
span_bug!(span, "{}", msg);
span_bug!(DUMMY_SP, "{}", msg);
}
}
}
@ -617,9 +593,8 @@ impl<'a, 'tcx> SubstFolder<'a, 'tcx> {
let ty = match opt_ty {
Some(GenericArgKind::Type(ty)) => ty,
Some(kind) => {
let span = self.span.unwrap_or(DUMMY_SP);
span_bug!(
span,
DUMMY_SP,
"expected type for `{:?}` ({:?}/{}) but found {:?} \
when substituting, substs={:?}",
p,
@ -630,9 +605,8 @@ impl<'a, 'tcx> SubstFolder<'a, 'tcx> {
);
}
None => {
let span = self.span.unwrap_or(DUMMY_SP);
span_bug!(
span,
DUMMY_SP,
"type parameter `{:?}` ({:?}/{}) out of range \
when substituting, substs={:?}",
p,
@ -652,9 +626,8 @@ impl<'a, 'tcx> SubstFolder<'a, 'tcx> {
let ct = match opt_ct {
Some(GenericArgKind::Const(ct)) => ct,
Some(kind) => {
let span = self.span.unwrap_or(DUMMY_SP);
span_bug!(
span,
DUMMY_SP,
"expected const for `{:?}` ({:?}/{}) but found {:?} \
when substituting substs={:?}",
p,
@ -665,9 +638,8 @@ impl<'a, 'tcx> SubstFolder<'a, 'tcx> {
);
}
None => {
let span = self.span.unwrap_or(DUMMY_SP);
span_bug!(
span,
DUMMY_SP,
"const parameter `{:?}` ({:?}/{}) out of range \
when substituting substs={:?}",
p,

76
compiler/rustc_passes/src/check_attr.rs
View file

@ -4,7 +4,8 @@
//! conflicts between multiple such attributes attached to the same
//! item.
use rustc_ast::{ast, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
use rustc_ast::tokenstream::DelimSpan;
use rustc_ast::{ast, AttrStyle, Attribute, Lit, LitKind, MacArgs, MetaItemKind, NestedMetaItem};
use rustc_data_structures::fx::FxHashMap;
use rustc_errors::{pluralize, struct_span_err, Applicability, MultiSpan};
use rustc_feature::{AttributeDuplicates, AttributeType, BuiltinAttribute, BUILTIN_ATTRIBUTE_MAP};
@ -810,6 +811,68 @@ impl CheckAttrVisitor<'_> {
}
}
/// Checks `#[doc(hidden)]` attributes. Returns `true` if valid.
fn check_doc_hidden(
&self,
attr: &Attribute,
meta_index: usize,
meta: &NestedMetaItem,
hir_id: HirId,
target: Target,
) -> bool {
if let Target::AssocConst
| Target::AssocTy
| Target::Method(MethodKind::Trait { body: true }) = target
{
let parent_hir_id = self.tcx.hir().get_parent_item(hir_id);
let containing_item = self.tcx.hir().expect_item(parent_hir_id);
if Target::from_item(containing_item) == Target::Impl {
let meta_items = attr.meta_item_list().unwrap();
let (span, replacement_span) = if meta_items.len() == 1 {
(attr.span, attr.span)
} else {
let meta_span = meta.span();
(
meta_span,
meta_span.until(match meta_items.get(meta_index + 1) {
Some(next_item) => next_item.span(),
None => match attr.get_normal_item().args {
MacArgs::Delimited(DelimSpan { close, .. }, ..) => close,
_ => unreachable!(),
},
}),
)
};
// FIXME: #[doc(hidden)] was previously erroneously allowed on trait impl items,
// so for backward compatibility only emit a warning and do not mark it as invalid.
self.tcx.struct_span_lint_hir(UNUSED_ATTRIBUTES, hir_id, span, |lint| {
lint.build("`#[doc(hidden)]` is ignored on trait impl items")
.warn(
"this was previously accepted by the compiler but is \
being phased out; it will become a hard error in \
a future release!",
)
.note(
"whether the impl item is `doc(hidden)` or not \
entirely depends on the corresponding trait item",
)
.span_suggestion(
replacement_span,
"remove this attribute",
String::new(),
Applicability::MachineApplicable,
)
.emit();
});
}
}
true
}
/// Checks that an attribute is *not* used at the crate level. Returns `true` if valid.
fn check_attr_not_crate_level(
&self,
@ -928,7 +991,7 @@ impl CheckAttrVisitor<'_> {
let mut is_valid = true;
if let Some(mi) = attr.meta() && let Some(list) = mi.meta_item_list() {
for meta in list {
for (meta_index, meta) in list.into_iter().enumerate() {
if let Some(i_meta) = meta.meta_item() {
match i_meta.name_or_empty() {
sym::alias
@ -969,6 +1032,15 @@ impl CheckAttrVisitor<'_> {
is_valid = false;
}
sym::hidden if !self.check_doc_hidden(attr,
meta_index,
meta,
hir_id,
target,
) => {
is_valid = false;
}
// no_default_passes: deprecated
// passes: deprecated
// plugins: removed, but rustdoc warns about it itself

10
compiler/rustc_typeck/src/astconv/mod.rs
View file

@ -523,11 +523,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
self.astconv
.normalize_ty(
self.span,
tcx.at(self.span).type_of(param.def_id).subst_spanned(
tcx,
substs,
Some(self.span),
),
tcx.at(self.span).type_of(param.def_id).subst(tcx, substs),
)
.into()
}
@ -547,9 +543,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
GenericParamDefKind::Const { has_default } => {
let ty = tcx.at(self.span).type_of(param.def_id);
if !infer_args && has_default {
tcx.const_param_default(param.def_id)
.subst_spanned(tcx, substs.unwrap(), Some(self.span))
.into()
tcx.const_param_default(param.def_id).subst(tcx, substs.unwrap()).into()
} else {
if infer_args {
self.astconv.ct_infer(ty, Some(param), self.span).into()

29
compiler/rustc_typeck/src/check/expr.rs
View file

@ -44,7 +44,7 @@ use rustc_middle::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase};
use rustc_middle::ty::error::ExpectedFound;
use rustc_middle::ty::error::TypeError::{FieldMisMatch, Sorts};
use rustc_middle::ty::subst::SubstsRef;
use rustc_middle::ty::{self, AdtKind, Ty, TypeFoldable};
use rustc_middle::ty::{self, AdtKind, DefIdTree, Ty, TypeFoldable};
use rustc_session::parse::feature_err;
use rustc_span::hygiene::DesugaringKind;
use rustc_span::lev_distance::find_best_match_for_name;
@ -2034,17 +2034,26 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
base: &'tcx hir::Expr<'tcx>,
def_id: DefId,
) {
let local_id = def_id.expect_local();
let hir_id = self.tcx.hir().local_def_id_to_hir_id(local_id);
let node = self.tcx.hir().get(hir_id);
if let Some(local_id) = def_id.as_local() {
let hir_id = self.tcx.hir().local_def_id_to_hir_id(local_id);
let node = self.tcx.hir().get(hir_id);
if let Some(fields) = node.tuple_fields() {
let kind = match self.tcx.opt_def_kind(local_id) {
Some(DefKind::Ctor(of, _)) => of,
_ => return,
};
if let Some(fields) = node.tuple_fields() {
let kind = match self.tcx.opt_def_kind(local_id) {
Some(DefKind::Ctor(of, _)) => of,
_ => return,
};
suggest_call_constructor(base.span, kind, fields.len(), err);
suggest_call_constructor(base.span, kind, fields.len(), err);
}
} else {
// The logic here isn't smart but `associated_item_def_ids`
// doesn't work nicely on local.
if let DefKind::Ctor(of, _) = self.tcx.def_kind(def_id) {
let parent_def_id = self.tcx.parent(def_id);
let fields = self.tcx.associated_item_def_ids(parent_def_id);
suggest_call_constructor(base.span, of, fields.len(), err);
}
}
}

9
compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs
View file

@ -1403,10 +1403,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// is missing.
let default = tcx.type_of(param.def_id);
self.fcx
.normalize_ty(
self.span,
default.subst_spanned(tcx, substs.unwrap(), Some(self.span)),
)
.normalize_ty(self.span, default.subst(tcx, substs.unwrap()))
.into()
} else {
// If no type arguments were provided, we have to infer them.
@ -1418,9 +1415,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
GenericParamDefKind::Const { has_default } => {
if !infer_args && has_default {
tcx.const_param_default(param.def_id)
.subst_spanned(tcx, substs.unwrap(), Some(self.span))
.into()
tcx.const_param_default(param.def_id).subst(tcx, substs.unwrap()).into()
} else {
self.fcx.var_for_def(self.span, param)
}

16
compiler/rustc_typeck/src/check/method/confirm.rs
View file

@ -462,19 +462,13 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
let sig = self.tcx.fn_sig(def_id);
// Instantiate late-bound regions and substitute the trait
// parameters into the method type to get the actual method type.
//
// N.B., instantiate late-bound regions first so that
// `instantiate_type_scheme` can normalize associated types that
// may reference those regions.
let method_sig = self.replace_bound_vars_with_fresh_vars(sig);
debug!("late-bound lifetimes from method instantiated, method_sig={:?}", method_sig);
let sig = sig.subst(self.tcx, all_substs);
debug!("type scheme substituted, sig={:?}", sig);
let method_sig = method_sig.subst(self.tcx, all_substs);
debug!("type scheme substituted, method_sig={:?}", method_sig);
let sig = self.replace_bound_vars_with_fresh_vars(sig);
debug!("late-bound lifetimes from method instantiated, sig={:?}", sig);
(method_sig, method_predicates)
(sig, method_predicates)
}
fn add_obligations(

2
compiler/rustc_typeck/src/check/method/mod.rs
View file

@ -461,8 +461,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// `instantiate_type_scheme` can normalize associated types that
// may reference those regions.
let fn_sig = tcx.fn_sig(def_id);
let fn_sig = self.replace_bound_vars_with_fresh_vars(span, infer::FnCall, fn_sig).0;
let fn_sig = fn_sig.subst(self.tcx, substs);
let fn_sig = self.replace_bound_vars_with_fresh_vars(span, infer::FnCall, fn_sig).0;
let InferOk { value, obligations: o } = if is_op {
self.normalize_op_associated_types_in_as_infer_ok(span, fn_sig, opt_input_expr)

14
compiler/rustc_typeck/src/check/method/probe.rs
View file

@ -1784,12 +1784,8 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
let generics = self.tcx.generics_of(method);
assert_eq!(substs.len(), generics.parent_count as usize);
// Erase any late-bound regions from the method and substitute
// in the values from the substitution.
let xform_fn_sig = self.erase_late_bound_regions(fn_sig);
if generics.params.is_empty() {
xform_fn_sig.subst(self.tcx, substs)
let xform_fn_sig = if generics.params.is_empty() {
fn_sig.subst(self.tcx, substs)
} else {
let substs = InternalSubsts::for_item(self.tcx, method, |param, _| {
let i = param.index as usize;
@ -1807,8 +1803,10 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
}
}
});
xform_fn_sig.subst(self.tcx, substs)
}
fn_sig.subst(self.tcx, substs)
};
self.erase_late_bound_regions(xform_fn_sig)
}
/// Gets the type of an impl and generate substitutions with placeholders.

1
library/alloc/src/collections/vec_deque/iter.rs
View file

@ -122,7 +122,6 @@ impl<'a, T> Iterator for Iter<'a, T> {
}
#[inline]
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
// Safety: The TrustedRandomAccess contract requires that callers only pass an index
// that is in bounds.

1
library/alloc/src/collections/vec_deque/iter_mut.rs
View file

@ -100,7 +100,6 @@ impl<'a, T> Iterator for IterMut<'a, T> {
}
#[inline]
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
// Safety: The TrustedRandomAccess contract requires that callers only pass an index
// that is in bounds.

1
library/alloc/src/vec/into_iter.rs
View file

@ -202,7 +202,6 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> {
self.len()
}
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> Self::Item
where
Self: TrustedRandomAccessNoCoerce,

1
library/core/src/convert/num.rs
View file

@ -25,7 +25,6 @@ macro_rules! impl_float_to_int {
$(
#[unstable(feature = "convert_float_to_int", issue = "67057")]
impl FloatToInt<$Int> for $Float {
#[doc(hidden)]
#[inline]
unsafe fn to_int_unchecked(self) -> $Int {
// SAFETY: the safety contract must be upheld by the caller.

1
library/core/src/iter/adapters/cloned.rs
View file

@ -60,7 +60,6 @@ where
self.it.map(T::clone).fold(init, f)
}
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> T
where
Self: TrustedRandomAccessNoCoerce,

1
library/core/src/iter/adapters/copied.rs
View file

@ -81,7 +81,6 @@ where
self.it.advance_by(n)
}
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> T
where
Self: TrustedRandomAccessNoCoerce,

1
library/core/src/iter/adapters/enumerate.rs
View file

@ -128,7 +128,6 @@ where
}
#[rustc_inherit_overflow_checks]
#[doc(hidden)]
#[inline]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> <Self as Iterator>::Item
where

1
library/core/src/iter/adapters/fuse.rs
View file

@ -129,7 +129,6 @@ where
}
#[inline]
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item
where
Self: TrustedRandomAccessNoCoerce,

1
library/core/src/iter/adapters/map.rs
View file

@ -124,7 +124,6 @@ where
self.iter.fold(init, map_fold(self.f, g))
}
#[doc(hidden)]
#[inline]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> B
where

1
library/core/src/iter/adapters/zip.rs
View file

@ -95,7 +95,6 @@ where
}
#[inline]
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item
where
Self: TrustedRandomAccessNoCoerce,

1
library/core/src/iter/range.rs
View file

@ -752,7 +752,6 @@ impl<A: Step> Iterator for ops::Range<A> {
}
#[inline]
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item
where
Self: TrustedRandomAccessNoCoerce,

79
library/core/src/num/f32.rs
View file

@ -393,6 +393,15 @@ impl f32 {
pub const MAX_10_EXP: i32 = 38;
/// Not a Number (NaN).
///
/// Note that IEEE-745 doesn't define just a single NaN value;
/// a plethora of bit patterns are considered to be NaN.
/// Furthermore, the standard makes a difference
/// between a "signaling" and a "quiet" NaN,
/// and allows inspecting its "payload" (the unspecified bits in the bit pattern).
/// This constant isn't guaranteed to equal to any specific NaN bitpattern,
/// and the stability of its representation over Rust versions
/// and target platforms isn't guaranteed.
#[stable(feature = "assoc_int_consts", since = "1.43.0")]
pub const NAN: f32 = 0.0_f32 / 0.0_f32;
/// Infinity (∞).
@ -402,7 +411,7 @@ impl f32 {
#[stable(feature = "assoc_int_consts", since = "1.43.0")]
pub const NEG_INFINITY: f32 = -1.0_f32 / 0.0_f32;
/// Returns `true` if this value is `NaN`.
/// Returns `true` if this value is NaN.
///
/// ```
/// let nan = f32::NAN;
@ -455,7 +464,7 @@ impl f32 {
(self == f32::INFINITY) | (self == f32::NEG_INFINITY)
}
/// Returns `true` if this number is neither infinite nor `NaN`.
/// Returns `true` if this number is neither infinite nor NaN.
///
/// ```
/// let f = 7.0f32;
@ -506,7 +515,7 @@ impl f32 {
}
/// Returns `true` if the number is neither zero, infinite,
/// [subnormal], or `NaN`.
/// [subnormal], or NaN.
///
/// ```
/// let min = f32::MIN_POSITIVE; // 1.17549435e-38f32
@ -622,8 +631,12 @@ impl f32 {
}
}
/// Returns `true` if `self` has a positive sign, including `+0.0`, `NaN`s with
/// positive sign bit and positive infinity.
/// Returns `true` if `self` has a positive sign, including `+0.0`, NaNs with
/// positive sign bit and positive infinity. Note that IEEE-745 doesn't assign any
/// meaning to the sign bit in case of a NaN, and as Rust doesn't guarantee that
/// the bit pattern of NaNs are conserved over arithmetic operations, the result of
/// `is_sign_positive` on a NaN might produce an unexpected result in some cases.
/// See [explanation of NaN as a special value](f32) for more info.
///
/// ```
/// let f = 7.0_f32;
@ -640,8 +653,12 @@ impl f32 {
!self.is_sign_negative()
}
/// Returns `true` if `self` has a negative sign, including `-0.0`, `NaN`s with
/// negative sign bit and negative infinity.
/// Returns `true` if `self` has a negative sign, including `-0.0`, NaNs with
/// negative sign bit and negative infinity. Note that IEEE-745 doesn't assign any
/// meaning to the sign bit in case of a NaN, and as Rust doesn't guarantee that
/// the bit pattern of NaNs are conserved over arithmetic operations, the result of
/// `is_sign_negative` on a NaN might produce an unexpected result in some cases.
/// See [explanation of NaN as a special value](f32) for more info.
///
/// ```
/// let f = 7.0f32;
@ -713,10 +730,12 @@ impl f32 {
self * (value / 180.0f32)
}
/// Returns the maximum of the two numbers.
/// Returns the maximum of the two numbers, ignoring NaN.
///
/// Follows the IEEE-754 2008 semantics for maxNum, except for handling of signaling NaNs.
/// This matches the behavior of libm’s fmax.
/// If one of the arguments is NaN, then the other argument is returned.
/// This follows the IEEE-754 2008 semantics for maxNum, except for handling of signaling NaNs;
/// this function handles all NaNs the same way and avoids maxNum's problems with associativity.
/// This also matches the behavior of libm’s fmax.
///
/// ```
/// let x = 1.0f32;
@ -724,8 +743,6 @@ impl f32 {
///
/// assert_eq!(x.max(y), y);
/// ```
///
/// If one of the arguments is NaN, then the other argument is returned.
#[must_use = "this returns the result of the comparison, without modifying either input"]
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -733,10 +750,12 @@ impl f32 {
intrinsics::maxnumf32(self, other)
}
/// Returns the minimum of the two numbers.
/// Returns the minimum of the two numbers, ignoring NaN.
///
/// Follows the IEEE-754 2008 semantics for minNum, except for handling of signaling NaNs.
/// This matches the behavior of libm’s fmin.
/// If one of the arguments is NaN, then the other argument is returned.
/// This follows the IEEE-754 2008 semantics for minNum, except for handling of signaling NaNs;
/// this function handles all NaNs the same way and avoids minNum's problems with associativity.
/// This also matches the behavior of libm’s fmin.
///
/// ```
/// let x = 1.0f32;
@ -744,8 +763,6 @@ impl f32 {
///
/// assert_eq!(x.min(y), x);
/// ```
///
/// If one of the arguments is NaN, then the other argument is returned.
#[must_use = "this returns the result of the comparison, without modifying either input"]
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -753,7 +770,7 @@ impl f32 {
intrinsics::minnumf32(self, other)
}
/// Returns the maximum of the two numbers, propagating NaNs.
/// Returns the maximum of the two numbers, propagating NaN.
///
/// This returns NaN when *either* argument is NaN, as opposed to
/// [`f32::max`] which only returns NaN when *both* arguments are NaN.
@ -770,6 +787,9 @@ impl f32 {
/// If one of the arguments is NaN, then NaN is returned. Otherwise this returns the greater
/// of the two numbers. For this operation, -0.0 is considered to be less than +0.0.
/// Note that this follows the semantics specified in IEEE 754-2019.
///
/// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
/// operand is conserved; see [explanation of NaN as a special value](f32) for more info.
#[must_use = "this returns the result of the comparison, without modifying either input"]
#[unstable(feature = "float_minimum_maximum", issue = "91079")]
#[inline]
@ -785,7 +805,7 @@ impl f32 {
}
}
/// Returns the minimum of the two numbers, propagating NaNs.
/// Returns the minimum of the two numbers, propagating NaN.
///
/// This returns NaN when *either* argument is NaN, as opposed to
/// [`f32::min`] which only returns NaN when *both* arguments are NaN.
@ -802,6 +822,9 @@ impl f32 {
/// If one of the arguments is NaN, then NaN is returned. Otherwise this returns the lesser
/// of the two numbers. For this operation, -0.0 is considered to be less than +0.0.
/// Note that this follows the semantics specified in IEEE 754-2019.
///
/// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
/// operand is conserved; see [explanation of NaN as a special value](f32) for more info.
#[must_use = "this returns the result of the comparison, without modifying either input"]
#[unstable(feature = "float_minimum_maximum", issue = "91079")]
#[inline]
@ -1009,6 +1032,9 @@ impl f32 {
/// Return the memory representation of this floating point number as a byte array in
/// big-endian (network) byte order.
///
/// See [`from_bits`](Self::from_bits) for some discussion of the
/// portability of this operation (there are almost no issues).
///
/// # Examples
///
/// ```
@ -1027,6 +1053,9 @@ impl f32 {
/// Return the memory representation of this floating point number as a byte array in
/// little-endian byte order.
///
/// See [`from_bits`](Self::from_bits) for some discussion of the
/// portability of this operation (there are almost no issues).
///
/// # Examples
///
/// ```
@ -1051,6 +1080,9 @@ impl f32 {
/// [`to_be_bytes`]: f32::to_be_bytes
/// [`to_le_bytes`]: f32::to_le_bytes
///
/// See [`from_bits`](Self::from_bits) for some discussion of the
/// portability of this operation (there are almost no issues).
///
/// # Examples
///
/// ```
@ -1075,6 +1107,9 @@ impl f32 {
/// Create a floating point value from its representation as a byte array in big endian.
///
/// See [`from_bits`](Self::from_bits) for some discussion of the
/// portability of this operation (there are almost no issues).
///
/// # Examples
///
/// ```
@ -1091,6 +1126,9 @@ impl f32 {
/// Create a floating point value from its representation as a byte array in little endian.
///
/// See [`from_bits`](Self::from_bits) for some discussion of the
/// portability of this operation (there are almost no issues).
///
/// # Examples
///
/// ```
@ -1114,6 +1152,9 @@ impl f32 {
/// [`from_be_bytes`]: f32::from_be_bytes
/// [`from_le_bytes`]: f32::from_le_bytes
///
/// See [`from_bits`](Self::from_bits) for some discussion of the
/// portability of this operation (there are almost no issues).
///
/// # Examples
///
/// ```

79
library/core/src/num/f64.rs
View file

@ -392,6 +392,15 @@ impl f64 {
pub const MAX_10_EXP: i32 = 308;
/// Not a Number (NaN).
///
/// Note that IEEE-745 doesn't define just a single NaN value;
/// a plethora of bit patterns are considered to be NaN.
/// Furthermore, the standard makes a difference
/// between a "signaling" and a "quiet" NaN,
/// and allows inspecting its "payload" (the unspecified bits in the bit pattern).
/// This constant isn't guaranteed to equal to any specific NaN bitpattern,
/// and the stability of its representation over Rust versions
/// and target platforms isn't guaranteed.
#[stable(feature = "assoc_int_consts", since = "1.43.0")]
pub const NAN: f64 = 0.0_f64 / 0.0_f64;
/// Infinity (∞).
@ -401,7 +410,7 @@ impl f64 {
#[stable(feature = "assoc_int_consts", since = "1.43.0")]
pub const NEG_INFINITY: f64 = -1.0_f64 / 0.0_f64;
/// Returns `true` if this value is `NaN`.
/// Returns `true` if this value is NaN.
///
/// ```
/// let nan = f64::NAN;
@ -456,7 +465,7 @@ impl f64 {
(self == f64::INFINITY) | (self == f64::NEG_INFINITY)
}
/// Returns `true` if this number is neither infinite nor `NaN`.
/// Returns `true` if this number is neither infinite nor NaN.
///
/// ```
/// let f = 7.0f64;
@ -507,7 +516,7 @@ impl f64 {
}
/// Returns `true` if the number is neither zero, infinite,
/// [subnormal], or `NaN`.
/// [subnormal], or NaN.
///
/// ```
/// let min = f64::MIN_POSITIVE; // 2.2250738585072014e-308f64
@ -614,8 +623,12 @@ impl f64 {
}
}
/// Returns `true` if `self` has a positive sign, including `+0.0`, `NaN`s with
/// positive sign bit and positive infinity.
/// Returns `true` if `self` has a positive sign, including `+0.0`, NaNs with
/// positive sign bit and positive infinity. Note that IEEE-745 doesn't assign any
/// meaning to the sign bit in case of a NaN, and as Rust doesn't guarantee that
/// the bit pattern of NaNs are conserved over arithmetic operations, the result of
/// `is_sign_positive` on a NaN might produce an unexpected result in some cases.
/// See [explanation of NaN as a special value](f32) for more info.
///
/// ```
/// let f = 7.0_f64;
@ -641,8 +654,12 @@ impl f64 {
self.is_sign_positive()
}
/// Returns `true` if `self` has a negative sign, including `-0.0`, `NaN`s with
/// negative sign bit and negative infinity.
/// Returns `true` if `self` has a negative sign, including `-0.0`, NaNs with
/// negative sign bit and negative infinity. Note that IEEE-745 doesn't assign any
/// meaning to the sign bit in case of a NaN, and as Rust doesn't guarantee that
/// the bit pattern of NaNs are conserved over arithmetic operations, the result of
/// `is_sign_negative` on a NaN might produce an unexpected result in some cases.
/// See [explanation of NaN as a special value](f32) for more info.
///
/// ```
/// let f = 7.0_f64;
@ -724,10 +741,12 @@ impl f64 {
self * (value / 180.0)
}
/// Returns the maximum of the two numbers.
/// Returns the maximum of the two numbers, ignoring NaN.
///
/// Follows the IEEE-754 2008 semantics for maxNum, except for handling of signaling NaNs.
/// This matches the behavior of libm’s fmax.
/// If one of the arguments is NaN, then the other argument is returned.
/// This follows the IEEE-754 2008 semantics for maxNum, except for handling of signaling NaNs;
/// this function handles all NaNs the same way and avoids maxNum's problems with associativity.
/// This also matches the behavior of libm’s fmax.
///
/// ```
/// let x = 1.0_f64;
@ -735,8 +754,6 @@ impl f64 {
///
/// assert_eq!(x.max(y), y);
/// ```
///
/// If one of the arguments is NaN, then the other argument is returned.
#[must_use = "this returns the result of the comparison, without modifying either input"]
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -744,10 +761,12 @@ impl f64 {
intrinsics::maxnumf64(self, other)
}
/// Returns the minimum of the two numbers.
/// Returns the minimum of the two numbers, ignoring NaN.
///
/// Follows the IEEE-754 2008 semantics for minNum, except for handling of signaling NaNs.
/// This matches the behavior of libm’s fmin.
/// If one of the arguments is NaN, then the other argument is returned.
/// This follows the IEEE-754 2008 semantics for minNum, except for handling of signaling NaNs;
/// this function handles all NaNs the same way and avoids minNum's problems with associativity.
/// This also matches the behavior of libm’s fmin.
///
/// ```
/// let x = 1.0_f64;
@ -755,8 +774,6 @@ impl f64 {
///
/// assert_eq!(x.min(y), x);
/// ```
///
/// If one of the arguments is NaN, then the other argument is returned.
#[must_use = "this returns the result of the comparison, without modifying either input"]
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -764,7 +781,7 @@ impl f64 {
intrinsics::minnumf64(self, other)
}
/// Returns the maximum of the two numbers, propagating NaNs.
/// Returns the maximum of the two numbers, propagating NaN.
///
/// This returns NaN when *either* argument is NaN, as opposed to
/// [`f64::max`] which only returns NaN when *both* arguments are NaN.
@ -781,6 +798,9 @@ impl f64 {
/// If one of the arguments is NaN, then NaN is returned. Otherwise this returns the greater
/// of the two numbers. For this operation, -0.0 is considered to be less than +0.0.
/// Note that this follows the semantics specified in IEEE 754-2019.
///
/// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
/// operand is conserved; see [explanation of NaN as a special value](f32) for more info.
#[must_use = "this returns the result of the comparison, without modifying either input"]
#[unstable(feature = "float_minimum_maximum", issue = "91079")]
#[inline]
@ -796,7 +816,7 @@ impl f64 {
}
}
/// Returns the minimum of the two numbers, propagating NaNs.
/// Returns the minimum of the two numbers, propagating NaN.
///
/// This returns NaN when *either* argument is NaN, as opposed to
/// [`f64::min`] which only returns NaN when *both* arguments are NaN.
@ -813,6 +833,9 @@ impl f64 {
/// If one of the arguments is NaN, then NaN is returned. Otherwise this returns the lesser
/// of the two numbers. For this operation, -0.0 is considered to be less than +0.0.
/// Note that this follows the semantics specified in IEEE 754-2019.
///
/// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
/// operand is conserved; see [explanation of NaN as a special value](f32) for more info.
#[must_use = "this returns the result of the comparison, without modifying either input"]
#[unstable(feature = "float_minimum_maximum", issue = "91079")]
#[inline]
@ -1007,6 +1030,9 @@ impl f64 {
/// Return the memory representation of this floating point number as a byte array in
/// big-endian (network) byte order.
///
/// See [`from_bits`](Self::from_bits) for some discussion of the
/// portability of this operation (there are almost no issues).
///
/// # Examples
///
/// ```
@ -1025,6 +1051,9 @@ impl f64 {
/// Return the memory representation of this floating point number as a byte array in
/// little-endian byte order.
///
/// See [`from_bits`](Self::from_bits) for some discussion of the
/// portability of this operation (there are almost no issues).
///
/// # Examples
///
/// ```
@ -1049,6 +1078,9 @@ impl f64 {
/// [`to_be_bytes`]: f64::to_be_bytes
/// [`to_le_bytes`]: f64::to_le_bytes
///
/// See [`from_bits`](Self::from_bits) for some discussion of the
/// portability of this operation (there are almost no issues).
///
/// # Examples
///
/// ```
@ -1073,6 +1105,9 @@ impl f64 {
/// Create a floating point value from its representation as a byte array in big endian.
///
/// See [`from_bits`](Self::from_bits) for some discussion of the
/// portability of this operation (there are almost no issues).
///
/// # Examples
///
/// ```
@ -1089,6 +1124,9 @@ impl f64 {
/// Create a floating point value from its representation as a byte array in little endian.
///
/// See [`from_bits`](Self::from_bits) for some discussion of the
/// portability of this operation (there are almost no issues).
///
/// # Examples
///
/// ```
@ -1112,6 +1150,9 @@ impl f64 {
/// [`from_be_bytes`]: f64::from_be_bytes
/// [`from_le_bytes`]: f64::from_le_bytes
///
/// See [`from_bits`](Self::from_bits) for some discussion of the
/// portability of this operation (there are almost no issues).
///
/// # Examples
///
/// ```

20
library/core/src/primitive_docs.rs
View file

@ -977,10 +977,22 @@ mod prim_tuple {}
/// like `1.0 / 0.0`.
/// - [NaN (not a number)](#associatedconstant.NAN): this value results from
/// calculations like `(-1.0).sqrt()`. NaN has some potentially unexpected
/// behavior: it is unequal to any float, including itself! It is also neither
/// smaller nor greater than any float, making it impossible to sort. Lastly,
/// it is considered infectious as almost all calculations where one of the
/// operands is NaN will also result in NaN.
/// behavior:
/// - It is unequal to any float, including itself! This is the reason `f32`
/// doesn't implement the `Eq` trait.
/// - It is also neither smaller nor greater than any float, making it
/// impossible to sort by the default comparison operation, which is the
/// reason `f32` doesn't implement the `Ord` trait.
/// - It is also considered *infectious* as almost all calculations where one
/// of the operands is NaN will also result in NaN. The explanations on this
/// page only explicitly document behavior on NaN operands if this default
/// is deviated from.
/// - Lastly, there are multiple bit patterns that are considered NaN.
/// Rust does not currently guarantee that the bit patterns of NaN are
/// preserved over arithmetic operations, and they are not guaranteed to be
/// portable or even fully deterministic! This means that there may be some
/// surprising results upon inspecting the bit patterns,
/// as the same calculations might produce NaNs with different bit patterns.
///
/// For more information on floating point numbers, see [Wikipedia][wikipedia].
///

11
library/core/src/slice/iter.rs
View file

@ -1322,7 +1322,6 @@ impl<'a, T> Iterator for Windows<'a, T> {
}
}
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
// SAFETY: since the caller guarantees that `i` is in bounds,
// which means that `i` cannot overflow an `isize`, and the
@ -1478,7 +1477,6 @@ impl<'a, T> Iterator for Chunks<'a, T> {
}
}
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
let start = idx * self.chunk_size;
// SAFETY: the caller guarantees that `i` is in bounds,
@ -1657,7 +1655,6 @@ impl<'a, T> Iterator for ChunksMut<'a, T> {
}
}
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
let start = idx * self.chunk_size;
// SAFETY: see comments for `Chunks::__iterator_get_unchecked`.
@ -1830,7 +1827,6 @@ impl<'a, T> Iterator for ChunksExact<'a, T> {
self.next_back()
}
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
let start = idx * self.chunk_size;
// SAFETY: mostly identical to `Chunks::__iterator_get_unchecked`.
@ -1984,7 +1980,6 @@ impl<'a, T> Iterator for ChunksExactMut<'a, T> {
self.next_back()
}
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
let start = idx * self.chunk_size;
// SAFETY: see comments for `ChunksMut::__iterator_get_unchecked`.
@ -2248,7 +2243,6 @@ impl<'a, T, const N: usize> Iterator for ArrayChunks<'a, T, N> {
self.iter.last()
}
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> &'a [T; N] {
// SAFETY: The safety guarantees of `__iterator_get_unchecked` are
// transferred to the caller.
@ -2367,7 +2361,6 @@ impl<'a, T, const N: usize> Iterator for ArrayChunksMut<'a, T, N> {
self.iter.last()
}
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> &'a mut [T; N] {
// SAFETY: The safety guarantees of `__iterator_get_unchecked` are transferred to
// the caller.
@ -2520,7 +2513,6 @@ impl<'a, T> Iterator for RChunks<'a, T> {
}
}
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
let end = self.v.len() - idx * self.chunk_size;
let start = match end.checked_sub(self.chunk_size) {
@ -2689,7 +2681,6 @@ impl<'a, T> Iterator for RChunksMut<'a, T> {
}
}
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
let end = self.v.len() - idx * self.chunk_size;
let start = match end.checked_sub(self.chunk_size) {
@ -2856,7 +2847,6 @@ impl<'a, T> Iterator for RChunksExact<'a, T> {
self.next_back()
}
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
let end = self.v.len() - idx * self.chunk_size;
let start = end - self.chunk_size;
@ -3016,7 +3006,6 @@ impl<'a, T> Iterator for RChunksExactMut<'a, T> {
self.next_back()
}
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
let end = self.v.len() - idx * self.chunk_size;
let start = end - self.chunk_size;

1
library/core/src/slice/iter/macros.rs
View file

@ -325,7 +325,6 @@ macro_rules! iterator {
None
}
#[doc(hidden)]
#[inline]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item {
// SAFETY: the caller must guarantee that `i` is in bounds of

1
library/core/src/str/iter.rs
View file

@ -298,7 +298,6 @@ impl Iterator for Bytes<'_> {
}
#[inline]
#[doc(hidden)]
unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> u8 {
// SAFETY: the caller must uphold the safety contract
// for `Iterator::__iterator_get_unchecked`.

26
library/std/src/f32.rs
View file

@ -29,7 +29,7 @@ pub use core::f32::{
#[cfg(not(test))]
impl f32 {
/// Returns the largest integer less than or equal to a number.
/// Returns the largest integer less than or equal to `self`.
///
/// # Examples
///
@ -50,7 +50,7 @@ impl f32 {
unsafe { intrinsics::floorf32(self) }
}
/// Returns the smallest integer greater than or equal to a number.
/// Returns the smallest integer greater than or equal to `self`.
///
/// # Examples
///
@ -69,7 +69,7 @@ impl f32 {
unsafe { intrinsics::ceilf32(self) }
}
/// Returns the nearest integer to a number. Round half-way cases away from
/// Returns the nearest integer to `self`. Round half-way cases away from
/// `0.0`.
///
/// # Examples
@ -89,7 +89,8 @@ impl f32 {
unsafe { intrinsics::roundf32(self) }
}
/// Returns the integer part of a number.
/// Returns the integer part of `self`.
/// This means that non-integer numbers are always truncated towards zero.
///
/// # Examples
///
@ -110,7 +111,7 @@ impl f32 {
unsafe { intrinsics::truncf32(self) }
}
/// Returns the fractional part of a number.
/// Returns the fractional part of `self`.
///
/// # Examples
///
@ -131,8 +132,7 @@ impl f32 {
self - self.trunc()
}
/// Computes the absolute value of `self`. Returns `NAN` if the
/// number is `NAN`.
/// Computes the absolute value of `self`.
///
/// # Examples
///
@ -160,7 +160,7 @@ impl f32 {
///
/// - `1.0` if the number is positive, `+0.0` or `INFINITY`
/// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
/// - `NAN` if the number is `NAN`
/// - NaN if the number is NaN
///
/// # Examples
///
@ -184,8 +184,10 @@ impl f32 {
/// `sign`.
///
/// Equal to `self` if the sign of `self` and `sign` are the same, otherwise
/// equal to `-self`. If `self` is a `NAN`, then a `NAN` with the sign of
/// `sign` is returned.
/// equal to `-self`. If `self` is a NaN, then a NaN with the sign bit of
/// `sign` is returned. Note, however, that conserving the sign bit on NaN
/// across arithmetical operations is not generally guaranteed.
/// See [explanation of NaN as a special value](primitive@f32) for more info.
///
/// # Examples
///
@ -298,7 +300,9 @@ impl f32 {
/// Raises a number to an integer power.
///
/// Using this function is generally faster than using `powf`
/// Using this function is generally faster than using `powf`.
/// It might have a different sequence of rounding operations than `powf`,
/// so the results are not guaranteed to agree.
///
/// # Examples
///

26
library/std/src/f64.rs
View file

@ -29,7 +29,7 @@ pub use core::f64::{
#[cfg(not(test))]
impl f64 {
/// Returns the largest integer less than or equal to a number.
/// Returns the largest integer less than or equal to `self`.
///
/// # Examples
///
@ -50,7 +50,7 @@ impl f64 {
unsafe { intrinsics::floorf64(self) }
}
/// Returns the smallest integer greater than or equal to a number.
/// Returns the smallest integer greater than or equal to `self`.
///
/// # Examples
///
@ -69,7 +69,7 @@ impl f64 {
unsafe { intrinsics::ceilf64(self) }
}
/// Returns the nearest integer to a number. Round half-way cases away from
/// Returns the nearest integer to `self`. Round half-way cases away from
/// `0.0`.
///
/// # Examples
@ -89,7 +89,8 @@ impl f64 {
unsafe { intrinsics::roundf64(self) }
}
/// Returns the integer part of a number.
/// Returns the integer part of `self`.
/// This means that non-integer numbers are always truncated towards zero.
///
/// # Examples
///
@ -110,7 +111,7 @@ impl f64 {
unsafe { intrinsics::truncf64(self) }
}
/// Returns the fractional part of a number.
/// Returns the fractional part of `self`.
///
/// # Examples
///
@ -131,8 +132,7 @@ impl f64 {
self - self.trunc()
}
/// Computes the absolute value of `self`. Returns `NAN` if the
/// number is `NAN`.
/// Computes the absolute value of `self`.
///
/// # Examples
///
@ -160,7 +160,7 @@ impl f64 {
///
/// - `1.0` if the number is positive, `+0.0` or `INFINITY`
/// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
/// - `NAN` if the number is `NAN`
/// - NaN if the number is NaN
///
/// # Examples
///
@ -184,8 +184,10 @@ impl f64 {
/// `sign`.
///
/// Equal to `self` if the sign of `self` and `sign` are the same, otherwise
/// equal to `-self`. If `self` is a `NAN`, then a `NAN` with the sign of
/// `sign` is returned.
/// equal to `-self`. If `self` is a NaN, then a NaN with the sign bit of
/// `sign` is returned. Note, however, that conserving the sign bit on NaN
/// across arithmetical operations is not generally guaranteed.
/// See [explanation of NaN as a special value](primitive@f32) for more info.
///
/// # Examples
///
@ -298,7 +300,9 @@ impl f64 {
/// Raises a number to an integer power.
///
/// Using this function is generally faster than using `powf`
/// Using this function is generally faster than using `powf`.
/// It might have a different sequence of rounding operations than `powf`,
/// so the results are not guaranteed to agree.
///
/// # Examples
///

17
library/std/src/ffi/os_str.rs
View file

@ -1222,23 +1222,6 @@ impl OsStr {
}
}
#[unstable(feature = "slice_concat_ext", issue = "27747")]
impl<S: Borrow<OsStr>> alloc::slice::Join<&OsStr> for [S] {
type Output = OsString;
fn join(slice: &Self, sep: &OsStr) -> OsString {
let Some(first) = slice.first() else {
return OsString::new();
};
let first = first.borrow().to_owned();
slice[1..].iter().fold(first, |mut a, b| {
a.push(sep);
a.push(b.borrow());
a
})
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl Borrow<OsStr> for OsString {
#[inline]

14
library/std/src/ffi/os_str/tests.rs
View file

@ -84,20 +84,6 @@ fn test_os_string_reserve_exact() {
assert!(os_string.capacity() >= 33)
}
#[test]
fn test_os_string_join() {
let strings = [OsStr::new("hello"), OsStr::new("dear"), OsStr::new("world")];
assert_eq!("hello", strings[..1].join(OsStr::new(" ")));
assert_eq!("hello dear world", strings.join(OsStr::new(" ")));
assert_eq!("hellodearworld", strings.join(OsStr::new("")));
assert_eq!("hello.\n dear.\n world", strings.join(OsStr::new(".\n ")));
assert_eq!("dear world", strings[1..].join(&OsString::from(" ")));
let strings_abc = [OsString::from("a"), OsString::from("b"), OsString::from("c")];
assert_eq!("a b c", strings_abc.join(OsStr::new(" ")));
}
#[test]
fn test_os_string_default() {
let os_string: OsString = Default::default();

2
library/std/src/lib.rs
View file

@ -241,7 +241,6 @@
#![feature(intra_doc_pointers)]
#![feature(lang_items)]
#![feature(let_chains)]
#![feature(let_else)]
#![feature(linkage)]
#![feature(min_specialization)]
#![feature(must_not_suspend)]
@ -302,7 +301,6 @@
#![feature(toowned_clone_into)]
#![feature(try_reserve_kind)]
#![feature(vec_into_raw_parts)]
#![feature(slice_concat_trait)]
//
// Library features (unwind):
#![feature(panic_unwind)]

20
library/std/src/primitive_docs.rs
View file

@ -977,10 +977,22 @@ mod prim_tuple {}
/// like `1.0 / 0.0`.
/// - [NaN (not a number)](#associatedconstant.NAN): this value results from
/// calculations like `(-1.0).sqrt()`. NaN has some potentially unexpected
/// behavior: it is unequal to any float, including itself! It is also neither
/// smaller nor greater than any float, making it impossible to sort. Lastly,
/// it is considered infectious as almost all calculations where one of the
/// operands is NaN will also result in NaN.
/// behavior:
/// - It is unequal to any float, including itself! This is the reason `f32`
/// doesn't implement the `Eq` trait.
/// - It is also neither smaller nor greater than any float, making it
/// impossible to sort by the default comparison operation, which is the
/// reason `f32` doesn't implement the `Ord` trait.
/// - It is also considered *infectious* as almost all calculations where one
/// of the operands is NaN will also result in NaN. The explanations on this
/// page only explicitly document behavior on NaN operands if this default
/// is deviated from.
/// - Lastly, there are multiple bit patterns that are considered NaN.
/// Rust does not currently guarantee that the bit patterns of NaN are
/// preserved over arithmetic operations, and they are not guaranteed to be
/// portable or even fully deterministic! This means that there may be some
/// surprising results upon inspecting the bit patterns,
/// as the same calculations might produce NaNs with different bit patterns.
///
/// For more information on floating point numbers, see [Wikipedia][wikipedia].
///

4
src/librustdoc/html/static/js/search.js
View file

@ -1089,7 +1089,7 @@ window.initSearch = rawSearchIndex => {
return parsedQuery.literalSearch ? MAX_LEV_DISTANCE + 1 : lev;
}
function checkPath(contains, lastElem, ty) {
function checkPath(contains, ty) {
if (contains.length === 0) {
return 0;
}
@ -1306,7 +1306,7 @@ window.initSearch = rawSearchIndex => {
}
if (elem.fullPath.length > 1) {
lev = checkPath(elem.pathWithoutLast, elem.pathLast, row);
lev = checkPath(elem.pathWithoutLast, row);
if (lev > MAX_LEV_DISTANCE || (parsedQuery.literalSearch && lev !== 0)) {
return;
} else if (lev > 0) {

42
src/test/ui/lint/unused/unused-attr-doc-hidden.fixed Normal file
View file

@ -0,0 +1,42 @@
#![deny(unused_attributes)]
#![crate_type = "lib"]
// run-rustfix
pub trait Trait {
type It;
const IT: ();
fn it0();
fn it1();
fn it2();
}
pub struct Implementor;
impl Trait for Implementor {
type It = ();
//~^^ ERROR `#[doc(hidden)]` is ignored
//~| WARNING this was previously accepted
const IT: () = ();
//~^^ ERROR `#[doc(hidden)]` is ignored
//~| WARNING this was previously accepted
#[doc(alias = "aka")]
fn it0() {}
//~^^ ERROR `#[doc(hidden)]` is ignored
//~| WARNING this was previously accepted
#[doc(alias = "this", )]
fn it1() {}
//~^^ ERROR `#[doc(hidden)]` is ignored
//~| WARNING this was previously accepted
#[doc()]
fn it2() {}
//~^^ ERROR `#[doc(hidden)]` is ignored
//~| WARNING this was previously accepted
//~| ERROR `#[doc(hidden)]` is ignored
//~| WARNING this was previously accepted
}

42
src/test/ui/lint/unused/unused-attr-doc-hidden.rs Normal file
View file

@ -0,0 +1,42 @@
#![deny(unused_attributes)]
#![crate_type = "lib"]
// run-rustfix
pub trait Trait {
type It;
const IT: ();
fn it0();
fn it1();
fn it2();
}
pub struct Implementor;
impl Trait for Implementor {
#[doc(hidden)]
type It = ();
//~^^ ERROR `#[doc(hidden)]` is ignored
//~| WARNING this was previously accepted
#[doc(hidden)]
const IT: () = ();
//~^^ ERROR `#[doc(hidden)]` is ignored
//~| WARNING this was previously accepted
#[doc(hidden, alias = "aka")]
fn it0() {}
//~^^ ERROR `#[doc(hidden)]` is ignored
//~| WARNING this was previously accepted
#[doc(alias = "this", hidden,)]
fn it1() {}
//~^^ ERROR `#[doc(hidden)]` is ignored
//~| WARNING this was previously accepted
#[doc(hidden, hidden)]
fn it2() {}
//~^^ ERROR `#[doc(hidden)]` is ignored
//~| WARNING this was previously accepted
//~| ERROR `#[doc(hidden)]` is ignored
//~| WARNING this was previously accepted
}

67
src/test/ui/lint/unused/unused-attr-doc-hidden.stderr Normal file
View file

@ -0,0 +1,67 @@
error: `#[doc(hidden)]` is ignored on trait impl items
--> $DIR/unused-attr-doc-hidden.rs:16:5
|
LL | #[doc(hidden)]
| ^^^^^^^^^^^^^^ help: remove this attribute
|
note: the lint level is defined here
--> $DIR/unused-attr-doc-hidden.rs:1:9
|
LL | #![deny(unused_attributes)]
| ^^^^^^^^^^^^^^^^^
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item
error: `#[doc(hidden)]` is ignored on trait impl items
--> $DIR/unused-attr-doc-hidden.rs:21:5
|
LL | #[doc(hidden)]
| ^^^^^^^^^^^^^^ help: remove this attribute
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item
error: `#[doc(hidden)]` is ignored on trait impl items
--> $DIR/unused-attr-doc-hidden.rs:26:11
|
LL | #[doc(hidden, alias = "aka")]
| ^^^^^^--
| |
| help: remove this attribute
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item
error: `#[doc(hidden)]` is ignored on trait impl items
--> $DIR/unused-attr-doc-hidden.rs:31:27
|
LL | #[doc(alias = "this", hidden,)]
| ^^^^^^-
| |
| help: remove this attribute
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item
error: `#[doc(hidden)]` is ignored on trait impl items
--> $DIR/unused-attr-doc-hidden.rs:36:11
|
LL | #[doc(hidden, hidden)]
| ^^^^^^--
| |
| help: remove this attribute
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item
error: `#[doc(hidden)]` is ignored on trait impl items
--> $DIR/unused-attr-doc-hidden.rs:36:19
|
LL | #[doc(hidden, hidden)]
| ^^^^^^ help: remove this attribute
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: whether the impl item is `doc(hidden)` or not entirely depends on the corresponding trait item
error: aborting due to 6 previous errors

1
src/test/ui/typeck/issue-96738.rs
View file

@ -1,3 +1,4 @@
fn main() {
Some.nonexistent_method(); //~ ERROR: no method named `nonexistent_method` found
Some.nonexistent_field; //~ ERROR: no field `nonexistent_field`
}

18
src/test/ui/typeck/issue-96738.stderr
View file

@ -11,6 +11,20 @@ help: call the constructor
LL | (Some)(_).nonexistent_method();
| + ++++
error: aborting due to previous error
error[E0609]: no field `nonexistent_field` on type `fn(_) -> Option<_> {Option::<_>::Some}`
--> $DIR/issue-96738.rs:3:10
|
LL | Some.nonexistent_field;
| ---- ^^^^^^^^^^^^^^^^^
| |
| this is the constructor of an enum variant
|
help: call the constructor
|
LL | (Some)(_).nonexistent_field;
| + ++++
For more information about this error, try `rustc --explain E0599`.
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0599, E0609.
For more information about an error, try `rustc --explain E0599`.