mirror of
https://github.com/rust-lang/rust.git
synced 2025-02-19 10:24:16 +00:00
Merging master
This commit is contained in:
Matthias Einwag
commit
871338c3ae
3
.gitmodules
vendored
3
.gitmodules
vendored
@ -44,3 +44,6 @@
|
||||
path = src/llvm-project
|
||||
url = https://github.com/rust-lang/llvm-project.git
|
||||
branch = rustc/8.0-2019-01-16
|
||||
[submodule "src/doc/embedded-book"]
|
||||
path = src/doc/embedded-book
|
||||
url = https://github.com/rust-embedded/book.git
|
||||
1
.mailmap
1
.mailmap
@ -155,6 +155,7 @@ Matt Brubeck <mbrubeck@limpet.net> <mbrubeck@cs.hmc.edu>
|
||||
Matthew Auld <matthew.auld@intel.com>
|
||||
Matthew McPherrin <matthew@mcpherrin.ca> <matt@mcpherrin.ca>
|
||||
Matthijs Hofstra <thiezz@gmail.com>
|
||||
Melody Horn <melody@boringcactus.com> <mathphreak@gmail.com>
|
||||
Michael Williams <m.t.williams@live.com>
|
||||
Michael Woerister <michaelwoerister@posteo> <michaelwoerister@gmail>
|
||||
Mickaël Raybaud-Roig <raybaudroigm@gmail.com> m-r-r <raybaudroigm@gmail.com>
|
||||
|
||||
66
Cargo.lock
66
Cargo.lock
@ -1,3 +1,5 @@
|
||||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
[[package]]
|
||||
name = "adler32"
|
||||
version = "1.0.3"
|
||||
@ -75,8 +77,8 @@ dependencies = [
|
||||
"colored 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"difference 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"environment 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
@ -237,7 +239,7 @@ dependencies = [
|
||||
"curl 0.4.19 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"curl-sys 0.4.15 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"filetime 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"flate2 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"fs2 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -530,7 +532,7 @@ name = "crates-io"
|
||||
version = "0.23.0"
|
||||
dependencies = [
|
||||
"curl 0.4.19 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"serde_derive 1.0.81 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -841,16 +843,16 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "failure"
|
||||
version = "0.1.3"
|
||||
version = "0.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"backtrace 0.3.11 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "failure_derive"
|
||||
version = "0.1.3"
|
||||
version = "0.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -1232,7 +1234,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
|
||||
[[package]]
|
||||
name = "jsonrpc-core"
|
||||
version = "9.0.0"
|
||||
version = "10.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"futures 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -1352,7 +1354,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "lsp-codec"
|
||||
version = "0.1.0"
|
||||
version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -1362,7 +1364,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "lsp-types"
|
||||
version = "0.54.0"
|
||||
version = "0.55.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -1503,7 +1505,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
|
||||
[[package]]
|
||||
name = "minifier"
|
||||
version = "0.0.26"
|
||||
version = "0.0.28"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"macro-utils 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -1677,8 +1679,8 @@ name = "opener"
|
||||
version = "0.3.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
@ -2045,7 +2047,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "racer"
|
||||
version = "2.1.16"
|
||||
version = "2.1.17"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -2246,26 +2248,26 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "rls"
|
||||
version = "1.31.6"
|
||||
version = "1.34.0"
|
||||
dependencies = [
|
||||
"cargo 0.35.0",
|
||||
"cargo_metadata 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"cargo_metadata 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"clippy_lints 0.0.212",
|
||||
"crossbeam-channel 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"difference 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"futures 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"home 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"jsonrpc-core 9.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"jsonrpc-core 10.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"lsp-codec 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"lsp-types 0.54.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"lsp-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"lsp-types 0.55.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"ordslice 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"racer 2.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"racer 2.1.17 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"rayon 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -2992,7 +2994,7 @@ dependencies = [
|
||||
name = "rustdoc"
|
||||
version = "0.0.0"
|
||||
dependencies = [
|
||||
"minifier 0.0.26 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"minifier 0.0.28 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"pulldown-cmark 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -3014,7 +3016,7 @@ name = "rustfix"
|
||||
version = "0.4.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"serde_derive 1.0.81 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -3032,7 +3034,7 @@ dependencies = [
|
||||
"derive-new 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"diff 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"env_logger 0.5.13 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"getopts 0.2.17 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"itertools 0.7.8 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
@ -3818,7 +3820,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
dependencies = [
|
||||
"bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@ -3997,8 +3999,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
"checksum environment 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1f4b14e20978669064c33b4c1e0fb4083412e40fe56cbea2eae80fd7591503ee"
|
||||
"checksum error-chain 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ff511d5dc435d703f4971bc399647c9bc38e20cb41452e3b9feb4765419ed3f3"
|
||||
"checksum error-chain 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "07e791d3be96241c77c43846b665ef1384606da2cd2a48730abe606a12906e02"
|
||||
"checksum failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6dd377bcc1b1b7ce911967e3ec24fa19c3224394ec05b54aa7b083d498341ac7"
|
||||
"checksum failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "64c2d913fe8ed3b6c6518eedf4538255b989945c14c2a7d5cbff62a5e2120596"
|
||||
"checksum failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "795bd83d3abeb9220f257e597aa0080a508b27533824adf336529648f6abf7e2"
|
||||
"checksum failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "ea1063915fd7ef4309e222a5a07cf9c319fb9c7836b1f89b85458672dbb127e1"
|
||||
"checksum fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
|
||||
"checksum filetime 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "a2df5c1a8c4be27e7707789dc42ae65976e60b394afd293d1419ab915833e646"
|
||||
"checksum fixedbitset 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "86d4de0081402f5e88cdac65c8dcdcc73118c1a7a465e2a05f0da05843a8ea33"
|
||||
@ -4040,7 +4042,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
"checksum jemalloc-sys 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "bfc62c8e50e381768ce8ee0428ee53741929f7ebd73e4d83f669bcf7693e00ae"
|
||||
"checksum jobserver 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "dd80e58f77e0cdea53ba96acc5e04479e5ffc5d869626a6beafe50fed867eace"
|
||||
"checksum json 0.11.13 (registry+https://github.com/rust-lang/crates.io-index)" = "9ad0485404155f45cce53a40d4b2d6ac356418300daed05273d9e26f91c390be"
|
||||
"checksum jsonrpc-core 9.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4e9cbeda300803d381390fb65e8158437728c39e6987ed23bee82728b73511a7"
|
||||
"checksum jsonrpc-core 10.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7a5152c3fda235dfd68341b3edf4121bc4428642c93acbd6de88c26bf95fc5d7"
|
||||
"checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
|
||||
"checksum lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "76f033c7ad61445c5b347c7382dd1237847eb1bce590fe50365dcb33d546be73"
|
||||
"checksum lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a374c89b9db55895453a74c1e38861d9deec0b01b405a82516e9d5de4820dea1"
|
||||
@ -4053,8 +4055,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
"checksum lock_api 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "949826a5ccf18c1b3a7c3d57692778d21768b79e46eb9dd07bfc4c2160036c54"
|
||||
"checksum log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c84ec4b527950aa83a329754b01dbe3f58361d1c5efacd1f6d68c494d08a17c6"
|
||||
"checksum log_settings 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "19af41f0565d7c19b2058153ad0b42d4d5ce89ec4dbf06ed6741114a8b63e7cd"
|
||||
"checksum lsp-codec 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9b29e3d1632fef13c1286b0b2f8545a7d894ae565a7fac013b90a17ee5bfbc91"
|
||||
"checksum lsp-types 0.54.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a252cc2be87d9329dd91c505a951996b3263582ba304870960faaae77b642183"
|
||||
"checksum lsp-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f3570f641b984e3e4613a1ca34db2ea72549bbc3c0316d33f5af91ab514dcbff"
|
||||
"checksum lsp-types 0.55.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3ca49aeb430780992121d582520170411658b1e41bf968b917d85fd0fb6da3c5"
|
||||
"checksum lzma-sys 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "d1eaa027402541975218bb0eec67d6b0412f6233af96e0d096d31dbdfd22e614"
|
||||
"checksum mac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
|
||||
"checksum macro-utils 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f2c4deaccc2ead6a28c16c0ba82f07d52b6475397415ce40876e559b0b0ea510"
|
||||
@ -4066,7 +4068,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
"checksum memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0a3eb002f0535929f1199681417029ebea04aadc0c7a4224b46be99c7f5d6a16"
|
||||
"checksum memmap 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e2ffa2c986de11a9df78620c01eeaaf27d94d3ff02bf81bfcca953102dd0c6ff"
|
||||
"checksum memoffset 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0f9dc261e2b62d7a622bf416ea3c5245cdd5d9a7fcc428c0d06804dfce1775b3"
|
||||
"checksum minifier 0.0.26 (registry+https://github.com/rust-lang/crates.io-index)" = "f299df45afd73332044ea9f717c816a84fc90c8b631409abf339ba93642a7985"
|
||||
"checksum minifier 0.0.28 (registry+https://github.com/rust-lang/crates.io-index)" = "3a2898502751dcc9d66b6fff57f3cf63cc91605e83e1a33515396f5027f8e4ca"
|
||||
"checksum miniz-sys 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "0300eafb20369952951699b68243ab4334f4b10a88f411c221d444b36c40e649"
|
||||
"checksum miniz_oxide 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5ad30a47319c16cde58d0314f5d98202a80c9083b5f61178457403dfb14e509c"
|
||||
"checksum miniz_oxide_c_api 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "28edaef377517fd9fe3e085c37d892ce7acd1fbeab9239c5a36eec352d8a8b7e"
|
||||
@ -4123,7 +4125,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
"checksum quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a"
|
||||
"checksum quote 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9949cfe66888ffe1d53e6ec9d9f3b70714083854be20fd5e271b232a017401e8"
|
||||
"checksum quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "53fa22a1994bd0f9372d7a816207d8a2677ad0325b073f5c5332760f0fb62b5c"
|
||||
"checksum racer 2.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "fbfcf2686b50f75a279cb42d9c6d253a1e68a475b415ea4baf7fb177ce94839a"
|
||||
"checksum racer 2.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "11db0de64c3eed7ee25f7b0af2109d296a67efa1efe7566ed17cc01115f961c8"
|
||||
"checksum rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8356f47b32624fef5b3301c1be97e5944ecdd595409cc5da11d05f211db6cfbd"
|
||||
"checksum rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e464cd887e869cddcae8792a4ee31d23c7edd516700695608f5b98c67ee0131c"
|
||||
"checksum rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ae9d223d52ae411a33cf7e54ec6034ec165df296ccd23533d671a28252b6f66a"
|
||||
|
||||
@ -60,17 +60,17 @@ pub trait Step: 'static + Clone + Debug + PartialEq + Eq + Hash {
|
||||
/// Run this rule for all hosts without cross compiling.
|
||||
const ONLY_HOSTS: bool = false;
|
||||
|
||||
/// Primary function to execute this rule. Can call `builder.ensure(...)`
|
||||
/// Primary function to execute this rule. Can call `builder.ensure()`
|
||||
/// with other steps to run those.
|
||||
fn run(self, builder: &Builder) -> Self::Output;
|
||||
|
||||
/// When bootstrap is passed a set of paths, this controls whether this rule
|
||||
/// will execute. However, it does not get called in a "default" context
|
||||
/// when we are not passed any paths; in that case, make_run is called
|
||||
/// when we are not passed any paths; in that case, `make_run` is called
|
||||
/// directly.
|
||||
fn should_run(run: ShouldRun) -> ShouldRun;
|
||||
|
||||
/// Build up a "root" rule, either as a default rule or from a path passed
|
||||
/// Builds up a "root" rule, either as a default rule or from a path passed
|
||||
/// to us.
|
||||
///
|
||||
/// When path is `None`, we are executing in a context where no paths were
|
||||
@ -400,6 +400,7 @@ impl<'a> Builder<'a> {
|
||||
test::TheBook,
|
||||
test::UnstableBook,
|
||||
test::RustcBook,
|
||||
test::EmbeddedBook,
|
||||
test::Rustfmt,
|
||||
test::Miri,
|
||||
test::Clippy,
|
||||
@ -430,6 +431,7 @@ impl<'a> Builder<'a> {
|
||||
doc::RustByExample,
|
||||
doc::RustcBook,
|
||||
doc::CargoBook,
|
||||
doc::EmbeddedBook,
|
||||
doc::EditionGuide,
|
||||
),
|
||||
Kind::Dist => describe!(
|
||||
@ -646,7 +648,7 @@ impl<'a> Builder<'a> {
|
||||
add_lib_path(vec![self.rustc_libdir(compiler)], cmd);
|
||||
}
|
||||
|
||||
/// Get a path to the compiler specified.
|
||||
/// Gets a path to the compiler specified.
|
||||
pub fn rustc(&self, compiler: Compiler) -> PathBuf {
|
||||
if compiler.is_snapshot(self) {
|
||||
self.initial_rustc.clone()
|
||||
@ -657,7 +659,7 @@ impl<'a> Builder<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the paths to all of the compiler's codegen backends.
|
||||
/// Gets the paths to all of the compiler's codegen backends.
|
||||
fn codegen_backends(&self, compiler: Compiler) -> impl Iterator<Item = PathBuf> {
|
||||
fs::read_dir(self.sysroot_codegen_backends(compiler))
|
||||
.into_iter()
|
||||
@ -1017,8 +1019,7 @@ impl<'a> Builder<'a> {
|
||||
|
||||
cargo.env("RUSTC_VERBOSE", self.verbosity.to_string());
|
||||
|
||||
// in std, we want to avoid denying warnings for stage 0 as that makes cfg's painful.
|
||||
if self.config.deny_warnings && !(mode == Mode::Std && stage == 0) {
|
||||
if self.config.deny_warnings {
|
||||
cargo.env("RUSTC_DENY_WARNINGS", "1");
|
||||
}
|
||||
|
||||
|
||||
@ -227,10 +227,10 @@ lazy_static! {
|
||||
pub static ref INTERNER: Interner = Interner::default();
|
||||
}
|
||||
|
||||
/// This is essentially a HashMap which allows storing any type in its input and
|
||||
/// This is essentially a `HashMap` which allows storing any type in its input and
|
||||
/// any type in its output. It is a write-once cache; values are never evicted,
|
||||
/// which means that references to the value can safely be returned from the
|
||||
/// get() method.
|
||||
/// `get()` method.
|
||||
#[derive(Debug)]
|
||||
pub struct Cache(
|
||||
RefCell<HashMap<
|
||||
|
||||
@ -66,7 +66,7 @@ impl Step for Rustc {
|
||||
});
|
||||
}
|
||||
|
||||
/// Build the compiler.
|
||||
/// Builds the compiler.
|
||||
///
|
||||
/// This will build the compiler for a particular stage of the build using
|
||||
/// the `compiler` targeting the `target` architecture. The artifacts
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
//! Responsible for cleaning out a build directory of all old and stale
|
||||
//! artifacts to prepare for a fresh build. Currently doesn't remove the
|
||||
//! `build/cache` directory (download cache) or the `build/$target/llvm`
|
||||
//! directory unless the --all flag is present.
|
||||
//! directory unless the `--all` flag is present.
|
||||
|
||||
use std::fs;
|
||||
use std::io::{self, ErrorKind};
|
||||
|
||||
@ -48,7 +48,7 @@ impl Step for Std {
|
||||
});
|
||||
}
|
||||
|
||||
/// Build the standard library.
|
||||
/// Builds the standard library.
|
||||
///
|
||||
/// This will build the standard library for a particular stage of the build
|
||||
/// using the `compiler` targeting the `target` architecture. The artifacts
|
||||
@ -269,7 +269,7 @@ impl Step for StartupObjects {
|
||||
});
|
||||
}
|
||||
|
||||
/// Build and prepare startup objects like rsbegin.o and rsend.o
|
||||
/// Builds and prepare startup objects like rsbegin.o and rsend.o
|
||||
///
|
||||
/// These are primarily used on Windows right now for linking executables/dlls.
|
||||
/// They don't require any library support as they're just plain old object
|
||||
@ -334,7 +334,7 @@ impl Step for Test {
|
||||
});
|
||||
}
|
||||
|
||||
/// Build libtest.
|
||||
/// Builds libtest.
|
||||
///
|
||||
/// This will build libtest and supporting libraries for a particular stage of
|
||||
/// the build using the `compiler` targeting the `target` architecture. The
|
||||
@ -455,7 +455,7 @@ impl Step for Rustc {
|
||||
});
|
||||
}
|
||||
|
||||
/// Build the compiler.
|
||||
/// Builds the compiler.
|
||||
///
|
||||
/// This will build the compiler for a particular stage of the build using
|
||||
/// the `compiler` targeting the `target` architecture. The artifacts
|
||||
|
||||
@ -342,7 +342,7 @@ impl Step for Mingw {
|
||||
run.builder.ensure(Mingw { host: run.target });
|
||||
}
|
||||
|
||||
/// Build the `rust-mingw` installer component.
|
||||
/// Builds the `rust-mingw` installer component.
|
||||
///
|
||||
/// This contains all the bits and pieces to run the MinGW Windows targets
|
||||
/// without any extra installed software (e.g., we bundle gcc, libraries, etc).
|
||||
|
||||
@ -61,6 +61,7 @@ macro_rules! book {
|
||||
// adding a build step in `src/bootstrap/builder.rs`!
|
||||
book!(
|
||||
EditionGuide, "src/doc/edition-guide", "edition-guide", RustbookVersion::MdBook1;
|
||||
EmbeddedBook, "src/doc/embedded-book", "embedded-book", RustbookVersion::MdBook2;
|
||||
Nomicon, "src/doc/nomicon", "nomicon", RustbookVersion::MdBook1;
|
||||
Reference, "src/doc/reference", "reference", RustbookVersion::MdBook1;
|
||||
RustByExample, "src/doc/rust-by-example", "rust-by-example", RustbookVersion::MdBook1;
|
||||
@ -71,10 +72,6 @@ book!(
|
||||
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
||||
enum RustbookVersion {
|
||||
MdBook1,
|
||||
|
||||
/// Note: Currently no books use mdBook v2, but we want the option
|
||||
/// to be available
|
||||
#[allow(dead_code)]
|
||||
MdBook2,
|
||||
}
|
||||
|
||||
@ -262,7 +259,7 @@ impl Step for TheBook {
|
||||
});
|
||||
}
|
||||
|
||||
/// Build the book and associated stuff.
|
||||
/// Builds the book and associated stuff.
|
||||
///
|
||||
/// We need to build:
|
||||
///
|
||||
@ -614,7 +611,7 @@ impl Step for WhitelistedRustc {
|
||||
});
|
||||
}
|
||||
|
||||
/// Generate whitelisted compiler crate documentation.
|
||||
/// Generates whitelisted compiler crate documentation.
|
||||
///
|
||||
/// This will generate all documentation for crates that are whitelisted
|
||||
/// to be included in the standard documentation. This documentation is
|
||||
@ -686,7 +683,7 @@ impl Step for Rustc {
|
||||
});
|
||||
}
|
||||
|
||||
/// Generate compiler documentation.
|
||||
/// Generates compiler documentation.
|
||||
///
|
||||
/// This will generate all documentation for compiler and dependencies.
|
||||
/// Compiler documentation is distributed separately, so we make sure
|
||||
@ -787,7 +784,7 @@ impl Step for Rustdoc {
|
||||
});
|
||||
}
|
||||
|
||||
/// Generate compiler documentation.
|
||||
/// Generates compiler documentation.
|
||||
///
|
||||
/// This will generate all documentation for compiler and dependencies.
|
||||
/// Compiler documentation is distributed separately, so we make sure
|
||||
|
||||
@ -69,7 +69,7 @@
|
||||
//! ## Copying stage0 {std,test,rustc}
|
||||
//!
|
||||
//! This copies the build output from Cargo into
|
||||
//! `build/$HOST/stage0-sysroot/lib/rustlib/$ARCH/lib`. FIXME: This step's
|
||||
//! `build/$HOST/stage0-sysroot/lib/rustlib/$ARCH/lib`. FIXME: this step's
|
||||
//! documentation should be expanded -- the information already here may be
|
||||
//! incorrect.
|
||||
//!
|
||||
@ -504,7 +504,7 @@ impl Build {
|
||||
cleared
|
||||
}
|
||||
|
||||
/// Get the space-separated set of activated features for the standard
|
||||
/// Gets the space-separated set of activated features for the standard
|
||||
/// library.
|
||||
fn std_features(&self) -> String {
|
||||
let mut features = "panic-unwind".to_string();
|
||||
@ -521,7 +521,7 @@ impl Build {
|
||||
features
|
||||
}
|
||||
|
||||
/// Get the space-separated set of activated features for the compiler.
|
||||
/// Gets the space-separated set of activated features for the compiler.
|
||||
fn rustc_features(&self) -> String {
|
||||
let mut features = String::new();
|
||||
if self.config.jemalloc {
|
||||
@ -609,7 +609,7 @@ impl Build {
|
||||
self.out.join(&*target).join("crate-docs")
|
||||
}
|
||||
|
||||
/// Returns true if no custom `llvm-config` is set for the specified target.
|
||||
/// Returns `true` if no custom `llvm-config` is set for the specified target.
|
||||
///
|
||||
/// If no custom `llvm-config` was specified then Rust's llvm will be used.
|
||||
fn is_rust_llvm(&self, target: Interned<String>) -> bool {
|
||||
@ -857,13 +857,13 @@ impl Build {
|
||||
.map(|p| &**p)
|
||||
}
|
||||
|
||||
/// Returns true if this is a no-std `target`, if defined
|
||||
/// Returns `true` if this is a no-std `target`, if defined
|
||||
fn no_std(&self, target: Interned<String>) -> Option<bool> {
|
||||
self.config.target_config.get(&target)
|
||||
.map(|t| t.no_std)
|
||||
}
|
||||
|
||||
/// Returns whether the target will be tested using the `remote-test-client`
|
||||
/// Returns `true` if the target will be tested using the `remote-test-client`
|
||||
/// and `remote-test-server` binaries.
|
||||
fn remote_tested(&self, target: Interned<String>) -> bool {
|
||||
self.qemu_rootfs(target).is_some() || target.contains("android") ||
|
||||
@ -1059,7 +1059,7 @@ impl Build {
|
||||
self.rust_info.version(self, channel::CFG_RELEASE_NUM)
|
||||
}
|
||||
|
||||
/// Return the full commit hash
|
||||
/// Returns the full commit hash.
|
||||
fn rust_sha(&self) -> Option<&str> {
|
||||
self.rust_info.sha()
|
||||
}
|
||||
@ -1079,7 +1079,7 @@ impl Build {
|
||||
panic!("failed to find version in {}'s Cargo.toml", package)
|
||||
}
|
||||
|
||||
/// Returns whether unstable features should be enabled for the compiler
|
||||
/// Returns `true` if unstable features should be enabled for the compiler
|
||||
/// we're building.
|
||||
fn unstable_features(&self) -> bool {
|
||||
match &self.config.channel[..] {
|
||||
@ -1327,7 +1327,7 @@ impl<'a> Compiler {
|
||||
self
|
||||
}
|
||||
|
||||
/// Returns whether this is a snapshot compiler for `build`'s configuration
|
||||
/// Returns `true` if this is a snapshot compiler for `build`'s configuration
|
||||
pub fn is_snapshot(&self, build: &Build) -> bool {
|
||||
self.stage == 0 && self.host == build.build
|
||||
}
|
||||
|
||||
@ -30,9 +30,9 @@ const ADB_TEST_DIR: &str = "/data/tmp/work";
|
||||
/// The two modes of the test runner; tests or benchmarks.
|
||||
#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone, PartialOrd, Ord)]
|
||||
pub enum TestKind {
|
||||
/// Run `cargo test`
|
||||
/// Run `cargo test`.
|
||||
Test,
|
||||
/// Run `cargo bench`
|
||||
/// Run `cargo bench`.
|
||||
Bench,
|
||||
}
|
||||
|
||||
@ -1288,7 +1288,7 @@ impl Step for DocTest {
|
||||
run.never()
|
||||
}
|
||||
|
||||
/// Run `rustdoc --test` for all documentation in `src/doc`.
|
||||
/// Runs `rustdoc --test` for all documentation in `src/doc`.
|
||||
///
|
||||
/// This will run all tests in our markdown documentation (e.g., the book)
|
||||
/// located in `src/doc`. The `rustdoc` that's run is the one that sits next to
|
||||
@ -1383,6 +1383,7 @@ test_book!(
|
||||
RustdocBook, "src/doc/rustdoc", "rustdoc", default=true;
|
||||
RustcBook, "src/doc/rustc", "rustc", default=true;
|
||||
RustByExample, "src/doc/rust-by-example", "rust-by-example", default=false;
|
||||
EmbeddedBook, "src/doc/embedded-book", "embedded-book", default=false;
|
||||
TheBook, "src/doc/book", "book", default=false;
|
||||
UnstableBook, "src/doc/unstable-book", "unstable-book", default=true;
|
||||
);
|
||||
@ -1407,7 +1408,7 @@ impl Step for ErrorIndex {
|
||||
});
|
||||
}
|
||||
|
||||
/// Run the error index generator tool to execute the tests located in the error
|
||||
/// Runs the error index generator tool to execute the tests located in the error
|
||||
/// index.
|
||||
///
|
||||
/// The `error_index_generator` tool lives in `src/tools` and is used to
|
||||
@ -1613,7 +1614,7 @@ impl Step for Crate {
|
||||
}
|
||||
}
|
||||
|
||||
/// Run all unit tests plus documentation tests for a given crate defined
|
||||
/// Runs all unit tests plus documentation tests for a given crate defined
|
||||
/// by a `Cargo.toml` (single manifest)
|
||||
///
|
||||
/// This is what runs tests for crates like the standard library, compiler, etc.
|
||||
@ -1832,7 +1833,7 @@ fn envify(s: &str) -> String {
|
||||
/// the standard library and such to the emulator ahead of time. This step
|
||||
/// represents this and is a dependency of all test suites.
|
||||
///
|
||||
/// Most of the time this is a noop. For some steps such as shipping data to
|
||||
/// Most of the time this is a no-op. For some steps such as shipping data to
|
||||
/// QEMU we have to build our own tools so we've got conditional dependencies
|
||||
/// on those programs as well. Note that the remote test client is built for
|
||||
/// the build target (us) and the server is built for the target.
|
||||
@ -1903,7 +1904,7 @@ impl Step for Distcheck {
|
||||
run.builder.ensure(Distcheck);
|
||||
}
|
||||
|
||||
/// Run "distcheck", a 'make check' from a tarball
|
||||
/// Runs "distcheck", a 'make check' from a tarball
|
||||
fn run(self, builder: &Builder) {
|
||||
builder.info("Distcheck");
|
||||
let dir = builder.out.join("tmp").join("distcheck");
|
||||
@ -1964,7 +1965,7 @@ impl Step for Bootstrap {
|
||||
const DEFAULT: bool = true;
|
||||
const ONLY_HOSTS: bool = true;
|
||||
|
||||
/// Test the build system itself
|
||||
/// Tests the build system itself.
|
||||
fn run(self, builder: &Builder) {
|
||||
let mut cmd = Command::new(&builder.initial_cargo);
|
||||
cmd.arg("test")
|
||||
|
||||
@ -40,7 +40,7 @@ impl Step for ToolBuild {
|
||||
run.never()
|
||||
}
|
||||
|
||||
/// Build a tool in `src/tools`
|
||||
/// Builds a tool in `src/tools`
|
||||
///
|
||||
/// This will build the specified tool with the specified `host` compiler in
|
||||
/// `stage` into the normal cargo output directory.
|
||||
@ -621,7 +621,7 @@ tool_extended!((self, builder),
|
||||
);
|
||||
|
||||
impl<'a> Builder<'a> {
|
||||
/// Get a `Command` which is ready to run `tool` in `stage` built for
|
||||
/// Gets a `Command` which is ready to run `tool` in `stage` built for
|
||||
/// `host`.
|
||||
pub fn tool_cmd(&self, tool: Tool) -> Command {
|
||||
let mut cmd = Command::new(self.tool_exe(tool));
|
||||
|
||||
@ -33,7 +33,7 @@ pub fn exe(name: &str, target: &str) -> String {
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns whether the file name given looks like a dynamic library.
|
||||
/// Returns `true` if the file name given looks like a dynamic library.
|
||||
pub fn is_dylib(name: &str) -> bool {
|
||||
name.ends_with(".dylib") || name.ends_with(".so") || name.ends_with(".dll")
|
||||
}
|
||||
|
||||
@ -2,6 +2,7 @@
|
||||
name = "build_helper"
|
||||
version = "0.1.0"
|
||||
authors = ["The Rust Project Developers"]
|
||||
edition = "2018"
|
||||
|
||||
[lib]
|
||||
name = "build_helper"
|
||||
|
||||
@ -1,3 +1,5 @@
|
||||
#![deny(rust_2018_idioms)]
|
||||
|
||||
use std::fs::File;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::{Command, Stdio};
|
||||
@ -161,7 +163,7 @@ pub fn mtime(path: &Path) -> SystemTime {
|
||||
.unwrap_or(UNIX_EPOCH)
|
||||
}
|
||||
|
||||
/// Returns whether `dst` is up to date given that the file or files in `src`
|
||||
/// Returns `true` if `dst` is up to date given that the file or files in `src`
|
||||
/// are used to generate it.
|
||||
///
|
||||
/// Uses last-modified time checks to verify this.
|
||||
@ -188,12 +190,12 @@ pub struct NativeLibBoilerplate {
|
||||
}
|
||||
|
||||
impl NativeLibBoilerplate {
|
||||
/// On OSX we don't want to ship the exact filename that compiler-rt builds.
|
||||
/// On macOS we don't want to ship the exact filename that compiler-rt builds.
|
||||
/// This conflicts with the system and ours is likely a wildly different
|
||||
/// version, so they can't be substituted.
|
||||
///
|
||||
/// As a result, we rename it here but we need to also use
|
||||
/// `install_name_tool` on OSX to rename the commands listed inside of it to
|
||||
/// `install_name_tool` on macOS to rename the commands listed inside of it to
|
||||
/// ensure it's linked against correctly.
|
||||
pub fn fixup_sanitizer_lib_name(&self, sanitizer_name: &str) {
|
||||
if env::var("TARGET").unwrap() != "x86_64-apple-darwin" {
|
||||
|
||||
@ -23,6 +23,7 @@ python2.7 "$X_PY" test --no-fail-fast \
|
||||
src/doc/nomicon \
|
||||
src/doc/reference \
|
||||
src/doc/rust-by-example \
|
||||
src/doc/embedded-book \
|
||||
src/tools/clippy \
|
||||
src/tools/rls \
|
||||
src/tools/rustfmt \
|
||||
|
||||
@ -121,14 +121,7 @@ fi
|
||||
travis_fold end log-system-info
|
||||
|
||||
if [ ! -z "$SCRIPT" ]; then
|
||||
# This `set +e` followed by capturing the return value is a temporary measure
|
||||
# to help debug "error with exit 259" on AppVeyor temporarily, otherwise all
|
||||
# that's needed here is the `sh`
|
||||
set +e
|
||||
sh -x -c "$SCRIPT"
|
||||
ret=$?
|
||||
echo "script exited with $ret"
|
||||
exit $ret
|
||||
else
|
||||
do_make() {
|
||||
travis_fold start "make-$1"
|
||||
|
||||
1
src/doc/embedded-book
Submodule
1
src/doc/embedded-book
Submodule
@ -0,0 +1 @@
|
||||
Subproject commit bd2778f304989ee52be8201504d6ec621dd60ca9
|
||||
@ -52,6 +52,12 @@ If reading multiple hundreds of pages about a language isn't your style, then
|
||||
a lot of words, RBE shows off a bunch of code, and keeps the talking to a
|
||||
minimum. It also includes exercises!
|
||||
|
||||
## Rustlings
|
||||
|
||||
[Rustlings](https://github.com/rust-lang/rustlings) guides you through downloading and setting up the Rust toolchain,
|
||||
and teaches you the basics of reading and writing Rust syntax. It's an
|
||||
alternative to Rust by Example that works with your own environment.
|
||||
|
||||
# Use Rust
|
||||
|
||||
Once you've gotten familiar with the language, these resources can help you
|
||||
@ -117,3 +123,19 @@ Rust. It's also sometimes called "the 'nomicon."
|
||||
[The `rustc` Guide](https://rust-lang.github.io/rustc-guide/) documents how
|
||||
the compiler works and how to contribute to it. This is useful if you want to build
|
||||
or modify the Rust compiler from source (e.g. to target something non-standard).
|
||||
|
||||
# Specialize Rust
|
||||
|
||||
When using Rust in specific domain areas, consider using the following resources tailored to each domain.
|
||||
|
||||
## Embedded Systems
|
||||
|
||||
When developing for Bare Metal or Embedded Linux systems, you may find these resources maintained by the [Embedded Working Group] useful.
|
||||
|
||||
[Embedded Working Group]: https://github.com/rust-embedded
|
||||
|
||||
### The Embedded Rust Book
|
||||
|
||||
[The Embedded Rust Book] is targeted at developers familiar with embedded development and familiar with Rust, but have not used Rust for embedded development.
|
||||
|
||||
[The Embedded Rust Book]: embedded-book/index.html
|
||||
|
||||
@ -1,9 +1,8 @@
|
||||
# Unstable features
|
||||
|
||||
Rustdoc is under active development, and like the Rust compiler, some features are only available
|
||||
on the nightly releases. Some of these are new and need some more testing before they're able to get
|
||||
released to the world at large, and some of them are tied to features in the Rust compiler that are
|
||||
themselves unstable. Several features here require a matching `#![feature(...)]` attribute to
|
||||
on nightly releases. Some of these features are new and need some more testing before they're able to be
|
||||
released to the world at large, and some of them are tied to features in the Rust compiler that are unstable. Several features here require a matching `#![feature(...)]` attribute to
|
||||
enable, and thus are more fully documented in the [Unstable Book]. Those sections will link over
|
||||
there as necessary.
|
||||
|
||||
@ -428,4 +427,4 @@ $ rustdoc src/lib.rs --test -Z unstable-options --persist-doctests target/rustdo
|
||||
|
||||
This flag allows you to keep doctest executables around after they're compiled or run.
|
||||
Usually, rustdoc will immediately discard a compiled doctest after it's been tested, but
|
||||
with this option, you can keep those binaries around for farther testing.
|
||||
with this option, you can keep those binaries around for farther testing.
|
||||
|
||||
@ -0,0 +1,42 @@
|
||||
# `repr_align_enum`
|
||||
|
||||
The tracking issue for this feature is: [#57996]
|
||||
|
||||
[#57996]: https://github.com/rust-lang/rust/issues/57996
|
||||
|
||||
------------------------
|
||||
|
||||
The `repr_align_enum` feature allows using the `#[repr(align(x))]` attribute
|
||||
on enums, similarly to structs.
|
||||
|
||||
# Examples
|
||||
|
||||
```rust
|
||||
#![feature(repr_align_enum)]
|
||||
|
||||
#[repr(align(8))]
|
||||
enum Aligned {
|
||||
Foo,
|
||||
Bar { value: u32 },
|
||||
}
|
||||
|
||||
fn main() {
|
||||
assert_eq!(std::mem::align_of::<Aligned>(), 8);
|
||||
}
|
||||
```
|
||||
|
||||
This is equivalent to using an aligned wrapper struct everywhere:
|
||||
|
||||
```rust
|
||||
#[repr(align(8))]
|
||||
struct Aligned(Unaligned);
|
||||
|
||||
enum Unaligned {
|
||||
Foo,
|
||||
Bar { value: u32 },
|
||||
}
|
||||
|
||||
fn main() {
|
||||
assert_eq!(std::mem::align_of::<Aligned>(), 8);
|
||||
}
|
||||
```
|
||||
@ -137,11 +137,11 @@ impl<T> ToOwned for T
|
||||
/// ```
|
||||
/// use std::borrow::{Cow, ToOwned};
|
||||
///
|
||||
/// struct Items<'a, X: 'a> where [X]: ToOwned<Owned=Vec<X>> {
|
||||
/// struct Items<'a, X: 'a> where [X]: ToOwned<Owned = Vec<X>> {
|
||||
/// values: Cow<'a, [X]>,
|
||||
/// }
|
||||
///
|
||||
/// impl<'a, X: Clone + 'a> Items<'a, X> where [X]: ToOwned<Owned=Vec<X>> {
|
||||
/// impl<'a, X: Clone + 'a> Items<'a, X> where [X]: ToOwned<Owned = Vec<X>> {
|
||||
/// fn new(v: Cow<'a, [X]>) -> Self {
|
||||
/// Items { values: v }
|
||||
/// }
|
||||
|
||||
@ -248,14 +248,18 @@ impl<T: Ord> Drop for PeekMut<'_, T> {
|
||||
impl<T: Ord> Deref for PeekMut<'_, T> {
|
||||
type Target = T;
|
||||
fn deref(&self) -> &T {
|
||||
&self.heap.data[0]
|
||||
debug_assert!(!self.heap.is_empty());
|
||||
// SAFE: PeekMut is only instantiated for non-empty heaps
|
||||
unsafe { self.heap.data.get_unchecked(0) }
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
|
||||
impl<T: Ord> DerefMut for PeekMut<'_, T> {
|
||||
fn deref_mut(&mut self) -> &mut T {
|
||||
&mut self.heap.data[0]
|
||||
debug_assert!(!self.heap.is_empty());
|
||||
// SAFE: PeekMut is only instantiated for non-empty heaps
|
||||
unsafe { self.heap.data.get_unchecked_mut(0) }
|
||||
}
|
||||
}
|
||||
|
||||
@ -859,13 +863,14 @@ struct Hole<'a, T: 'a> {
|
||||
}
|
||||
|
||||
impl<'a, T> Hole<'a, T> {
|
||||
/// Create a new Hole at index `pos`.
|
||||
/// Create a new `Hole` at index `pos`.
|
||||
///
|
||||
/// Unsafe because pos must be within the data slice.
|
||||
#[inline]
|
||||
unsafe fn new(data: &'a mut [T], pos: usize) -> Self {
|
||||
debug_assert!(pos < data.len());
|
||||
let elt = ptr::read(&data[pos]);
|
||||
// SAFE: pos should be inside the slice
|
||||
let elt = ptr::read(data.get_unchecked(pos));
|
||||
Hole {
|
||||
data,
|
||||
elt: ManuallyDrop::new(elt),
|
||||
|
||||
@ -2368,7 +2368,7 @@ impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
|
||||
|
||||
/// Gets a mutable reference to the value in the entry.
|
||||
///
|
||||
/// If you need a reference to the `OccupiedEntry` which may outlive the
|
||||
/// If you need a reference to the `OccupiedEntry` that may outlive the
|
||||
/// destruction of the `Entry` value, see [`into_mut`].
|
||||
///
|
||||
/// [`into_mut`]: #method.into_mut
|
||||
|
||||
@ -50,11 +50,11 @@ pub const CAPACITY: usize = 2 * B - 1;
|
||||
///
|
||||
/// We have a separate type for the header and rely on it matching the prefix of `LeafNode`, in
|
||||
/// order to statically allocate a single dummy node to avoid allocations. This struct is
|
||||
/// `repr(C)` to prevent them from being reordered. `LeafNode` does not just contain a
|
||||
/// `repr(C)` to prevent them from being reordered. `LeafNode` does not just contain a
|
||||
/// `NodeHeader` because we do not want unnecessary padding between `len` and the keys.
|
||||
/// Crucially, `NodeHeader` can be safely transmuted to different K and V. (This is exploited
|
||||
/// Crucially, `NodeHeader` can be safely transmuted to different K and V. (This is exploited
|
||||
/// by `as_header`.)
|
||||
/// See `into_key_slice` for an explanation of K2. K2 cannot be safely transmuted around
|
||||
/// See `into_key_slice` for an explanation of K2. K2 cannot be safely transmuted around
|
||||
/// because the size of `NodeHeader` depends on its alignment!
|
||||
#[repr(C)]
|
||||
struct NodeHeader<K, V, K2 = ()> {
|
||||
@ -1295,7 +1295,7 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns whether it is valid to call `.merge()`, i.e., whether there is enough room in
|
||||
/// Returns `true` if it is valid to call `.merge()`, i.e., whether there is enough room in
|
||||
/// a node to hold the combination of the nodes to the left and right of this handle along
|
||||
/// with the key/value pair at this handle.
|
||||
pub fn can_merge(&self) -> bool {
|
||||
@ -1573,7 +1573,7 @@ unsafe fn move_edges<K, V>(
|
||||
impl<BorrowType, K, V, HandleType>
|
||||
Handle<NodeRef<BorrowType, K, V, marker::LeafOrInternal>, HandleType> {
|
||||
|
||||
/// Check whether the underlying node is an `Internal` node or a `Leaf` node.
|
||||
/// Checks whether the underlying node is an `Internal` node or a `Leaf` node.
|
||||
pub fn force(self) -> ForceResult<
|
||||
Handle<NodeRef<BorrowType, K, V, marker::Leaf>, HandleType>,
|
||||
Handle<NodeRef<BorrowType, K, V, marker::Internal>, HandleType>
|
||||
|
||||
@ -556,7 +556,7 @@ impl<T: Ord> BTreeSet<T> {
|
||||
Recover::replace(&mut self.map, value)
|
||||
}
|
||||
|
||||
/// Removes a value from the set. Returns `true` if the value was
|
||||
/// Removes a value from the set. Returns whether the value was
|
||||
/// present in the set.
|
||||
///
|
||||
/// The value may be any borrowed form of the set's value type,
|
||||
@ -988,7 +988,7 @@ impl<'a, T> DoubleEndedIterator for Range<'a, T> {
|
||||
#[stable(feature = "fused", since = "1.26.0")]
|
||||
impl<T> FusedIterator for Range<'_, T> {}
|
||||
|
||||
/// Compare `x` and `y`, but return `short` if x is None and `long` if y is None
|
||||
/// Compares `x` and `y`, but return `short` if x is None and `long` if y is None
|
||||
fn cmp_opt<T: Ord>(x: Option<&T>, y: Option<&T>, short: Ordering, long: Ordering) -> Ordering {
|
||||
match (x, y) {
|
||||
(None, _) => short,
|
||||
|
||||
@ -124,7 +124,7 @@ impl<T> VecDeque<T> {
|
||||
ptr::write(self.ptr().add(off), value);
|
||||
}
|
||||
|
||||
/// Returns `true` if and only if the buffer is at full capacity.
|
||||
/// Returns `true` if the buffer is at full capacity.
|
||||
#[inline]
|
||||
fn is_full(&self) -> bool {
|
||||
self.cap() - self.len() == 1
|
||||
@ -560,7 +560,7 @@ impl<T> VecDeque<T> {
|
||||
/// Does nothing if the capacity is already sufficient.
|
||||
///
|
||||
/// Note that the allocator may give the collection more space than it
|
||||
/// requests. Therefore capacity can not be relied upon to be precisely
|
||||
/// requests. Therefore, capacity can not be relied upon to be precisely
|
||||
/// minimal. Prefer `reserve` if future insertions are expected.
|
||||
///
|
||||
/// # Errors
|
||||
@ -924,7 +924,7 @@ impl<T> VecDeque<T> {
|
||||
self.tail == self.head
|
||||
}
|
||||
|
||||
/// Create a draining iterator that removes the specified range in the
|
||||
/// Creates a draining iterator that removes the specified range in the
|
||||
/// `VecDeque` and yields the removed items.
|
||||
///
|
||||
/// Note 1: The element range is removed even if the iterator is not
|
||||
@ -932,7 +932,7 @@ impl<T> VecDeque<T> {
|
||||
///
|
||||
/// Note 2: It is unspecified how many elements are removed from the deque,
|
||||
/// if the `Drain` value is not dropped, but the borrow it holds expires
|
||||
/// (eg. due to mem::forget).
|
||||
/// (e.g., due to `mem::forget`).
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
@ -1922,7 +1922,7 @@ impl<T> VecDeque<T> {
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// If `mid` is greater than `len()`. Note that `mid == len()`
|
||||
/// If `mid` is greater than `len()`. Note that `mid == len()`
|
||||
/// does _not_ panic and is a no-op rotation.
|
||||
///
|
||||
/// # Complexity
|
||||
@ -1967,7 +1967,7 @@ impl<T> VecDeque<T> {
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// If `k` is greater than `len()`. Note that `k == len()`
|
||||
/// If `k` is greater than `len()`. Note that `k == len()`
|
||||
/// does _not_ panic and is a no-op rotation.
|
||||
///
|
||||
/// # Complexity
|
||||
|
||||
@ -27,7 +27,7 @@
|
||||
//! will then parse the format string and determine if the list of arguments
|
||||
//! provided is suitable to pass to this format string.
|
||||
//!
|
||||
//! To convert a single value to a string, use the [`to_string`] method. This
|
||||
//! To convert a single value to a string, use the [`to_string`] method. This
|
||||
//! will use the [`Display`] formatting trait.
|
||||
//!
|
||||
//! ## Positional parameters
|
||||
@ -102,7 +102,7 @@
|
||||
//! When requesting that an argument be formatted with a particular type, you
|
||||
//! are actually requesting that an argument ascribes to a particular trait.
|
||||
//! This allows multiple actual types to be formatted via `{:x}` (like [`i8`] as
|
||||
//! well as [`isize`]). The current mapping of types to traits is:
|
||||
//! well as [`isize`]). The current mapping of types to traits is:
|
||||
//!
|
||||
//! * *nothing* ⇒ [`Display`]
|
||||
//! * `?` ⇒ [`Debug`]
|
||||
@ -427,7 +427,7 @@
|
||||
//! 3. An asterisk `.*`:
|
||||
//!
|
||||
//! `.*` means that this `{...}` is associated with *two* format inputs rather than one: the
|
||||
//! first input holds the `usize` precision, and the second holds the value to print. Note that
|
||||
//! first input holds the `usize` precision, and the second holds the value to print. Note that
|
||||
//! in this case, if one uses the format string `{<arg>:<spec>.*}`, then the `<arg>` part refers
|
||||
//! to the *value* to print, and the `precision` must come in the input preceding `<arg>`.
|
||||
//!
|
||||
|
||||
@ -55,9 +55,7 @@
|
||||
reason = "this library is unlikely to be stabilized in its current \
|
||||
form or name",
|
||||
issue = "27783")]
|
||||
#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
|
||||
html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
|
||||
html_root_url = "https://doc.rust-lang.org/nightly/",
|
||||
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/",
|
||||
issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/",
|
||||
test(no_crate_inject, attr(allow(unused_variables), deny(warnings))))]
|
||||
#![no_std]
|
||||
@ -70,7 +68,6 @@
|
||||
#![warn(intra_doc_link_resolution_failure)]
|
||||
#![warn(missing_debug_implementations)]
|
||||
|
||||
#![cfg_attr(not(test), feature(fn_traits))]
|
||||
#![cfg_attr(not(test), feature(generator_trait))]
|
||||
#![cfg_attr(test, feature(test))]
|
||||
|
||||
@ -88,6 +85,7 @@
|
||||
#![feature(dropck_eyepatch)]
|
||||
#![feature(exact_size_is_empty)]
|
||||
#![feature(fmt_internals)]
|
||||
#![feature(fn_traits)]
|
||||
#![feature(fundamental)]
|
||||
#![feature(futures_api)]
|
||||
#![feature(lang_items)]
|
||||
@ -102,6 +100,7 @@
|
||||
#![feature(receiver_trait)]
|
||||
#![feature(specialization)]
|
||||
#![feature(staged_api)]
|
||||
#![feature(std_internals)]
|
||||
#![feature(str_internals)]
|
||||
#![feature(trusted_len)]
|
||||
#![feature(try_reserve)]
|
||||
|
||||
@ -34,7 +34,8 @@
|
||||
#[cfg(not(test))]
|
||||
#[macro_export]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[allow_internal_unstable]
|
||||
#[cfg_attr(not(stage0), allow_internal_unstable(box_syntax))]
|
||||
#[cfg_attr(stage0, allow_internal_unstable)]
|
||||
macro_rules! vec {
|
||||
($elem:expr; $n:expr) => (
|
||||
$crate::vec::from_elem($elem, $n)
|
||||
@ -62,18 +63,18 @@ macro_rules! vec {
|
||||
|
||||
/// Creates a `String` using interpolation of runtime expressions.
|
||||
///
|
||||
/// The first argument `format!` receives is a format string. This must be a string
|
||||
/// literal. The power of the formatting string is in the `{}`s contained.
|
||||
/// The first argument `format!` receives is a format string. This must be a string
|
||||
/// literal. The power of the formatting string is in the `{}`s contained.
|
||||
///
|
||||
/// Additional parameters passed to `format!` replace the `{}`s within the
|
||||
/// formatting string in the order given unless named or positional parameters
|
||||
/// are used, see [`std::fmt`][fmt] for more information.
|
||||
/// are used; see [`std::fmt`][fmt] for more information.
|
||||
///
|
||||
/// A common use for `format!` is concatenation and interpolation of strings.
|
||||
/// The same convention is used with [`print!`] and [`write!`] macros,
|
||||
/// depending on the intended destination of the string.
|
||||
///
|
||||
/// To convert a single value to a string, use the [`to_string`] method. This
|
||||
/// To convert a single value to a string, use the [`to_string`] method. This
|
||||
/// will use the [`Display`] formatting trait.
|
||||
///
|
||||
/// [fmt]: ../std/fmt/index.html
|
||||
|
||||
@ -335,7 +335,7 @@ impl<T, A: Alloc> RawVec<T, A> {
|
||||
/// enough to want to do that it's easiest to just have a dedicated method. Slightly
|
||||
/// more efficient logic can be provided for this than the general case.
|
||||
///
|
||||
/// Returns true if the reallocation attempt has succeeded, or false otherwise.
|
||||
/// Returns `true` if the reallocation attempt has succeeded.
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
@ -504,7 +504,7 @@ impl<T, A: Alloc> RawVec<T, A> {
|
||||
/// the requested space. This is not really unsafe, but the unsafe
|
||||
/// code *you* write that relies on the behavior of this function may break.
|
||||
///
|
||||
/// Returns true if the reallocation attempt has succeeded, or false otherwise.
|
||||
/// Returns `true` if the reallocation attempt has succeeded.
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
|
||||
@ -512,7 +512,7 @@ impl<T: ?Sized> Rc<T> {
|
||||
this.strong()
|
||||
}
|
||||
|
||||
/// Returns true if there are no other `Rc` or [`Weak`][weak] pointers to
|
||||
/// Returns `true` if there are no other `Rc` or [`Weak`][weak] pointers to
|
||||
/// this inner value.
|
||||
///
|
||||
/// [weak]: struct.Weak.html
|
||||
@ -561,7 +561,7 @@ impl<T: ?Sized> Rc<T> {
|
||||
|
||||
#[inline]
|
||||
#[stable(feature = "ptr_eq", since = "1.17.0")]
|
||||
/// Returns true if the two `Rc`s point to the same value (not
|
||||
/// Returns `true` if the two `Rc`s point to the same value (not
|
||||
/// just values that compare as equal).
|
||||
///
|
||||
/// # Examples
|
||||
@ -1334,8 +1334,8 @@ impl<T: ?Sized> Weak<T> {
|
||||
})
|
||||
}
|
||||
|
||||
/// Return `None` when the pointer is dangling and there is no allocated `RcBox`,
|
||||
/// i.e., this `Weak` was created by `Weak::new`
|
||||
/// Returns `None` when the pointer is dangling and there is no allocated `RcBox`
|
||||
/// (i.e., when this `Weak` was created by `Weak::new`).
|
||||
#[inline]
|
||||
fn inner(&self) -> Option<&RcBox<T>> {
|
||||
if is_dangling(self.ptr) {
|
||||
@ -1345,7 +1345,7 @@ impl<T: ?Sized> Weak<T> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if the two `Weak`s point to the same value (not just values
|
||||
/// Returns `true` if the two `Weak`s point to the same value (not just values
|
||||
/// that compare as equal).
|
||||
///
|
||||
/// # Notes
|
||||
|
||||
@ -205,10 +205,10 @@ impl<T> [T] {
|
||||
///
|
||||
/// The comparator function must define a total ordering for the elements in the slice. If
|
||||
/// the ordering is not total, the order of the elements is unspecified. An order is a
|
||||
/// total order if it is (for all a, b and c):
|
||||
/// total order if it is (for all `a`, `b` and `c`):
|
||||
///
|
||||
/// * total and antisymmetric: exactly one of a < b, a == b or a > b is true; and
|
||||
/// * transitive, a < b and b < c implies a < c. The same must hold for both == and >.
|
||||
/// * total and antisymmetric: exactly one of `a < b`, `a == b` or `a > b` is true, and
|
||||
/// * transitive, `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`.
|
||||
///
|
||||
/// For example, while [`f64`] doesn't implement [`Ord`] because `NaN != NaN`, we can use
|
||||
/// `partial_cmp` as our sort function when we know the slice doesn't contain a `NaN`.
|
||||
|
||||
@ -29,8 +29,6 @@
|
||||
#![allow(unused_imports)]
|
||||
|
||||
use core::borrow::Borrow;
|
||||
use core::fmt;
|
||||
use core::str as core_str;
|
||||
use core::str::pattern::{Pattern, Searcher, ReverseSearcher, DoubleEndedSearcher};
|
||||
use core::mem;
|
||||
use core::ptr;
|
||||
@ -443,45 +441,6 @@ impl str {
|
||||
return s;
|
||||
}
|
||||
|
||||
/// Escapes each char in `s` with [`char::escape_debug`].
|
||||
///
|
||||
/// Note: only extended grapheme codepoints that begin the string will be
|
||||
/// escaped.
|
||||
///
|
||||
/// [`char::escape_debug`]: primitive.char.html#method.escape_debug
|
||||
#[unstable(feature = "str_escape",
|
||||
reason = "return type may change to be an iterator",
|
||||
issue = "27791")]
|
||||
pub fn escape_debug(&self) -> String {
|
||||
let mut string = String::with_capacity(self.len());
|
||||
let mut chars = self.chars();
|
||||
if let Some(first) = chars.next() {
|
||||
string.extend(first.escape_debug_ext(true))
|
||||
}
|
||||
string.extend(chars.flat_map(|c| c.escape_debug_ext(false)));
|
||||
string
|
||||
}
|
||||
|
||||
/// Escapes each char in `s` with [`char::escape_default`].
|
||||
///
|
||||
/// [`char::escape_default`]: primitive.char.html#method.escape_default
|
||||
#[unstable(feature = "str_escape",
|
||||
reason = "return type may change to be an iterator",
|
||||
issue = "27791")]
|
||||
pub fn escape_default(&self) -> String {
|
||||
self.chars().flat_map(|c| c.escape_default()).collect()
|
||||
}
|
||||
|
||||
/// Escapes each char in `s` with [`char::escape_unicode`].
|
||||
///
|
||||
/// [`char::escape_unicode`]: primitive.char.html#method.escape_unicode
|
||||
#[unstable(feature = "str_escape",
|
||||
reason = "return type may change to be an iterator",
|
||||
issue = "27791")]
|
||||
pub fn escape_unicode(&self) -> String {
|
||||
self.chars().flat_map(|c| c.escape_unicode()).collect()
|
||||
}
|
||||
|
||||
/// Converts a [`Box<str>`] into a [`String`] without copying or allocating.
|
||||
///
|
||||
/// [`String`]: string/struct.String.html
|
||||
@ -612,3 +571,4 @@ impl str {
|
||||
pub unsafe fn from_boxed_utf8_unchecked(v: Box<[u8]>) -> Box<str> {
|
||||
Box::from_raw(Box::into_raw(v) as *mut str)
|
||||
}
|
||||
|
||||
|
||||
@ -963,7 +963,7 @@ impl String {
|
||||
/// Does nothing if the capacity is already sufficient.
|
||||
///
|
||||
/// Note that the allocator may give the collection more space than it
|
||||
/// requests. Therefore capacity can not be relied upon to be precisely
|
||||
/// requests. Therefore, capacity can not be relied upon to be precisely
|
||||
/// minimal. Prefer `reserve` if future insertions are expected.
|
||||
///
|
||||
/// # Errors
|
||||
@ -1377,9 +1377,7 @@ impl String {
|
||||
self.vec.len()
|
||||
}
|
||||
|
||||
/// Returns `true` if this `String` has a length of zero.
|
||||
///
|
||||
/// Returns `false` otherwise.
|
||||
/// Returns `true` if this `String` has a length of zero, and `false` otherwise.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
|
||||
@ -560,7 +560,7 @@ impl<T: ?Sized> Arc<T> {
|
||||
|
||||
#[inline]
|
||||
#[stable(feature = "ptr_eq", since = "1.17.0")]
|
||||
/// Returns true if the two `Arc`s point to the same value (not
|
||||
/// Returns `true` if the two `Arc`s point to the same value (not
|
||||
/// just values that compare as equal).
|
||||
///
|
||||
/// # Examples
|
||||
@ -1191,8 +1191,8 @@ impl<T: ?Sized> Weak<T> {
|
||||
})
|
||||
}
|
||||
|
||||
/// Return `None` when the pointer is dangling and there is no allocated `ArcInner`,
|
||||
/// i.e., this `Weak` was created by `Weak::new`
|
||||
/// Returns `None` when the pointer is dangling and there is no allocated `ArcInner`,
|
||||
/// (i.e., when this `Weak` was created by `Weak::new`).
|
||||
#[inline]
|
||||
fn inner(&self) -> Option<&ArcInner<T>> {
|
||||
if is_dangling(self.ptr) {
|
||||
@ -1202,7 +1202,7 @@ impl<T: ?Sized> Weak<T> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if the two `Weak`s point to the same value (not just values
|
||||
/// Returns `true` if the two `Weak`s point to the same value (not just values
|
||||
/// that compare as equal).
|
||||
///
|
||||
/// # Notes
|
||||
|
||||
@ -1,3 +1,5 @@
|
||||
#![cfg(not(miri))]
|
||||
|
||||
use std::any::Any;
|
||||
use std::sync::{Arc, Weak};
|
||||
use std::cell::RefCell;
|
||||
|
||||
@ -282,6 +282,7 @@ fn assert_covariance() {
|
||||
//
|
||||
// Destructors must be called exactly once per element.
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn panic_safe() {
|
||||
static DROP_COUNTER: AtomicUsize = AtomicUsize::new(0);
|
||||
|
||||
|
||||
@ -1,3 +1,5 @@
|
||||
#![cfg(not(miri))]
|
||||
|
||||
mod map;
|
||||
mod set;
|
||||
|
||||
|
||||
@ -1,6 +1,8 @@
|
||||
#![cfg(not(miri))]
|
||||
|
||||
use std::alloc::{Global, Alloc, Layout, System};
|
||||
|
||||
/// https://github.com/rust-lang/rust/issues/45955
|
||||
/// Issue #45955.
|
||||
#[test]
|
||||
fn alloc_system_overaligned_request() {
|
||||
check_overalign_requests(System)
|
||||
|
||||
@ -5,7 +5,6 @@
|
||||
#![feature(pattern)]
|
||||
#![feature(repeat_generic_slice)]
|
||||
#![feature(slice_sort_by_cached_key)]
|
||||
#![feature(str_escape)]
|
||||
#![feature(try_reserve)]
|
||||
#![feature(unboxed_closures)]
|
||||
#![feature(vecdeque_rotate)]
|
||||
|
||||
@ -1,3 +1,5 @@
|
||||
#![cfg(not(miri))]
|
||||
|
||||
use std::any::Any;
|
||||
use std::rc::{Rc, Weak};
|
||||
use std::cell::RefCell;
|
||||
|
||||
@ -1,3 +1,5 @@
|
||||
#![cfg(not(miri))]
|
||||
|
||||
use std::cell::Cell;
|
||||
use std::cmp::Ordering::{self, Equal, Greater, Less};
|
||||
use std::mem;
|
||||
|
||||
@ -31,6 +31,7 @@ fn test_rfind() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_collect() {
|
||||
let empty = "";
|
||||
let s: String = empty.chars().collect();
|
||||
@ -118,6 +119,7 @@ fn test_concat_for_different_types() {
|
||||
#[test]
|
||||
fn test_concat_for_different_lengths() {
|
||||
let empty: &[&str] = &[];
|
||||
#[cfg(not(miri))]
|
||||
test_concat!("", empty);
|
||||
test_concat!("a", ["a"]);
|
||||
test_concat!("ab", ["a", "b"]);
|
||||
@ -146,6 +148,7 @@ fn test_join_for_different_types() {
|
||||
#[test]
|
||||
fn test_join_for_different_lengths() {
|
||||
let empty: &[&str] = &[];
|
||||
#[cfg(not(miri))]
|
||||
test_join!("", empty, "-");
|
||||
test_join!("a", ["a"], "-");
|
||||
test_join!("a-b", ["a", "b"], "-");
|
||||
@ -159,6 +162,7 @@ fn test_join_for_different_lengths_with_long_separator() {
|
||||
assert_eq!("～～～～～".len(), 15);
|
||||
|
||||
let empty: &[&str] = &[];
|
||||
#[cfg(not(miri))]
|
||||
test_join!("", empty, "～～～～～");
|
||||
test_join!("a", ["a"], "～～～～～");
|
||||
test_join!("a～～～～～b", ["a", "b"], "～～～～～");
|
||||
@ -166,6 +170,7 @@ fn test_join_for_different_lengths_with_long_separator() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_unsafe_slice() {
|
||||
assert_eq!("ab", unsafe {"abc".get_unchecked(0..2)});
|
||||
assert_eq!("bc", unsafe {"abc".get_unchecked(1..3)});
|
||||
@ -238,6 +243,7 @@ fn test_replacen() {
|
||||
#[test]
|
||||
fn test_replace() {
|
||||
let a = "a";
|
||||
#[cfg(not(miri))]
|
||||
assert_eq!("".replace(a, "b"), "");
|
||||
assert_eq!("a".replace(a, "b"), "b");
|
||||
assert_eq!("ab".replace(a, "b"), "bb");
|
||||
@ -297,6 +303,7 @@ fn test_replace_pattern() {
|
||||
// The current implementation of SliceIndex fails to handle methods
|
||||
// orthogonally from range types; therefore, it is worth testing
|
||||
// all of the indexing operations on each input.
|
||||
#[cfg(not(miri))]
|
||||
mod slice_index {
|
||||
// Test a slicing operation **that should succeed,**
|
||||
// testing it on all of the indexing methods.
|
||||
@ -679,6 +686,7 @@ fn test_str_slice_rangetoinclusive_ok() {
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
#[cfg(not(miri))]
|
||||
fn test_str_slice_rangetoinclusive_notok() {
|
||||
let s = "abcαβγ";
|
||||
&s[..=3];
|
||||
@ -694,6 +702,7 @@ fn test_str_slicemut_rangetoinclusive_ok() {
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
#[cfg(not(miri))]
|
||||
fn test_str_slicemut_rangetoinclusive_notok() {
|
||||
let mut s = "abcαβγ".to_owned();
|
||||
let s: &mut str = &mut s;
|
||||
@ -883,6 +892,7 @@ fn test_as_bytes() {
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
#[cfg(not(miri))]
|
||||
fn test_as_bytes_fail() {
|
||||
// Don't double free. (I'm not sure if this exercises the
|
||||
// original problem code path anymore.)
|
||||
@ -972,6 +982,7 @@ fn test_split_at_mut() {
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
#[cfg(not(miri))]
|
||||
fn test_split_at_boundscheck() {
|
||||
let s = "ศไทย中华Việt Nam";
|
||||
s.split_at(1);
|
||||
@ -979,15 +990,15 @@ fn test_split_at_boundscheck() {
|
||||
|
||||
#[test]
|
||||
fn test_escape_unicode() {
|
||||
assert_eq!("abc".escape_unicode(), "\\u{61}\\u{62}\\u{63}");
|
||||
assert_eq!("a c".escape_unicode(), "\\u{61}\\u{20}\\u{63}");
|
||||
assert_eq!("\r\n\t".escape_unicode(), "\\u{d}\\u{a}\\u{9}");
|
||||
assert_eq!("'\"\\".escape_unicode(), "\\u{27}\\u{22}\\u{5c}");
|
||||
assert_eq!("\x00\x01\u{fe}\u{ff}".escape_unicode(), "\\u{0}\\u{1}\\u{fe}\\u{ff}");
|
||||
assert_eq!("\u{100}\u{ffff}".escape_unicode(), "\\u{100}\\u{ffff}");
|
||||
assert_eq!("\u{10000}\u{10ffff}".escape_unicode(), "\\u{10000}\\u{10ffff}");
|
||||
assert_eq!("ab\u{fb00}".escape_unicode(), "\\u{61}\\u{62}\\u{fb00}");
|
||||
assert_eq!("\u{1d4ea}\r".escape_unicode(), "\\u{1d4ea}\\u{d}");
|
||||
assert_eq!("abc".escape_unicode().to_string(), "\\u{61}\\u{62}\\u{63}");
|
||||
assert_eq!("a c".escape_unicode().to_string(), "\\u{61}\\u{20}\\u{63}");
|
||||
assert_eq!("\r\n\t".escape_unicode().to_string(), "\\u{d}\\u{a}\\u{9}");
|
||||
assert_eq!("'\"\\".escape_unicode().to_string(), "\\u{27}\\u{22}\\u{5c}");
|
||||
assert_eq!("\x00\x01\u{fe}\u{ff}".escape_unicode().to_string(), "\\u{0}\\u{1}\\u{fe}\\u{ff}");
|
||||
assert_eq!("\u{100}\u{ffff}".escape_unicode().to_string(), "\\u{100}\\u{ffff}");
|
||||
assert_eq!("\u{10000}\u{10ffff}".escape_unicode().to_string(), "\\u{10000}\\u{10ffff}");
|
||||
assert_eq!("ab\u{fb00}".escape_unicode().to_string(), "\\u{61}\\u{62}\\u{fb00}");
|
||||
assert_eq!("\u{1d4ea}\r".escape_unicode().to_string(), "\\u{1d4ea}\\u{d}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -998,31 +1009,32 @@ fn test_escape_debug() {
|
||||
// they are escaped. However, when the character is unescaped (e.g., for
|
||||
// printable characters), only a single backslash appears (as the character
|
||||
// itself appears in the debug string).
|
||||
assert_eq!("abc".escape_debug(), "abc");
|
||||
assert_eq!("a c".escape_debug(), "a c");
|
||||
assert_eq!("éèê".escape_debug(), "éèê");
|
||||
assert_eq!("\r\n\t".escape_debug(), "\\r\\n\\t");
|
||||
assert_eq!("'\"\\".escape_debug(), "\\'\\\"\\\\");
|
||||
assert_eq!("\u{7f}\u{ff}".escape_debug(), "\\u{7f}\u{ff}");
|
||||
assert_eq!("\u{100}\u{ffff}".escape_debug(), "\u{100}\\u{ffff}");
|
||||
assert_eq!("\u{10000}\u{10ffff}".escape_debug(), "\u{10000}\\u{10ffff}");
|
||||
assert_eq!("ab\u{200b}".escape_debug(), "ab\\u{200b}");
|
||||
assert_eq!("\u{10d4ea}\r".escape_debug(), "\\u{10d4ea}\\r");
|
||||
assert_eq!("\u{301}a\u{301}bé\u{e000}".escape_debug(), "\\u{301}a\u{301}bé\\u{e000}");
|
||||
assert_eq!("abc".escape_debug().to_string(), "abc");
|
||||
assert_eq!("a c".escape_debug().to_string(), "a c");
|
||||
assert_eq!("éèê".escape_debug().to_string(), "éèê");
|
||||
assert_eq!("\r\n\t".escape_debug().to_string(), "\\r\\n\\t");
|
||||
assert_eq!("'\"\\".escape_debug().to_string(), "\\'\\\"\\\\");
|
||||
assert_eq!("\u{7f}\u{ff}".escape_debug().to_string(), "\\u{7f}\u{ff}");
|
||||
assert_eq!("\u{100}\u{ffff}".escape_debug().to_string(), "\u{100}\\u{ffff}");
|
||||
assert_eq!("\u{10000}\u{10ffff}".escape_debug().to_string(), "\u{10000}\\u{10ffff}");
|
||||
assert_eq!("ab\u{200b}".escape_debug().to_string(), "ab\\u{200b}");
|
||||
assert_eq!("\u{10d4ea}\r".escape_debug().to_string(), "\\u{10d4ea}\\r");
|
||||
assert_eq!("\u{301}a\u{301}bé\u{e000}".escape_debug().to_string(),
|
||||
"\\u{301}a\u{301}bé\\u{e000}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_escape_default() {
|
||||
assert_eq!("abc".escape_default(), "abc");
|
||||
assert_eq!("a c".escape_default(), "a c");
|
||||
assert_eq!("éèê".escape_default(), "\\u{e9}\\u{e8}\\u{ea}");
|
||||
assert_eq!("\r\n\t".escape_default(), "\\r\\n\\t");
|
||||
assert_eq!("'\"\\".escape_default(), "\\'\\\"\\\\");
|
||||
assert_eq!("\u{7f}\u{ff}".escape_default(), "\\u{7f}\\u{ff}");
|
||||
assert_eq!("\u{100}\u{ffff}".escape_default(), "\\u{100}\\u{ffff}");
|
||||
assert_eq!("\u{10000}\u{10ffff}".escape_default(), "\\u{10000}\\u{10ffff}");
|
||||
assert_eq!("ab\u{200b}".escape_default(), "ab\\u{200b}");
|
||||
assert_eq!("\u{10d4ea}\r".escape_default(), "\\u{10d4ea}\\r");
|
||||
assert_eq!("abc".escape_default().to_string(), "abc");
|
||||
assert_eq!("a c".escape_default().to_string(), "a c");
|
||||
assert_eq!("éèê".escape_default().to_string(), "\\u{e9}\\u{e8}\\u{ea}");
|
||||
assert_eq!("\r\n\t".escape_default().to_string(), "\\r\\n\\t");
|
||||
assert_eq!("'\"\\".escape_default().to_string(), "\\'\\\"\\\\");
|
||||
assert_eq!("\u{7f}\u{ff}".escape_default().to_string(), "\\u{7f}\\u{ff}");
|
||||
assert_eq!("\u{100}\u{ffff}".escape_default().to_string(), "\\u{100}\\u{ffff}");
|
||||
assert_eq!("\u{10000}\u{10ffff}".escape_default().to_string(), "\\u{10000}\\u{10ffff}");
|
||||
assert_eq!("ab\u{200b}".escape_default().to_string(), "ab\\u{200b}");
|
||||
assert_eq!("\u{10d4ea}\r".escape_default().to_string(), "\\u{10d4ea}\\r");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -1066,6 +1078,7 @@ fn test_rev_iterator() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_chars_decoding() {
|
||||
let mut bytes = [0; 4];
|
||||
for c in (0..0x110000).filter_map(std::char::from_u32) {
|
||||
@ -1077,6 +1090,7 @@ fn test_chars_decoding() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_chars_rev_decoding() {
|
||||
let mut bytes = [0; 4];
|
||||
for c in (0..0x110000).filter_map(std::char::from_u32) {
|
||||
@ -1306,6 +1320,7 @@ fn test_splitator() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_str_default() {
|
||||
use std::default::Default;
|
||||
|
||||
@ -1365,6 +1380,7 @@ fn test_bool_from_str() {
|
||||
assert_eq!("not even a boolean".parse::<bool>().ok(), None);
|
||||
}
|
||||
|
||||
#[cfg(not(miri))]
|
||||
fn check_contains_all_substrings(s: &str) {
|
||||
assert!(s.contains(""));
|
||||
for i in 0..s.len() {
|
||||
@ -1375,6 +1391,7 @@ fn check_contains_all_substrings(s: &str) {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn strslice_issue_16589() {
|
||||
assert!("bananas".contains("nana"));
|
||||
|
||||
@ -1384,6 +1401,7 @@ fn strslice_issue_16589() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn strslice_issue_16878() {
|
||||
assert!(!"1234567ah012345678901ah".contains("hah"));
|
||||
assert!(!"00abc01234567890123456789abc".contains("bcabc"));
|
||||
@ -1391,6 +1409,7 @@ fn strslice_issue_16878() {
|
||||
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_strslice_contains() {
|
||||
let x = "There are moments, Jeeves, when one asks oneself, 'Do trousers matter?'";
|
||||
check_contains_all_substrings(x);
|
||||
@ -1528,6 +1547,7 @@ fn trim_ws() {
|
||||
|
||||
#[test]
|
||||
fn to_lowercase() {
|
||||
#[cfg(not(miri))]
|
||||
assert_eq!("".to_lowercase(), "");
|
||||
assert_eq!("AÉDžaé ".to_lowercase(), "aédžaé ");
|
||||
|
||||
@ -1561,6 +1581,7 @@ fn to_lowercase() {
|
||||
|
||||
#[test]
|
||||
fn to_uppercase() {
|
||||
#[cfg(not(miri))]
|
||||
assert_eq!("".to_uppercase(), "");
|
||||
assert_eq!("aéDžßfiᾀ".to_uppercase(), "AÉDŽSSFIἈΙ");
|
||||
}
|
||||
@ -1592,6 +1613,7 @@ fn test_cow_from() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_repeat() {
|
||||
assert_eq!("".repeat(3), "");
|
||||
assert_eq!("abc".repeat(0), "");
|
||||
|
||||
@ -1,3 +1,5 @@
|
||||
#![cfg(not(miri))]
|
||||
|
||||
use std::borrow::Cow;
|
||||
use std::collections::CollectionAllocErr::*;
|
||||
use std::mem::size_of;
|
||||
|
||||
@ -1,3 +1,5 @@
|
||||
#![cfg(not(miri))]
|
||||
|
||||
use std::borrow::Cow;
|
||||
use std::mem::size_of;
|
||||
use std::{usize, isize};
|
||||
|
||||
@ -108,6 +108,7 @@ fn test_index() {
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
#[cfg(not(miri))]
|
||||
fn test_index_out_of_bounds() {
|
||||
let mut deq = VecDeque::new();
|
||||
for i in 1..4 {
|
||||
@ -906,20 +907,24 @@ fn test_append() {
|
||||
// normal append
|
||||
a.append(&mut b);
|
||||
assert_eq!(a.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
|
||||
#[cfg(not(miri))]
|
||||
assert_eq!(b.iter().cloned().collect::<Vec<_>>(), []);
|
||||
|
||||
// append nothing to something
|
||||
a.append(&mut b);
|
||||
assert_eq!(a.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
|
||||
#[cfg(not(miri))]
|
||||
assert_eq!(b.iter().cloned().collect::<Vec<_>>(), []);
|
||||
|
||||
// append something to nothing
|
||||
b.append(&mut a);
|
||||
assert_eq!(b.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
|
||||
#[cfg(not(miri))]
|
||||
assert_eq!(a.iter().cloned().collect::<Vec<_>>(), []);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_append_permutations() {
|
||||
fn construct_vec_deque(
|
||||
push_back: usize,
|
||||
@ -1120,6 +1125,7 @@ fn test_reserve_exact_2() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_try_reserve() {
|
||||
|
||||
// These are the interesting cases:
|
||||
@ -1221,6 +1227,7 @@ fn test_try_reserve() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_try_reserve_exact() {
|
||||
|
||||
// This is exactly the same as test_try_reserve with the method changed.
|
||||
|
||||
@ -463,7 +463,7 @@ impl<T> Vec<T> {
|
||||
/// Does nothing if the capacity is already sufficient.
|
||||
///
|
||||
/// Note that the allocator may give the collection more space than it
|
||||
/// requests. Therefore capacity can not be relied upon to be precisely
|
||||
/// requests. Therefore, capacity can not be relied upon to be precisely
|
||||
/// minimal. Prefer `reserve` if future insertions are expected.
|
||||
///
|
||||
/// # Panics
|
||||
@ -525,7 +525,7 @@ impl<T> Vec<T> {
|
||||
/// Does nothing if the capacity is already sufficient.
|
||||
///
|
||||
/// Note that the allocator may give the collection more space than it
|
||||
/// requests. Therefore capacity can not be relied upon to be precisely
|
||||
/// requests. Therefore, capacity can not be relied upon to be precisely
|
||||
/// minimal. Prefer `reserve` if future insertions are expected.
|
||||
///
|
||||
/// # Errors
|
||||
@ -738,7 +738,7 @@ impl<T> Vec<T> {
|
||||
/// Forces the length of the vector to `new_len`.
|
||||
///
|
||||
/// This is a low-level operation that maintains none of the normal
|
||||
/// invariants of the type. Normally changing the length of a vector
|
||||
/// invariants of the type. Normally changing the length of a vector
|
||||
/// is done using one of the safe operations instead, such as
|
||||
/// [`truncate`], [`resize`], [`extend`], or [`clear`].
|
||||
///
|
||||
@ -2608,7 +2608,7 @@ impl<T> Drain<'_, T> {
|
||||
/// The range from `self.vec.len` to `self.tail_start` contains elements
|
||||
/// that have been moved out.
|
||||
/// Fill that range as much as possible with new elements from the `replace_with` iterator.
|
||||
/// Return whether we filled the entire range. (`replace_with.next()` didn’t return `None`.)
|
||||
/// Returns `true` if we filled the entire range. (`replace_with.next()` didn’t return `None`.)
|
||||
unsafe fn fill<I: Iterator<Item=T>>(&mut self, replace_with: &mut I) -> bool {
|
||||
let vec = self.vec.as_mut();
|
||||
let range_start = vec.len;
|
||||
@ -2628,7 +2628,7 @@ impl<T> Drain<'_, T> {
|
||||
true
|
||||
}
|
||||
|
||||
/// Make room for inserting more elements before the tail.
|
||||
/// Makes room for inserting more elements before the tail.
|
||||
unsafe fn move_tail(&mut self, extra_capacity: usize) {
|
||||
let vec = self.vec.as_mut();
|
||||
let used_capacity = self.tail_start + self.tail_len;
|
||||
|
||||
@ -2,6 +2,7 @@
|
||||
authors = ["The Rust Project Developers"]
|
||||
name = "arena"
|
||||
version = "0.0.0"
|
||||
edition = "2018"
|
||||
|
||||
[lib]
|
||||
name = "arena"
|
||||
@ -9,4 +10,4 @@ path = "lib.rs"
|
||||
crate-type = ["dylib"]
|
||||
|
||||
[dependencies]
|
||||
rustc_data_structures = { path = "../librustc_data_structures" }
|
||||
rustc_data_structures = { path = "../librustc_data_structures" }
|
||||
|
||||
@ -8,22 +8,20 @@
|
||||
//! This crate implements `TypedArena`, a simple arena that can only hold
|
||||
//! objects of a single type.
|
||||
|
||||
#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
|
||||
html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
|
||||
html_root_url = "https://doc.rust-lang.org/nightly/",
|
||||
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/",
|
||||
test(no_crate_inject, attr(deny(warnings))))]
|
||||
|
||||
#![deny(rust_2018_idioms)]
|
||||
|
||||
#![feature(alloc)]
|
||||
#![feature(core_intrinsics)]
|
||||
#![feature(dropck_eyepatch)]
|
||||
#![feature(nll)]
|
||||
#![feature(raw_vec_internals)]
|
||||
#![cfg_attr(test, feature(test))]
|
||||
|
||||
#![allow(deprecated)]
|
||||
|
||||
extern crate alloc;
|
||||
extern crate rustc_data_structures;
|
||||
|
||||
use rustc_data_structures::sync::MTLock;
|
||||
|
||||
@ -478,7 +476,7 @@ impl SyncDroplessArena {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
extern crate test;
|
||||
use self::test::Bencher;
|
||||
use test::Bencher;
|
||||
use super::TypedArena;
|
||||
use std::cell::Cell;
|
||||
|
||||
@ -513,15 +511,15 @@ mod tests {
|
||||
|
||||
impl<'a> Wrap<'a> {
|
||||
fn alloc_inner<F: Fn() -> Inner>(&self, f: F) -> &Inner {
|
||||
let r: &EI = self.0.alloc(EI::I(f()));
|
||||
let r: &EI<'_> = self.0.alloc(EI::I(f()));
|
||||
if let &EI::I(ref i) = r {
|
||||
i
|
||||
} else {
|
||||
panic!("mismatch");
|
||||
}
|
||||
}
|
||||
fn alloc_outer<F: Fn() -> Outer<'a>>(&self, f: F) -> &Outer {
|
||||
let r: &EI = self.0.alloc(EI::O(f()));
|
||||
fn alloc_outer<F: Fn() -> Outer<'a>>(&self, f: F) -> &Outer<'_> {
|
||||
let r: &EI<'_> = self.0.alloc(EI::O(f()));
|
||||
if let &EI::O(ref o) = r {
|
||||
o
|
||||
} else {
|
||||
@ -611,7 +609,7 @@ mod tests {
|
||||
count: &'a Cell<u32>,
|
||||
}
|
||||
|
||||
impl<'a> Drop for DropCounter<'a> {
|
||||
impl Drop for DropCounter<'_> {
|
||||
fn drop(&mut self) {
|
||||
self.count.set(self.count.get() + 1);
|
||||
}
|
||||
@ -621,7 +619,7 @@ mod tests {
|
||||
fn test_typed_arena_drop_count() {
|
||||
let counter = Cell::new(0);
|
||||
{
|
||||
let arena: TypedArena<DropCounter> = TypedArena::default();
|
||||
let arena: TypedArena<DropCounter<'_>> = TypedArena::default();
|
||||
for _ in 0..100 {
|
||||
// Allocate something with drop glue to make sure it doesn't leak.
|
||||
arena.alloc(DropCounter { count: &counter });
|
||||
@ -633,7 +631,7 @@ mod tests {
|
||||
#[test]
|
||||
fn test_typed_arena_drop_on_clear() {
|
||||
let counter = Cell::new(0);
|
||||
let mut arena: TypedArena<DropCounter> = TypedArena::default();
|
||||
let mut arena: TypedArena<DropCounter<'_>> = TypedArena::default();
|
||||
for i in 0..10 {
|
||||
for _ in 0..100 {
|
||||
// Allocate something with drop glue to make sure it doesn't leak.
|
||||
|
||||
@ -425,7 +425,7 @@ impl fmt::Display for CannotReallocInPlace {
|
||||
/// The `GlobalAlloc` trait is an `unsafe` trait for a number of reasons, and
|
||||
/// implementors must ensure that they adhere to these contracts:
|
||||
///
|
||||
/// * It's undefined behavior if global allocators unwind. This restriction may
|
||||
/// * It's undefined behavior if global allocators unwind. This restriction may
|
||||
/// be lifted in the future, but currently a panic from any of these
|
||||
/// functions may lead to memory unsafety.
|
||||
///
|
||||
|
||||
@ -18,7 +18,7 @@
|
||||
//!
|
||||
//! Consider a situation where we want to log out a value passed to a function.
|
||||
//! We know the value we're working on implements Debug, but we don't know its
|
||||
//! concrete type. We want to give special treatment to certain types: in this
|
||||
//! concrete type. We want to give special treatment to certain types: in this
|
||||
//! case printing out the length of String values prior to their value.
|
||||
//! We don't know the concrete type of our value at compile time, so we need to
|
||||
//! use runtime reflection instead.
|
||||
@ -31,8 +31,8 @@
|
||||
//! fn log<T: Any + Debug>(value: &T) {
|
||||
//! let value_any = value as &dyn Any;
|
||||
//!
|
||||
//! // try to convert our value to a String. If successful, we want to
|
||||
//! // output the String's length as well as its value. If not, it's a
|
||||
//! // Try to convert our value to a `String`. If successful, we want to
|
||||
//! // output the String`'s length as well as its value. If not, it's a
|
||||
//! // different type: just print it out unadorned.
|
||||
//! match value_any.downcast_ref::<String>() {
|
||||
//! Some(as_string) => {
|
||||
|
||||
@ -130,7 +130,7 @@
|
||||
//!
|
||||
//! This is simply a special - but common - case of the previous: hiding mutability for operations
|
||||
//! that appear to be immutable. The `clone` method is expected to not change the source value, and
|
||||
//! is declared to take `&self`, not `&mut self`. Therefore any mutation that happens in the
|
||||
//! is declared to take `&self`, not `&mut self`. Therefore, any mutation that happens in the
|
||||
//! `clone` method must use cell types. For example, `Rc<T>` maintains its reference counts within a
|
||||
//! `Cell<T>`.
|
||||
//!
|
||||
@ -1133,7 +1133,7 @@ impl<'b, T: ?Sized> Ref<'b, T> {
|
||||
/// The `RefCell` is already immutably borrowed, so this cannot fail.
|
||||
///
|
||||
/// This is an associated function that needs to be used as
|
||||
/// `Ref::clone(...)`. A `Clone` implementation or a method would interfere
|
||||
/// `Ref::clone(...)`. A `Clone` implementation or a method would interfere
|
||||
/// with the widespread use of `r.borrow().clone()` to clone the contents of
|
||||
/// a `RefCell`.
|
||||
#[stable(feature = "cell_extras", since = "1.15.0")]
|
||||
@ -1145,7 +1145,7 @@ impl<'b, T: ?Sized> Ref<'b, T> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Make a new `Ref` for a component of the borrowed data.
|
||||
/// Makes a new `Ref` for a component of the borrowed data.
|
||||
///
|
||||
/// The `RefCell` is already immutably borrowed, so this cannot fail.
|
||||
///
|
||||
@ -1174,7 +1174,7 @@ impl<'b, T: ?Sized> Ref<'b, T> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Split a `Ref` into multiple `Ref`s for different components of the
|
||||
/// Splits a `Ref` into multiple `Ref`s for different components of the
|
||||
/// borrowed data.
|
||||
///
|
||||
/// The `RefCell` is already immutably borrowed, so this cannot fail.
|
||||
@ -1217,13 +1217,13 @@ impl<T: ?Sized + fmt::Display> fmt::Display for Ref<'_, T> {
|
||||
}
|
||||
|
||||
impl<'b, T: ?Sized> RefMut<'b, T> {
|
||||
/// Make a new `RefMut` for a component of the borrowed data, e.g., an enum
|
||||
/// Makes a new `RefMut` for a component of the borrowed data, e.g., an enum
|
||||
/// variant.
|
||||
///
|
||||
/// The `RefCell` is already mutably borrowed, so this cannot fail.
|
||||
///
|
||||
/// This is an associated function that needs to be used as
|
||||
/// `RefMut::map(...)`. A method would interfere with methods of the same
|
||||
/// `RefMut::map(...)`. A method would interfere with methods of the same
|
||||
/// name on the contents of a `RefCell` used through `Deref`.
|
||||
///
|
||||
/// # Examples
|
||||
@ -1253,7 +1253,7 @@ impl<'b, T: ?Sized> RefMut<'b, T> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Split a `RefMut` into multiple `RefMut`s for different components of the
|
||||
/// Splits a `RefMut` into multiple `RefMut`s for different components of the
|
||||
/// borrowed data.
|
||||
///
|
||||
/// The underlying `RefCell` will remain mutably borrowed until both
|
||||
@ -1416,7 +1416,7 @@ impl<T: ?Sized + fmt::Display> fmt::Display for RefMut<'_, T> {
|
||||
/// co-exist with it. A `&mut T` must always be unique.
|
||||
///
|
||||
/// Note that while mutating or mutably aliasing the contents of an `&UnsafeCell<T>` is
|
||||
/// okay (provided you enforce the invariants some other way), it is still undefined behavior
|
||||
/// ok (provided you enforce the invariants some other way), it is still undefined behavior
|
||||
/// to have multiple `&mut UnsafeCell<T>` aliases.
|
||||
///
|
||||
/// # Examples
|
||||
|
||||
@ -20,7 +20,7 @@ pub struct DecodeUtf16Error {
|
||||
code: u16,
|
||||
}
|
||||
|
||||
/// Create an iterator over the UTF-16 encoded code points in `iter`,
|
||||
/// Creates an iterator over the UTF-16 encoded code points in `iter`,
|
||||
/// returning unpaired surrogates as `Err`s.
|
||||
///
|
||||
/// # Examples
|
||||
|
||||
@ -189,10 +189,8 @@ impl char {
|
||||
/// An extended version of `escape_debug` that optionally permits escaping
|
||||
/// Extended Grapheme codepoints. This allows us to format characters like
|
||||
/// nonspacing marks better when they're at the start of a string.
|
||||
#[doc(hidden)]
|
||||
#[unstable(feature = "str_internals", issue = "0")]
|
||||
#[inline]
|
||||
pub fn escape_debug_ext(self, escape_grapheme_extended: bool) -> EscapeDebug {
|
||||
pub(crate) fn escape_debug_ext(self, escape_grapheme_extended: bool) -> EscapeDebug {
|
||||
let init_state = match self {
|
||||
'\t' => EscapeDefaultState::Backslash('t'),
|
||||
'\r' => EscapeDefaultState::Backslash('r'),
|
||||
@ -524,7 +522,7 @@ impl char {
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if this `char` is an alphabetic code point, and false if not.
|
||||
/// Returns `true` if this `char` is an alphabetic code point, and false if not.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
@ -548,7 +546,7 @@ impl char {
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if this `char` satisfies the 'XID_Start' Unicode property, and false
|
||||
/// Returns `true` if this `char` satisfies the 'XID_Start' Unicode property, and false
|
||||
/// otherwise.
|
||||
///
|
||||
/// 'XID_Start' is a Unicode Derived Property specified in
|
||||
@ -562,7 +560,7 @@ impl char {
|
||||
derived_property::XID_Start(self)
|
||||
}
|
||||
|
||||
/// Returns true if this `char` satisfies the 'XID_Continue' Unicode property, and false
|
||||
/// Returns `true` if this `char` satisfies the 'XID_Continue' Unicode property, and false
|
||||
/// otherwise.
|
||||
///
|
||||
/// 'XID_Continue' is a Unicode Derived Property specified in
|
||||
@ -576,7 +574,7 @@ impl char {
|
||||
derived_property::XID_Continue(self)
|
||||
}
|
||||
|
||||
/// Returns true if this `char` is lowercase, and false otherwise.
|
||||
/// Returns `true` if this `char` is lowercase.
|
||||
///
|
||||
/// 'Lowercase' is defined according to the terms of the Unicode Derived Core
|
||||
/// Property `Lowercase`.
|
||||
@ -604,7 +602,7 @@ impl char {
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if this `char` is uppercase, and false otherwise.
|
||||
/// Returns `true` if this `char` is uppercase.
|
||||
///
|
||||
/// 'Uppercase' is defined according to the terms of the Unicode Derived Core
|
||||
/// Property `Uppercase`.
|
||||
@ -632,7 +630,7 @@ impl char {
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if this `char` is whitespace, and false otherwise.
|
||||
/// Returns `true` if this `char` is whitespace.
|
||||
///
|
||||
/// 'Whitespace' is defined according to the terms of the Unicode Derived Core
|
||||
/// Property `White_Space`.
|
||||
@ -659,7 +657,7 @@ impl char {
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns true if this `char` is alphanumeric, and false otherwise.
|
||||
/// Returns `true` if this `char` is alphanumeric.
|
||||
///
|
||||
/// 'Alphanumeric'-ness is defined in terms of the Unicode General Categories
|
||||
/// 'Nd', 'Nl', 'No' and the Derived Core Property 'Alphabetic'.
|
||||
@ -684,7 +682,7 @@ impl char {
|
||||
self.is_alphabetic() || self.is_numeric()
|
||||
}
|
||||
|
||||
/// Returns true if this `char` is a control code point, and false otherwise.
|
||||
/// Returns `true` if this `char` is a control code point.
|
||||
///
|
||||
/// 'Control code point' is defined in terms of the Unicode General
|
||||
/// Category `Cc`.
|
||||
@ -704,7 +702,7 @@ impl char {
|
||||
general_category::Cc(self)
|
||||
}
|
||||
|
||||
/// Returns true if this `char` is an extended grapheme character, and false otherwise.
|
||||
/// Returns `true` if this `char` is an extended grapheme character.
|
||||
///
|
||||
/// 'Extended grapheme character' is defined in terms of the Unicode Shaping and Rendering
|
||||
/// Category `Grapheme_Extend`.
|
||||
@ -713,7 +711,7 @@ impl char {
|
||||
derived_property::Grapheme_Extend(self)
|
||||
}
|
||||
|
||||
/// Returns true if this `char` is numeric, and false otherwise.
|
||||
/// Returns `true` if this `char` is numeric.
|
||||
///
|
||||
/// 'Numeric'-ness is defined in terms of the Unicode General Categories
|
||||
/// 'Nd', 'Nl', 'No'.
|
||||
|
||||
@ -26,7 +26,7 @@ use self::Ordering::*;
|
||||
/// relations](http://en.wikipedia.org/wiki/Partial_equivalence_relation).
|
||||
///
|
||||
/// This trait allows for partial equality, for types that do not have a full
|
||||
/// equivalence relation. For example, in floating point numbers `NaN != NaN`,
|
||||
/// equivalence relation. For example, in floating point numbers `NaN != NaN`,
|
||||
/// so floating point types implement `PartialEq` but not `Eq`.
|
||||
///
|
||||
/// Formally, the equality must be (for all `a`, `b` and `c`):
|
||||
|
||||
@ -17,7 +17,10 @@
|
||||
//! [`TryFrom<T>`][`TryFrom`] rather than [`Into<U>`][`Into`] or [`TryInto<U>`][`TryInto`],
|
||||
//! as [`From`] and [`TryFrom`] provide greater flexibility and offer
|
||||
//! equivalent [`Into`] or [`TryInto`] implementations for free, thanks to a
|
||||
//! blanket implementation in the standard library.
|
||||
//! blanket implementation in the standard library. However, there are some cases
|
||||
//! where this is not possible, such as creating conversions into a type defined
|
||||
//! outside your library, so implementing [`Into`] instead of [`From`] is
|
||||
//! sometimes necessary.
|
||||
//!
|
||||
//! # Generic Implementations
|
||||
//!
|
||||
@ -217,7 +220,7 @@ pub trait AsMut<T: ?Sized> {
|
||||
///
|
||||
/// There is one exception to implementing `Into`, and it's kind of esoteric.
|
||||
/// If the destination type is not part of the current crate, and it uses a
|
||||
/// generic variable, then you can't implement `From` directly. For example,
|
||||
/// generic variable, then you can't implement `From` directly. For example,
|
||||
/// take this crate:
|
||||
///
|
||||
/// ```compile_fail
|
||||
|
||||
@ -54,7 +54,7 @@
|
||||
///
|
||||
/// ## How can I implement `Default`?
|
||||
///
|
||||
/// Provide an implementation for the `default()` method that returns the value of
|
||||
/// Provides an implementation for the `default()` method that returns the value of
|
||||
/// your type that should be the default:
|
||||
///
|
||||
/// ```
|
||||
|
||||
@ -184,7 +184,7 @@ impl<'a> VaList<'a> {
|
||||
va_arg(self)
|
||||
}
|
||||
|
||||
/// Copy the `va_list` at the current location.
|
||||
/// Copies the `va_list` at the current location.
|
||||
#[unstable(feature = "c_variadic",
|
||||
reason = "the `c_variadic` feature has not been properly tested on \
|
||||
all supported platforms",
|
||||
@ -213,7 +213,7 @@ extern "rust-intrinsic" {
|
||||
/// `va_copy`.
|
||||
fn va_end(ap: &mut VaList);
|
||||
|
||||
/// Copy the current location of arglist `src` to the arglist `dst`.
|
||||
/// Copies the current location of arglist `src` to the arglist `dst`.
|
||||
#[cfg(any(all(not(target_arch = "aarch64"), not(target_arch = "powerpc"),
|
||||
not(target_arch = "x86_64")),
|
||||
windows))]
|
||||
|
||||
@ -483,12 +483,12 @@ impl Display for Arguments<'_> {
|
||||
/// implementations, such as [`debug_struct`][debug_struct].
|
||||
///
|
||||
/// `Debug` implementations using either `derive` or the debug builder API
|
||||
/// on [`Formatter`] support pretty printing using the alternate flag: `{:#?}`.
|
||||
/// on [`Formatter`] support pretty-printing using the alternate flag: `{:#?}`.
|
||||
///
|
||||
/// [debug_struct]: ../../std/fmt/struct.Formatter.html#method.debug_struct
|
||||
/// [`Formatter`]: ../../std/fmt/struct.Formatter.html
|
||||
///
|
||||
/// Pretty printing with `#?`:
|
||||
/// Pretty-printing with `#?`:
|
||||
///
|
||||
/// ```
|
||||
/// #[derive(Debug)]
|
||||
|
||||
@ -61,7 +61,7 @@ pub trait Future {
|
||||
/// progress, meaning that each time the current task is woken up, it should
|
||||
/// actively re-`poll` pending futures that it still has an interest in.
|
||||
///
|
||||
/// The `poll` function is not called repeatedly in a tight loop-- instead,
|
||||
/// The `poll` function is not called repeatedly in a tight loop -- instead,
|
||||
/// it should only be called when the future indicates that it is ready to
|
||||
/// make progress (by calling `wake()`). If you're familiar with the
|
||||
/// `poll(2)` or `select(2)` syscalls on Unix it's worth noting that futures
|
||||
|
||||
@ -10,7 +10,7 @@ use mem;
|
||||
/// An implementation of SipHash 1-3.
|
||||
///
|
||||
/// This is currently the default hashing function used by standard library
|
||||
/// (eg. `collections::HashMap` uses it by default).
|
||||
/// (e.g., `collections::HashMap` uses it by default).
|
||||
///
|
||||
/// See: <https://131002.net/siphash>
|
||||
#[unstable(feature = "hashmap_internals", issue = "0")]
|
||||
@ -90,7 +90,7 @@ macro_rules! compress {
|
||||
});
|
||||
}
|
||||
|
||||
/// Load an integer of the desired type from a byte stream, in LE order. Uses
|
||||
/// Loads an integer of the desired type from a byte stream, in LE order. Uses
|
||||
/// `copy_nonoverlapping` to let the compiler generate the most efficient way
|
||||
/// to load it from a possibly unaligned address.
|
||||
///
|
||||
@ -107,7 +107,7 @@ macro_rules! load_int_le {
|
||||
});
|
||||
}
|
||||
|
||||
/// Load an u64 using up to 7 bytes of a byte slice.
|
||||
/// Loads an u64 using up to 7 bytes of a byte slice.
|
||||
///
|
||||
/// Unsafe because: unchecked indexing at start..start+len
|
||||
#[inline]
|
||||
|
||||
@ -34,7 +34,7 @@ use intrinsics;
|
||||
/// use std::hint::unreachable_unchecked;
|
||||
///
|
||||
/// // `b.saturating_add(1)` is always positive (not zero),
|
||||
/// // hence `checked_div` will never return None.
|
||||
/// // hence `checked_div` will never return `None`.
|
||||
/// // Therefore, the else branch is unreachable.
|
||||
/// a.checked_div(b.saturating_add(1))
|
||||
/// .unwrap_or_else(|| unsafe { unreachable_unchecked() })
|
||||
|
||||
@ -75,3 +75,47 @@ macro_rules! forward_ref_op_assign {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a zero-size type similar to a closure type, but named.
|
||||
#[unstable(feature = "std_internals", issue = "0")]
|
||||
macro_rules! impl_fn_for_zst {
|
||||
($(
|
||||
$( #[$attr: meta] )*
|
||||
// FIXME: when libcore is in the 2018 edition, use `?` repetition in
|
||||
// $( <$( $li : lifetime ),+> )?
|
||||
struct $Name: ident impl$( <$( $lifetime : lifetime ),+> )* Fn =
|
||||
|$( $arg: ident: $ArgTy: ty ),*| -> $ReturnTy: ty
|
||||
$body: block;
|
||||
)+) => {
|
||||
$(
|
||||
$( #[$attr] )*
|
||||
struct $Name;
|
||||
|
||||
impl $( <$( $lifetime ),+> )* Fn<($( $ArgTy, )*)> for $Name {
|
||||
#[inline]
|
||||
extern "rust-call" fn call(&self, ($( $arg, )*): ($( $ArgTy, )*)) -> $ReturnTy {
|
||||
$body
|
||||
}
|
||||
}
|
||||
|
||||
impl $( <$( $lifetime ),+> )* FnMut<($( $ArgTy, )*)> for $Name {
|
||||
#[inline]
|
||||
extern "rust-call" fn call_mut(
|
||||
&mut self,
|
||||
($( $arg, )*): ($( $ArgTy, )*)
|
||||
) -> $ReturnTy {
|
||||
Fn::call(&*self, ($( $arg, )*))
|
||||
}
|
||||
}
|
||||
|
||||
impl $( <$( $lifetime ),+> )* FnOnce<($( $ArgTy, )*)> for $Name {
|
||||
type Output = $ReturnTy;
|
||||
|
||||
#[inline]
|
||||
extern "rust-call" fn call_once(self, ($( $arg, )*): ($( $ArgTy, )*)) -> $ReturnTy {
|
||||
Fn::call(&self, ($( $arg, )*))
|
||||
}
|
||||
}
|
||||
)+
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
//! rustc compiler intrinsics.
|
||||
//! Compiler intrinsics.
|
||||
//!
|
||||
//! The corresponding definitions are in librustc_codegen_llvm/intrinsic.rs.
|
||||
//! The corresponding definitions are in `librustc_codegen_llvm/intrinsic.rs`.
|
||||
//!
|
||||
//! # Volatiles
|
||||
//!
|
||||
@ -315,35 +315,35 @@ extern "rust-intrinsic" {
|
||||
/// [`AtomicBool::swap`](../../std/sync/atomic/struct.AtomicBool.html#method.swap).
|
||||
pub fn atomic_xchg_relaxed<T>(dst: *mut T, src: T) -> T;
|
||||
|
||||
/// Add to the current value, returning the previous value.
|
||||
/// Adds to the current value, returning the previous value.
|
||||
/// The stabilized version of this intrinsic is available on the
|
||||
/// `std::sync::atomic` types via the `fetch_add` method by passing
|
||||
/// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
|
||||
/// as the `order`. For example,
|
||||
/// [`AtomicIsize::fetch_add`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_add).
|
||||
pub fn atomic_xadd<T>(dst: *mut T, src: T) -> T;
|
||||
/// Add to the current value, returning the previous value.
|
||||
/// Adds to the current value, returning the previous value.
|
||||
/// The stabilized version of this intrinsic is available on the
|
||||
/// `std::sync::atomic` types via the `fetch_add` method by passing
|
||||
/// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
|
||||
/// as the `order`. For example,
|
||||
/// [`AtomicIsize::fetch_add`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_add).
|
||||
pub fn atomic_xadd_acq<T>(dst: *mut T, src: T) -> T;
|
||||
/// Add to the current value, returning the previous value.
|
||||
/// Adds to the current value, returning the previous value.
|
||||
/// The stabilized version of this intrinsic is available on the
|
||||
/// `std::sync::atomic` types via the `fetch_add` method by passing
|
||||
/// [`Ordering::Release`](../../std/sync/atomic/enum.Ordering.html)
|
||||
/// as the `order`. For example,
|
||||
/// [`AtomicIsize::fetch_add`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_add).
|
||||
pub fn atomic_xadd_rel<T>(dst: *mut T, src: T) -> T;
|
||||
/// Add to the current value, returning the previous value.
|
||||
/// Adds to the current value, returning the previous value.
|
||||
/// The stabilized version of this intrinsic is available on the
|
||||
/// `std::sync::atomic` types via the `fetch_add` method by passing
|
||||
/// [`Ordering::AcqRel`](../../std/sync/atomic/enum.Ordering.html)
|
||||
/// as the `order`. For example,
|
||||
/// [`AtomicIsize::fetch_add`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_add).
|
||||
pub fn atomic_xadd_acqrel<T>(dst: *mut T, src: T) -> T;
|
||||
/// Add to the current value, returning the previous value.
|
||||
/// Adds to the current value, returning the previous value.
|
||||
/// The stabilized version of this intrinsic is available on the
|
||||
/// `std::sync::atomic` types via the `fetch_add` method by passing
|
||||
/// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
|
||||
@ -556,7 +556,7 @@ extern "rust-intrinsic" {
|
||||
pub fn atomic_umax_relaxed<T>(dst: *mut T, src: T) -> T;
|
||||
|
||||
/// The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction
|
||||
/// if supported; otherwise, it is a noop.
|
||||
/// if supported; otherwise, it is a no-op.
|
||||
/// Prefetches have no effect on the behavior of the program but can change its performance
|
||||
/// characteristics.
|
||||
///
|
||||
@ -564,7 +564,7 @@ extern "rust-intrinsic" {
|
||||
/// ranging from (0) - no locality, to (3) - extremely local keep in cache
|
||||
pub fn prefetch_read_data<T>(data: *const T, locality: i32);
|
||||
/// The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction
|
||||
/// if supported; otherwise, it is a noop.
|
||||
/// if supported; otherwise, it is a no-op.
|
||||
/// Prefetches have no effect on the behavior of the program but can change its performance
|
||||
/// characteristics.
|
||||
///
|
||||
@ -572,7 +572,7 @@ extern "rust-intrinsic" {
|
||||
/// ranging from (0) - no locality, to (3) - extremely local keep in cache
|
||||
pub fn prefetch_write_data<T>(data: *const T, locality: i32);
|
||||
/// The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction
|
||||
/// if supported; otherwise, it is a noop.
|
||||
/// if supported; otherwise, it is a no-op.
|
||||
/// Prefetches have no effect on the behavior of the program but can change its performance
|
||||
/// characteristics.
|
||||
///
|
||||
@ -580,7 +580,7 @@ extern "rust-intrinsic" {
|
||||
/// ranging from (0) - no locality, to (3) - extremely local keep in cache
|
||||
pub fn prefetch_read_instruction<T>(data: *const T, locality: i32);
|
||||
/// The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction
|
||||
/// if supported; otherwise, it is a noop.
|
||||
/// if supported; otherwise, it is a no-op.
|
||||
/// Prefetches have no effect on the behavior of the program but can change its performance
|
||||
/// characteristics.
|
||||
///
|
||||
@ -697,7 +697,7 @@ extern "rust-intrinsic" {
|
||||
/// Creates a value initialized to zero.
|
||||
///
|
||||
/// `init` is unsafe because it returns a zeroed-out datum,
|
||||
/// which is unsafe unless T is `Copy`. Also, even if T is
|
||||
/// which is unsafe unless `T` is `Copy`. Also, even if T is
|
||||
/// `Copy`, an all-zero value may not correspond to any legitimate
|
||||
/// state for the type in question.
|
||||
pub fn init<T>() -> T;
|
||||
@ -857,7 +857,7 @@ extern "rust-intrinsic" {
|
||||
///
|
||||
/// // The no-copy, unsafe way, still using transmute, but not UB.
|
||||
/// // This is equivalent to the original, but safer, and reuses the
|
||||
/// // same Vec internals. Therefore the new inner type must have the
|
||||
/// // same `Vec` internals. Therefore, the new inner type must have the
|
||||
/// // exact same size, and the same alignment, as the old type.
|
||||
/// // The same caveats exist for this method as transmute, for
|
||||
/// // the original inner type (`&i32`) to the converted inner type
|
||||
@ -875,8 +875,8 @@ extern "rust-intrinsic" {
|
||||
/// ```
|
||||
/// use std::{slice, mem};
|
||||
///
|
||||
/// // There are multiple ways to do this; and there are multiple problems
|
||||
/// // with the following, transmute, way.
|
||||
/// // There are multiple ways to do this, and there are multiple problems
|
||||
/// // with the following (transmute) way.
|
||||
/// fn split_at_mut_transmute<T>(slice: &mut [T], mid: usize)
|
||||
/// -> (&mut [T], &mut [T]) {
|
||||
/// let len = slice.len();
|
||||
@ -988,7 +988,7 @@ extern "rust-intrinsic" {
|
||||
/// beginning at `dst` with the same size.
|
||||
///
|
||||
/// Like [`read`], `copy_nonoverlapping` creates a bitwise copy of `T`, regardless of
|
||||
/// whether `T` is [`Copy`]. If `T` is not [`Copy`], using *both* the values
|
||||
/// whether `T` is [`Copy`]. If `T` is not [`Copy`], using *both* the values
|
||||
/// in the region beginning at `*src` and the region beginning at `*dst` can
|
||||
/// [violate memory safety][read-ownership].
|
||||
///
|
||||
@ -1055,7 +1055,7 @@ extern "rust-intrinsic" {
|
||||
/// [`copy_nonoverlapping`] can be used instead.
|
||||
///
|
||||
/// `copy` is semantically equivalent to C's [`memmove`], but with the argument
|
||||
/// order swapped. Copying takes place as if the bytes were copied from `src`
|
||||
/// order swapped. Copying takes place as if the bytes were copied from `src`
|
||||
/// to a temporary array and then copied from the array to `dst`.
|
||||
///
|
||||
/// [`copy_nonoverlapping`]: ./fn.copy_nonoverlapping.html
|
||||
@ -1072,7 +1072,7 @@ extern "rust-intrinsic" {
|
||||
/// * Both `src` and `dst` must be properly aligned.
|
||||
///
|
||||
/// Like [`read`], `copy` creates a bitwise copy of `T`, regardless of
|
||||
/// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the values
|
||||
/// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the values
|
||||
/// in the region beginning at `*src` and the region beginning at `*dst` can
|
||||
/// [violate memory safety][read-ownership].
|
||||
///
|
||||
@ -1200,19 +1200,19 @@ extern "rust-intrinsic" {
|
||||
/// unless size is equal to zero.
|
||||
pub fn volatile_set_memory<T>(dst: *mut T, val: u8, count: usize);
|
||||
|
||||
/// Perform a volatile load from the `src` pointer.
|
||||
/// Performs a volatile load from the `src` pointer.
|
||||
/// The stabilized version of this intrinsic is
|
||||
/// [`std::ptr::read_volatile`](../../std/ptr/fn.read_volatile.html).
|
||||
pub fn volatile_load<T>(src: *const T) -> T;
|
||||
/// Perform a volatile store to the `dst` pointer.
|
||||
/// Performs a volatile store to the `dst` pointer.
|
||||
/// The stabilized version of this intrinsic is
|
||||
/// [`std::ptr::write_volatile`](../../std/ptr/fn.write_volatile.html).
|
||||
pub fn volatile_store<T>(dst: *mut T, val: T);
|
||||
|
||||
/// Perform a volatile load from the `src` pointer
|
||||
/// Performs a volatile load from the `src` pointer
|
||||
/// The pointer is not required to be aligned.
|
||||
pub fn unaligned_volatile_load<T>(src: *const T) -> T;
|
||||
/// Perform a volatile store to the `dst` pointer.
|
||||
/// Performs a volatile store to the `dst` pointer.
|
||||
/// The pointer is not required to be aligned.
|
||||
pub fn unaligned_volatile_store<T>(dst: *mut T, val: T);
|
||||
|
||||
|
||||
@ -20,19 +20,19 @@ pub trait Step: Clone + PartialOrd + Sized {
|
||||
/// without overflow.
|
||||
fn steps_between(start: &Self, end: &Self) -> Option<usize>;
|
||||
|
||||
/// Replaces this step with `1`, returning itself
|
||||
/// Replaces this step with `1`, returning itself.
|
||||
fn replace_one(&mut self) -> Self;
|
||||
|
||||
/// Replaces this step with `0`, returning itself
|
||||
/// Replaces this step with `0`, returning itself.
|
||||
fn replace_zero(&mut self) -> Self;
|
||||
|
||||
/// Adds one to this step, returning the result
|
||||
/// Adds one to this step, returning the result.
|
||||
fn add_one(&self) -> Self;
|
||||
|
||||
/// Subtracts one to this step, returning the result
|
||||
/// Subtracts one to this step, returning the result.
|
||||
fn sub_one(&self) -> Self;
|
||||
|
||||
/// Add an usize, returning None on overflow
|
||||
/// Adds a `usize`, returning `None` on overflow.
|
||||
fn add_usize(&self, n: usize) -> Option<Self>;
|
||||
}
|
||||
|
||||
|
||||
@ -504,10 +504,8 @@ pub fn once_with<A, F: FnOnce() -> A>(gen: F) -> OnceWith<F> {
|
||||
/// [`FusedIterator`]: trait.FusedIterator.html
|
||||
/// [`Iterator::size_hint`]: trait.Iterator.html#method.size_hint
|
||||
///
|
||||
/// The closure can use its its captures and environment
|
||||
/// to track state across iterations.
|
||||
/// Depending on how the iterator is used,
|
||||
/// this may require specifying the `move` keyword on the closure.
|
||||
/// The closure can use captures and its environment to track state across iterations. Depending on
|
||||
/// how the iterator is used, this may require specifying the `move` keyword on the closure.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
|
||||
@ -104,7 +104,7 @@ pub trait ExactSizeIterator: Iterator {
|
||||
lower
|
||||
}
|
||||
|
||||
/// Returns whether the iterator is empty.
|
||||
/// Returns `true` if the iterator is empty.
|
||||
///
|
||||
/// This method has a default implementation using `self.len()`, so you
|
||||
/// don't need to implement it yourself.
|
||||
|
||||
@ -120,7 +120,7 @@ pub trait Iterator {
|
||||
/// // ... and then None once it's over.
|
||||
/// assert_eq!(None, iter.next());
|
||||
///
|
||||
/// // More calls may or may not return None. Here, they always will.
|
||||
/// // More calls may or may not return `None`. Here, they always will.
|
||||
/// assert_eq!(None, iter.next());
|
||||
/// assert_eq!(None, iter.next());
|
||||
/// ```
|
||||
@ -564,9 +564,9 @@ pub trait Iterator {
|
||||
/// Calls a closure on each element of an iterator.
|
||||
///
|
||||
/// This is equivalent to using a [`for`] loop on the iterator, although
|
||||
/// `break` and `continue` are not possible from a closure. It's generally
|
||||
/// `break` and `continue` are not possible from a closure. It's generally
|
||||
/// more idiomatic to use a `for` loop, but `for_each` may be more legible
|
||||
/// when processing items at the end of longer iterator chains. In some
|
||||
/// when processing items at the end of longer iterator chains. In some
|
||||
/// cases `for_each` may also be faster than a loop, because it will use
|
||||
/// internal iteration on adaptors like `Chain`.
|
||||
///
|
||||
@ -952,8 +952,7 @@ pub trait Iterator {
|
||||
/// ```
|
||||
///
|
||||
/// The `3` is no longer there, because it was consumed in order to see if
|
||||
/// the iteration should stop, but wasn't placed back into the iterator or
|
||||
/// some similar thing.
|
||||
/// the iteration should stop, but wasn't placed back into the iterator.
|
||||
#[inline]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
|
||||
@ -1216,7 +1215,7 @@ pub trait Iterator {
|
||||
/// assert_eq!(iter.next(), Some(4));
|
||||
/// assert_eq!(iter.next(), None);
|
||||
///
|
||||
/// // it will always return None after the first time.
|
||||
/// // it will always return `None` after the first time.
|
||||
/// assert_eq!(iter.next(), None);
|
||||
/// assert_eq!(iter.next(), None);
|
||||
/// assert_eq!(iter.next(), None);
|
||||
@ -1516,7 +1515,7 @@ pub trait Iterator {
|
||||
/// is propagated back to the caller immediately (short-circuiting).
|
||||
///
|
||||
/// The initial value is the value the accumulator will have on the first
|
||||
/// call. If applying the closure succeeded against every element of the
|
||||
/// call. If applying the closure succeeded against every element of the
|
||||
/// iterator, `try_fold()` returns the final accumulator as success.
|
||||
///
|
||||
/// Folding is useful whenever you have a collection of something, and want
|
||||
@ -1529,10 +1528,10 @@ pub trait Iterator {
|
||||
/// do something better than the default `for` loop implementation.
|
||||
///
|
||||
/// In particular, try to have this call `try_fold()` on the internal parts
|
||||
/// from which this iterator is composed. If multiple calls are needed,
|
||||
/// from which this iterator is composed. If multiple calls are needed,
|
||||
/// the `?` operator may be convenient for chaining the accumulator value
|
||||
/// along, but beware any invariants that need to be upheld before those
|
||||
/// early returns. This is a `&mut self` method, so iteration needs to be
|
||||
/// early returns. This is a `&mut self` method, so iteration needs to be
|
||||
/// resumable after hitting an error here.
|
||||
///
|
||||
/// # Examples
|
||||
|
||||
@ -24,7 +24,7 @@
|
||||
//! often generated by LLVM. Additionally, this library can make explicit
|
||||
//! calls to these functions. Their signatures are the same as found in C.
|
||||
//! These functions are often provided by the system libc, but can also be
|
||||
//! provided by the [rlibc crate](https://crates.io/crates/rlibc).
|
||||
//! provided by the [compiler-builtins crate](https://crates.io/crates/compiler_builtins).
|
||||
//!
|
||||
//! * `rust_begin_panic` - This function takes four arguments, a
|
||||
//! `fmt::Arguments`, a `&'static str`, and two `u32`'s. These four arguments
|
||||
@ -51,9 +51,7 @@
|
||||
#![cfg(not(test))]
|
||||
|
||||
#![stable(feature = "core", since = "1.6.0")]
|
||||
#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
|
||||
html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
|
||||
html_root_url = "https://doc.rust-lang.org/nightly/",
|
||||
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/",
|
||||
html_playground_url = "https://play.rust-lang.org/",
|
||||
issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/",
|
||||
test(no_crate_inject, attr(deny(warnings))),
|
||||
@ -97,6 +95,7 @@
|
||||
#![feature(simd_ffi)]
|
||||
#![feature(specialization)]
|
||||
#![feature(staged_api)]
|
||||
#![feature(std_internals)]
|
||||
#![feature(stmt_expr_attributes)]
|
||||
#![feature(unboxed_closures)]
|
||||
#![feature(unsized_locals)]
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
/// Entry point of thread panic, for details, see std::macros
|
||||
/// Entry point of thread panic. For details, see `std::macros`.
|
||||
#[macro_export]
|
||||
#[allow_internal_unstable]
|
||||
#[cfg_attr(not(stage0), allow_internal_unstable(core_panic, __rust_unstable_column))]
|
||||
#[cfg_attr(stage0, allow_internal_unstable)]
|
||||
#[stable(feature = "core", since = "1.6.0")]
|
||||
macro_rules! panic {
|
||||
() => (
|
||||
@ -409,7 +410,8 @@ macro_rules! write {
|
||||
/// ```
|
||||
#[macro_export]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[allow_internal_unstable]
|
||||
#[cfg_attr(stage0, allow_internal_unstable)]
|
||||
#[cfg_attr(not(stage0), allow_internal_unstable(format_args_nl))]
|
||||
macro_rules! writeln {
|
||||
($dst:expr) => (
|
||||
write!($dst, "\n")
|
||||
@ -432,7 +434,7 @@ macro_rules! writeln {
|
||||
/// * Iterators that dynamically terminate.
|
||||
///
|
||||
/// If the determination that the code is unreachable proves incorrect, the
|
||||
/// program immediately terminates with a [`panic!`]. The function [`unreachable_unchecked`],
|
||||
/// program immediately terminates with a [`panic!`]. The function [`unreachable_unchecked`],
|
||||
/// which belongs to the [`std::hint`] module, informs the compiler to
|
||||
/// optimize the code out of the release version entirely.
|
||||
///
|
||||
@ -493,7 +495,7 @@ macro_rules! unreachable {
|
||||
/// A standardized placeholder for marking unfinished code.
|
||||
///
|
||||
/// This can be useful if you are prototyping and are just looking to have your
|
||||
/// code typecheck, or if you're implementing a trait that requires multiple
|
||||
/// code type-check, or if you're implementing a trait that requires multiple
|
||||
/// methods, and you're only planning on using one of them.
|
||||
///
|
||||
/// # Panics
|
||||
@ -555,12 +557,12 @@ macro_rules! unimplemented {
|
||||
#[macro_export]
|
||||
#[unstable(feature = "maybe_uninit", issue = "53491")]
|
||||
macro_rules! uninitialized_array {
|
||||
// This `into_inner` is safe because an array of `MaybeUninit` does not
|
||||
// This `into_initialized` is safe because an array of `MaybeUninit` does not
|
||||
// require initialization.
|
||||
// FIXME(#49147): Could be replaced by an array initializer, once those can
|
||||
// be any const expression.
|
||||
($t:ty; $size:expr) => (unsafe {
|
||||
MaybeUninit::<[MaybeUninit<$t>; $size]>::uninitialized().into_inner()
|
||||
MaybeUninit::<[MaybeUninit<$t>; $size]>::uninitialized().into_initialized()
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@ -15,6 +15,7 @@ use ptr;
|
||||
use ops::{Deref, DerefMut};
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[doc(inline)]
|
||||
pub use intrinsics::transmute;
|
||||
|
||||
/// Takes ownership and "forgets" about the value **without running its destructor**.
|
||||
@ -294,7 +295,7 @@ pub const fn size_of<T>() -> usize {
|
||||
/// Returns the size of the pointed-to value in bytes.
|
||||
///
|
||||
/// This is usually the same as `size_of::<T>()`. However, when `T` *has* no
|
||||
/// statically known size, e.g., a slice [`[T]`][slice] or a [trait object],
|
||||
/// statically-known size, e.g., a slice [`[T]`][slice] or a [trait object],
|
||||
/// then `size_of_val` can be used to get the dynamically-known size.
|
||||
///
|
||||
/// [slice]: ../../std/primitive.slice.html
|
||||
@ -402,7 +403,7 @@ pub fn align_of_val<T: ?Sized>(val: &T) -> usize {
|
||||
unsafe { intrinsics::min_align_of_val(val) }
|
||||
}
|
||||
|
||||
/// Returns whether dropping values of type `T` matters.
|
||||
/// Returns `true` if dropping values of type `T` matters.
|
||||
///
|
||||
/// This is purely an optimization hint, and may be implemented conservatively:
|
||||
/// it may return `true` for types that don't actually need to be dropped.
|
||||
@ -957,7 +958,7 @@ impl<T> ManuallyDrop<T> {
|
||||
ManuallyDrop { value }
|
||||
}
|
||||
|
||||
/// Extract the value from the `ManuallyDrop` container.
|
||||
/// Extracts the value from the `ManuallyDrop` container.
|
||||
///
|
||||
/// This allows the value to be dropped again.
|
||||
///
|
||||
@ -1034,7 +1035,46 @@ impl<T: ?Sized> DerefMut for ManuallyDrop<T> {
|
||||
}
|
||||
}
|
||||
|
||||
/// A newtype to construct uninitialized instances of `T`
|
||||
/// A newtype to construct uninitialized instances of `T`.
|
||||
///
|
||||
/// The compiler, in general, assumes that variables are properly initialized
|
||||
/// at their respective type. For example, a variable of reference type must
|
||||
/// be aligned and non-NULL. This is an invariant that must *always* be upheld,
|
||||
/// even in unsafe code. As a consequence, zero-initializing a variable of reference
|
||||
/// type causes instantaneous undefined behavior, no matter whether that reference
|
||||
/// ever gets used to access memory:
|
||||
///
|
||||
/// ```rust,no_run
|
||||
/// use std::mem;
|
||||
///
|
||||
/// let x: &i32 = unsafe { mem::zeroed() }; // undefined behavior!
|
||||
/// ```
|
||||
///
|
||||
/// This is exploited by the compiler for various optimizations, such as eliding
|
||||
/// run-time checks and optimizing `enum` layout.
|
||||
///
|
||||
/// Not initializing memory at all (instead of zero--initializing it) causes the same
|
||||
/// issue: after all, the initial value of the variable might just happen to be
|
||||
/// one that violates the invariant.
|
||||
///
|
||||
/// `MaybeUninit` serves to enable unsafe code to deal with uninitialized data:
|
||||
/// it is a signal to the compiler indicating that the data here might *not*
|
||||
/// be initialized:
|
||||
///
|
||||
/// ```rust
|
||||
/// #![feature(maybe_uninit)]
|
||||
/// use std::mem::MaybeUninit;
|
||||
///
|
||||
/// // Create an explicitly uninitialized reference.
|
||||
/// let mut x = MaybeUninit::<&i32>::uninitialized();
|
||||
/// // Set it to a valid value.
|
||||
/// x.set(&0);
|
||||
/// // Extract the initialized data -- this is only allowed *after* properly
|
||||
/// // initializing `x`!
|
||||
/// let x = unsafe { x.into_initialized() };
|
||||
/// ```
|
||||
///
|
||||
/// The compiler then knows to not optimize this code.
|
||||
#[allow(missing_debug_implementations)]
|
||||
#[unstable(feature = "maybe_uninit", issue = "53491")]
|
||||
// NOTE after stabilizing `MaybeUninit` proceed to deprecate `mem::{uninitialized,zeroed}`
|
||||
@ -1054,7 +1094,7 @@ impl<T> MaybeUninit<T> {
|
||||
MaybeUninit { value: ManuallyDrop::new(val) }
|
||||
}
|
||||
|
||||
/// Create a new `MaybeUninit` in an uninitialized state.
|
||||
/// Creates a new `MaybeUninit` in an uninitialized state.
|
||||
///
|
||||
/// Note that dropping a `MaybeUninit` will never call `T`'s drop code.
|
||||
/// It is your responsibility to make sure `T` gets dropped if it got initialized.
|
||||
@ -1064,8 +1104,8 @@ impl<T> MaybeUninit<T> {
|
||||
MaybeUninit { uninit: () }
|
||||
}
|
||||
|
||||
/// Create a new `MaybeUninit` in an uninitialized state, with the memory being
|
||||
/// filled with `0` bytes. It depends on `T` whether that already makes for
|
||||
/// Creates a new `MaybeUninit` in an uninitialized state, with the memory being
|
||||
/// filled with `0` bytes. It depends on `T` whether that already makes for
|
||||
/// proper initialization. For example, `MaybeUninit<usize>::zeroed()` is initialized,
|
||||
/// but `MaybeUninit<&'static i32>::zeroed()` is not because references must not
|
||||
/// be null.
|
||||
@ -1082,16 +1122,19 @@ impl<T> MaybeUninit<T> {
|
||||
u
|
||||
}
|
||||
|
||||
/// Set the value of the `MaybeUninit`. This overwrites any previous value without dropping it.
|
||||
/// Sets the value of the `MaybeUninit`. This overwrites any previous value without dropping it.
|
||||
/// For your convenience, this also returns a mutable reference to the (now safely initialized)
|
||||
/// contents of `self`.
|
||||
#[unstable(feature = "maybe_uninit", issue = "53491")]
|
||||
#[inline(always)]
|
||||
pub fn set(&mut self, val: T) {
|
||||
pub fn set(&mut self, val: T) -> &mut T {
|
||||
unsafe {
|
||||
self.value = ManuallyDrop::new(val);
|
||||
self.get_mut()
|
||||
}
|
||||
}
|
||||
|
||||
/// Extract the value from the `MaybeUninit` container. This is a great way
|
||||
/// Extracts the value from the `MaybeUninit` container. This is a great way
|
||||
/// to ensure that the data will get dropped, because the resulting `T` is
|
||||
/// subject to the usual drop handling.
|
||||
///
|
||||
@ -1101,12 +1144,20 @@ impl<T> MaybeUninit<T> {
|
||||
/// state, otherwise this will immediately cause undefined behavior.
|
||||
#[unstable(feature = "maybe_uninit", issue = "53491")]
|
||||
#[inline(always)]
|
||||
pub unsafe fn into_inner(self) -> T {
|
||||
pub unsafe fn into_initialized(self) -> T {
|
||||
intrinsics::panic_if_uninhabited::<T>();
|
||||
ManuallyDrop::into_inner(self.value)
|
||||
}
|
||||
|
||||
/// Get a reference to the contained value.
|
||||
/// Deprecated alternative to `into_initialized`. Will never get stabilized.
|
||||
/// Exists only to transition stdsimd to `into_initialized`.
|
||||
#[inline(always)]
|
||||
#[allow(unused)]
|
||||
pub(crate) unsafe fn into_inner(self) -> T {
|
||||
self.into_initialized()
|
||||
}
|
||||
|
||||
/// Gets a reference to the contained value.
|
||||
///
|
||||
/// # Unsafety
|
||||
///
|
||||
@ -1118,7 +1169,7 @@ impl<T> MaybeUninit<T> {
|
||||
&*self.value
|
||||
}
|
||||
|
||||
/// Get a mutable reference to the contained value.
|
||||
/// Gets a mutable reference to the contained value.
|
||||
///
|
||||
/// # Unsafety
|
||||
///
|
||||
@ -1133,30 +1184,30 @@ impl<T> MaybeUninit<T> {
|
||||
&mut *self.value
|
||||
}
|
||||
|
||||
/// Get a pointer to the contained value. Reading from this pointer will be undefined
|
||||
/// behavior unless the `MaybeUninit` is initialized.
|
||||
/// Gets a pointer to the contained value. Reading from this pointer or turning it
|
||||
/// into a reference will be undefined behavior unless the `MaybeUninit` is initialized.
|
||||
#[unstable(feature = "maybe_uninit", issue = "53491")]
|
||||
#[inline(always)]
|
||||
pub fn as_ptr(&self) -> *const T {
|
||||
unsafe { &*self.value as *const T }
|
||||
}
|
||||
|
||||
/// Get a mutable pointer to the contained value. Reading from this pointer will be undefined
|
||||
/// behavior unless the `MaybeUninit` is initialized.
|
||||
/// Get sa mutable pointer to the contained value. Reading from this pointer or turning it
|
||||
/// into a reference will be undefined behavior unless the `MaybeUninit` is initialized.
|
||||
#[unstable(feature = "maybe_uninit", issue = "53491")]
|
||||
#[inline(always)]
|
||||
pub fn as_mut_ptr(&mut self) -> *mut T {
|
||||
unsafe { &mut *self.value as *mut T }
|
||||
}
|
||||
|
||||
/// Get a pointer to the first element of the array.
|
||||
/// Gets a pointer to the first element of the array.
|
||||
#[unstable(feature = "maybe_uninit", issue = "53491")]
|
||||
#[inline(always)]
|
||||
pub fn first_ptr(this: &[MaybeUninit<T>]) -> *const T {
|
||||
this as *const [MaybeUninit<T>] as *const T
|
||||
}
|
||||
|
||||
/// Get a mutable pointer to the first element of the array.
|
||||
/// Gets a mutable pointer to the first element of the array.
|
||||
#[unstable(feature = "maybe_uninit", issue = "53491")]
|
||||
#[inline(always)]
|
||||
pub fn first_ptr_mut(this: &mut [MaybeUninit<T>]) -> *mut T {
|
||||
|
||||
@ -61,7 +61,7 @@ mod fpu_precision {
|
||||
unsafe { asm!("fldcw $0" :: "m" (cw) :: "volatile") }
|
||||
}
|
||||
|
||||
/// Set the precision field of the FPU to `T` and return a `FPUControlWord`
|
||||
/// Sets the precision field of the FPU to `T` and returns a `FPUControlWord`.
|
||||
pub fn set_precision<T>() -> FPUControlWord {
|
||||
let cw = 0u16;
|
||||
|
||||
|
||||
@ -37,7 +37,7 @@
|
||||
//!
|
||||
//! In addition, there are numerous helper functions that are used in the paper but not available
|
||||
//! in Rust (or at least in core). Our version is additionally complicated by the need to handle
|
||||
//! overflow and underflow and the desire to handle subnormal numbers. Bellerophon and
|
||||
//! overflow and underflow and the desire to handle subnormal numbers. Bellerophon and
|
||||
//! Algorithm R have trouble with overflow, subnormals, and underflow. We conservatively switch to
|
||||
//! Algorithm M (with the modifications described in section 8 of the paper) well before the
|
||||
//! inputs get into the critical region.
|
||||
@ -54,7 +54,7 @@
|
||||
//! operations as well, if you want 0.5 ULP accuracy you need to do *everything* in full precision
|
||||
//! and round *exactly once, at the end*, by considering all truncated bits at once.
|
||||
//!
|
||||
//! FIXME Although some code duplication is necessary, perhaps parts of the code could be shuffled
|
||||
//! FIXME: Although some code duplication is necessary, perhaps parts of the code could be shuffled
|
||||
//! around such that less code is duplicated. Large parts of the algorithms are independent of the
|
||||
//! float type to output, or only needs access to a few constants, which could be passed in as
|
||||
//! parameters.
|
||||
@ -148,7 +148,7 @@ macro_rules! from_str_float_impl {
|
||||
/// # Return value
|
||||
///
|
||||
/// `Err(ParseFloatError)` if the string did not represent a valid
|
||||
/// number. Otherwise, `Ok(n)` where `n` is the floating-point
|
||||
/// number. Otherwise, `Ok(n)` where `n` is the floating-point
|
||||
/// number represented by `src`.
|
||||
#[inline]
|
||||
fn from_str(src: &str) -> Result<Self, ParseFloatError> {
|
||||
@ -209,7 +209,7 @@ fn pfe_invalid() -> ParseFloatError {
|
||||
ParseFloatError { kind: FloatErrorKind::Invalid }
|
||||
}
|
||||
|
||||
/// Split decimal string into sign and the rest, without inspecting or validating the rest.
|
||||
/// Splits a decimal string into sign and the rest, without inspecting or validating the rest.
|
||||
fn extract_sign(s: &str) -> (Sign, &str) {
|
||||
match s.as_bytes()[0] {
|
||||
b'+' => (Sign::Positive, &s[1..]),
|
||||
@ -219,7 +219,7 @@ fn extract_sign(s: &str) -> (Sign, &str) {
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert a decimal string into a floating point number.
|
||||
/// Converts a decimal string into a floating point number.
|
||||
fn dec2flt<T: RawFloat>(s: &str) -> Result<T, ParseFloatError> {
|
||||
if s.is_empty() {
|
||||
return Err(pfe_empty())
|
||||
|
||||
@ -27,7 +27,7 @@ pub fn compare_with_half_ulp(f: &Big, ones_place: usize) -> Ordering {
|
||||
Equal
|
||||
}
|
||||
|
||||
/// Convert an ASCII string containing only decimal digits to a `u64`.
|
||||
/// Converts an ASCII string containing only decimal digits to a `u64`.
|
||||
///
|
||||
/// Does not perform checks for overflow or invalid characters, so if the caller is not careful,
|
||||
/// the result is bogus and can panic (though it won't be `unsafe`). Additionally, empty strings
|
||||
@ -44,7 +44,7 @@ pub fn from_str_unchecked<'a, T>(bytes: T) -> u64 where T : IntoIterator<Item=&'
|
||||
result
|
||||
}
|
||||
|
||||
/// Convert a string of ASCII digits into a bignum.
|
||||
/// Converts a string of ASCII digits into a bignum.
|
||||
///
|
||||
/// Like `from_str_unchecked`, this function relies on the parser to weed out non-digits.
|
||||
pub fn digits_to_big(integral: &[u8], fractional: &[u8]) -> Big {
|
||||
@ -69,7 +69,7 @@ pub fn to_u64(x: &Big) -> u64 {
|
||||
}
|
||||
|
||||
|
||||
/// Extract a range of bits.
|
||||
/// Extracts a range of bits.
|
||||
|
||||
/// Index 0 is the least significant bit and the range is half-open as usual.
|
||||
/// Panics if asked to extract more bits than fit into the return type.
|
||||
|
||||
@ -42,7 +42,7 @@ pub enum ParseResult<'a> {
|
||||
Invalid,
|
||||
}
|
||||
|
||||
/// Check if the input string is a valid floating point number and if so, locate the integral
|
||||
/// Checks if the input string is a valid floating point number and if so, locate the integral
|
||||
/// part, the fractional part, and the exponent in it. Does not handle signs.
|
||||
pub fn parse_decimal(s: &str) -> ParseResult {
|
||||
if s.is_empty() {
|
||||
|
||||
@ -59,10 +59,10 @@ pub trait RawFloat
|
||||
/// Type used by `to_bits` and `from_bits`.
|
||||
type Bits: Add<Output = Self::Bits> + From<u8> + TryFrom<u64>;
|
||||
|
||||
/// Raw transmutation to integer.
|
||||
/// Performs a raw transmutation to an integer.
|
||||
fn to_bits(self) -> Self::Bits;
|
||||
|
||||
/// Raw transmutation from integer.
|
||||
/// Performs a raw transmutation from an integer.
|
||||
fn from_bits(v: Self::Bits) -> Self;
|
||||
|
||||
/// Returns the category that this number falls into.
|
||||
@ -71,14 +71,14 @@ pub trait RawFloat
|
||||
/// Returns the mantissa, exponent and sign as integers.
|
||||
fn integer_decode(self) -> (u64, i16, i8);
|
||||
|
||||
/// Decode the float.
|
||||
/// Decodes the float.
|
||||
fn unpack(self) -> Unpacked;
|
||||
|
||||
/// Cast from a small integer that can be represented exactly. Panic if the integer can't be
|
||||
/// Casts from a small integer that can be represented exactly. Panic if the integer can't be
|
||||
/// represented, the other code in this module makes sure to never let that happen.
|
||||
fn from_int(x: u64) -> Self;
|
||||
|
||||
/// Get the value 10<sup>e</sup> from a pre-computed table.
|
||||
/// Gets the value 10<sup>e</sup> from a pre-computed table.
|
||||
/// Panics for `e >= CEIL_LOG5_OF_MAX_SIG`.
|
||||
fn short_fast_pow10(e: usize) -> Self;
|
||||
|
||||
@ -240,7 +240,7 @@ impl RawFloat for f64 {
|
||||
fn from_bits(v: Self::Bits) -> Self { Self::from_bits(v) }
|
||||
}
|
||||
|
||||
/// Convert an Fp to the closest machine float type.
|
||||
/// Converts an `Fp` to the closest machine float type.
|
||||
/// Does not handle subnormal results.
|
||||
pub fn fp_to_float<T: RawFloat>(x: Fp) -> T {
|
||||
let x = x.normalize();
|
||||
@ -319,7 +319,7 @@ pub fn big_to_fp(f: &Big) -> Fp {
|
||||
}
|
||||
}
|
||||
|
||||
/// Find the largest floating point number strictly smaller than the argument.
|
||||
/// Finds the largest floating point number strictly smaller than the argument.
|
||||
/// Does not handle subnormals, zero, or exponent underflow.
|
||||
pub fn prev_float<T: RawFloat>(x: T) -> T {
|
||||
match x.classify() {
|
||||
|
||||
@ -144,7 +144,7 @@ pub mod consts {
|
||||
#[lang = "f32"]
|
||||
#[cfg(not(test))]
|
||||
impl f32 {
|
||||
/// Returns `true` if this value is `NaN` and false otherwise.
|
||||
/// Returns `true` if this value is `NaN`.
|
||||
///
|
||||
/// ```
|
||||
/// use std::f32;
|
||||
@ -169,8 +169,8 @@ impl f32 {
|
||||
f32::from_bits(self.to_bits() & 0x7fff_ffff)
|
||||
}
|
||||
|
||||
/// Returns `true` if this value is positive infinity or negative infinity and
|
||||
/// false otherwise.
|
||||
/// Returns `true` if this value is positive infinity or negative infinity, and
|
||||
/// `false` otherwise.
|
||||
///
|
||||
/// ```
|
||||
/// use std::f32;
|
||||
@ -272,7 +272,7 @@ impl f32 {
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns `true` if and only if `self` has a positive sign, including `+0.0`, `NaN`s with
|
||||
/// Returns `true` if `self` has a positive sign, including `+0.0`, `NaN`s with
|
||||
/// positive sign bit and positive infinity.
|
||||
///
|
||||
/// ```
|
||||
@ -288,7 +288,7 @@ impl f32 {
|
||||
!self.is_sign_negative()
|
||||
}
|
||||
|
||||
/// Returns `true` if and only if `self` has a negative sign, including `-0.0`, `NaN`s with
|
||||
/// Returns `true` if `self` has a negative sign, including `-0.0`, `NaN`s with
|
||||
/// negative sign bit and negative infinity.
|
||||
///
|
||||
/// ```
|
||||
|
||||
@ -144,7 +144,7 @@ pub mod consts {
|
||||
#[lang = "f64"]
|
||||
#[cfg(not(test))]
|
||||
impl f64 {
|
||||
/// Returns `true` if this value is `NaN` and false otherwise.
|
||||
/// Returns `true` if this value is `NaN`.
|
||||
///
|
||||
/// ```
|
||||
/// use std::f64;
|
||||
@ -169,8 +169,8 @@ impl f64 {
|
||||
f64::from_bits(self.to_bits() & 0x7fff_ffff_ffff_ffff)
|
||||
}
|
||||
|
||||
/// Returns `true` if this value is positive infinity or negative infinity and
|
||||
/// false otherwise.
|
||||
/// Returns `true` if this value is positive infinity or negative infinity, and
|
||||
/// `false` otherwise.
|
||||
///
|
||||
/// ```
|
||||
/// use std::f64;
|
||||
@ -272,7 +272,7 @@ impl f64 {
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns `true` if and only if `self` has a positive sign, including `+0.0`, `NaN`s with
|
||||
/// Returns `true` if `self` has a positive sign, including `+0.0`, `NaN`s with
|
||||
/// positive sign bit and positive infinity.
|
||||
///
|
||||
/// ```
|
||||
@ -296,7 +296,7 @@ impl f64 {
|
||||
self.is_sign_positive()
|
||||
}
|
||||
|
||||
/// Returns `true` if and only if `self` has a negative sign, including `-0.0`, `NaN`s with
|
||||
/// Returns `true` if `self` has a negative sign, including `-0.0`, `NaN`s with
|
||||
/// negative sign bit and negative infinity.
|
||||
///
|
||||
/// ```
|
||||
|
||||
@ -52,7 +52,7 @@ assert_eq!(size_of::<Option<core::num::", stringify!($Ty), ">>(), size_of::<", s
|
||||
}
|
||||
|
||||
impl $Ty {
|
||||
/// Create a non-zero without checking the value.
|
||||
/// Creates a non-zero without checking the value.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
@ -63,7 +63,7 @@ assert_eq!(size_of::<Option<core::num::", stringify!($Ty), ">>(), size_of::<", s
|
||||
$Ty(n)
|
||||
}
|
||||
|
||||
/// Create a non-zero if the given value is not zero.
|
||||
/// Creates a non-zero if the given value is not zero.
|
||||
#[$stability]
|
||||
#[inline]
|
||||
pub fn new(n: $Int) -> Option<Self> {
|
||||
@ -882,17 +882,38 @@ $EndFeature, "
|
||||
```"),
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[inline]
|
||||
#[cfg(stage0)]
|
||||
pub fn saturating_add(self, rhs: Self) -> Self {
|
||||
#[cfg(stage0)]
|
||||
match self.checked_add(rhs) {
|
||||
Some(x) => x,
|
||||
None if rhs >= 0 => Self::max_value(),
|
||||
None => Self::min_value(),
|
||||
}
|
||||
#[cfg(not(stage0))]
|
||||
{
|
||||
intrinsics::saturating_add(self, rhs)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
doc_comment! {
|
||||
concat!("Saturating integer addition. Computes `self + rhs`, saturating at the numeric
|
||||
bounds instead of overflowing.
|
||||
|
||||
# Examples
|
||||
|
||||
Basic usage:
|
||||
|
||||
```
|
||||
", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_add(1), 101);
|
||||
assert_eq!(", stringify!($SelfT), "::max_value().saturating_add(100), ", stringify!($SelfT),
|
||||
"::max_value());",
|
||||
$EndFeature, "
|
||||
```"),
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_const_unstable(feature = "const_saturating_int_methods")]
|
||||
#[inline]
|
||||
#[cfg(not(stage0))]
|
||||
pub const fn saturating_add(self, rhs: Self) -> Self {
|
||||
intrinsics::saturating_add(self, rhs)
|
||||
}
|
||||
}
|
||||
|
||||
@ -912,17 +933,36 @@ $EndFeature, "
|
||||
```"),
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[inline]
|
||||
#[cfg(stage0)]
|
||||
pub fn saturating_sub(self, rhs: Self) -> Self {
|
||||
#[cfg(stage0)]
|
||||
match self.checked_sub(rhs) {
|
||||
Some(x) => x,
|
||||
None if rhs >= 0 => Self::min_value(),
|
||||
None => Self::max_value(),
|
||||
}
|
||||
#[cfg(not(stage0))]
|
||||
{
|
||||
intrinsics::saturating_sub(self, rhs)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
doc_comment! {
|
||||
concat!("Saturating integer subtraction. Computes `self - rhs`, saturating at the
|
||||
numeric bounds instead of overflowing.
|
||||
|
||||
# Examples
|
||||
|
||||
Basic usage:
|
||||
|
||||
```
|
||||
", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_sub(127), -27);
|
||||
assert_eq!(", stringify!($SelfT), "::min_value().saturating_sub(100), ", stringify!($SelfT),
|
||||
"::min_value());",
|
||||
$EndFeature, "
|
||||
```"),
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_const_unstable(feature = "const_saturating_int_methods")]
|
||||
#[inline]
|
||||
#[cfg(not(stage0))]
|
||||
pub const fn saturating_sub(self, rhs: Self) -> Self {
|
||||
intrinsics::saturating_sub(self, rhs)
|
||||
}
|
||||
}
|
||||
|
||||
@ -2753,16 +2793,34 @@ assert_eq!(200u8.saturating_add(127), 255);", $EndFeature, "
|
||||
```"),
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[inline]
|
||||
#[cfg(stage0)]
|
||||
pub fn saturating_add(self, rhs: Self) -> Self {
|
||||
#[cfg(stage0)]
|
||||
match self.checked_add(rhs) {
|
||||
Some(x) => x,
|
||||
None => Self::max_value(),
|
||||
}
|
||||
#[cfg(not(stage0))]
|
||||
{
|
||||
intrinsics::saturating_add(self, rhs)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
doc_comment! {
|
||||
concat!("Saturating integer addition. Computes `self + rhs`, saturating at
|
||||
the numeric bounds instead of overflowing.
|
||||
|
||||
# Examples
|
||||
|
||||
Basic usage:
|
||||
|
||||
```
|
||||
", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_add(1), 101);
|
||||
assert_eq!(200u8.saturating_add(127), 255);", $EndFeature, "
|
||||
```"),
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_const_unstable(feature = "const_saturating_int_methods")]
|
||||
#[inline]
|
||||
#[cfg(not(stage0))]
|
||||
pub const fn saturating_add(self, rhs: Self) -> Self {
|
||||
intrinsics::saturating_add(self, rhs)
|
||||
}
|
||||
}
|
||||
|
||||
@ -2780,16 +2838,33 @@ assert_eq!(13", stringify!($SelfT), ".saturating_sub(127), 0);", $EndFeature, "
|
||||
```"),
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[inline]
|
||||
#[cfg(stage0)]
|
||||
pub fn saturating_sub(self, rhs: Self) -> Self {
|
||||
#[cfg(stage0)]
|
||||
match self.checked_sub(rhs) {
|
||||
Some(x) => x,
|
||||
None => Self::min_value(),
|
||||
}
|
||||
#[cfg(not(stage0))]
|
||||
{
|
||||
intrinsics::saturating_sub(self, rhs)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
doc_comment! {
|
||||
concat!("Saturating integer subtraction. Computes `self - rhs`, saturating
|
||||
at the numeric bounds instead of overflowing.
|
||||
|
||||
# Examples
|
||||
|
||||
Basic usage:
|
||||
|
||||
```
|
||||
", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_sub(27), 73);
|
||||
assert_eq!(13", stringify!($SelfT), ".saturating_sub(127), 0);", $EndFeature, "
|
||||
```"),
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_const_unstable(feature = "const_saturating_int_methods")]
|
||||
#[inline]
|
||||
#[cfg(not(stage0))]
|
||||
pub const fn saturating_sub(self, rhs: Self) -> Self {
|
||||
intrinsics::saturating_sub(self, rhs)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -49,7 +49,7 @@
|
||||
/// }
|
||||
///
|
||||
/// // Notice that the implementation uses the associated type `Output`.
|
||||
/// impl<T: Add<Output=T>> Add for Point<T> {
|
||||
/// impl<T: Add<Output = T>> Add for Point<T> {
|
||||
/// type Output = Point<T>;
|
||||
///
|
||||
/// fn add(self, other: Point<T>) -> Point<T> {
|
||||
@ -157,7 +157,7 @@ add_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
|
||||
/// }
|
||||
///
|
||||
/// // Notice that the implementation uses the associated type `Output`.
|
||||
/// impl<T: Sub<Output=T>> Sub for Point<T> {
|
||||
/// impl<T: Sub<Output = T>> Sub for Point<T> {
|
||||
/// type Output = Point<T>;
|
||||
///
|
||||
/// fn sub(self, other: Point<T>) -> Point<T> {
|
||||
@ -518,7 +518,7 @@ pub trait Rem<RHS=Self> {
|
||||
|
||||
macro_rules! rem_impl_integer {
|
||||
($($t:ty)*) => ($(
|
||||
/// This operation satisfies `n % d == n - (n / d) * d`. The
|
||||
/// This operation satisfies `n % d == n - (n / d) * d`. The
|
||||
/// result has the same sign as the left operand.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl Rem for $t {
|
||||
|
||||
@ -62,7 +62,7 @@
|
||||
label="expected an `Fn<{Args}>` closure, found `{Self}`",
|
||||
)]
|
||||
#[fundamental] // so that regex can rely that `&str: !FnMut`
|
||||
#[must_use]
|
||||
#[must_use = "closures are lazy and do nothing unless called"]
|
||||
pub trait Fn<Args> : FnMut<Args> {
|
||||
/// Performs the call operation.
|
||||
#[unstable(feature = "fn_traits", issue = "29625")]
|
||||
@ -141,7 +141,7 @@ pub trait Fn<Args> : FnMut<Args> {
|
||||
label="expected an `FnMut<{Args}>` closure, found `{Self}`",
|
||||
)]
|
||||
#[fundamental] // so that regex can rely that `&str: !FnMut`
|
||||
#[must_use]
|
||||
#[must_use = "closures are lazy and do nothing unless called"]
|
||||
pub trait FnMut<Args> : FnOnce<Args> {
|
||||
/// Performs the call operation.
|
||||
#[unstable(feature = "fn_traits", issue = "29625")]
|
||||
@ -220,7 +220,7 @@ pub trait FnMut<Args> : FnOnce<Args> {
|
||||
label="expected an `FnOnce<{Args}>` closure, found `{Self}`",
|
||||
)]
|
||||
#[fundamental] // so that regex can rely that `&str: !FnMut`
|
||||
#[must_use]
|
||||
#[must_use = "closures are lazy and do nothing unless called"]
|
||||
pub trait FnOnce<Args> {
|
||||
/// The returned type after the call operator is used.
|
||||
#[stable(feature = "fn_once_output", since = "1.12.0")]
|
||||
|
||||
@ -52,7 +52,7 @@ impl fmt::Debug for RangeFull {
|
||||
/// (`start..end`).
|
||||
///
|
||||
/// The `Range` `start..end` contains all values with `x >= start` and
|
||||
/// `x < end`. It is empty unless `start < end`.
|
||||
/// `x < end`. It is empty unless `start < end`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
@ -297,7 +297,7 @@ impl<Idx: PartialOrd<Idx>> RangeTo<Idx> {
|
||||
/// A range bounded inclusively below and above (`start..=end`).
|
||||
///
|
||||
/// The `RangeInclusive` `start..=end` contains all values with `x >= start`
|
||||
/// and `x <= end`. It is empty unless `start <= end`.
|
||||
/// and `x <= end`. It is empty unless `start <= end`.
|
||||
///
|
||||
/// This iterator is [fused], but the specific values of `start` and `end` after
|
||||
/// iteration has finished are **unspecified** other than that [`.is_empty()`]
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
/// A trait for customizing the behavior of the `?` operator.
|
||||
///
|
||||
/// A type implementing `Try` is one that has a canonical way to view it
|
||||
/// in terms of a success/failure dichotomy. This trait allows both
|
||||
/// in terms of a success/failure dichotomy. This trait allows both
|
||||
/// extracting those success or failure values from an existing instance and
|
||||
/// creating a new instance from a success or failure value.
|
||||
#[unstable(feature = "try_trait", issue = "42327")]
|
||||
|
||||
@ -214,7 +214,7 @@ impl<T> Option<T> {
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Convert an `Option<`[`String`]`>` into an `Option<`[`usize`]`>`, preserving the original.
|
||||
/// Converts an `Option<`[`String`]`>` into an `Option<`[`usize`]`>`, preserving the original.
|
||||
/// The [`map`] method takes the `self` argument by value, consuming the original,
|
||||
/// so this technique uses `as_ref` to first take an `Option` to a reference
|
||||
/// to the value inside the original.
|
||||
@ -395,7 +395,7 @@ impl<T> Option<T> {
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Convert an `Option<`[`String`]`>` into an `Option<`[`usize`]`>`, consuming the original:
|
||||
/// Converts an `Option<`[`String`]`>` into an `Option<`[`usize`]`>`, consuming the original:
|
||||
///
|
||||
/// [`String`]: ../../std/string/struct.String.html
|
||||
/// [`usize`]: ../../std/primitive.usize.html
|
||||
@ -963,7 +963,7 @@ impl<T: Default> Option<T> {
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Convert a string to an integer, turning poorly-formed strings
|
||||
/// Converts a string to an integer, turning poorly-formed strings
|
||||
/// into 0 (the default value for integers). [`parse`] converts
|
||||
/// a string to any other type that implements [`FromStr`], returning
|
||||
/// [`None`] on error.
|
||||
|
||||
@ -199,7 +199,7 @@ impl<P: Deref> Pin<P> {
|
||||
Pin { pointer }
|
||||
}
|
||||
|
||||
/// Get a pinned shared reference from this pinned pointer.
|
||||
/// Gets a pinned shared reference from this pinned pointer.
|
||||
#[stable(feature = "pin", since = "1.33.0")]
|
||||
#[inline(always)]
|
||||
pub fn as_ref(self: &Pin<P>) -> Pin<&P::Target> {
|
||||
@ -208,7 +208,7 @@ impl<P: Deref> Pin<P> {
|
||||
}
|
||||
|
||||
impl<P: DerefMut> Pin<P> {
|
||||
/// Get a pinned mutable reference from this pinned pointer.
|
||||
/// Gets a pinned mutable reference from this pinned pointer.
|
||||
#[stable(feature = "pin", since = "1.33.0")]
|
||||
#[inline(always)]
|
||||
pub fn as_mut(self: &mut Pin<P>) -> Pin<&mut P::Target> {
|
||||
@ -247,7 +247,7 @@ impl<'a, T: ?Sized> Pin<&'a T> {
|
||||
Pin::new_unchecked(new_pointer)
|
||||
}
|
||||
|
||||
/// Get a shared reference out of a pin.
|
||||
/// Gets a shared reference out of a pin.
|
||||
///
|
||||
/// Note: `Pin` also implements `Deref` to the target, which can be used
|
||||
/// to access the inner value. However, `Deref` only provides a reference
|
||||
@ -262,14 +262,14 @@ impl<'a, T: ?Sized> Pin<&'a T> {
|
||||
}
|
||||
|
||||
impl<'a, T: ?Sized> Pin<&'a mut T> {
|
||||
/// Convert this `Pin<&mut T>` into a `Pin<&T>` with the same lifetime.
|
||||
/// Converts this `Pin<&mut T>` into a `Pin<&T>` with the same lifetime.
|
||||
#[stable(feature = "pin", since = "1.33.0")]
|
||||
#[inline(always)]
|
||||
pub fn into_ref(self: Pin<&'a mut T>) -> Pin<&'a T> {
|
||||
Pin { pointer: self.pointer }
|
||||
}
|
||||
|
||||
/// Get a mutable reference to the data inside of this `Pin`.
|
||||
/// Gets a mutable reference to the data inside of this `Pin`.
|
||||
///
|
||||
/// This requires that the data inside this `Pin` is `Unpin`.
|
||||
///
|
||||
@ -286,7 +286,7 @@ impl<'a, T: ?Sized> Pin<&'a mut T> {
|
||||
self.pointer
|
||||
}
|
||||
|
||||
/// Get a mutable reference to the data inside of this `Pin`.
|
||||
/// Gets a mutable reference to the data inside of this `Pin`.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
|
||||
@ -12,7 +12,7 @@
|
||||
//! to access only a single value, in which case the documentation omits the size
|
||||
//! and implicitly assumes it to be `size_of::<T>()` bytes.
|
||||
//!
|
||||
//! The precise rules for validity are not determined yet. The guarantees that are
|
||||
//! The precise rules for validity are not determined yet. The guarantees that are
|
||||
//! provided at this point are very minimal:
|
||||
//!
|
||||
//! * A [null] pointer is *never* valid, not even for accesses of [size zero][zst].
|
||||
@ -104,7 +104,7 @@ pub use intrinsics::write_bytes;
|
||||
///
|
||||
/// * `to_drop` must be [valid] for reads.
|
||||
///
|
||||
/// * `to_drop` must be properly aligned. See the example below for how to drop
|
||||
/// * `to_drop` must be properly aligned. See the example below for how to drop
|
||||
/// an unaligned pointer.
|
||||
///
|
||||
/// Additionally, if `T` is not [`Copy`], using the pointed-to value after
|
||||
@ -135,7 +135,7 @@ pub use intrinsics::write_bytes;
|
||||
/// unsafe {
|
||||
/// // Get a raw pointer to the last element in `v`.
|
||||
/// let ptr = &mut v[1] as *mut _;
|
||||
/// // Shorten `v` to prevent the last item from being dropped. We do that first,
|
||||
/// // Shorten `v` to prevent the last item from being dropped. We do that first,
|
||||
/// // to prevent issues if the `drop_in_place` below panics.
|
||||
/// v.set_len(1);
|
||||
/// // Without a call `drop_in_place`, the last item would never be dropped,
|
||||
@ -531,7 +531,7 @@ pub unsafe fn replace<T>(dst: *mut T, mut src: T) -> T {
|
||||
///
|
||||
/// `read` creates a bitwise copy of `T`, regardless of whether `T` is [`Copy`].
|
||||
/// If `T` is not [`Copy`], using both the returned value and the value at
|
||||
/// `*src` can violate memory safety. Note that assigning to `*src` counts as a
|
||||
/// `*src` can violate memory safety. Note that assigning to `*src` counts as a
|
||||
/// use because it will attempt to drop the value at `*src`.
|
||||
///
|
||||
/// [`write`] can be used to overwrite data without causing it to be dropped.
|
||||
@ -573,7 +573,7 @@ pub unsafe fn replace<T>(dst: *mut T, mut src: T) -> T {
|
||||
pub unsafe fn read<T>(src: *const T) -> T {
|
||||
let mut tmp = MaybeUninit::<T>::uninitialized();
|
||||
copy_nonoverlapping(src, tmp.as_mut_ptr(), 1);
|
||||
tmp.into_inner()
|
||||
tmp.into_initialized()
|
||||
}
|
||||
|
||||
/// Reads the value from `src` without moving it. This leaves the
|
||||
@ -588,7 +588,7 @@ pub unsafe fn read<T>(src: *const T) -> T {
|
||||
/// * `src` must be [valid] for reads.
|
||||
///
|
||||
/// Like [`read`], `read_unaligned` creates a bitwise copy of `T`, regardless of
|
||||
/// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the returned
|
||||
/// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the returned
|
||||
/// value and the value at `*src` can [violate memory safety][read-ownership].
|
||||
///
|
||||
/// Note that even if `T` has size `0`, the pointer must be non-NULL.
|
||||
@ -642,7 +642,7 @@ pub unsafe fn read_unaligned<T>(src: *const T) -> T {
|
||||
copy_nonoverlapping(src as *const u8,
|
||||
tmp.as_mut_ptr() as *mut u8,
|
||||
mem::size_of::<T>());
|
||||
tmp.into_inner()
|
||||
tmp.into_initialized()
|
||||
}
|
||||
|
||||
/// Overwrites a memory location with the given value without reading or
|
||||
@ -825,7 +825,7 @@ pub unsafe fn write_unaligned<T>(dst: *mut T, src: T) {
|
||||
///
|
||||
/// The compiler shouldn't change the relative order or number of volatile
|
||||
/// memory operations. However, volatile memory operations on zero-sized types
|
||||
/// (e.g., if a zero-sized type is passed to `read_volatile`) are no-ops
|
||||
/// (e.g., if a zero-sized type is passed to `read_volatile`) are noops
|
||||
/// and may be ignored.
|
||||
///
|
||||
/// [c11]: http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf
|
||||
@ -839,7 +839,7 @@ pub unsafe fn write_unaligned<T>(dst: *mut T, src: T) {
|
||||
/// * `src` must be properly aligned.
|
||||
///
|
||||
/// Like [`read`], `read_unaligned` creates a bitwise copy of `T`, regardless of
|
||||
/// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the returned
|
||||
/// whether `T` is [`Copy`]. If `T` is not [`Copy`], using both the returned
|
||||
/// value and the value at `*src` can [violate memory safety][read-ownership].
|
||||
/// However, storing non-[`Copy`] types in volatile memory is almost certainly
|
||||
/// incorrect.
|
||||
@ -903,7 +903,7 @@ pub unsafe fn read_volatile<T>(src: *const T) -> T {
|
||||
///
|
||||
/// The compiler shouldn't change the relative order or number of volatile
|
||||
/// memory operations. However, volatile memory operations on zero-sized types
|
||||
/// (e.g., if a zero-sized type is passed to `write_volatile`) are no-ops
|
||||
/// (e.g., if a zero-sized type is passed to `write_volatile`) are noops
|
||||
/// and may be ignored.
|
||||
///
|
||||
/// [c11]: http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf
|
||||
@ -1093,7 +1093,7 @@ impl<T: ?Sized> *const T {
|
||||
/// unless `x` and `y` point into the same allocated object.
|
||||
///
|
||||
/// Always use `.offset(count)` instead when possible, because `offset`
|
||||
/// allows the compiler to optimize better. If you need to cross object
|
||||
/// allows the compiler to optimize better. If you need to cross object
|
||||
/// boundaries, cast the pointer to an integer and do the arithmetic there.
|
||||
///
|
||||
/// # Examples
|
||||
@ -1712,7 +1712,7 @@ impl<T: ?Sized> *mut T {
|
||||
/// unless `x` and `y` point into the same allocated object.
|
||||
///
|
||||
/// Always use `.offset(count)` instead when possible, because `offset`
|
||||
/// allows the compiler to optimize better. If you need to cross object
|
||||
/// allows the compiler to optimize better. If you need to cross object
|
||||
/// boundaries, cast the pointer to an integer and do the arithmetic there.
|
||||
///
|
||||
/// # Examples
|
||||
@ -2473,7 +2473,7 @@ impl<T: ?Sized> PartialEq for *mut T {
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
impl<T: ?Sized> Eq for *mut T {}
|
||||
|
||||
/// Compare raw pointers for equality.
|
||||
/// Compares raw pointers for equality.
|
||||
///
|
||||
/// This is the same as using the `==` operator, but less generic:
|
||||
/// the arguments have to be `*const T` raw pointers,
|
||||
|
||||
@ -896,7 +896,7 @@ impl<T: Default, E> Result<T, E> {
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Convert a string to an integer, turning poorly-formed strings
|
||||
/// Converts a string to an integer, turning poorly-formed strings
|
||||
/// into 0 (the default value for integers). [`parse`] converts
|
||||
/// a string to any other type that implements [`FromStr`], returning an
|
||||
/// [`Err`] on error.
|
||||
|
||||
@ -11,7 +11,7 @@ const HI_U64: u64 = 0x8080808080808080;
|
||||
const LO_USIZE: usize = LO_U64 as usize;
|
||||
const HI_USIZE: usize = HI_U64 as usize;
|
||||
|
||||
/// Returns whether `x` contains any zero byte.
|
||||
/// Returns `true` if `x` contains any zero byte.
|
||||
///
|
||||
/// From *Matters Computational*, J. Arndt:
|
||||
///
|
||||
|
||||
@ -1197,7 +1197,7 @@ impl<T> [T] {
|
||||
|
||||
/// Returns an iterator over subslices separated by elements that match
|
||||
/// `pred` limited to returning at most `n` items. This starts at the end of
|
||||
/// the slice and works backwards. The matched element is not contained in
|
||||
/// the slice and works backwards. The matched element is not contained in
|
||||
/// the subslices.
|
||||
///
|
||||
/// The last element returned, if any, will contain the remainder of the
|
||||
@ -3145,7 +3145,7 @@ unsafe impl<T: Sync> Sync for Iter<'_, T> {}
|
||||
unsafe impl<T: Sync> Send for Iter<'_, T> {}
|
||||
|
||||
impl<'a, T> Iter<'a, T> {
|
||||
/// View the underlying data as a subslice of the original data.
|
||||
/// Views the underlying data as a subslice of the original data.
|
||||
///
|
||||
/// This has the same lifetime as the original slice, and so the
|
||||
/// iterator can continue to be used while this exists.
|
||||
@ -3247,7 +3247,7 @@ unsafe impl<T: Sync> Sync for IterMut<'_, T> {}
|
||||
unsafe impl<T: Send> Send for IterMut<'_, T> {}
|
||||
|
||||
impl<'a, T> IterMut<'a, T> {
|
||||
/// View the underlying data as a subslice of the original data.
|
||||
/// Views the underlying data as a subslice of the original data.
|
||||
///
|
||||
/// To avoid creating `&mut` references that alias, this is forced
|
||||
/// to consume the iterator.
|
||||
@ -4123,7 +4123,7 @@ pub struct ChunksExact<'a, T:'a> {
|
||||
}
|
||||
|
||||
impl<'a, T> ChunksExact<'a, T> {
|
||||
/// Return the remainder of the original slice that is not going to be
|
||||
/// Returns the remainder of the original slice that is not going to be
|
||||
/// returned by the iterator. The returned slice has at most `chunk_size-1`
|
||||
/// elements.
|
||||
#[stable(feature = "chunks_exact", since = "1.31.0")]
|
||||
@ -4247,7 +4247,7 @@ pub struct ChunksExactMut<'a, T:'a> {
|
||||
}
|
||||
|
||||
impl<'a, T> ChunksExactMut<'a, T> {
|
||||
/// Return the remainder of the original slice that is not going to be
|
||||
/// Returns the remainder of the original slice that is not going to be
|
||||
/// returned by the iterator. The returned slice has at most `chunk_size-1`
|
||||
/// elements.
|
||||
#[stable(feature = "chunks_exact", since = "1.31.0")]
|
||||
@ -4619,7 +4619,7 @@ pub struct RChunksExact<'a, T:'a> {
|
||||
}
|
||||
|
||||
impl<'a, T> RChunksExact<'a, T> {
|
||||
/// Return the remainder of the original slice that is not going to be
|
||||
/// Returns the remainder of the original slice that is not going to be
|
||||
/// returned by the iterator. The returned slice has at most `chunk_size-1`
|
||||
/// elements.
|
||||
#[stable(feature = "rchunks", since = "1.31.0")]
|
||||
@ -4744,7 +4744,7 @@ pub struct RChunksExactMut<'a, T:'a> {
|
||||
}
|
||||
|
||||
impl<'a, T> RChunksExactMut<'a, T> {
|
||||
/// Return the remainder of the original slice that is not going to be
|
||||
/// Returns the remainder of the original slice that is not going to be
|
||||
/// returned by the iterator. The returned slice has at most `chunk_size-1`
|
||||
/// elements.
|
||||
#[stable(feature = "rchunks", since = "1.31.0")]
|
||||
|
||||
@ -26,7 +26,7 @@ impl<T> RawArray<T> {
|
||||
}
|
||||
|
||||
/// Rotates the range `[mid-left, mid+right)` such that the element at `mid`
|
||||
/// becomes the first element. Equivalently, rotates the range `left`
|
||||
/// becomes the first element. Equivalently, rotates the range `left`
|
||||
/// elements to the left or `right` elements to the right.
|
||||
///
|
||||
/// # Safety
|
||||
@ -36,10 +36,10 @@ impl<T> RawArray<T> {
|
||||
/// # Algorithm
|
||||
///
|
||||
/// For longer rotations, swap the left-most `delta = min(left, right)`
|
||||
/// elements with the right-most `delta` elements. LLVM vectorizes this,
|
||||
/// elements with the right-most `delta` elements. LLVM vectorizes this,
|
||||
/// which is profitable as we only reach this step for a "large enough"
|
||||
/// rotation. Doing this puts `delta` elements on the larger side into the
|
||||
/// correct position, leaving a smaller rotate problem. Demonstration:
|
||||
/// rotation. Doing this puts `delta` elements on the larger side into the
|
||||
/// correct position, leaving a smaller rotate problem. Demonstration:
|
||||
///
|
||||
/// ```text
|
||||
/// [ 6 7 8 9 10 11 12 13 . 1 2 3 4 5 ]
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
//! String manipulation
|
||||
//! String manipulation.
|
||||
//!
|
||||
//! For more details, see std::str
|
||||
//! For more details, see the `std::str` module.
|
||||
|
||||
#![stable(feature = "rust1", since = "1.0.0")]
|
||||
|
||||
@ -8,10 +8,13 @@ use self::pattern::Pattern;
|
||||
use self::pattern::{Searcher, ReverseSearcher, DoubleEndedSearcher};
|
||||
|
||||
use char;
|
||||
use fmt;
|
||||
use fmt::{self, Write};
|
||||
use iter::{Map, Cloned, FusedIterator, TrustedLen, TrustedRandomAccess, Filter};
|
||||
use iter::{Flatten, FlatMap, Chain};
|
||||
use slice::{self, SliceIndex, Split as SliceSplit};
|
||||
use mem;
|
||||
use ops::Try;
|
||||
use option;
|
||||
|
||||
pub mod pattern;
|
||||
|
||||
@ -226,7 +229,7 @@ impl Utf8Error {
|
||||
#[stable(feature = "utf8_error", since = "1.5.0")]
|
||||
pub fn valid_up_to(&self) -> usize { self.valid_up_to }
|
||||
|
||||
/// Provide more information about the failure:
|
||||
/// Provides more information about the failure:
|
||||
///
|
||||
/// * `None`: the end of the input was reached unexpectedly.
|
||||
/// `self.valid_up_to()` is 1 to 3 bytes from the end of the input.
|
||||
@ -612,7 +615,7 @@ impl<'a> DoubleEndedIterator for Chars<'a> {
|
||||
impl FusedIterator for Chars<'_> {}
|
||||
|
||||
impl<'a> Chars<'a> {
|
||||
/// View the underlying data as a subslice of the original data.
|
||||
/// Views the underlying data as a subslice of the original data.
|
||||
///
|
||||
/// This has the same lifetime as the original slice, and so the
|
||||
/// iterator can continue to be used while this exists.
|
||||
@ -702,7 +705,7 @@ impl<'a> DoubleEndedIterator for CharIndices<'a> {
|
||||
impl FusedIterator for CharIndices<'_> {}
|
||||
|
||||
impl<'a> CharIndices<'a> {
|
||||
/// View the underlying data as a subslice of the original data.
|
||||
/// Views the underlying data as a subslice of the original data.
|
||||
///
|
||||
/// This has the same lifetime as the original slice, and so the
|
||||
/// iterator can continue to be used while this exists.
|
||||
@ -1345,33 +1348,14 @@ impl FusedIterator for Lines<'_> {}
|
||||
#[allow(deprecated)]
|
||||
pub struct LinesAny<'a>(Lines<'a>);
|
||||
|
||||
/// A nameable, cloneable fn type
|
||||
#[derive(Clone)]
|
||||
struct LinesAnyMap;
|
||||
|
||||
impl<'a> Fn<(&'a str,)> for LinesAnyMap {
|
||||
#[inline]
|
||||
extern "rust-call" fn call(&self, (line,): (&'a str,)) -> &'a str {
|
||||
impl_fn_for_zst! {
|
||||
/// A nameable, cloneable fn type
|
||||
#[derive(Clone)]
|
||||
struct LinesAnyMap impl<'a> Fn = |line: &'a str| -> &'a str {
|
||||
let l = line.len();
|
||||
if l > 0 && line.as_bytes()[l - 1] == b'\r' { &line[0 .. l - 1] }
|
||||
else { line }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> FnMut<(&'a str,)> for LinesAnyMap {
|
||||
#[inline]
|
||||
extern "rust-call" fn call_mut(&mut self, (line,): (&'a str,)) -> &'a str {
|
||||
Fn::call(&*self, (line,))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> FnOnce<(&'a str,)> for LinesAnyMap {
|
||||
type Output = &'a str;
|
||||
|
||||
#[inline]
|
||||
extern "rust-call" fn call_once(self, (line,): (&'a str,)) -> &'a str {
|
||||
Fn::call(&self, (line,))
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
@ -1579,9 +1563,9 @@ mod traits {
|
||||
|
||||
/// Implements ordering of strings.
|
||||
///
|
||||
/// Strings are ordered lexicographically by their byte values. This orders Unicode code
|
||||
/// points based on their positions in the code charts. This is not necessarily the same as
|
||||
/// "alphabetical" order, which varies by language and locale. Sorting strings according to
|
||||
/// Strings are ordered lexicographically by their byte values. This orders Unicode code
|
||||
/// points based on their positions in the code charts. This is not necessarily the same as
|
||||
/// "alphabetical" order, which varies by language and locale. Sorting strings according to
|
||||
/// culturally-accepted standards requires locale-specific data that is outside the scope of
|
||||
/// the `str` type.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
@ -1607,9 +1591,9 @@ mod traits {
|
||||
|
||||
/// Implements comparison operations on strings.
|
||||
///
|
||||
/// Strings are compared lexicographically by their byte values. This compares Unicode code
|
||||
/// points based on their positions in the code charts. This is not necessarily the same as
|
||||
/// "alphabetical" order, which varies by language and locale. Comparing strings according to
|
||||
/// Strings are compared lexicographically by their byte values. This compares Unicode code
|
||||
/// points based on their positions in the code charts. This is not necessarily the same as
|
||||
/// "alphabetical" order, which varies by language and locale. Comparing strings according to
|
||||
/// culturally-accepted standards requires locale-specific data that is outside the scope of
|
||||
/// the `str` type.
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
@ -2643,7 +2627,7 @@ impl str {
|
||||
Bytes(self.as_bytes().iter().cloned())
|
||||
}
|
||||
|
||||
/// Split a string slice by whitespace.
|
||||
/// Splits a string slice by whitespace.
|
||||
///
|
||||
/// The iterator returned will return string slices that are sub-slices of
|
||||
/// the original string slice, separated by any amount of whitespace.
|
||||
@ -2686,7 +2670,7 @@ impl str {
|
||||
SplitWhitespace { inner: self.split(IsWhitespace).filter(IsNotEmpty) }
|
||||
}
|
||||
|
||||
/// Split a string slice by ASCII whitespace.
|
||||
/// Splits a string slice by ASCII whitespace.
|
||||
///
|
||||
/// The iterator returned will return string slices that are sub-slices of
|
||||
/// the original string slice, separated by any amount of ASCII whitespace.
|
||||
@ -2727,7 +2711,7 @@ impl str {
|
||||
let inner = self
|
||||
.as_bytes()
|
||||
.split(IsAsciiWhitespace)
|
||||
.filter(IsNotEmpty)
|
||||
.filter(BytesIsNotEmpty)
|
||||
.map(UnsafeBytesToStr);
|
||||
SplitAsciiWhitespace { inner }
|
||||
}
|
||||
@ -2961,8 +2945,8 @@ impl str {
|
||||
/// An iterator over substrings of this string slice, separated by
|
||||
/// characters matched by a pattern.
|
||||
///
|
||||
/// The pattern can be a `&str`, [`char`], or a closure that determines the
|
||||
/// split.
|
||||
/// The pattern can be any type that implements the Pattern trait. Notable
|
||||
/// examples are `&str`, [`char`], and closures that determines the split.
|
||||
///
|
||||
/// # Iterator behavior
|
||||
///
|
||||
@ -3078,8 +3062,8 @@ impl str {
|
||||
/// An iterator over substrings of the given string slice, separated by
|
||||
/// characters matched by a pattern and yielded in reverse order.
|
||||
///
|
||||
/// The pattern can be a `&str`, [`char`], or a closure that determines the
|
||||
/// split.
|
||||
/// The pattern can be any type that implements the Pattern trait. Notable
|
||||
/// examples are `&str`, [`char`], and closures that determines the split.
|
||||
///
|
||||
/// # Iterator behavior
|
||||
///
|
||||
@ -3128,8 +3112,8 @@ impl str {
|
||||
/// An iterator over substrings of the given string slice, separated by
|
||||
/// characters matched by a pattern.
|
||||
///
|
||||
/// The pattern can be a `&str`, [`char`], or a closure that determines the
|
||||
/// split.
|
||||
/// The pattern can be any type that implements the Pattern trait. Notable
|
||||
/// examples are `&str`, [`char`], and closures that determines the split.
|
||||
///
|
||||
/// Equivalent to [`split`], except that the trailing substring
|
||||
/// is skipped if empty.
|
||||
@ -3175,8 +3159,8 @@ impl str {
|
||||
/// An iterator over substrings of `self`, separated by characters
|
||||
/// matched by a pattern and yielded in reverse order.
|
||||
///
|
||||
/// The pattern can be a simple `&str`, [`char`], or a closure that
|
||||
/// determines the split.
|
||||
/// The pattern can be any type that implements the Pattern trait. Notable
|
||||
/// examples are `&str`, [`char`], and closures that determines the split.
|
||||
/// Additional libraries might provide more complex patterns like
|
||||
/// regular expressions.
|
||||
///
|
||||
@ -3222,8 +3206,8 @@ impl str {
|
||||
/// If `n` substrings are returned, the last substring (the `n`th substring)
|
||||
/// will contain the remainder of the string.
|
||||
///
|
||||
/// The pattern can be a `&str`, [`char`], or a closure that determines the
|
||||
/// split.
|
||||
/// The pattern can be any type that implements the Pattern trait. Notable
|
||||
/// examples are `&str`, [`char`], and closures that determines the split.
|
||||
///
|
||||
/// # Iterator behavior
|
||||
///
|
||||
@ -3275,8 +3259,8 @@ impl str {
|
||||
/// If `n` substrings are returned, the last substring (the `n`th substring)
|
||||
/// will contain the remainder of the string.
|
||||
///
|
||||
/// The pattern can be a `&str`, [`char`], or a closure that
|
||||
/// determines the split.
|
||||
/// The pattern can be any type that implements the Pattern trait. Notable
|
||||
/// examples are `&str`, [`char`], and closures that determines the split.
|
||||
///
|
||||
/// # Iterator behavior
|
||||
///
|
||||
@ -3319,8 +3303,8 @@ impl str {
|
||||
/// An iterator over the disjoint matches of a pattern within the given string
|
||||
/// slice.
|
||||
///
|
||||
/// The pattern can be a `&str`, [`char`], or a closure that
|
||||
/// determines if a character matches.
|
||||
/// The pattern can be any type that implements the Pattern trait. Notable
|
||||
/// examples are `&str`, [`char`], and closures that determines the split.
|
||||
///
|
||||
/// # Iterator behavior
|
||||
///
|
||||
@ -3504,7 +3488,7 @@ impl str {
|
||||
///
|
||||
/// A string is a sequence of bytes. `start` in this context means the first
|
||||
/// position of that byte string; for a left-to-right language like English or
|
||||
/// Russian, this will be left side; and for right-to-left languages like
|
||||
/// Russian, this will be left side, and for right-to-left languages like
|
||||
/// like Arabic or Hebrew, this will be the right side.
|
||||
///
|
||||
/// # Examples
|
||||
@ -3541,7 +3525,7 @@ impl str {
|
||||
///
|
||||
/// A string is a sequence of bytes. `end` in this context means the last
|
||||
/// position of that byte string; for a left-to-right language like English or
|
||||
/// Russian, this will be right side; and for right-to-left languages like
|
||||
/// Russian, this will be right side, and for right-to-left languages like
|
||||
/// like Arabic or Hebrew, this will be the left side.
|
||||
///
|
||||
/// # Examples
|
||||
@ -3787,7 +3771,7 @@ impl str {
|
||||
///
|
||||
/// A string is a sequence of bytes. `start` in this context means the first
|
||||
/// position of that byte string; for a left-to-right language like English or
|
||||
/// Russian, this will be left side; and for right-to-left languages like
|
||||
/// Russian, this will be left side, and for right-to-left languages like
|
||||
/// like Arabic or Hebrew, this will be the right side.
|
||||
///
|
||||
/// # Examples
|
||||
@ -3819,7 +3803,7 @@ impl str {
|
||||
///
|
||||
/// A string is a sequence of bytes. `end` in this context means the last
|
||||
/// position of that byte string; for a left-to-right language like English or
|
||||
/// Russian, this will be right side; and for right-to-left languages like
|
||||
/// Russian, this will be right side, and for right-to-left languages like
|
||||
/// like Arabic or Hebrew, this will be the left side.
|
||||
///
|
||||
/// # Examples
|
||||
@ -3964,6 +3948,146 @@ impl str {
|
||||
let me = unsafe { self.as_bytes_mut() };
|
||||
me.make_ascii_lowercase()
|
||||
}
|
||||
|
||||
/// Return an iterator that escapes each char in `s` with [`char::escape_debug`].
|
||||
///
|
||||
/// Note: only extended grapheme codepoints that begin the string will be
|
||||
/// escaped.
|
||||
///
|
||||
/// [`char::escape_debug`]: ../std/primitive.char.html#method.escape_debug
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// As an iterator:
|
||||
///
|
||||
/// ```
|
||||
/// for c in "❤\n!".escape_debug() {
|
||||
/// print!("{}", c);
|
||||
/// }
|
||||
/// println!();
|
||||
/// ```
|
||||
///
|
||||
/// Using `println!` directly:
|
||||
///
|
||||
/// ```
|
||||
/// println!("{}", "❤\n!".escape_debug());
|
||||
/// ```
|
||||
///
|
||||
///
|
||||
/// Both are equivalent to:
|
||||
///
|
||||
/// ```
|
||||
/// println!("❤\\n!");
|
||||
/// ```
|
||||
///
|
||||
/// Using `to_string`:
|
||||
///
|
||||
/// ```
|
||||
/// assert_eq!("❤\n!".escape_debug().to_string(), "❤\\n!");
|
||||
/// ```
|
||||
#[stable(feature = "str_escape", since = "1.34.0")]
|
||||
pub fn escape_debug(&self) -> EscapeDebug {
|
||||
let mut chars = self.chars();
|
||||
EscapeDebug {
|
||||
inner: chars.next()
|
||||
.map(|first| first.escape_debug_ext(true))
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.chain(chars.flat_map(CharEscapeDebugContinue))
|
||||
}
|
||||
}
|
||||
|
||||
/// Return an iterator that escapes each char in `s` with [`char::escape_default`].
|
||||
///
|
||||
/// [`char::escape_default`]: ../std/primitive.char.html#method.escape_default
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// As an iterator:
|
||||
///
|
||||
/// ```
|
||||
/// for c in "❤\n!".escape_default() {
|
||||
/// print!("{}", c);
|
||||
/// }
|
||||
/// println!();
|
||||
/// ```
|
||||
///
|
||||
/// Using `println!` directly:
|
||||
///
|
||||
/// ```
|
||||
/// println!("{}", "❤\n!".escape_default());
|
||||
/// ```
|
||||
///
|
||||
///
|
||||
/// Both are equivalent to:
|
||||
///
|
||||
/// ```
|
||||
/// println!("\\u{{2764}}\n!");
|
||||
/// ```
|
||||
///
|
||||
/// Using `to_string`:
|
||||
///
|
||||
/// ```
|
||||
/// assert_eq!("❤\n!".escape_default().to_string(), "\\u{2764}\\n!");
|
||||
/// ```
|
||||
#[stable(feature = "str_escape", since = "1.34.0")]
|
||||
pub fn escape_default(&self) -> EscapeDefault {
|
||||
EscapeDefault { inner: self.chars().flat_map(CharEscapeDefault) }
|
||||
}
|
||||
|
||||
/// Return an iterator that escapes each char in `s` with [`char::escape_unicode`].
|
||||
///
|
||||
/// [`char::escape_unicode`]: ../std/primitive.char.html#method.escape_unicode
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// As an iterator:
|
||||
///
|
||||
/// ```
|
||||
/// for c in "❤\n!".escape_unicode() {
|
||||
/// print!("{}", c);
|
||||
/// }
|
||||
/// println!();
|
||||
/// ```
|
||||
///
|
||||
/// Using `println!` directly:
|
||||
///
|
||||
/// ```
|
||||
/// println!("{}", "❤\n!".escape_unicode());
|
||||
/// ```
|
||||
///
|
||||
///
|
||||
/// Both are equivalent to:
|
||||
///
|
||||
/// ```
|
||||
/// println!("\\u{{2764}}\\u{{a}}\\u{{21}}");
|
||||
/// ```
|
||||
///
|
||||
/// Using `to_string`:
|
||||
///
|
||||
/// ```
|
||||
/// assert_eq!("❤\n!".escape_unicode().to_string(), "\\u{2764}\\u{a}\\u{21}");
|
||||
/// ```
|
||||
#[stable(feature = "str_escape", since = "1.34.0")]
|
||||
pub fn escape_unicode(&self) -> EscapeUnicode {
|
||||
EscapeUnicode { inner: self.chars().flat_map(CharEscapeUnicode) }
|
||||
}
|
||||
}
|
||||
|
||||
impl_fn_for_zst! {
|
||||
#[derive(Clone)]
|
||||
struct CharEscapeDebugContinue impl Fn = |c: char| -> char::EscapeDebug {
|
||||
c.escape_debug_ext(false)
|
||||
};
|
||||
|
||||
#[derive(Clone)]
|
||||
struct CharEscapeUnicode impl Fn = |c: char| -> char::EscapeUnicode {
|
||||
c.escape_unicode()
|
||||
};
|
||||
#[derive(Clone)]
|
||||
struct CharEscapeDefault impl Fn = |c: char| -> char::EscapeDefault {
|
||||
c.escape_default()
|
||||
};
|
||||
}
|
||||
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
@ -4011,102 +4135,36 @@ pub struct SplitWhitespace<'a> {
|
||||
#[stable(feature = "split_ascii_whitespace", since = "1.34.0")]
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct SplitAsciiWhitespace<'a> {
|
||||
inner: Map<Filter<SliceSplit<'a, u8, IsAsciiWhitespace>, IsNotEmpty>, UnsafeBytesToStr>,
|
||||
inner: Map<Filter<SliceSplit<'a, u8, IsAsciiWhitespace>, BytesIsNotEmpty>, UnsafeBytesToStr>,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct IsWhitespace;
|
||||
impl_fn_for_zst! {
|
||||
#[derive(Clone)]
|
||||
struct IsWhitespace impl Fn = |c: char| -> bool {
|
||||
c.is_whitespace()
|
||||
};
|
||||
|
||||
impl FnOnce<(char, )> for IsWhitespace {
|
||||
type Output = bool;
|
||||
#[derive(Clone)]
|
||||
struct IsAsciiWhitespace impl Fn = |byte: &u8| -> bool {
|
||||
byte.is_ascii_whitespace()
|
||||
};
|
||||
|
||||
#[inline]
|
||||
extern "rust-call" fn call_once(mut self, arg: (char, )) -> bool {
|
||||
self.call_mut(arg)
|
||||
}
|
||||
#[derive(Clone)]
|
||||
struct IsNotEmpty impl<'a, 'b> Fn = |s: &'a &'b str| -> bool {
|
||||
!s.is_empty()
|
||||
};
|
||||
|
||||
#[derive(Clone)]
|
||||
struct BytesIsNotEmpty impl<'a, 'b> Fn = |s: &'a &'b [u8]| -> bool {
|
||||
!s.is_empty()
|
||||
};
|
||||
|
||||
#[derive(Clone)]
|
||||
struct UnsafeBytesToStr impl<'a> Fn = |bytes: &'a [u8]| -> &'a str {
|
||||
unsafe { from_utf8_unchecked(bytes) }
|
||||
};
|
||||
}
|
||||
|
||||
impl FnMut<(char, )> for IsWhitespace {
|
||||
#[inline]
|
||||
extern "rust-call" fn call_mut(&mut self, arg: (char, )) -> bool {
|
||||
arg.0.is_whitespace()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct IsAsciiWhitespace;
|
||||
|
||||
impl<'a> FnOnce<(&'a u8, )> for IsAsciiWhitespace {
|
||||
type Output = bool;
|
||||
|
||||
#[inline]
|
||||
extern "rust-call" fn call_once(mut self, arg: (&u8, )) -> bool {
|
||||
self.call_mut(arg)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> FnMut<(&'a u8, )> for IsAsciiWhitespace {
|
||||
#[inline]
|
||||
extern "rust-call" fn call_mut(&mut self, arg: (&u8, )) -> bool {
|
||||
arg.0.is_ascii_whitespace()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct IsNotEmpty;
|
||||
|
||||
impl<'a, 'b> FnOnce<(&'a &'b str, )> for IsNotEmpty {
|
||||
type Output = bool;
|
||||
|
||||
#[inline]
|
||||
extern "rust-call" fn call_once(mut self, arg: (&'a &'b str, )) -> bool {
|
||||
self.call_mut(arg)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b> FnMut<(&'a &'b str, )> for IsNotEmpty {
|
||||
#[inline]
|
||||
extern "rust-call" fn call_mut(&mut self, arg: (&'a &'b str, )) -> bool {
|
||||
!arg.0.is_empty()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b> FnOnce<(&'a &'b [u8], )> for IsNotEmpty {
|
||||
type Output = bool;
|
||||
|
||||
#[inline]
|
||||
extern "rust-call" fn call_once(mut self, arg: (&'a &'b [u8], )) -> bool {
|
||||
self.call_mut(arg)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'b> FnMut<(&'a &'b [u8], )> for IsNotEmpty {
|
||||
#[inline]
|
||||
extern "rust-call" fn call_mut(&mut self, arg: (&'a &'b [u8], )) -> bool {
|
||||
!arg.0.is_empty()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct UnsafeBytesToStr;
|
||||
|
||||
impl<'a> FnOnce<(&'a [u8], )> for UnsafeBytesToStr {
|
||||
type Output = &'a str;
|
||||
|
||||
#[inline]
|
||||
extern "rust-call" fn call_once(mut self, arg: (&'a [u8], )) -> &'a str {
|
||||
self.call_mut(arg)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> FnMut<(&'a [u8], )> for UnsafeBytesToStr {
|
||||
#[inline]
|
||||
extern "rust-call" fn call_mut(&mut self, arg: (&'a [u8], )) -> &'a str {
|
||||
unsafe { from_utf8_unchecked(arg.0) }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#[stable(feature = "split_whitespace", since = "1.1.0")]
|
||||
impl<'a> Iterator for SplitWhitespace<'a> {
|
||||
type Item = &'a str;
|
||||
@ -4216,3 +4274,74 @@ impl<'a> Iterator for EncodeUtf16<'a> {
|
||||
|
||||
#[stable(feature = "fused", since = "1.26.0")]
|
||||
impl FusedIterator for EncodeUtf16<'_> {}
|
||||
|
||||
/// The return type of [`str::escape_debug`].
|
||||
///
|
||||
/// [`str::escape_debug`]: ../../std/primitive.str.html#method.escape_debug
|
||||
#[stable(feature = "str_escape", since = "1.34.0")]
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct EscapeDebug<'a> {
|
||||
inner: Chain<
|
||||
Flatten<option::IntoIter<char::EscapeDebug>>,
|
||||
FlatMap<Chars<'a>, char::EscapeDebug, CharEscapeDebugContinue>
|
||||
>,
|
||||
}
|
||||
|
||||
/// The return type of [`str::escape_default`].
|
||||
///
|
||||
/// [`str::escape_default`]: ../../std/primitive.str.html#method.escape_default
|
||||
#[stable(feature = "str_escape", since = "1.34.0")]
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct EscapeDefault<'a> {
|
||||
inner: FlatMap<Chars<'a>, char::EscapeDefault, CharEscapeDefault>,
|
||||
}
|
||||
|
||||
/// The return type of [`str::escape_unicode`].
|
||||
///
|
||||
/// [`str::escape_unicode`]: ../../std/primitive.str.html#method.escape_unicode
|
||||
#[stable(feature = "str_escape", since = "1.34.0")]
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct EscapeUnicode<'a> {
|
||||
inner: FlatMap<Chars<'a>, char::EscapeUnicode, CharEscapeUnicode>,
|
||||
}
|
||||
|
||||
macro_rules! escape_types_impls {
|
||||
($( $Name: ident ),+) => {$(
|
||||
#[stable(feature = "str_escape", since = "1.34.0")]
|
||||
impl<'a> fmt::Display for $Name<'a> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
self.clone().try_for_each(|c| f.write_char(c))
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "str_escape", since = "1.34.0")]
|
||||
impl<'a> Iterator for $Name<'a> {
|
||||
type Item = char;
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<char> { self.inner.next() }
|
||||
|
||||
#[inline]
|
||||
fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
|
||||
|
||||
#[inline]
|
||||
fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
|
||||
Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
|
||||
{
|
||||
self.inner.try_fold(init, fold)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
|
||||
where Fold: FnMut(Acc, Self::Item) -> Acc,
|
||||
{
|
||||
self.inner.fold(init, fold)
|
||||
}
|
||||
}
|
||||
|
||||
#[stable(feature = "str_escape", since = "1.34.0")]
|
||||
impl<'a> FusedIterator for $Name<'a> {}
|
||||
)+}
|
||||
}
|
||||
|
||||
escape_types_impls!(EscapeDebug, EscapeDefault, EscapeUnicode);
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
//! The string Pattern API.
|
||||
//!
|
||||
//! For more details, see the traits `Pattern`, `Searcher`,
|
||||
//! `ReverseSearcher` and `DoubleEndedSearcher`.
|
||||
//! For more details, see the traits [`Pattern`], [`Searcher`],
|
||||
//! [`ReverseSearcher`], and [`DoubleEndedSearcher`].
|
||||
|
||||
#![unstable(feature = "pattern",
|
||||
reason = "API not fully fleshed out and ready to be stabilized",
|
||||
@ -117,7 +117,7 @@ pub unsafe trait Searcher<'a> {
|
||||
/// `[Reject(0, 1), Reject(1, 2), Match(2, 5), Reject(5, 8)]`
|
||||
fn next(&mut self) -> SearchStep;
|
||||
|
||||
/// Find the next `Match` result. See `next()`
|
||||
/// Finds the next `Match` result. See `next()`
|
||||
///
|
||||
/// Unlike next(), there is no guarantee that the returned ranges
|
||||
/// of this and next_reject will overlap. This will return (start_match, end_match),
|
||||
@ -134,7 +134,7 @@ pub unsafe trait Searcher<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Find the next `Reject` result. See `next()` and `next_match()`
|
||||
/// Finds the next `Reject` result. See `next()` and `next_match()`
|
||||
///
|
||||
/// Unlike next(), there is no guarantee that the returned ranges
|
||||
/// of this and next_match will overlap.
|
||||
@ -185,7 +185,7 @@ pub unsafe trait ReverseSearcher<'a>: Searcher<'a> {
|
||||
/// `[Reject(7, 8), Match(4, 7), Reject(1, 4), Reject(0, 1)]`
|
||||
fn next_back(&mut self) -> SearchStep;
|
||||
|
||||
/// Find the next `Match` result. See `next_back()`
|
||||
/// Finds the next `Match` result. See `next_back()`
|
||||
#[inline]
|
||||
fn next_match_back(&mut self) -> Option<(usize, usize)>{
|
||||
loop {
|
||||
@ -197,7 +197,7 @@ pub unsafe trait ReverseSearcher<'a>: Searcher<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Find the next `Reject` result. See `next_back()`
|
||||
/// Finds the next `Reject` result. See `next_back()`
|
||||
#[inline]
|
||||
fn next_reject_back(&mut self) -> Option<(usize, usize)>{
|
||||
loop {
|
||||
|
||||
@ -7,6 +7,7 @@ use result::Result;
|
||||
|
||||
/// Indicates whether a value is available or if the current task has been
|
||||
/// scheduled to receive a wakeup instead.
|
||||
#[must_use = "this `Poll` may be a `Pending` variant, which should be handled"]
|
||||
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
|
||||
pub enum Poll<T> {
|
||||
/// Represents that a value is immediately ready.
|
||||
@ -21,7 +22,7 @@ pub enum Poll<T> {
|
||||
}
|
||||
|
||||
impl<T> Poll<T> {
|
||||
/// Change the ready value of this `Poll` with the closure provided
|
||||
/// Changes the ready value of this `Poll` with the closure provided.
|
||||
pub fn map<U, F>(self, f: F) -> Poll<U>
|
||||
where F: FnOnce(T) -> U
|
||||
{
|
||||
@ -31,7 +32,7 @@ impl<T> Poll<T> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns whether this is `Poll::Ready`
|
||||
/// Returns `true` if this is `Poll::Ready`
|
||||
#[inline]
|
||||
pub fn is_ready(&self) -> bool {
|
||||
match *self {
|
||||
@ -40,7 +41,7 @@ impl<T> Poll<T> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns whether this is `Poll::Pending`
|
||||
/// Returns `true` if this is `Poll::Pending`
|
||||
#[inline]
|
||||
pub fn is_pending(&self) -> bool {
|
||||
!self.is_ready()
|
||||
@ -48,7 +49,7 @@ impl<T> Poll<T> {
|
||||
}
|
||||
|
||||
impl<T, E> Poll<Result<T, E>> {
|
||||
/// Change the success value of this `Poll` with the closure provided
|
||||
/// Changes the success value of this `Poll` with the closure provided.
|
||||
pub fn map_ok<U, F>(self, f: F) -> Poll<Result<U, E>>
|
||||
where F: FnOnce(T) -> U
|
||||
{
|
||||
@ -59,7 +60,7 @@ impl<T, E> Poll<Result<T, E>> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Change the error value of this `Poll` with the closure provided
|
||||
/// Changes the error value of this `Poll` with the closure provided.
|
||||
pub fn map_err<U, F>(self, f: F) -> Poll<Result<T, U>>
|
||||
where F: FnOnce(E) -> U
|
||||
{
|
||||
|
||||
@ -1,3 +1,5 @@
|
||||
#![cfg(not(miri))]
|
||||
|
||||
use core::cell::*;
|
||||
use core::default::Default;
|
||||
use std::mem::drop;
|
||||
|
||||
@ -1,3 +1,5 @@
|
||||
#![cfg(not(miri))]
|
||||
|
||||
mod builders;
|
||||
mod float;
|
||||
mod num;
|
||||
|
||||
@ -1,3 +1,5 @@
|
||||
#![cfg(not(miri))]
|
||||
|
||||
mod sip;
|
||||
|
||||
use std::hash::{Hash, Hasher};
|
||||
|
||||
@ -190,6 +190,7 @@ fn test_iterator_step_by() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_iterator_step_by_nth() {
|
||||
let mut it = (0..16).step_by(5);
|
||||
assert_eq!(it.nth(0), Some(0));
|
||||
@ -208,6 +209,7 @@ fn test_iterator_step_by_nth() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_iterator_step_by_nth_overflow() {
|
||||
#[cfg(target_pointer_width = "8")]
|
||||
type Bigger = u16;
|
||||
@ -253,12 +255,14 @@ fn test_iterator_step_by_nth_overflow() {
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
#[cfg(not(miri))]
|
||||
fn test_iterator_step_by_zero() {
|
||||
let mut it = (0..).step_by(0);
|
||||
it.next();
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_iterator_step_by_size_hint() {
|
||||
struct StubSizeHint(usize, Option<usize>);
|
||||
impl Iterator for StubSizeHint {
|
||||
@ -877,7 +881,7 @@ fn test_iterator_flat_map() {
|
||||
assert_eq!(i, ys.len());
|
||||
}
|
||||
|
||||
/// Test `FlatMap::fold` with items already picked off the front and back,
|
||||
/// Tests `FlatMap::fold` with items already picked off the front and back,
|
||||
/// to make sure all parts of the `FlatMap` are folded correctly.
|
||||
#[test]
|
||||
fn test_iterator_flat_map_fold() {
|
||||
@ -915,7 +919,7 @@ fn test_iterator_flatten() {
|
||||
assert_eq!(i, ys.len());
|
||||
}
|
||||
|
||||
/// Test `Flatten::fold` with items already picked off the front and back,
|
||||
/// Tests `Flatten::fold` with items already picked off the front and back,
|
||||
/// to make sure all parts of the `Flatten` are folded correctly.
|
||||
#[test]
|
||||
fn test_iterator_flatten_fold() {
|
||||
@ -1413,6 +1417,7 @@ fn test_rposition() {
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
#[cfg(not(miri))]
|
||||
fn test_rposition_panic() {
|
||||
let v: [(Box<_>, Box<_>); 4] =
|
||||
[(box 0, box 0), (box 0, box 0),
|
||||
@ -1652,6 +1657,7 @@ fn test_range_inclusive_nth() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_range_step() {
|
||||
#![allow(deprecated)]
|
||||
|
||||
@ -1675,6 +1681,7 @@ fn test_range_step() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_step_by_skip() {
|
||||
assert_eq!((0..640).step_by(128).skip(1).collect::<Vec<_>>(), [128, 256, 384, 512]);
|
||||
assert_eq!((0..=50).step_by(10).nth(3), Some(30));
|
||||
@ -1682,6 +1689,7 @@ fn test_step_by_skip() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))]
|
||||
fn test_range_inclusive_step() {
|
||||
assert_eq!((0..=50).step_by(10).collect::<Vec<_>>(), [0, 10, 20, 30, 40, 50]);
|
||||
assert_eq!((0..=5).step_by(1).collect::<Vec<_>>(), [0, 1, 2, 3, 4, 5]);
|
||||
|
||||
@ -1,3 +1,5 @@
|
||||
#![cfg(not(miri))]
|
||||
|
||||
use core::convert::{TryFrom, TryInto};
|
||||
use core::cmp::PartialEq;
|
||||
use core::fmt::Debug;
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user