Skip to content

Commit 295b932

Browse files
RalfJungRalfJung
committed
library: consistently use American spelling for 'behavior'
1 parent 2da7b7f commit 295b932

File tree

46 files changed

+75
-75
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

46 files changed

+75
-75
lines changed

‎alloc/src/collections/binary_heap/tests.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -350,7 +350,7 @@ fn test_drain_forget() {
350350
mem::forget(it);
351351
}))
352352
.unwrap();
353-
// Behaviour after leaking is explicitly unspecified and order is arbitrary,
353+
// Behavior after leaking is explicitly unspecified and order is arbitrary,
354354
// so it's fine if these start failing, but probably worth knowing.
355355
assert!(q.is_empty());
356356
assert_eq!(a.dropped() + b.dropped() + c.dropped(), 1);
@@ -377,7 +377,7 @@ fn test_drain_sorted_forget() {
377377
mem::forget(it);
378378
}))
379379
.unwrap();
380-
// Behaviour after leaking is explicitly unspecified,
380+
// Behavior after leaking is explicitly unspecified,
381381
// so it's fine if these start failing, but probably worth knowing.
382382
assert_eq!(q.len(), 2);
383383
assert_eq!(a.dropped(), 0);

‎alloc/src/collections/btree/map/tests.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1216,7 +1216,7 @@ mod test_extract_if {
12161216
{
12171217
let mut it = map.extract_if(|dummy, _| dummy.query(true));
12181218
catch_unwind(AssertUnwindSafe(|| while it.next().is_some() {})).unwrap_err();
1219-
// Iterator behaviour after a panic is explicitly unspecified,
1219+
// Iterator behavior after a panic is explicitly unspecified,
12201220
// so this is just the current implementation:
12211221
let result = catch_unwind(AssertUnwindSafe(|| it.next()));
12221222
assert!(matches!(result, Ok(None)));

‎alloc/src/rc.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -3075,7 +3075,7 @@ impl<T: ?Sized, A: Allocator> Weak<T, A> {
30753075
///
30763076
/// drop(strong);
30773077
/// // But not any more. We can do weak.as_ptr(), but accessing the pointer would lead to
3078-
/// // undefined behaviour.
3078+
/// // undefined behavior.
30793079
/// // assert_eq!("hello", unsafe { &*weak.as_ptr() });
30803080
/// ```
30813081
///

‎alloc/src/sync.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -804,7 +804,7 @@ impl<T, A: Allocator> Arc<T, A> {
804804
// observe a non-zero strong count. Therefore we need at least "Release" ordering
805805
// in order to synchronize with the `compare_exchange_weak` in `Weak::upgrade`.
806806
//
807-
// "Acquire" ordering is not required. When considering the possible behaviours
807+
// "Acquire" ordering is not required. When considering the possible behaviors
808808
// of `data_fn` we only need to look at what it could do with a reference to a
809809
// non-upgradeable `Weak`:
810810
// - It can *clone* the `Weak`, increasing the weak reference count.
@@ -2788,7 +2788,7 @@ impl<T: ?Sized, A: Allocator> Weak<T, A> {
27882788
///
27892789
/// drop(strong);
27902790
/// // But not any more. We can do weak.as_ptr(), but accessing the pointer would lead to
2791-
/// // undefined behaviour.
2791+
/// // undefined behavior.
27922792
/// // assert_eq!("hello", unsafe { &*weak.as_ptr() });
27932793
/// ```
27942794
///

‎alloc/src/vec/is_zero.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -172,7 +172,7 @@ macro_rules! impl_is_zero_option_of_bool {
172172
fn is_zero(&self) -> bool {
173173
// SAFETY: This is *not* a stable layout guarantee, but
174174
// inside `core` we're allowed to rely on the current rustc
175-
// behaviour that options of bools will be one byte with
175+
// behavior that options of bools will be one byte with
176176
// no padding, so long as they're nested less than 254 deep.
177177
let raw: u8 = unsafe { core::mem::transmute(*self) };
178178
raw == 0

‎core/src/alloc/global.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -173,7 +173,7 @@ pub unsafe trait GlobalAlloc {
173173
/// # Safety
174174
///
175175
/// The caller has to ensure that `layout` has non-zero size. Like `alloc`
176-
/// zero sized `layout` can result in undefined behaviour.
176+
/// zero sized `layout` can result in undefined behavior.
177177
/// However the allocated block of memory is guaranteed to be initialized.
178178
///
179179
/// # Errors
@@ -234,7 +234,7 @@ pub unsafe trait GlobalAlloc {
234234
/// does not overflow `isize` (i.e., the rounded value must be less than or
235235
/// equal to `isize::MAX`).
236236
///
237-
/// If these are not followed, undefined behaviour can result.
237+
/// If these are not followed, undefined behavior can result.
238238
///
239239
/// (Extension subtraits might provide more specific bounds on
240240
/// behavior, e.g., guarantee a sentinel address or a null pointer

‎core/src/cell.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1221,7 +1221,7 @@ impl<T: ?Sized> RefCell<T> {
12211221
/// Unlike `RefCell::borrow`, this method is unsafe because it does not
12221222
/// return a `Ref`, thus leaving the borrow flag untouched. Mutably
12231223
/// borrowing the `RefCell` while the reference returned by this method
1224-
/// is alive is undefined behaviour.
1224+
/// is alive is undefined behavior.
12251225
///
12261226
/// # Examples
12271227
///

‎core/src/cmp.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -380,7 +380,7 @@ pub struct AssertParamIsEq<T: Eq + ?Sized> {
380380
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
381381
#[stable(feature = "rust1", since = "1.0.0")]
382382
// This is a lang item only so that `BinOp::Cmp` in MIR can return it.
383-
// It has no special behaviour, but does require that the three variants
383+
// It has no special behavior, but does require that the three variants
384384
// `Less`/`Equal`/`Greater` remain `-1_i8`/`0_i8`/`+1_i8` respectively.
385385
#[lang = "Ordering"]
386386
#[repr(i8)]

‎core/src/intrinsics.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -930,7 +930,7 @@ extern "rust-intrinsic" {
930930
/// on most platforms.
931931
/// On Unix, the
932932
/// process will probably terminate with a signal like `SIGABRT`, `SIGILL`, `SIGTRAP`, `SIGSEGV` or
933-
/// `SIGBUS`. The precise behaviour is not guaranteed and not stable.
933+
/// `SIGBUS`. The precise behavior is not guaranteed and not stable.
934934
#[rustc_safe_intrinsic]
935935
#[rustc_nounwind]
936936
pub fn abort() -> !;
@@ -1384,7 +1384,7 @@ extern "rust-intrinsic" {
13841384

13851385
/// Like [`transmute`], but even less checked at compile-time: rather than
13861386
/// giving an error for `size_of::<Src>() != size_of::<Dst>()`, it's
1387-
/// **Undefined Behaviour** at runtime.
1387+
/// **Undefined Behavior** at runtime.
13881388
///
13891389
/// Prefer normal `transmute` where possible, for the extra checking, since
13901390
/// both do exactly the same thing at runtime, if they both compile.

‎core/src/intrinsics/mir.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -298,7 +298,7 @@ define!(
298298
);
299299
define!(
300300
"mir_unwind_unreachable",
301-
/// An unwind action that triggers undefined behaviour.
301+
/// An unwind action that triggers undefined behavior.
302302
fn UnwindUnreachable() -> UnwindActionArg
303303
);
304304
define!(

‎core/src/mem/maybe_uninit.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -723,7 +723,7 @@ impl<T> MaybeUninit<T> {
723723
/// this does not constitute a stable guarantee), because the only
724724
/// requirement the compiler knows about it is that the data pointer must be
725725
/// non-null. Dropping such a `Vec<T>` however will cause undefined
726-
/// behaviour.
726+
/// behavior.
727727
///
728728
/// [`assume_init`]: MaybeUninit::assume_init
729729
/// [`Vec<T>`]: ../../std/vec/struct.Vec.html

‎core/src/num/nonzero.rs

+8-8
Original file line numberDiff line numberDiff line change
@@ -355,7 +355,7 @@ where
355355
}
356356

357357
/// Creates a non-zero without checking whether the value is non-zero.
358-
/// This results in undefined behaviour if the value is zero.
358+
/// This results in undefined behavior if the value is zero.
359359
///
360360
/// # Safety
361361
///
@@ -952,9 +952,9 @@ macro_rules! nonzero_integer {
952952

953953
/// Multiplies two non-zero integers together,
954954
/// assuming overflow cannot occur.
955-
/// Overflow is unchecked, and it is undefined behaviour to overflow
955+
/// Overflow is unchecked, and it is undefined behavior to overflow
956956
/// *even if the result would wrap to a non-zero value*.
957-
/// The behaviour is undefined as soon as
957+
/// The behavior is undefined as soon as
958958
#[doc = sign_dependent_expr!{
959959
$signedness ?
960960
if signed {
@@ -1323,9 +1323,9 @@ macro_rules! nonzero_integer_signedness_dependent_methods {
13231323

13241324
/// Adds an unsigned integer to a non-zero value,
13251325
/// assuming overflow cannot occur.
1326-
/// Overflow is unchecked, and it is undefined behaviour to overflow
1326+
/// Overflow is unchecked, and it is undefined behavior to overflow
13271327
/// *even if the result would wrap to a non-zero value*.
1328-
/// The behaviour is undefined as soon as
1328+
/// The behavior is undefined as soon as
13291329
#[doc = concat!("`self + rhs > ", stringify!($Int), "::MAX`.")]
13301330
///
13311331
/// # Examples
@@ -1599,7 +1599,7 @@ macro_rules! nonzero_integer_signedness_dependent_methods {
15991599

16001600
/// Computes the absolute value of self.
16011601
#[doc = concat!("See [`", stringify!($Int), "::abs`]")]
1602-
/// for documentation on overflow behaviour.
1602+
/// for documentation on overflow behavior.
16031603
///
16041604
/// # Example
16051605
///
@@ -1878,7 +1878,7 @@ macro_rules! nonzero_integer_signedness_dependent_methods {
18781878
/// Negates self, overflowing if this is equal to the minimum value.
18791879
///
18801880
#[doc = concat!("See [`", stringify!($Int), "::overflowing_neg`]")]
1881-
/// for documentation on overflow behaviour.
1881+
/// for documentation on overflow behavior.
18821882
///
18831883
/// # Example
18841884
///
@@ -1943,7 +1943,7 @@ macro_rules! nonzero_integer_signedness_dependent_methods {
19431943
/// of the type.
19441944
///
19451945
#[doc = concat!("See [`", stringify!($Int), "::wrapping_neg`]")]
1946-
/// for documentation on overflow behaviour.
1946+
/// for documentation on overflow behavior.
19471947
///
19481948
/// # Example
19491949
///

‎core/src/num/uint_macros.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -3086,7 +3086,7 @@ macro_rules! uint_impl {
30863086
/// ```
30873087
#[inline]
30883088
#[unstable(feature = "wrapping_next_power_of_two", issue = "32463",
3089-
reason = "needs decision on wrapping behaviour")]
3089+
reason = "needs decision on wrapping behavior")]
30903090
#[rustc_const_unstable(feature = "wrapping_next_power_of_two", issue = "32463")]
30913091
#[must_use = "this returns the result of the operation, \
30923092
without modifying the original"]

‎core/src/num/wrapping.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1043,7 +1043,7 @@ macro_rules! wrapping_int_impl_unsigned {
10431043
#[must_use = "this returns the result of the operation, \
10441044
without modifying the original"]
10451045
#[unstable(feature = "wrapping_next_power_of_two", issue = "32463",
1046-
reason = "needs decision on wrapping behaviour")]
1046+
reason = "needs decision on wrapping behavior")]
10471047
pub fn next_power_of_two(self) -> Self {
10481048
Wrapping(self.0.wrapping_next_power_of_two())
10491049
}

‎core/src/ops/deref.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@
1515
///
1616
/// Types that implement `Deref` or `DerefMut` are often called "smart
1717
/// pointers" and the mechanism of deref coercion has been specifically designed
18-
/// to facilitate the pointer-like behaviour that name suggests. Often, the
18+
/// to facilitate the pointer-like behavior that name suggests. Often, the
1919
/// purpose of a "smart pointer" type is to change the ownership semantics
2020
/// of a contained value (for example, [`Rc`][rc] or [`Cow`][cow]) or the
2121
/// storage semantics of a contained value (for example, [`Box`][box]).
@@ -42,7 +42,7 @@
4242
/// 1. a value of the type transparently behaves like a value of the target
4343
/// type;
4444
/// 1. the implementation of the deref function is cheap; and
45-
/// 1. users of the type will not be surprised by any deref coercion behaviour.
45+
/// 1. users of the type will not be surprised by any deref coercion behavior.
4646
///
4747
/// In general, deref traits **should not** be implemented if:
4848
///
@@ -185,7 +185,7 @@ impl<T: ?Sized> Deref for &mut T {
185185
///
186186
/// Types that implement `DerefMut` or `Deref` are often called "smart
187187
/// pointers" and the mechanism of deref coercion has been specifically designed
188-
/// to facilitate the pointer-like behaviour that name suggests. Often, the
188+
/// to facilitate the pointer-like behavior that name suggests. Often, the
189189
/// purpose of a "smart pointer" type is to change the ownership semantics
190190
/// of a contained value (for example, [`Rc`][rc] or [`Cow`][cow]) or the
191191
/// storage semantics of a contained value (for example, [`Box`][box]).

‎core/src/option.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -150,7 +150,7 @@
150150
//! It is further guaranteed that, for the cases above, one can
151151
//! [`mem::transmute`] from all valid values of `T` to `Option<T>` and
152152
//! from `Some::<T>(_)` to `T` (but transmuting `None::<T>` to `T`
153-
//! is undefined behaviour).
153+
//! is undefined behavior).
154154
//!
155155
//! # Method overview
156156
//!

‎core/src/primitive_docs.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -100,7 +100,7 @@ mod prim_bool {}
100100
///
101101
/// Both match arms must produce values of type [`u32`], but since `break` never produces a value
102102
/// at all we know it can never produce a value which isn't a [`u32`]. This illustrates another
103-
/// behaviour of the `!` type - expressions with type `!` will coerce into any other type.
103+
/// behavior of the `!` type - expressions with type `!` will coerce into any other type.
104104
///
105105
/// [`u32`]: prim@u32
106106
/// [`exit`]: ../std/process/fn.exit.html
@@ -134,7 +134,7 @@ mod prim_bool {}
134134
///
135135
/// Since the [`Err`] variant contains a `!`, it can never occur. If the `exhaustive_patterns`
136136
/// feature is present this means we can exhaustively match on [`Result<T, !>`] by just taking the
137-
/// [`Ok`] variant. This illustrates another behaviour of `!` - it can be used to "delete" certain
137+
/// [`Ok`] variant. This illustrates another behavior of `!` - it can be used to "delete" certain
138138
/// enum variants from generic types like `Result`.
139139
///
140140
/// ## Infinite loops
@@ -351,7 +351,7 @@ mod prim_never {}
351351
/// ```
352352
///
353353
/// ```no_run
354-
/// // Undefined behaviour
354+
/// // Undefined behavior
355355
/// let _ = unsafe { char::from_u32_unchecked(0x110000) };
356356
/// ```
357357
///
@@ -568,7 +568,7 @@ impl () {}
568568
/// Instead of coercing a reference to a raw pointer, you can use the macros
569569
/// [`ptr::addr_of!`] (for `*const T`) and [`ptr::addr_of_mut!`] (for `*mut T`).
570570
/// These macros allow you to create raw pointers to fields to which you cannot
571-
/// create a reference (without causing undefined behaviour), such as an
571+
/// create a reference (without causing undefined behavior), such as an
572572
/// unaligned field. This might be necessary if packed structs or uninitialized
573573
/// memory is involved.
574574
///
@@ -1453,7 +1453,7 @@ mod prim_usize {}
14531453
/// <code>&[bool]</code> can only point to an allocation containing the integer values `1`
14541454
/// ([`true`](../std/keyword.true.html)) or `0` ([`false`](../std/keyword.false.html)), but
14551455
/// creating a <code>&[bool]</code> that points to an allocation containing
1456-
/// the value `3` causes undefined behaviour.
1456+
/// the value `3` causes undefined behavior.
14571457
/// In fact, <code>[Option]\<&T></code> has the same memory representation as a
14581458
/// nullable but aligned pointer, and can be passed across FFI boundaries as such.
14591459
///

‎core/src/ptr/mod.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -134,7 +134,7 @@
134134
//! # Provenance
135135
//!
136136
//! Pointers are not *simply* an "integer" or "address". For instance, it's uncontroversial
137-
//! to say that a Use After Free is clearly Undefined Behaviour, even if you "get lucky"
137+
//! to say that a Use After Free is clearly Undefined Behavior, even if you "get lucky"
138138
//! and the freed memory gets reallocated before your read/write (in fact this is the
139139
//! worst-case scenario, UAFs would be much less concerning if this didn't happen!).
140140
//! As another example, consider that [`wrapping_offset`] is documented to "remember"
@@ -1125,7 +1125,7 @@ pub const unsafe fn swap_nonoverlapping<T>(x: *mut T, y: *mut T, count: usize) {
11251125
unsafe { swap_nonoverlapping_simple_untyped(x, y, count) }
11261126
}
11271127

1128-
/// Same behaviour and safety conditions as [`swap_nonoverlapping`]
1128+
/// Same behavior and safety conditions as [`swap_nonoverlapping`]
11291129
///
11301130
/// LLVM can vectorize this (at least it can for the power-of-two-sized types
11311131
/// `swap_nonoverlapping` tries to use) so no need to manually SIMD it.

‎core/src/str/pattern.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -57,9 +57,9 @@ use crate::{cmp, fmt};
5757
/// [`Searcher`] type, which does the actual work of finding
5858
/// occurrences of the pattern in a string.
5959
///
60-
/// Depending on the type of the pattern, the behaviour of methods like
60+
/// Depending on the type of the pattern, the behavior of methods like
6161
/// [`str::find`] and [`str::contains`] can change. The table below describes
62-
/// some of those behaviours.
62+
/// some of those behaviors.
6363
///
6464
/// | Pattern type | Match condition |
6565
/// |--------------------------|-------------------------------------------|

‎core/tests/num/int_macros.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -113,7 +113,7 @@ macro_rules! int_module {
113113
// Rotating these should make no difference
114114
//
115115
// We test using 124 bits because to ensure that overlong bit shifts do
116-
// not cause undefined behaviour. See #10183.
116+
// not cause undefined behavior. See #10183.
117117
assert_eq_const_safe!(_0.rotate_left(124), _0);
118118
assert_eq_const_safe!(_1.rotate_left(124), _1);
119119
assert_eq_const_safe!(_0.rotate_right(124), _0);

‎core/tests/num/uint_macros.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -79,7 +79,7 @@ macro_rules! uint_module {
7979
// Rotating these should make no difference
8080
//
8181
// We test using 124 bits because to ensure that overlong bit shifts do
82-
// not cause undefined behaviour. See #10183.
82+
// not cause undefined behavior. See #10183.
8383
assert_eq_const_safe!(_0.rotate_left(124), _0);
8484
assert_eq_const_safe!(_1.rotate_left(124), _1);
8585
assert_eq_const_safe!(_0.rotate_right(124), _0);

‎proc_macro/src/bridge/symbol.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -76,7 +76,7 @@ impl Symbol {
7676
.all(|b| matches!(b, b'_' | b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9'))
7777
}
7878

79-
// Mimics the behaviour of `Symbol::can_be_raw` from `rustc_span`
79+
// Mimics the behavior of `Symbol::can_be_raw` from `rustc_span`
8080
fn can_be_raw(string: &str) -> bool {
8181
match string {
8282
"_" | "super" | "self" | "Self" | "crate" => false,

‎std/src/collections/hash/map/tests.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1098,7 +1098,7 @@ mod test_extract_if {
10981098
_ => panic!(),
10991099
});
11001100
catch_unwind(AssertUnwindSafe(|| while it.next().is_some() {})).unwrap_err();
1101-
// Iterator behaviour after a panic is explicitly unspecified,
1101+
// Iterator behavior after a panic is explicitly unspecified,
11021102
// so this is just the current implementation:
11031103
let result = catch_unwind(AssertUnwindSafe(|| it.next()));
11041104
assert!(result.is_err());

‎std/src/env.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -618,7 +618,7 @@ impl Error for JoinPathsError {
618618
///
619619
/// # Deprecation
620620
///
621-
/// This function is deprecated because the behaviour on Windows is not correct.
621+
/// This function is deprecated because the behavior on Windows is not correct.
622622
/// The 'HOME' environment variable is not standard on Windows, and may not produce
623623
/// desired results; for instance, under Cygwin or Mingw it will return `/home/you`
624624
/// when it should return `C:\Users\you`.

‎std/src/os/unix/fs.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -153,7 +153,7 @@ pub trait FileExt {
153153
///
154154
/// It is possible to inadvertently set this flag, like in the example below.
155155
/// Therefore, it is important to be vigilant while changing options to mitigate
156-
/// unexpected behaviour.
156+
/// unexpected behavior.
157157
///
158158
/// ```no_run
159159
/// use std::fs::File;

‎std/src/path.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -1167,7 +1167,7 @@ impl FusedIterator for Ancestors<'_> {}
11671167
/// path.push(r"..\otherdir");
11681168
/// path.push("system32");
11691169
///
1170-
/// The behaviour of `PathBuf` may be changed to a panic on such inputs
1170+
/// The behavior of `PathBuf` may be changed to a panic on such inputs
11711171
/// in the future. [`Extend::extend`] should be used to add multi-part paths.
11721172
#[cfg_attr(not(test), rustc_diagnostic_item = "PathBuf")]
11731173
#[stable(feature = "rust1", since = "1.0.0")]
@@ -1409,7 +1409,7 @@ impl PathBuf {
14091409
/// (That is, it will have the same parent.)
14101410
///
14111411
/// The argument is not sanitized, so can include separators. This
1412-
/// behaviour may be changed to a panic in the future.
1412+
/// behavior may be changed to a panic in the future.
14131413
///
14141414
/// [`self.file_name`]: Path::file_name
14151415
/// [`pop`]: PathBuf::pop

0 commit comments

Comments
 (0)