---
name: Regression
about: Report something that unexpectedly changed between Rust versions.
-labels: C-bug regression-untriaged
+labels: C-bug, regression-untriaged
---
<!--
Thank you for filing a regression report! 🐛 A regression is something that changed between versions of Rust but was not supposed to.
"url 2.1.1",
]
-[[package]]
-name = "annotate-snippets"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7021ce4924a3f25f802b2cccd1af585e39ea1a363a1aa2e72afe54b67a3a7a7"
-dependencies = [
- "ansi_term 0.11.0",
-]
-
[[package]]
name = "annotate-snippets"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d78ea013094e5ea606b1c05fe35f1dd7ea1eb1ea259908d040b25bd5ec677ee5"
+dependencies = [
+ "yansi-term",
+]
[[package]]
name = "ansi_term"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f8cb5d814eb646a863c4f24978cff2880c4be96ad8cde2c0f0678732902e271"
-[[package]]
-name = "arrayvec"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
-
[[package]]
name = "arrayvec"
version = "0.7.0"
name = "clippy-mini-macro-test"
version = "0.2.0"
+[[package]]
+name = "clippy_dev"
+version = "0.0.1"
+dependencies = [
+ "bytecount",
+ "clap",
+ "itertools 0.9.0",
+ "opener",
+ "regex",
+ "shell-escape",
+ "walkdir",
+]
+
[[package]]
name = "clippy_lints"
version = "0.1.53"
[[package]]
name = "curl"
-version = "0.4.34"
+version = "0.4.36"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e268162af1a5fe89917ae25ba3b0a77c8da752bdc58e7dbb4f15b91fbd33756e"
+checksum = "d0bac9f84ca0977c4d9b8db998689de55b9e976656a6bc87fada2ca710d504c7"
dependencies = [
"curl-sys",
"libc",
"openssl-probe",
"openssl-sys",
"schannel",
- "socket2",
+ "socket2 0.4.0",
"winapi 0.3.9",
]
[[package]]
name = "curl-sys"
-version = "0.4.39+curl-7.74.0"
+version = "0.4.42+curl-7.76.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07a8ce861e7b68a0b394e814d7ee9f1b2750ff8bd10372c6ad3bacc10e86f874"
+checksum = "4636d8d6109c842707018a104051436bffb8991ea20b2d1293db70b6e0ee4c7c"
dependencies = [
"cc",
"libc",
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a33c1b55807fbed163481b5ba66db4b2fa6cde694a5027be10fb724206c5897"
dependencies = [
- "socket2",
+ "socket2 0.3.16",
"winapi 0.3.9",
]
[[package]]
name = "openssl"
-version = "0.10.30"
+version = "0.10.33"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d575eff3665419f9b83678ff2815858ad9d11567e082f5ac1814baba4e2bcb4"
+checksum = "a61075b62a23fef5a29815de7536d940aa35ce96d18ce0cc5076272db678a577"
dependencies = [
"bitflags",
- "cfg-if 0.1.10",
+ "cfg-if 1.0.0",
"foreign-types",
- "lazy_static",
"libc",
+ "once_cell",
"openssl-sys",
]
[[package]]
name = "openssl-src"
-version = "111.12.0+1.1.1h"
+version = "111.15.0+1.1.1k"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "858a4132194f8570a7ee9eb8629e85b23cbc4565f2d4a162e87556e5956abf61"
+checksum = "b1a5f6ae2ac04393b217ea9f700cd04fa9bf3d93fae2872069f3d15d908af70a"
dependencies = [
"cc",
]
[[package]]
name = "openssl-sys"
-version = "0.9.58"
+version = "0.9.61"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a842db4709b604f0fe5d1170ae3565899be2ad3d9cbc72dedc789ac0511f78de"
+checksum = "313752393519e876837e09e1fa183ddef0be7735868dced3196f4472d536277f"
dependencies = [
"autocfg",
"cc",
[[package]]
name = "racer"
-version = "2.1.45"
+version = "2.1.46"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15408926f6207643150e0fc2c54a75a689b192df03ac6c59d42ea99c6782c7f7"
+checksum = "e7cbda48a9124ed2e83766d2c15e3725710d344abca35fad8cf52341a55883b1"
dependencies = [
"bitflags",
"clap",
[[package]]
name = "rustc-ap-rustc_arena"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "259cca0e975ecb05fd289ace45280c30ff792efc04e856a7f18b7fc86a3cb610"
+checksum = "526610f47139efa440178239553b59ea805ff57a532b4e295c71d2a9b18fd676"
dependencies = [
"rustc-ap-rustc_data_structures",
"smallvec",
[[package]]
name = "rustc-ap-rustc_ast"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb9be435d50c88e94bbad6ea468c8680b52c5043bb298ab8058d05251717f8f8"
+checksum = "cf6a9dda0804a7243b0282e3b75a8cf4654c7a61f033e587751941e1fe39391b"
dependencies = [
"bitflags",
"rustc-ap-rustc_data_structures",
"tracing",
]
-[[package]]
-name = "rustc-ap-rustc_ast_passes"
-version = "712.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75246dd1a95a57f7767e53bde3971baa2d948078e180564709f5ea46cf863ddd"
-dependencies = [
- "itertools 0.9.0",
- "rustc-ap-rustc_ast",
- "rustc-ap-rustc_ast_pretty",
- "rustc-ap-rustc_attr",
- "rustc-ap-rustc_data_structures",
- "rustc-ap-rustc_errors",
- "rustc-ap-rustc_feature",
- "rustc-ap-rustc_parse",
- "rustc-ap-rustc_session",
- "rustc-ap-rustc_span",
- "tracing",
-]
-
[[package]]
name = "rustc-ap-rustc_ast_pretty"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79bede0b44bed453fd0034b7ba492840391f6486bf3e17a1af12922f0b98d4cc"
+checksum = "82f5019be8b41a58664169fd2f4b1a37fe82705681db394b76419e4e87d40ab1"
dependencies = [
"rustc-ap-rustc_ast",
"rustc-ap-rustc_span",
"tracing",
]
-[[package]]
-name = "rustc-ap-rustc_attr"
-version = "712.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84a92a4a34b996694ca2dab70361c60d2d48c07adce57e8155b7ec75e069e3ea"
-dependencies = [
- "rustc-ap-rustc_ast",
- "rustc-ap-rustc_ast_pretty",
- "rustc-ap-rustc_data_structures",
- "rustc-ap-rustc_errors",
- "rustc-ap-rustc_feature",
- "rustc-ap-rustc_lexer",
- "rustc-ap-rustc_macros",
- "rustc-ap-rustc_serialize",
- "rustc-ap-rustc_session",
- "rustc-ap-rustc_span",
-]
-
[[package]]
name = "rustc-ap-rustc_data_structures"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cbfa7f82517a1b2efe7106c864c3f930b1da8aff07a27fd317af2f36522fd2e"
+checksum = "a701717fb14549331085756b9741ae3b4bf35808489f1887d72c1d0e0fe52b77"
dependencies = [
- "arrayvec 0.5.2",
+ "arrayvec",
"bitflags",
"cfg-if 0.1.10",
- "crossbeam-utils 0.7.2",
+ "crossbeam-utils 0.8.3",
"ena",
"indexmap",
"jobserver",
"libc",
"measureme",
+ "memmap2",
"parking_lot",
"rustc-ap-rustc_graphviz",
"rustc-ap-rustc_index",
[[package]]
name = "rustc-ap-rustc_errors"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58a272a5101843bcb40900cc9ccf80ecfec62830bb1f4a242986da4a34c0da89"
+checksum = "e3182ce85e8bfc96443475547f2f5aa2b5e67655d9b88721795f36f0ba9e265a"
dependencies = [
- "annotate-snippets 0.8.0",
+ "annotate-snippets",
"atty",
"rustc-ap-rustc_data_structures",
"rustc-ap-rustc_lint_defs",
"winapi 0.3.9",
]
-[[package]]
-name = "rustc-ap-rustc_expand"
-version = "712.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3bc7988f3facf2402fe057405ef0f7fbacc7e7a483da25e35a35ac09491fbbfb"
-dependencies = [
- "rustc-ap-rustc_ast",
- "rustc-ap-rustc_ast_passes",
- "rustc-ap-rustc_ast_pretty",
- "rustc-ap-rustc_attr",
- "rustc-ap-rustc_data_structures",
- "rustc-ap-rustc_errors",
- "rustc-ap-rustc_feature",
- "rustc-ap-rustc_lexer",
- "rustc-ap-rustc_lint_defs",
- "rustc-ap-rustc_macros",
- "rustc-ap-rustc_parse",
- "rustc-ap-rustc_serialize",
- "rustc-ap-rustc_session",
- "rustc-ap-rustc_span",
- "smallvec",
- "tracing",
-]
-
[[package]]
name = "rustc-ap-rustc_feature"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e931cd1580ae60c5737d3fa57633034935e885414e794d83b3e52a81021985c"
+checksum = "eed033b93270126ef60963c3ebbd0e026bf53b985172b6366c7b0e7881c9d507"
dependencies = [
"rustc-ap-rustc_data_structures",
"rustc-ap-rustc_span",
[[package]]
name = "rustc-ap-rustc_fs_util"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fe9422e10d5b441d2a78202667bc85d7cf713a087b9ae6cdea0dfc825d79f07"
+checksum = "28ee6531986a205101e09fd143d7bf31897388f33b1814d4bcc45fd62211dca6"
[[package]]
name = "rustc-ap-rustc_graphviz"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffffffdef9fd51db69c1d4c045ced8aaab999be5627f2d3a0ce020d74c1f1e50"
+checksum = "3398fddc0e23d2db89c036f8952ddf78cadc597f7059752116e69483e164a5b6"
[[package]]
name = "rustc-ap-rustc_index"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f6f53afc4f7111c82295cb7ea3878f520bbac6a2c5a12e125b4ca9156498cff"
+checksum = "dca4e27eb5b701f6bbd47d8fc9d242378fca3e4107a519a28415c2989c4a3bd3"
dependencies = [
- "arrayvec 0.5.2",
+ "arrayvec",
"rustc-ap-rustc_macros",
"rustc-ap-rustc_serialize",
]
[[package]]
name = "rustc-ap-rustc_lexer"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8056b05346dff7e39164d0434c6ec443a14ab5fbf6221bd1a56e5abbeae5f60c"
+checksum = "786bbfe9d4d5264294c1819dbf1497a2480b583d5eda1ca9ae22e12d6661f5df"
dependencies = [
"unicode-xid",
]
[[package]]
name = "rustc-ap-rustc_lint_defs"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "364c3fb7b3cbdfe3fbb21d4078ff2cb3c58df63cda27995f8b064d21ee6dede5"
+checksum = "be2f045e2b999c154ec505d5fea69c994b742f3ebd2f552d11a6c81723921e47"
dependencies = [
"rustc-ap-rustc_ast",
"rustc-ap-rustc_data_structures",
[[package]]
name = "rustc-ap-rustc_macros"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4607d6879cae3bae4d0369ca4b3a7510fd6295ac32eec088ac975208ba96ca45"
+checksum = "27789cd26d6b9e2fdfa68a262a20664d79ca67d31a3886d40fb88ebf6935869c"
dependencies = [
"proc-macro2",
"quote",
[[package]]
name = "rustc-ap-rustc_parse"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78d22889bff7ca2346037c9df7ea55c66ffb714f5b50fb62b41975f8ac7a2d70"
+checksum = "1dc331f4958350679679e619d63a891e8d5d34ef99087068c89aa9e657d52caa"
dependencies = [
"bitflags",
"rustc-ap-rustc_ast",
[[package]]
name = "rustc-ap-rustc_serialize"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d33c710120953c0214f47a6caf42064d7e241003b4af36c98a6d6156e70335f1"
+checksum = "e9a6824a462c4c1a379e911b0faf86d303a54bcf8673d4cc445195085966a4a4"
dependencies = [
"indexmap",
"smallvec",
[[package]]
name = "rustc-ap-rustc_session"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d35919041429a90713c8f704fa5209ba159cb554ce74d95722cbc18ac4b4c6f"
+checksum = "a782a5f6ada0dbe089c6416ad0104f0b8a8bdb4bd26ea95e5fefaec67aed5e8a"
dependencies = [
"bitflags",
"getopts",
[[package]]
name = "rustc-ap-rustc_span"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73b12170c69603c0bf4b50e5c25fd348aae13b8c6465aa0ef4389c9eaa568e51"
+checksum = "a257546cb264b250c7abdb81239bb02f18a274a966211755a3ea89411b122214"
dependencies = [
"cfg-if 0.1.10",
"md-5",
[[package]]
name = "rustc-ap-rustc_target"
-version = "712.0.0"
+version = "718.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a8329d92e7dc24b974f759e6c6e97e2bbc47b18d0573343028f8135ca367200"
+checksum = "b5a72dd689421bcb5750f3ed0dedf367076e714ef0ba56c02ed391b9a8582862"
dependencies = [
"bitflags",
"rustc-ap-rustc_data_structures",
name = "rustc_data_structures"
version = "0.0.0"
dependencies = [
- "arrayvec 0.7.0",
+ "arrayvec",
"bitflags",
"cfg-if 0.1.10",
"crossbeam-utils 0.8.3",
name = "rustc_errors"
version = "0.0.0"
dependencies = [
- "annotate-snippets 0.8.0",
+ "annotate-snippets",
"atty",
"rustc_data_structures",
"rustc_lint_defs",
name = "rustc_index"
version = "0.0.0"
dependencies = [
- "arrayvec 0.7.0",
+ "arrayvec",
"rustc_macros",
"rustc_serialize",
]
name = "rustdoc"
version = "0.0.0"
dependencies = [
- "arrayvec 0.7.0",
+ "arrayvec",
"expect-test",
"itertools 0.9.0",
"minifier",
name = "rustfmt-nightly"
version = "1.4.37"
dependencies = [
- "annotate-snippets 0.6.1",
+ "annotate-snippets",
"anyhow",
"bytecount",
"cargo_metadata 0.8.2",
"lazy_static",
"log",
"regex",
- "rustc-ap-rustc_ast",
- "rustc-ap-rustc_ast_pretty",
- "rustc-ap-rustc_data_structures",
- "rustc-ap-rustc_errors",
- "rustc-ap-rustc_expand",
- "rustc-ap-rustc_parse",
- "rustc-ap-rustc_session",
- "rustc-ap-rustc_span",
"rustc-workspace-hack",
"rustfmt-config_proc_macro",
"serde",
"winapi 0.3.9",
]
+[[package]]
+name = "socket2"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e3dfc207c526015c632472a77be09cf1b6e46866581aecae5cc38fb4235dea2"
+dependencies = [
+ "libc",
+ "winapi 0.3.9",
+]
+
[[package]]
name = "stable_deref_trait"
version = "1.2.0"
dependencies = [
"linked-hash-map",
]
+
+[[package]]
+name = "yansi-term"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe5c30ade05e61656247b2e334a031dfd0cc466fadef865bdcdea8d537951bf1"
+dependencies = [
+ "winapi 0.3.9",
+]
"src/rustdoc-json-types",
"src/tools/cargotest",
"src/tools/clippy",
+ "src/tools/clippy/clippy_dev",
"src/tools/compiletest",
"src/tools/error_index_generator",
"src/tools/linkchecker",
+Version 1.52.0 (2021-05-06)
+============================
+
+Language
+--------
+- [Added the `unsafe_op_in_unsafe_fn` lint, which checks whether the unsafe code
+ in an `unsafe fn` is wrapped in a `unsafe` block.][79208] This lint
+ is allowed by default, and may become a warning or hard error in a
+ future edition.
+- [You can now cast mutable references to arrays to a pointer of the same type as
+ the element.][81479]
+
+Compiler
+--------
+- [Upgraded the default LLVM to LLVM 12.][81451]
+
+Added tier 3\* support for the following targets.
+
+- [`s390x-unknown-linux-musl`][82166]
+- [`riscv32gc-unknown-linux-musl` & `riscv64gc-unknown-linux-musl`][82202]
+- [`powerpc-unknown-openbsd`][82733]
+
+\* Refer to Rust's [platform support page][platform-support-doc] for more
+information on Rust's tiered platform support.
+
+Libraries
+---------
+- [`OsString` now implements `Extend` and `FromIterator`.][82121]
+- [`cmp::Reverse` now has `#[repr(transparent)]` representation.][81879]
+- [`Arc<impl Error>` now implements `error::Error`.][80553]
+- [All integer division and remainder operations are now `const`.][80962]
+
+Stabilised APIs
+-------------
+- [`Arguments::as_str`]
+- [`char::MAX`]
+- [`char::REPLACEMENT_CHARACTER`]
+- [`char::UNICODE_VERSION`]
+- [`char::decode_utf16`]
+- [`char::from_digit`]
+- [`char::from_u32_unchecked`]
+- [`char::from_u32`]
+- [`slice::partition_point`]
+- [`str::rsplit_once`]
+- [`str::split_once`]
+
+The following previously stable APIs are now `const`.
+
+- [`char::len_utf8`]
+- [`char::len_utf16`]
+- [`char::to_ascii_uppercase`]
+- [`char::to_ascii_lowercase`]
+- [`char::eq_ignore_ascii_case`]
+- [`u8::to_ascii_uppercase`]
+- [`u8::to_ascii_lowercase`]
+- [`u8::eq_ignore_ascii_case`]
+
+Rustdoc
+-------
+- [Rustdoc lints are now treated as a tool lint, meaning that
+ lints are now prefixed with `rustdoc::` (e.g. `#[warn(rustdoc::non_autolinks)]`).][80527]
+ Using the old style is still allowed, and will become a warning in
+ a future release.
+- [Rustdoc now supports argument files.][82261]
+- [Rustdoc now generates smart punctuation for documentation.][79423]
+- [You can now use "task lists" in Rustdoc Markdown.][81766] E.g.
+ ```markdown
+ - [x] Complete
+ - [ ] Todo
+ ```
+
+Misc
+----
+- [You can now pass multiple filters to tests.][81356] E.g.
+ `cargo test -- foo bar` will run all tests that match `foo` and `bar`.
+- [Rustup now distributes PDB symbols for the `std` library on Windows,
+ allowing you to see `std` symbols when debugging.][82218]
+
+Internal Only
+-------------
+These changes provide no direct user facing benefits, but represent significant
+improvements to the internals and overall performance of rustc and
+related tools.
+
+- [Check the result cache before the DepGraph when ensuring queries][81855]
+- [Try fast_reject::simplify_type in coherence before doing full check][81744]
+- [Only store a LocalDefId in some HIR nodes][81611]
+- [Store HIR attributes in a side table][79519]
+
+Compatibility Notes
+-------------------
+- [Cargo build scripts are now forbidden from setting `RUSTC_BOOTSTRAP`.][cargo/9181]
+- [Removed support for the `x86_64-rumprun-netbsd` target.][82594]
+- [Deprecated the `x86_64-sun-solaris` target in favor of `x86_64-pc-solaris`.][82216]
+- [Rustdoc now only accepts `,`, ` `, and `\t` as delimiters for specifying
+ languages in code blocks.][78429]
+- [Rustc now catches more cases of `pub_use_of_private_extern_crate`][80763]
+- [Changes in how proc macros handle whitespace may lead to panics when used
+ with older `proc-macro-hack` versions. A `cargo update` should be sufficient to fix this in all cases.][84136]
+
+[84136]: https://github.com/rust-lang/rust/issues/84136
+[80763]: https://github.com/rust-lang/rust/pull/80763
+[82166]: https://github.com/rust-lang/rust/pull/82166
+[82121]: https://github.com/rust-lang/rust/pull/82121
+[81879]: https://github.com/rust-lang/rust/pull/81879
+[82261]: https://github.com/rust-lang/rust/pull/82261
+[82218]: https://github.com/rust-lang/rust/pull/82218
+[82216]: https://github.com/rust-lang/rust/pull/82216
+[82202]: https://github.com/rust-lang/rust/pull/82202
+[81855]: https://github.com/rust-lang/rust/pull/81855
+[81766]: https://github.com/rust-lang/rust/pull/81766
+[81744]: https://github.com/rust-lang/rust/pull/81744
+[81611]: https://github.com/rust-lang/rust/pull/81611
+[81479]: https://github.com/rust-lang/rust/pull/81479
+[81451]: https://github.com/rust-lang/rust/pull/81451
+[81356]: https://github.com/rust-lang/rust/pull/81356
+[80962]: https://github.com/rust-lang/rust/pull/80962
+[80553]: https://github.com/rust-lang/rust/pull/80553
+[80527]: https://github.com/rust-lang/rust/pull/80527
+[79519]: https://github.com/rust-lang/rust/pull/79519
+[79423]: https://github.com/rust-lang/rust/pull/79423
+[79208]: https://github.com/rust-lang/rust/pull/79208
+[78429]: https://github.com/rust-lang/rust/pull/78429
+[82733]: https://github.com/rust-lang/rust/pull/82733
+[82594]: https://github.com/rust-lang/rust/pull/82594
+[cargo/9181]: https://github.com/rust-lang/cargo/pull/9181
+[`char::MAX`]: https://doc.rust-lang.org/std/primitive.char.html#associatedconstant.MAX
+[`char::REPLACEMENT_CHARACTER`]: https://doc.rust-lang.org/std/primitive.char.html#associatedconstant.REPLACEMENT_CHARACTER
+[`char::UNICODE_VERSION`]: https://doc.rust-lang.org/std/primitive.char.html#associatedconstant.UNICODE_VERSION
+[`char::decode_utf16`]: https://doc.rust-lang.org/std/primitive.char.html#method.decode_utf16
+[`char::from_u32`]: https://doc.rust-lang.org/std/primitive.char.html#method.from_u32
+[`char::from_u32_unchecked`]: https://doc.rust-lang.org/std/primitive.char.html#method.from_u32_unchecked
+[`char::from_digit`]: https://doc.rust-lang.org/std/primitive.char.html#method.from_digit
+[`Peekable::next_if`]: https://doc.rust-lang.org/stable/std/iter/struct.Peekable.html#method.next_if
+[`Peekable::next_if_eq`]: https://doc.rust-lang.org/stable/std/iter/struct.Peekable.html#method.next_if_eq
+[`Arguments::as_str`]: https://doc.rust-lang.org/stable/std/fmt/struct.Arguments.html#method.as_str
+[`str::split_once`]: https://doc.rust-lang.org/stable/std/primitive.str.html#method.split_once
+[`str::rsplit_once`]: https://doc.rust-lang.org/stable/std/primitive.str.html#method.rsplit_once
+[`slice::partition_point`]: https://doc.rust-lang.org/stable/std/primitive.slice.html#method.partition_point
+[`char::len_utf8`]: https://doc.rust-lang.org/stable/std/primitive.char.html#method.len_utf8
+[`char::len_utf16`]: https://doc.rust-lang.org/stable/std/primitive.char.html#method.len_utf16
+[`char::to_ascii_uppercase`]: https://doc.rust-lang.org/stable/std/primitive.char.html#method.to_ascii_uppercase
+[`char::to_ascii_lowercase`]: https://doc.rust-lang.org/stable/std/primitive.char.html#method.to_ascii_lowercase
+[`char::eq_ignore_ascii_case`]: https://doc.rust-lang.org/stable/std/primitive.char.html#method.eq_ignore_ascii_case
+[`u8::to_ascii_uppercase`]: https://doc.rust-lang.org/stable/std/primitive.u8.html#method.to_ascii_uppercase
+[`u8::to_ascii_lowercase`]: https://doc.rust-lang.org/stable/std/primitive.u8.html#method.to_ascii_lowercase
+[`u8::eq_ignore_ascii_case`]: https://doc.rust-lang.org/stable/std/primitive.u8.html#method.eq_ignore_ascii_case
+
Version 1.51.0 (2021-03-25)
============================
let mut generic_args = vec![];
for (idx, arg) in args.into_iter().enumerate() {
if legacy_args_idx.contains(&idx) {
- let parent_def_id = self.current_hir_id_owner.last().unwrap().0;
+ let parent_def_id = self.current_hir_id_owner.0;
let node_id = self.resolver.next_node_id();
// Add a definition for the in-band const def.
use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::sync::Lrc;
-use rustc_errors::struct_span_err;
+use rustc_errors::{struct_span_err, Applicability};
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Namespace, PartialRes, PerNS, Res};
use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId, CRATE_DEF_ID};
use rustc_session::lint::{BuiltinLintDiagnostics, LintBuffer};
use rustc_session::utils::{FlattenNonterminals, NtToTokenstream};
use rustc_session::Session;
+use rustc_span::edition::Edition;
use rustc_span::hygiene::ExpnId;
use rustc_span::source_map::{respan, DesugaringKind};
use rustc_span::symbol::{kw, sym, Ident, Symbol};
type_def_lifetime_params: DefIdMap<usize>,
- current_hir_id_owner: Vec<(LocalDefId, u32)>,
+ current_hir_id_owner: (LocalDefId, u32),
item_local_id_counters: NodeMap<u32>,
node_id_to_hir_id: IndexVec<NodeId, Option<hir::HirId>>,
anonymous_lifetime_mode: AnonymousLifetimeMode::PassThrough,
type_def_lifetime_params: Default::default(),
current_module: CRATE_DEF_ID,
- current_hir_id_owner: vec![(CRATE_DEF_ID, 0)],
+ current_hir_id_owner: (CRATE_DEF_ID, 0),
item_local_id_counters: Default::default(),
node_id_to_hir_id: IndexVec::new(),
generator_kind: None,
.insert(owner, HIR_ID_COUNTER_LOCKED)
.unwrap_or_else(|| panic!("no `item_local_id_counters` entry for {:?}", owner));
let def_id = self.resolver.local_def_id(owner);
- self.current_hir_id_owner.push((def_id, counter));
+ let old_owner = std::mem::replace(&mut self.current_hir_id_owner, (def_id, counter));
let ret = f(self);
- let (new_def_id, new_counter) = self.current_hir_id_owner.pop().unwrap();
+ let (new_def_id, new_counter) =
+ std::mem::replace(&mut self.current_hir_id_owner, old_owner);
debug_assert!(def_id == new_def_id);
debug_assert!(new_counter >= counter);
/// properly. Calling the method twice with the same `NodeId` is fine though.
fn lower_node_id(&mut self, ast_node_id: NodeId) -> hir::HirId {
self.lower_node_id_generic(ast_node_id, |this| {
- let &mut (owner, ref mut local_id_counter) =
- this.current_hir_id_owner.last_mut().unwrap();
+ let &mut (owner, ref mut local_id_counter) = &mut this.current_hir_id_owner;
let local_id = *local_id_counter;
*local_id_counter += 1;
hir::HirId { owner, local_id: hir::ItemLocalId::from_u32(local_id) }
// wouldn't have been added yet.
let generics = this.lower_generics_mut(
generics,
- ImplTraitContext::Universal(
- &mut params,
- this.current_hir_id_owner.last().unwrap().0,
- ),
+ ImplTraitContext::Universal(&mut params, this.current_hir_id_owner.0),
);
let res = f(this, &mut params);
(params, (generics, res))
}
AssocTyConstraintKind::Bound { ref bounds } => {
let mut capturable_lifetimes;
- let mut parent_def_id = self.current_hir_id_owner.last().unwrap().0;
+ let mut parent_def_id = self.current_hir_id_owner.0;
// Piggy-back on the `impl Trait` context to figure out the correct behavior.
let (desugar_to_impl_trait, itctx) = match itctx {
// We are in the return position:
// Construct a AnonConst where the expr is the "ty"'s path.
- let parent_def_id = self.current_hir_id_owner.last().unwrap().0;
+ let parent_def_id = self.current_hir_id_owner.0;
let node_id = self.resolver.next_node_id();
// Add a definition for the in-band const def.
if let Some((_, ibty)) = &mut in_band_ty_params {
this.lower_ty_direct(
¶m.ty,
- ImplTraitContext::Universal(
- ibty,
- this.current_hir_id_owner.last().unwrap().0,
- ),
+ ImplTraitContext::Universal(ibty, this.current_hir_id_owner.0),
)
} else {
this.lower_ty_direct(¶m.ty, ImplTraitContext::disallowed())
.map(|snippet| snippet.starts_with("#["))
.unwrap_or(true);
if !is_macro_callsite {
- self.resolver.lint_buffer().buffer_lint_with_diagnostic(
- BARE_TRAIT_OBJECTS,
- id,
- span,
- "trait objects without an explicit `dyn` are deprecated",
- BuiltinLintDiagnostics::BareTraitObject(span, is_global),
- )
+ if span.edition() < Edition::Edition2021 {
+ self.resolver.lint_buffer().buffer_lint_with_diagnostic(
+ BARE_TRAIT_OBJECTS,
+ id,
+ span,
+ "trait objects without an explicit `dyn` are deprecated",
+ BuiltinLintDiagnostics::BareTraitObject(span, is_global),
+ )
+ } else {
+ let msg = "trait objects must include the `dyn` keyword";
+ let label = "add `dyn` keyword before this trait";
+ let mut err = struct_span_err!(self.sess, span, E0782, "{}", msg,);
+ err.span_suggestion_verbose(
+ span.shrink_to_lo(),
+ label,
+ String::from("dyn "),
+ Applicability::MachineApplicable,
+ );
+ err.emit();
+ }
}
}
);
}
}
+
+ // Check for unstable modifiers on `#[link(..)]` attribute
+ if self.sess.check_name(attr, sym::link) {
+ for nested_meta in attr.meta_item_list().unwrap_or_default() {
+ if nested_meta.has_name(sym::modifiers) {
+ gate_feature_post!(
+ self,
+ native_link_modifiers,
+ nested_meta.span(),
+ "native link modifiers are experimental"
+ );
+
+ if let Some(modifiers) = nested_meta.value_str() {
+ for modifier in modifiers.as_str().split(',') {
+ if let Some(modifier) = modifier.strip_prefix(&['+', '-'][..]) {
+ macro_rules! gate_modifier { ($($name:literal => $feature:ident)*) => {
+ $(if modifier == $name {
+ let msg = concat!("`#[link(modifiers=\"", $name, "\")]` is unstable");
+ gate_feature_post!(
+ self,
+ $feature,
+ nested_meta.name_value_literal_span().unwrap(),
+ msg
+ );
+ })*
+ }}
+
+ gate_modifier!(
+ "bundle" => native_link_modifiers_bundle
+ "verbatim" => native_link_modifiers_verbatim
+ "whole-archive" => native_link_modifiers_whole_archive
+ "as-needed" => native_link_modifiers_as_needed
+ );
+ }
+ }
+ }
+ }
+ }
+ }
}
fn visit_item(&mut self, i: &'a ast::Item) {
self.print_either_attributes(attrs, ast::AttrStyle::Inner, false, true)
}
- fn print_inner_attributes_no_trailing_hardbreak(&mut self, attrs: &[ast::Attribute]) {
- self.print_either_attributes(attrs, ast::AttrStyle::Inner, false, false)
- }
-
fn print_outer_attributes(&mut self, attrs: &[ast::Attribute]) {
self.print_either_attributes(attrs, ast::AttrStyle::Outer, false, true)
}
}
}
- fn print_expr_vec(&mut self, exprs: &[P<ast::Expr>], attrs: &[ast::Attribute]) {
+ fn print_expr_vec(&mut self, exprs: &[P<ast::Expr>]) {
self.ibox(INDENT_UNIT);
self.s.word("[");
- self.print_inner_attributes_inline(attrs);
self.commasep_exprs(Inconsistent, exprs);
self.s.word("]");
self.end();
}
- fn print_expr_anon_const(&mut self, expr: &ast::AnonConst, attrs: &[ast::Attribute]) {
+ fn print_expr_anon_const(&mut self, expr: &ast::AnonConst) {
self.ibox(INDENT_UNIT);
self.s.word("const");
- self.print_inner_attributes_inline(attrs);
self.print_expr(&expr.value);
self.end();
}
- fn print_expr_repeat(
- &mut self,
- element: &ast::Expr,
- count: &ast::AnonConst,
- attrs: &[ast::Attribute],
- ) {
+ fn print_expr_repeat(&mut self, element: &ast::Expr, count: &ast::AnonConst) {
self.ibox(INDENT_UNIT);
self.s.word("[");
- self.print_inner_attributes_inline(attrs);
self.print_expr(element);
self.word_space(";");
self.print_expr(&count.value);
path: &ast::Path,
fields: &[ast::ExprField],
rest: &ast::StructRest,
- attrs: &[ast::Attribute],
) {
self.print_path(path, true, 0);
self.s.word("{");
- self.print_inner_attributes_inline(attrs);
self.commasep_cmnt(
Consistent,
fields,
self.s.word("}");
}
- fn print_expr_tup(&mut self, exprs: &[P<ast::Expr>], attrs: &[ast::Attribute]) {
+ fn print_expr_tup(&mut self, exprs: &[P<ast::Expr>]) {
self.popen();
- self.print_inner_attributes_inline(attrs);
self.commasep_exprs(Inconsistent, exprs);
if exprs.len() == 1 {
self.s.word(",");
self.print_expr_maybe_paren(expr, parser::PREC_PREFIX);
}
ast::ExprKind::Array(ref exprs) => {
- self.print_expr_vec(&exprs[..], attrs);
+ self.print_expr_vec(exprs);
}
ast::ExprKind::ConstBlock(ref anon_const) => {
- self.print_expr_anon_const(anon_const, attrs);
+ self.print_expr_anon_const(anon_const);
}
ast::ExprKind::Repeat(ref element, ref count) => {
- self.print_expr_repeat(element, count, attrs);
+ self.print_expr_repeat(element, count);
}
ast::ExprKind::Struct(ref se) => {
- self.print_expr_struct(&se.path, &se.fields, &se.rest, attrs);
+ self.print_expr_struct(&se.path, &se.fields, &se.rest);
}
ast::ExprKind::Tup(ref exprs) => {
- self.print_expr_tup(&exprs[..], attrs);
+ self.print_expr_tup(exprs);
}
ast::ExprKind::Call(ref func, ref args) => {
self.print_expr_call(func, &args[..]);
self.print_expr_as_cond(expr);
self.s.space();
self.bopen();
- self.print_inner_attributes_no_trailing_hardbreak(attrs);
for arm in arms {
self.print_arm(arm);
}
ast::ExprKind::MacCall(ref m) => self.print_mac(m),
ast::ExprKind::Paren(ref e) => {
self.popen();
- self.print_inner_attributes_inline(attrs);
self.print_expr(e);
self.pclose();
}
item: &Annotatable,
push: &mut dyn FnMut(Annotatable),
) {
+ let span = cx.with_def_site_ctxt(span);
let inline = cx.meta_word(span, sym::inline);
- let no_coverage_ident =
- rustc_ast::attr::mk_nested_word_item(Ident::new(sym::no_coverage, span));
- let no_coverage_feature =
- rustc_ast::attr::mk_list_item(Ident::new(sym::feature, span), vec![no_coverage_ident]);
- let no_coverage = cx.meta_word(span, sym::no_coverage);
let hidden = rustc_ast::attr::mk_nested_word_item(Ident::new(sym::hidden, span));
let doc = rustc_ast::attr::mk_list_item(Ident::new(sym::doc, span), vec![hidden]);
- let attrs = vec![
- cx.attribute(inline),
- cx.attribute(no_coverage_feature),
- cx.attribute(no_coverage),
- cx.attribute(doc),
- ];
+ let no_coverage = cx.meta_word(span, sym::no_coverage);
+ let attrs = vec![cx.attribute(inline), cx.attribute(doc), cx.attribute(no_coverage)];
let trait_def = TraitDef {
span,
attributes: Vec::new(),
with:
name: cg_clif-${{ runner.os }}
path: cg_clif.tar.xz
+
+ - name: Upload prebuilt cg_clif (cross compile)
+ if: matrix.env.TARGET_TRIPLE == 'x86_64-pc-windows-gnu'
+ uses: actions/upload-artifact@v2
+ with:
+ name: cg_clif-${{ runner.os }}-cross-x86_64-mingw
+ path: cg_clif.tar.xz
{
// source for rustc_* is not included in the rust-src component; disable the errors about this
- "rust-analyzer.diagnostics.disabled": ["unresolved-extern-crate", "macro-error"],
+ "rust-analyzer.diagnostics.disabled": ["unresolved-extern-crate", "unresolved-macro-call"],
"rust-analyzer.assist.importMergeBehavior": "last",
"rust-analyzer.cargo.runBuildScripts": true,
"rust-analyzer.linkedProjects": [
[[package]]
name = "cranelift-bforest"
-version = "0.72.0"
-source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#8e43e96410a14143d368273cf1e708f8094bb8e0"
+version = "0.73.0"
+source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#45bee40f338c631bff4a799288101ba328c7ad36"
dependencies = [
"cranelift-entity",
]
[[package]]
name = "cranelift-codegen"
-version = "0.72.0"
-source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#8e43e96410a14143d368273cf1e708f8094bb8e0"
+version = "0.73.0"
+source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#45bee40f338c631bff4a799288101ba328c7ad36"
dependencies = [
"byteorder",
"cranelift-bforest",
[[package]]
name = "cranelift-codegen-meta"
-version = "0.72.0"
-source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#8e43e96410a14143d368273cf1e708f8094bb8e0"
+version = "0.73.0"
+source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#45bee40f338c631bff4a799288101ba328c7ad36"
dependencies = [
"cranelift-codegen-shared",
"cranelift-entity",
[[package]]
name = "cranelift-codegen-shared"
-version = "0.72.0"
-source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#8e43e96410a14143d368273cf1e708f8094bb8e0"
+version = "0.73.0"
+source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#45bee40f338c631bff4a799288101ba328c7ad36"
[[package]]
name = "cranelift-entity"
-version = "0.72.0"
-source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#8e43e96410a14143d368273cf1e708f8094bb8e0"
+version = "0.73.0"
+source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#45bee40f338c631bff4a799288101ba328c7ad36"
[[package]]
name = "cranelift-frontend"
-version = "0.72.0"
-source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#8e43e96410a14143d368273cf1e708f8094bb8e0"
+version = "0.73.0"
+source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#45bee40f338c631bff4a799288101ba328c7ad36"
dependencies = [
"cranelift-codegen",
"log",
[[package]]
name = "cranelift-jit"
-version = "0.72.0"
-source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#8e43e96410a14143d368273cf1e708f8094bb8e0"
+version = "0.73.0"
+source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#45bee40f338c631bff4a799288101ba328c7ad36"
dependencies = [
"anyhow",
"cranelift-codegen",
[[package]]
name = "cranelift-module"
-version = "0.72.0"
-source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#8e43e96410a14143d368273cf1e708f8094bb8e0"
+version = "0.73.0"
+source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#45bee40f338c631bff4a799288101ba328c7ad36"
dependencies = [
"anyhow",
"cranelift-codegen",
[[package]]
name = "cranelift-native"
-version = "0.72.0"
-source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#8e43e96410a14143d368273cf1e708f8094bb8e0"
+version = "0.73.0"
+source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#45bee40f338c631bff4a799288101ba328c7ad36"
dependencies = [
"cranelift-codegen",
"target-lexicon",
[[package]]
name = "cranelift-object"
-version = "0.72.0"
-source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#8e43e96410a14143d368273cf1e708f8094bb8e0"
+version = "0.73.0"
+source = "git+https://github.com/bytecodealliance/wasmtime/?branch=main#45bee40f338c631bff4a799288101ba328c7ad36"
dependencies = [
"anyhow",
"cranelift-codegen",
"cranelift-frontend",
"cranelift-jit",
"cranelift-module",
+ "cranelift-native",
"cranelift-object",
"gimli",
"indexmap",
[[package]]
name = "target-lexicon"
-version = "0.11.2"
+version = "0.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "422045212ea98508ae3d28025bc5aaa2bd4a9cdaecd442a08da2ee620ee9ea95"
+checksum = "64ae3b39281e4b14b8123bdbaddd472b7dfe215e444181f2f9d2443c2444f834"
[[package]]
name = "thiserror"
[dependencies]
# These have to be in sync with each other
-cranelift-codegen = { git = "https://github.com/bytecodealliance/wasmtime/", branch = "main", features = ["unwind", "x64"] }
+cranelift-codegen = { git = "https://github.com/bytecodealliance/wasmtime/", branch = "main", features = ["unwind"] }
cranelift-frontend = { git = "https://github.com/bytecodealliance/wasmtime/", branch = "main" }
cranelift-module = { git = "https://github.com/bytecodealliance/wasmtime/", branch = "main" }
+cranelift-native = { git = "https://github.com/bytecodealliance/wasmtime/", branch = "main" }
cranelift-jit = { git = "https://github.com/bytecodealliance/wasmtime/", branch = "main", optional = true }
cranelift-object = { git = "https://github.com/bytecodealliance/wasmtime/", branch = "main" }
-target-lexicon = "0.11.0"
+target-lexicon = "0.12.0"
gimli = { version = "0.23.0", default-features = false, features = ["write"]}
object = { version = "0.23.0", default-features = false, features = ["std", "read_core", "write", "archive", "coff", "elf", "macho", "pe"] }
#cranelift-codegen = { path = "../wasmtime/cranelift/codegen" }
#cranelift-frontend = { path = "../wasmtime/cranelift/frontend" }
#cranelift-module = { path = "../wasmtime/cranelift/module" }
+#cranelift-native = { path = ../wasmtime/cranelift/native" }
#cranelift-jit = { path = "../wasmtime/cranelift/jit" }
#cranelift-object = { path = "../wasmtime/cranelift/object" }
For additional ways to use rustc_codegen_cranelift like the JIT mode see [usage.md](docs/usage.md).
-## Env vars
+## Configuration
-See [env_vars.md](docs/env_vars.md) for all env vars used by rustc_codegen_cranelift.
+See the documentation on the `BackendConfig` struct in [config.rs](src/config.rs) for all
+configuration options.
## Not yet supported
[[package]]
name = "compiler_builtins"
-version = "0.1.39"
+version = "0.1.40"
dependencies = [
"rustc-std-workspace-core",
]
[[package]]
name = "libc"
-version = "0.2.91"
+version = "0.2.94"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8916b1f6ca17130ec6568feccee27c156ad12037880833a3b842a823236502e7"
+checksum = "18794a8ad5b29321f790b55d93dfba91e125cb1a9edbd4f8e3150acc771c1a5e"
dependencies = [
"rustc-std-workspace-core",
]
name = "panic_abort"
version = "0.0.0"
dependencies = [
+ "alloc",
"cfg-if",
"compiler_builtins",
"core",
"panic_abort",
"panic_unwind",
"rustc-demangle",
+ "std_detect",
"unwind",
"wasi",
]
+[[package]]
+name = "std_detect"
+version = "0.1.5"
+dependencies = [
+ "cfg-if",
+ "compiler_builtins",
+ "libc",
+ "rustc-std-workspace-alloc",
+ "rustc-std-workspace-core",
+]
+
[[package]]
name = "sysroot"
version = "0.0.0"
git clone https://github.com/rust-lang/compiler-builtins.git || echo "rust-lang/compiler-builtins has already been cloned"
pushd compiler-builtins
git checkout -- .
-git checkout 0.1.39
+git checkout 0.1.40
git apply ../../crate_patches/000*-compiler-builtins-*.patch
popd
fn wrapping_shr(self, other: u32) -> Self;
- fn rotate_left(self, other: u32) -> Self;
fn overflowing_add(self, other: Self) -> (Self, bool);
- fn aborting_div(self, other: Self) -> Self;
- fn aborting_rem(self, other: Self) -> Self;
+ fn leading_zeros(self) -> u32;
+ }
@@ -209,10 +208,6 @@ macro_rules! int_impl_common {
<Self>::wrapping_shr(self, other)
}
+++ /dev/null
-# List of env vars recognized by cg_clif
-
-<dl>
- <dt>CG_CLIF_JIT_ARGS</dt>
- <dd>When JIT mode is enable pass these arguments to the program.</dd>
- <dt>CG_CLIF_INCR_CACHE_DISABLED</dt>
- <dd>Don't cache object files in the incremental cache. Useful during development of cg_clif
- to make it possible to use incremental mode for all analyses performed by rustc without caching
- object files when their content should have been changed by a change to cg_clif.</dd>
- <dt>CG_CLIF_DISPLAY_CG_TIME</dt>
- <dd>If "1", display the time it took to perform codegen for a crate.</dd>
- <dt>CG_CLIF_ENABLE_VERIFIER</dt>
- <dd>Enable the Cranelift ir verifier for all compilation passes. If not set it will only run once
- before passing the clif ir to Cranelift for compilation.</dt>
-</dl>
puts(s);
}
+macro_rules! assert {
+ ($e:expr) => {
+ if !$e {
+ panic(stringify!(! $e));
+ }
+ };
+}
+
+macro_rules! assert_eq {
+ ($l:expr, $r: expr) => {
+ if $l != $r {
+ panic(stringify!($l != $r));
+ }
+ }
+}
+
#[lang = "termination"]
trait Termination {
fn report(self) -> i32;
fn report(self) -> i32 {
unsafe {
NUM = 6 * 7 + 1 + (1u8 == 1u8) as u8; // 44
- *NUM_REF as i32
+ assert_eq!(*NUM_REF as i32, 44);
}
+ 0
}
}
unsafe { puts(*((argv as usize + 2 * intrinsics::size_of::<*const u8>()) as *const *const i8)); }
}
- main().report();
- 0
+ main().report() as isize
}
static mut NUM: u8 = 6 * 7;
static NUM_REF: &'static u8 = unsafe { &NUM };
-macro_rules! assert {
- ($e:expr) => {
- if !$e {
- panic(stringify!(! $e));
- }
- };
-}
-
-macro_rules! assert_eq {
- ($l:expr, $r: expr) => {
- if $l != $r {
- panic(stringify!($l != $r));
- }
- }
-}
-
struct Unique<T: ?Sized> {
pointer: *const T,
_marker: PhantomData<T>,
unsafe {
global_asm_test();
}
+
+ // Both statics have a reference that points to the same anonymous allocation.
+ static REF1: &u8 = &42;
+ static REF2: &u8 = REF1;
+ assert_eq!(*REF1, *REF2);
}
#[cfg(all(not(jit), target_os = "linux"))]
assert_eq!(2.3f32.copysign(-1.0), -2.3f32);
println!("{}", 2.3f32.powf(2.0));
+ assert_eq!(i64::MAX.checked_mul(2), None);
+
assert_eq!(-128i8, (-128i8).saturating_sub(1));
assert_eq!(127i8, 127i8.saturating_sub(-128));
assert_eq!(-128i8, (-128i8).saturating_add(-128));
assert_eq!(houndred_i128 as f64, 100.0);
assert_eq!(houndred_f32 as i128, 100);
assert_eq!(houndred_f64 as i128, 100);
+ assert_eq!(1u128.rotate_left(2), 4);
// Test signed 128bit comparing
let max = usize::MAX as i128;
[toolchain]
-channel = "nightly-2021-03-29"
+channel = "nightly-2021-04-28"
components = ["rust-src", "rustc-dev", "llvm-tools-preview"]
set -e
export CG_CLIF_DISPLAY_CG_TIME=1
-export CG_CLIF_INCR_CACHE_DISABLED=1
+export CG_CLIF_DISABLE_INCR_CACHE=1
export HOST_TRIPLE=$(rustc -vV | grep host | cut -d: -f2 | tr -d " ")
export TARGET_TRIPLE=${TARGET_TRIPLE:-$HOST_TRIPLE}
[dependencies]
core = { path = "../core" }
-compiler_builtins = { version = "0.1.39", features = ['rustc-dep-of-std'] }
-+compiler_builtins = { version = "0.1.39", features = ['rustc-dep-of-std', 'no-asm'] }
++compiler_builtins = { version = "0.1.40", features = ['rustc-dep-of-std', 'no-asm'] }
[dev-dependencies]
rand = "0.7"
rm src/test/ui/numbers-arithmetic/int-abs-overflow.rs
rm src/test/ui/drop/drop-trait-enum.rs
rm src/test/ui/numbers-arithmetic/issue-8460.rs
+rm src/test/incremental/change_crate_dep_kind.rs # requires -Cpanic=unwind
rm src/test/ui/issues/issue-28950.rs # depends on stack size optimizations
rm src/test/ui/init-large-type.rs # same
rm src/test/ui/numbers-arithmetic/saturating-float-casts.rs # intrinsic gives different but valid result
rm src/test/ui/mir/mir_misc_casts.rs # depends on deduplication of constants
rm src/test/ui/mir/mir_raw_fat_ptr.rs # same
+rm src/test/ui/consts/issue-33537.rs # same
rm src/test/ui/async-await/async-fn-size-moved-locals.rs # -Cpanic=abort shrinks some generator by one byte
rm src/test/ui/async-await/async-fn-size-uninit-locals.rs # same
rm src/test/ui/generator/size-moved-locals.rs # same
rm src/test/incremental/hashes/inline_asm.rs # inline asm
rm src/test/incremental/issue-72386.rs # same
-rm src/test/incremental/change_crate_dep_kind.rs # requires -Cpanic=unwind
rm src/test/incremental/issue-49482.rs # same
rm src/test/incremental/issue-54059.rs # same
rm src/test/incremental/lto.rs # requires lto
+rm -r src/test/run-make/emit-shared-files # requires the rustdoc executable in build/bin/
+rm -r src/test/run-make/unstable-flag-required # same
+
rm src/test/pretty/asm.rs # inline asm
rm src/test/pretty/raw-str-nonexpr.rs # same
rm src/test/ui/json-bom-plus-crlf-multifile.rs # differing warning
rm src/test/ui/json-bom-plus-crlf.rs # same
+rm src/test/ui/match/issue-82392.rs # differing error
rm src/test/ui/type-alias-impl-trait/cross_crate_ice*.rs # requires removed aux dep
rm src/test/ui/allocator/no_std-alloc-error-handler-default.rs # missing rust_oom definition
module: &mut dyn Module,
inst: Instance<'tcx>,
) -> FuncId {
- let name = tcx.symbol_name(inst).name.to_string();
+ let name = tcx.symbol_name(inst).name;
let sig = get_function_sig(tcx, module.isa().triple(), inst);
- module.declare_function(&name, Linkage::Import, &sig).unwrap()
+ module.declare_function(name, Linkage::Import, &sig).unwrap()
}
impl<'tcx> FunctionCx<'_, '_, 'tcx> {
/// Instance must be monomorphized
pub(crate) fn get_function_ref(&mut self, inst: Instance<'tcx>) -> FuncRef {
- let func_id = import_function(self.tcx, self.cx.module, inst);
- let func_ref = self.cx.module.declare_func_in_func(func_id, &mut self.bcx.func);
+ let func_id = import_function(self.tcx, self.module, inst);
+ let func_ref = self.module.declare_func_in_func(func_id, &mut self.bcx.func);
if self.clif_comments.enabled() {
self.add_comment(func_ref, format!("{:?}", inst));
args: &[Value],
) -> &[Value] {
let sig = Signature { params, returns, call_conv: CallConv::triple_default(self.triple()) };
- let func_id = self.cx.module.declare_function(&name, Linkage::Import, &sig).unwrap();
- let func_ref = self.cx.module.declare_func_in_func(func_id, &mut self.bcx.func);
+ let func_id = self.module.declare_function(name, Linkage::Import, &sig).unwrap();
+ let func_ref = self.module.declare_func_in_func(func_id, &mut self.bcx.func);
let call_inst = self.bcx.ins().call(func_ref, args);
if self.clif_comments.enabled() {
self.add_comment(call_inst, format!("easy_call {}", name));
pub(crate) fn codegen_terminator_call<'tcx>(
fx: &mut FunctionCx<'_, '_, 'tcx>,
span: Span,
- current_block: Block,
func: &Operand<'tcx>,
args: &[Operand<'tcx>],
destination: Option<(Place<'tcx>, BasicBlock)>,
.map(|inst| fx.tcx.codegen_fn_attrs(inst.def_id()).flags.contains(CodegenFnAttrFlags::COLD))
.unwrap_or(false);
if is_cold {
- fx.cold_blocks.insert(current_block);
+ // FIXME Mark current_block block as cold once Cranelift supports it
}
// Unpack arguments tuple for closures
pub(crate) fn codegen(
tcx: TyCtxt<'_>,
module: &mut impl Module,
- unwind_context: &mut UnwindContext<'_>,
+ unwind_context: &mut UnwindContext,
) -> bool {
let any_dynamic_crate = tcx.dependency_formats(LOCAL_CRATE).iter().any(|(_, list)| {
use rustc_middle::middle::dependency_format::Linkage;
fn codegen_inner(
module: &mut impl Module,
- unwind_context: &mut UnwindContext<'_>,
+ unwind_context: &mut UnwindContext,
kind: AllocatorKind,
) {
let usize_ty = module.target_config().pointer_type();
));
}
- fn add_native_library(&mut self, name: rustc_span::symbol::Symbol) {
- let location = find_library(name, &self.lib_search_paths, self.sess);
+ fn add_native_library(&mut self, name: rustc_span::symbol::Symbol, verbatim: bool) {
+ let location = find_library(name, verbatim, &self.lib_search_paths, self.sess);
self.add_archive(location.clone(), |_| false).unwrap_or_else(|e| {
panic!("failed to add native library {}: {}", location.to_string_lossy(), e);
});
use rustc_data_structures::fx::FxHashMap;
use rustc_session::Session;
+use cranelift_codegen::isa::TargetIsa;
use cranelift_module::FuncId;
+use cranelift_object::{ObjectBuilder, ObjectModule, ObjectProduct};
use object::write::*;
use object::{RelocationEncoding, SectionKind, SymbolFlags};
-use cranelift_object::{ObjectBuilder, ObjectModule, ObjectProduct};
-
use gimli::SectionId;
use crate::debuginfo::{DebugReloc, DebugRelocName};
pub(crate) trait WriteMetadata {
- fn add_rustc_section(&mut self, symbol_name: String, data: Vec<u8>, is_like_osx: bool);
+ fn add_rustc_section(&mut self, symbol_name: String, data: Vec<u8>);
}
impl WriteMetadata for object::write::Object {
- fn add_rustc_section(&mut self, symbol_name: String, data: Vec<u8>, _is_like_osx: bool) {
+ fn add_rustc_section(&mut self, symbol_name: String, data: Vec<u8>) {
let segment = self.segment_name(object::write::StandardSegment::Data).to_vec();
let section_id = self.add_section(segment, b".rustc".to_vec(), object::SectionKind::Data);
let offset = self.append_section_data(section_id, &data, 1);
}
pub(crate) fn with_object(sess: &Session, name: &str, f: impl FnOnce(&mut Object)) -> Vec<u8> {
- let triple = crate::build_isa(sess).triple().clone();
+ let triple = crate::target_triple(sess);
let binary_format = match triple.binary_format {
target_lexicon::BinaryFormat::Elf => object::BinaryFormat::Elf,
metadata_object.write().unwrap()
}
-pub(crate) fn make_module(sess: &Session, name: String) -> ObjectModule {
- let mut builder = ObjectBuilder::new(
- crate::build_isa(sess),
- name + ".o",
- cranelift_module::default_libcall_names(),
- )
- .unwrap();
+pub(crate) fn make_module(sess: &Session, isa: Box<dyn TargetIsa>, name: String) -> ObjectModule {
+ let mut builder =
+ ObjectBuilder::new(isa, name + ".o", cranelift_module::default_libcall_names()).unwrap();
// Unlike cg_llvm, cg_clif defaults to disabling -Zfunction-sections. For cg_llvm binary size
// is important, while cg_clif cares more about compilation times. Enabling -Zfunction-sections
// can easily double the amount of time necessary to perform linking.
use rustc_middle::ty::layout::FnAbiExt;
use rustc_target::abi::call::FnAbi;
+use crate::constant::ConstantCx;
use crate::prelude::*;
-pub(crate) fn codegen_fn<'tcx>(cx: &mut crate::CodegenCx<'_, 'tcx>, instance: Instance<'tcx>) {
+pub(crate) fn codegen_fn<'tcx>(
+ cx: &mut crate::CodegenCx<'tcx>,
+ module: &mut dyn Module,
+ instance: Instance<'tcx>,
+) {
let tcx = cx.tcx;
let _inst_guard =
let mir = tcx.instance_mir(instance.def);
// Declare function
- let name = tcx.symbol_name(instance).name.to_string();
- let sig = get_function_sig(tcx, cx.module.isa().triple(), instance);
- let func_id = cx.module.declare_function(&name, Linkage::Local, &sig).unwrap();
+ let symbol_name = tcx.symbol_name(instance);
+ let sig = get_function_sig(tcx, module.isa().triple(), instance);
+ let func_id = module.declare_function(symbol_name.name, Linkage::Local, &sig).unwrap();
cx.cached_context.clear();
(0..mir.basic_blocks().len()).map(|_| bcx.create_block()).collect();
// Make FunctionCx
- let pointer_type = cx.module.target_config().pointer_type();
+ let pointer_type = module.target_config().pointer_type();
let clif_comments = crate::pretty_clif::CommentWriter::new(tcx, instance);
let mut fx = FunctionCx {
cx,
+ module,
tcx,
pointer_type,
+ vtables: FxHashMap::default(),
+ constants_cx: ConstantCx::new(),
instance,
+ symbol_name,
mir,
fn_abi: Some(FnAbi::of_instance(&RevealAllLayoutCx(tcx), instance, &[])),
block_map,
local_map: IndexVec::with_capacity(mir.local_decls.len()),
caller_location: None, // set by `codegen_fn_prelude`
- cold_blocks: EntitySet::new(),
clif_comments,
source_info_set: indexmap::IndexSet::new(),
let mut clif_comments = fx.clif_comments;
let source_info_set = fx.source_info_set;
let local_map = fx.local_map;
- let cold_blocks = fx.cold_blocks;
+
+ fx.constants_cx.finalize(fx.tcx, &mut *fx.module);
// Store function in context
let context = &mut cx.cached_context;
// Perform rust specific optimizations
tcx.sess.time("optimize clif ir", || {
- crate::optimize::optimize_function(
- tcx,
- instance,
- context,
- &cold_blocks,
- &mut clif_comments,
- );
+ crate::optimize::optimize_function(tcx, instance, context, &mut clif_comments);
});
// If the return block is not reachable, then the SSA builder may have inserted an `iconst.i128`
// instruction, which doesn't have an encoding.
context.compute_cfg();
context.compute_domtree();
- context.eliminate_unreachable_code(cx.module.isa()).unwrap();
- context.dce(cx.module.isa()).unwrap();
+ context.eliminate_unreachable_code(module.isa()).unwrap();
+ context.dce(module.isa()).unwrap();
// Some Cranelift optimizations expect the domtree to not yet be computed and as such don't
// invalidate it when it would change.
context.domtree.clear();
context.want_disasm = crate::pretty_clif::should_write_ir(tcx);
// Define function
- let module = &mut cx.module;
tcx.sess.time("define function", || {
module
.define_function(func_id, context, &mut NullTrapSink {}, &mut NullStackMapSink {})
crate::pretty_clif::write_clif_file(
tcx,
"opt",
- Some(cx.module.isa()),
+ Some(module.isa()),
instance,
&context,
&clif_comments,
if let Some(disasm) = &context.mach_compile_result.as_ref().unwrap().disasm {
crate::pretty_clif::write_ir_file(
tcx,
- &format!("{}.vcode", tcx.symbol_name(instance).name),
+ || format!("{}.vcode", tcx.symbol_name(instance).name),
|file| file.write_all(disasm.as_bytes()),
)
}
// Define debuginfo for function
- let isa = cx.module.isa();
+ let isa = module.isa();
let debug_context = &mut cx.debug_context;
let unwind_context = &mut cx.unwind_context;
tcx.sess.time("generate debug info", || {
debug_context.define_function(
instance,
func_id,
- &name,
+ symbol_name.name,
isa,
context,
&source_info_set,
// Unwinding after panicking is not supported
continue;
- // FIXME once unwinding is supported uncomment next lines
- // // Unwinding is unlikely to happen, so mark cleanup block's as cold.
- // fx.cold_blocks.insert(block);
+ // FIXME Once unwinding is supported and Cranelift supports marking blocks as cold, do
+ // so for cleanup blocks.
}
fx.bcx.ins().nop();
let target = fx.get_block(*target);
let failure = fx.bcx.create_block();
- fx.cold_blocks.insert(failure);
+ // FIXME Mark failure block as cold once Cranelift supports it
if *expected {
fx.bcx.ins().brz(cond, failure, &[]);
from_hir_call: _,
} => {
fx.tcx.sess.time("codegen call", || {
- crate::abi::codegen_terminator_call(
- fx,
- *fn_span,
- block,
- func,
- args,
- *destination,
- )
+ crate::abi::codegen_terminator_call(fx, *fn_span, func, args, *destination)
});
}
TerminatorKind::InlineAsm {
// FIXME use emit_small_memset where possible
let addr = lval.to_ptr().get_addr(fx);
let val = operand.load_scalar(fx);
- fx.bcx.call_memset(fx.cx.module.target_config(), addr, val, times);
+ fx.bcx.call_memset(fx.module.target_config(), addr, val, times);
} else {
let loop_block = fx.bcx.create_block();
let loop_block2 = fx.bcx.create_block();
| StatementKind::AscribeUserType(..) => {}
StatementKind::LlvmInlineAsm(asm) => {
- use rustc_span::symbol::Symbol;
- let LlvmInlineAsm { asm, outputs, inputs } = &**asm;
- let rustc_hir::LlvmInlineAsmInner {
- asm: asm_code, // Name
- outputs: output_names, // Vec<LlvmInlineAsmOutput>
- inputs: input_names, // Vec<Name>
- clobbers, // Vec<Name>
- volatile, // bool
- alignstack, // bool
- dialect: _,
- asm_str_style: _,
- } = asm;
- match asm_code.as_str().trim() {
+ match asm.asm.asm.as_str().trim() {
"" => {
// Black box
}
- "mov %rbx, %rsi\n cpuid\n xchg %rbx, %rsi" => {
- assert_eq!(input_names, &[Symbol::intern("{eax}"), Symbol::intern("{ecx}")]);
- assert_eq!(output_names.len(), 4);
- for (i, c) in (&["={eax}", "={esi}", "={ecx}", "={edx}"]).iter().enumerate() {
- assert_eq!(&output_names[i].constraint.as_str(), c);
- assert!(!output_names[i].is_rw);
- assert!(!output_names[i].is_indirect);
- }
-
- assert_eq!(clobbers, &[]);
-
- assert!(!volatile);
- assert!(!alignstack);
-
- assert_eq!(inputs.len(), 2);
- let leaf = codegen_operand(fx, &inputs[0].1).load_scalar(fx); // %eax
- let subleaf = codegen_operand(fx, &inputs[1].1).load_scalar(fx); // %ecx
-
- let (eax, ebx, ecx, edx) =
- crate::intrinsics::codegen_cpuid_call(fx, leaf, subleaf);
-
- assert_eq!(outputs.len(), 4);
- codegen_place(fx, outputs[0])
- .write_cvalue(fx, CValue::by_val(eax, fx.layout_of(fx.tcx.types.u32)));
- codegen_place(fx, outputs[1])
- .write_cvalue(fx, CValue::by_val(ebx, fx.layout_of(fx.tcx.types.u32)));
- codegen_place(fx, outputs[2])
- .write_cvalue(fx, CValue::by_val(ecx, fx.layout_of(fx.tcx.types.u32)));
- codegen_place(fx, outputs[3])
- .write_cvalue(fx, CValue::by_val(edx, fx.layout_of(fx.tcx.types.u32)));
- }
- "xgetbv" => {
- assert_eq!(input_names, &[Symbol::intern("{ecx}")]);
-
- assert_eq!(output_names.len(), 2);
- for (i, c) in (&["={eax}", "={edx}"]).iter().enumerate() {
- assert_eq!(&output_names[i].constraint.as_str(), c);
- assert!(!output_names[i].is_rw);
- assert!(!output_names[i].is_indirect);
- }
-
- assert_eq!(clobbers, &[]);
-
- assert!(!volatile);
- assert!(!alignstack);
-
- crate::trap::trap_unimplemented(fx, "_xgetbv arch intrinsic is not supported");
- }
- // ___chkstk, ___chkstk_ms and __alloca are only used on Windows
- _ if fx.tcx.symbol_name(fx.instance).name.starts_with("___chkstk") => {
- crate::trap::trap_unimplemented(fx, "Stack probes are not supported");
- }
- _ if fx.tcx.symbol_name(fx.instance).name == "__alloca" => {
- crate::trap::trap_unimplemented(fx, "Alloca is not supported");
- }
- // Used in sys::windows::abort_internal
- "int $$0x29" => {
- crate::trap::trap_unimplemented(fx, "Windows abort");
- }
- _ => fx
- .tcx
- .sess
- .span_fatal(stmt.source_info.span, "Inline assembly is not supported"),
+ _ => fx.tcx.sess.span_fatal(
+ stmt.source_info.span,
+ "Legacy `llvm_asm!` inline assembly is not supported. \
+ Try using the new `asm!` instead.",
+ ),
}
}
StatementKind::Coverage { .. } => fx.tcx.sess.fatal("-Zcoverage is unimplemented"),
let elem_size: u64 = pointee.size.bytes();
let bytes =
if elem_size != 1 { fx.bcx.ins().imul_imm(count, elem_size as i64) } else { count };
- fx.bcx.call_memcpy(fx.cx.module.target_config(), dst, src, bytes);
+ fx.bcx.call_memcpy(fx.module.target_config(), dst, src, bytes);
}
}
}
use rustc_index::vec::IndexVec;
+use rustc_middle::ty::SymbolName;
use rustc_target::abi::call::FnAbi;
use rustc_target::abi::{Integer, Primitive};
use rustc_target::spec::{HasTargetSpec, Target};
+use crate::constant::ConstantCx;
use crate::prelude::*;
pub(crate) fn pointer_ty(tcx: TyCtxt<'_>) -> types::Type {
}
}
-pub(crate) struct FunctionCx<'m, 'clif, 'tcx> {
- pub(crate) cx: &'clif mut crate::CodegenCx<'m, 'tcx>,
+pub(crate) struct FunctionCx<'m, 'clif, 'tcx: 'm> {
+ pub(crate) cx: &'clif mut crate::CodegenCx<'tcx>,
+ pub(crate) module: &'m mut dyn Module,
pub(crate) tcx: TyCtxt<'tcx>,
pub(crate) pointer_type: Type, // Cached from module
+ pub(crate) vtables: FxHashMap<(Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>), DataId>,
+ pub(crate) constants_cx: ConstantCx,
pub(crate) instance: Instance<'tcx>,
+ pub(crate) symbol_name: SymbolName<'tcx>,
pub(crate) mir: &'tcx Body<'tcx>,
pub(crate) fn_abi: Option<FnAbi<'tcx, Ty<'tcx>>>,
/// When `#[track_caller]` is used, the implicit caller location is stored in this variable.
pub(crate) caller_location: Option<CValue<'tcx>>,
- /// See [`crate::optimize::code_layout`] for more information.
- pub(crate) cold_blocks: EntitySet<Block>,
-
pub(crate) clif_comments: crate::pretty_clif::CommentWriter,
pub(crate) source_info_set: indexmap::IndexSet<SourceInfo>,
}
pub(crate) fn triple(&self) -> &target_lexicon::Triple {
- self.cx.module.isa().triple()
+ self.module.isa().triple()
}
pub(crate) fn anonymous_str(&mut self, prefix: &str, msg: &str) -> Value {
let mut data_ctx = DataContext::new();
data_ctx.define(msg.as_bytes().to_vec().into_boxed_slice());
let msg_id = self
- .cx
.module
.declare_data(&format!("__{}_{:08x}", prefix, msg_hash), Linkage::Local, false, false)
.unwrap();
// Ignore DuplicateDefinition error, as the data will be the same
- let _ = self.cx.module.define_data(msg_id, &data_ctx);
+ let _ = self.module.define_data(msg_id, &data_ctx);
- let local_msg_id = self.cx.module.declare_data_in_func(msg_id, self.bcx.func);
+ let local_msg_id = self.module.declare_data_in_func(msg_id, self.bcx.func);
if self.clif_comments.enabled() {
self.add_comment(local_msg_id, msg);
}
--- /dev/null
+use std::env;
+use std::str::FromStr;
+
+fn bool_env_var(key: &str) -> bool {
+ env::var(key).as_ref().map(|val| &**val) == Ok("1")
+}
+
+/// The mode to use for compilation.
+#[derive(Copy, Clone, Debug)]
+pub enum CodegenMode {
+ /// AOT compile the crate. This is the default.
+ Aot,
+ /// JIT compile and execute the crate.
+ Jit,
+ /// JIT compile and execute the crate, but only compile functions the first time they are used.
+ JitLazy,
+}
+
+impl FromStr for CodegenMode {
+ type Err = String;
+
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ match s {
+ "aot" => Ok(CodegenMode::Aot),
+ "jit" => Ok(CodegenMode::Jit),
+ "jit-lazy" => Ok(CodegenMode::JitLazy),
+ _ => Err(format!("Unknown codegen mode `{}`", s)),
+ }
+ }
+}
+
+/// Configuration of cg_clif as passed in through `-Cllvm-args` and various env vars.
+#[derive(Clone, Debug)]
+pub struct BackendConfig {
+ /// Should the crate be AOT compiled or JIT executed.
+ ///
+ /// Defaults to AOT compilation. Can be set using `-Cllvm-args=mode=...`.
+ pub codegen_mode: CodegenMode,
+
+ /// When JIT mode is enable pass these arguments to the program.
+ ///
+ /// Defaults to the value of `CG_CLIF_JIT_ARGS`.
+ pub jit_args: Vec<String>,
+
+ /// Display the time it took to perform codegen for a crate.
+ ///
+ /// Defaults to true when the `CG_CLIF_DISPLAY_CG_TIME` env var is set to 1 or false otherwise.
+ /// Can be set using `-Cllvm-args=display_cg_time=...`.
+ pub display_cg_time: bool,
+
+ /// Enable the Cranelift ir verifier for all compilation passes. If not set it will only run
+ /// once before passing the clif ir to Cranelift for compilation.
+ ///
+ /// Defaults to true when the `CG_CLIF_ENABLE_VERIFIER` env var is set to 1 or when cg_clif is
+ /// compiled with debug assertions enabled or false otherwise. Can be set using
+ /// `-Cllvm-args=enable_verifier=...`.
+ pub enable_verifier: bool,
+
+ /// Don't cache object files in the incremental cache. Useful during development of cg_clif
+ /// to make it possible to use incremental mode for all analyses performed by rustc without
+ /// caching object files when their content should have been changed by a change to cg_clif.
+ ///
+ /// Defaults to true when the `CG_CLIF_DISABLE_INCR_CACHE` env var is set to 1 or false
+ /// otherwise. Can be set using `-Cllvm-args=disable_incr_cache=...`.
+ pub disable_incr_cache: bool,
+}
+
+impl Default for BackendConfig {
+ fn default() -> Self {
+ BackendConfig {
+ codegen_mode: CodegenMode::Aot,
+ jit_args: {
+ let args = std::env::var("CG_CLIF_JIT_ARGS").unwrap_or_else(|_| String::new());
+ args.split(' ').map(|arg| arg.to_string()).collect()
+ },
+ display_cg_time: bool_env_var("CG_CLIF_DISPLAY_CG_TIME"),
+ enable_verifier: cfg!(debug_assertions) || bool_env_var("CG_CLIF_ENABLE_VERIFIER"),
+ disable_incr_cache: bool_env_var("CG_CLIF_DISABLE_INCR_CACHE"),
+ }
+ }
+}
+
+impl BackendConfig {
+ /// Parse the configuration passed in using `-Cllvm-args`.
+ pub fn from_opts(opts: &[String]) -> Result<Self, String> {
+ fn parse_bool(name: &str, value: &str) -> Result<bool, String> {
+ value.parse().map_err(|_| format!("failed to parse value `{}` for {}", value, name))
+ }
+
+ let mut config = BackendConfig::default();
+ for opt in opts {
+ if let Some((name, value)) = opt.split_once('=') {
+ match name {
+ "mode" => config.codegen_mode = value.parse()?,
+ "display_cg_time" => config.display_cg_time = parse_bool(name, value)?,
+ "enable_verifier" => config.enable_verifier = parse_bool(name, value)?,
+ "disable_incr_cache" => config.disable_incr_cache = parse_bool(name, value)?,
+ _ => return Err(format!("Unknown option `{}`", name)),
+ }
+ } else {
+ return Err(format!("Invalid option `{}`", opt));
+ }
+ }
+
+ Ok(config)
+ }
+}
use rustc_span::DUMMY_SP;
-use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_errors::ErrorReported;
use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
use rustc_middle::mir::interpret::{
use crate::prelude::*;
-#[derive(Default)]
pub(crate) struct ConstantCx {
todo: Vec<TodoItem>,
done: FxHashSet<DataId>,
+ anon_allocs: FxHashMap<AllocId, DataId>,
}
#[derive(Copy, Clone, Debug)]
}
impl ConstantCx {
+ pub(crate) fn new() -> Self {
+ ConstantCx { todo: vec![], done: FxHashSet::default(), anon_allocs: FxHashMap::default() }
+ }
+
pub(crate) fn finalize(mut self, tcx: TyCtxt<'_>, module: &mut dyn Module) {
//println!("todo {:?}", self.todo);
define_all_allocs(tcx, module, &mut self);
all_constants_ok
}
-pub(crate) fn codegen_static(constants_cx: &mut ConstantCx, def_id: DefId) {
+pub(crate) fn codegen_static(tcx: TyCtxt<'_>, module: &mut dyn Module, def_id: DefId) {
+ let mut constants_cx = ConstantCx::new();
constants_cx.todo.push(TodoItem::Static(def_id));
+ constants_cx.finalize(tcx, module);
}
pub(crate) fn codegen_tls_ref<'tcx>(
def_id: DefId,
layout: TyAndLayout<'tcx>,
) -> CValue<'tcx> {
- let data_id = data_id_for_static(fx.tcx, fx.cx.module, def_id, false);
- let local_data_id = fx.cx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+ let data_id = data_id_for_static(fx.tcx, fx.module, def_id, false);
+ let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
if fx.clif_comments.enabled() {
fx.add_comment(local_data_id, format!("tls {:?}", def_id));
}
def_id: DefId,
layout: TyAndLayout<'tcx>,
) -> CPlace<'tcx> {
- let data_id = data_id_for_static(fx.tcx, fx.cx.module, def_id, false);
- let local_data_id = fx.cx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+ let data_id = data_id_for_static(fx.tcx, fx.module, def_id, false);
+ let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
if fx.clif_comments.enabled() {
fx.add_comment(local_data_id, format!("{:?}", def_id));
}
let alloc_kind = fx.tcx.get_global_alloc(ptr.alloc_id);
let base_addr = match alloc_kind {
Some(GlobalAlloc::Memory(alloc)) => {
- fx.cx.constants_cx.todo.push(TodoItem::Alloc(ptr.alloc_id));
- let data_id =
- data_id_for_alloc_id(fx.cx.module, ptr.alloc_id, alloc.mutability);
+ fx.constants_cx.todo.push(TodoItem::Alloc(ptr.alloc_id));
+ let data_id = data_id_for_alloc_id(
+ &mut fx.constants_cx,
+ fx.module,
+ ptr.alloc_id,
+ alloc.mutability,
+ );
let local_data_id =
- fx.cx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+ fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
if fx.clif_comments.enabled() {
fx.add_comment(local_data_id, format!("{:?}", ptr.alloc_id));
}
fx.bcx.ins().global_value(fx.pointer_type, local_data_id)
}
Some(GlobalAlloc::Function(instance)) => {
- let func_id =
- crate::abi::import_function(fx.tcx, fx.cx.module, instance);
+ let func_id = crate::abi::import_function(fx.tcx, fx.module, instance);
let local_func_id =
- fx.cx.module.declare_func_in_func(func_id, &mut fx.bcx.func);
+ fx.module.declare_func_in_func(func_id, &mut fx.bcx.func);
fx.bcx.ins().func_addr(fx.pointer_type, local_func_id)
}
Some(GlobalAlloc::Static(def_id)) => {
assert!(fx.tcx.is_static(def_id));
- let data_id = data_id_for_static(fx.tcx, fx.cx.module, def_id, false);
+ let data_id = data_id_for_static(fx.tcx, fx.module, def_id, false);
let local_data_id =
- fx.cx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+ fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
if fx.clif_comments.enabled() {
fx.add_comment(local_data_id, format!("{:?}", def_id));
}
alloc: &'tcx Allocation,
) -> crate::pointer::Pointer {
let alloc_id = fx.tcx.create_memory_alloc(alloc);
- fx.cx.constants_cx.todo.push(TodoItem::Alloc(alloc_id));
- let data_id = data_id_for_alloc_id(fx.cx.module, alloc_id, alloc.mutability);
+ fx.constants_cx.todo.push(TodoItem::Alloc(alloc_id));
+ let data_id =
+ data_id_for_alloc_id(&mut fx.constants_cx, &mut *fx.module, alloc_id, alloc.mutability);
- let local_data_id = fx.cx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+ let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
if fx.clif_comments.enabled() {
fx.add_comment(local_data_id, format!("{:?}", alloc_id));
}
}
fn data_id_for_alloc_id(
+ cx: &mut ConstantCx,
module: &mut dyn Module,
alloc_id: AllocId,
mutability: rustc_hir::Mutability,
) -> DataId {
- module
- .declare_data(
- &format!(".L__alloc_{:x}", alloc_id.0),
- Linkage::Local,
- mutability == rustc_hir::Mutability::Mut,
- false,
- )
- .unwrap()
+ *cx.anon_allocs.entry(alloc_id).or_insert_with(|| {
+ module.declare_anonymous_data(mutability == rustc_hir::Mutability::Mut, false).unwrap()
+ })
}
fn data_id_for_static(
GlobalAlloc::Memory(alloc) => alloc,
GlobalAlloc::Function(_) | GlobalAlloc::Static(_) => unreachable!(),
};
- let data_id = data_id_for_alloc_id(module, alloc_id, alloc.mutability);
+ let data_id = data_id_for_alloc_id(cx, module, alloc_id, alloc.mutability);
(data_id, alloc, None)
}
TodoItem::Static(def_id) => {
}
GlobalAlloc::Memory(target_alloc) => {
cx.todo.push(TodoItem::Alloc(reloc));
- data_id_for_alloc_id(module, reloc, target_alloc.mutability)
+ data_id_for_alloc_id(cx, module, reloc, target_alloc.mutability)
}
GlobalAlloc::Static(def_id) => {
if tcx.codegen_fn_attrs(def_id).flags.contains(CodegenFnAttrFlags::THREAD_LOCAL)
data_ctx.write_data_addr(offset.bytes() as u32, global_value, addend as i64);
}
- // FIXME don't duplicate definitions in lazy jit mode
- let _ = module.define_data(data_id, &data_ctx);
+ module.define_data(data_id, &data_ctx).unwrap();
cx.done.insert(data_id);
}
use cranelift_codegen::isa::{unwind::UnwindInfo, TargetIsa};
use gimli::write::{Address, CieId, EhFrame, FrameTable, Section};
+use gimli::RunTimeEndian;
use crate::backend::WriteDebugInfo;
-pub(crate) struct UnwindContext<'tcx> {
- tcx: TyCtxt<'tcx>,
+pub(crate) struct UnwindContext {
+ endian: RunTimeEndian,
frame_table: FrameTable,
cie_id: Option<CieId>,
}
-impl<'tcx> UnwindContext<'tcx> {
- pub(crate) fn new(tcx: TyCtxt<'tcx>, isa: &dyn TargetIsa, pic_eh_frame: bool) -> Self {
+impl UnwindContext {
+ pub(crate) fn new(tcx: TyCtxt<'_>, isa: &dyn TargetIsa, pic_eh_frame: bool) -> Self {
+ let endian = super::target_endian(tcx);
let mut frame_table = FrameTable::default();
let cie_id = if let Some(mut cie) = isa.create_systemv_cie() {
None
};
- UnwindContext { tcx, frame_table, cie_id }
+ UnwindContext { endian, frame_table, cie_id }
}
pub(crate) fn add_function(&mut self, func_id: FuncId, context: &Context, isa: &dyn TargetIsa) {
}
pub(crate) fn emit<P: WriteDebugInfo>(self, product: &mut P) {
- let mut eh_frame =
- EhFrame::from(super::emit::WriterRelocate::new(super::target_endian(self.tcx)));
+ let mut eh_frame = EhFrame::from(super::emit::WriterRelocate::new(self.endian));
self.frame_table.write_eh_frame(&mut eh_frame).unwrap();
if !eh_frame.0.writer.slice().is_empty() {
}
}
- #[cfg(feature = "jit")]
- pub(crate) unsafe fn register_jit(
- self,
- jit_module: &cranelift_jit::JITModule,
- ) -> Option<UnwindRegistry> {
- let mut eh_frame =
- EhFrame::from(super::emit::WriterRelocate::new(super::target_endian(self.tcx)));
+ #[cfg(all(feature = "jit", windows))]
+ pub(crate) unsafe fn register_jit(self, _jit_module: &cranelift_jit::JITModule) {}
+
+ #[cfg(all(feature = "jit", not(windows)))]
+ pub(crate) unsafe fn register_jit(self, jit_module: &cranelift_jit::JITModule) {
+ let mut eh_frame = EhFrame::from(super::emit::WriterRelocate::new(self.endian));
self.frame_table.write_eh_frame(&mut eh_frame).unwrap();
if eh_frame.0.writer.slice().is_empty() {
- return None;
+ return;
}
let mut eh_frame = eh_frame.0.relocate_for_jit(jit_module);
// GCC expects a terminating "empty" length, so write a 0 length at the end of the table.
eh_frame.extend(&[0, 0, 0, 0]);
- let mut registrations = Vec::new();
+ // FIXME support unregistering unwind tables once cranelift-jit supports deallocating
+ // individual functions
+ #[allow(unused_variables)]
+ let (eh_frame, eh_frame_len, _) = Vec::into_raw_parts(eh_frame);
// =======================================================================
// Everything after this line up to the end of the file is loosly based on
#[cfg(target_os = "macos")]
{
// On macOS, `__register_frame` takes a pointer to a single FDE
- let start = eh_frame.as_ptr();
- let end = start.add(eh_frame.len());
+ let start = eh_frame;
+ let end = start.add(eh_frame_len);
let mut current = start;
// Walk all of the entries in the frame table and register them
// Skip over the CIE
if current != start {
__register_frame(current);
- registrations.push(current as usize);
}
// Move to the next table entry (+4 because the length itself is not inclusive)
#[cfg(not(target_os = "macos"))]
{
// On other platforms, `__register_frame` will walk the FDEs until an entry of length 0
- let ptr = eh_frame.as_ptr();
- __register_frame(ptr);
- registrations.push(ptr as usize);
+ __register_frame(eh_frame);
}
-
- Some(UnwindRegistry { _frame_table: eh_frame, registrations })
}
}
-/// Represents a registry of function unwind information for System V ABI.
-pub(crate) struct UnwindRegistry {
- _frame_table: Vec<u8>,
- registrations: Vec<usize>,
-}
-
extern "C" {
// libunwind import
fn __register_frame(fde: *const u8);
- fn __deregister_frame(fde: *const u8);
-}
-
-impl Drop for UnwindRegistry {
- fn drop(&mut self) {
- unsafe {
- // libgcc stores the frame entries as a linked list in decreasing sort order
- // based on the PC value of the registered entry.
- //
- // As we store the registrations in increasing order, it would be O(N^2) to
- // deregister in that order.
- //
- // To ensure that we just pop off the first element in the list upon every
- // deregistration, walk our list of registrations backwards.
- for fde in self.registrations.iter().rev() {
- __deregister_frame(*fde as *const _);
- }
- }
- }
}
use crate::{prelude::*, BackendConfig};
-fn new_module(tcx: TyCtxt<'_>, name: String) -> ObjectModule {
- let module = crate::backend::make_module(tcx.sess, name);
- assert_eq!(pointer_ty(tcx), module.target_config().pointer_type());
- module
-}
-
struct ModuleCodegenResult(CompiledModule, Option<(WorkProductId, WorkProduct)>);
impl<HCX> HashStable<HCX> for ModuleCodegenResult {
fn emit_module(
tcx: TyCtxt<'_>,
+ backend_config: &BackendConfig,
name: String,
kind: ModuleKind,
module: ObjectModule,
debug: Option<DebugContext<'_>>,
- unwind_context: UnwindContext<'_>,
+ unwind_context: UnwindContext,
) -> ModuleCodegenResult {
let mut product = module.finish();
tcx.sess.fatal(&format!("error writing object file: {}", err));
}
- let work_product = if std::env::var("CG_CLIF_INCR_CACHE_DISABLED").is_ok() {
+ let work_product = if backend_config.disable_incr_cache {
None
} else {
rustc_incremental::copy_cgu_workproduct_to_incr_comp_cache_dir(
let cgu = tcx.codegen_unit(cgu_name);
let mono_items = cgu.items_in_deterministic_order(tcx);
- let mut module = new_module(tcx, cgu_name.as_str().to_string());
+ let isa = crate::build_isa(tcx.sess, &backend_config);
+ let mut module = crate::backend::make_module(tcx.sess, isa, cgu_name.as_str().to_string());
let mut cx = crate::CodegenCx::new(
tcx,
- backend_config,
- &mut module,
+ backend_config.clone(),
+ module.isa(),
tcx.sess.opts.debuginfo != DebugInfo::None,
);
- super::predefine_mono_items(&mut cx, &mono_items);
+ super::predefine_mono_items(tcx, &mut module, &mono_items);
for (mono_item, _) in mono_items {
match mono_item {
MonoItem::Fn(inst) => {
- cx.tcx.sess.time("codegen fn", || crate::base::codegen_fn(&mut cx, inst));
- }
- MonoItem::Static(def_id) => {
- crate::constant::codegen_static(&mut cx.constants_cx, def_id)
+ cx.tcx
+ .sess
+ .time("codegen fn", || crate::base::codegen_fn(&mut cx, &mut module, inst));
}
+ MonoItem::Static(def_id) => crate::constant::codegen_static(tcx, &mut module, def_id),
MonoItem::GlobalAsm(item_id) => {
let item = cx.tcx.hir().item(item_id);
if let rustc_hir::ItemKind::GlobalAsm(rustc_hir::GlobalAsm { asm }) = item.kind {
}
}
}
- let (global_asm, debug, mut unwind_context) =
- tcx.sess.time("finalize CodegenCx", || cx.finalize());
- crate::main_shim::maybe_create_entry_wrapper(tcx, &mut module, &mut unwind_context);
+ crate::main_shim::maybe_create_entry_wrapper(tcx, &mut module, &mut cx.unwind_context, false);
- let codegen_result = emit_module(
- tcx,
- cgu.name().as_str().to_string(),
- ModuleKind::Regular,
- module,
- debug,
- unwind_context,
- );
+ let debug_context = cx.debug_context;
+ let unwind_context = cx.unwind_context;
+ let codegen_result = tcx.sess.time("write object file", || {
+ emit_module(
+ tcx,
+ &backend_config,
+ cgu.name().as_str().to_string(),
+ ModuleKind::Regular,
+ module,
+ debug_context,
+ unwind_context,
+ )
+ });
- codegen_global_asm(tcx, &cgu.name().as_str(), &global_asm);
+ codegen_global_asm(tcx, &cgu.name().as_str(), &cx.global_asm);
codegen_result
}
-pub(super) fn run_aot(
+pub(crate) fn run_aot(
tcx: TyCtxt<'_>,
backend_config: BackendConfig,
metadata: EncodedMetadata,
}
}
- let modules = super::time(tcx, "codegen mono items", || {
+ let modules = super::time(tcx, backend_config.display_cg_time, "codegen mono items", || {
cgus.iter()
.map(|cgu| {
let cgu_reuse = determine_cgu_reuse(tcx, cgu);
tcx.sess.cgu_reuse_tracker.set_actual_reuse(&cgu.name().as_str(), cgu_reuse);
match cgu_reuse {
- _ if std::env::var("CG_CLIF_INCR_CACHE_DISABLED").is_ok() => {}
+ _ if backend_config.disable_incr_cache => {}
CguReuse::No => {}
CguReuse::PreLto => {
return reuse_workproduct_for_cgu(tcx, &*cgu, &mut work_products);
let (ModuleCodegenResult(module, work_product), _) = tcx.dep_graph.with_task(
dep_node,
tcx,
- (backend_config, cgu.name()),
+ (backend_config.clone(), cgu.name()),
module_codegen,
rustc_middle::dep_graph::hash_result,
);
tcx.sess.abort_if_errors();
- let mut allocator_module = new_module(tcx, "allocator_shim".to_string());
+ let isa = crate::build_isa(tcx.sess, &backend_config);
+ let mut allocator_module =
+ crate::backend::make_module(tcx.sess, isa, "allocator_shim".to_string());
+ assert_eq!(pointer_ty(tcx), allocator_module.target_config().pointer_type());
let mut allocator_unwind_context = UnwindContext::new(tcx, allocator_module.isa(), true);
let created_alloc_shim =
crate::allocator::codegen(tcx, &mut allocator_module, &mut allocator_unwind_context);
let allocator_module = if created_alloc_shim {
let ModuleCodegenResult(module, work_product) = emit_module(
tcx,
+ &backend_config,
"allocator_shim".to_string(),
ModuleKind::Allocator,
allocator_module,
-//! The JIT driver uses [`cranelift_simplejit`] to JIT execute programs without writing any object
+//! The JIT driver uses [`cranelift_jit`] to JIT execute programs without writing any object
//! files.
use std::cell::RefCell;
use crate::{prelude::*, BackendConfig};
use crate::{CodegenCx, CodegenMode};
-thread_local! {
- pub static BACKEND_CONFIG: RefCell<Option<BackendConfig>> = RefCell::new(None);
- pub static CURRENT_MODULE: RefCell<Option<JITModule>> = RefCell::new(None);
+struct JitState {
+ backend_config: BackendConfig,
+ jit_module: JITModule,
}
-pub(super) fn run_jit(tcx: TyCtxt<'_>, backend_config: BackendConfig) -> ! {
- if !tcx.sess.opts.output_types.should_codegen() {
- tcx.sess.fatal("JIT mode doesn't work with `cargo check`.");
- }
+thread_local! {
+ static LAZY_JIT_STATE: RefCell<Option<JitState>> = RefCell::new(None);
+}
+fn create_jit_module<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ backend_config: &BackendConfig,
+ hotswap: bool,
+) -> (JITModule, CodegenCx<'tcx>) {
let imported_symbols = load_imported_symbols_for_jit(tcx);
- let mut jit_builder =
- JITBuilder::with_isa(crate::build_isa(tcx.sess), cranelift_module::default_libcall_names());
- jit_builder.hotswap(matches!(backend_config.codegen_mode, CodegenMode::JitLazy));
+ let isa = crate::build_isa(tcx.sess, backend_config);
+ let mut jit_builder = JITBuilder::with_isa(isa, cranelift_module::default_libcall_names());
+ jit_builder.hotswap(hotswap);
crate::compiler_builtins::register_functions_for_jit(&mut jit_builder);
jit_builder.symbols(imported_symbols);
let mut jit_module = JITModule::new(jit_builder);
- assert_eq!(pointer_ty(tcx), jit_module.target_config().pointer_type());
+
+ let mut cx = crate::CodegenCx::new(tcx, backend_config.clone(), jit_module.isa(), false);
+
+ crate::allocator::codegen(tcx, &mut jit_module, &mut cx.unwind_context);
+ crate::main_shim::maybe_create_entry_wrapper(
+ tcx,
+ &mut jit_module,
+ &mut cx.unwind_context,
+ true,
+ );
+
+ (jit_module, cx)
+}
+
+pub(crate) fn run_jit(tcx: TyCtxt<'_>, backend_config: BackendConfig) -> ! {
+ if !tcx.sess.opts.output_types.should_codegen() {
+ tcx.sess.fatal("JIT mode doesn't work with `cargo check`");
+ }
+
+ if !tcx.sess.crate_types().contains(&rustc_session::config::CrateType::Executable) {
+ tcx.sess.fatal("can't jit non-executable crate");
+ }
+
+ let (mut jit_module, mut cx) = create_jit_module(
+ tcx,
+ &backend_config,
+ matches!(backend_config.codegen_mode, CodegenMode::JitLazy),
+ );
let (_, cgus) = tcx.collect_and_partition_mono_items(LOCAL_CRATE);
let mono_items = cgus
.into_iter()
.collect::<Vec<(_, (_, _))>>();
- let mut cx = crate::CodegenCx::new(tcx, backend_config, &mut jit_module, false);
-
- super::time(tcx, "codegen mono items", || {
- super::predefine_mono_items(&mut cx, &mono_items);
+ super::time(tcx, backend_config.display_cg_time, "codegen mono items", || {
+ super::predefine_mono_items(tcx, &mut jit_module, &mono_items);
for (mono_item, _) in mono_items {
match mono_item {
MonoItem::Fn(inst) => match backend_config.codegen_mode {
CodegenMode::Aot => unreachable!(),
CodegenMode::Jit => {
- cx.tcx.sess.time("codegen fn", || crate::base::codegen_fn(&mut cx, inst));
+ cx.tcx.sess.time("codegen fn", || {
+ crate::base::codegen_fn(&mut cx, &mut jit_module, inst)
+ });
}
- CodegenMode::JitLazy => codegen_shim(&mut cx, inst),
+ CodegenMode::JitLazy => codegen_shim(&mut cx, &mut jit_module, inst),
},
MonoItem::Static(def_id) => {
- crate::constant::codegen_static(&mut cx.constants_cx, def_id);
+ crate::constant::codegen_static(tcx, &mut jit_module, def_id);
}
MonoItem::GlobalAsm(item_id) => {
- let item = cx.tcx.hir().item(item_id);
+ let item = tcx.hir().item(item_id);
tcx.sess.span_fatal(item.span, "Global asm is not supported in JIT mode");
}
}
}
});
- let (global_asm, _debug, mut unwind_context) =
- tcx.sess.time("finalize CodegenCx", || cx.finalize());
- jit_module.finalize_definitions();
-
- if !global_asm.is_empty() {
+ if !cx.global_asm.is_empty() {
tcx.sess.fatal("Inline asm is not supported in JIT mode");
}
- crate::allocator::codegen(tcx, &mut jit_module, &mut unwind_context);
-
tcx.sess.abort_if_errors();
jit_module.finalize_definitions();
- let _unwind_register_guard = unsafe { unwind_context.register_jit(&jit_module) };
+ unsafe { cx.unwind_context.register_jit(&jit_module) };
println!(
"Rustc codegen cranelift will JIT run the executable, because -Cllvm-args=mode=jit was passed"
);
- let args = ::std::env::var("CG_CLIF_JIT_ARGS").unwrap_or_else(|_| String::new());
let args = std::iter::once(&*tcx.crate_name(LOCAL_CRATE).as_str().to_string())
- .chain(args.split(' '))
+ .chain(backend_config.jit_args.iter().map(|arg| &**arg))
.map(|arg| CString::new(arg).unwrap())
.collect::<Vec<_>>();
let mut argv = args.iter().map(|arg| arg.as_ptr()).collect::<Vec<_>>();
// useful as some dynamic linkers use it as a marker to jump over.
argv.push(std::ptr::null());
- BACKEND_CONFIG.with(|tls_backend_config| {
- assert!(tls_backend_config.borrow_mut().replace(backend_config).is_none())
+ let start_sig = Signature {
+ params: vec![
+ AbiParam::new(jit_module.target_config().pointer_type()),
+ AbiParam::new(jit_module.target_config().pointer_type()),
+ ],
+ returns: vec![AbiParam::new(jit_module.target_config().pointer_type() /*isize*/)],
+ call_conv: CallConv::triple_default(&crate::target_triple(tcx.sess)),
+ };
+ let start_func_id = jit_module.declare_function("main", Linkage::Import, &start_sig).unwrap();
+ let finalized_start: *const u8 = jit_module.get_finalized_function(start_func_id);
+
+ LAZY_JIT_STATE.with(|lazy_jit_state| {
+ let mut lazy_jit_state = lazy_jit_state.borrow_mut();
+ assert!(lazy_jit_state.is_none());
+ *lazy_jit_state = Some(JitState { backend_config, jit_module });
});
- let (main_def_id, entry_ty) = tcx.entry_fn(LOCAL_CRATE).unwrap();
- let instance = Instance::mono(tcx, main_def_id.to_def_id()).polymorphize(tcx);
-
- match entry_ty {
- EntryFnType::Main => {
- // FIXME set program arguments somehow
-
- let main_sig = Signature {
- params: vec![],
- returns: vec![],
- call_conv: CallConv::triple_default(&crate::target_triple(tcx.sess)),
- };
- let main_func_id = jit_module
- .declare_function(tcx.symbol_name(instance).name, Linkage::Import, &main_sig)
- .unwrap();
- let finalized_main: *const u8 = jit_module.get_finalized_function(main_func_id);
-
- CURRENT_MODULE.with(|current_module| {
- assert!(current_module.borrow_mut().replace(jit_module).is_none())
- });
-
- let f: extern "C" fn() = unsafe { ::std::mem::transmute(finalized_main) };
- f();
- std::process::exit(0);
- }
- EntryFnType::Start => {
- let start_sig = Signature {
- params: vec![
- AbiParam::new(jit_module.target_config().pointer_type()),
- AbiParam::new(jit_module.target_config().pointer_type()),
- ],
- returns: vec![AbiParam::new(
- jit_module.target_config().pointer_type(), /*isize*/
- )],
- call_conv: CallConv::triple_default(&crate::target_triple(tcx.sess)),
- };
- let start_func_id = jit_module
- .declare_function(tcx.symbol_name(instance).name, Linkage::Import, &start_sig)
- .unwrap();
- let finalized_start: *const u8 = jit_module.get_finalized_function(start_func_id);
-
- CURRENT_MODULE.with(|current_module| {
- assert!(current_module.borrow_mut().replace(jit_module).is_none())
- });
-
- let f: extern "C" fn(c_int, *const *const c_char) -> c_int =
- unsafe { ::std::mem::transmute(finalized_start) };
- let ret = f(args.len() as c_int, argv.as_ptr());
- std::process::exit(ret);
- }
- }
+ let f: extern "C" fn(c_int, *const *const c_char) -> c_int =
+ unsafe { ::std::mem::transmute(finalized_start) };
+ let ret = f(args.len() as c_int, argv.as_ptr());
+ std::process::exit(ret);
}
#[no_mangle]
// lift is used to ensure the correct lifetime for instance.
let instance = tcx.lift(unsafe { *instance_ptr }).unwrap();
- CURRENT_MODULE.with(|jit_module| {
- let mut jit_module = jit_module.borrow_mut();
- let jit_module = jit_module.as_mut().unwrap();
- let backend_config =
- BACKEND_CONFIG.with(|backend_config| backend_config.borrow().clone().unwrap());
+ LAZY_JIT_STATE.with(|lazy_jit_state| {
+ let mut lazy_jit_state = lazy_jit_state.borrow_mut();
+ let lazy_jit_state = lazy_jit_state.as_mut().unwrap();
+ let jit_module = &mut lazy_jit_state.jit_module;
+ let backend_config = lazy_jit_state.backend_config.clone();
- let name = tcx.symbol_name(instance).name.to_string();
+ let name = tcx.symbol_name(instance).name;
let sig = crate::abi::get_function_sig(tcx, jit_module.isa().triple(), instance);
- let func_id = jit_module.declare_function(&name, Linkage::Export, &sig).unwrap();
+ let func_id = jit_module.declare_function(name, Linkage::Export, &sig).unwrap();
jit_module.prepare_for_function_redefine(func_id).unwrap();
- let mut cx = crate::CodegenCx::new(tcx, backend_config, jit_module, false);
- tcx.sess.time("codegen fn", || crate::base::codegen_fn(&mut cx, instance));
+ let mut cx = crate::CodegenCx::new(tcx, backend_config, jit_module.isa(), false);
+ tcx.sess.time("codegen fn", || crate::base::codegen_fn(&mut cx, jit_module, instance));
- let (global_asm, _debug_context, unwind_context) = cx.finalize();
- assert!(global_asm.is_empty());
+ assert!(cx.global_asm.is_empty());
jit_module.finalize_definitions();
- std::mem::forget(unsafe { unwind_context.register_jit(&jit_module) });
+ unsafe { cx.unwind_context.register_jit(&jit_module) };
jit_module.get_finalized_function(func_id)
})
})
imported_symbols
}
-fn codegen_shim<'tcx>(cx: &mut CodegenCx<'_, 'tcx>, inst: Instance<'tcx>) {
+fn codegen_shim<'tcx>(cx: &mut CodegenCx<'tcx>, module: &mut JITModule, inst: Instance<'tcx>) {
let tcx = cx.tcx;
- let pointer_type = cx.module.target_config().pointer_type();
+ let pointer_type = module.target_config().pointer_type();
- let name = tcx.symbol_name(inst).name.to_string();
- let sig = crate::abi::get_function_sig(tcx, cx.module.isa().triple(), inst);
- let func_id = cx.module.declare_function(&name, Linkage::Export, &sig).unwrap();
+ let name = tcx.symbol_name(inst).name;
+ let sig = crate::abi::get_function_sig(tcx, module.isa().triple(), inst);
+ let func_id = module.declare_function(name, Linkage::Export, &sig).unwrap();
let instance_ptr = Box::into_raw(Box::new(inst));
- let jit_fn = cx
- .module
+ let jit_fn = module
.declare_function(
"__clif_jit_fn",
Linkage::Import,
&Signature {
- call_conv: cx.module.target_config().default_call_conv,
+ call_conv: module.target_config().default_call_conv,
params: vec![AbiParam::new(pointer_type)],
returns: vec![AbiParam::new(pointer_type)],
},
)
.unwrap();
- let mut trampoline = Function::with_name_signature(ExternalName::default(), sig.clone());
+ cx.cached_context.clear();
+ let trampoline = &mut cx.cached_context.func;
+ trampoline.signature = sig.clone();
+
let mut builder_ctx = FunctionBuilderContext::new();
- let mut trampoline_builder = FunctionBuilder::new(&mut trampoline, &mut builder_ctx);
+ let mut trampoline_builder = FunctionBuilder::new(trampoline, &mut builder_ctx);
- let jit_fn = cx.module.declare_func_in_func(jit_fn, trampoline_builder.func);
+ let jit_fn = module.declare_func_in_func(jit_fn, trampoline_builder.func);
let sig_ref = trampoline_builder.func.import_signature(sig);
let entry_block = trampoline_builder.create_block();
let ret_vals = trampoline_builder.func.dfg.inst_results(call_inst).to_vec();
trampoline_builder.ins().return_(&ret_vals);
- cx.module
+ module
.define_function(
func_id,
- &mut Context::for_function(trampoline),
+ &mut cx.cached_context,
&mut NullTrapSink {},
&mut NullStackMapSink {},
)
-//! Drivers are responsible for calling [`codegen_mono_item`] and performing any further actions
-//! like JIT executing or writing object files.
+//! Drivers are responsible for calling [`codegen_fn`] or [`codegen_static`] for each mono item and
+//! performing any further actions like JIT executing or writing object files.
+//!
+//! [`codegen_fn`]: crate::base::codegen_fn
+//! [`codegen_static`]: crate::constant::codegen_static
-use std::any::Any;
-
-use rustc_middle::middle::cstore::EncodedMetadata;
use rustc_middle::mir::mono::{Linkage as RLinkage, MonoItem, Visibility};
use crate::prelude::*;
-use crate::CodegenMode;
-mod aot;
+pub(crate) mod aot;
#[cfg(feature = "jit")]
-mod jit;
-
-pub(crate) fn codegen_crate(
- tcx: TyCtxt<'_>,
- metadata: EncodedMetadata,
- need_metadata_module: bool,
- backend_config: crate::BackendConfig,
-) -> Box<dyn Any> {
- tcx.sess.abort_if_errors();
-
- match backend_config.codegen_mode {
- CodegenMode::Aot => aot::run_aot(tcx, backend_config, metadata, need_metadata_module),
- CodegenMode::Jit | CodegenMode::JitLazy => {
- let is_executable =
- tcx.sess.crate_types().contains(&rustc_session::config::CrateType::Executable);
- if !is_executable {
- tcx.sess.fatal("can't jit non-executable crate");
- }
-
- #[cfg(feature = "jit")]
- let _: ! = jit::run_jit(tcx, backend_config);
-
- #[cfg(not(feature = "jit"))]
- tcx.sess.fatal("jit support was disabled when compiling rustc_codegen_cranelift");
- }
- }
-}
+pub(crate) mod jit;
fn predefine_mono_items<'tcx>(
- cx: &mut crate::CodegenCx<'_, 'tcx>,
+ tcx: TyCtxt<'tcx>,
+ module: &mut dyn Module,
mono_items: &[(MonoItem<'tcx>, (RLinkage, Visibility))],
) {
- cx.tcx.sess.time("predefine functions", || {
- let is_compiler_builtins = cx.tcx.is_compiler_builtins(LOCAL_CRATE);
+ tcx.sess.time("predefine functions", || {
+ let is_compiler_builtins = tcx.is_compiler_builtins(LOCAL_CRATE);
for &(mono_item, (linkage, visibility)) in mono_items {
match mono_item {
MonoItem::Fn(instance) => {
- let name = cx.tcx.symbol_name(instance).name.to_string();
+ let name = tcx.symbol_name(instance).name;
let _inst_guard = crate::PrintOnPanic(|| format!("{:?} {}", instance, name));
- let sig = get_function_sig(cx.tcx, cx.module.isa().triple(), instance);
+ let sig = get_function_sig(tcx, module.isa().triple(), instance);
let linkage = crate::linkage::get_clif_linkage(
mono_item,
linkage,
visibility,
is_compiler_builtins,
);
- cx.module.declare_function(&name, linkage, &sig).unwrap();
+ module.declare_function(name, linkage, &sig).unwrap();
}
MonoItem::Static(_) | MonoItem::GlobalAsm(_) => {}
}
});
}
-fn time<R>(tcx: TyCtxt<'_>, name: &'static str, f: impl FnOnce() -> R) -> R {
- if std::env::var("CG_CLIF_DISPLAY_CG_TIME").as_ref().map(|val| &**val) == Ok("1") {
+fn time<R>(tcx: TyCtxt<'_>, display: bool, name: &'static str, f: impl FnOnce() -> R) -> R {
+ if display {
println!("[{:<30}: {}] start", tcx.crate_name(LOCAL_CRATE), name);
let before = std::time::Instant::now();
let res = tcx.sess.time(name, f);
let true_ = fx.bcx.ins().iconst(types::I32, 1);
fx.bcx.ins().trapnz(true_, TrapCode::User(1));
return;
+ } else if template[0] == InlineAsmTemplatePiece::String("mov rsi, rbx".to_string())
+ && template[1] == InlineAsmTemplatePiece::String("\n".to_string())
+ && template[2] == InlineAsmTemplatePiece::String("cpuid".to_string())
+ && template[3] == InlineAsmTemplatePiece::String("\n".to_string())
+ && template[4] == InlineAsmTemplatePiece::String("xchg rsi, rbx".to_string())
+ {
+ assert_eq!(operands.len(), 4);
+ let (leaf, eax_place) = match operands[0] {
+ InlineAsmOperand::InOut { reg, late: true, ref in_value, out_place } => {
+ let reg = expect_reg(reg);
+ assert_eq!(reg, InlineAsmReg::X86(X86InlineAsmReg::ax));
+ (
+ crate::base::codegen_operand(fx, in_value).load_scalar(fx),
+ crate::base::codegen_place(fx, out_place.unwrap()),
+ )
+ }
+ _ => unreachable!(),
+ };
+ let ebx_place = match operands[1] {
+ InlineAsmOperand::Out { reg, late: true, place } => {
+ let reg = expect_reg(reg);
+ assert_eq!(reg, InlineAsmReg::X86(X86InlineAsmReg::si));
+ crate::base::codegen_place(fx, place.unwrap())
+ }
+ _ => unreachable!(),
+ };
+ let (sub_leaf, ecx_place) = match operands[2] {
+ InlineAsmOperand::InOut { reg, late: true, ref in_value, out_place } => {
+ let reg = expect_reg(reg);
+ assert_eq!(reg, InlineAsmReg::X86(X86InlineAsmReg::cx));
+ (
+ crate::base::codegen_operand(fx, in_value).load_scalar(fx),
+ crate::base::codegen_place(fx, out_place.unwrap()),
+ )
+ }
+ _ => unreachable!(),
+ };
+ let edx_place = match operands[3] {
+ InlineAsmOperand::Out { reg, late: true, place } => {
+ let reg = expect_reg(reg);
+ assert_eq!(reg, InlineAsmReg::X86(X86InlineAsmReg::dx));
+ crate::base::codegen_place(fx, place.unwrap())
+ }
+ _ => unreachable!(),
+ };
+
+ let (eax, ebx, ecx, edx) = crate::intrinsics::codegen_cpuid_call(fx, leaf, sub_leaf);
+
+ eax_place.write_cvalue(fx, CValue::by_val(eax, fx.layout_of(fx.tcx.types.u32)));
+ ebx_place.write_cvalue(fx, CValue::by_val(ebx, fx.layout_of(fx.tcx.types.u32)));
+ ecx_place.write_cvalue(fx, CValue::by_val(ecx, fx.layout_of(fx.tcx.types.u32)));
+ edx_place.write_cvalue(fx, CValue::by_val(edx, fx.layout_of(fx.tcx.types.u32)));
+ return;
+ } else if fx.tcx.symbol_name(fx.instance).name.starts_with("___chkstk") {
+ // ___chkstk, ___chkstk_ms and __alloca are only used on Windows
+ crate::trap::trap_unimplemented(fx, "Stack probes are not supported");
+ } else if fx.tcx.symbol_name(fx.instance).name == "__alloca" {
+ crate::trap::trap_unimplemented(fx, "Alloca is not supported");
}
let mut slot_size = Size::from_bytes(0);
let inline_asm_index = fx.inline_asm_index;
fx.inline_asm_index += 1;
- let asm_name =
- format!("{}__inline_asm_{}", fx.tcx.symbol_name(fx.instance).name, inline_asm_index);
+ let asm_name = format!("{}__inline_asm_{}", fx.symbol_name, inline_asm_index);
let generated_asm = generate_asm_wrapper(
&asm_name,
}
let inline_asm_func = fx
- .cx
.module
.declare_function(
asm_name,
},
)
.unwrap();
- let inline_asm_func = fx.cx.module.declare_func_in_func(inline_asm_func, &mut fx.bcx.func);
+ let inline_asm_func = fx.module.declare_func_in_func(inline_asm_func, &mut fx.bcx.func);
if fx.clif_comments.enabled() {
fx.add_comment(inline_asm_func, asm_name);
}
pub(crate) fn codegen_cpuid_call<'tcx>(
fx: &mut FunctionCx<'_, '_, 'tcx>,
leaf: Value,
- _subleaf: Value,
+ _sub_leaf: Value,
) -> (Value, Value, Value, Value) {
let leaf_0 = fx.bcx.create_block();
let leaf_1 = fx.bcx.create_block();
};
// Used by `_mm_movemask_epi8` and `_mm256_movemask_epi8`
- llvm.x86.sse2.pmovmskb.128 | llvm.x86.avx2.pmovmskb | llvm.x86.sse2.movmsk.pd, (c a) {
+ "llvm.x86.sse2.pmovmskb.128" | "llvm.x86.avx2.pmovmskb" | "llvm.x86.sse2.movmsk.pd", (c a) {
let (lane_count, lane_ty) = a.layout().ty.simd_size_and_type(fx.tcx);
let lane_ty = fx.clif_type(lane_ty).unwrap();
assert!(lane_count <= 32);
let res = CValue::by_val(res, fx.layout_of(fx.tcx.types.i32));
ret.write_cvalue(fx, res);
};
- llvm.x86.sse2.cmp.ps | llvm.x86.sse2.cmp.pd, (c x, c y, o kind) {
+ "llvm.x86.sse2.cmp.ps" | "llvm.x86.sse2.cmp.pd", (c x, c y, o kind) {
let kind_const = crate::constant::mir_operand_get_const_val(fx, kind).expect("llvm.x86.sse2.cmp.* kind not const");
let flt_cc = match kind_const.try_to_bits(Size::from_bytes(1)).unwrap_or_else(|| panic!("kind not scalar: {:?}", kind_const)) {
0 => FloatCC::Equal,
bool_to_zero_or_max_uint(fx, res_lane_layout, res_lane)
});
};
- llvm.x86.sse2.psrli.d, (c a, o imm8) {
+ "llvm.x86.sse2.psrli.d", (c a, o imm8) {
let imm8 = crate::constant::mir_operand_get_const_val(fx, imm8).expect("llvm.x86.sse2.psrli.d imm8 not const");
simd_for_each_lane(fx, a, ret, |fx, _lane_layout, res_lane_layout, lane| {
let res_lane = match imm8.try_to_bits(Size::from_bytes(4)).unwrap_or_else(|| panic!("imm8 not scalar: {:?}", imm8)) {
CValue::by_val(res_lane, res_lane_layout)
});
};
- llvm.x86.sse2.pslli.d, (c a, o imm8) {
+ "llvm.x86.sse2.pslli.d", (c a, o imm8) {
let imm8 = crate::constant::mir_operand_get_const_val(fx, imm8).expect("llvm.x86.sse2.psrli.d imm8 not const");
simd_for_each_lane(fx, a, ret, |fx, _lane_layout, res_lane_layout, lane| {
let res_lane = match imm8.try_to_bits(Size::from_bytes(4)).unwrap_or_else(|| panic!("imm8 not scalar: {:?}", imm8)) {
CValue::by_val(res_lane, res_lane_layout)
});
};
- llvm.x86.sse2.storeu.dq, (v mem_addr, c a) {
+ "llvm.x86.sse2.storeu.dq", (v mem_addr, c a) {
// FIXME correctly handle the unalignment
let dest = CPlace::for_ptr(Pointer::new(mem_addr), a.layout());
dest.write_cvalue(fx, a);
pub(crate) use cpuid::codegen_cpuid_call;
pub(crate) use llvm::codegen_llvm_intrinsic_call;
+use rustc_span::symbol::{sym, kw};
+use rustc_middle::ty::print::with_no_trimmed_paths;
+
use crate::prelude::*;
use cranelift_codegen::ir::AtomicRmwOp;
-use rustc_middle::ty::print::with_no_trimmed_paths;
macro intrinsic_pat {
(_) => {
_
},
($name:ident) => {
- stringify!($name)
+ sym::$name
+ },
+ (kw.$name:ident) => {
+ kw::$name
},
($name:literal) => {
- stringify!($name)
+ $name
},
- ($x:ident . $($xs:tt).*) => {
- concat!(stringify!($x), ".", intrinsic_pat!($($xs).*))
- }
}
macro intrinsic_arg {
)*) => {
match $intrinsic {
$(
- stringify!($name) => {
+ sym::$name => {
assert!($substs.is_noop());
if let [$(ref $arg),*] = *$args {
let ($($arg,)*) = (
let def_id = instance.def_id();
let substs = instance.substs;
- let intrinsic = fx.tcx.item_name(def_id).as_str();
- let intrinsic = &intrinsic[..];
+ let intrinsic = fx.tcx.item_name(def_id);
let ret = match destination {
Some((place, _)) => place,
None => {
// Insert non returning intrinsics here
match intrinsic {
- "abort" => {
+ sym::abort => {
trap_abort(fx, "Called intrinsic::abort.");
}
- "transmute" => {
+ sym::transmute => {
crate::base::codegen_panic(fx, "Transmuting to uninhabited type.", span);
}
_ => unimplemented!("unsupported instrinsic {}", intrinsic),
}
};
- if intrinsic.starts_with("simd_") {
+ if intrinsic.as_str().starts_with("simd_") {
self::simd::codegen_simd_intrinsic_call(fx, instance, args, ret, span);
let ret_block = fx.get_block(destination.expect("SIMD intrinsics don't diverge").1);
fx.bcx.ins().jump(ret_block, &[]);
sinf64(flt) -> f64 => sin,
cosf32(flt) -> f32 => cosf,
cosf64(flt) -> f64 => cos,
- tanf32(flt) -> f32 => tanf,
- tanf64(flt) -> f64 => tan,
}
intrinsic_match! {
count
};
- if intrinsic.contains("nonoverlapping") {
+ if intrinsic == sym::copy_nonoverlapping {
// FIXME emit_small_memcpy
- fx.bcx.call_memcpy(fx.cx.module.target_config(), dst, src, byte_amount);
+ fx.bcx.call_memcpy(fx.module.target_config(), dst, src, byte_amount);
} else {
// FIXME emit_small_memmove
- fx.bcx.call_memmove(fx.cx.module.target_config(), dst, src, byte_amount);
+ fx.bcx.call_memmove(fx.module.target_config(), dst, src, byte_amount);
}
};
// NOTE: the volatile variants have src and dst swapped
};
// FIXME make the copy actually volatile when using emit_small_mem{cpy,move}
- if intrinsic.contains("nonoverlapping") {
+ if intrinsic == sym::volatile_copy_nonoverlapping_memory {
// FIXME emit_small_memcpy
- fx.bcx.call_memcpy(fx.cx.module.target_config(), dst, src, byte_amount);
+ fx.bcx.call_memcpy(fx.module.target_config(), dst, src, byte_amount);
} else {
// FIXME emit_small_memmove
- fx.bcx.call_memmove(fx.cx.module.target_config(), dst, src, byte_amount);
+ fx.bcx.call_memmove(fx.module.target_config(), dst, src, byte_amount);
}
};
size_of_val, <T> (c ptr) {
ret.write_cvalue(fx, CValue::by_val(align, usize_layout));
};
- _ if intrinsic.starts_with("unchecked_") || intrinsic == "exact_div", (c x, c y) {
+ unchecked_add | unchecked_sub | unchecked_div | exact_div | unchecked_rem
+ | unchecked_shl | unchecked_shr, (c x, c y) {
// FIXME trap on overflow
let bin_op = match intrinsic {
- "unchecked_add" => BinOp::Add,
- "unchecked_sub" => BinOp::Sub,
- "unchecked_div" | "exact_div" => BinOp::Div,
- "unchecked_rem" => BinOp::Rem,
- "unchecked_shl" => BinOp::Shl,
- "unchecked_shr" => BinOp::Shr,
- _ => unreachable!("intrinsic {}", intrinsic),
+ sym::unchecked_add => BinOp::Add,
+ sym::unchecked_sub => BinOp::Sub,
+ sym::unchecked_div | sym::exact_div => BinOp::Div,
+ sym::unchecked_rem => BinOp::Rem,
+ sym::unchecked_shl => BinOp::Shl,
+ sym::unchecked_shr => BinOp::Shr,
+ _ => unreachable!(),
};
let res = crate::num::codegen_int_binop(fx, bin_op, x, y);
ret.write_cvalue(fx, res);
};
- _ if intrinsic.ends_with("_with_overflow"), (c x, c y) {
+ add_with_overflow | sub_with_overflow | mul_with_overflow, (c x, c y) {
assert_eq!(x.layout().ty, y.layout().ty);
let bin_op = match intrinsic {
- "add_with_overflow" => BinOp::Add,
- "sub_with_overflow" => BinOp::Sub,
- "mul_with_overflow" => BinOp::Mul,
- _ => unreachable!("intrinsic {}", intrinsic),
+ sym::add_with_overflow => BinOp::Add,
+ sym::sub_with_overflow => BinOp::Sub,
+ sym::mul_with_overflow => BinOp::Mul,
+ _ => unreachable!(),
};
let res = crate::num::codegen_checked_int_binop(
);
ret.write_cvalue(fx, res);
};
- _ if intrinsic.starts_with("saturating_"), <T> (c lhs, c rhs) {
+ saturating_add | saturating_sub, <T> (c lhs, c rhs) {
assert_eq!(lhs.layout().ty, rhs.layout().ty);
let bin_op = match intrinsic {
- "saturating_add" => BinOp::Add,
- "saturating_sub" => BinOp::Sub,
- _ => unreachable!("intrinsic {}", intrinsic),
+ sym::saturating_add => BinOp::Add,
+ sym::saturating_sub => BinOp::Sub,
+ _ => unreachable!(),
};
let signed = type_sign(T);
let (min, max) = type_min_max_value(&mut fx.bcx, clif_ty, signed);
let val = match (intrinsic, signed) {
- ("saturating_add", false) => fx.bcx.ins().select(has_overflow, max, val),
- ("saturating_sub", false) => fx.bcx.ins().select(has_overflow, min, val),
- ("saturating_add", true) => {
+ (sym::saturating_add, false) => fx.bcx.ins().select(has_overflow, max, val),
+ (sym::saturating_sub, false) => fx.bcx.ins().select(has_overflow, min, val),
+ (sym::saturating_add, true) => {
let rhs = rhs.load_scalar(fx);
let rhs_ge_zero = fx.bcx.ins().icmp_imm(IntCC::SignedGreaterThanOrEqual, rhs, 0);
let sat_val = fx.bcx.ins().select(rhs_ge_zero, max, min);
fx.bcx.ins().select(has_overflow, sat_val, val)
}
- ("saturating_sub", true) => {
+ (sym::saturating_sub, true) => {
let rhs = rhs.load_scalar(fx);
let rhs_ge_zero = fx.bcx.ins().icmp_imm(IntCC::SignedGreaterThanOrEqual, rhs, 0);
let sat_val = fx.bcx.ins().select(rhs_ge_zero, min, max);
};
rotate_left, <T>(v x, v y) {
let layout = fx.layout_of(T);
+ let y = if fx.bcx.func.dfg.value_type(y) == types::I128 {
+ fx.bcx.ins().ireduce(types::I64, y)
+ } else {
+ y
+ };
let res = fx.bcx.ins().rotl(x, y);
ret.write_cvalue(fx, CValue::by_val(res, layout));
};
rotate_right, <T>(v x, v y) {
let layout = fx.layout_of(T);
+ let y = if fx.bcx.func.dfg.value_type(y) == types::I128 {
+ fx.bcx.ins().ireduce(types::I64, y)
+ } else {
+ y
+ };
let res = fx.bcx.ins().rotr(x, y);
ret.write_cvalue(fx, CValue::by_val(res, layout));
};
let dst_ptr = dst.load_scalar(fx);
// FIXME make the memset actually volatile when switching to emit_small_memset
// FIXME use emit_small_memset
- fx.bcx.call_memset(fx.cx.module.target_config(), dst_ptr, val, count);
+ fx.bcx.call_memset(fx.module.target_config(), dst_ptr, val, count);
};
ctlz | ctlz_nonzero, <T> (v arg) {
// FIXME trap on `ctlz_nonzero` with zero arg.
return;
}
- if intrinsic == "assert_zero_valid" && !layout.might_permit_raw_init(fx, /*zero:*/ true).unwrap() {
+ if intrinsic == sym::assert_zero_valid && !layout.might_permit_raw_init(fx, /*zero:*/ true).unwrap() {
with_no_trimmed_paths(|| crate::base::codegen_panic(
fx,
&format!("attempted to zero-initialize type `{}`, which is invalid", T),
return;
}
- if intrinsic == "assert_uninit_valid" && !layout.might_permit_raw_init(fx, /*zero:*/ false).unwrap() {
+ if intrinsic == sym::assert_uninit_valid && !layout.might_permit_raw_init(fx, /*zero:*/ false).unwrap() {
with_no_trimmed_paths(|| crate::base::codegen_panic(
fx,
&format!("attempted to leave type `{}` uninitialized, which is invalid", T),
volatile_load | unaligned_volatile_load, (c ptr) {
// Cranelift treats loads as volatile by default
- // FIXME ignore during stack2reg optimization
// FIXME correctly handle unaligned_volatile_load
let inner_layout =
fx.layout_of(ptr.layout().ty.builtin_deref(true).unwrap().ty);
};
volatile_store | unaligned_volatile_store, (v ptr, c val) {
// Cranelift treats stores as volatile by default
- // FIXME ignore during stack2reg optimization
// FIXME correctly handle unaligned_volatile_store
let dest = CPlace::for_ptr(Pointer::new(ptr), val.layout());
dest.write_cvalue(fx, val);
ret.write_cvalue(fx, caller_location);
};
- _ if intrinsic.starts_with("atomic_fence"), () {
+ _ if intrinsic.as_str().starts_with("atomic_fence"), () {
fx.bcx.ins().fence();
};
- _ if intrinsic.starts_with("atomic_singlethreadfence"), () {
+ _ if intrinsic.as_str().starts_with("atomic_singlethreadfence"), () {
// FIXME use a compiler fence once Cranelift supports it
fx.bcx.ins().fence();
};
- _ if intrinsic.starts_with("atomic_load"), <T> (v ptr) {
+ _ if intrinsic.as_str().starts_with("atomic_load"), <T> (v ptr) {
validate_atomic_type!(fx, intrinsic, span, T);
let ty = fx.clif_type(T).unwrap();
let val = CValue::by_val(val, fx.layout_of(T));
ret.write_cvalue(fx, val);
};
- _ if intrinsic.starts_with("atomic_store"), (v ptr, c val) {
+ _ if intrinsic.as_str().starts_with("atomic_store"), (v ptr, c val) {
validate_atomic_type!(fx, intrinsic, span, val.layout().ty);
let val = val.load_scalar(fx);
fx.bcx.ins().atomic_store(MemFlags::trusted(), val, ptr);
};
- _ if intrinsic.starts_with("atomic_xchg"), (v ptr, c new) {
+ _ if intrinsic.as_str().starts_with("atomic_xchg"), (v ptr, c new) {
let layout = new.layout();
validate_atomic_type!(fx, intrinsic, span, layout.ty);
let ty = fx.clif_type(layout.ty).unwrap();
let old = CValue::by_val(old, layout);
ret.write_cvalue(fx, old);
};
- _ if intrinsic.starts_with("atomic_cxchg"), (v ptr, c test_old, c new) { // both atomic_cxchg_* and atomic_cxchgweak_*
+ _ if intrinsic.as_str().starts_with("atomic_cxchg"), (v ptr, c test_old, c new) { // both atomic_cxchg_* and atomic_cxchgweak_*
let layout = new.layout();
validate_atomic_type!(fx, intrinsic, span, layout.ty);
ret.write_cvalue(fx, ret_val)
};
- _ if intrinsic.starts_with("atomic_xadd"), (v ptr, c amount) {
+ _ if intrinsic.as_str().starts_with("atomic_xadd"), (v ptr, c amount) {
let layout = amount.layout();
validate_atomic_type!(fx, intrinsic, span, layout.ty);
let ty = fx.clif_type(layout.ty).unwrap();
let old = CValue::by_val(old, layout);
ret.write_cvalue(fx, old);
};
- _ if intrinsic.starts_with("atomic_xsub"), (v ptr, c amount) {
+ _ if intrinsic.as_str().starts_with("atomic_xsub"), (v ptr, c amount) {
let layout = amount.layout();
validate_atomic_type!(fx, intrinsic, span, layout.ty);
let ty = fx.clif_type(layout.ty).unwrap();
let old = CValue::by_val(old, layout);
ret.write_cvalue(fx, old);
};
- _ if intrinsic.starts_with("atomic_and"), (v ptr, c src) {
+ _ if intrinsic.as_str().starts_with("atomic_and"), (v ptr, c src) {
let layout = src.layout();
validate_atomic_type!(fx, intrinsic, span, layout.ty);
let ty = fx.clif_type(layout.ty).unwrap();
let old = CValue::by_val(old, layout);
ret.write_cvalue(fx, old);
};
- _ if intrinsic.starts_with("atomic_or"), (v ptr, c src) {
+ _ if intrinsic.as_str().starts_with("atomic_or"), (v ptr, c src) {
let layout = src.layout();
validate_atomic_type!(fx, intrinsic, span, layout.ty);
let ty = fx.clif_type(layout.ty).unwrap();
let old = CValue::by_val(old, layout);
ret.write_cvalue(fx, old);
};
- _ if intrinsic.starts_with("atomic_xor"), (v ptr, c src) {
+ _ if intrinsic.as_str().starts_with("atomic_xor"), (v ptr, c src) {
let layout = src.layout();
validate_atomic_type!(fx, intrinsic, span, layout.ty);
let ty = fx.clif_type(layout.ty).unwrap();
};
// FIXME https://github.com/bytecodealliance/wasmtime/issues/2647
- _ if intrinsic.starts_with("atomic_nand"), (v ptr, c src) {
+ _ if intrinsic.as_str().starts_with("atomic_nand"), (v ptr, c src) {
let layout = src.layout();
validate_atomic_type!(fx, intrinsic, span, layout.ty);
let ty = fx.clif_type(layout.ty).unwrap();
let old = CValue::by_val(old, layout);
ret.write_cvalue(fx, old);
};
- _ if intrinsic.starts_with("atomic_max"), (v ptr, c src) {
+ _ if intrinsic.as_str().starts_with("atomic_max"), (v ptr, c src) {
let layout = src.layout();
validate_atomic_type!(fx, intrinsic, span, layout.ty);
let ty = fx.clif_type(layout.ty).unwrap();
let old = CValue::by_val(old, layout);
ret.write_cvalue(fx, old);
};
- _ if intrinsic.starts_with("atomic_umax"), (v ptr, c src) {
+ _ if intrinsic.as_str().starts_with("atomic_umax"), (v ptr, c src) {
let layout = src.layout();
validate_atomic_type!(fx, intrinsic, span, layout.ty);
let ty = fx.clif_type(layout.ty).unwrap();
let old = CValue::by_val(old, layout);
ret.write_cvalue(fx, old);
};
- _ if intrinsic.starts_with("atomic_min"), (v ptr, c src) {
+ _ if intrinsic.as_str().starts_with("atomic_min"), (v ptr, c src) {
let layout = src.layout();
validate_atomic_type!(fx, intrinsic, span, layout.ty);
let ty = fx.clif_type(layout.ty).unwrap();
let old = CValue::by_val(old, layout);
ret.write_cvalue(fx, old);
};
- _ if intrinsic.starts_with("atomic_umin"), (v ptr, c src) {
+ _ if intrinsic.as_str().starts_with("atomic_umin"), (v ptr, c src) {
let layout = src.layout();
validate_atomic_type!(fx, intrinsic, span, layout.ty);
let ty = fx.clif_type(layout.ty).unwrap();
ret.write_cvalue(fx, val);
};
- try, (v f, v data, v _catch_fn) {
+ kw.Try, (v f, v data, v _catch_fn) {
// FIXME once unwinding is supported, change this to actually catch panics
let f_sig = fx.bcx.func.import_signature(Signature {
call_conv: CallConv::triple_default(fx.triple()),
fadd_fast | fsub_fast | fmul_fast | fdiv_fast | frem_fast, (c x, c y) {
let res = crate::num::codegen_float_binop(fx, match intrinsic {
- "fadd_fast" => BinOp::Add,
- "fsub_fast" => BinOp::Sub,
- "fmul_fast" => BinOp::Mul,
- "fdiv_fast" => BinOp::Div,
- "frem_fast" => BinOp::Rem,
+ sym::fadd_fast => BinOp::Add,
+ sym::fsub_fast => BinOp::Sub,
+ sym::fmul_fast => BinOp::Mul,
+ sym::fdiv_fast => BinOp::Div,
+ sym::frem_fast => BinOp::Rem,
_ => unreachable!(),
}, x, y);
ret.write_cvalue(fx, res);
let def_id = instance.def_id();
let substs = instance.substs;
- let intrinsic = fx.tcx.item_name(def_id).as_str();
- let intrinsic = &intrinsic[..];
+ let intrinsic = fx.tcx.item_name(def_id);
intrinsic_match! {
fx, intrinsic, substs, args,
};
// simd_shuffle32<T, U>(x: T, y: T, idx: [u32; 32]) -> U
- _ if intrinsic.starts_with("simd_shuffle"), (c x, c y, o idx) {
+ _ if intrinsic.as_str().starts_with("simd_shuffle"), (c x, c y, o idx) {
validate_simd_type!(fx, intrinsic, span, x.layout().ty);
- let n: u16 = intrinsic["simd_shuffle".len()..].parse().unwrap();
+ let n: u16 = intrinsic.as_str()["simd_shuffle".len()..].parse().unwrap();
assert_eq!(x.layout(), y.layout());
let layout = x.layout();
-#![feature(rustc_private, decl_macro, never_type, hash_drain_filter)]
+#![feature(rustc_private, decl_macro, never_type, hash_drain_filter, vec_into_raw_parts)]
#![warn(rust_2018_idioms)]
#![warn(unused_lifetimes)]
#![warn(unreachable_pub)]
extern crate rustc_driver;
use std::any::Any;
-use std::str::FromStr;
use rustc_codegen_ssa::traits::CodegenBackend;
use rustc_codegen_ssa::CodegenResults;
use rustc_session::config::OutputFilenames;
use rustc_session::Session;
+use cranelift_codegen::isa::TargetIsa;
use cranelift_codegen::settings::{self, Configurable};
-use crate::constant::ConstantCx;
+pub use crate::config::*;
use crate::prelude::*;
mod abi;
mod codegen_i128;
mod common;
mod compiler_builtins;
+mod config;
mod constant;
mod debuginfo;
mod discriminant;
pub(crate) use rustc_index::vec::Idx;
- pub(crate) use cranelift_codegen::entity::EntitySet;
pub(crate) use cranelift_codegen::ir::condcodes::{FloatCC, IntCC};
pub(crate) use cranelift_codegen::ir::function::Function;
pub(crate) use cranelift_codegen::ir::types;
}
}
-struct CodegenCx<'m, 'tcx: 'm> {
+/// The codegen context holds any information shared between the codegen of individual functions
+/// inside a single codegen unit with the exception of the Cranelift [`Module`](cranelift_module::Module).
+struct CodegenCx<'tcx> {
tcx: TyCtxt<'tcx>,
- module: &'m mut dyn Module,
global_asm: String,
- constants_cx: ConstantCx,
cached_context: Context,
- vtables: FxHashMap<(Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>), DataId>,
debug_context: Option<DebugContext<'tcx>>,
- unwind_context: UnwindContext<'tcx>,
+ unwind_context: UnwindContext,
}
-impl<'m, 'tcx> CodegenCx<'m, 'tcx> {
+impl<'tcx> CodegenCx<'tcx> {
fn new(
tcx: TyCtxt<'tcx>,
backend_config: BackendConfig,
- module: &'m mut dyn Module,
+ isa: &dyn TargetIsa,
debug_info: bool,
) -> Self {
- let unwind_context = UnwindContext::new(
- tcx,
- module.isa(),
- matches!(backend_config.codegen_mode, CodegenMode::Aot),
- );
- let debug_context =
- if debug_info { Some(DebugContext::new(tcx, module.isa())) } else { None };
+ assert_eq!(pointer_ty(tcx), isa.pointer_type());
+
+ let unwind_context =
+ UnwindContext::new(tcx, isa, matches!(backend_config.codegen_mode, CodegenMode::Aot));
+ let debug_context = if debug_info { Some(DebugContext::new(tcx, isa)) } else { None };
CodegenCx {
tcx,
- module,
global_asm: String::new(),
- constants_cx: ConstantCx::default(),
cached_context: Context::new(),
- vtables: FxHashMap::default(),
debug_context,
unwind_context,
}
}
-
- fn finalize(self) -> (String, Option<DebugContext<'tcx>>, UnwindContext<'tcx>) {
- self.constants_cx.finalize(self.tcx, self.module);
- (self.global_asm, self.debug_context, self.unwind_context)
- }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub enum CodegenMode {
- Aot,
- Jit,
- JitLazy,
-}
-
-impl Default for CodegenMode {
- fn default() -> Self {
- CodegenMode::Aot
- }
-}
-
-impl FromStr for CodegenMode {
- type Err = String;
-
- fn from_str(s: &str) -> Result<Self, Self::Err> {
- match s {
- "aot" => Ok(CodegenMode::Aot),
- "jit" => Ok(CodegenMode::Jit),
- "jit-lazy" => Ok(CodegenMode::JitLazy),
- _ => Err(format!("Unknown codegen mode `{}`", s)),
- }
- }
-}
-
-#[derive(Copy, Clone, Debug, Default)]
-pub struct BackendConfig {
- pub codegen_mode: CodegenMode,
-}
-
-impl BackendConfig {
- fn from_opts(opts: &[String]) -> Result<Self, String> {
- let mut config = BackendConfig::default();
- for opt in opts {
- if let Some((name, value)) = opt.split_once('=') {
- match name {
- "mode" => config.codegen_mode = value.parse()?,
- _ => return Err(format!("Unknown option `{}`", name)),
- }
- } else {
- return Err(format!("Invalid option `{}`", opt));
- }
- }
- Ok(config)
- }
}
pub struct CraneliftCodegenBackend {
metadata: EncodedMetadata,
need_metadata_module: bool,
) -> Box<dyn Any> {
- let config = if let Some(config) = self.config {
+ tcx.sess.abort_if_errors();
+ let config = if let Some(config) = self.config.clone() {
config
} else {
BackendConfig::from_opts(&tcx.sess.opts.cg.llvm_args)
.unwrap_or_else(|err| tcx.sess.fatal(&err))
};
- driver::codegen_crate(tcx, metadata, need_metadata_module, config)
+ match config.codegen_mode {
+ CodegenMode::Aot => driver::aot::run_aot(tcx, config, metadata, need_metadata_module),
+ CodegenMode::Jit | CodegenMode::JitLazy => {
+ #[cfg(feature = "jit")]
+ let _: ! = driver::jit::run_jit(tcx, config);
+
+ #[cfg(not(feature = "jit"))]
+ tcx.sess.fatal("jit support was disabled when compiling rustc_codegen_cranelift");
+ }
+ }
}
fn join_codegen(
sess.target.llvm_target.parse().unwrap()
}
-fn build_isa(sess: &Session) -> Box<dyn isa::TargetIsa + 'static> {
+fn build_isa(sess: &Session, backend_config: &BackendConfig) -> Box<dyn isa::TargetIsa + 'static> {
use target_lexicon::BinaryFormat;
let target_triple = crate::target_triple(sess);
let mut flags_builder = settings::builder();
flags_builder.enable("is_pic").unwrap();
flags_builder.set("enable_probestack", "false").unwrap(); // __cranelift_probestack is not provided
- let enable_verifier =
- cfg!(debug_assertions) || std::env::var("CG_CLIF_ENABLE_VERIFIER").is_ok();
- flags_builder.set("enable_verifier", if enable_verifier { "true" } else { "false" }).unwrap();
+ let enable_verifier = if backend_config.enable_verifier { "true" } else { "false" };
+ flags_builder.set("enable_verifier", enable_verifier).unwrap();
let tls_model = match target_triple.binary_format {
BinaryFormat::Elf => "elf_gd",
let flags = settings::Flags::new(flags_builder);
let variant = cranelift_codegen::isa::BackendVariant::MachInst;
- let mut isa_builder = cranelift_codegen::isa::lookup_variant(target_triple, variant).unwrap();
- // Don't use "haswell", as it implies `has_lzcnt`.macOS CI is still at Ivy Bridge EP, so `lzcnt`
- // is interpreted as `bsr`.
- isa_builder.enable("nehalem").unwrap();
+
+ let isa_builder = match sess.opts.cg.target_cpu.as_deref() {
+ Some("native") => {
+ let builder = cranelift_native::builder_with_options(variant, true).unwrap();
+ builder
+ }
+ Some(value) => {
+ let mut builder = cranelift_codegen::isa::lookup_variant(target_triple, variant).unwrap();
+ if let Err(_) = builder.enable(value) {
+ sess.fatal("The specified target cpu isn't currently supported by Cranelift.");
+ }
+ builder
+ }
+ None => {
+ let mut builder = cranelift_codegen::isa::lookup_variant(target_triple, variant).unwrap();
+ // Don't use "haswell" as the default, as it implies `has_lzcnt`.
+ // macOS CI is still at Ivy Bridge EP, so `lzcnt` is interpreted as `bsr`.
+ builder.enable("nehalem").unwrap();
+ builder
+ }
+ };
+
isa_builder.finish(flags)
}
(RLinkage::External, Visibility::Default) => Linkage::Export,
(RLinkage::Internal, Visibility::Default) => Linkage::Local,
(RLinkage::External, Visibility::Hidden) => Linkage::Hidden,
+ (RLinkage::WeakAny, Visibility::Default) => Linkage::Preemptible,
_ => panic!("{:?} = {:?} {:?}", mono_item, linkage, visibility),
}
}
use cranelift_codegen::binemit::{NullStackMapSink, NullTrapSink};
use rustc_hir::LangItem;
+use rustc_middle::ty::subst::GenericArg;
+use rustc_middle::ty::AssocKind;
use rustc_session::config::EntryFnType;
+use rustc_span::symbol::Ident;
use crate::prelude::*;
pub(crate) fn maybe_create_entry_wrapper(
tcx: TyCtxt<'_>,
module: &mut impl Module,
- unwind_context: &mut UnwindContext<'_>,
+ unwind_context: &mut UnwindContext,
+ is_jit: bool,
) {
- let (main_def_id, use_start_lang_item) = match tcx.entry_fn(LOCAL_CRATE) {
+ let (main_def_id, is_main_fn) = match tcx.entry_fn(LOCAL_CRATE) {
Some((def_id, entry_ty)) => (
- def_id.to_def_id(),
+ def_id,
match entry_ty {
EntryFnType::Main => true,
EntryFnType::Start => false,
};
let instance = Instance::mono(tcx, main_def_id).polymorphize(tcx);
- if module.get_name(&*tcx.symbol_name(instance).name).is_none() {
+ if !is_jit && module.get_name(&*tcx.symbol_name(instance).name).is_none() {
return;
}
- create_entry_fn(tcx, module, unwind_context, main_def_id, use_start_lang_item);
+ create_entry_fn(tcx, module, unwind_context, main_def_id, is_jit, is_main_fn);
fn create_entry_fn(
tcx: TyCtxt<'_>,
m: &mut impl Module,
- unwind_context: &mut UnwindContext<'_>,
+ unwind_context: &mut UnwindContext,
rust_main_def_id: DefId,
- use_start_lang_item: bool,
+ ignore_lang_start_wrapper: bool,
+ is_main_fn: bool,
) {
let main_ret_ty = tcx.fn_sig(rust_main_def_id).output();
// Given that `main()` has no arguments,
let instance = Instance::mono(tcx, rust_main_def_id).polymorphize(tcx);
- let main_name = tcx.symbol_name(instance).name.to_string();
+ let main_name = tcx.symbol_name(instance).name;
let main_sig = get_function_sig(tcx, m.isa().triple(), instance);
- let main_func_id = m.declare_function(&main_name, Linkage::Import, &main_sig).unwrap();
+ let main_func_id = m.declare_function(main_name, Linkage::Import, &main_sig).unwrap();
let mut ctx = Context::new();
ctx.func = Function::with_name_signature(ExternalName::user(0, 0), cmain_sig);
let main_func_ref = m.declare_func_in_func(main_func_id, &mut bcx.func);
- let call_inst = if use_start_lang_item {
+ let result = if is_main_fn && ignore_lang_start_wrapper {
+ // regular main fn, but ignoring #[lang = "start"] as we are running in the jit
+ // FIXME set program arguments somehow
+ let call_inst = bcx.ins().call(main_func_ref, &[]);
+ let call_results = bcx.func.dfg.inst_results(call_inst).to_owned();
+
+ let termination_trait = tcx.require_lang_item(LangItem::Termination, None);
+ let report = tcx
+ .associated_items(termination_trait)
+ .find_by_name_and_kind(
+ tcx,
+ Ident::from_str("report"),
+ AssocKind::Fn,
+ termination_trait,
+ )
+ .unwrap();
+ let report = Instance::resolve(
+ tcx,
+ ParamEnv::reveal_all(),
+ report.def_id,
+ tcx.mk_substs([GenericArg::from(main_ret_ty)].iter()),
+ )
+ .unwrap()
+ .unwrap();
+
+ let report_name = tcx.symbol_name(report).name;
+ let report_sig = get_function_sig(tcx, m.isa().triple(), report);
+ let report_func_id =
+ m.declare_function(report_name, Linkage::Import, &report_sig).unwrap();
+ let report_func_ref = m.declare_func_in_func(report_func_id, &mut bcx.func);
+
+ // FIXME do proper abi handling instead of expecting the pass mode to be identical
+ // for returns and arguments.
+ let report_call_inst = bcx.ins().call(report_func_ref, &call_results);
+ let res = bcx.func.dfg.inst_results(report_call_inst)[0];
+ match m.target_config().pointer_type() {
+ types::I32 => res,
+ types::I64 => bcx.ins().sextend(types::I64, res),
+ _ => unimplemented!("16bit systems are not yet supported"),
+ }
+ } else if is_main_fn {
let start_def_id = tcx.require_lang_item(LangItem::Start, None);
let start_instance = Instance::resolve(
tcx,
let main_val = bcx.ins().func_addr(m.target_config().pointer_type(), main_func_ref);
let func_ref = m.declare_func_in_func(start_func_id, &mut bcx.func);
- bcx.ins().call(func_ref, &[main_val, arg_argc, arg_argv])
+ let call_inst = bcx.ins().call(func_ref, &[main_val, arg_argc, arg_argv]);
+ bcx.inst_results(call_inst)[0]
} else {
// using user-defined start fn
- bcx.ins().call(main_func_ref, &[arg_argc, arg_argv])
+ let call_inst = bcx.ins().call(main_func_ref, &[arg_argc, arg_argv]);
+ bcx.inst_results(call_inst)[0]
};
- let result = bcx.inst_results(call_inst)[0];
bcx.ins().return_(&[result]);
bcx.seal_all_blocks();
bcx.finalize();
use rustc_data_structures::owning_ref::OwningRef;
use rustc_data_structures::rustc_erase_owner;
use rustc_data_structures::sync::MetadataRef;
-use rustc_middle::middle::cstore::{EncodedMetadata, MetadataLoader};
+use rustc_middle::middle::cstore::MetadataLoader;
use rustc_middle::ty::TyCtxt;
-use rustc_session::config;
use rustc_target::spec::Target;
use crate::backend::WriteMetadata;
+/// The metadata loader used by cg_clif.
+///
+/// The metadata is stored in the same format as cg_llvm.
+///
+/// # Metadata location
+///
+/// <dl>
+/// <dt>rlib</dt>
+/// <dd>The metadata can be found in the `lib.rmeta` file inside of the ar archive.</dd>
+/// <dt>dylib</dt>
+/// <dd>The metadata can be found in the `.rustc` section of the shared library.</dd>
+/// </dl>
pub(crate) struct CraneliftMetadataLoader;
fn load_metadata_with(
}
// Adapted from https://github.com/rust-lang/rust/blob/da573206f87b5510de4b0ee1a9c044127e409bd3/src/librustc_codegen_llvm/base.rs#L47-L112
-pub(crate) fn write_metadata<P: WriteMetadata>(
- tcx: TyCtxt<'_>,
- product: &mut P,
-) -> EncodedMetadata {
+pub(crate) fn write_metadata<O: WriteMetadata>(tcx: TyCtxt<'_>, object: &mut O) {
use snap::write::FrameEncoder;
use std::io::Write;
- #[derive(PartialEq, Eq, PartialOrd, Ord)]
- enum MetadataKind {
- None,
- Uncompressed,
- Compressed,
- }
-
- let kind = tcx
- .sess
- .crate_types()
- .iter()
- .map(|ty| match *ty {
- config::CrateType::Executable
- | config::CrateType::Staticlib
- | config::CrateType::Cdylib => MetadataKind::None,
-
- config::CrateType::Rlib => MetadataKind::Uncompressed,
-
- config::CrateType::Dylib | config::CrateType::ProcMacro => MetadataKind::Compressed,
- })
- .max()
- .unwrap_or(MetadataKind::None);
-
- if kind == MetadataKind::None {
- return EncodedMetadata::new();
- }
-
let metadata = tcx.encode_metadata();
- if kind == MetadataKind::Uncompressed {
- return metadata;
- }
-
- assert!(kind == MetadataKind::Compressed);
let mut compressed = tcx.metadata_encoding_version();
FrameEncoder::new(&mut compressed).write_all(&metadata.raw_data).unwrap();
- product.add_rustc_section(
+ object.add_rustc_section(
rustc_middle::middle::exported_symbols::metadata_symbol_name(tcx),
compressed,
- tcx.sess.target.is_like_osx,
);
-
- metadata
}
let val_hi = fx.bcx.ins().umulhi(lhs, rhs);
fx.bcx.ins().icmp_imm(IntCC::NotEqual, val_hi, 0)
} else {
+ // Based on LLVM's instruction sequence for compiling
+ // a.checked_mul(b).is_some() to riscv64gc:
+ // mulh a2, a0, a1
+ // mul a0, a0, a1
+ // srai a0, a0, 63
+ // xor a0, a0, a2
+ // snez a0, a0
let val_hi = fx.bcx.ins().smulhi(lhs, rhs);
- let not_all_zero = fx.bcx.ins().icmp_imm(IntCC::NotEqual, val_hi, 0);
- let not_all_ones = fx.bcx.ins().icmp_imm(
- IntCC::NotEqual,
- val_hi,
- u64::try_from((1u128 << ty.bits()) - 1).unwrap() as i64,
- );
- fx.bcx.ins().band(not_all_zero, not_all_ones)
+ let val_sign = fx.bcx.ins().sshr_imm(val, i64::from(ty.bits() - 1));
+ let xor = fx.bcx.ins().bxor(val_hi, val_sign);
+ fx.bcx.ins().icmp_imm(IntCC::NotEqual, xor, 0)
};
(val, has_overflow)
}
+++ /dev/null
-//! This optimization moves cold code to the end of the function.
-//!
-//! Some code is executed much less often than other code. For example panicking or the
-//! landingpads for unwinding. By moving this cold code to the end of the function the average
-//! amount of jumps is reduced and the code locality is improved.
-//!
-//! # Undefined behaviour
-//!
-//! This optimization doesn't assume anything that isn't already assumed by Cranelift itself.
-
-use crate::prelude::*;
-
-pub(super) fn optimize_function(ctx: &mut Context, cold_blocks: &EntitySet<Block>) {
- // FIXME Move the block in place instead of remove and append once
- // bytecodealliance/cranelift#1339 is implemented.
-
- let mut block_insts = FxHashMap::default();
- for block in cold_blocks.keys().filter(|&block| cold_blocks.contains(block)) {
- let insts = ctx.func.layout.block_insts(block).collect::<Vec<_>>();
- for &inst in &insts {
- ctx.func.layout.remove_inst(inst);
- }
- block_insts.insert(block, insts);
- ctx.func.layout.remove_block(block);
- }
-
- // And then append them at the back again.
- for block in cold_blocks.keys().filter(|&block| cold_blocks.contains(block)) {
- ctx.func.layout.append_block(block);
- for inst in block_insts.remove(&block).unwrap() {
- ctx.func.layout.append_inst(inst, block);
- }
- }
-}
use crate::prelude::*;
-mod code_layout;
pub(crate) mod peephole;
-mod stack2reg;
pub(crate) fn optimize_function<'tcx>(
tcx: TyCtxt<'tcx>,
instance: Instance<'tcx>,
ctx: &mut Context,
- cold_blocks: &EntitySet<Block>,
clif_comments: &mut crate::pretty_clif::CommentWriter,
) {
- // The code_layout optimization is very cheap.
- self::code_layout::optimize_function(ctx, cold_blocks);
+ // FIXME classify optimizations over opt levels once we have more
- if tcx.sess.opts.optimize == rustc_session::config::OptLevel::No {
- return; // FIXME classify optimizations over opt levels
- }
-
- // FIXME(#1142) stack2reg miscompiles lewton
- if false {
- self::stack2reg::optimize_function(ctx, clif_comments);
- }
-
- crate::pretty_clif::write_clif_file(tcx, "stack2reg", None, instance, &ctx, &*clif_comments);
+ crate::pretty_clif::write_clif_file(tcx, "preopt", None, instance, &ctx, &*clif_comments);
crate::base::verify_func(tcx, &*clif_comments, &ctx.func);
}
+++ /dev/null
-//! This optimization replaces stack accesses with SSA variables and removes dead stores when possible.
-//!
-//! # Undefined behaviour
-//!
-//! This optimization is based on the assumption that stack slots which don't have their address
-//! leaked through `stack_addr` are only accessed using `stack_load` and `stack_store` in the
-//! function which has the stack slots. This optimization also assumes that stack slot accesses
-//! are never out of bounds. If these assumptions are not correct, then this optimization may remove
-//! `stack_store` instruction incorrectly, or incorrectly use a previously stored value as the value
-//! being loaded by a `stack_load`.
-
-use std::collections::BTreeMap;
-use std::fmt;
-use std::ops::Not;
-
-use rustc_data_structures::fx::FxHashSet;
-
-use cranelift_codegen::cursor::{Cursor, FuncCursor};
-use cranelift_codegen::ir::immediates::Offset32;
-use cranelift_codegen::ir::{InstructionData, Opcode, ValueDef};
-
-use crate::prelude::*;
-
-/// Workaround for `StackSlot` not implementing `Ord`.
-#[derive(Copy, Clone, PartialEq, Eq)]
-struct OrdStackSlot(StackSlot);
-
-impl fmt::Debug for OrdStackSlot {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- write!(f, "{:?}", self.0)
- }
-}
-
-impl PartialOrd for OrdStackSlot {
- fn partial_cmp(&self, rhs: &Self) -> Option<std::cmp::Ordering> {
- self.0.as_u32().partial_cmp(&rhs.0.as_u32())
- }
-}
-
-impl Ord for OrdStackSlot {
- fn cmp(&self, rhs: &Self) -> std::cmp::Ordering {
- self.0.as_u32().cmp(&rhs.0.as_u32())
- }
-}
-
-#[derive(Debug, Default)]
-struct StackSlotUsage {
- stack_addr: FxHashSet<Inst>,
- stack_load: FxHashSet<Inst>,
- stack_store: FxHashSet<Inst>,
-}
-
-impl StackSlotUsage {
- fn potential_stores_for_load(&self, ctx: &Context, load: Inst) -> Vec<Inst> {
- self.stack_store
- .iter()
- .cloned()
- .filter(|&store| {
- match spatial_overlap(&ctx.func, store, load) {
- SpatialOverlap::No => false, // Can never be the source of the loaded value.
- SpatialOverlap::Partial | SpatialOverlap::Full => true,
- }
- })
- .filter(|&store| {
- match temporal_order(ctx, store, load) {
- TemporalOrder::NeverBefore => false, // Can never be the source of the loaded value.
- TemporalOrder::MaybeBefore | TemporalOrder::DefinitivelyBefore => true,
- }
- })
- .collect::<Vec<Inst>>()
- }
-
- fn potential_loads_of_store(&self, ctx: &Context, store: Inst) -> Vec<Inst> {
- self.stack_load
- .iter()
- .cloned()
- .filter(|&load| {
- match spatial_overlap(&ctx.func, store, load) {
- SpatialOverlap::No => false, // Can never be the source of the loaded value.
- SpatialOverlap::Partial | SpatialOverlap::Full => true,
- }
- })
- .filter(|&load| {
- match temporal_order(ctx, store, load) {
- TemporalOrder::NeverBefore => false, // Can never be the source of the loaded value.
- TemporalOrder::MaybeBefore | TemporalOrder::DefinitivelyBefore => true,
- }
- })
- .collect::<Vec<Inst>>()
- }
-
- fn remove_unused_stack_addr(func: &mut Function, inst: Inst) {
- func.dfg.detach_results(inst);
- func.dfg.replace(inst).nop();
- }
-
- fn remove_unused_load(func: &mut Function, load: Inst) {
- func.dfg.detach_results(load);
- func.dfg.replace(load).nop();
- }
-
- fn remove_dead_store(&mut self, func: &mut Function, store: Inst) {
- func.dfg.replace(store).nop();
- self.stack_store.remove(&store);
- }
-
- fn change_load_to_alias(&mut self, func: &mut Function, load: Inst, value: Value) {
- let loaded_value = func.dfg.inst_results(load)[0];
- let loaded_type = func.dfg.value_type(loaded_value);
-
- if func.dfg.value_type(value) == loaded_type {
- func.dfg.detach_results(load);
- func.dfg.replace(load).nop();
- func.dfg.change_to_alias(loaded_value, value);
- } else {
- func.dfg.replace(load).bitcast(loaded_type, value);
- }
-
- self.stack_load.remove(&load);
- }
-}
-
-struct OptimizeContext<'a> {
- ctx: &'a mut Context,
- stack_slot_usage_map: BTreeMap<OrdStackSlot, StackSlotUsage>,
-}
-
-impl<'a> OptimizeContext<'a> {
- fn for_context(ctx: &'a mut Context) -> Self {
- ctx.flowgraph(); // Compute cfg and domtree.
-
- // Record all stack_addr, stack_load and stack_store instructions.
- let mut stack_slot_usage_map = BTreeMap::<OrdStackSlot, StackSlotUsage>::new();
-
- let mut cursor = FuncCursor::new(&mut ctx.func);
- while let Some(_block) = cursor.next_block() {
- while let Some(inst) = cursor.next_inst() {
- match cursor.func.dfg[inst] {
- InstructionData::StackLoad {
- opcode: Opcode::StackAddr,
- stack_slot,
- offset: _,
- } => {
- stack_slot_usage_map
- .entry(OrdStackSlot(stack_slot))
- .or_insert_with(StackSlotUsage::default)
- .stack_addr
- .insert(inst);
- }
- InstructionData::StackLoad {
- opcode: Opcode::StackLoad,
- stack_slot,
- offset: _,
- } => {
- stack_slot_usage_map
- .entry(OrdStackSlot(stack_slot))
- .or_insert_with(StackSlotUsage::default)
- .stack_load
- .insert(inst);
- }
- InstructionData::StackStore {
- opcode: Opcode::StackStore,
- arg: _,
- stack_slot,
- offset: _,
- } => {
- stack_slot_usage_map
- .entry(OrdStackSlot(stack_slot))
- .or_insert_with(StackSlotUsage::default)
- .stack_store
- .insert(inst);
- }
- _ => {}
- }
- }
- }
-
- OptimizeContext { ctx, stack_slot_usage_map }
- }
-}
-
-pub(super) fn optimize_function(
- ctx: &mut Context,
- clif_comments: &mut crate::pretty_clif::CommentWriter,
-) {
- combine_stack_addr_with_load_store(&mut ctx.func);
-
- let mut opt_ctx = OptimizeContext::for_context(ctx);
-
- // FIXME Repeat following instructions until fixpoint.
-
- remove_unused_stack_addr_and_stack_load(&mut opt_ctx);
-
- if clif_comments.enabled() {
- for (&OrdStackSlot(stack_slot), usage) in &opt_ctx.stack_slot_usage_map {
- clif_comments.add_comment(stack_slot, format!("used by: {:?}", usage));
- }
- }
-
- for (stack_slot, users) in opt_ctx.stack_slot_usage_map.iter_mut() {
- if users.stack_addr.is_empty().not() {
- // Stack addr leaked; there may be unknown loads and stores.
- // FIXME use stacked borrows to optimize
- continue;
- }
-
- for load in users.stack_load.clone().into_iter() {
- let potential_stores = users.potential_stores_for_load(&opt_ctx.ctx, load);
-
- if clif_comments.enabled() {
- for &store in &potential_stores {
- clif_comments.add_comment(
- load,
- format!(
- "Potential store -> load forwarding {} -> {} ({:?}, {:?})",
- opt_ctx.ctx.func.dfg.display_inst(store, None),
- opt_ctx.ctx.func.dfg.display_inst(load, None),
- spatial_overlap(&opt_ctx.ctx.func, store, load),
- temporal_order(&opt_ctx.ctx, store, load),
- ),
- );
- }
- }
-
- match *potential_stores {
- [] => {
- if clif_comments.enabled() {
- clif_comments
- .add_comment(load, "[BUG?] Reading uninitialized memory".to_string());
- }
- }
- [store]
- if spatial_overlap(&opt_ctx.ctx.func, store, load) == SpatialOverlap::Full
- && temporal_order(&opt_ctx.ctx, store, load)
- == TemporalOrder::DefinitivelyBefore =>
- {
- // Only one store could have been the origin of the value.
- let stored_value = opt_ctx.ctx.func.dfg.inst_args(store)[0];
-
- if clif_comments.enabled() {
- clif_comments.add_comment(
- load,
- format!("Store to load forward {} -> {}", store, load),
- );
- }
-
- users.change_load_to_alias(&mut opt_ctx.ctx.func, load, stored_value);
- }
- _ => {} // FIXME implement this
- }
- }
-
- for store in users.stack_store.clone().into_iter() {
- let potential_loads = users.potential_loads_of_store(&opt_ctx.ctx, store);
-
- if clif_comments.enabled() {
- for &load in &potential_loads {
- clif_comments.add_comment(
- store,
- format!(
- "Potential load from store {} <- {} ({:?}, {:?})",
- opt_ctx.ctx.func.dfg.display_inst(load, None),
- opt_ctx.ctx.func.dfg.display_inst(store, None),
- spatial_overlap(&opt_ctx.ctx.func, store, load),
- temporal_order(&opt_ctx.ctx, store, load),
- ),
- );
- }
- }
-
- if potential_loads.is_empty() {
- // Never loaded; can safely remove all stores and the stack slot.
- // FIXME also remove stores when there is always a next store before a load.
-
- if clif_comments.enabled() {
- clif_comments.add_comment(
- store,
- format!(
- "Remove dead stack store {} of {}",
- opt_ctx.ctx.func.dfg.display_inst(store, None),
- stack_slot.0
- ),
- );
- }
-
- users.remove_dead_store(&mut opt_ctx.ctx.func, store);
- }
- }
-
- if users.stack_store.is_empty() && users.stack_load.is_empty() {
- opt_ctx.ctx.func.stack_slots[stack_slot.0].size = 0;
- }
- }
-}
-
-fn combine_stack_addr_with_load_store(func: &mut Function) {
- // Turn load and store into stack_load and stack_store when possible.
- let mut cursor = FuncCursor::new(func);
- while let Some(_block) = cursor.next_block() {
- while let Some(inst) = cursor.next_inst() {
- match cursor.func.dfg[inst] {
- InstructionData::Load { opcode: Opcode::Load, arg: addr, flags: _, offset } => {
- if cursor.func.dfg.ctrl_typevar(inst) == types::I128
- || cursor.func.dfg.ctrl_typevar(inst).is_vector()
- {
- continue; // WORKAROUD: stack_load.i128 not yet implemented
- }
- if let Some((stack_slot, stack_addr_offset)) =
- try_get_stack_slot_and_offset_for_addr(cursor.func, addr)
- {
- if let Some(combined_offset) = offset.try_add_i64(stack_addr_offset.into())
- {
- let ty = cursor.func.dfg.ctrl_typevar(inst);
- cursor.func.dfg.replace(inst).stack_load(
- ty,
- stack_slot,
- combined_offset,
- );
- }
- }
- }
- InstructionData::Store {
- opcode: Opcode::Store,
- args: [value, addr],
- flags: _,
- offset,
- } => {
- if cursor.func.dfg.ctrl_typevar(inst) == types::I128
- || cursor.func.dfg.ctrl_typevar(inst).is_vector()
- {
- continue; // WORKAROUND: stack_store.i128 not yet implemented
- }
- if let Some((stack_slot, stack_addr_offset)) =
- try_get_stack_slot_and_offset_for_addr(cursor.func, addr)
- {
- if let Some(combined_offset) = offset.try_add_i64(stack_addr_offset.into())
- {
- cursor.func.dfg.replace(inst).stack_store(
- value,
- stack_slot,
- combined_offset,
- );
- }
- }
- }
- _ => {}
- }
- }
- }
-}
-
-fn remove_unused_stack_addr_and_stack_load(opt_ctx: &mut OptimizeContext<'_>) {
- // FIXME incrementally rebuild on each call?
- let mut stack_addr_load_insts_users = FxHashMap::<Inst, FxHashSet<Inst>>::default();
-
- let mut cursor = FuncCursor::new(&mut opt_ctx.ctx.func);
- while let Some(_block) = cursor.next_block() {
- while let Some(inst) = cursor.next_inst() {
- for &arg in cursor.func.dfg.inst_args(inst) {
- if let ValueDef::Result(arg_origin, 0) = cursor.func.dfg.value_def(arg) {
- match cursor.func.dfg[arg_origin].opcode() {
- Opcode::StackAddr | Opcode::StackLoad => {
- stack_addr_load_insts_users
- .entry(arg_origin)
- .or_insert_with(FxHashSet::default)
- .insert(inst);
- }
- _ => {}
- }
- }
- }
- }
- }
-
- #[cfg(debug_assertions)]
- for inst in stack_addr_load_insts_users.keys() {
- let mut is_recorded_stack_addr_or_stack_load = false;
- for stack_slot_users in opt_ctx.stack_slot_usage_map.values() {
- is_recorded_stack_addr_or_stack_load |= stack_slot_users.stack_addr.contains(inst)
- || stack_slot_users.stack_load.contains(inst);
- }
- assert!(is_recorded_stack_addr_or_stack_load);
- }
-
- // Replace all unused stack_addr and stack_load instructions with nop.
- let mut func = &mut opt_ctx.ctx.func;
-
- for stack_slot_users in opt_ctx.stack_slot_usage_map.values_mut() {
- stack_slot_users
- .stack_addr
- .drain_filter(|inst| {
- stack_addr_load_insts_users.get(inst).map(|users| users.is_empty()).unwrap_or(true)
- })
- .for_each(|inst| StackSlotUsage::remove_unused_stack_addr(&mut func, inst));
-
- stack_slot_users
- .stack_load
- .drain_filter(|inst| {
- stack_addr_load_insts_users.get(inst).map(|users| users.is_empty()).unwrap_or(true)
- })
- .for_each(|inst| StackSlotUsage::remove_unused_load(&mut func, inst));
- }
-}
-
-fn try_get_stack_slot_and_offset_for_addr(
- func: &Function,
- addr: Value,
-) -> Option<(StackSlot, Offset32)> {
- if let ValueDef::Result(addr_inst, 0) = func.dfg.value_def(addr) {
- if let InstructionData::StackLoad { opcode: Opcode::StackAddr, stack_slot, offset } =
- func.dfg[addr_inst]
- {
- return Some((stack_slot, offset));
- }
- }
- None
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-enum SpatialOverlap {
- No,
- Partial,
- Full,
-}
-
-fn spatial_overlap(func: &Function, src: Inst, dest: Inst) -> SpatialOverlap {
- fn inst_info(func: &Function, inst: Inst) -> (StackSlot, Offset32, u32) {
- match func.dfg[inst] {
- InstructionData::StackLoad { opcode: Opcode::StackAddr, stack_slot, offset }
- | InstructionData::StackLoad { opcode: Opcode::StackLoad, stack_slot, offset }
- | InstructionData::StackStore {
- opcode: Opcode::StackStore,
- stack_slot,
- offset,
- arg: _,
- } => (stack_slot, offset, func.dfg.ctrl_typevar(inst).bytes()),
- _ => unreachable!("{:?}", func.dfg[inst]),
- }
- }
-
- debug_assert_ne!(src, dest);
-
- let (src_ss, src_offset, src_size) = inst_info(func, src);
- let (dest_ss, dest_offset, dest_size) = inst_info(func, dest);
-
- if src_ss != dest_ss {
- return SpatialOverlap::No;
- }
-
- if src_offset == dest_offset && src_size == dest_size {
- return SpatialOverlap::Full;
- }
-
- let src_end: i64 = src_offset.try_add_i64(i64::from(src_size)).unwrap().into();
- let dest_end: i64 = dest_offset.try_add_i64(i64::from(dest_size)).unwrap().into();
- if src_end <= dest_offset.into() || dest_end <= src_offset.into() {
- return SpatialOverlap::No;
- }
-
- SpatialOverlap::Partial
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-enum TemporalOrder {
- /// `src` will never be executed before `dest`.
- NeverBefore,
-
- /// `src` may be executed before `dest`.
- MaybeBefore,
-
- /// `src` will always be executed before `dest`.
- /// There may still be other instructions in between.
- DefinitivelyBefore,
-}
-
-fn temporal_order(ctx: &Context, src: Inst, dest: Inst) -> TemporalOrder {
- debug_assert_ne!(src, dest);
-
- if ctx.domtree.dominates(src, dest, &ctx.func.layout) {
- TemporalOrder::DefinitivelyBefore
- } else if ctx.domtree.dominates(src, dest, &ctx.func.layout) {
- TemporalOrder::NeverBefore
- } else {
- TemporalOrder::MaybeBefore
- }
-}
pub(crate) fn write_ir_file(
tcx: TyCtxt<'_>,
- name: &str,
+ name: impl FnOnce() -> String,
write: impl FnOnce(&mut dyn Write) -> std::io::Result<()>,
) {
if !should_write_ir(tcx) {
res @ Err(_) => res.unwrap(),
}
- let clif_file_name = clif_output_dir.join(name);
+ let clif_file_name = clif_output_dir.join(name());
let res = std::fs::File::create(clif_file_name).and_then(|mut file| write(&mut file));
if let Err(err) = res {
context: &cranelift_codegen::Context,
mut clif_comments: &CommentWriter,
) {
- write_ir_file(tcx, &format!("{}.{}.clif", tcx.symbol_name(instance).name, postfix), |file| {
- let value_ranges =
- isa.map(|isa| context.build_value_labels_ranges(isa).expect("value location ranges"));
+ write_ir_file(
+ tcx,
+ || format!("{}.{}.clif", tcx.symbol_name(instance).name, postfix),
+ |file| {
+ let value_ranges = isa
+ .map(|isa| context.build_value_labels_ranges(isa).expect("value location ranges"));
- let mut clif = String::new();
- cranelift_codegen::write::decorate_function(
- &mut clif_comments,
- &mut clif,
- &context.func,
- &DisplayFunctionAnnotations {
- isa: Some(&*crate::build_isa(tcx.sess)),
- value_ranges: value_ranges.as_ref(),
- },
- )
- .unwrap();
+ let mut clif = String::new();
+ cranelift_codegen::write::decorate_function(
+ &mut clif_comments,
+ &mut clif,
+ &context.func,
+ &DisplayFunctionAnnotations { isa, value_ranges: value_ranges.as_ref() },
+ )
+ .unwrap();
- writeln!(file, "test compile")?;
- writeln!(file, "set is_pic")?;
- writeln!(file, "set enable_simd")?;
- writeln!(file, "target {} haswell", crate::target_triple(tcx.sess))?;
- writeln!(file)?;
- file.write_all(clif.as_bytes())?;
- Ok(())
- });
+ writeln!(file, "test compile")?;
+ writeln!(file, "set is_pic")?;
+ writeln!(file, "set enable_simd")?;
+ writeln!(file, "target {} haswell", crate::target_triple(tcx.sess))?;
+ writeln!(file)?;
+ file.write_all(clif.as_bytes())?;
+ Ok(())
+ },
+ );
}
impl fmt::Debug for FunctionCx<'_, '_, '_> {
fn codegen_print(fx: &mut FunctionCx<'_, '_, '_>, msg: &str) {
let puts = fx
- .cx
.module
.declare_function(
"puts",
},
)
.unwrap();
- let puts = fx.cx.module.declare_func_in_func(puts, &mut fx.bcx.func);
+ let puts = fx.module.declare_func_in_func(puts, &mut fx.bcx.func);
if fx.clif_comments.enabled() {
fx.add_comment(puts, "puts");
}
- let symbol_name = fx.tcx.symbol_name(fx.instance);
- let real_msg = format!("trap at {:?} ({}): {}\0", fx.instance, symbol_name, msg);
+ let real_msg = format!("trap at {:?} ({}): {}\0", fx.instance, fx.symbol_name, msg);
let msg_ptr = fx.anonymous_str("trap", &real_msg);
fx.bcx.ins().call(puts, &[msg_ptr]);
}
let src_align = src_layout.align.abi.bytes() as u8;
let dst_align = dst_layout.align.abi.bytes() as u8;
fx.bcx.emit_small_memory_copy(
- fx.cx.module.target_config(),
+ fx.module.target_config(),
to_addr,
from_addr,
size,
layout: TyAndLayout<'tcx>,
trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
) -> Value {
- let data_id = if let Some(data_id) = fx.cx.vtables.get(&(layout.ty, trait_ref)) {
+ let data_id = if let Some(data_id) = fx.vtables.get(&(layout.ty, trait_ref)) {
*data_id
} else {
let data_id = build_vtable(fx, layout, trait_ref);
- fx.cx.vtables.insert((layout.ty, trait_ref), data_id);
+ fx.vtables.insert((layout.ty, trait_ref), data_id);
data_id
};
- let local_data_id = fx.cx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+ let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
fx.bcx.ins().global_value(fx.pointer_type, local_data_id)
}
let drop_in_place_fn = import_function(
tcx,
- fx.cx.module,
+ fx.module,
Instance::resolve_drop_in_place(tcx, layout.ty).polymorphize(fx.tcx),
);
opt_mth.map(|(def_id, substs)| {
import_function(
tcx,
- fx.cx.module,
+ fx.module,
Instance::resolve_for_vtable(tcx, ParamEnv::reveal_all(), def_id, substs)
.unwrap()
.polymorphize(fx.tcx),
for (i, component) in components.into_iter().enumerate() {
if let Some(func_id) = component {
- let func_ref = fx.cx.module.declare_func_in_data(func_id, &mut data_ctx);
+ let func_ref = fx.module.declare_func_in_data(func_id, &mut data_ctx);
data_ctx.write_function_addr((i * usize_size) as u32, func_ref);
}
}
data_ctx.set_align(fx.tcx.data_layout.pointer_align.pref.bytes());
- let data_id = fx
- .cx
- .module
- .declare_data(
- &format!(
- "__vtable.{}.for.{:?}.{}",
- trait_ref
- .as_ref()
- .map(|trait_ref| format!("{:?}", trait_ref.skip_binder()).into())
- .unwrap_or(std::borrow::Cow::Borrowed("???")),
- layout.ty,
- fx.cx.vtables.len(),
- ),
- Linkage::Local,
- false,
- false,
- )
- .unwrap();
-
- // FIXME don't duplicate definitions in lazy jit mode
- let _ = fx.cx.module.define_data(data_id, &data_ctx);
+ let data_id = fx.module.declare_anonymous_data(false, false).unwrap();
+
+ fx.module.define_data(data_id, &data_ctx).unwrap();
data_id
}
/// Adds all of the contents of a native library to this archive. This will
/// search in the relevant locations for a library named `name`.
- fn add_native_library(&mut self, name: Symbol) {
- let location = find_library(name, &self.config.lib_search_paths, self.config.sess);
+ fn add_native_library(&mut self, name: Symbol, verbatim: bool) {
+ let location =
+ find_library(name, verbatim, &self.config.lib_search_paths, self.config.sess);
self.add_archive(&location, |_| false).unwrap_or_else(|e| {
self.config.sess.fatal(&format!(
"failed to add native library {}: {}",
use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet};
use rustc_hir::def_id::{DefId, DefIdSet, LOCAL_CRATE};
use rustc_llvm::RustString;
-use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
use rustc_middle::mir::coverage::CodeRegion;
use rustc_span::Symbol;
///
/// We can find the unused functions (including generic functions) by the set difference of all MIR
/// `DefId`s (`tcx` query `mir_keys`) minus the codegenned `DefId`s (`tcx` query
-/// `collect_and_partition_mono_items`).
+/// `codegened_and_inlined_items`).
///
/// *HOWEVER* the codegenned `DefId`s are partitioned across multiple `CodegenUnit`s (CGUs), and
/// this function is processing a `function_coverage_map` for the functions (`Instance`/`DefId`)
let mut unused_def_ids_by_file: FxHashMap<Symbol, Vec<DefId>> = FxHashMap::default();
for &non_codegenned_def_id in all_def_ids.difference(codegenned_def_ids) {
- let codegen_fn_attrs = tcx.codegen_fn_attrs(non_codegenned_def_id);
- if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NO_COVERAGE) {
- continue;
- }
- // Make sure the non-codegenned (unused) function has a file_name
+ // Make sure the non-codegenned (unused) function has at least one MIR
+ // `Coverage` statement with a code region, and return its file name.
if let Some(non_codegenned_file_name) = tcx.covered_file_name(non_codegenned_def_id) {
let def_ids =
unused_def_ids_by_file.entry(*non_codegenned_file_name).or_insert_with(Vec::new);
unfinished_type,
member_holding_stub,
member_descriptions,
+ None,
);
MetadataCreationResult::new(metadata_stub, true)
}
layout: TyAndLayout<'tcx>,
tag_type_metadata: Option<&'ll DIType>,
containing_scope: &'ll DIScope,
+ common_members: Vec<Option<&'ll DIType>>,
span: Span,
}
} else {
type_metadata(cx, self.enum_type, self.span)
};
- let flags = match self.enum_type.kind() {
- ty::Generator(..) => DIFlags::FlagArtificial,
- _ => DIFlags::FlagZero,
- };
match self.layout.variants {
Variants::Single { index } => {
self.enum_type,
variant_type_metadata,
member_descriptions,
+ Some(&self.common_members),
);
vec![MemberDescription {
name: if fallback { String::new() } else { variant_info.variant_name() },
offset: Size::ZERO,
size: self.layout.size,
align: self.layout.align.abi,
- flags,
+ flags: DIFlags::FlagZero,
discriminant: None,
source_info: variant_info.source_info(cx),
}]
self.enum_type,
variant_type_metadata,
member_descriptions,
+ Some(&self.common_members),
);
MemberDescription {
offset: Size::ZERO,
size: self.layout.size,
align: self.layout.align.abi,
- flags,
+ flags: DIFlags::FlagZero,
discriminant: Some(
self.layout.ty.discriminant_for_variant(cx.tcx, i).unwrap().val
as u64,
self.enum_type,
variant_type_metadata,
variant_member_descriptions,
+ Some(&self.common_members),
);
// Encode the information about the null variant in the union
offset: Size::ZERO,
size: variant.size,
align: variant.align.abi,
- flags,
+ flags: DIFlags::FlagZero,
discriminant: None,
source_info: variant_info.source_info(cx),
}]
self.enum_type,
variant_type_metadata,
member_descriptions,
+ Some(&self.common_members),
);
let niche_value = if i == dataful_variant {
offset: Size::ZERO,
size: self.layout.size,
align: self.layout.align.abi,
- flags,
+ flags: DIFlags::FlagZero,
discriminant: niche_value,
source_info: variant_info.source_info(cx),
}
}
None
}
-
- fn is_artificial(&self) -> bool {
- match self {
- VariantInfo::Generator { .. } => true,
- VariantInfo::Adt(..) => false,
- }
- }
}
/// Returns a tuple of (1) `type_metadata_stub` of the variant, (2) a
&variant_name,
unique_type_id,
Some(containing_scope),
- // FIXME(tmandry): This doesn't seem to have any effect.
- if variant.is_artificial() { DIFlags::FlagArtificial } else { DIFlags::FlagZero },
+ DIFlags::FlagZero,
)
});
) -> RecursiveTypeDescription<'ll, 'tcx> {
let tcx = cx.tcx;
let enum_name = compute_debuginfo_type_name(tcx, enum_type, false);
- // FIXME(tmandry): This doesn't seem to have any effect.
- let enum_flags = match enum_type.kind() {
- ty::Generator(..) => DIFlags::FlagArtificial,
- _ => DIFlags::FlagZero,
- };
let containing_scope = get_namespace_for_item(cx, enum_def_id);
// FIXME: This should emit actual file metadata for the enum, but we
UNKNOWN_LINE_NUMBER,
layout.size.bits(),
layout.align.abi.bits() as u32,
- enum_flags,
+ DIFlags::FlagZero,
None,
0, // RuntimeLang
unique_type_id_str.as_ptr().cast(),
layout,
tag_type_metadata: discriminant_type_metadata,
containing_scope,
+ common_members: vec![],
span,
}),
);
}
};
- let mut outer_fields = match layout.variants {
+ let outer_fields = match layout.variants {
Variants::Single { .. } => vec![],
Variants::Multiple { .. } => {
let tuple_mdf = TupleMemberDescriptionFactory {
UNKNOWN_LINE_NUMBER,
layout.size.bits(),
layout.align.abi.bits() as u32,
- enum_flags,
+ DIFlags::FlagZero,
discriminator_metadata,
empty_array,
variant_part_unique_type_id_str.as_ptr().cast(),
variant_part_unique_type_id_str.len(),
)
};
- outer_fields.push(Some(variant_part));
let struct_wrapper = {
// The variant part must be wrapped in a struct according to DWARF.
- let type_array = create_DIArray(DIB(cx), &outer_fields);
+ // All fields except the discriminant (including `outer_fields`)
+ // should be put into structures inside the variant part, which gives
+ // an equivalent layout but offers us much better integration with
+ // debuggers.
+ let type_array = create_DIArray(DIB(cx), &[Some(variant_part)]);
let type_map = debug_context(cx).type_map.borrow();
let unique_type_id_str = type_map.get_unique_type_id_as_string(unique_type_id);
UNKNOWN_LINE_NUMBER,
layout.size.bits(),
layout.align.abi.bits() as u32,
- enum_flags,
+ DIFlags::FlagZero,
None,
type_array,
0,
layout,
tag_type_metadata: None,
containing_scope,
+ common_members: outer_fields,
span,
}),
)
DIFlags::FlagZero,
);
// ... and immediately create and add the member descriptions.
- set_members_of_composite_type(cx, composite_type, composite_type_metadata, member_descriptions);
+ set_members_of_composite_type(
+ cx,
+ composite_type,
+ composite_type_metadata,
+ member_descriptions,
+ None,
+ );
composite_type_metadata
}
composite_type: Ty<'tcx>,
composite_type_metadata: &'ll DICompositeType,
member_descriptions: Vec<MemberDescription<'ll>>,
+ common_members: Option<&Vec<Option<&'ll DIType>>>,
) {
// In some rare cases LLVM metadata uniquing would lead to an existing type
// description being used instead of a new one created in
}
}
- let member_metadata: Vec<_> = member_descriptions
+ let mut member_metadata: Vec<_> = member_descriptions
.into_iter()
.map(|desc| Some(desc.into_metadata(cx, composite_type_metadata)))
.collect();
+ if let Some(other_members) = common_members {
+ member_metadata.extend(other_members.iter());
+ }
let type_params = compute_type_parameters(cx, composite_type);
unsafe {
spflags |= DISPFlags::SPFlagOptimized;
}
if let Some((id, _)) = self.tcx.entry_fn(LOCAL_CRATE) {
- if id.to_def_id() == def_id {
+ if id == def_id {
spflags |= DISPFlags::SPFlagMainSubprogram;
}
}
let mut name_buf = None;
let name_len = llvm::LLVMRustGetSectionName(si.llsi, &mut name_buf);
let name = name_buf.map_or_else(
- String::new, // We got a NULL ptr, ignore `name_len`.
+ String::new, // We got a null ptr, ignore `name_len`.
|buf| {
String::from_utf8(
slice::from_raw_parts(buf.as_ptr() as *const u8, name_len as usize)
use std::io;
use std::path::{Path, PathBuf};
-pub fn find_library(name: Symbol, search_paths: &[PathBuf], sess: &Session) -> PathBuf {
+pub fn find_library(
+ name: Symbol,
+ verbatim: bool,
+ search_paths: &[PathBuf],
+ sess: &Session,
+) -> PathBuf {
// On Windows, static libraries sometimes show up as libfoo.a and other
// times show up as foo.lib
- let oslibname =
- format!("{}{}{}", sess.target.staticlib_prefix, name, sess.target.staticlib_suffix);
+ let oslibname = if verbatim {
+ name.to_string()
+ } else {
+ format!("{}{}{}", sess.target.staticlib_prefix, name, sess.target.staticlib_suffix)
+ };
let unixlibname = format!("lib{}.a", name);
for path in search_paths {
lto: bool,
skip_objects: bool,
) -> io::Result<()>;
- fn add_native_library(&mut self, name: Symbol);
+ fn add_native_library(&mut self, name: Symbol, verbatim: bool);
fn update_symbols(&mut self);
fn build(self);
// metadata of the rlib we're generating somehow.
for lib in codegen_results.crate_info.used_libraries.iter() {
match lib.kind {
- NativeLibKind::StaticBundle => {}
- NativeLibKind::StaticNoBundle
- | NativeLibKind::Dylib
- | NativeLibKind::Framework
+ NativeLibKind::Static { bundle: None | Some(true), .. } => {}
+ NativeLibKind::Static { bundle: Some(false), .. }
+ | NativeLibKind::Dylib { .. }
+ | NativeLibKind::Framework { .. }
| NativeLibKind::RawDylib
| NativeLibKind::Unspecified => continue,
}
if let Some(name) = lib.name {
- ab.add_native_library(name);
+ ab.add_native_library(name, lib.verbatim.unwrap_or(false));
}
}
// Clearly this is not sufficient for a general purpose feature, and
// we'd want to read from the library's metadata to determine which
// object files come from where and selectively skip them.
- let skip_object_files = native_libs
- .iter()
- .any(|lib| lib.kind == NativeLibKind::StaticBundle && !relevant_lib(sess, lib));
+ let skip_object_files = native_libs.iter().any(|lib| {
+ matches!(lib.kind, NativeLibKind::Static { bundle: None | Some(true), .. })
+ && !relevant_lib(sess, lib)
+ });
ab.add_rlib(
path,
&name.as_str(),
let path = find_sanitizer_runtime(&sess, &filename);
let rpath = path.to_str().expect("non-utf8 component in path");
linker.args(&["-Wl,-rpath", "-Xlinker", rpath]);
- linker.link_dylib(Symbol::intern(&filename));
+ linker.link_dylib(Symbol::intern(&filename), false, true);
} else {
let filename = format!("librustc{}_rt.{}.a", channel, name);
let path = find_sanitizer_runtime(&sess, &filename).join(&filename);
.filter_map(|lib| {
let name = lib.name?;
match lib.kind {
- NativeLibKind::StaticNoBundle
- | NativeLibKind::Dylib
+ NativeLibKind::Static { bundle: Some(false), .. }
+ | NativeLibKind::Dylib { .. }
| NativeLibKind::Unspecified => {
+ let verbatim = lib.verbatim.unwrap_or(false);
if sess.target.is_like_msvc {
- Some(format!("{}.lib", name))
+ Some(format!("{}{}", name, if verbatim { "" } else { ".lib" }))
+ } else if sess.target.linker_is_gnu {
+ Some(format!("-l{}{}", if verbatim { ":" } else { "" }, name))
} else {
Some(format!("-l{}", name))
}
}
- NativeLibKind::Framework => {
+ NativeLibKind::Framework { .. } => {
// ld-only syntax, since there are no frameworks in MSVC
Some(format!("-framework {}", name))
}
// These are included, no need to print them
- NativeLibKind::StaticBundle | NativeLibKind::RawDylib => None,
+ NativeLibKind::Static { bundle: None | Some(true), .. }
+ | NativeLibKind::RawDylib => None,
}
})
.collect();
codegen_results.crate_info.used_libraries.iter().filter(|l| relevant_lib(sess, l));
let search_path = archive_search_paths(sess);
+ let mut last = (NativeLibKind::Unspecified, None);
for lib in relevant_libs {
+ // Skip if this library is the same as the last.
+ last = if (lib.kind, lib.name) == last { continue } else { (lib.kind, lib.name) };
+
let name = match lib.name {
Some(l) => l,
None => continue,
};
+ let verbatim = lib.verbatim.unwrap_or(false);
match lib.kind {
- NativeLibKind::Dylib | NativeLibKind::Unspecified => cmd.link_dylib(name),
- NativeLibKind::Framework => cmd.link_framework(name),
- NativeLibKind::StaticNoBundle => cmd.link_staticlib(name),
- NativeLibKind::StaticBundle => cmd.link_whole_staticlib(name, &search_path),
+ NativeLibKind::Dylib { as_needed } => {
+ cmd.link_dylib(name, verbatim, as_needed.unwrap_or(true))
+ }
+ NativeLibKind::Unspecified => cmd.link_dylib(name, verbatim, true),
+ NativeLibKind::Framework { as_needed } => {
+ cmd.link_framework(name, as_needed.unwrap_or(true))
+ }
+ NativeLibKind::Static { bundle: None | Some(true), .. }
+ | NativeLibKind::Static { whole_archive: Some(true), .. } => {
+ cmd.link_whole_staticlib(name, verbatim, &search_path);
+ }
+ NativeLibKind::Static { .. } => cmd.link_staticlib(name, verbatim),
NativeLibKind::RawDylib => {
// FIXME(#58713): Proper handling for raw dylibs.
bug!("raw_dylib feature not yet implemented");
// there's a static library that's not relevant we skip all object
// files.
let native_libs = &codegen_results.crate_info.native_libraries[&cnum];
- let skip_native = native_libs
- .iter()
- .any(|lib| lib.kind == NativeLibKind::StaticBundle && !relevant_lib(sess, lib));
+ let skip_native = native_libs.iter().any(|lib| {
+ matches!(lib.kind, NativeLibKind::Static { bundle: None | Some(true), .. })
+ && !relevant_lib(sess, lib)
+ });
if (!are_upstream_rust_objects_already_included(sess)
|| ignored_for_lto(sess, &codegen_results.crate_info, cnum))
.expect("failed to find crate type in dependency format list");
let crates = &codegen_results.crate_info.used_crates_static;
+ let mut last = (NativeLibKind::Unspecified, None);
for &(cnum, _) in crates {
for lib in codegen_results.crate_info.native_libraries[&cnum].iter() {
+ // Skip if this library is the same as the last.
+ last = if (lib.kind, lib.name) == last { continue } else { (lib.kind, lib.name) };
+
let name = match lib.name {
Some(l) => l,
None => continue,
if !relevant_lib(sess, &lib) {
continue;
}
+ let verbatim = lib.verbatim.unwrap_or(false);
match lib.kind {
- NativeLibKind::Dylib | NativeLibKind::Unspecified => cmd.link_dylib(name),
- NativeLibKind::Framework => cmd.link_framework(name),
- NativeLibKind::StaticNoBundle => {
+ NativeLibKind::Dylib { as_needed } => {
+ cmd.link_dylib(name, verbatim, as_needed.unwrap_or(true))
+ }
+ NativeLibKind::Unspecified => cmd.link_dylib(name, verbatim, true),
+ NativeLibKind::Framework { as_needed } => {
+ cmd.link_framework(name, as_needed.unwrap_or(true))
+ }
+ NativeLibKind::Static { bundle: Some(false), .. } => {
// Link "static-nobundle" native libs only if the crate they originate from
// is being linked statically to the current crate. If it's linked dynamically
// or is an rlib already included via some other dylib crate, the symbols from
// native libs will have already been included in that dylib.
if data[cnum.as_usize() - 1] == Linkage::Static {
- cmd.link_staticlib(name)
+ cmd.link_staticlib(name, verbatim)
}
}
// ignore statically included native libraries here as we've
// already included them when we included the rust library
// previously
- NativeLibKind::StaticBundle => {}
+ NativeLibKind::Static { bundle: None | Some(true), .. } => {}
NativeLibKind::RawDylib => {
// FIXME(#58713): Proper handling for raw dylibs.
bug!("raw_dylib feature not yet implemented");
pub trait Linker {
fn cmd(&mut self) -> &mut Command;
fn set_output_kind(&mut self, output_kind: LinkOutputKind, out_filename: &Path);
- fn link_dylib(&mut self, lib: Symbol);
+ fn link_dylib(&mut self, lib: Symbol, verbatim: bool, as_needed: bool);
fn link_rust_dylib(&mut self, lib: Symbol, path: &Path);
- fn link_framework(&mut self, framework: Symbol);
- fn link_staticlib(&mut self, lib: Symbol);
+ fn link_framework(&mut self, framework: Symbol, as_needed: bool);
+ fn link_staticlib(&mut self, lib: Symbol, verbatim: bool);
fn link_rlib(&mut self, lib: &Path);
fn link_whole_rlib(&mut self, lib: &Path);
- fn link_whole_staticlib(&mut self, lib: Symbol, search_path: &[PathBuf]);
+ fn link_whole_staticlib(&mut self, lib: Symbol, verbatim: bool, search_path: &[PathBuf]);
fn include_path(&mut self, path: &Path);
fn framework_path(&mut self, path: &Path);
fn output_filename(&mut self, path: &Path);
fn add_object(&mut self, path: &Path);
fn gc_sections(&mut self, keep_metadata: bool);
+ fn no_gc_sections(&mut self);
fn full_relro(&mut self);
fn partial_relro(&mut self);
fn no_relro(&mut self);
}
}
- fn link_dylib(&mut self, lib: Symbol) {
+ fn link_dylib(&mut self, lib: Symbol, verbatim: bool, as_needed: bool) {
+ if self.sess.target.os == "illumos" && lib.as_str() == "c" {
+ // libc will be added via late_link_args on illumos so that it will
+ // appear last in the library search order.
+ // FIXME: This should be replaced by a more complete and generic
+ // mechanism for controlling the order of library arguments passed
+ // to the linker.
+ return;
+ }
+ if !as_needed {
+ if self.sess.target.is_like_osx {
+ // FIXME(81490): ld64 doesn't support these flags but macOS 11
+ // has -needed-l{} / -needed_library {}
+ // but we have no way to detect that here.
+ self.sess.warn("`as-needed` modifier not implemented yet for ld64");
+ } else if self.sess.target.linker_is_gnu {
+ self.linker_arg("--no-as-needed");
+ } else {
+ self.sess.warn("`as-needed` modifier not supported for current linker");
+ }
+ }
self.hint_dynamic();
- self.cmd.arg(format!("-l{}", lib));
+ self.cmd.arg(format!("-l{}{}", if verbatim { ":" } else { "" }, lib));
+ if !as_needed {
+ if self.sess.target.is_like_osx {
+ // See above FIXME comment
+ } else if self.sess.target.linker_is_gnu {
+ self.linker_arg("--as-needed");
+ }
+ }
}
- fn link_staticlib(&mut self, lib: Symbol) {
+ fn link_staticlib(&mut self, lib: Symbol, verbatim: bool) {
self.hint_static();
- self.cmd.arg(format!("-l{}", lib));
+ self.cmd.arg(format!("-l{}{}", if verbatim { ":" } else { "" }, lib));
}
fn link_rlib(&mut self, lib: &Path) {
self.hint_static();
self.cmd.arg(format!("-l{}", lib));
}
- fn link_framework(&mut self, framework: Symbol) {
+ fn link_framework(&mut self, framework: Symbol, as_needed: bool) {
self.hint_dynamic();
+ if !as_needed {
+ // FIXME(81490): ld64 as of macOS 11 supports the -needed_framework
+ // flag but we have no way to detect that here.
+ // self.cmd.arg("-needed_framework").sym_arg(framework);
+ self.sess.warn("`as-needed` modifier not implemented yet for ld64");
+ }
self.cmd.arg("-framework").sym_arg(framework);
}
// don't otherwise explicitly reference them. This can occur for
// libraries which are just providing bindings, libraries with generic
// functions, etc.
- fn link_whole_staticlib(&mut self, lib: Symbol, search_path: &[PathBuf]) {
+ fn link_whole_staticlib(&mut self, lib: Symbol, verbatim: bool, search_path: &[PathBuf]) {
self.hint_static();
let target = &self.sess.target;
if !target.is_like_osx {
- self.linker_arg("--whole-archive").cmd.arg(format!("-l{}", lib));
+ self.linker_arg("--whole-archive").cmd.arg(format!(
+ "-l{}{}",
+ if verbatim { ":" } else { "" },
+ lib
+ ));
self.linker_arg("--no-whole-archive");
} else {
// -force_load is the macOS equivalent of --whole-archive, but it
// involves passing the full path to the library to link.
self.linker_arg("-force_load");
- let lib = archive::find_library(lib, search_path, &self.sess);
+ let lib = archive::find_library(lib, verbatim, search_path, &self.sess);
self.linker_arg(&lib);
}
}
// insert it here.
if self.sess.target.is_like_osx {
self.linker_arg("-dead_strip");
- } else if self.sess.target.is_like_solaris {
- self.linker_arg("-zignore");
// If we're building a dylib, we don't use --gc-sections because LLVM
// has already done the best it can do, and we also don't want to
}
}
+ fn no_gc_sections(&mut self) {
+ if self.sess.target.is_like_osx {
+ self.linker_arg("-no_dead_strip");
+ } else if self.sess.target.is_like_solaris {
+ self.linker_arg("-zrecord");
+ } else {
+ self.linker_arg("--no-gc-sections");
+ }
+ }
+
fn optimize(&mut self) {
if !self.sess.target.linker_is_gnu {
return;
fn add_as_needed(&mut self) {
if self.sess.target.linker_is_gnu {
self.linker_arg("--as-needed");
+ } else if self.sess.target.is_like_solaris {
+ // -z ignore is the Solaris equivalent to the GNU ld --as-needed option
+ self.linker_arg("-z");
+ self.linker_arg("ignore");
}
}
}
}
}
- fn link_dylib(&mut self, lib: Symbol) {
- self.cmd.arg(&format!("{}.lib", lib));
+ fn no_gc_sections(&mut self) {
+ self.cmd.arg("/OPT:NOREF,NOICF");
+ }
+
+ fn link_dylib(&mut self, lib: Symbol, verbatim: bool, _as_needed: bool) {
+ self.cmd.arg(format!("{}{}", lib, if verbatim { "" } else { ".lib" }));
}
fn link_rust_dylib(&mut self, lib: Symbol, path: &Path) {
}
}
- fn link_staticlib(&mut self, lib: Symbol) {
- self.cmd.arg(&format!("{}.lib", lib));
+ fn link_staticlib(&mut self, lib: Symbol, verbatim: bool) {
+ self.cmd.arg(format!("{}{}", lib, if verbatim { "" } else { ".lib" }));
}
fn full_relro(&mut self) {
fn framework_path(&mut self, _path: &Path) {
bug!("frameworks are not supported on windows")
}
- fn link_framework(&mut self, _framework: Symbol) {
+ fn link_framework(&mut self, _framework: Symbol, _as_needed: bool) {
bug!("frameworks are not supported on windows")
}
- fn link_whole_staticlib(&mut self, lib: Symbol, _search_path: &[PathBuf]) {
- self.link_staticlib(lib);
- self.cmd.arg(format!("/WHOLEARCHIVE:{}.lib", lib));
+ fn link_whole_staticlib(&mut self, lib: Symbol, verbatim: bool, _search_path: &[PathBuf]) {
+ self.link_staticlib(lib, verbatim);
+ self.cmd.arg(format!("/WHOLEARCHIVE:{}{}", lib, if verbatim { "" } else { ".lib" }));
}
fn link_whole_rlib(&mut self, path: &Path) {
self.link_rlib(path);
self.cmd.arg("-L").arg(path);
}
- fn link_staticlib(&mut self, lib: Symbol) {
+ fn link_staticlib(&mut self, lib: Symbol, _verbatim: bool) {
self.cmd.arg("-l").sym_arg(lib);
}
self.cmd.arg(path);
}
- fn link_dylib(&mut self, lib: Symbol) {
+ fn link_dylib(&mut self, lib: Symbol, verbatim: bool, _as_needed: bool) {
// Emscripten always links statically
- self.link_staticlib(lib);
+ self.link_staticlib(lib, verbatim);
}
- fn link_whole_staticlib(&mut self, lib: Symbol, _search_path: &[PathBuf]) {
+ fn link_whole_staticlib(&mut self, lib: Symbol, verbatim: bool, _search_path: &[PathBuf]) {
// not supported?
- self.link_staticlib(lib);
+ self.link_staticlib(lib, verbatim);
}
fn link_whole_rlib(&mut self, lib: &Path) {
}
fn link_rust_dylib(&mut self, lib: Symbol, _path: &Path) {
- self.link_dylib(lib);
+ self.link_dylib(lib, false, true);
}
fn link_rlib(&mut self, lib: &Path) {
bug!("frameworks are not supported on Emscripten")
}
- fn link_framework(&mut self, _framework: Symbol) {
+ fn link_framework(&mut self, _framework: Symbol, _as_needed: bool) {
bug!("frameworks are not supported on Emscripten")
}
// noop
}
+ fn no_gc_sections(&mut self) {
+ // noop
+ }
+
fn optimize(&mut self) {
// Emscripten performs own optimizations
self.cmd.arg(match self.sess.opts.optimize {
}
}
- fn link_dylib(&mut self, lib: Symbol) {
+ fn link_dylib(&mut self, lib: Symbol, _verbatim: bool, _as_needed: bool) {
self.cmd.arg("-l").sym_arg(lib);
}
- fn link_staticlib(&mut self, lib: Symbol) {
+ fn link_staticlib(&mut self, lib: Symbol, _verbatim: bool) {
self.cmd.arg("-l").sym_arg(lib);
}
self.cmd.arg("-l").sym_arg(lib);
}
- fn link_framework(&mut self, _framework: Symbol) {
+ fn link_framework(&mut self, _framework: Symbol, _as_needed: bool) {
panic!("frameworks not supported")
}
- fn link_whole_staticlib(&mut self, lib: Symbol, _search_path: &[PathBuf]) {
+ fn link_whole_staticlib(&mut self, lib: Symbol, _verbatim: bool, _search_path: &[PathBuf]) {
self.cmd.arg("-l").sym_arg(lib);
}
self.cmd.arg("--gc-sections");
}
+ fn no_gc_sections(&mut self) {
+ self.cmd.arg("--no-gc-sections");
+ }
+
fn optimize(&mut self) {
self.cmd.arg(match self.sess.opts.optimize {
OptLevel::No => "-O0",
});
}
- fn link_dylib(&mut self, _lib: Symbol) {
+ fn link_dylib(&mut self, _lib: Symbol, _verbatim: bool, _as_needed: bool) {
panic!("external dylibs not supported")
}
panic!("external dylibs not supported")
}
- fn link_staticlib(&mut self, _lib: Symbol) {
+ fn link_staticlib(&mut self, _lib: Symbol, _verbatim: bool) {
panic!("staticlibs not supported")
}
- fn link_whole_staticlib(&mut self, _lib: Symbol, _search_path: &[PathBuf]) {
+ fn link_whole_staticlib(&mut self, _lib: Symbol, _verbatim: bool, _search_path: &[PathBuf]) {
panic!("staticlibs not supported")
}
panic!("frameworks not supported")
}
- fn link_framework(&mut self, _framework: Symbol) {
+ fn link_framework(&mut self, _framework: Symbol, _as_needed: bool) {
panic!("frameworks not supported")
}
fn gc_sections(&mut self, _keep_metadata: bool) {}
+ fn no_gc_sections(&mut self) {}
+
fn pgo_gen(&mut self) {}
fn no_crt_objects(&mut self) {}
use rustc_data_structures::profiling::{get_resident_set_size, print_time_passes_entry};
use rustc_data_structures::sync::{par_iter, ParallelIterator};
use rustc_hir as hir;
-use rustc_hir::def_id::{LocalDefId, LOCAL_CRATE};
+use rustc_hir::def_id::{DefId, LOCAL_CRATE};
use rustc_hir::lang_items::LangItem;
use rustc_index::vec::Idx;
use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
cx: &'a Bx::CodegenCx,
) -> Option<Bx::Function> {
let main_def_id = cx.tcx().entry_fn(LOCAL_CRATE).map(|(def_id, _)| def_id)?;
- let instance = Instance::mono(cx.tcx(), main_def_id.to_def_id());
+ let main_is_local = main_def_id.is_local();
+ let instance = Instance::mono(cx.tcx(), main_def_id);
- if !cx.codegen_unit().contains_item(&MonoItem::Fn(instance)) {
+ if main_is_local {
// We want to create the wrapper in the same codegen unit as Rust's main
// function.
- return None;
+ if !cx.codegen_unit().contains_item(&MonoItem::Fn(instance)) {
+ return None;
+ }
+ } else {
+ // FIXME: Add support for non-local main fn codegen
+ let span = cx.tcx().main_def.unwrap().span;
+ let n = 28937;
+ cx.sess()
+ .struct_span_err(span, "entry symbol `main` from foreign crate is not yet supported.")
+ .note(&format!(
+ "see issue #{} <https://github.com/rust-lang/rust/issues/{}> \
+ for more information",
+ n, n,
+ ))
+ .emit();
+ cx.sess().abort_if_errors();
+ bug!();
}
let main_llfn = cx.get_fn_addr(instance);
fn create_entry_fn<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
cx: &'a Bx::CodegenCx,
rust_main: Bx::Value,
- rust_main_def_id: LocalDefId,
+ rust_main_def_id: DefId,
use_start_lang_item: bool,
) -> Bx::Function {
// The entry function is either `int main(void)` or `int main(int argc, char **argv)`,
pub kind: NativeLibKind,
pub name: Option<Symbol>,
pub cfg: Option<ast::MetaItem>,
+ pub verbatim: Option<bool>,
}
impl From<&cstore::NativeLib> for NativeLib {
fn from(lib: &cstore::NativeLib) -> Self {
- NativeLib { kind: lib.kind, name: lib.name, cfg: lib.cfg.clone() }
+ NativeLib { kind: lib.kind, name: lib.name, cfg: lib.cfg.clone(), verbatim: lib.verbatim }
}
}
// Returns Err(()) if we already know this obligation failed.
fn register_obligation_at(&mut self, obligation: O, parent: Option<usize>) -> Result<(), ()> {
- if self.done_cache.contains(&obligation.as_cache_key()) {
+ let cache_key = obligation.as_cache_key();
+ if self.done_cache.contains(&cache_key) {
debug!("register_obligation_at: ignoring already done obligation: {:?}", obligation);
return Ok(());
}
- match self.active_cache.entry(obligation.as_cache_key()) {
+ match self.active_cache.entry(cache_key.clone()) {
Entry::Occupied(o) => {
let node = &mut self.nodes[*o.get()];
if let Some(parent_index) = parent {
&& self
.error_cache
.get(&obligation_tree_id)
- .map(|errors| errors.contains(&obligation.as_cache_key()))
+ .map(|errors| errors.contains(&cache_key))
.unwrap_or(false);
if already_failed {
E0779: include_str!("./error_codes/E0779.md"),
E0780: include_str!("./error_codes/E0780.md"),
E0781: include_str!("./error_codes/E0781.md"),
+E0782: include_str!("./error_codes/E0782.md"),
+E0783: include_str!("./error_codes/E0783.md"),
;
// E0006, // merged with E0005
// E0008, // cannot bind by-move into a pattern guard
+#### Note: this error code is no longer emitted by the compiler.
+
More than one `main` function was found.
Erroneous code example:
-```compile_fail,E0136
+```compile_fail
fn main() {
// ...
}
--- /dev/null
+Trait objects must include the `dyn` keyword.
+
+Erroneous code example:
+
+```edition2021,compile_fail,E0782
+trait Foo {}
+fn test(arg: Box<Foo>) {} // error!
+```
+
+Trait objects are a way to call methods on types that are not known until
+runtime but conform to some trait.
+
+Trait objects should be formed with `Box<dyn Foo>`, but in the code above
+`dyn` is left off.
+
+This makes it harder to see that `arg` is a trait object and not a
+simply a heap allocated type called `Foo`.
+
+To fix this issue, add `dyn` before the trait name.
+
+```edition2021
+trait Foo {}
+fn test(arg: Box<dyn Foo>) {} // ok!
+```
+
+This used to be allowed before edition 2021, but is now an error.
--- /dev/null
+The range pattern `...` is no longer allowed.
+
+Erroneous code example:
+
+```edition2021,compile_fail,E0783
+match 2u8 {
+ 0...9 => println!("Got a number less than 10"), // error!
+ _ => println!("Got a number 10 or more"),
+}
+```
+
+Older Rust code using previous editions allowed `...` to stand for exclusive
+ranges which are now signified using `..=`.
+
+To make this code compile replace the `...` with `..=`.
+
+```edition2021
+match 2u8 {
+ 0..=9 => println!("Got a number less than 10"), // ok!
+ _ => println!("Got a number 10 or more"),
+}
+```
pub use diagnostic::{Diagnostic, DiagnosticId, DiagnosticStyledString, SubDiagnostic};
pub use diagnostic_builder::DiagnosticBuilder;
+use std::backtrace::Backtrace;
/// A handler deals with errors and other compiler output.
/// Certain errors (fatal, bug, unimpl) may cause immediate exit,
deduplicated_err_count: usize,
emitter: Box<dyn Emitter + sync::Send>,
delayed_span_bugs: Vec<Diagnostic>,
- delayed_good_path_bugs: Vec<Diagnostic>,
+ delayed_good_path_bugs: Vec<DelayedDiagnostic>,
/// This set contains the `DiagnosticId` of all emitted diagnostics to avoid
/// emitting the same diagnostic with extended help (`--teach`) twice, which
if !self.has_any_message() {
let bugs = std::mem::replace(&mut self.delayed_good_path_bugs, Vec::new());
self.flush_delayed(
- bugs,
+ bugs.into_iter().map(DelayedDiagnostic::decorate).collect(),
"no warnings or errors encountered even though `delayed_good_path_bugs` issued",
);
}
}
fn delay_good_path_bug(&mut self, msg: &str) {
- let mut diagnostic = Diagnostic::new(Level::Bug, msg);
+ let diagnostic = Diagnostic::new(Level::Bug, msg);
if self.flags.report_delayed_bugs {
self.emit_diagnostic(&diagnostic);
}
- diagnostic.note(&format!("delayed at {}", std::backtrace::Backtrace::force_capture()));
- self.delayed_good_path_bugs.push(diagnostic);
+ let backtrace = std::backtrace::Backtrace::force_capture();
+ self.delayed_good_path_bugs.push(DelayedDiagnostic::with_backtrace(diagnostic, backtrace));
}
fn failure(&mut self, msg: &str) {
}
}
+struct DelayedDiagnostic {
+ inner: Diagnostic,
+ note: Backtrace,
+}
+
+impl DelayedDiagnostic {
+ fn with_backtrace(diagnostic: Diagnostic, backtrace: Backtrace) -> Self {
+ DelayedDiagnostic { inner: diagnostic, note: backtrace }
+ }
+
+ fn decorate(mut self) -> Diagnostic {
+ self.inner.note(&format!("delayed at {}", self.note));
+ self.inner
+ }
+}
+
#[derive(Copy, PartialEq, Clone, Hash, Debug, Encodable, Decodable)]
pub enum Level {
Bug,
use rustc_data_structures::map_in_place::MapInPlace;
use rustc_data_structures::stack::ensure_sufficient_stack;
use rustc_data_structures::sync::Lrc;
-use rustc_errors::{Applicability, PResult};
+use rustc_errors::{Applicability, FatalError, PResult};
use rustc_feature::Features;
use rustc_parse::parser::{AttemptLocalParseRecovery, ForceCollect, Parser, RecoverComma};
use rustc_parse::validate_attr;
kind.article(), kind.descr()
),
);
+ // FIXME: this workaround issue #84569
+ FatalError.raise();
}
};
self.cx.trace_macros_diag();
pub enum ModError<'a> {
CircularInclusion(Vec<PathBuf>),
ModInBlock(Option<Ident>),
- FileNotFound(Ident, PathBuf),
- MultipleCandidates(Ident, String, String),
+ FileNotFound(Ident, PathBuf, PathBuf),
+ MultipleCandidates(Ident, PathBuf, PathBuf),
ParserError(DiagnosticBuilder<'a>),
}
file_path: secondary_path,
dir_ownership: DirOwnership::Owned { relative: None },
}),
- (false, false) => Err(ModError::FileNotFound(ident, default_path)),
- (true, true) => {
- Err(ModError::MultipleCandidates(ident, default_path_str, secondary_path_str))
- }
+ (false, false) => Err(ModError::FileNotFound(ident, default_path, secondary_path)),
+ (true, true) => Err(ModError::MultipleCandidates(ident, default_path, secondary_path)),
}
}
}
err
}
- ModError::FileNotFound(ident, default_path) => {
+ ModError::FileNotFound(ident, default_path, secondary_path) => {
let mut err = struct_span_err!(
diag,
span,
ident,
);
err.help(&format!(
- "to create the module `{}`, create file \"{}\"",
+ "to create the module `{}`, create file \"{}\" or \"{}\"",
ident,
default_path.display(),
+ secondary_path.display(),
));
err
}
- ModError::MultipleCandidates(ident, default_path_short, secondary_path_short) => {
+ ModError::MultipleCandidates(ident, default_path, secondary_path) => {
let mut err = struct_span_err!(
diag,
span,
E0761,
- "file for module `{}` found at both {} and {}",
+ "file for module `{}` found at both \"{}\" and \"{}\"",
ident,
- default_path_short,
- secondary_path_short,
+ default_path.display(),
+ secondary_path.display(),
);
err.help("delete or rename one of them to remove the ambiguity");
err
/// Allows unsizing coercions in `const fn`.
(active, const_fn_unsize, "1.53.0", Some(64992), None),
+ /// Allows using imported `main` function
+ (active, imported_main, "1.53.0", Some(28937), None),
+
+ /// Allows specifying modifiers in the link attribute: `#[link(modifiers = "...")]`
+ (active, native_link_modifiers, "1.53.0", Some(81490), None),
+
+ /// Allows specifying the bundle link modifier
+ (active, native_link_modifiers_bundle, "1.53.0", Some(81490), None),
+
+ /// Allows specifying the verbatim link modifier
+ (active, native_link_modifiers_verbatim, "1.53.0", Some(81490), None),
+
+ /// Allows specifying the whole-archive link modifier
+ (active, native_link_modifiers_whole_archive, "1.53.0", Some(81490), None),
+
+ /// Allows specifying the as-needed link modifier
+ (active, native_link_modifiers_as_needed, "1.53.0", Some(81490), None),
+
// -------------------------------------------------------------------------
// feature-group-end: actual feature gates
// -------------------------------------------------------------------------
sym::const_generics_defaults,
sym::inherent_associated_types,
sym::type_alias_impl_trait,
+ sym::native_link_modifiers,
+ sym::native_link_modifiers_bundle,
+ sym::native_link_modifiers_verbatim,
+ sym::native_link_modifiers_whole_archive,
+ sym::native_link_modifiers_as_needed,
];
/// Some features are not allowed to be used together at the same time, if
template!(List: "address, memory, thread"),
experimental!(no_sanitize)
),
- ungated!(
- // Not exclusively gated at the crate level (though crate-level is
- // supported). The feature can alternatively be enabled on individual
- // functions.
- no_coverage, AssumedUsed,
- template!(Word),
- ),
+ gated!(no_coverage, AssumedUsed, template!(Word), experimental!(no_coverage)),
// FIXME: #14408 assume docs are used since rustdoc looks at them.
ungated!(doc, AssumedUsed, template!(List: "hidden|inline|...", NameValueStr: "string")),
hash
}
- /// Used by librustdoc for fake DefIds.
- pub fn num_def_ids(&self) -> usize {
- self.index_to_key.len()
- }
-
pub fn enumerated_keys_and_path_hashes(
&self,
) -> impl Iterator<Item = (DefIndex, &DefKey, &DefPathHash)> + '_ {
// Fortunately, we just checked that this isn't the case.
let path = dep_graph_path_from(&sess.incr_comp_session_dir());
let report_incremental_info = sess.opts.debugging_opts.incremental_info;
- let expected_hash = sess.opts.dep_tracking_hash();
+ let expected_hash = sess.opts.dep_tracking_hash(false);
let mut prev_work_products = FxHashMap::default();
let nightly_build = sess.is_nightly_build();
}
// First encode the commandline arguments hash
- if let Err(err) = sess.opts.dep_tracking_hash().encode(&mut encoder) {
+ if let Err(err) = sess.opts.dep_tracking_hash(false).encode(&mut encoder) {
sess.err(&format!(
"failed to write dependency graph hash `{}`: {}",
path_buf.display(),
Op: Fn(Word, Word) -> Word,
{
assert_eq!(out_vec.len(), in_vec.len());
- let mut changed = false;
+ let mut changed = 0;
for (out_elem, in_elem) in iter::zip(out_vec, in_vec) {
let old_val = *out_elem;
let new_val = op(old_val, *in_elem);
*out_elem = new_val;
- changed |= old_val != new_val;
+ // This is essentially equivalent to a != with changed being a bool, but
+ // in practice this code gets auto-vectorized by the compiler for most
+ // operators. Using != here causes us to generate quite poor code as the
+ // compiler tries to go back to a boolean on each loop iteration.
+ changed |= old_val ^ new_val;
}
- changed
+ changed != 0
}
const SPARSE_MAX: usize = 8;
self.tcx.associated_item(def_id).ident
),
infer::EarlyBoundRegion(_, name) => format!(" for lifetime parameter `{}`", name),
- infer::BoundRegionInCoherence(name) => {
- format!(" for lifetime parameter `{}` in coherence check", name)
- }
infer::UpvarRegion(ref upvar_id, _) => {
let var_name = self.tcx.hir().name(upvar_id.var_path.hir_id);
format!(" for capture of `{}` by closure", var_name)
UpvarRegion(ty::UpvarId, Span),
- BoundRegionInCoherence(Symbol),
-
/// This origin is used for the inference variables that we create
/// during NLL region processing.
Nll(NllRegionVariableOrigin),
| EarlyBoundRegion(a, ..)
| LateBoundRegion(a, ..)
| UpvarRegion(_, a) => a,
- BoundRegionInCoherence(_) => rustc_span::DUMMY_SP,
Nll(..) => bug!("NLL variable used with `span`"),
}
}
Some(assoc_name),
));
for (super_predicate, _) in super_predicates.predicates {
- let bound_predicate = super_predicate.kind();
- let subst_predicate = super_predicate
- .subst_supertrait(tcx, &bound_predicate.rebind(trait_ref.skip_binder()));
+ let subst_predicate = super_predicate.subst_supertrait(tcx, &trait_ref);
if let Some(binder) = subst_predicate.to_opt_poly_trait_ref() {
stack.push(binder.value);
}
_ => return,
};
- let attrs = &*tcx.get_attrs(def_id.to_def_id());
+ let attrs = &*tcx.get_attrs(def_id);
let attrs = attrs.iter().filter(|attr| tcx.sess.check_name(attr, sym::rustc_error));
for attr in attrs {
match attr.meta_item_list() {
};
use rustc_session::lint::Level;
use rustc_session::search_paths::SearchPath;
-use rustc_session::utils::{CanonicalizedPath, NativeLibKind};
+use rustc_session::utils::{CanonicalizedPath, NativeLib, NativeLibKind};
use rustc_session::{build_session, getopts, DiagnosticOutput, Session};
use rustc_span::edition::{Edition, DEFAULT_EDITION};
use rustc_span::symbol::sym;
use rustc_span::SourceFileHashAlgorithm;
use rustc_target::spec::{CodeModel, LinkerFlavor, MergeFunctions, PanicStrategy};
use rustc_target::spec::{RelocModel, RelroLevel, SanitizerSet, SplitDebuginfo, TlsModel};
+
use std::collections::{BTreeMap, BTreeSet};
use std::iter::FromIterator;
use std::num::NonZeroUsize;
BTreeMap::from_iter(entries.into_iter())
}
+fn assert_same_clone(x: &Options) {
+ assert_eq!(x.dep_tracking_hash(true), x.clone().dep_tracking_hash(true));
+ assert_eq!(x.dep_tracking_hash(false), x.clone().dep_tracking_hash(false));
+}
+
+fn assert_same_hash(x: &Options, y: &Options) {
+ assert_eq!(x.dep_tracking_hash(true), y.dep_tracking_hash(true));
+ assert_eq!(x.dep_tracking_hash(false), y.dep_tracking_hash(false));
+ // Check clone
+ assert_same_clone(x);
+ assert_same_clone(y);
+}
+
+fn assert_different_hash(x: &Options, y: &Options) {
+ assert_ne!(x.dep_tracking_hash(true), y.dep_tracking_hash(true));
+ assert_ne!(x.dep_tracking_hash(false), y.dep_tracking_hash(false));
+ // Check clone
+ assert_same_clone(x);
+ assert_same_clone(y);
+}
+
// When the user supplies --test we should implicitly supply --cfg test
#[test]
fn test_switch_implies_cfg_test() {
v2.output_types = OutputTypes::new(&[(OutputType::Exe, Some(PathBuf::from("/some/thing")))]);
v3.output_types = OutputTypes::new(&[(OutputType::Exe, None)]);
- assert!(v1.dep_tracking_hash() != v2.dep_tracking_hash());
- assert!(v1.dep_tracking_hash() != v3.dep_tracking_hash());
- assert!(v2.dep_tracking_hash() != v3.dep_tracking_hash());
-
- // Check clone
- assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
- assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
- assert_eq!(v3.dep_tracking_hash(), v3.clone().dep_tracking_hash());
+ assert_different_hash(&v1, &v2);
+ assert_different_hash(&v1, &v3);
+ assert_different_hash(&v2, &v3);
}
#[test]
(OutputType::Exe, Some(PathBuf::from("./some/thing"))),
]);
- assert_eq!(v1.dep_tracking_hash(), v2.dep_tracking_hash());
-
- // Check clone
- assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
+ assert_same_hash(&v1, &v2);
}
#[test]
(String::from("d"), new_public_extern_entry(vec!["f", "e"])),
]));
- assert_eq!(v1.dep_tracking_hash(), v2.dep_tracking_hash());
- assert_eq!(v1.dep_tracking_hash(), v3.dep_tracking_hash());
- assert_eq!(v2.dep_tracking_hash(), v3.dep_tracking_hash());
-
- // Check clone
- assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
- assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
- assert_eq!(v3.dep_tracking_hash(), v3.clone().dep_tracking_hash());
+ assert_same_hash(&v1, &v2);
+ assert_same_hash(&v1, &v3);
+ assert_same_hash(&v2, &v3);
}
#[test]
(String::from("d"), Level::Deny),
];
- assert!(v1.dep_tracking_hash() != v2.dep_tracking_hash());
- assert!(v1.dep_tracking_hash() != v3.dep_tracking_hash());
- assert!(v2.dep_tracking_hash() != v3.dep_tracking_hash());
-
- // Check clone
- assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
- assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
- assert_eq!(v3.dep_tracking_hash(), v3.clone().dep_tracking_hash());
+ assert_different_hash(&v1, &v2);
+ assert_different_hash(&v1, &v3);
+ assert_different_hash(&v2, &v3);
}
#[test]
(String::from("d"), Level::Forbid),
];
- assert_eq!(v1.dep_tracking_hash(), v2.dep_tracking_hash());
-
- // Check clone
- assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
- assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
+ assert_same_hash(&v1, &v2);
}
#[test]
v4.search_paths.push(SearchPath::from_cli_opt("dependency=ghi", JSON));
v4.search_paths.push(SearchPath::from_cli_opt("framework=jkl", JSON));
- assert!(v1.dep_tracking_hash() == v2.dep_tracking_hash());
- assert!(v1.dep_tracking_hash() == v3.dep_tracking_hash());
- assert!(v1.dep_tracking_hash() == v4.dep_tracking_hash());
-
- // Check clone
- assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
- assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
- assert_eq!(v3.dep_tracking_hash(), v3.clone().dep_tracking_hash());
- assert_eq!(v4.dep_tracking_hash(), v4.clone().dep_tracking_hash());
+ assert_same_hash(&v1, &v2);
+ assert_same_hash(&v1, &v3);
+ assert_same_hash(&v1, &v4);
}
#[test]
let mut v2 = Options::default();
let mut v3 = Options::default();
let mut v4 = Options::default();
+ let mut v5 = Options::default();
// Reference
v1.libs = vec![
- (String::from("a"), None, NativeLibKind::StaticBundle),
- (String::from("b"), None, NativeLibKind::Framework),
- (String::from("c"), None, NativeLibKind::Unspecified),
+ NativeLib {
+ name: String::from("a"),
+ new_name: None,
+ kind: NativeLibKind::Static { bundle: None, whole_archive: None },
+ verbatim: None,
+ },
+ NativeLib {
+ name: String::from("b"),
+ new_name: None,
+ kind: NativeLibKind::Framework { as_needed: None },
+ verbatim: None,
+ },
+ NativeLib {
+ name: String::from("c"),
+ new_name: None,
+ kind: NativeLibKind::Unspecified,
+ verbatim: None,
+ },
];
// Change label
v2.libs = vec![
- (String::from("a"), None, NativeLibKind::StaticBundle),
- (String::from("X"), None, NativeLibKind::Framework),
- (String::from("c"), None, NativeLibKind::Unspecified),
+ NativeLib {
+ name: String::from("a"),
+ new_name: None,
+ kind: NativeLibKind::Static { bundle: None, whole_archive: None },
+ verbatim: None,
+ },
+ NativeLib {
+ name: String::from("X"),
+ new_name: None,
+ kind: NativeLibKind::Framework { as_needed: None },
+ verbatim: None,
+ },
+ NativeLib {
+ name: String::from("c"),
+ new_name: None,
+ kind: NativeLibKind::Unspecified,
+ verbatim: None,
+ },
];
// Change kind
v3.libs = vec![
- (String::from("a"), None, NativeLibKind::StaticBundle),
- (String::from("b"), None, NativeLibKind::StaticBundle),
- (String::from("c"), None, NativeLibKind::Unspecified),
+ NativeLib {
+ name: String::from("a"),
+ new_name: None,
+ kind: NativeLibKind::Static { bundle: None, whole_archive: None },
+ verbatim: None,
+ },
+ NativeLib {
+ name: String::from("b"),
+ new_name: None,
+ kind: NativeLibKind::Static { bundle: None, whole_archive: None },
+ verbatim: None,
+ },
+ NativeLib {
+ name: String::from("c"),
+ new_name: None,
+ kind: NativeLibKind::Unspecified,
+ verbatim: None,
+ },
];
// Change new-name
v4.libs = vec![
- (String::from("a"), None, NativeLibKind::StaticBundle),
- (String::from("b"), Some(String::from("X")), NativeLibKind::Framework),
- (String::from("c"), None, NativeLibKind::Unspecified),
+ NativeLib {
+ name: String::from("a"),
+ new_name: None,
+ kind: NativeLibKind::Static { bundle: None, whole_archive: None },
+ verbatim: None,
+ },
+ NativeLib {
+ name: String::from("b"),
+ new_name: Some(String::from("X")),
+ kind: NativeLibKind::Framework { as_needed: None },
+ verbatim: None,
+ },
+ NativeLib {
+ name: String::from("c"),
+ new_name: None,
+ kind: NativeLibKind::Unspecified,
+ verbatim: None,
+ },
];
- assert!(v1.dep_tracking_hash() != v2.dep_tracking_hash());
- assert!(v1.dep_tracking_hash() != v3.dep_tracking_hash());
- assert!(v1.dep_tracking_hash() != v4.dep_tracking_hash());
+ // Change verbatim
+ v5.libs = vec![
+ NativeLib {
+ name: String::from("a"),
+ new_name: None,
+ kind: NativeLibKind::Static { bundle: None, whole_archive: None },
+ verbatim: None,
+ },
+ NativeLib {
+ name: String::from("b"),
+ new_name: None,
+ kind: NativeLibKind::Framework { as_needed: None },
+ verbatim: Some(true),
+ },
+ NativeLib {
+ name: String::from("c"),
+ new_name: None,
+ kind: NativeLibKind::Unspecified,
+ verbatim: None,
+ },
+ ];
- // Check clone
- assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
- assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
- assert_eq!(v3.dep_tracking_hash(), v3.clone().dep_tracking_hash());
- assert_eq!(v4.dep_tracking_hash(), v4.clone().dep_tracking_hash());
+ assert_different_hash(&v1, &v2);
+ assert_different_hash(&v1, &v3);
+ assert_different_hash(&v1, &v4);
+ assert_different_hash(&v1, &v5);
}
#[test]
// Reference
v1.libs = vec![
- (String::from("a"), None, NativeLibKind::StaticBundle),
- (String::from("b"), None, NativeLibKind::Framework),
- (String::from("c"), None, NativeLibKind::Unspecified),
+ NativeLib {
+ name: String::from("a"),
+ new_name: None,
+ kind: NativeLibKind::Static { bundle: None, whole_archive: None },
+ verbatim: None,
+ },
+ NativeLib {
+ name: String::from("b"),
+ new_name: None,
+ kind: NativeLibKind::Framework { as_needed: None },
+ verbatim: None,
+ },
+ NativeLib {
+ name: String::from("c"),
+ new_name: None,
+ kind: NativeLibKind::Unspecified,
+ verbatim: None,
+ },
];
v2.libs = vec![
- (String::from("b"), None, NativeLibKind::Framework),
- (String::from("a"), None, NativeLibKind::StaticBundle),
- (String::from("c"), None, NativeLibKind::Unspecified),
+ NativeLib {
+ name: String::from("b"),
+ new_name: None,
+ kind: NativeLibKind::Framework { as_needed: None },
+ verbatim: None,
+ },
+ NativeLib {
+ name: String::from("a"),
+ new_name: None,
+ kind: NativeLibKind::Static { bundle: None, whole_archive: None },
+ verbatim: None,
+ },
+ NativeLib {
+ name: String::from("c"),
+ new_name: None,
+ kind: NativeLibKind::Unspecified,
+ verbatim: None,
+ },
];
v3.libs = vec![
- (String::from("c"), None, NativeLibKind::Unspecified),
- (String::from("a"), None, NativeLibKind::StaticBundle),
- (String::from("b"), None, NativeLibKind::Framework),
+ NativeLib {
+ name: String::from("c"),
+ new_name: None,
+ kind: NativeLibKind::Unspecified,
+ verbatim: None,
+ },
+ NativeLib {
+ name: String::from("a"),
+ new_name: None,
+ kind: NativeLibKind::Static { bundle: None, whole_archive: None },
+ verbatim: None,
+ },
+ NativeLib {
+ name: String::from("b"),
+ new_name: None,
+ kind: NativeLibKind::Framework { as_needed: None },
+ verbatim: None,
+ },
];
- assert!(v1.dep_tracking_hash() == v2.dep_tracking_hash());
- assert!(v1.dep_tracking_hash() == v3.dep_tracking_hash());
- assert!(v2.dep_tracking_hash() == v3.dep_tracking_hash());
-
- // Check clone
- assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
- assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
- assert_eq!(v3.dep_tracking_hash(), v3.clone().dep_tracking_hash());
+ assert_same_hash(&v1, &v2);
+ assert_same_hash(&v1, &v3);
+ assert_same_hash(&v2, &v3);
}
#[test]
macro_rules! untracked {
($name: ident, $non_default_value: expr) => {
+ assert_ne!(opts.cg.$name, $non_default_value);
opts.cg.$name = $non_default_value;
- assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
+ assert_same_hash(&reference, &opts);
};
}
macro_rules! tracked {
($name: ident, $non_default_value: expr) => {
opts = reference.clone();
+ assert_ne!(opts.cg.$name, $non_default_value);
opts.cg.$name = $non_default_value;
- assert_ne!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
+ assert_different_hash(&reference, &opts);
};
}
tracked!(target_feature, String::from("all the features, all of them"));
}
+#[test]
+fn test_top_level_options_tracked_no_crate() {
+ let reference = Options::default();
+ let mut opts;
+
+ macro_rules! tracked {
+ ($name: ident, $non_default_value: expr) => {
+ opts = reference.clone();
+ assert_ne!(opts.$name, $non_default_value);
+ opts.$name = $non_default_value;
+ // The crate hash should be the same
+ assert_eq!(reference.dep_tracking_hash(true), opts.dep_tracking_hash(true));
+ // The incremental hash should be different
+ assert_ne!(reference.dep_tracking_hash(false), opts.dep_tracking_hash(false));
+ };
+ }
+
+ // Make sure that changing a [TRACKED_NO_CRATE_HASH] option leaves the crate hash unchanged but changes the incremental hash.
+ // This list is in alphabetical order.
+ tracked!(remap_path_prefix, vec![("/home/bors/rust".into(), "src".into())]);
+ tracked!(
+ real_rust_source_base_dir,
+ Some("/home/bors/rust/.rustup/toolchains/nightly/lib/rustlib/src/rust".into())
+ );
+}
+
#[test]
fn test_debugging_options_tracking_hash() {
let reference = Options::default();
macro_rules! untracked {
($name: ident, $non_default_value: expr) => {
+ assert_ne!(opts.debugging_opts.$name, $non_default_value);
opts.debugging_opts.$name = $non_default_value;
- assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
+ assert_same_hash(&reference, &opts);
};
}
untracked!(ast_json, true);
untracked!(ast_json_noexpand, true);
untracked!(borrowck, String::from("other"));
- untracked!(deduplicate_diagnostics, true);
+ untracked!(deduplicate_diagnostics, false);
untracked!(dep_tasks, true);
untracked!(dont_buffer_diagnostics, true);
untracked!(dump_dep_graph, true);
untracked!(self_profile_events, Some(vec![String::new()]));
untracked!(span_debug, true);
untracked!(span_free_formats, true);
- untracked!(strip, Strip::None);
+ untracked!(strip, Strip::Debuginfo);
untracked!(terminal_width, Some(80));
untracked!(threads, 99);
untracked!(time, true);
macro_rules! tracked {
($name: ident, $non_default_value: expr) => {
opts = reference.clone();
+ assert_ne!(opts.debugging_opts.$name, $non_default_value);
opts.debugging_opts.$name = $non_default_value;
- assert_ne!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
+ assert_different_hash(&reference, &opts);
};
}
/// [`..` range expression]: https://doc.rust-lang.org/reference/expressions/range-expr.html
pub ELLIPSIS_INCLUSIVE_RANGE_PATTERNS,
Warn,
- "`...` range patterns are deprecated"
+ "`...` range patterns are deprecated",
+ @future_incompatible = FutureIncompatibleInfo {
+ reference: "issue #80165 <https://github.com/rust-lang/rust/issues/80165>",
+ edition: Some(Edition::Edition2021),
+ };
}
#[derive(Default)]
let suggestion = "use `..=` for an inclusive range";
if parenthesise {
self.node_id = Some(pat.id);
- cx.struct_span_lint(ELLIPSIS_INCLUSIVE_RANGE_PATTERNS, pat.span, |lint| {
- let end = expr_to_string(&end);
- let replace = match start {
- Some(start) => format!("&({}..={})", expr_to_string(&start), end),
- None => format!("&(..={})", end),
- };
- lint.build(msg)
- .span_suggestion(
- pat.span,
- suggestion,
- replace,
- Applicability::MachineApplicable,
- )
- .emit();
- });
+ let end = expr_to_string(&end);
+ let replace = match start {
+ Some(start) => format!("&({}..={})", expr_to_string(&start), end),
+ None => format!("&(..={})", end),
+ };
+ if join.edition() >= Edition::Edition2021 {
+ let mut err =
+ rustc_errors::struct_span_err!(cx.sess, pat.span, E0783, "{}", msg,);
+ err.span_suggestion(
+ pat.span,
+ suggestion,
+ replace,
+ Applicability::MachineApplicable,
+ )
+ .emit();
+ } else {
+ cx.struct_span_lint(ELLIPSIS_INCLUSIVE_RANGE_PATTERNS, pat.span, |lint| {
+ lint.build(msg)
+ .span_suggestion(
+ pat.span,
+ suggestion,
+ replace,
+ Applicability::MachineApplicable,
+ )
+ .emit();
+ });
+ }
} else {
- cx.struct_span_lint(ELLIPSIS_INCLUSIVE_RANGE_PATTERNS, join, |lint| {
- lint.build(msg)
- .span_suggestion_short(
- join,
- suggestion,
- "..=".to_owned(),
- Applicability::MachineApplicable,
- )
- .emit();
- });
+ let replace = "..=".to_owned();
+ if join.edition() >= Edition::Edition2021 {
+ let mut err =
+ rustc_errors::struct_span_err!(cx.sess, pat.span, E0783, "{}", msg,);
+ err.span_suggestion_short(
+ join,
+ suggestion,
+ replace,
+ Applicability::MachineApplicable,
+ )
+ .emit();
+ } else {
+ cx.struct_span_lint(ELLIPSIS_INCLUSIVE_RANGE_PATTERNS, join, |lint| {
+ lint.build(msg)
+ .span_suggestion_short(
+ join,
+ suggestion,
+ replace,
+ Applicability::MachineApplicable,
+ )
+ .emit();
+ });
+ }
};
}
}
declare_lint! {
/// The `invalid_value` lint detects creating a value that is not valid,
- /// such as a NULL reference.
+ /// such as a null reference.
///
/// ### Example
///
/// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
pub INVALID_VALUE,
Warn,
- "an invalid value is being created (such as a NULL reference)"
+ "an invalid value is being created (such as a null reference)"
}
declare_lint_pass!(InvalidValue => [INVALID_VALUE]);
/// [`impl Trait`]: https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
pub BARE_TRAIT_OBJECTS,
Warn,
- "suggest using `dyn Trait` for trait objects"
+ "suggest using `dyn Trait` for trait objects",
+ @future_incompatible = FutureIncompatibleInfo {
+ reference: "issue #80165 <https://github.com/rust-lang/rust/issues/80165>",
+ edition: Some(Edition::Edition2021),
+ };
}
declare_lint! {
std::string ErrorInfo;
std::error_code EC;
- raw_fd_ostream OS(Path, EC, sys::fs::F_None);
+ raw_fd_ostream OS(Path, EC, sys::fs::OF_None);
if (EC)
ErrorInfo = EC.message();
if (ErrorInfo != "") {
buffer_ostream BOS(OS);
if (DwoPath) {
- raw_fd_ostream DOS(DwoPath, EC, sys::fs::F_None);
+ raw_fd_ostream DOS(DwoPath, EC, sys::fs::OF_None);
EC.clear();
if (EC)
ErrorInfo = EC.message();
LLVMRustPrintModule(LLVMModuleRef M, const char *Path, DemangleFn Demangle) {
std::string ErrorInfo;
std::error_code EC;
- raw_fd_ostream OS(Path, EC, sys::fs::F_None);
+ raw_fd_ostream OS(Path, EC, sys::fs::OF_None);
if (EC)
ErrorInfo = EC.message();
if (ErrorInfo != "") {
return Ok(ret.cast());
}
- // A NULL return from `dlopen` indicates that an error has definitely occurred, so if
+ // A null return from `dlopen` indicates that an error has definitely occurred, so if
// nothing is in `dlerror`, we are racing with another thread that has stolen our error
// message. See the explanation on the `dl::error` module for more information.
dlerror.get().and_then(|()| Err("Unknown error".to_string()))
) -> Result<*mut u8, String> {
let mut dlerror = error::lock();
- // Unlike `dlopen`, it's possible for `dlsym` to return NULL without overwriting `dlerror`.
+ // Unlike `dlopen`, it's possible for `dlsym` to return null without overwriting `dlerror`.
// Because of this, we clear `dlerror` before calling `dlsym` to avoid picking up a stale
// error message by accident.
dlerror.clear();
return Ok(ret.cast());
}
- // If `dlsym` returns NULL but there is nothing in `dlerror` it means one of two things:
+ // If `dlsym` returns null but there is nothing in `dlerror` it means one of two things:
// - We tried to load a symbol mapped to address 0. This is not technically an error but is
// unlikely to occur in practice and equally unlikely to be handled correctly by calling
// code. Therefore we treat it as an error anyway.
use rustc_session::parse::feature_err;
use rustc_session::utils::NativeLibKind;
use rustc_session::Session;
-use rustc_span::source_map::Span;
use rustc_span::symbol::{kw, sym, Symbol};
+use rustc_span::Span;
use rustc_target::spec::abi::Abi;
crate fn collect(tcx: TyCtxt<'_>) -> Vec<NativeLib> {
cfg: None,
foreign_module: Some(it.def_id.to_def_id()),
wasm_import_module: None,
+ verbatim: None,
};
let mut kind_specified = false;
None => continue, // skip like historical compilers
};
lib.kind = match &*kind.as_str() {
- "static" => NativeLibKind::StaticBundle,
- "static-nobundle" => NativeLibKind::StaticNoBundle,
- "dylib" => NativeLibKind::Dylib,
- "framework" => NativeLibKind::Framework,
+ "static" => NativeLibKind::Static { bundle: None, whole_archive: None },
+ "static-nobundle" => {
+ sess.struct_span_warn(
+ item.span(),
+ "library kind `static-nobundle` has been superseded by specifying \
+ modifier `-bundle` with library kind `static`",
+ )
+ .emit();
+ NativeLibKind::Static { bundle: Some(false), whole_archive: None }
+ }
+ "dylib" => NativeLibKind::Dylib { as_needed: None },
+ "framework" => NativeLibKind::Framework { as_needed: None },
"raw-dylib" => NativeLibKind::RawDylib,
k => {
struct_span_err!(sess, item.span(), E0458, "unknown kind: `{}`", k)
}
}
+ // Do this outside the above loop so we don't depend on modifiers coming
+ // after kinds
+ if let Some(item) = items.iter().find(|item| item.has_name(sym::modifiers)) {
+ if let Some(modifiers) = item.value_str() {
+ let span = item.name_value_literal_span().unwrap();
+ for modifier in modifiers.as_str().split(',') {
+ let (modifier, value) = match modifier.strip_prefix(&['+', '-'][..]) {
+ Some(m) => (m, modifier.starts_with('+')),
+ None => {
+ sess.span_err(
+ span,
+ "invalid linking modifier syntax, expected '+' or '-' prefix \
+ before one of: bundle, verbatim, whole-archive, as-needed",
+ );
+ continue;
+ }
+ };
+
+ match (modifier, &mut lib.kind) {
+ ("bundle", NativeLibKind::Static { bundle, .. }) => {
+ *bundle = Some(value);
+ }
+ ("bundle", _) => sess.span_err(
+ span,
+ "bundle linking modifier is only compatible with \
+ `static` linking kind",
+ ),
+
+ ("verbatim", _) => lib.verbatim = Some(value),
+
+ ("whole-archive", NativeLibKind::Static { whole_archive, .. }) => {
+ *whole_archive = Some(value);
+ }
+ ("whole-archive", _) => sess.span_err(
+ span,
+ "whole-archive linking modifier is only compatible with \
+ `static` linking kind",
+ ),
+
+ ("as-needed", NativeLibKind::Dylib { as_needed })
+ | ("as-needed", NativeLibKind::Framework { as_needed }) => {
+ *as_needed = Some(value);
+ }
+ ("as-needed", _) => sess.span_err(
+ span,
+ "as-needed linking modifier is only compatible with \
+ `dylib` and `framework` linking kinds",
+ ),
+
+ _ => sess.span_err(
+ span,
+ &format!(
+ "unrecognized linking modifier `{}`, expected one \
+ of: bundle, verbatim, whole-archive, as-needed",
+ modifier
+ ),
+ ),
+ }
+ }
+ } else {
+ let msg = "must be of the form `#[link(modifiers = \"...\")]`";
+ sess.span_err(item.span(), msg);
+ }
+ }
+
// In general we require #[link(name = "...")] but we allow
// #[link(wasm_import_module = "...")] without the `name`.
let requires_name = kind_specified || lib.wasm_import_module.is_none();
return;
}
let is_osx = self.tcx.sess.target.is_like_osx;
- if lib.kind == NativeLibKind::Framework && !is_osx {
+ if matches!(lib.kind, NativeLibKind::Framework { .. }) && !is_osx {
let msg = "native frameworks are only available on macOS targets";
match span {
Some(span) => struct_span_err!(self.tcx.sess, span, E0455, "{}", msg).emit(),
)
.emit();
}
- if lib.kind == NativeLibKind::StaticNoBundle && !self.tcx.features().static_nobundle {
+ if matches!(lib.kind, NativeLibKind::Static { bundle: Some(false), .. })
+ && !self.tcx.features().static_nobundle
+ {
feature_err(
&self.tcx.sess.parse_sess,
sym::static_nobundle,
fn process_command_line(&mut self) {
// First, check for errors
let mut renames = FxHashSet::default();
- for (name, new_name, _) in &self.tcx.sess.opts.libs {
- if let Some(ref new_name) = new_name {
+ for lib in &self.tcx.sess.opts.libs {
+ if let Some(ref new_name) = lib.new_name {
let any_duplicate = self
.libs
.iter()
.filter_map(|lib| lib.name.as_ref())
- .any(|n| &n.as_str() == name);
+ .any(|n| &n.as_str() == &lib.name);
if new_name.is_empty() {
self.tcx.sess.err(&format!(
"an empty renaming target was specified for library `{}`",
- name
+ lib.name
));
} else if !any_duplicate {
self.tcx.sess.err(&format!(
"renaming of the library `{}` was specified, \
however this crate contains no `#[link(...)]` \
attributes referencing this library.",
- name
+ lib.name
));
- } else if !renames.insert(name) {
+ } else if !renames.insert(&lib.name) {
self.tcx.sess.err(&format!(
"multiple renamings were \
specified for library `{}` .",
- name
+ lib.name
));
}
}
// it. (This ensures that the linker is able to see symbols from
// all possible dependent libraries before linking in the library
// in question.)
- for &(ref name, ref new_name, kind) in &self.tcx.sess.opts.libs {
+ for passed_lib in &self.tcx.sess.opts.libs {
// If we've already added any native libraries with the same
// name, they will be pulled out into `existing`, so that we
// can move them to the end of the list below.
.libs
.drain_filter(|lib| {
if let Some(lib_name) = lib.name {
- if lib_name.as_str() == *name {
- if kind != NativeLibKind::Unspecified {
- lib.kind = kind;
+ if lib_name.as_str() == passed_lib.name {
+ if passed_lib.kind != NativeLibKind::Unspecified {
+ lib.kind = passed_lib.kind;
}
- if let Some(new_name) = new_name {
+ if let Some(new_name) = &passed_lib.new_name {
lib.name = Some(Symbol::intern(new_name));
}
+ lib.verbatim = passed_lib.verbatim;
return true;
}
}
.collect::<Vec<_>>();
if existing.is_empty() {
// Add if not found
- let new_name = new_name.as_ref().map(|s| &**s); // &Option<String> -> Option<&str>
+ let new_name = passed_lib.new_name.as_ref().map(|s| &**s); // &Option<String> -> Option<&str>
let lib = NativeLib {
- name: Some(Symbol::intern(new_name.unwrap_or(name))),
- kind,
+ name: Some(Symbol::intern(new_name.unwrap_or(&passed_lib.name))),
+ kind: passed_lib.kind,
cfg: None,
foreign_module: None,
wasm_import_module: None,
+ verbatim: passed_lib.verbatim,
};
self.register_native_lib(None, lib);
} else {
.map(Path::new)
.filter(|_| {
// Only spend time on further checks if we have what to translate *to*.
- sess.real_rust_source_base_dir.is_some()
+ sess.opts.real_rust_source_base_dir.is_some()
})
.filter(|virtual_dir| {
// Don't translate away `/rustc/$hash` if we're still remapping to it,
debug!(
"try_to_translate_virtual_to_real(name={:?}): \
virtual_rust_source_base_dir={:?}, real_rust_source_base_dir={:?}",
- name, virtual_rust_source_base_dir, sess.real_rust_source_base_dir,
+ name, virtual_rust_source_base_dir, sess.opts.real_rust_source_base_dir,
);
if let Some(virtual_dir) = virtual_rust_source_base_dir {
- if let Some(real_dir) = &sess.real_rust_source_base_dir {
+ if let Some(real_dir) = &sess.opts.real_rust_source_base_dir {
if let rustc_span::FileName::Real(old_name) = name {
if let rustc_span::RealFileName::Named(one_path) = old_name {
if let Ok(rest) = one_path.strip_prefix(virtual_dir) {
self.root.hash
}
- fn num_def_ids(&self) -> usize {
- self.root.tables.def_keys.size()
- }
-
fn local_def_id(&self, index: DefIndex) -> DefId {
DefId { krate: self.cnum, index }
}
// resolve! Does this work? Unsure! That's what the issue is about
*providers = Providers {
is_dllimport_foreign_item: |tcx, id| match tcx.native_library_kind(id) {
- Some(NativeLibKind::Dylib | NativeLibKind::RawDylib | NativeLibKind::Unspecified) => {
- true
- }
+ Some(
+ NativeLibKind::Dylib { .. } | NativeLibKind::RawDylib | NativeLibKind::Unspecified,
+ ) => true,
_ => false,
},
is_statically_included_foreign_item: |tcx, id| {
- matches!(
- tcx.native_library_kind(id),
- Some(NativeLibKind::StaticBundle | NativeLibKind::StaticNoBundle)
- )
+ matches!(tcx.native_library_kind(id), Some(NativeLibKind::Static { .. }))
},
native_library_kind: |tcx, id| {
tcx.native_libraries(id.krate)
self.get_crate_data(def_id.krate).module_expansion(def_id.index, sess)
}
- pub fn num_def_ids(&self, cnum: CrateNum) -> usize {
- self.get_crate_data(cnum).num_def_ids()
- }
-
pub fn item_attrs(&self, def_id: DefId, sess: &Session) -> Vec<ast::Attribute> {
self.get_crate_data(def_id.krate).get_item_attrs(def_id.index, sess).collect()
}
[] predicates: rustc_middle::ty::PredicateInner<$tcx>,
// HIR query types
- [few] indexed_hir: rustc_middle::hir::map::IndexedHir<$tcx>,
+ [few] indexed_hir: rustc_middle::hir::IndexedHir<$tcx>,
[few] hir_definitions: rustc_hir::definitions::Definitions,
[] hir_owner: rustc_middle::hir::Owner<$tcx>,
[] hir_owner_nodes: rustc_middle::hir::OwnerNodes<$tcx>,
use crate::arena::Arena;
-use crate::hir::map::{Entry, HirOwnerData, Map};
-use crate::hir::{Owner, OwnerNodes, ParentedNode};
+use crate::hir::map::{HirOwnerData, Map};
+use crate::hir::{IndexedHir, Owner, OwnerNodes, ParentedNode};
use crate::ich::StableHashingContext;
-use crate::middle::cstore::CrateStore;
use rustc_data_structures::fingerprint::Fingerprint;
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-use rustc_data_structures::svh::Svh;
use rustc_hir as hir;
+use rustc_hir::def_id::LocalDefId;
use rustc_hir::def_id::CRATE_DEF_INDEX;
-use rustc_hir::def_id::{LocalDefId, LOCAL_CRATE};
-use rustc_hir::definitions::{self, DefPathHash};
+use rustc_hir::definitions;
use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
use rustc_hir::*;
use rustc_index::vec::{Idx, IndexVec};
-use rustc_session::{CrateDisambiguator, Session};
+use rustc_session::Session;
use rustc_span::source_map::SourceMap;
-use rustc_span::{Span, Symbol, DUMMY_SP};
+use rustc_span::{Span, DUMMY_SP};
use std::iter::repeat;
source_map: &'a SourceMap,
map: IndexVec<LocalDefId, HirOwnerData<'hir>>,
+ parenting: FxHashMap<LocalDefId, HirId>,
/// The parent of this node
parent_node: hir::HirId,
definitions: &'a definitions::Definitions,
hcx: StableHashingContext<'a>,
-
- // We are collecting HIR hashes here so we can compute the
- // crate hash from them later on.
- hir_body_nodes: Vec<(DefPathHash, Fingerprint)>,
}
fn insert_vec_map<K: Idx, V: Clone>(map: &mut IndexVec<K, Option<V>>, k: K, v: V) {
fn hash_body(
hcx: &mut StableHashingContext<'_>,
- def_path_hash: DefPathHash,
item_like: impl for<'a> HashStable<StableHashingContext<'a>>,
- hir_body_nodes: &mut Vec<(DefPathHash, Fingerprint)>,
) -> Fingerprint {
- let hash = {
- let mut stable_hasher = StableHasher::new();
- hcx.while_hashing_hir_bodies(true, |hcx| {
- item_like.hash_stable(hcx, &mut stable_hasher);
- });
- stable_hasher.finish()
- };
- hir_body_nodes.push((def_path_hash, hash));
- hash
+ let mut stable_hasher = StableHasher::new();
+ hcx.while_hashing_hir_bodies(true, |hcx| {
+ item_like.hash_stable(hcx, &mut stable_hasher);
+ });
+ stable_hasher.finish()
}
-fn upstream_crates(cstore: &dyn CrateStore) -> Vec<(Symbol, Fingerprint, Svh)> {
- let mut upstream_crates: Vec<_> = cstore
- .crates_untracked()
- .iter()
- .map(|&cnum| {
- let name = cstore.crate_name_untracked(cnum);
- let disambiguator = cstore.crate_disambiguator_untracked(cnum).to_fingerprint();
- let hash = cstore.crate_hash_untracked(cnum);
- (name, disambiguator, hash)
- })
- .collect();
- upstream_crates.sort_unstable_by_key(|&(name, dis, _)| (name.as_str(), dis));
- upstream_crates
+/// Represents an entry and its parent `HirId`.
+#[derive(Copy, Clone, Debug)]
+pub struct Entry<'hir> {
+ parent: HirId,
+ node: Node<'hir>,
}
impl<'a, 'hir> NodeCollector<'a, 'hir> {
definitions: &'a definitions::Definitions,
mut hcx: StableHashingContext<'a>,
) -> NodeCollector<'a, 'hir> {
- let root_mod_def_path_hash =
- definitions.def_path_hash(LocalDefId { local_def_index: CRATE_DEF_INDEX });
-
- let mut hir_body_nodes = Vec::new();
-
let hash = {
let Crate {
ref item,
attrs: _,
} = *krate;
- hash_body(&mut hcx, root_mod_def_path_hash, item, &mut hir_body_nodes)
+ hash_body(&mut hcx, item)
};
let mut collector = NodeCollector {
current_dep_node_owner: LocalDefId { local_def_index: CRATE_DEF_INDEX },
definitions,
hcx,
- hir_body_nodes,
map: (0..definitions.def_index_count())
.map(|_| HirOwnerData { signature: None, with_bodies: None })
.collect(),
+ parenting: FxHashMap::default(),
};
collector.insert_entry(
hir::CRATE_HIR_ID,
collector
}
- pub(super) fn finalize_and_compute_crate_hash(
- mut self,
- crate_disambiguator: CrateDisambiguator,
- cstore: &dyn CrateStore,
- commandline_args_hash: u64,
- ) -> (IndexVec<LocalDefId, HirOwnerData<'hir>>, Svh) {
+ pub(super) fn finalize_and_compute_crate_hash(mut self) -> IndexedHir<'hir> {
// Insert bodies into the map
for (id, body) in self.krate.bodies.iter() {
let bodies = &mut self.map[id.hir_id.owner].with_bodies.as_mut().unwrap().bodies;
assert!(bodies.insert(id.hir_id.local_id, body).is_none());
}
-
- self.hir_body_nodes.sort_unstable_by_key(|bn| bn.0);
-
- let node_hashes = self.hir_body_nodes.iter().fold(
- Fingerprint::ZERO,
- |combined_fingerprint, &(def_path_hash, fingerprint)| {
- combined_fingerprint.combine(def_path_hash.0.combine(fingerprint))
- },
- );
-
- let upstream_crates = upstream_crates(cstore);
-
- // We hash the final, remapped names of all local source files so we
- // don't have to include the path prefix remapping commandline args.
- // If we included the full mapping in the SVH, we could only have
- // reproducible builds by compiling from the same directory. So we just
- // hash the result of the mapping instead of the mapping itself.
- let mut source_file_names: Vec<_> = self
- .source_map
- .files()
- .iter()
- .filter(|source_file| source_file.cnum == LOCAL_CRATE)
- .map(|source_file| source_file.name_hash)
- .collect();
-
- source_file_names.sort_unstable();
-
- let crate_hash_input = (
- ((node_hashes, upstream_crates), source_file_names),
- (commandline_args_hash, crate_disambiguator.to_fingerprint()),
- );
-
- let mut stable_hasher = StableHasher::new();
- crate_hash_input.hash_stable(&mut self.hcx, &mut stable_hasher);
- let crate_hash: Fingerprint = stable_hasher.finish();
-
- let svh = Svh::new(crate_hash.to_smaller_hash());
- (self.map, svh)
+ IndexedHir { map: self.map, parenting: self.parenting }
}
fn insert_entry(&mut self, id: HirId, entry: Entry<'hir>, hash: Fingerprint) {
nodes.hash = hash;
debug_assert!(data.signature.is_none());
- data.signature =
- Some(self.arena.alloc(Owner { parent: entry.parent, node: entry.node }));
+ data.signature = Some(self.arena.alloc(Owner { node: entry.node }));
let dk_parent = self.definitions.def_key(id.owner).parent;
if let Some(dk_parent) = dk_parent {
id.owner, dk_parent, entry.parent,
)
}
+
+ debug_assert_eq!(self.parenting.get(&id.owner), Some(&entry.parent));
}
} else {
assert_eq!(entry.parent.owner, id.owner);
f: F,
) {
let prev_owner = self.current_dep_node_owner;
-
- let def_path_hash = self.definitions.def_path_hash(dep_node_owner);
-
- let hash = hash_body(&mut self.hcx, def_path_hash, item_like, &mut self.hir_body_nodes);
+ let hash = hash_body(&mut self.hcx, item_like);
self.current_dep_node_owner = dep_node_owner;
f(self, hash);
self.current_dep_node_owner = prev_owner;
}
+
+ fn insert_nested(&mut self, item: LocalDefId) {
+ #[cfg(debug_assertions)]
+ {
+ let dk_parent = self.definitions.def_key(item).parent.unwrap();
+ let dk_parent = LocalDefId { local_def_index: dk_parent };
+ let dk_parent = self.definitions.local_def_id_to_hir_id(dk_parent);
+ debug_assert_eq!(
+ dk_parent.owner, self.parent_node.owner,
+ "Different parents for {:?}",
+ item
+ )
+ }
+
+ assert_eq!(self.parenting.insert(item, self.parent_node), None);
+ }
}
impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
fn visit_nested_item(&mut self, item: ItemId) {
debug!("visit_nested_item: {:?}", item);
+ self.insert_nested(item.def_id);
self.visit_item(self.krate.item(item));
}
fn visit_nested_trait_item(&mut self, item_id: TraitItemId) {
+ self.insert_nested(item_id.def_id);
self.visit_trait_item(self.krate.trait_item(item_id));
}
fn visit_nested_impl_item(&mut self, item_id: ImplItemId) {
+ self.insert_nested(item_id.def_id);
self.visit_impl_item(self.krate.impl_item(item_id));
}
fn visit_nested_foreign_item(&mut self, foreign_id: ForeignItemId) {
+ self.insert_nested(foreign_id.def_id);
self.visit_foreign_item(self.krate.foreign_item(foreign_id));
}
self.definitions.local_def_id_to_hir_id(LocalDefId { local_def_index })
});
self.with_parent(parent, |this| {
+ this.insert_nested(macro_def.def_id);
this.with_dep_node_owner(macro_def.def_id, macro_def, |this, hash| {
this.insert_with_hash(
macro_def.span,
use self::collector::NodeCollector;
-use crate::hir::{Owner, OwnerNodes};
+use crate::hir::{HirOwnerData, IndexedHir};
+use crate::middle::cstore::CrateStore;
use crate::ty::TyCtxt;
use rustc_ast as ast;
+use rustc_data_structures::fingerprint::Fingerprint;
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_data_structures::svh::Svh;
use rustc_hir::def::{DefKind, Res};
use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE};
use rustc_hir::intravisit::Visitor;
use rustc_hir::itemlikevisit::ItemLikeVisitor;
use rustc_hir::*;
-use rustc_index::vec::IndexVec;
+use rustc_index::vec::Idx;
use rustc_span::hygiene::MacroKind;
use rustc_span::source_map::Spanned;
use rustc_span::symbol::{kw, Ident, Symbol};
pub mod blocks;
mod collector;
-/// Represents an entry and its parent `HirId`.
-#[derive(Copy, Clone, Debug)]
-pub struct Entry<'hir> {
- parent: HirId,
- node: Node<'hir>,
-}
-
-impl<'hir> Entry<'hir> {
- fn parent_node(self) -> Option<HirId> {
- match self.node {
- Node::Crate(_) => None,
- _ => Some(self.parent),
- }
- }
-}
-
fn fn_decl<'hir>(node: Node<'hir>) -> Option<&'hir FnDecl<'hir>> {
match node {
Node::Item(Item { kind: ItemKind::Fn(sig, _, _), .. })
}
}
-#[derive(Debug)]
-pub(super) struct HirOwnerData<'hir> {
- pub(super) signature: Option<&'hir Owner<'hir>>,
- pub(super) with_bodies: Option<&'hir mut OwnerNodes<'hir>>,
-}
-
-#[derive(Debug)]
-pub struct IndexedHir<'hir> {
- /// The SVH of the local crate.
- pub crate_hash: Svh,
-
- pub(super) map: IndexVec<LocalDefId, HirOwnerData<'hir>>,
-}
-
#[derive(Copy, Clone)]
pub struct Map<'hir> {
pub(super) tcx: TyCtxt<'hir>,
}
self.current_id = parent_id;
- if let Some(entry) = self.map.find_entry(parent_id) {
- return Some((parent_id, entry.node));
+ if let Some(node) = self.map.find(parent_id) {
+ return Some((parent_id, node));
+ }
+ // If this `HirId` doesn't have an entry, skip it and look for its `parent_id`.
+ }
+ }
+}
+
+/// An iterator that walks up the ancestor tree of a given `HirId`.
+/// Constructed using `tcx.hir().parent_owner_iter(hir_id)`.
+pub struct ParentOwnerIterator<'map, 'hir> {
+ current_id: HirId,
+ map: &'map Map<'hir>,
+}
+
+impl<'hir> Iterator for ParentOwnerIterator<'_, 'hir> {
+ type Item = (HirId, Node<'hir>);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ if self.current_id.local_id.index() != 0 {
+ self.current_id.local_id = ItemLocalId::new(0);
+ if let Some(node) = self.map.find(self.current_id) {
+ return Some((self.current_id, node));
+ }
+ }
+ if self.current_id == CRATE_HIR_ID {
+ return None;
+ }
+ loop {
+ // There are nodes that do not have entries, so we need to skip them.
+ let parent_id = self.map.def_key(self.current_id.owner).parent;
+
+ let parent_id = parent_id.map_or(CRATE_HIR_ID.owner, |local_def_index| {
+ let def_id = LocalDefId { local_def_index };
+ self.map.local_def_id_to_hir_id(def_id).owner
+ });
+ self.current_id = HirId::make_owner(parent_id);
+
+ // If this `HirId` doesn't have an entry, skip it and look for its `parent_id`.
+ if let Some(node) = self.map.find(self.current_id) {
+ return Some((self.current_id, node));
}
- // If this `HirId` doesn't have an `Entry`, skip it and look for its `parent_id`.
}
}
}
bug!(
"local_def_id: no entry for `{:?}`, which has a map of `{:?}`",
hir_id,
- self.find_entry(hir_id)
+ self.find(hir_id)
)
})
}
.unwrap_or_else(|| bug!("def_kind: unsupported node: {:?}", local_def_id))
}
- fn find_entry(&self, id: HirId) -> Option<Entry<'hir>> {
+ pub fn find_parent_node(&self, id: HirId) -> Option<HirId> {
if id.local_id == ItemLocalId::from_u32(0) {
- let owner = self.tcx.hir_owner(id.owner);
- owner.map(|owner| Entry { parent: owner.parent, node: owner.node })
+ Some(self.tcx.hir_owner_parent(id.owner))
} else {
- let owner = self.tcx.hir_owner_nodes(id.owner);
- owner.and_then(|owner| {
- let node = owner.nodes[id.local_id].as_ref();
- // FIXME(eddyb) use a single generic type instead of having both
- // `Entry` and `ParentedNode`, which are effectively the same.
- // Alternatively, rewrite code using `Entry` to use `ParentedNode`.
- node.map(|node| Entry {
- parent: HirId { owner: id.owner, local_id: node.parent },
- node: node.node,
- })
- })
+ let owner = self.tcx.hir_owner_nodes(id.owner)?;
+ let node = owner.nodes[id.local_id].as_ref()?;
+ let hir_id = HirId { owner: id.owner, local_id: node.parent };
+ Some(hir_id)
+ }
+ }
+
+ pub fn get_parent_node(&self, hir_id: HirId) -> HirId {
+ self.find_parent_node(hir_id).unwrap_or(CRATE_HIR_ID)
+ }
+
+ /// Retrieves the `Node` corresponding to `id`, returning `None` if cannot be found.
+ pub fn find(&self, id: HirId) -> Option<Node<'hir>> {
+ if id.local_id == ItemLocalId::from_u32(0) {
+ let owner = self.tcx.hir_owner(id.owner)?;
+ Some(owner.node)
+ } else {
+ let owner = self.tcx.hir_owner_nodes(id.owner)?;
+ let node = owner.nodes[id.local_id].as_ref()?;
+ Some(node.node)
}
}
- fn get_entry(&self, id: HirId) -> Entry<'hir> {
- self.find_entry(id).unwrap()
+ /// Retrieves the `Node` corresponding to `id`, panicking if it cannot be found.
+ pub fn get(&self, id: HirId) -> Node<'hir> {
+ self.find(id).unwrap_or_else(|| bug!("couldn't find hir id {} in the HIR map", id))
+ }
+
+ pub fn get_if_local(&self, id: DefId) -> Option<Node<'hir>> {
+ id.as_local().and_then(|id| self.find(self.local_def_id_to_hir_id(id)))
+ }
+
+ pub fn get_generics(&self, id: DefId) -> Option<&'hir Generics<'hir>> {
+ self.get_if_local(id).and_then(|node| match &node {
+ Node::ImplItem(impl_item) => Some(&impl_item.generics),
+ Node::TraitItem(trait_item) => Some(&trait_item.generics),
+ Node::Item(Item {
+ kind:
+ ItemKind::Fn(_, generics, _)
+ | ItemKind::TyAlias(_, generics)
+ | ItemKind::Enum(_, generics)
+ | ItemKind::Struct(_, generics)
+ | ItemKind::Union(_, generics)
+ | ItemKind::Trait(_, _, generics, ..)
+ | ItemKind::TraitAlias(generics, _)
+ | ItemKind::Impl(Impl { generics, .. }),
+ ..
+ }) => Some(generics),
+ _ => None,
+ })
}
pub fn item(&self, id: ItemId) -> &'hir Item<'hir> {
pub fn get_module(&self, module: LocalDefId) -> (&'hir Mod<'hir>, Span, HirId) {
let hir_id = self.local_def_id_to_hir_id(module);
- match self.get_entry(hir_id).node {
+ match self.get(hir_id) {
Node::Item(&Item { span, kind: ItemKind::Mod(ref m), .. }) => (m, span, hir_id),
Node::Crate(item) => (&item, item.inner, hir_id),
node => panic!("not a module: {:?}", node),
}
}
- /// Retrieves the `Node` corresponding to `id`, panicking if it cannot be found.
- pub fn get(&self, id: HirId) -> Node<'hir> {
- self.find(id).unwrap_or_else(|| bug!("couldn't find hir id {} in the HIR map", id))
- }
-
- pub fn get_if_local(&self, id: DefId) -> Option<Node<'hir>> {
- id.as_local().and_then(|id| self.find(self.local_def_id_to_hir_id(id)))
- }
-
- pub fn get_generics(&self, id: DefId) -> Option<&'hir Generics<'hir>> {
- self.get_if_local(id).and_then(|node| match &node {
- Node::ImplItem(impl_item) => Some(&impl_item.generics),
- Node::TraitItem(trait_item) => Some(&trait_item.generics),
- Node::Item(Item {
- kind:
- ItemKind::Fn(_, generics, _)
- | ItemKind::TyAlias(_, generics)
- | ItemKind::Enum(_, generics)
- | ItemKind::Struct(_, generics)
- | ItemKind::Union(_, generics)
- | ItemKind::Trait(_, _, generics, ..)
- | ItemKind::TraitAlias(generics, _)
- | ItemKind::Impl(Impl { generics, .. }),
- ..
- }) => Some(generics),
- _ => None,
- })
- }
-
- /// Retrieves the `Node` corresponding to `id`, returning `None` if cannot be found.
- pub fn find(&self, hir_id: HirId) -> Option<Node<'hir>> {
- self.find_entry(hir_id).map(|entry| entry.node)
- }
-
- /// Similar to `get_parent`; returns the parent HIR Id, or just `hir_id` if there
- /// is no parent. Note that the parent may be `CRATE_HIR_ID`, which is not itself
- /// present in the map, so passing the return value of `get_parent_node` to
- /// `get` may in fact panic.
- /// This function returns the immediate parent in the HIR, whereas `get_parent`
- /// returns the enclosing item. Note that this might not be the actual parent
- /// node in the HIR -- some kinds of nodes are not in the map and these will
- /// never appear as the parent node. Thus, you can always walk the parent nodes
- /// from a node to the root of the HIR (unless you get back the same ID here,
- /// which can happen if the ID is not in the map itself or is just weird).
- pub fn get_parent_node(&self, hir_id: HirId) -> HirId {
- self.get_entry(hir_id).parent_node().unwrap_or(hir_id)
- }
-
/// Returns an iterator for the nodes in the ancestor tree of the `current_id`
/// until the crate root is reached. Prefer this over your own loop using `get_parent_node`.
pub fn parent_iter(&self, current_id: HirId) -> ParentHirIterator<'_, 'hir> {
ParentHirIterator { current_id, map: self }
}
+ /// Returns an iterator for the nodes in the ancestor tree of the `current_id`
+ /// until the crate root is reached. Prefer this over your own loop using `get_parent_node`.
+ pub fn parent_owner_iter(&self, current_id: HirId) -> ParentOwnerIterator<'_, 'hir> {
+ ParentOwnerIterator { current_id, map: self }
+ }
+
/// Checks if the node is left-hand side of an assignment.
pub fn is_lhs(&self, id: HirId) -> bool {
match self.find(self.get_parent_node(id)) {
/// Whether `hir_id` corresponds to a `mod` or a crate.
pub fn is_hir_id_module(&self, hir_id: HirId) -> bool {
matches!(
- self.get_entry(hir_id).node,
+ self.get(hir_id),
Node::Item(Item { kind: ItemKind::Mod(_), .. }) | Node::Crate(..)
)
}
pub fn get_return_block(&self, id: HirId) -> Option<HirId> {
let mut iter = self.parent_iter(id).peekable();
let mut ignore_tail = false;
- if let Some(entry) = self.find_entry(id) {
- if let Node::Expr(Expr { kind: ExprKind::Ret(_), .. }) = entry.node {
+ if let Some(node) = self.find(id) {
+ if let Node::Expr(Expr { kind: ExprKind::Ret(_), .. }) = node {
// When dealing with `return` statements, we don't care about climbing only tail
// expressions.
ignore_tail = true;
/// in the HIR which is recorded by the map and is an item, either an item
/// in a module, trait, or impl.
pub fn get_parent_item(&self, hir_id: HirId) -> HirId {
- for (hir_id, node) in self.parent_iter(hir_id) {
- match node {
- Node::Crate(_)
- | Node::Item(_)
- | Node::ForeignItem(_)
- | Node::TraitItem(_)
- | Node::ImplItem(_) => return hir_id,
- _ => {}
+ for (hir_id, node) in self.parent_owner_iter(hir_id) {
+ if let Node::Crate(_)
+ | Node::Item(_)
+ | Node::ForeignItem(_)
+ | Node::TraitItem(_)
+ | Node::ImplItem(_) = node
+ {
+ return hir_id;
}
}
- hir_id
+ CRATE_HIR_ID
}
/// Returns the `HirId` of `id`'s nearest module parent, or `id` itself if no
/// module parent is in this map.
pub(super) fn get_module_parent_node(&self, hir_id: HirId) -> HirId {
- for (hir_id, node) in self.parent_iter(hir_id) {
+ for (hir_id, node) in self.parent_owner_iter(hir_id) {
if let Node::Item(&Item { kind: ItemKind::Mod(_), .. }) = node {
return hir_id;
}
pub fn get_foreign_abi(&self, hir_id: HirId) -> Abi {
let parent = self.get_parent_item(hir_id);
- if let Some(entry) = self.find_entry(parent) {
- if let Entry {
- node: Node::Item(Item { kind: ItemKind::ForeignMod { abi, .. }, .. }),
- ..
- } = entry
- {
+ if let Some(node) = self.find(parent) {
+ if let Node::Item(Item { kind: ItemKind::ForeignMod { abi, .. }, .. }) = node {
return *abi;
}
}
}
pub fn opt_span(&self, hir_id: HirId) -> Option<Span> {
- let span = match self.find_entry(hir_id)?.node {
+ let span = match self.find(hir_id)? {
Node::Param(param) => param.span,
Node::Item(item) => match &item.kind {
ItemKind::Fn(sig, _, _) => sig.span,
/// Like `hir.span()`, but includes the body of function items
/// (instead of just the function header)
pub fn span_with_body(&self, hir_id: HirId) -> Span {
- match self.find_entry(hir_id).map(|entry| entry.node) {
+ match self.find(hir_id) {
Some(Node::TraitItem(item)) => item.span,
Some(Node::ImplItem(impl_item)) => impl_item.span,
Some(Node::Item(item)) => item.span,
let _prof_timer = tcx.sess.prof.generic_activity("build_hir_map");
- let (map, crate_hash) = {
- let hcx = tcx.create_stable_hashing_context();
+ let hcx = tcx.create_stable_hashing_context();
+ let mut collector =
+ NodeCollector::root(tcx.sess, &**tcx.arena, tcx.untracked_crate, &tcx.definitions, hcx);
+ intravisit::walk_crate(&mut collector, tcx.untracked_crate);
- let mut collector =
- NodeCollector::root(tcx.sess, &**tcx.arena, tcx.untracked_crate, &tcx.definitions, hcx);
- intravisit::walk_crate(&mut collector, tcx.untracked_crate);
+ let map = collector.finalize_and_compute_crate_hash();
+ tcx.arena.alloc(map)
+}
- let crate_disambiguator = tcx.sess.local_crate_disambiguator();
- let cmdline_args = tcx.sess.opts.dep_tracking_hash();
- collector.finalize_and_compute_crate_hash(crate_disambiguator, &*tcx.cstore, cmdline_args)
- };
+pub(super) fn crate_hash(tcx: TyCtxt<'_>, crate_num: CrateNum) -> Svh {
+ let mut hir_body_nodes: Vec<_> = tcx
+ .index_hir(crate_num)
+ .map
+ .iter_enumerated()
+ .filter_map(|(def_id, hod)| {
+ let def_path_hash = tcx.definitions.def_path_hash(def_id);
+ let hash = hod.with_bodies.as_ref()?.hash;
+ Some((def_path_hash, hash))
+ })
+ .collect();
+ hir_body_nodes.sort_unstable_by_key(|bn| bn.0);
- tcx.arena.alloc(IndexedHir { crate_hash, map })
+ let node_hashes = hir_body_nodes.iter().fold(
+ Fingerprint::ZERO,
+ |combined_fingerprint, &(def_path_hash, fingerprint)| {
+ combined_fingerprint.combine(def_path_hash.0.combine(fingerprint))
+ },
+ );
+
+ let upstream_crates = upstream_crates(&*tcx.cstore);
+
+ // We hash the final, remapped names of all local source files so we
+ // don't have to include the path prefix remapping commandline args.
+ // If we included the full mapping in the SVH, we could only have
+ // reproducible builds by compiling from the same directory. So we just
+ // hash the result of the mapping instead of the mapping itself.
+ let mut source_file_names: Vec<_> = tcx
+ .sess
+ .source_map()
+ .files()
+ .iter()
+ .filter(|source_file| source_file.cnum == LOCAL_CRATE)
+ .map(|source_file| source_file.name_hash)
+ .collect();
+
+ source_file_names.sort_unstable();
+
+ let mut hcx = tcx.create_stable_hashing_context();
+ let mut stable_hasher = StableHasher::new();
+ node_hashes.hash_stable(&mut hcx, &mut stable_hasher);
+ upstream_crates.hash_stable(&mut hcx, &mut stable_hasher);
+ source_file_names.hash_stable(&mut hcx, &mut stable_hasher);
+ tcx.sess.opts.dep_tracking_hash(true).hash_stable(&mut hcx, &mut stable_hasher);
+ tcx.sess.local_crate_disambiguator().to_fingerprint().hash_stable(&mut hcx, &mut stable_hasher);
+
+ let crate_hash: Fingerprint = stable_hasher.finish();
+ Svh::new(crate_hash.to_smaller_hash())
+}
+
+fn upstream_crates(cstore: &dyn CrateStore) -> Vec<(Symbol, Fingerprint, Svh)> {
+ let mut upstream_crates: Vec<_> = cstore
+ .crates_untracked()
+ .iter()
+ .map(|&cnum| {
+ let name = cstore.crate_name_untracked(cnum);
+ let disambiguator = cstore.crate_disambiguator_untracked(cnum).to_fingerprint();
+ let hash = cstore.crate_hash_untracked(cnum);
+ (name, disambiguator, hash)
+ })
+ .collect();
+ upstream_crates.sort_unstable_by_key(|&(name, dis, _)| (name.as_str(), dis));
+ upstream_crates
}
fn hir_id_to_string(map: &Map<'_>, id: HirId) -> String {
use rustc_span::DUMMY_SP;
use std::collections::BTreeMap;
+#[derive(Debug)]
+struct HirOwnerData<'hir> {
+ signature: Option<&'hir Owner<'hir>>,
+ with_bodies: Option<&'hir mut OwnerNodes<'hir>>,
+}
+
+#[derive(Debug)]
+pub struct IndexedHir<'hir> {
+ map: IndexVec<LocalDefId, HirOwnerData<'hir>>,
+ parenting: FxHashMap<LocalDefId, HirId>,
+}
+
#[derive(Debug)]
pub struct Owner<'tcx> {
- parent: HirId,
node: Node<'tcx>,
}
impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Owner<'tcx> {
fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
- let Owner { parent, node } = self;
- hcx.while_hashing_hir_bodies(false, |hcx| {
- parent.hash_stable(hcx, hasher);
- node.hash_stable(hcx, hasher);
- });
+ let Owner { node } = self;
+ hcx.while_hashing_hir_bodies(false, |hcx| node.hash_stable(hcx, hasher));
}
}
};
providers.hir_crate = |tcx, _| tcx.untracked_crate;
providers.index_hir = map::index_hir;
+ providers.crate_hash = map::crate_hash;
providers.hir_module_items = |tcx, id| &tcx.untracked_crate.modules[&id];
providers.hir_owner = |tcx, id| tcx.index_hir(LOCAL_CRATE).map[id].signature;
providers.hir_owner_nodes = |tcx, id| tcx.index_hir(LOCAL_CRATE).map[id].with_bodies.as_deref();
+ providers.hir_owner_parent = |tcx, id| {
+ let index = tcx.index_hir(LOCAL_CRATE);
+ index.parenting.get(&id).copied().unwrap_or(CRATE_HIR_ID)
+ };
providers.hir_attrs = |tcx, id| AttributeMap { map: &tcx.untracked_crate.attrs, prefix: id };
providers.def_span = |tcx, def_id| tcx.hir().span_if_local(def_id).unwrap_or(DUMMY_SP);
providers.fn_arg_names = |tcx, id| {
#![feature(control_flow_enum)]
#![feature(associated_type_defaults)]
#![feature(iter_zip)]
+#![feature(thread_local_const_init)]
#![recursion_limit = "512"]
#[macro_use]
// emit shouldn't be automatically fixed by rustfix.
err.allow_suggestions(false);
- // If this is a future incompatible lint it'll become a hard error, so
- // we have to emit *something*. Also, if this lint occurs in the
- // expansion of a macro from an external crate, allow individual lints
- // to opt-out from being reported.
- if future_incompatible.is_none() && !lint.report_in_external_macro {
+ // If this is a future incompatible that is not an edition fixing lint
+ // it'll become a hard error, so we have to emit *something*. Also,
+ // if this lint occurs in the expansion of a macro from an external crate,
+ // allow individual lints to opt-out from being reported.
+ let not_future_incompatible =
+ future_incompatible.map(|f| f.edition.is_some()).unwrap_or(true);
+ if not_future_incompatible && !lint.report_in_external_macro {
err.cancel();
// Don't continue further, since we don't want to have
// `diag_span_note_once` called for a diagnostic that isn't emitted.
pub cfg: Option<ast::MetaItem>,
pub foreign_module: Option<DefId>,
pub wasm_import_module: Option<Symbol>,
+ pub verbatim: Option<bool>,
}
#[derive(Clone, TyEncodable, TyDecodable, HashStable, Debug)]
#[derive(Debug, Copy, Clone, TyEncodable, TyDecodable, HashStable)]
pub enum CheckInAllocMsg {
MemoryAccessTest,
- NullPointerTest,
PointerArithmeticTest,
InboundsTest,
}
"{}",
match *self {
CheckInAllocMsg::MemoryAccessTest => "memory access",
- CheckInAllocMsg::NullPointerTest => "NULL pointer test",
CheckInAllocMsg::PointerArithmeticTest => "pointer arithmetic",
CheckInAllocMsg::InboundsTest => "inbounds test",
}
ptr.alloc_id,
allocation_size.bytes()
),
- DanglingIntPointer(_, CheckInAllocMsg::NullPointerTest) => {
- write!(f, "NULL pointer is not allowed for this operation")
+ DanglingIntPointer(_, CheckInAllocMsg::InboundsTest) => {
+ write!(f, "null pointer is not allowed for this operation")
}
DanglingIntPointer(i, msg) => {
write!(f, "{} failed: 0x{:x} is not a valid pointer", msg, i)
BorrowKind::Mut { allow_two_phase_borrow } => allow_two_phase_borrow,
}
}
+
+ pub fn describe_mutability(&self) -> String {
+ match *self {
+ BorrowKind::Shared | BorrowKind::Shallow | BorrowKind::Unique => {
+ "immutable".to_string()
+ }
+ BorrowKind::Mut { .. } => "mutable".to_string(),
+ }
+ }
}
///////////////////////////////////////////////////////////////////////////
}
/// Format the message arguments for the `assert(cond, msg..)` terminator in MIR printing.
- fn fmt_assert_args<W: Write>(&self, f: &mut W) -> fmt::Result
+ pub fn fmt_assert_args<W: Write>(&self, f: &mut W) -> fmt::Result
where
O: Debug,
{
};
let mut struct_fmt = fmt.debug_struct(&name);
+ // FIXME(project-rfc-2229#48): This should be a list of capture names/places
if let Some(upvars) = tcx.upvars_mentioned(def_id) {
for (&var_id, place) in iter::zip(upvars.keys(), places) {
let var_name = tcx.hir().name(var_id);
let name = format!("[generator@{:?}]", tcx.hir().span(hir_id));
let mut struct_fmt = fmt.debug_struct(&name);
+ // FIXME(project-rfc-2229#48): This should be a list of capture names/places
if let Some(upvars) = tcx.upvars_mentioned(def_id) {
for (&var_id, place) in iter::zip(upvars.keys(), places) {
let var_name = tcx.hir().name(var_id);
use rustc_data_structures::fingerprint::Fingerprint;
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
+use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
use rustc_hir::{HirId, ItemId};
use rustc_session::config::OptLevel;
use rustc_span::source_map::Span;
// indicator, then we'll be creating a globally shared version.
if tcx.codegen_fn_attrs(instance.def_id()).contains_extern_indicator()
|| !instance.def.generates_cgu_internal_copy(tcx)
- || Some(instance.def_id()) == entry_def_id.map(LocalDefId::to_def_id)
+ || Some(instance.def_id()) == entry_def_id
{
return InstantiationMode::GloballyShared { may_conflict: false };
}
),
DerefOfRawPointer => (
"dereference of raw pointer",
- "raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules \
+ "raw pointers may be null, dangling or unaligned; they can violate aliasing rules \
and cause data races: all of these are undefined behavior",
),
AssignToDroppingUnionField => (
/// The indexed HIR. This can be conveniently accessed by `tcx.hir()`.
/// Avoid calling this query directly.
- query index_hir(_: CrateNum) -> &'tcx map::IndexedHir<'tcx> {
+ query index_hir(_: CrateNum) -> &'tcx crate::hir::IndexedHir<'tcx> {
eval_always
no_hash
desc { "index HIR" }
desc { |tcx| "HIR owner of `{}`", tcx.def_path_str(key.to_def_id()) }
}
+ /// Gives access to the HIR node's parent for the HIR owner `key`.
+ ///
+ /// This can be conveniently accessed by methods on `tcx.hir()`.
+ /// Avoid calling this query directly.
+ query hir_owner_parent(key: LocalDefId) -> hir::HirId {
+ eval_always
+ desc { |tcx| "HIR parent of `{}`", tcx.def_path_str(key.to_def_id()) }
+ }
+
/// Gives access to the HIR nodes and bodies inside the HIR owner `key`.
///
/// This can be conveniently accessed by methods on `tcx.hir()`.
/// Identifies the entry-point (e.g., the `main` function) for a given
/// crate, returning `None` if there is no entry point (such as for library crates).
- query entry_fn(_: CrateNum) -> Option<(LocalDefId, EntryFnType)> {
+ query entry_fn(_: CrateNum) -> Option<(DefId, EntryFnType)> {
desc { "looking up the entry function of a crate" }
}
query plugin_registrar_fn(_: CrateNum) -> Option<DefId> {
}
impl CapturedPlace<'tcx> {
+ pub fn to_string(&self, tcx: TyCtxt<'tcx>) -> String {
+ place_to_string_for_capture(tcx, &self.place)
+ }
+
/// Returns the hir-id of the root variable for the captured place.
/// e.g., if `a.b.c` was captured, would return the hir-id for `a`.
pub fn get_root_variable(&self) -> hir::HirId {
}
}
+ /// Return span pointing to use that resulted in selecting the captured path
+ pub fn get_path_span(&self, tcx: TyCtxt<'tcx>) -> Span {
+ if let Some(path_expr_id) = self.info.path_expr_id {
+ tcx.hir().span(path_expr_id)
+ } else if let Some(capture_kind_expr_id) = self.info.capture_kind_expr_id {
+ tcx.hir().span(capture_kind_expr_id)
+ } else {
+ // Fallback on upvars mentioned if neither path or capture expr id is captured
+
+ // Safe to unwrap since we know this place is captured by the closure, therefore the closure must have upvars.
+ tcx.upvars_mentioned(self.get_closure_local_def_id()).unwrap()
+ [&self.get_root_variable()]
+ .span
+ }
+ }
+
/// Return span pointing to use that resulted in selecting the current capture kind
pub fn get_capture_kind_span(&self, tcx: TyCtxt<'tcx>) -> Span {
if let Some(capture_kind_expr_id) = self.info.capture_kind_expr_id {
use crate::ty::{
self, AdtDef, AdtKind, Binder, BindingMode, BoundVar, CanonicalPolyFnSig, Const, ConstVid,
DefIdTree, ExistentialPredicate, FloatTy, FloatVar, FloatVid, GenericParamDefKind, InferConst,
- InferTy, IntTy, IntVar, IntVid, List, ParamConst, ParamTy, PolyFnSig, Predicate,
- PredicateInner, PredicateKind, ProjectionTy, Region, RegionKind, ReprOptions,
+ InferTy, IntTy, IntVar, IntVid, List, MainDefinition, ParamConst, ParamTy, PolyFnSig,
+ Predicate, PredicateInner, PredicateKind, ProjectionTy, Region, RegionKind, ReprOptions,
TraitObjectVisitor, Ty, TyKind, TyS, TyVar, TyVid, TypeAndMut, UintTy, Visibility,
};
use rustc_ast as ast;
layout_interner: ShardedHashMap<&'tcx Layout, ()>,
output_filenames: Arc<OutputFilenames>,
+
+ pub main_def: Option<MainDefinition>,
}
impl<'tcx> TyCtxt<'tcx> {
const_stability_interner: Default::default(),
alloc_map: Lock::new(interpret::AllocMap::new()),
output_filenames: Arc::new(output_filenames.clone()),
+ main_def: resolutions.main_def,
}
}
#[cfg(not(parallel_compiler))]
thread_local! {
/// A thread local variable that stores a pointer to the current `ImplicitCtxt`.
- static TLV: Cell<usize> = Cell::new(0);
+ static TLV: Cell<usize> = const { Cell::new(0) };
}
/// Sets TLV to `value` during the call to `f`.
{
let mut computation = FlagComputation::new();
+ if !value.bound_vars().is_empty() {
+ computation.flags = computation.flags | TypeFlags::HAS_RE_LATE_BOUND;
+ }
+
f(&mut computation, value.skip_binder());
self.add_flags(computation.flags);
&ty::Infer(infer) => {
self.add_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
match infer {
- ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_) => {}
+ ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_) => {
+ self.add_flags(TypeFlags::HAS_TY_FRESH)
+ }
ty::TyVar(_) | ty::IntVar(_) | ty::FloatVar(_) => {
self.add_flags(TypeFlags::HAS_TY_INFER)
ty::ConstKind::Infer(infer) => {
self.add_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
match infer {
- InferConst::Fresh(_) => {}
+ InferConst::Fresh(_) => self.add_flags(TypeFlags::HAS_CT_FRESH),
InferConst::Var(_) => self.add_flags(TypeFlags::HAS_CT_INFER),
}
}
/// Extern prelude entries. The value is `true` if the entry was introduced
/// via `extern crate` item and not `--extern` option or compiler built-in.
pub extern_prelude: FxHashMap<Symbol, bool>,
+ pub main_def: Option<MainDefinition>,
+}
+
+#[derive(Clone, Copy)]
+pub struct MainDefinition {
+ pub res: Res<ast::NodeId>,
+ pub is_import: bool,
+ pub span: Span,
+}
+
+impl MainDefinition {
+ pub fn opt_fn_def_id(self) -> Option<DefId> {
+ if let Res::Def(DefKind::Fn, def_id) = self.res { Some(def_id) } else { None }
+ }
}
/// The "header" of an impl is everything outside the body: a Self type, a trait
}
thread_local! {
- static FORCE_IMPL_FILENAME_LINE: Cell<bool> = Cell::new(false);
- static SHOULD_PREFIX_WITH_CRATE: Cell<bool> = Cell::new(false);
- static NO_TRIMMED_PATH: Cell<bool> = Cell::new(false);
- static NO_QUERIES: Cell<bool> = Cell::new(false);
+ static FORCE_IMPL_FILENAME_LINE: Cell<bool> = const { Cell::new(false) };
+ static SHOULD_PREFIX_WITH_CRATE: Cell<bool> = const { Cell::new(false) };
+ static NO_TRIMMED_PATH: Cell<bool> = const { Cell::new(false) };
+ static NO_QUERIES: Cell<bool> = const { Cell::new(false) };
}
/// Avoids running any queries during any prints that occur
use crate::dep_graph;
use crate::hir::exports::Export;
-use crate::hir::map;
use crate::infer::canonical::{self, Canonical};
use crate::lint::LintLevelMap;
use crate::middle::codegen_fn_attrs::CodegenFnAttrs;
assert!(Q::query_state(tcx).all_inactive());
let cache = Q::query_cache(tcx);
- cache.iter_results(|results| {
- for (key, value, dep_node) in results {
- if Q::cache_on_disk(tcx, &key, Some(value)) {
- let dep_node = SerializedDepNodeIndex::new(dep_node.index());
-
- // Record position of the cache entry.
- query_result_index
- .push((dep_node, AbsoluteBytePos::new(encoder.encoder.position())));
-
- // Encode the type check tables with the `SerializedDepNodeIndex`
- // as tag.
- encoder.encode_tagged(dep_node, value)?;
+ let mut res = Ok(());
+ cache.iter_results(&mut |key, value, dep_node| {
+ if res.is_err() {
+ return;
+ }
+ if Q::cache_on_disk(tcx, &key, Some(value)) {
+ let dep_node = SerializedDepNodeIndex::new(dep_node.index());
+
+ // Record position of the cache entry.
+ query_result_index.push((dep_node, AbsoluteBytePos::new(encoder.encoder.position())));
+
+ // Encode the type check tables with the `SerializedDepNodeIndex`
+ // as tag.
+ match encoder.encode_tagged(dep_node, value) {
+ Ok(()) => {}
+ Err(e) => {
+ res = Err(e);
+ }
}
}
- Ok(())
- })
+ });
+
+ res
}
);
err.span_label(span, format!("use of possibly-uninitialized {}", item_msg));
- use_spans.var_span_label(
+ use_spans.var_span_label_path_only(
&mut err,
format!("{} occurs due to use{}", desired_action.as_noun(), use_spans.describe()),
);
partially_str,
move_spans.describe()
),
+ "moved",
);
}
}
}
}
- use_spans.var_span_label(
+ use_spans.var_span_label_path_only(
&mut err,
format!("{} occurs due to use{}", desired_action.as_noun(), use_spans.describe()),
);
err.span_label(borrow_span, format!("borrow of {} occurs here", borrow_msg));
err.span_label(span, format!("move out of {} occurs here", value_msg));
- borrow_spans.var_span_label(
+ borrow_spans.var_span_label_path_only(
&mut err,
format!("borrow occurs due to use{}", borrow_spans.describe()),
);
- move_spans
- .var_span_label(&mut err, format!("move occurs due to use{}", move_spans.describe()));
+ move_spans.var_span_label(
+ &mut err,
+ format!("move occurs due to use{}", move_spans.describe()),
+ "moved",
+ );
self.explain_why_borrow_contains_point(location, borrow, None)
.add_explanation_to_diagnostic(
let use_spans = self.move_spans(place.as_ref(), location);
let span = use_spans.var_or_use();
+ // If the attempted use is in a closure then we do not care about the path span of the place we are currently trying to use
+ // we call `var_span_label` on `borrow_spans` to annotate if the existing borrow was in a closure
let mut err = self.cannot_use_when_mutably_borrowed(
span,
&self.describe_any_place(place.as_ref()),
&self.describe_any_place(borrow.borrowed_place.as_ref()),
);
- borrow_spans.var_span_label(&mut err, {
- let place = &borrow.borrowed_place;
- let desc_place = self.describe_any_place(place.as_ref());
- format!("borrow occurs due to use of {}{}", desc_place, borrow_spans.describe())
- });
+ borrow_spans.var_span_label(
+ &mut err,
+ {
+ let place = &borrow.borrowed_place;
+ let desc_place = self.describe_any_place(place.as_ref());
+ format!("borrow occurs due to use of {}{}", desc_place, borrow_spans.describe())
+ },
+ "mutable",
+ );
self.explain_why_borrow_contains_point(location, borrow, None)
.add_explanation_to_diagnostic(
desc_place,
borrow_spans.describe(),
),
+ "immutable",
);
return err;
if issued_spans == borrow_spans {
borrow_spans.var_span_label(
&mut err,
- format!("borrows occur due to use of {}{}", desc_place, borrow_spans.describe()),
+ format!("borrows occur due to use of {}{}", desc_place, borrow_spans.describe(),),
+ gen_borrow_kind.describe_mutability(),
);
} else {
let borrow_place = &issued_borrow.borrowed_place;
borrow_place_desc,
issued_spans.describe(),
),
+ issued_borrow.kind.describe_mutability(),
);
borrow_spans.var_span_label(
desc_place,
borrow_spans.describe(),
),
+ gen_borrow_kind.describe_mutability(),
);
}
self.prefixes(borrow.borrowed_place.as_ref(), PrefixSet::All).last().unwrap();
let borrow_spans = self.retrieve_borrow_spans(borrow);
- let borrow_span = borrow_spans.var_or_use();
+ let borrow_span = borrow_spans.var_or_use_path_span();
assert!(root_place.projection.is_empty());
let proper_span = self.body.local_decls[root_place.local].source_info.span;
location, name, borrow, drop_span, borrow_spans
);
- let borrow_span = borrow_spans.var_or_use();
+ let borrow_span = borrow_spans.var_or_use_path_span();
if let BorrowExplanation::MustBeValidFor {
category,
span,
loan_spans.var_span_label(
&mut err,
format!("borrow occurs due to use{}", loan_spans.describe()),
+ loan.kind.describe_mutability(),
);
err.buffer(&mut self.errors_buffer);
let mut err = self.cannot_assign_to_borrowed(span, loan_span, &descr_place);
- loan_spans
- .var_span_label(&mut err, format!("borrow occurs due to use{}", loan_spans.describe()));
+ loan_spans.var_span_label(
+ &mut err,
+ format!("borrow occurs due to use{}", loan_spans.describe()),
+ loan.kind.describe_mutability(),
+ );
self.explain_why_borrow_contains_point(location, loan, None).add_explanation_to_diagnostic(
self.infcx.tcx,
#[derive(Debug)]
pub(in crate::borrow_check) enum BorrowExplanation {
- UsedLater(LaterUseKind, Span),
- UsedLaterInLoop(LaterUseKind, Span),
+ UsedLater(LaterUseKind, Span, Option<Span>),
+ UsedLaterInLoop(LaterUseKind, Span, Option<Span>),
UsedLaterWhenDropped {
drop_loc: Location,
dropped_local: Local,
borrow_span: Option<Span>,
) {
match *self {
- BorrowExplanation::UsedLater(later_use_kind, var_or_use_span) => {
+ BorrowExplanation::UsedLater(later_use_kind, var_or_use_span, path_span) => {
let message = match later_use_kind {
LaterUseKind::TraitCapture => "captured here by trait object",
LaterUseKind::ClosureCapture => "captured here by closure",
LaterUseKind::FakeLetRead => "stored here",
LaterUseKind::Other => "used here",
};
- if !borrow_span.map_or(false, |sp| sp.overlaps(var_or_use_span)) {
- err.span_label(
- var_or_use_span,
- format!("{}borrow later {}", borrow_desc, message),
- );
+ // We can use `var_or_use_span` if either `path_span` is not present, or both spans are the same
+ if path_span.map(|path_span| path_span == var_or_use_span).unwrap_or(true) {
+ if borrow_span.map(|sp| !sp.overlaps(var_or_use_span)).unwrap_or(true) {
+ err.span_label(
+ var_or_use_span,
+ format!("{}borrow later {}", borrow_desc, message),
+ );
+ }
+ } else {
+ // path_span must be `Some` as otherwise the if condition is true
+ let path_span = path_span.unwrap();
+ // path_span is only present in the case of closure capture
+ assert!(matches!(later_use_kind, LaterUseKind::ClosureCapture));
+ if !borrow_span.map_or(false, |sp| sp.overlaps(var_or_use_span)) {
+ let path_label = "used here by closure";
+ let capture_kind_label = message;
+ err.span_label(
+ var_or_use_span,
+ format!("{}borrow later {}", borrow_desc, capture_kind_label),
+ );
+ err.span_label(path_span, path_label);
+ }
}
}
- BorrowExplanation::UsedLaterInLoop(later_use_kind, var_or_use_span) => {
+ BorrowExplanation::UsedLaterInLoop(later_use_kind, var_or_use_span, path_span) => {
let message = match later_use_kind {
LaterUseKind::TraitCapture => {
"borrow captured here by trait object, in later iteration of loop"
LaterUseKind::FakeLetRead => "borrow later stored here",
LaterUseKind::Other => "borrow used here, in later iteration of loop",
};
- err.span_label(var_or_use_span, format!("{}{}", borrow_desc, message));
+ // We can use `var_or_use_span` if either `path_span` is not present, or both spans are the same
+ if path_span.map(|path_span| path_span == var_or_use_span).unwrap_or(true) {
+ err.span_label(var_or_use_span, format!("{}{}", borrow_desc, message));
+ } else {
+ // path_span must be `Some` as otherwise the if condition is true
+ let path_span = path_span.unwrap();
+ // path_span is only present in the case of closure capture
+ assert!(matches!(later_use_kind, LaterUseKind::ClosureCapture));
+ if borrow_span.map(|sp| !sp.overlaps(var_or_use_span)).unwrap_or(true) {
+ let path_label = "used here by closure";
+ let capture_kind_label = message;
+ err.span_label(
+ var_or_use_span,
+ format!("{}borrow later {}", borrow_desc, capture_kind_label),
+ );
+ err.span_label(path_span, path_label);
+ }
+ }
}
BorrowExplanation::UsedLaterWhenDropped {
drop_loc,
let borrow_location = location;
if self.is_use_in_later_iteration_of_loop(borrow_location, location) {
let later_use = self.later_use_kind(borrow, spans, location);
- BorrowExplanation::UsedLaterInLoop(later_use.0, later_use.1)
+ BorrowExplanation::UsedLaterInLoop(later_use.0, later_use.1, later_use.2)
} else {
// Check if the location represents a `FakeRead`, and adapt the error
// message to the `FakeReadCause` it is from: in particular,
// the ones inserted in optimized `let var = <expr>` patterns.
let later_use = self.later_use_kind(borrow, spans, location);
- BorrowExplanation::UsedLater(later_use.0, later_use.1)
+ BorrowExplanation::UsedLater(later_use.0, later_use.1, later_use.2)
}
}
}
/// Determine how the borrow was later used.
+ /// First span returned points to the location of the conflicting use
+ /// Second span if `Some` is returned in the case of closures and points
+ /// to the use of the path
fn later_use_kind(
&self,
borrow: &BorrowData<'tcx>,
use_spans: UseSpans<'tcx>,
location: Location,
- ) -> (LaterUseKind, Span) {
+ ) -> (LaterUseKind, Span, Option<Span>) {
match use_spans {
- UseSpans::ClosureUse { var_span, .. } => {
+ UseSpans::ClosureUse { capture_kind_span, path_span, .. } => {
// Used in a closure.
- (LaterUseKind::ClosureCapture, var_span)
+ (LaterUseKind::ClosureCapture, capture_kind_span, Some(path_span))
}
UseSpans::PatUse(span)
| UseSpans::OtherUse(span)
}
}
};
- return (LaterUseKind::Call, function_span);
+ return (LaterUseKind::Call, function_span, None);
} else {
LaterUseKind::Other
}
LaterUseKind::Other
};
- (kind, span)
+ (kind, span, None)
}
}
}
Span,
};
use rustc_target::abi::VariantIdx;
-use std::iter;
use super::borrow_set::BorrowData;
use super::MirBorrowckCtxt;
PlaceRef { local, projection: [proj_base @ .., elem] } => {
match elem {
ProjectionElem::Deref => {
- // FIXME(project-rfc_2229#36): print capture precisely here.
let upvar_field_projection = self.is_upvar_field_projection(place);
if let Some(field) = upvar_field_projection {
let var_index = field.index();
- let name = self.upvars[var_index].name.to_string();
+ let name = self.upvars[var_index].place.to_string(self.infcx.tcx);
if self.upvars[var_index].by_ref {
buf.push_str(&name);
} else {
let upvar_field_projection = self.is_upvar_field_projection(place);
if let Some(field) = upvar_field_projection {
let var_index = field.index();
- let name = self.upvars[var_index].name.to_string();
+ let name = self.upvars[var_index].place.to_string(self.infcx.tcx);
buf.push_str(&name);
} else {
let field_name = self
/// The span of the args of the closure, including the `move` keyword if
/// it's present.
args_span: Span,
- /// The span of the first use of the captured variable inside the closure.
- var_span: Span,
+ /// The span of the use resulting in capture kind
+ /// Check `ty::CaptureInfo` for more details
+ capture_kind_span: Span,
+ /// The span of the use resulting in the captured path
+ /// Check `ty::CaptureInfo` for more details
+ path_span: Span,
},
/// The access is caused by using a variable as the receiver of a method
/// that takes 'self'
}
}
+ /// Returns the span of `self`, in the case of a `ClosureUse` returns the `path_span`
+ pub(super) fn var_or_use_path_span(self) -> Span {
+ match self {
+ UseSpans::ClosureUse { path_span: span, .. }
+ | UseSpans::PatUse(span)
+ | UseSpans::OtherUse(span) => span,
+ UseSpans::FnSelfUse {
+ fn_call_span, kind: FnSelfUseKind::DerefCoercion { .. }, ..
+ } => fn_call_span,
+ UseSpans::FnSelfUse { var_span, .. } => var_span,
+ }
+ }
+
+ /// Returns the span of `self`, in the case of a `ClosureUse` returns the `capture_kind_span`
pub(super) fn var_or_use(self) -> Span {
match self {
- UseSpans::ClosureUse { var_span: span, .. }
+ UseSpans::ClosureUse { capture_kind_span: span, .. }
| UseSpans::PatUse(span)
| UseSpans::OtherUse(span) => span,
UseSpans::FnSelfUse {
}
}
+ // Add a span label to the use of the captured variable, if it exists.
+ // only adds label to the `path_span`
+ pub(super) fn var_span_label_path_only(
+ self,
+ err: &mut DiagnosticBuilder<'_>,
+ message: impl Into<String>,
+ ) {
+ if let UseSpans::ClosureUse { path_span, .. } = self {
+ err.span_label(path_span, message);
+ }
+ }
+
// Add a span label to the use of the captured variable, if it exists.
pub(super) fn var_span_label(
self,
err: &mut DiagnosticBuilder<'_>,
message: impl Into<String>,
+ kind_desc: impl Into<String>,
) {
- if let UseSpans::ClosureUse { var_span, .. } = self {
- err.span_label(var_span, message);
+ if let UseSpans::ClosureUse { capture_kind_span, path_span, .. } = self {
+ if capture_kind_span == path_span {
+ err.span_label(capture_kind_span, message);
+ } else {
+ let capture_kind_label =
+ format!("capture is {} because of use here", kind_desc.into());
+ let path_label = message;
+ err.span_label(capture_kind_span, capture_kind_label);
+ err.span_label(path_span, path_label);
+ }
}
}
box AggregateKind::Closure(def_id, _)
| box AggregateKind::Generator(def_id, _, _) => {
debug!("move_spans: def_id={:?} places={:?}", def_id, places);
- if let Some((args_span, generator_kind, var_span)) =
+ if let Some((args_span, generator_kind, capture_kind_span, path_span)) =
self.closure_span(*def_id, moved_place, places)
{
- return ClosureUse { generator_kind, args_span, var_span };
+ return ClosureUse {
+ generator_kind,
+ args_span,
+ capture_kind_span,
+ path_span,
+ };
}
}
_ => {}
| FakeReadCause::ForLet(Some(closure_def_id)) => {
debug!("move_spans: def_id={:?} place={:?}", closure_def_id, place);
let places = &[Operand::Move(*place)];
- if let Some((args_span, generator_kind, var_span)) =
+ if let Some((args_span, generator_kind, capture_kind_span, path_span)) =
self.closure_span(closure_def_id, moved_place, places)
{
- return ClosureUse { generator_kind, args_span, var_span };
+ return ClosureUse {
+ generator_kind,
+ args_span,
+ capture_kind_span,
+ path_span,
+ };
}
}
_ => {}
"borrow_spans: def_id={:?} is_generator={:?} places={:?}",
def_id, is_generator, places
);
- if let Some((args_span, generator_kind, var_span)) =
+ if let Some((args_span, generator_kind, capture_kind_span, path_span)) =
self.closure_span(*def_id, Place::from(target).as_ref(), places)
{
- return ClosureUse { generator_kind, args_span, var_span };
+ return ClosureUse { generator_kind, args_span, capture_kind_span, path_span };
} else {
return OtherUse(use_span);
}
OtherUse(use_span)
}
- /// Finds the span of a captured variable within a closure or generator.
+ /// Finds the spans of a captured place within a closure or generator.
+ /// The first span is the location of the use resulting in the capture kind of the capture
+ /// The second span is the location the use resulting in the captured path of the capture
fn closure_span(
&self,
def_id: DefId,
target_place: PlaceRef<'tcx>,
places: &[Operand<'tcx>],
- ) -> Option<(Span, Option<GeneratorKind>, Span)> {
+ ) -> Option<(Span, Option<GeneratorKind>, Span, Span)> {
debug!(
"closure_span: def_id={:?} target_place={:?} places={:?}",
def_id, target_place, places
let expr = &self.infcx.tcx.hir().expect_expr(hir_id).kind;
debug!("closure_span: hir_id={:?} expr={:?}", hir_id, expr);
if let hir::ExprKind::Closure(.., body_id, args_span, _) = expr {
- for (captured_place, place) in iter::zip(
- self.infcx.tcx.typeck(def_id.expect_local()).closure_min_captures_flattened(def_id),
- places,
- ) {
- let upvar_hir_id = captured_place.get_root_variable();
- //FIXME(project-rfc-2229#8): Use better span from captured_place
- let span = self.infcx.tcx.upvars_mentioned(local_did)?[&upvar_hir_id].span;
+ for (captured_place, place) in self
+ .infcx
+ .tcx
+ .typeck(def_id.expect_local())
+ .closure_min_captures_flattened(def_id)
+ .zip(places)
+ {
match place {
Operand::Copy(place) | Operand::Move(place)
if target_place == place.as_ref() =>
let body = self.infcx.tcx.hir().body(*body_id);
let generator_kind = body.generator_kind();
- // If we have a more specific span available, point to that.
- // We do this even though this span might be part of a borrow error
- // message rather than a move error message. Our goal is to point
- // to a span that shows why the upvar is used in the closure,
- // so a move-related span is as good as any (and potentially better,
- // if the overall error is due to a move of the upvar).
-
- let usage_span = match captured_place.info.capture_kind {
- ty::UpvarCapture::ByValue(Some(span)) => span,
- _ => span,
- };
- return Some((*args_span, generator_kind, usage_span));
+ return Some((
+ *args_span,
+ generator_kind,
+ captured_place.get_capture_kind_span(self.infcx.tcx),
+ captured_place.get_path_span(self.infcx.tcx),
+ ));
}
_ => {}
}
};
let upvar = &self.upvars[upvar_field.unwrap().index()];
- // FIXME(project-rfc-2229#8): Improve borrow-check diagnostics in case of precise
- // capture.
let upvar_hir_id = upvar.place.get_root_variable();
- let upvar_name = upvar.name;
+ let upvar_name = upvar.place.to_string(self.infcx.tcx);
let upvar_span = self.infcx.tcx.hir().span(upvar_hir_id);
let place_name = self.describe_any_place(move_place.as_ref());
self.note_type_does_not_implement_copy(err, &place_desc, place_ty, Some(span), "");
use_spans.args_span_label(err, format!("move out of {} occurs here", place_desc));
- use_spans
- .var_span_label(err, format!("move occurs due to use{}", use_spans.describe()));
+ use_spans.var_span_label(
+ err,
+ format!("move occurs due to use{}", use_spans.describe()),
+ "moved",
+ );
}
}
}
if self.is_upvar_field_projection(access_place.as_ref()).is_some() {
reason = ", as it is not declared as mutable".to_string();
} else {
- let name = self.upvars[upvar_index.index()].name;
+ let name = self.upvars[upvar_index.index()].place.to_string(self.infcx.tcx);
reason = format!(", as `{}` is not declared as mutable", name);
}
}
"mutable borrow occurs due to use of {} in closure",
self.describe_any_place(access_place.as_ref()),
),
+ "mutable",
);
borrow_span
}
diag.span_label(*span, message);
+ // FIXME(project-rfc-2229#48): This should store a captured_place not a hir id
if let ReturnConstraint::ClosureUpvar(upvar) = kind {
let def_id = match self.regioncx.universal_regions().defining_ty {
DefiningTy::Closure(def_id, _) => def_id,
// FIXME(eddyb) perhaps move this somewhere more centrally.
#[derive(Debug)]
crate struct Upvar<'tcx> {
- // FIXME(project-rfc_2229#36): print capture precisely here.
- name: Symbol,
-
place: CapturedPlace<'tcx>,
/// If true, the capture is behind a reference.
let upvars: Vec<_> = tables
.closure_min_captures_flattened(def.did.to_def_id())
.map(|captured_place| {
- let var_hir_id = captured_place.get_root_variable();
let capture = captured_place.info.capture_kind;
let by_ref = match capture {
ty::UpvarCapture::ByValue(_) => false,
ty::UpvarCapture::ByRef(..) => true,
};
- Upvar { name: tcx.hir().name(var_hir_id), place: captured_place.clone(), by_ref }
+ Upvar { place: captured_place.clone(), by_ref }
})
.collect();
self.write_scalar(result, dest)?;
}
sym::copy => {
- self.copy(&args[0], &args[1], &args[2], /*nonoverlapping*/ false)?;
+ self.copy_intrinsic(&args[0], &args[1], &args[2], /*nonoverlapping*/ false)?;
}
sym::offset => {
let ptr = self.read_scalar(&args[0])?.check_init()?;
let b = self.read_immediate(&args[1])?.to_scalar()?;
// Special case: if both scalars are *equal integers*
- // and not NULL, we pretend there is an allocation of size 0 right there,
- // and their offset is 0. (There's never a valid object at NULL, making it an
+ // and not null, we pretend there is an allocation of size 0 right there,
+ // and their offset is 0. (There's never a valid object at null, making it an
// exception from the exception.)
// This is the dual to the special exception for offset-by-0
// in the inbounds pointer offset operation (see the Miri code, `src/operator.rs`).
/// Offsets a pointer by some multiple of its type, returning an error if the pointer leaves its
/// allocation. For integer pointers, we consider each of them their own tiny allocation of size
- /// 0, so offset-by-0 (and only 0) is okay -- except that NULL cannot be offset by _any_ value.
+ /// 0, so offset-by-0 (and only 0) is okay -- except that null cannot be offset by _any_ value.
pub fn ptr_offset_inbounds(
&self,
ptr: Scalar<M::PointerTag>,
// pointers to be properly aligned (unlike a read/write operation).
let min_ptr = if offset_bytes >= 0 { ptr } else { offset_ptr };
let size = offset_bytes.unsigned_abs();
- // This call handles checking for integer/NULL pointers.
+ // This call handles checking for integer/null pointers.
self.memory.check_ptr_access_align(
min_ptr,
Size::from_bytes(size),
None,
- CheckInAllocMsg::InboundsTest,
+ CheckInAllocMsg::PointerArithmeticTest,
)?;
Ok(offset_ptr)
}
+
+ /// Copy `count*size_of::<T>()` many bytes from `*src` to `*dst`.
+ pub(crate) fn copy_intrinsic(
+ &mut self,
+ src: &OpTy<'tcx, <M as Machine<'mir, 'tcx>>::PointerTag>,
+ dst: &OpTy<'tcx, <M as Machine<'mir, 'tcx>>::PointerTag>,
+ count: &OpTy<'tcx, <M as Machine<'mir, 'tcx>>::PointerTag>,
+ nonoverlapping: bool,
+ ) -> InterpResult<'tcx> {
+ let count = self.read_scalar(&count)?.to_machine_usize(self)?;
+ let layout = self.layout_of(src.layout.ty.builtin_deref(true).unwrap().ty)?;
+ let (size, align) = (layout.size, layout.align.abi);
+ let size = size.checked_mul(count, self).ok_or_else(|| {
+ err_ub_format!(
+ "overflow computing total size of `{}`",
+ if nonoverlapping { "copy_nonoverlapping" } else { "copy" }
+ )
+ })?;
+
+ // Make sure we check both pointers for an access of the total size and aligment,
+ // *even if* the total size is 0.
+ let src =
+ self.memory.check_ptr_access(self.read_scalar(&src)?.check_init()?, size, align)?;
+
+ let dst =
+ self.memory.check_ptr_access(self.read_scalar(&dst)?.check_init()?, size, align)?;
+
+ if let (Some(src), Some(dst)) = (src, dst) {
+ self.memory.copy(src, dst, size, nonoverlapping)?;
+ }
+ Ok(())
+ }
}
) -> InterpResult<'tcx, Pointer<Self::PointerTag>> {
Err((if int == 0 {
// This is UB, seriously.
+ // (`DanglingIntPointer` with these exact arguments has special printing code.)
err_ub!(DanglingIntPointer(0, CheckInAllocMsg::InboundsTest))
} else {
// This is just something we cannot support during const-eval.
//!
//! Generally, we use `Pointer` to denote memory addresses. However, some operations
//! have a "size"-like parameter, and they take `Scalar` for the address because
-//! if the size is 0, then the pointer can also be a (properly aligned, non-NULL)
+//! if the size is 0, then the pointer can also be a (properly aligned, non-null)
//! integer. It is crucial that these operations call `check_align` *before*
//! short-circuiting the empty case!
/// Map for "extra" function pointers.
extra_fn_ptr_map: FxHashMap<AllocId, M::ExtraFnVal>,
- /// To be able to compare pointers with NULL, and to check alignment for accesses
+ /// To be able to compare pointers with null, and to check alignment for accesses
/// to ZSTs (where pointers may dangle), we keep track of the size even for allocations
/// that do not exist any more.
// FIXME: this should not be public, but interning currently needs access to it
Ok(bits) => {
let bits = u64::try_from(bits).unwrap(); // it's ptr-sized
assert!(size.bytes() == 0);
- // Must be non-NULL.
+ // Must be non-null.
if bits == 0 {
throw_ub!(DanglingIntPointer(0, msg))
}
Err(ptr) => {
let (allocation_size, alloc_align) =
self.get_size_and_align(ptr.alloc_id, AllocCheck::Dereferenceable)?;
- // Test bounds. This also ensures non-NULL.
+ // Test bounds. This also ensures non-null.
// It is sufficient to check this for the end pointer. The addition
// checks for overflow.
let end_ptr = ptr.offset(size, self)?;
})
}
- /// Test if the pointer might be NULL.
+ /// Test if the pointer might be null.
pub fn ptr_may_be_null(&self, ptr: Pointer<M::PointerTag>) -> bool {
let (size, _align) = self
.get_size_and_align(ptr.alloc_id, AllocCheck::MaybeDead)
assert!(place.mplace.align <= align, "dynamic alignment less strict than static one?");
// Check (stricter) dynamic alignment, unless forced otherwise.
place.mplace.align = force_align.unwrap_or(align);
- // When dereferencing a pointer, it must be non-NULL, aligned, and live.
+ // When dereferencing a pointer, it must be non-null, aligned, and live.
if let Some(ptr) = self.check_mplace_access(&place, Some(size))? {
place.mplace.ptr = ptr.into();
}
//!
//! The main entry point is the `step` method.
-use crate::interpret::OpTy;
use rustc_middle::mir;
use rustc_middle::mir::interpret::{InterpResult, Scalar};
use rustc_target::abi::LayoutOf;
let src = self.eval_operand(src, None)?;
let dst = self.eval_operand(dst, None)?;
let count = self.eval_operand(count, None)?;
- self.copy(&src, &dst, &count, /* nonoverlapping */ true)?;
+ self.copy_intrinsic(&src, &dst, &count, /* nonoverlapping */ true)?;
}
// Statements we do not track.
Ok(())
}
- pub(crate) fn copy(
- &mut self,
- src: &OpTy<'tcx, <M as Machine<'mir, 'tcx>>::PointerTag>,
- dst: &OpTy<'tcx, <M as Machine<'mir, 'tcx>>::PointerTag>,
- count: &OpTy<'tcx, <M as Machine<'mir, 'tcx>>::PointerTag>,
- nonoverlapping: bool,
- ) -> InterpResult<'tcx> {
- let count = self.read_scalar(&count)?.to_machine_usize(self)?;
- let layout = self.layout_of(src.layout.ty.builtin_deref(true).unwrap().ty)?;
- let (size, align) = (layout.size, layout.align.abi);
- let size = size.checked_mul(count, self).ok_or_else(|| {
- err_ub_format!(
- "overflow computing total size of `{}`",
- if nonoverlapping { "copy_nonoverlapping" } else { "copy" }
- )
- })?;
-
- // Make sure we check both pointers for an access of the total size and aligment,
- // *even if* the total size is 0.
- let src =
- self.memory.check_ptr_access(self.read_scalar(&src)?.check_init()?, size, align)?;
-
- let dst =
- self.memory.check_ptr_access(self.read_scalar(&dst)?.check_init()?, size, align)?;
-
- if let (Some(src), Some(dst)) = (src, dst) {
- self.memory.copy(src, dst, size, nonoverlapping)?;
- }
- Ok(())
- }
-
/// Evaluate an assignment statement.
///
/// There is no separate `eval_rvalue` function. Instead, the code for handling each rvalue
vtable,
3 * self.ecx.tcx.data_layout.pointer_size, // drop, size, align
Some(self.ecx.tcx.data_layout.pointer_align.abi),
- CheckInAllocMsg::InboundsTest,
+ CheckInAllocMsg::InboundsTest, // will anyway be replaced by validity message
),
self.path,
err_ub!(DanglingIntPointer(..)) |
place.ptr,
size,
Some(align),
- CheckInAllocMsg::InboundsTest,
+ CheckInAllocMsg::InboundsTest, // will anyway be replaced by validity message
),
self.path,
err_ub!(AlignmentCheckFailed { required, has }) =>
has.bytes()
},
err_ub!(DanglingIntPointer(0, _)) =>
- { "a NULL {}", kind },
+ { "a null {}", kind },
err_ub!(DanglingIntPointer(i, _)) =>
{ "a dangling {} (address 0x{:x} is unallocated)", kind, i },
err_ub!(PointerOutOfBounds { .. }) =>
let bits = match value.to_bits_or_ptr(op.layout.size, self.ecx) {
Err(ptr) => {
if lo == 1 && hi == max_hi {
- // Only NULL is the niche. So make sure the ptr is NOT NULL.
+ // Only null is the niche. So make sure the ptr is NOT null.
if self.ecx.memory.ptr_may_be_null(ptr) {
throw_validation_failure!(self.path,
- { "a potentially NULL pointer" }
+ { "a potentially null pointer" }
expected {
"something that cannot possibly fail to be {}",
wrapping_range_format(valid_range, max_hi)
tcx: TyCtxt<'tcx>,
mode: MonoItemCollectionMode,
output: &'a mut Vec<Spanned<MonoItem<'tcx>>>,
- entry_fn: Option<(LocalDefId, EntryFnType)>,
+ entry_fn: Option<(DefId, EntryFnType)>,
}
impl ItemLikeVisitor<'v> for RootCollector<'_, 'v> {
&& match self.mode {
MonoItemCollectionMode::Eager => true,
MonoItemCollectionMode::Lazy => {
- self.entry_fn.map(|(id, _)| id) == Some(def_id)
+ self.entry_fn.and_then(|(id, _)| id.as_local()) == Some(def_id)
|| self.tcx.is_reachable_non_generic(def_id)
|| self
.tcx
ty::PredicateKind::Subtype(_) => {
bug!("subtype predicate on function: {:#?}", predicate)
}
- ty::PredicateKind::Trait(pred, constness) => {
+ ty::PredicateKind::Trait(pred, _constness) => {
if Some(pred.def_id()) == tcx.lang_items().sized_trait() {
continue;
}
// arguments when determining importance.
let kind = LocalKind::Arg;
- if constness == hir::Constness::Const {
- self.check_op_spanned(ops::ty::TraitBound(kind), span);
- } else if !tcx.features().const_fn
- || self.ccx.is_const_stable_const_fn()
- {
- // HACK: We shouldn't need the conditional above, but trait
- // bounds on containing impl blocks are wrongly being marked as
- // "not-const".
- self.check_op_spanned(ops::ty::TraitBound(kind), span);
- }
+ self.check_op_spanned(ops::ty::TraitBound(kind), span);
}
// other kinds of bounds are either tautologies
// or cause errors in other passes
// if we applied optimizations, we potentially have some cfg to cleanup to
// make it easier for further passes
if should_simplify {
- simplify_cfg(body);
+ simplify_cfg(tcx, body);
simplify_locals(body, tcx);
}
}
use rustc_middle::ty::TyCtxt;
use rustc_span::def_id::DefId;
use rustc_span::source_map::SourceMap;
-use rustc_span::{CharPos, Pos, SourceFile, Span, Symbol};
+use rustc_span::{CharPos, ExpnKind, Pos, SourceFile, Span, Symbol};
/// A simple error message wrapper for `coverage::Error`s.
#[derive(Debug)]
impl<'a, 'tcx> Instrumentor<'a, 'tcx> {
fn new(pass_name: &'a str, tcx: TyCtxt<'tcx>, mir_body: &'a mut mir::Body<'tcx>) -> Self {
let source_map = tcx.sess.source_map();
- let (some_fn_sig, hir_body) = fn_sig_and_body(tcx, mir_body.source.def_id());
- let body_span = hir_body.value.span;
+ let def_id = mir_body.source.def_id();
+ let (some_fn_sig, hir_body) = fn_sig_and_body(tcx, def_id);
+
+ let mut body_span = hir_body.value.span;
+
+ if tcx.is_closure(def_id) {
+ // If the MIR function is a closure, and if the closure body span
+ // starts from a macro, but it's content is not in that macro, try
+ // to find a non-macro callsite, and instrument the spans there
+ // instead.
+ loop {
+ let expn_data = body_span.ctxt().outer_expn_data();
+ if expn_data.is_root() {
+ break;
+ }
+ if let ExpnKind::Macro(..) = expn_data.kind {
+ body_span = expn_data.call_site;
+ } else {
+ break;
+ }
+ }
+ }
+
let source_file = source_map.lookup_source_file(body_span.lo());
let fn_sig_span = match some_fn_sig.filter(|fn_sig| {
fn_sig.span.ctxt() == body_span.ctxt()
use rustc_middle::ty::TyCtxt;
use rustc_span::source_map::original_sp;
-use rustc_span::{BytePos, Span};
+use rustc_span::{BytePos, ExpnKind, MacroKind, Span, Symbol};
+use std::cell::RefCell;
use std::cmp::Ordering;
#[derive(Debug, Copy, Clone)]
#[derive(Debug, Clone)]
pub(super) struct CoverageSpan {
pub span: Span,
+ pub expn_span: Span,
+ pub current_macro_or_none: RefCell<Option<Option<Symbol>>>,
pub bcb: BasicCoverageBlock,
pub coverage_statements: Vec<CoverageStatement>,
pub is_closure: bool,
impl CoverageSpan {
pub fn for_fn_sig(fn_sig_span: Span) -> Self {
- Self { span: fn_sig_span, bcb: START_BCB, coverage_statements: vec![], is_closure: false }
+ Self {
+ span: fn_sig_span,
+ expn_span: fn_sig_span,
+ current_macro_or_none: Default::default(),
+ bcb: START_BCB,
+ coverage_statements: vec![],
+ is_closure: false,
+ }
}
pub fn for_statement(
statement: &Statement<'tcx>,
span: Span,
+ expn_span: Span,
bcb: BasicCoverageBlock,
bb: BasicBlock,
stmt_index: usize,
Self {
span,
+ expn_span,
+ current_macro_or_none: Default::default(),
bcb,
coverage_statements: vec![CoverageStatement::Statement(bb, span, stmt_index)],
is_closure,
}
}
- pub fn for_terminator(span: Span, bcb: BasicCoverageBlock, bb: BasicBlock) -> Self {
+ pub fn for_terminator(
+ span: Span,
+ expn_span: Span,
+ bcb: BasicCoverageBlock,
+ bb: BasicBlock,
+ ) -> Self {
Self {
span,
+ expn_span,
+ current_macro_or_none: Default::default(),
bcb,
coverage_statements: vec![CoverageStatement::Terminator(bb, span)],
is_closure: false,
.collect::<Vec<_>>()
.join("\n")
}
+
+ /// If the span is part of a macro, returns the macro name symbol.
+ pub fn current_macro(&self) -> Option<Symbol> {
+ self.current_macro_or_none
+ .borrow_mut()
+ .get_or_insert_with(|| {
+ if let ExpnKind::Macro(MacroKind::Bang, current_macro) =
+ self.expn_span.ctxt().outer_expn_data().kind
+ {
+ return Some(current_macro);
+ }
+ None
+ })
+ .map(|symbol| symbol)
+ }
+
+ /// If the span is part of a macro, and the macro is visible (expands directly to the given
+ /// body_span), returns the macro name symbol.
+ pub fn visible_macro(&self, body_span: Span) -> Option<Symbol> {
+ if let Some(current_macro) = self.current_macro() {
+ if self.expn_span.parent().unwrap_or_else(|| bug!("macro must have a parent")).ctxt()
+ == body_span.ctxt()
+ {
+ return Some(current_macro);
+ }
+ }
+ None
+ }
+
+ pub fn is_macro_expansion(&self) -> bool {
+ self.current_macro().is_some()
+ }
}
/// Converts the initial set of `CoverageSpan`s (one per MIR `Statement` or `Terminator`) into a
/// iteration.
some_curr: Option<CoverageSpan>,
- /// The original `span` for `curr`, in case the `curr` span is modified.
+ /// The original `span` for `curr`, in case `curr.span()` is modified. The `curr_original_span`
+ /// **must not be mutated** (except when advancing to the next `curr`), even if `curr.span()`
+ /// is mutated.
curr_original_span: Span,
/// The CoverageSpan from a prior iteration; typically assigned from that iteration's `curr`.
/// If that `curr` was discarded, `prev` retains its value from the previous iteration.
some_prev: Option<CoverageSpan>,
- /// Assigned from `curr_original_span` from the previous iteration.
+ /// Assigned from `curr_original_span` from the previous iteration. The `prev_original_span`
+ /// **must not be mutated** (except when advancing to the next `prev`), even if `prev.span()`
+ /// is mutated.
prev_original_span: Span,
+ /// A copy of the expn_span from the prior iteration.
+ prev_expn_span: Option<Span>,
+
/// One or more `CoverageSpan`s with the same `Span` but different `BasicCoverageBlock`s, and
/// no `BasicCoverageBlock` in this list dominates another `BasicCoverageBlock` in the list.
/// If a new `curr` span also fits this criteria (compared to an existing list of
curr_original_span: Span::with_root_ctxt(BytePos(0), BytePos(0)),
some_prev: None,
prev_original_span: Span::with_root_ctxt(BytePos(0), BytePos(0)),
+ prev_expn_span: None,
pending_dups: Vec::new(),
};
let sorted_spans = coverage_spans.mir_to_initial_sorted_coverage_spans();
coverage_spans.sorted_spans_iter = Some(sorted_spans.into_iter());
- coverage_spans.some_prev = coverage_spans.sorted_spans_iter.as_mut().unwrap().next();
- coverage_spans.prev_original_span =
- coverage_spans.some_prev.as_ref().expect("at least one span").span;
coverage_spans.to_refined_spans()
}
/// de-duplicated `CoverageSpan`s.
fn to_refined_spans(mut self) -> Vec<CoverageSpan> {
while self.next_coverage_span() {
- if self.curr().is_mergeable(self.prev()) {
+ if self.some_prev.is_none() {
+ debug!(" initial span");
+ self.check_invoked_macro_name_span();
+ } else if self.curr().is_mergeable(self.prev()) {
debug!(" same bcb (and neither is a closure), merge with prev={:?}", self.prev());
let prev = self.take_prev();
self.curr_mut().merge_from(prev);
+ self.check_invoked_macro_name_span();
// Note that curr.span may now differ from curr_original_span
} else if self.prev_ends_before_curr() {
debug!(
self.prev()
);
let prev = self.take_prev();
- self.refined_spans.push(prev);
+ self.push_refined_span(prev);
+ self.check_invoked_macro_name_span();
} else if self.prev().is_closure {
// drop any equal or overlapping span (`curr`) and keep `prev` to test again in the
// next iter
} else if self.curr().is_closure {
self.carve_out_span_for_closure();
} else if self.prev_original_span == self.curr().span {
- // Note that this compares the new span to `prev_original_span`, which may not
- // be the full `prev.span` (if merged during the previous iteration).
- self.hold_pending_dups_unless_dominated();
+ // Note that this compares the new (`curr`) span to `prev_original_span`.
+ // In this branch, the actual span byte range of `prev_original_span` is not
+ // important. What is important is knowing whether the new `curr` span was
+ // **originally** the same as the original span of `prev()`. The original spans
+ // reflect their original sort order, and for equal spans, conveys a partial
+ // ordering based on CFG dominator priority.
+ if self.prev().is_macro_expansion() && self.curr().is_macro_expansion() {
+ // Macros that expand to include branching (such as
+ // `assert_eq!()`, `assert_ne!()`, `info!()`, `debug!()`, or
+ // `trace!()) typically generate callee spans with identical
+ // ranges (typically the full span of the macro) for all
+ // `BasicBlocks`. This makes it impossible to distinguish
+ // the condition (`if val1 != val2`) from the optional
+ // branched statements (such as the call to `panic!()` on
+ // assert failure). In this case it is better (or less
+ // worse) to drop the optional branch bcbs and keep the
+ // non-conditional statements, to count when reached.
+ debug!(
+ " curr and prev are part of a macro expansion, and curr has the same span \
+ as prev, but is in a different bcb. Drop curr and keep prev for next iter. \
+ prev={:?}",
+ self.prev()
+ );
+ self.take_curr();
+ } else {
+ self.hold_pending_dups_unless_dominated();
+ }
} else {
self.cutoff_prev_at_overlapping_curr();
+ self.check_invoked_macro_name_span();
}
}
debug!(" AT END, adding last prev={:?}", self.prev());
let prev = self.take_prev();
- let CoverageSpans { pending_dups, mut refined_spans, .. } = self;
+ let pending_dups = self.pending_dups.split_off(0);
for dup in pending_dups {
debug!(" ...adding at least one pending dup={:?}", dup);
- refined_spans.push(dup);
+ self.push_refined_span(dup);
}
// Async functions wrap a closure that implements the body to be executed. The enclosing
// excluded. The closure's `Return` is the only one that will be counted. This provides
// adequate coverage, and more intuitive counts. (Avoids double-counting the closing brace
// of the function body.)
- let body_ends_with_closure = if let Some(last_covspan) = refined_spans.last() {
+ let body_ends_with_closure = if let Some(last_covspan) = self.refined_spans.last() {
last_covspan.is_closure && last_covspan.span.hi() == self.body_span.hi()
} else {
false
};
if !body_ends_with_closure {
- refined_spans.push(prev);
+ self.push_refined_span(prev);
}
// Remove `CoverageSpan`s derived from closures, originally added to ensure the coverage
// regions for the current function leave room for the closure's own coverage regions
// (injected separately, from the closure's own MIR).
- refined_spans.retain(|covspan| !covspan.is_closure);
- refined_spans
+ self.refined_spans.retain(|covspan| !covspan.is_closure);
+ self.refined_spans
+ }
+
+ fn push_refined_span(&mut self, covspan: CoverageSpan) {
+ let len = self.refined_spans.len();
+ if len > 0 {
+ let last = &mut self.refined_spans[len - 1];
+ if last.is_mergeable(&covspan) {
+ debug!(
+ "merging new refined span with last refined span, last={:?}, covspan={:?}",
+ last, covspan
+ );
+ last.merge_from(covspan);
+ return;
+ }
+ }
+ self.refined_spans.push(covspan)
+ }
+
+ fn check_invoked_macro_name_span(&mut self) {
+ if let Some(visible_macro) = self.curr().visible_macro(self.body_span) {
+ if self.prev_expn_span.map_or(true, |prev_expn_span| {
+ self.curr().expn_span.ctxt() != prev_expn_span.ctxt()
+ }) {
+ let merged_prefix_len = self.curr_original_span.lo() - self.curr().span.lo();
+ let after_macro_bang =
+ merged_prefix_len + BytePos(visible_macro.as_str().bytes().count() as u32 + 1);
+ let mut macro_name_cov = self.curr().clone();
+ self.curr_mut().span =
+ self.curr().span.with_lo(self.curr().span.lo() + after_macro_bang);
+ macro_name_cov.span =
+ macro_name_cov.span.with_hi(macro_name_cov.span.lo() + after_macro_bang);
+ debug!(
+ " and curr starts a new macro expansion, so add a new span just for \
+ the macro `{}!`, new span={:?}",
+ visible_macro, macro_name_cov
+ );
+ self.push_refined_span(macro_name_cov);
+ }
+ }
}
// Generate a set of `CoverageSpan`s from the filtered set of `Statement`s and `Terminator`s of
.iter()
.enumerate()
.filter_map(move |(index, statement)| {
- filtered_statement_span(statement, self.body_span).map(|span| {
- CoverageSpan::for_statement(statement, span, bcb, bb, index)
- })
+ filtered_statement_span(statement, self.body_span).map(
+ |(span, expn_span)| {
+ CoverageSpan::for_statement(
+ statement, span, expn_span, bcb, bb, index,
+ )
+ },
+ )
})
- .chain(
- filtered_terminator_span(data.terminator(), self.body_span)
- .map(|span| CoverageSpan::for_terminator(span, bcb, bb)),
- )
+ .chain(filtered_terminator_span(data.terminator(), self.body_span).map(
+ |(span, expn_span)| CoverageSpan::for_terminator(span, expn_span, bcb, bb),
+ ))
})
.collect()
}
let pending_dups = self.pending_dups.split_off(0);
for dup in pending_dups.into_iter() {
debug!(" ...adding at least one pending={:?}", dup);
- self.refined_spans.push(dup);
+ self.push_refined_span(dup);
}
} else {
self.pending_dups.clear();
/// Advance `prev` to `curr` (if any), and `curr` to the next `CoverageSpan` in sorted order.
fn next_coverage_span(&mut self) -> bool {
if let Some(curr) = self.some_curr.take() {
+ self.prev_expn_span = Some(curr.expn_span);
self.some_prev = Some(curr);
self.prev_original_span = self.curr_original_span;
}
while let Some(curr) = self.sorted_spans_iter.as_mut().unwrap().next() {
debug!("FOR curr={:?}", curr);
- if self.prev_starts_after_next(&curr) {
+ if self.some_prev.is_some() && self.prev_starts_after_next(&curr) {
debug!(
" prev.span starts after curr.span, so curr will be dropped (skipping past \
closure?); prev={:?}",
for mut dup in pending_dups.iter().cloned() {
dup.span = dup.span.with_hi(left_cutoff);
debug!(" ...and at least one pre_closure dup={:?}", dup);
- self.refined_spans.push(dup);
+ self.push_refined_span(dup);
}
}
- self.refined_spans.push(pre_closure);
+ self.push_refined_span(pre_closure);
}
if has_post_closure_span {
- // Update prev.span to start after the closure (and discard curr)
+ // Mutate `prev.span()` to start after the closure (and discard curr).
+ // (**NEVER** update `prev_original_span` because it affects the assumptions
+ // about how the `CoverageSpan`s are ordered.)
self.prev_mut().span = self.prev().span.with_lo(right_cutoff);
- self.prev_original_span = self.prev().span;
+ debug!(" Mutated prev.span to start after the closure. prev={:?}", self.prev());
for dup in pending_dups.iter_mut() {
+ debug!(" ...and at least one overlapping dup={:?}", dup);
dup.span = dup.span.with_lo(right_cutoff);
}
self.pending_dups.append(&mut pending_dups);
let closure_covspan = self.take_curr();
- self.refined_spans.push(closure_covspan); // since self.prev() was already updated
+ self.push_refined_span(closure_covspan); // since self.prev() was already updated
} else {
pending_dups.clear();
}
}
/// Called if `curr.span` equals `prev_original_span` (and potentially equal to all
- /// `pending_dups` spans, if any); but keep in mind, `prev.span` may start at a `Span.lo()` that
- /// is less than (further left of) `prev_original_span.lo()`.
+ /// `pending_dups` spans, if any). Keep in mind, `prev.span()` may have been changed.
+ /// If prev.span() was merged into other spans (with matching BCB, for instance),
+ /// `prev.span.hi()` will be greater than (further right of) `prev_original_span.hi()`.
+ /// If prev.span() was split off to the right of a closure, prev.span().lo() will be
+ /// greater than prev_original_span.lo(). The actual span of `prev_original_span` is
+ /// not as important as knowing that `prev()` **used to have the same span** as `curr(),
+ /// which means their sort order is still meaningful for determinating the dominator
+ /// relationship.
///
/// When two `CoverageSpan`s have the same `Span`, dominated spans can be discarded; but if
/// neither `CoverageSpan` dominates the other, both (or possibly more than two) are held,
} else {
debug!(" ... adding modified prev={:?}", self.prev());
let prev = self.take_prev();
- self.refined_spans.push(prev);
+ self.push_refined_span(prev);
}
} else {
// with `pending_dups`, `prev` cannot have any statements that don't overlap
}
}
+/// See `function_source_span()` for a description of the two returned spans.
+/// If the MIR `Statement` is not contributive to computing coverage spans,
+/// returns `None`.
pub(super) fn filtered_statement_span(
statement: &'a Statement<'tcx>,
body_span: Span,
-) -> Option<Span> {
+) -> Option<(Span, Span)> {
match statement.kind {
// These statements have spans that are often outside the scope of the executed source code
// for their parent `BasicBlock`.
}
}
+/// See `function_source_span()` for a description of the two returned spans.
+/// If the MIR `Terminator` is not contributive to computing coverage spans,
+/// returns `None`.
pub(super) fn filtered_terminator_span(
terminator: &'a Terminator<'tcx>,
body_span: Span,
-) -> Option<Span> {
+) -> Option<(Span, Span)> {
match terminator.kind {
// These terminators have spans that don't positively contribute to computing a reasonable
// span of actually executed source code. (For example, SwitchInt terminators extracted from
}
}
+/// Returns two spans from the given span (the span associated with a
+/// `Statement` or `Terminator`):
+///
+/// 1. An extrapolated span (pre-expansion[^1]) corresponding to a range within
+/// the function's body source. This span is guaranteed to be contained
+/// within, or equal to, the `body_span`. If the extrapolated span is not
+/// contained within the `body_span`, the `body_span` is returned.
+/// 2. The actual `span` value from the `Statement`, before expansion.
+///
+/// Only the first span is used when computing coverage code regions. The second
+/// span is useful if additional expansion data is needed (such as to look up
+/// the macro name for a composed span within that macro).)
+///
+/// [^1]Expansions result from Rust syntax including macros, syntactic
+/// sugar, etc.).
#[inline]
-fn function_source_span(span: Span, body_span: Span) -> Span {
- let span = original_sp(span, body_span).with_ctxt(body_span.ctxt());
- if body_span.contains(span) { span } else { body_span }
+fn function_source_span(span: Span, body_span: Span) -> (Span, Span) {
+ let original_span = original_sp(span, body_span).with_ctxt(body_span.ctxt());
+ (if body_span.contains(original_span) { original_span } else { body_span }, span)
}
//! This crate hosts a selection of "unit tests" for components of the `InstrumentCoverage` MIR
//! pass.
//!
+//! ```shell
+//! ./x.py test --keep-stage 1 compiler/rustc_mir --test-args '--show-output coverage'
+//! ```
+//!
//! The tests construct a few "mock" objects, as needed, to support the `InstrumentCoverage`
//! functions and algorithms. Mocked objects include instances of `mir::Body`; including
//! `Terminator`s of various `kind`s, and `Span` objects. Some functions used by or used on
let mut basic_coverage_blocks = graph::CoverageGraph::from_mir(&mir_body);
let mut coverage_spans = Vec::new();
for (bcb, data) in basic_coverage_blocks.iter_enumerated() {
- if let Some(span) =
+ if let Some((span, expn_span)) =
spans::filtered_terminator_span(data.terminator(&mir_body), body_span)
{
- coverage_spans.push(spans::CoverageSpan::for_terminator(span, bcb, data.last_bb()));
+ coverage_spans.push(spans::CoverageSpan::for_terminator(
+ span,
+ expn_span,
+ bcb,
+ data.last_bb(),
+ ));
}
}
let mut coverage_counters = counters::CoverageCounters::new(0);
if has_opts_to_apply {
let mut opt_applier = OptApplier { tcx, duplicates };
opt_applier.visit_body(body);
- simplify_cfg(body);
+ simplify_cfg(tcx, body);
}
}
}
// Since this optimization adds new basic blocks and invalidates others,
// clean up the cfg to make it nicer for other passes
if should_cleanup {
- simplify_cfg(body);
+ simplify_cfg(tcx, body);
}
}
}
// Make sure we remove dead blocks to remove
// unrelated code from the resume part of the function
- simplify::remove_dead_blocks(&mut body);
+ simplify::remove_dead_blocks(tcx, &mut body);
dump_mir(tcx, None, "generator_drop", &0, &body, |_, _| Ok(()));
// Make sure we remove dead blocks to remove
// unrelated code from the drop part of the function
- simplify::remove_dead_blocks(body);
+ simplify::remove_dead_blocks(tcx, body);
dump_mir(tcx, None, "generator_resume", &0, body, |_, _| Ok(()));
}
if inline(tcx, body) {
debug!("running simplify cfg on {:?}", body.source);
CfgSimplifier::new(body).simplify();
- remove_dead_blocks(body);
+ remove_dead_blocks(tcx, body);
}
}
}
}
if should_cleanup {
- simplify_cfg(body);
+ simplify_cfg(tcx, body);
}
}
}
}
}
- simplify::remove_dead_blocks(body)
+ simplify::remove_dead_blocks(tcx, body)
}
}
// if we applied optimizations, we potentially have some cfg to cleanup to
// make it easier for further passes
if should_simplify {
- simplify_cfg(body);
+ simplify_cfg(tcx, body);
}
}
}
use crate::transform::MirPass;
use rustc_index::vec::{Idx, IndexVec};
+use rustc_middle::mir::coverage::*;
use rustc_middle::mir::visit::{MutVisitor, MutatingUseContext, PlaceContext, Visitor};
use rustc_middle::mir::*;
use rustc_middle::ty::TyCtxt;
}
}
-pub fn simplify_cfg(body: &mut Body<'_>) {
+pub fn simplify_cfg(tcx: TyCtxt<'tcx>, body: &mut Body<'_>) {
CfgSimplifier::new(body).simplify();
- remove_dead_blocks(body);
+ remove_dead_blocks(tcx, body);
// FIXME: Should probably be moved into some kind of pass manager
body.basic_blocks_mut().raw.shrink_to_fit();
Cow::Borrowed(&self.label)
}
- fn run_pass(&self, _tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+ fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
debug!("SimplifyCfg({:?}) - simplifying {:?}", self.label, body.source);
- simplify_cfg(body);
+ simplify_cfg(tcx, body);
}
}
}
}
-pub fn remove_dead_blocks(body: &mut Body<'_>) {
+pub fn remove_dead_blocks(tcx: TyCtxt<'tcx>, body: &mut Body<'_>) {
let reachable = traversal::reachable_as_bitset(body);
let num_blocks = body.basic_blocks().len();
if num_blocks == reachable.count() {
}
used_blocks += 1;
}
+
+ if tcx.sess.instrument_coverage() {
+ save_unreachable_coverage(basic_blocks, used_blocks);
+ }
+
basic_blocks.raw.truncate(used_blocks);
for block in basic_blocks {
}
}
+fn save_unreachable_coverage(
+ basic_blocks: &mut IndexVec<BasicBlock, BasicBlockData<'_>>,
+ first_dead_block: usize,
+) {
+ // retain coverage info for dead blocks, so coverage reports will still
+ // report `0` executions for the uncovered code regions.
+ let mut dropped_coverage = Vec::new();
+ for dead_block in first_dead_block..basic_blocks.len() {
+ for statement in basic_blocks[BasicBlock::new(dead_block)].statements.iter() {
+ if let StatementKind::Coverage(coverage) = &statement.kind {
+ if let Some(code_region) = &coverage.code_region {
+ dropped_coverage.push((statement.source_info, code_region.clone()));
+ }
+ }
+ }
+ }
+ for (source_info, code_region) in dropped_coverage {
+ basic_blocks[START_BLOCK].statements.push(Statement {
+ source_info,
+ kind: StatementKind::Coverage(box Coverage {
+ kind: CoverageKind::Unreachable,
+ code_region: Some(code_region),
+ }),
+ })
+ }
+}
pub struct SimplifyLocals;
impl<'tcx> MirPass<'tcx> for SimplifyLocals {
if did_remove_blocks {
// We have dead blocks now, so remove those.
- simplify::remove_dead_blocks(body);
+ simplify::remove_dead_blocks(tcx, body);
}
}
}
}
if replaced {
- simplify::remove_dead_blocks(body);
+ simplify::remove_dead_blocks(tcx, body);
}
}
}
W: Write,
{
let def_id = body.source.def_id();
- let body_span = hir_body(tcx, def_id).value.span;
+ let hir_body = hir_body(tcx, def_id);
+ if hir_body.is_none() {
+ return Ok(());
+ }
+ let body_span = hir_body.unwrap().value.span;
let mut span_viewables = Vec::new();
for (bb, data) in body.basic_blocks().iter_enumerated() {
match spanview {
let hir_id =
tcx.hir().local_def_id_to_hir_id(def_id.as_local().expect("expected DefId is local"));
let fn_decl_span = tcx.hir().span(hir_id);
- let body_span = hir_body(tcx, def_id).value.span;
- if fn_decl_span.ctxt() == body_span.ctxt() {
- fn_decl_span.to(body_span)
+ if let Some(body_span) = hir_body(tcx, def_id).map(|hir_body| hir_body.value.span) {
+ if fn_decl_span.ctxt() == body_span.ctxt() { fn_decl_span.to(body_span) } else { body_span }
} else {
- // This probably occurs for functions defined via macros
- body_span
+ fn_decl_span
}
}
-fn hir_body<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx rustc_hir::Body<'tcx> {
+fn hir_body<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Option<&'tcx rustc_hir::Body<'tcx>> {
let hir_node = tcx.hir().get_if_local(def_id).expect("expected DefId is local");
- let fn_body_id = hir::map::associated_body(hir_node).expect("HIR node is a function with body");
- tcx.hir().body(fn_body_id)
+ hir::map::associated_body(hir_node).map(|fn_body_id| tcx.hir().body(fn_body_id))
}
fn escape_html(s: &str) -> String {
}
}
- fn parse_tuple_parens_expr(&mut self, mut attrs: AttrVec) -> PResult<'a, P<Expr>> {
+ fn parse_tuple_parens_expr(&mut self, attrs: AttrVec) -> PResult<'a, P<Expr>> {
let lo = self.token.span;
self.expect(&token::OpenDelim(token::Paren))?;
- attrs.extend(self.parse_inner_attributes()?); // `(#![foo] a, b, ...)` is OK.
let (es, trailing_comma) = match self.parse_seq_to_end(
&token::CloseDelim(token::Paren),
SeqSep::trailing_allowed(token::Comma),
self.maybe_recover_from_bad_qpath(expr, true)
}
- fn parse_array_or_repeat_expr(&mut self, mut attrs: AttrVec) -> PResult<'a, P<Expr>> {
+ fn parse_array_or_repeat_expr(&mut self, attrs: AttrVec) -> PResult<'a, P<Expr>> {
let lo = self.token.span;
self.bump(); // `[`
- attrs.extend(self.parse_inner_attributes()?);
-
let close = &token::CloseDelim(token::Bracket);
let kind = if self.eat(close) {
// Empty vector
}
/// Parses a `match ... { ... }` expression (`match` token already eaten).
- fn parse_match_expr(&mut self, mut attrs: AttrVec) -> PResult<'a, P<Expr>> {
+ fn parse_match_expr(&mut self, attrs: AttrVec) -> PResult<'a, P<Expr>> {
let match_span = self.prev_token.span;
let lo = self.prev_token.span;
let scrutinee = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?;
}
return Err(e);
}
- attrs.extend(self.parse_inner_attributes()?);
let mut arms: Vec<Arm> = Vec::new();
while self.token != token::CloseDelim(token::Brace) {
pub(super) fn parse_struct_expr(
&mut self,
pth: ast::Path,
- mut attrs: AttrVec,
+ attrs: AttrVec,
recover: bool,
) -> PResult<'a, P<Expr>> {
let mut fields = Vec::new();
let mut base = ast::StructRest::None;
let mut recover_async = false;
- attrs.extend(self.parse_inner_attributes()?);
-
let mut async_block_err = |e: &mut DiagnosticBuilder<'_>, span: Span| {
recover_async = true;
e.span_label(span, "`async` blocks are only allowed in Rust 2018 or later");
/// Is a `dyn B0 + ... + Bn` type allowed here?
fn is_explicit_dyn_type(&mut self) -> bool {
self.check_keyword(kw::Dyn)
- && (self.token.uninterpolated_span().rust_2018()
+ && (!self.token.uninterpolated_span().rust_2015()
|| self.look_ahead(1, |t| {
t.can_begin_bound() && !can_continue_type_after_non_fn_ident(t)
}))
) -> PResult<'a, GenericBounds> {
let mut bounds = Vec::new();
let mut negative_bounds = Vec::new();
- while self.can_begin_bound() {
+
+ while self.can_begin_bound() || self.token.is_keyword(kw::Dyn) {
+ if self.token.is_keyword(kw::Dyn) {
+ // Account for `&dyn Trait + dyn Other`.
+ self.struct_span_err(self.token.span, "invalid `dyn` keyword")
+ .help("`dyn` is only needed at the start of a trait `+`-separated list")
+ .span_suggestion(
+ self.token.span,
+ "remove this keyword",
+ String::new(),
+ Applicability::MachineApplicable,
+ )
+ .emit();
+ self.bump();
+ }
match self.parse_generic_bound()? {
Ok(bound) => bounds.push(bound),
Err(neg_sp) => negative_bounds.push(neg_sp),
let lifetime_defs = self.parse_late_bound_lifetime_defs()?;
let path = self.parse_path(PathStyle::Type)?;
if has_parens {
- self.expect(&token::CloseDelim(token::Paren))?;
+ if self.token.is_like_plus() {
+ // Someone has written something like `&dyn (Trait + Other)`. The correct code
+ // would be `&(dyn Trait + Other)`, but we don't have access to the appropriate
+ // span to suggest that. When written as `&dyn Trait + Other`, an appropriate
+ // suggestion is given.
+ let bounds = vec![];
+ self.parse_remaining_bounds(bounds, true)?;
+ self.expect(&token::CloseDelim(token::Paren))?;
+ let sp = vec![lo, self.prev_token.span];
+ let sugg: Vec<_> = sp.iter().map(|sp| (*sp, String::new())).collect();
+ self.struct_span_err(sp, "incorrect braces around trait bounds")
+ .multipart_suggestion(
+ "remove the parentheses",
+ sugg,
+ Applicability::MachineApplicable,
+ )
+ .emit();
+ } else {
+ self.expect(&token::CloseDelim(token::Paren))?;
+ }
}
let modifier = modifiers.to_trait_bound_modifier();
)
.chain(
// Seed entry point
- tcx.entry_fn(LOCAL_CRATE).map(|(def_id, _)| tcx.hir().local_def_id_to_hir_id(def_id)),
+ tcx.entry_fn(LOCAL_CRATE).and_then(|(def_id, _)| {
+ def_id.as_local().map(|def_id| tcx.hir().local_def_id_to_hir_id(def_id))
+ }),
)
.collect::<Vec<_>>();
use rustc_ast::entry::EntryPointType;
use rustc_errors::struct_span_err;
-use rustc_hir::def_id::{CrateNum, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE};
+use rustc_hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
use rustc_hir::itemlikevisit::ItemLikeVisitor;
use rustc_hir::{ForeignItem, HirId, ImplItem, Item, ItemKind, TraitItem, CRATE_HIR_ID};
use rustc_middle::hir::map::Map;
use rustc_middle::ty::query::Providers;
use rustc_middle::ty::TyCtxt;
use rustc_session::config::{CrateType, EntryFnType};
+use rustc_session::parse::feature_err;
use rustc_session::Session;
use rustc_span::symbol::sym;
use rustc_span::{Span, DUMMY_SP};
map: Map<'tcx>,
- /// The top-level function called `main`.
- main_fn: Option<(HirId, Span)>,
-
/// The function that has attribute named `main`.
attr_main_fn: Option<(HirId, Span)>,
}
}
-fn entry_fn(tcx: TyCtxt<'_>, cnum: CrateNum) -> Option<(LocalDefId, EntryFnType)> {
+fn entry_fn(tcx: TyCtxt<'_>, cnum: CrateNum) -> Option<(DefId, EntryFnType)> {
assert_eq!(cnum, LOCAL_CRATE);
let any_exe = tcx.sess.crate_types().iter().any(|ty| *ty == CrateType::Executable);
let mut ctxt = EntryContext {
session: tcx.sess,
map: tcx.hir(),
- main_fn: None,
attr_main_fn: None,
start_fn: None,
non_main_fns: Vec::new(),
throw_attr_err(&ctxt.session, attr.span, "rustc_main");
}
}
- EntryPointType::MainNamed => {
- if ctxt.main_fn.is_none() {
- ctxt.main_fn = Some((item.hir_id(), item.span));
- } else {
- struct_span_err!(ctxt.session, item.span, E0136, "multiple `main` functions")
- .emit();
- }
- }
+ EntryPointType::MainNamed => (),
EntryPointType::OtherMain => {
ctxt.non_main_fns.push((item.hir_id(), item.span));
}
}
}
-fn configure_main(
- tcx: TyCtxt<'_>,
- visitor: &EntryContext<'_, '_>,
-) -> Option<(LocalDefId, EntryFnType)> {
+fn configure_main(tcx: TyCtxt<'_>, visitor: &EntryContext<'_, '_>) -> Option<(DefId, EntryFnType)> {
if let Some((hir_id, _)) = visitor.start_fn {
- Some((tcx.hir().local_def_id(hir_id), EntryFnType::Start))
+ Some((tcx.hir().local_def_id(hir_id).to_def_id(), EntryFnType::Start))
} else if let Some((hir_id, _)) = visitor.attr_main_fn {
- Some((tcx.hir().local_def_id(hir_id), EntryFnType::Main))
- } else if let Some((hir_id, _)) = visitor.main_fn {
- Some((tcx.hir().local_def_id(hir_id), EntryFnType::Main))
+ Some((tcx.hir().local_def_id(hir_id).to_def_id(), EntryFnType::Main))
+ } else if let Some(def_id) = tcx.main_def.and_then(|main_def| main_def.opt_fn_def_id()) {
+ if tcx.main_def.unwrap().is_import && !tcx.features().imported_main {
+ let span = tcx.main_def.unwrap().span;
+ feature_err(
+ &tcx.sess.parse_sess,
+ sym::imported_main,
+ span,
+ "using an imported function as entry point `main` is experimental",
+ )
+ .emit();
+ }
+ Some((def_id, EntryFnType::Main))
} else {
no_main_err(tcx, visitor);
None
} else {
err.note(¬e);
}
+
+ if let Some(main_def) = tcx.main_def {
+ if main_def.opt_fn_def_id().is_none() {
+ // There is something at `crate::main`, but it is not a function definition.
+ err.span_label(main_def.span, &format!("non-function item at `crate::main` is found"));
+ }
+ }
+
if tcx.sess.teach(&err.get_code().unwrap()) {
err.note(
"If you don't know the basics of Rust, you can go look to the Rust Book \
err.emit();
}
-pub fn find_entry_point(tcx: TyCtxt<'_>) -> Option<(LocalDefId, EntryFnType)> {
+pub fn find_entry_point(tcx: TyCtxt<'_>) -> Option<(DefId, EntryFnType)> {
tcx.entry_fn(LOCAL_CRATE)
}
// need to invoke queries itself, we cannot keep the query caches
// locked while doing so. Instead we copy out the
// `(query_key, dep_node_index)` pairs and release the lock again.
- let query_keys_and_indices: Vec<_> = query_cache
- .iter_results(|results| results.map(|(k, _, i)| (k.clone(), i)).collect());
+ let mut query_keys_and_indices = Vec::new();
+ query_cache.iter_results(&mut |k, _, i| query_keys_and_indices.push((k.clone(), i)));
// Now actually allocate the strings. If allocating the strings
// generates new entries in the query cache, we'll miss them but
let query_name = profiler.get_or_alloc_cached_string(query_name);
let event_id = event_id_builder.from_label(query_name).to_string_id();
- query_cache.iter_results(|results| {
- let query_invocation_ids: Vec<_> = results.map(|v| v.2.into()).collect();
-
- profiler.bulk_map_query_invocation_id_to_single_string(
- query_invocation_ids.into_iter(),
- event_id,
- );
+ let mut query_invocation_ids = Vec::new();
+ query_cache.iter_results(&mut |_, _, i| {
+ query_invocation_ids.push(i.into());
});
+
+ profiler.bulk_map_query_invocation_id_to_single_string(
+ query_invocation_ids.into_iter(),
+ event_id,
+ );
}
});
}
key_type: type_name::<C::Key>(),
value_size: mem::size_of::<C::Value>(),
value_type: type_name::<C::Value>(),
- entry_count: map.iter_results(|results| results.count()),
+ entry_count: 0,
local_def_id_keys: None,
};
- map.iter_results(|results| {
- for (key, _, _) in results {
- key.key_stats(&mut stats)
- }
+ map.iter_results(&mut |key, _, _| {
+ stats.entry_count += 1;
+ key.key_stats(&mut stats)
});
stats
}
type Cache;
}
-pub trait QueryStorage: Default {
+pub trait QueryStorage {
type Value: Debug;
type Stored: Clone;
fn store_nocache(&self, value: Self::Value) -> Self::Stored;
}
-pub trait QueryCache: QueryStorage {
+pub trait QueryCache: QueryStorage + Sized {
type Key: Hash + Eq + Clone + Debug;
type Sharded: Default;
index: DepNodeIndex,
) -> Self::Stored;
- fn iter<R>(
+ fn iter(
&self,
shards: &Sharded<Self::Sharded>,
- f: impl for<'a> FnOnce(
- &'a mut dyn Iterator<Item = (&'a Self::Key, &'a Self::Value, DepNodeIndex)>,
- ) -> R,
- ) -> R;
+ f: &mut dyn FnMut(&Self::Key, &Self::Value, DepNodeIndex),
+ );
}
pub struct DefaultCacheSelector;
value
}
- fn iter<R>(
+ fn iter(
&self,
shards: &Sharded<Self::Sharded>,
- f: impl for<'a> FnOnce(&'a mut dyn Iterator<Item = (&'a K, &'a V, DepNodeIndex)>) -> R,
- ) -> R {
+ f: &mut dyn FnMut(&Self::Key, &Self::Value, DepNodeIndex),
+ ) {
let shards = shards.lock_shards();
- let mut results = shards.iter().flat_map(|shard| shard.iter()).map(|(k, v)| (k, &v.0, v.1));
- f(&mut results)
+ for shard in shards.iter() {
+ for (k, v) in shard.iter() {
+ f(k, &v.0, v.1);
+ }
+ }
}
}
&value.0
}
- fn iter<R>(
+ fn iter(
&self,
shards: &Sharded<Self::Sharded>,
- f: impl for<'a> FnOnce(&'a mut dyn Iterator<Item = (&'a K, &'a V, DepNodeIndex)>) -> R,
- ) -> R {
+ f: &mut dyn FnMut(&Self::Key, &Self::Value, DepNodeIndex),
+ ) {
let shards = shards.lock_shards();
- let mut results = shards.iter().flat_map(|shard| shard.iter()).map(|(k, v)| (k, &v.0, v.1));
- f(&mut results)
+ for shard in shards.iter() {
+ for (k, v) in shard.iter() {
+ f(k, &v.0, v.1);
+ }
+ }
}
}
(self.hash_result)(hcx, value)
}
- pub(crate) fn handle_cycle_error(&self, tcx: CTX, diag: DiagnosticBuilder<'_>) -> V {
- (self.handle_cycle_error)(tcx, diag)
- }
-
pub(crate) fn cache_on_disk(&self, tcx: CTX, key: &K, value: Option<&V>) -> bool {
(self.cache_on_disk)(tcx, key, value)
}
use std::convert::TryFrom;
use std::hash::Hash;
-use std::marker::PhantomData;
use std::num::NonZeroU32;
#[cfg(parallel_compiler)]
/// The latch that is used to wait on this job.
#[cfg(parallel_compiler)]
latch: Option<QueryLatch<D>>,
-
- dummy: PhantomData<QueryLatch<D>>,
}
impl<D> QueryJob<D>
parent,
#[cfg(parallel_compiler)]
latch: None,
- dummy: PhantomData,
}
}
#[cfg(parallel_compiler)]
- pub(super) fn latch(&mut self, _id: QueryJobId<D>) -> QueryLatch<D> {
+ pub(super) fn latch(&mut self) -> QueryLatch<D> {
if self.latch.is_none() {
self.latch = Some(QueryLatch::new());
}
self.latch.as_ref().unwrap().clone()
}
- #[cfg(not(parallel_compiler))]
- pub(super) fn latch(&mut self, id: QueryJobId<D>) -> QueryLatch<D> {
- QueryLatch { id }
- }
-
/// Signals to waiters that the query is complete.
///
/// This does nothing for single threaded rustc,
}
#[cfg(not(parallel_compiler))]
-#[derive(Clone)]
-pub(super) struct QueryLatch<D> {
- id: QueryJobId<D>,
-}
-
-#[cfg(not(parallel_compiler))]
-impl<D> QueryLatch<D>
+impl<D> QueryJobId<D>
where
D: Copy + Clone + Eq + Hash,
{
let info = query_map.get(&job).unwrap();
cycle.push(info.info.clone());
- if job == self.id {
+ if job == *self {
cycle.reverse();
// This is the end of the cycle
};
use crate::query::{QueryContext, QueryMap, QueryStackFrame};
-#[cfg(not(parallel_compiler))]
-use rustc_data_structures::cold_path;
use rustc_data_structures::fingerprint::Fingerprint;
use rustc_data_structures::fx::{FxHashMap, FxHasher};
use rustc_data_structures::sharded::{get_shard_index_by_hash, Sharded};
use rustc_data_structures::sync::{Lock, LockGuard};
use rustc_data_structures::thin_vec::ThinVec;
+#[cfg(not(parallel_compiler))]
+use rustc_errors::DiagnosticBuilder;
use rustc_errors::{Diagnostic, FatalError};
use rustc_span::Span;
use std::collections::hash_map::Entry;
pub cache_hits: AtomicUsize,
}
-impl<C: QueryCache> Default for QueryCacheStore<C> {
+impl<C: QueryCache + Default> Default for QueryCacheStore<C> {
fn default() -> Self {
Self {
cache: C::default(),
(QueryLookup { key_hash, shard }, lock)
}
- pub fn iter_results<R>(
- &self,
- f: impl for<'a> FnOnce(
- &'a mut dyn Iterator<Item = (&'a C::Key, &'a C::Value, DepNodeIndex)>,
- ) -> R,
- ) -> R {
+ pub fn iter_results(&self, f: &mut dyn FnMut(&C::Key, &C::Value, DepNodeIndex)) {
self.cache.iter(&self.shards, f)
}
}
// We use try_lock_shards here since we are called from the
// deadlock handler, and this shouldn't be locked.
let shards = self.shards.try_lock_shards()?;
- let shards = shards.iter().enumerate();
- jobs.extend(shards.flat_map(|(shard_id, shard)| {
- shard.active.iter().filter_map(move |(k, v)| {
+ for (shard_id, shard) in shards.iter().enumerate() {
+ for (k, v) in shard.active.iter() {
if let QueryResult::Started(ref job) = *v {
let id = QueryJobId::new(job.id, shard_id, kind);
let info = QueryInfo { span: job.span, query: make_query(tcx, k.clone()) };
- Some((id, QueryJobInfo { info, job: job.clone() }))
- } else {
- None
+ jobs.insert(id, QueryJobInfo { info, job: job.clone() });
}
- })
- }));
+ }
+ }
Some(())
}
id: QueryJobId<D>,
}
+#[cold]
+#[inline(never)]
+#[cfg(not(parallel_compiler))]
+fn mk_cycle<CTX, V, R>(
+ tcx: CTX,
+ root: QueryJobId<CTX::DepKind>,
+ span: Span,
+ handle_cycle_error: fn(CTX, DiagnosticBuilder<'_>) -> V,
+ cache: &dyn crate::query::QueryStorage<Value = V, Stored = R>,
+) -> R
+where
+ CTX: QueryContext,
+ V: std::fmt::Debug,
+ R: Clone,
+{
+ let error: CycleError = root.find_cycle_in_stack(
+ tcx.try_collect_active_jobs().unwrap(),
+ &tcx.current_query_job(),
+ span,
+ );
+ let error = report_cycle(tcx.dep_context().sess(), error);
+ let value = handle_cycle_error(tcx, error);
+ cache.store_nocache(value)
+}
+
impl<'tcx, D, C> JobOwner<'tcx, D, C>
where
D: Copy + Clone + Eq + Hash,
state: &'b QueryState<CTX::DepKind, C::Key>,
cache: &'b QueryCacheStore<C>,
span: Span,
- key: &C::Key,
+ key: C::Key,
lookup: QueryLookup,
query: &QueryVtable<CTX, C::Key, C::Value>,
) -> TryGetJob<'b, CTX::DepKind, C>
let mut state_lock = state.shards.get_shard_by_index(shard).lock();
let lock = &mut *state_lock;
- let (latch, mut _query_blocked_prof_timer) = match lock.active.entry((*key).clone()) {
- Entry::Occupied(mut entry) => {
- match entry.get_mut() {
- QueryResult::Started(job) => {
- // For parallel queries, we'll block and wait until the query running
- // in another thread has completed. Record how long we wait in the
- // self-profiler.
- let _query_blocked_prof_timer = if cfg!(parallel_compiler) {
- Some(tcx.dep_context().profiler().query_blocked())
- } else {
- None
- };
-
- // Create the id of the job we're waiting for
- let id = QueryJobId::new(job.id, shard, query.dep_kind);
-
- (job.latch(id), _query_blocked_prof_timer)
- }
- QueryResult::Poisoned => FatalError.raise(),
- }
- }
+ match lock.active.entry(key) {
Entry::Vacant(entry) => {
- // No job entry for this query. Return a new one to be started later.
-
// Generate an id unique within this shard.
let id = lock.jobs.checked_add(1).unwrap();
lock.jobs = id;
let id = QueryShardJobId(NonZeroU32::new(id).unwrap());
- let global_id = QueryJobId::new(id, shard, query.dep_kind);
-
let job = tcx.current_query_job();
let job = QueryJob::new(id, span, job);
+ let key = entry.key().clone();
entry.insert(QueryResult::Started(job));
- let owner = JobOwner { state, cache, id: global_id, key: (*key).clone() };
+ let global_id = QueryJobId::new(id, shard, query.dep_kind);
+ let owner = JobOwner { state, cache, id: global_id, key };
return TryGetJob::NotYetStarted(owner);
}
- };
- mem::drop(state_lock);
-
- // If we are single-threaded we know that we have cycle error,
- // so we just return the error.
- #[cfg(not(parallel_compiler))]
- return TryGetJob::Cycle(cold_path(|| {
- let error: CycleError = latch.find_cycle_in_stack(
- tcx.try_collect_active_jobs().unwrap(),
- &tcx.current_query_job(),
- span,
- );
- let error = report_cycle(tcx.dep_context().sess(), error);
- let value = query.handle_cycle_error(tcx, error);
- cache.cache.store_nocache(value)
- }));
-
- // With parallel queries we might just have to wait on some other
- // thread.
- #[cfg(parallel_compiler)]
- {
- let result = latch.wait_on(tcx.current_query_job(), span);
-
- if let Err(cycle) = result {
- let cycle = report_cycle(tcx.dep_context().sess(), cycle);
- let value = query.handle_cycle_error(tcx, cycle);
- let value = cache.cache.store_nocache(value);
- return TryGetJob::Cycle(value);
- }
+ Entry::Occupied(mut entry) => {
+ match entry.get_mut() {
+ #[cfg(not(parallel_compiler))]
+ QueryResult::Started(job) => {
+ let id = QueryJobId::new(job.id, shard, query.dep_kind);
- let cached = cache
- .cache
- .lookup(cache, &key, |value, index| {
- if unlikely!(tcx.dep_context().profiler().enabled()) {
- tcx.dep_context().profiler().query_cache_hit(index.into());
+ drop(state_lock);
+
+ // If we are single-threaded we know that we have cycle error,
+ // so we just return the error.
+ return TryGetJob::Cycle(mk_cycle(
+ tcx,
+ id,
+ span,
+ query.handle_cycle_error,
+ &cache.cache,
+ ));
}
- #[cfg(debug_assertions)]
- {
- cache.cache_hits.fetch_add(1, Ordering::Relaxed);
+ #[cfg(parallel_compiler)]
+ QueryResult::Started(job) => {
+ // For parallel queries, we'll block and wait until the query running
+ // in another thread has completed. Record how long we wait in the
+ // self-profiler.
+ let query_blocked_prof_timer = tcx.dep_context().profiler().query_blocked();
+
+ // Get the latch out
+ let latch = job.latch();
+ let key = entry.key().clone();
+
+ drop(state_lock);
+
+ // With parallel queries we might just have to wait on some other
+ // thread.
+ let result = latch.wait_on(tcx.current_query_job(), span);
+
+ if let Err(cycle) = result {
+ let cycle = report_cycle(tcx.dep_context().sess(), cycle);
+ let value = (query.handle_cycle_error)(tcx, cycle);
+ let value = cache.cache.store_nocache(value);
+ return TryGetJob::Cycle(value);
+ }
+
+ let cached = cache
+ .cache
+ .lookup(cache, &key, |value, index| {
+ if unlikely!(tcx.dep_context().profiler().enabled()) {
+ tcx.dep_context().profiler().query_cache_hit(index.into());
+ }
+ #[cfg(debug_assertions)]
+ {
+ cache.cache_hits.fetch_add(1, Ordering::Relaxed);
+ }
+ (value.clone(), index)
+ })
+ .unwrap_or_else(|_| panic!("value must be in cache after waiting"));
+
+ query_blocked_prof_timer.finish_with_query_invocation_id(cached.1.into());
+
+ return TryGetJob::JobCompleted(cached);
}
- (value.clone(), index)
- })
- .unwrap_or_else(|_| panic!("value must be in cache after waiting"));
-
- if let Some(prof_timer) = _query_blocked_prof_timer.take() {
- prof_timer.finish_with_query_invocation_id(cached.1.into());
+ QueryResult::Poisoned => FatalError.raise(),
+ }
}
-
- return TryGetJob::JobCompleted(cached);
}
}
CTX: QueryContext,
{
let job = match JobOwner::<'_, CTX::DepKind, C>::try_start(
- tcx, state, cache, span, &key, lookup, query,
+ tcx,
+ state,
+ cache,
+ span,
+ key.clone(),
+ lookup,
+ query,
) {
TryGetJob::NotYetStarted(job) => job,
TryGetJob::Cycle(result) => return result,
};
let job = match JobOwner::<'_, CTX::DepKind, C>::try_start(
- tcx, state, cache, span, &key, lookup, query,
+ tcx,
+ state,
+ cache,
+ span,
+ key.clone(),
+ lookup,
+ query,
) {
TryGetJob::NotYetStarted(job) => job,
TryGetJob::Cycle(_) => return,
name
));
}
- err.help("use `#![feature(const_generics)]` and `#![feature(const_evaluatable_checked)]` to allow generic const expressions");
+
+ if self.session.is_nightly_build() {
+ err.help(
+ "use `#![feature(const_generics)]` and `#![feature(const_evaluatable_checked)]` \
+ to allow generic const expressions"
+ );
+ }
err
}
_ => false,
};
+ let find_span = |source: &PathSource<'_>, err: &mut DiagnosticBuilder<'_>| {
+ match source {
+ PathSource::Expr(Some(Expr { span, kind: ExprKind::Call(_, _), .. }))
+ | PathSource::TupleStruct(span, _) => {
+ // We want the main underline to cover the suggested code as well for
+ // cleaner output.
+ err.set_span(*span);
+ *span
+ }
+ _ => span,
+ }
+ };
+
let mut bad_struct_syntax_suggestion = |def_id: DefId| {
let (followed_by_brace, closing_brace) = self.followed_by_brace(span);
}
}
PathSource::Expr(_) | PathSource::TupleStruct(..) | PathSource::Pat => {
- let span = match &source {
- PathSource::Expr(Some(Expr {
- span, kind: ExprKind::Call(_, _), ..
- }))
- | PathSource::TupleStruct(span, _) => {
- // We want the main underline to cover the suggested code as well for
- // cleaner output.
- err.set_span(*span);
- *span
- }
- _ => span,
- };
+ let span = find_span(&source, err);
if let Some(span) = self.def_span(def_id) {
err.span_label(span, &format!("`{}` defined here", path_str));
}
) if ns == ValueNS => {
bad_struct_syntax_suggestion(def_id);
}
+ (Res::Def(DefKind::Ctor(_, CtorKind::Const), def_id), _) if ns == ValueNS => {
+ match source {
+ PathSource::Expr(_) | PathSource::TupleStruct(..) | PathSource::Pat => {
+ let span = find_span(&source, err);
+ if let Some(span) = self.def_span(def_id) {
+ err.span_label(span, &format!("`{}` defined here", path_str));
+ }
+ err.span_suggestion(
+ span,
+ &format!("use this syntax instead"),
+ format!("{path_str}"),
+ Applicability::MaybeIncorrect,
+ );
+ }
+ _ => return false,
+ }
+ }
(Res::Def(DefKind::Ctor(_, CtorKind::Fn), def_id), _) if ns == ValueNS => {
if let Some(span) = self.def_span(def_id) {
err.span_label(span, &format!("`{}` defined here", path_str));
use rustc_middle::middle::cstore::{CrateStore, MetadataLoaderDyn};
use rustc_middle::span_bug;
use rustc_middle::ty::query::Providers;
-use rustc_middle::ty::{self, DefIdTree, ResolverOutputs};
+use rustc_middle::ty::{self, DefIdTree, MainDefinition, ResolverOutputs};
use rustc_session::lint;
use rustc_session::lint::{BuiltinLintDiagnostics, LintBuffer};
use rustc_session::Session;
trait_impl_items: FxHashSet<LocalDefId>,
legacy_const_generic_args: FxHashMap<DefId, Option<Vec<usize>>>,
+
+ main_def: Option<MainDefinition>,
}
/// Nothing really interesting here; it just provides memory for the rest of the crate.
next_disambiguator: Default::default(),
trait_impl_items: Default::default(),
legacy_const_generic_args: Default::default(),
+ main_def: Default::default(),
};
let root_parent_scope = ParentScope::module(graph_root, &resolver);
let maybe_unused_trait_imports = self.maybe_unused_trait_imports;
let maybe_unused_extern_crates = self.maybe_unused_extern_crates;
let glob_map = self.glob_map;
+ let main_def = self.main_def;
ResolverOutputs {
definitions,
cstore: Box::new(self.crate_loader.into_cstore()),
.iter()
.map(|(ident, entry)| (ident.name, entry.introduced_by_item))
.collect(),
+ main_def,
}
}
.iter()
.map(|(ident, entry)| (ident.name, entry.introduced_by_item))
.collect(),
+ main_def: self.main_def.clone(),
}
}
self.session.time("finalize_imports", || ImportResolver { r: self }.finalize_imports());
self.session.time("finalize_macro_resolutions", || self.finalize_macro_resolutions());
self.session.time("late_resolve_crate", || self.late_resolve_crate(krate));
+ self.session.time("resolve_main", || self.resolve_main());
self.session.time("resolve_check_unused", || self.check_unused(krate));
self.session.time("resolve_report_errors", || self.report_errors(krate));
self.session.time("resolve_postprocess", || self.crate_loader.postprocess(krate));
}
None
}
+
+ fn resolve_main(&mut self) {
+ let module = self.graph_root;
+ let ident = Ident::with_dummy_span(sym::main);
+ let parent_scope = &ParentScope::module(module, self);
+
+ let name_binding = match self.resolve_ident_in_module(
+ ModuleOrUniformRoot::Module(module),
+ ident,
+ ValueNS,
+ parent_scope,
+ false,
+ DUMMY_SP,
+ ) {
+ Ok(name_binding) => name_binding,
+ _ => return,
+ };
+
+ let res = name_binding.res();
+ let is_import = name_binding.is_import();
+ let span = name_binding.span;
+ if let Res::Def(DefKind::Fn, _) = res {
+ self.record_use(ident, ValueNS, name_binding, false);
+ }
+ self.main_def = Some(MainDefinition { res, is_import, span });
+ }
}
fn names_to_string(names: &[Symbol]) -> String {
use crate::lint;
use crate::search_paths::SearchPath;
-use crate::utils::{CanonicalizedPath, NativeLibKind};
+use crate::utils::{CanonicalizedPath, NativeLib, NativeLibKind};
use crate::{early_error, early_warn, Session};
use rustc_data_structures::fx::FxHashSet;
Off,
}
-#[derive(Clone, PartialEq, Hash)]
+#[derive(Clone, PartialEq, Hash, Debug)]
pub enum LinkerPluginLto {
LinkerPlugin(PathBuf),
LinkerPluginAuto,
}
}
-#[derive(Clone, PartialEq, Hash)]
+#[derive(Clone, PartialEq, Hash, Debug)]
pub enum SwitchWithOptPath {
Enabled(Option<PathBuf>),
Disabled,
cli_forced_codegen_units: None,
cli_forced_thinlto_off: false,
remap_path_prefix: Vec::new(),
+ real_rust_source_base_dir: None,
edition: DEFAULT_EDITION,
json_artifact_notifications: false,
json_unused_externs: false,
impl_stable_hash_via_hash!(CrateType);
-#[derive(Clone, Hash)]
+#[derive(Clone, Hash, Debug, PartialEq, Eq)]
pub enum Passes {
Some(Vec<String>),
All,
ret.reserve(6); // the minimum number of insertions
// Target bindings.
ret.insert((sym::target_os, Some(Symbol::intern(os))));
- if let Some(ref fam) = sess.target.os_family {
+ for fam in &sess.target.families {
ret.insert((sym::target_family, Some(Symbol::intern(fam))));
if fam == "windows" {
ret.insert((sym::windows, None));
"",
"Link the generated crate(s) to the specified native
library NAME. The optional KIND can be one of
- static, framework, or dylib (the default).",
- "[KIND=]NAME",
+ static, framework, or dylib (the default).
+ Optional comma separated MODIFIERS (bundle|verbatim|whole-archive|as-needed)
+ may be specified each with a prefix of either '+' to
+ enable or '-' to disable.",
+ "[KIND[:MODIFIERS]=]NAME[:RENAME]",
),
make_crate_type_option(),
opt::opt_s("", "crate-name", "Specify the name of the crate being built", "NAME"),
}
}
-fn parse_libs(
- matches: &getopts::Matches,
+fn parse_native_lib_kind(kind: &str, error_format: ErrorOutputType) -> NativeLibKind {
+ match kind {
+ "dylib" => NativeLibKind::Dylib { as_needed: None },
+ "framework" => NativeLibKind::Framework { as_needed: None },
+ "static" => NativeLibKind::Static { bundle: None, whole_archive: None },
+ "static-nobundle" => {
+ early_warn(
+ error_format,
+ "library kind `static-nobundle` has been superseded by specifying \
+ `-bundle` on library kind `static`. Try `static:-bundle`",
+ );
+ NativeLibKind::Static { bundle: Some(false), whole_archive: None }
+ }
+ s => early_error(
+ error_format,
+ &format!("unknown library kind `{}`, expected one of dylib, framework, or static", s),
+ ),
+ }
+}
+
+fn parse_native_lib_modifiers(
+ is_nightly: bool,
+ mut kind: NativeLibKind,
+ modifiers: &str,
error_format: ErrorOutputType,
-) -> Vec<(String, Option<String>, NativeLibKind)> {
+) -> (NativeLibKind, Option<bool>) {
+ let mut verbatim = None;
+ for modifier in modifiers.split(',') {
+ let (modifier, value) = match modifier.strip_prefix(&['+', '-'][..]) {
+ Some(m) => (m, modifier.starts_with('+')),
+ None => early_error(
+ error_format,
+ "invalid linking modifier syntax, expected '+' or '-' prefix \
+ before one of: bundle, verbatim, whole-archive, as-needed",
+ ),
+ };
+
+ if !is_nightly {
+ early_error(
+ error_format,
+ "linking modifiers are currently unstable and only accepted on \
+ the nightly compiler",
+ );
+ }
+
+ match (modifier, &mut kind) {
+ ("bundle", NativeLibKind::Static { bundle, .. }) => {
+ *bundle = Some(value);
+ }
+ ("bundle", _) => early_error(
+ error_format,
+ "bundle linking modifier is only compatible with \
+ `static` linking kind",
+ ),
+
+ ("verbatim", _) => verbatim = Some(value),
+
+ ("whole-archive", NativeLibKind::Static { whole_archive, .. }) => {
+ *whole_archive = Some(value);
+ }
+ ("whole-archive", _) => early_error(
+ error_format,
+ "whole-archive linking modifier is only compatible with \
+ `static` linking kind",
+ ),
+
+ ("as-needed", NativeLibKind::Dylib { as_needed })
+ | ("as-needed", NativeLibKind::Framework { as_needed }) => {
+ *as_needed = Some(value);
+ }
+ ("as-needed", _) => early_error(
+ error_format,
+ "as-needed linking modifier is only compatible with \
+ `dylib` and `framework` linking kinds",
+ ),
+
+ _ => early_error(
+ error_format,
+ &format!(
+ "unrecognized linking modifier `{}`, expected one \
+ of: bundle, verbatim, whole-archive, as-needed",
+ modifier
+ ),
+ ),
+ }
+ }
+
+ (kind, verbatim)
+}
+
+fn parse_libs(matches: &getopts::Matches, error_format: ErrorOutputType) -> Vec<NativeLib> {
+ let is_nightly = nightly_options::match_is_nightly_build(matches);
matches
.opt_strs("l")
.into_iter()
.map(|s| {
- // Parse string of the form "[KIND=]lib[:new_name]",
- // where KIND is one of "dylib", "framework", "static".
- let (name, kind) = match s.split_once('=') {
- None => (s, NativeLibKind::Unspecified),
+ // Parse string of the form "[KIND[:MODIFIERS]=]lib[:new_name]",
+ // where KIND is one of "dylib", "framework", "static" and
+ // where MODIFIERS are a comma separated list of supported modifiers
+ // (bundle, verbatim, whole-archive, as-needed). Each modifier is prefixed
+ // with either + or - to indicate whether it is enabled or disabled.
+ // The last value specified for a given modifier wins.
+ let (name, kind, verbatim) = match s.split_once('=') {
+ None => (s, NativeLibKind::Unspecified, None),
Some((kind, name)) => {
- let kind = match kind {
- "dylib" => NativeLibKind::Dylib,
- "framework" => NativeLibKind::Framework,
- "static" => NativeLibKind::StaticBundle,
- "static-nobundle" => NativeLibKind::StaticNoBundle,
- s => {
- early_error(
- error_format,
- &format!(
- "unknown library kind `{}`, expected \
- one of dylib, framework, or static",
- s
- ),
- );
+ let (kind, verbatim) = match kind.split_once(':') {
+ None => (parse_native_lib_kind(kind, error_format), None),
+ Some((kind, modifiers)) => {
+ let kind = parse_native_lib_kind(kind, error_format);
+ parse_native_lib_modifiers(is_nightly, kind, modifiers, error_format)
}
};
- (name.to_string(), kind)
+ (name.to_string(), kind, verbatim)
}
};
- if kind == NativeLibKind::StaticNoBundle
- && !nightly_options::match_is_nightly_build(matches)
- {
- early_error(
- error_format,
- "the library kind 'static-nobundle' is only \
- accepted on the nightly compiler",
- );
- }
+
let (name, new_name) = match name.split_once(':') {
None => (name, None),
Some((name, new_name)) => (name.to_string(), Some(new_name.to_owned())),
};
- (name, new_name, kind)
+ NativeLib { name, new_name, kind, verbatim }
})
.collect()
}
}
}
+ // Try to find a directory containing the Rust `src`, for more details see
+ // the doc comment on the `real_rust_source_base_dir` field.
+ let tmp_buf;
+ let sysroot = match &sysroot_opt {
+ Some(s) => s,
+ None => {
+ tmp_buf = crate::filesearch::get_or_default_sysroot();
+ &tmp_buf
+ }
+ };
+ let real_rust_source_base_dir = {
+ // This is the location used by the `rust-src` `rustup` component.
+ let mut candidate = sysroot.join("lib/rustlib/src/rust");
+ if let Ok(metadata) = candidate.symlink_metadata() {
+ // Replace the symlink rustbuild creates, with its destination.
+ // We could try to use `fs::canonicalize` instead, but that might
+ // produce unnecessarily verbose path.
+ if metadata.file_type().is_symlink() {
+ if let Ok(symlink_dest) = std::fs::read_link(&candidate) {
+ candidate = symlink_dest;
+ }
+ }
+ }
+
+ // Only use this directory if it has a file we can expect to always find.
+ if candidate.join("library/std/src/lib.rs").is_file() { Some(candidate) } else { None }
+ };
+
Options {
crate_types,
optimize: opt_level,
cli_forced_codegen_units: codegen_units,
cli_forced_thinlto_off: disable_thinlto,
remap_path_prefix,
+ real_rust_source_base_dir,
edition,
json_artifact_notifications,
json_unused_externs,
};
use crate::lint;
use crate::options::WasiExecModel;
- use crate::utils::NativeLibKind;
+ use crate::utils::{NativeLib, NativeLibKind};
use rustc_feature::UnstableFeatures;
use rustc_span::edition::Edition;
use rustc_target::spec::{CodeModel, MergeFunctions, PanicStrategy, RelocModel};
}
macro_rules! impl_dep_tracking_hash_via_hash {
- ($t:ty) => {
+ ($($t:ty),+ $(,)?) => {$(
impl DepTrackingHash for $t {
fn hash(&self, hasher: &mut DefaultHasher, _: ErrorOutputType) {
Hash::hash(self, hasher);
}
}
- };
+ )+};
}
macro_rules! impl_dep_tracking_hash_for_sortable_vec_of {
- ($t:ty) => {
+ ($($t:ty),+ $(,)?) => {$(
impl DepTrackingHash for Vec<$t> {
fn hash(&self, hasher: &mut DefaultHasher, error_format: ErrorOutputType) {
let mut elems: Vec<&$t> = self.iter().collect();
}
}
}
- };
- }
+ )+};
+ }
+
+ impl_dep_tracking_hash_via_hash!(
+ bool,
+ usize,
+ u64,
+ String,
+ PathBuf,
+ lint::Level,
+ Option<bool>,
+ Option<u32>,
+ Option<usize>,
+ Option<NonZeroUsize>,
+ Option<String>,
+ Option<(String, u64)>,
+ Option<Vec<String>>,
+ Option<MergeFunctions>,
+ Option<RelocModel>,
+ Option<CodeModel>,
+ Option<TlsModel>,
+ Option<WasiExecModel>,
+ Option<PanicStrategy>,
+ Option<RelroLevel>,
+ Option<InstrumentCoverage>,
+ Option<lint::Level>,
+ Option<PathBuf>,
+ CrateType,
+ MergeFunctions,
+ PanicStrategy,
+ RelroLevel,
+ Passes,
+ OptLevel,
+ LtoCli,
+ DebugInfo,
+ UnstableFeatures,
+ OutputTypes,
+ NativeLib,
+ NativeLibKind,
+ SanitizerSet,
+ CFGuard,
+ TargetTriple,
+ Edition,
+ LinkerPluginLto,
+ Option<SplitDebuginfo>,
+ SwitchWithOptPath,
+ Option<SymbolManglingVersion>,
+ Option<SourceFileHashAlgorithm>,
+ TrimmedDefPaths,
+ );
- impl_dep_tracking_hash_via_hash!(bool);
- impl_dep_tracking_hash_via_hash!(usize);
- impl_dep_tracking_hash_via_hash!(u64);
- impl_dep_tracking_hash_via_hash!(String);
- impl_dep_tracking_hash_via_hash!(PathBuf);
- impl_dep_tracking_hash_via_hash!(lint::Level);
- impl_dep_tracking_hash_via_hash!(Option<bool>);
- impl_dep_tracking_hash_via_hash!(Option<u32>);
- impl_dep_tracking_hash_via_hash!(Option<usize>);
- impl_dep_tracking_hash_via_hash!(Option<NonZeroUsize>);
- impl_dep_tracking_hash_via_hash!(Option<String>);
- impl_dep_tracking_hash_via_hash!(Option<(String, u64)>);
- impl_dep_tracking_hash_via_hash!(Option<Vec<String>>);
- impl_dep_tracking_hash_via_hash!(Option<MergeFunctions>);
- impl_dep_tracking_hash_via_hash!(Option<RelocModel>);
- impl_dep_tracking_hash_via_hash!(Option<CodeModel>);
- impl_dep_tracking_hash_via_hash!(Option<TlsModel>);
- impl_dep_tracking_hash_via_hash!(Option<WasiExecModel>);
- impl_dep_tracking_hash_via_hash!(Option<PanicStrategy>);
- impl_dep_tracking_hash_via_hash!(Option<RelroLevel>);
- impl_dep_tracking_hash_via_hash!(Option<InstrumentCoverage>);
- impl_dep_tracking_hash_via_hash!(Option<lint::Level>);
- impl_dep_tracking_hash_via_hash!(Option<PathBuf>);
- impl_dep_tracking_hash_via_hash!(CrateType);
- impl_dep_tracking_hash_via_hash!(MergeFunctions);
- impl_dep_tracking_hash_via_hash!(PanicStrategy);
- impl_dep_tracking_hash_via_hash!(RelroLevel);
- impl_dep_tracking_hash_via_hash!(Passes);
- impl_dep_tracking_hash_via_hash!(OptLevel);
- impl_dep_tracking_hash_via_hash!(LtoCli);
- impl_dep_tracking_hash_via_hash!(DebugInfo);
- impl_dep_tracking_hash_via_hash!(UnstableFeatures);
- impl_dep_tracking_hash_via_hash!(OutputTypes);
- impl_dep_tracking_hash_via_hash!(NativeLibKind);
- impl_dep_tracking_hash_via_hash!(SanitizerSet);
- impl_dep_tracking_hash_via_hash!(CFGuard);
- impl_dep_tracking_hash_via_hash!(TargetTriple);
- impl_dep_tracking_hash_via_hash!(Edition);
- impl_dep_tracking_hash_via_hash!(LinkerPluginLto);
- impl_dep_tracking_hash_via_hash!(Option<SplitDebuginfo>);
- impl_dep_tracking_hash_via_hash!(SwitchWithOptPath);
- impl_dep_tracking_hash_via_hash!(Option<SymbolManglingVersion>);
- impl_dep_tracking_hash_via_hash!(Option<SourceFileHashAlgorithm>);
- impl_dep_tracking_hash_via_hash!(TrimmedDefPaths);
-
- impl_dep_tracking_hash_for_sortable_vec_of!(String);
- impl_dep_tracking_hash_for_sortable_vec_of!(PathBuf);
- impl_dep_tracking_hash_for_sortable_vec_of!(CrateType);
- impl_dep_tracking_hash_for_sortable_vec_of!((String, lint::Level));
- impl_dep_tracking_hash_for_sortable_vec_of!((String, Option<String>, NativeLibKind));
- impl_dep_tracking_hash_for_sortable_vec_of!((String, u64));
+ impl_dep_tracking_hash_for_sortable_vec_of!(
+ String,
+ PathBuf,
+ (PathBuf, PathBuf),
+ CrateType,
+ NativeLib,
+ (String, lint::Level),
+ (String, u64)
+ );
impl<T1, T2> DepTrackingHash for (T1, T2)
where
use crate::early_error;
use crate::lint;
use crate::search_paths::SearchPath;
-use crate::utils::NativeLibKind;
+use crate::utils::NativeLib;
use rustc_target::spec::{CodeModel, LinkerFlavor, MergeFunctions, PanicStrategy, SanitizerSet};
use rustc_target::spec::{RelocModel, RelroLevel, SplitDebuginfo, TargetTriple, TlsModel};
use std::path::PathBuf;
use std::str;
-macro_rules! hash_option {
- ($opt_name:ident, $opt_expr:expr, $sub_hashes:expr, [UNTRACKED]) => {{}};
- ($opt_name:ident, $opt_expr:expr, $sub_hashes:expr, [TRACKED]) => {{
+macro_rules! insert {
+ ($opt_name:ident, $opt_expr:expr, $sub_hashes:expr) => {
if $sub_hashes
.insert(stringify!($opt_name), $opt_expr as &dyn dep_tracking::DepTrackingHash)
.is_some()
{
panic!("duplicate key in CLI DepTrackingHash: {}", stringify!($opt_name))
}
+ };
+}
+
+macro_rules! hash_opt {
+ ($opt_name:ident, $opt_expr:expr, $sub_hashes:expr, $_for_crate_hash: ident, [UNTRACKED]) => {{}};
+ ($opt_name:ident, $opt_expr:expr, $sub_hashes:expr, $_for_crate_hash: ident, [TRACKED]) => {{ insert!($opt_name, $opt_expr, $sub_hashes) }};
+ ($opt_name:ident, $opt_expr:expr, $sub_hashes:expr, $for_crate_hash: ident, [TRACKED_NO_CRATE_HASH]) => {{
+ if !$for_crate_hash {
+ insert!($opt_name, $opt_expr, $sub_hashes)
+ }
}};
+ ($opt_name:ident, $opt_expr:expr, $sub_hashes:expr, $_for_crate_hash: ident, [SUBSTRUCT]) => {{}};
+}
+
+macro_rules! hash_substruct {
+ ($opt_name:ident, $opt_expr:expr, $error_format:expr, $for_crate_hash:expr, $hasher:expr, [UNTRACKED]) => {{}};
+ ($opt_name:ident, $opt_expr:expr, $error_format:expr, $for_crate_hash:expr, $hasher:expr, [TRACKED]) => {{}};
+ ($opt_name:ident, $opt_expr:expr, $error_format:expr, $for_crate_hash:expr, $hasher:expr, [TRACKED_NO_CRATE_HASH]) => {{}};
+ ($opt_name:ident, $opt_expr:expr, $error_format:expr, $for_crate_hash:expr, $hasher:expr, [SUBSTRUCT]) => {
+ use crate::config::dep_tracking::DepTrackingHash;
+ $opt_expr.dep_tracking_hash($for_crate_hash, $error_format).hash($hasher, $error_format);
+ };
}
macro_rules! top_level_options {
- (pub struct Options { $(
- $opt:ident : $t:ty [$dep_tracking_marker:ident $($warn_val:expr, $warn_text:expr)*],
+ ( $( #[$top_level_attr:meta] )* pub struct Options { $(
+ $( #[$attr:meta] )*
+ $opt:ident : $t:ty [$dep_tracking_marker:ident],
)* } ) => (
#[derive(Clone)]
+ $( #[$top_level_attr] )*
pub struct Options {
- $(pub $opt: $t),*
+ $(
+ $( #[$attr] )*
+ pub $opt: $t
+ ),*
}
impl Options {
- pub fn dep_tracking_hash(&self) -> u64 {
+ pub fn dep_tracking_hash(&self, for_crate_hash: bool) -> u64 {
let mut sub_hashes = BTreeMap::new();
$({
- hash_option!($opt,
- &self.$opt,
- &mut sub_hashes,
- [$dep_tracking_marker $($warn_val,
- $warn_text,
- self.error_format)*]);
+ hash_opt!($opt,
+ &self.$opt,
+ &mut sub_hashes,
+ for_crate_hash,
+ [$dep_tracking_marker]);
})*
let mut hasher = DefaultHasher::new();
dep_tracking::stable_hash(sub_hashes,
&mut hasher,
self.error_format);
+ $({
+ hash_substruct!($opt,
+ &self.$opt,
+ self.error_format,
+ for_crate_hash,
+ &mut hasher,
+ [$dep_tracking_marker]);
+ })*
hasher.finish()
}
}
);
}
-// The top-level command-line options struct.
-//
-// For each option, one has to specify how it behaves with regard to the
-// dependency tracking system of incremental compilation. This is done via the
-// square-bracketed directive after the field type. The options are:
-//
-// [TRACKED]
-// A change in the given field will cause the compiler to completely clear the
-// incremental compilation cache before proceeding.
-//
-// [UNTRACKED]
-// Incremental compilation is not influenced by this option.
-//
-// If you add a new option to this struct or one of the sub-structs like
-// `CodegenOptions`, think about how it influences incremental compilation. If in
-// doubt, specify [TRACKED], which is always "correct" but might lead to
-// unnecessary re-compilation.
top_level_options!(
+ /// The top-level command-line options struct.
+ ///
+ /// For each option, one has to specify how it behaves with regard to the
+ /// dependency tracking system of incremental compilation. This is done via the
+ /// square-bracketed directive after the field type. The options are:
+ ///
+ /// - `[TRACKED]`
+ /// A change in the given field will cause the compiler to completely clear the
+ /// incremental compilation cache before proceeding.
+ ///
+ /// - `[TRACKED_NO_CRATE_HASH]`
+ /// Same as `[TRACKED]`, but will not affect the crate hash. This is useful for options that only
+ /// affect the incremental cache.
+ ///
+ /// - `[UNTRACKED]`
+ /// Incremental compilation is not influenced by this option.
+ ///
+ /// - `[SUBSTRUCT]`
+ /// Second-level sub-structs containing more options.
+ ///
+ /// If you add a new option to this struct or one of the sub-structs like
+ /// `CodegenOptions`, think about how it influences incremental compilation. If in
+ /// doubt, specify `[TRACKED]`, which is always "correct" but might lead to
+ /// unnecessary re-compilation.
pub struct Options {
- // The crate config requested for the session, which may be combined
- // with additional crate configurations during the compile process.
+ /// The crate config requested for the session, which may be combined
+ /// with additional crate configurations during the compile process.
crate_types: Vec<CrateType> [TRACKED],
optimize: OptLevel [TRACKED],
- // Include the `debug_assertions` flag in dependency tracking, since it
- // can influence whether overflow checks are done or not.
+ /// Include the `debug_assertions` flag in dependency tracking, since it
+ /// can influence whether overflow checks are done or not.
debug_assertions: bool [TRACKED],
debuginfo: DebugInfo [TRACKED],
lint_opts: Vec<(String, lint::Level)> [TRACKED],
describe_lints: bool [UNTRACKED],
output_types: OutputTypes [TRACKED],
search_paths: Vec<SearchPath> [UNTRACKED],
- libs: Vec<(String, Option<String>, NativeLibKind)> [TRACKED],
+ libs: Vec<NativeLib> [TRACKED],
maybe_sysroot: Option<PathBuf> [UNTRACKED],
target_triple: TargetTriple [TRACKED],
test: bool [TRACKED],
error_format: ErrorOutputType [UNTRACKED],
- // If `Some`, enable incremental compilation, using the given
- // directory to store intermediate results.
+ /// If `Some`, enable incremental compilation, using the given
+ /// directory to store intermediate results.
incremental: Option<PathBuf> [UNTRACKED],
- debugging_opts: DebuggingOptions [TRACKED],
+ debugging_opts: DebuggingOptions [SUBSTRUCT],
prints: Vec<PrintRequest> [UNTRACKED],
- // Determines which borrow checker(s) to run. This is the parsed, sanitized
- // version of `debugging_opts.borrowck`, which is just a plain string.
+ /// Determines which borrow checker(s) to run. This is the parsed, sanitized
+ /// version of `debugging_opts.borrowck`, which is just a plain string.
borrowck_mode: BorrowckMode [UNTRACKED],
- cg: CodegenOptions [TRACKED],
+ cg: CodegenOptions [SUBSTRUCT],
externs: Externs [UNTRACKED],
extern_dep_specs: ExternDepSpecs [UNTRACKED],
crate_name: Option<String> [TRACKED],
- // An optional name to use as the crate for std during std injection,
- // written `extern crate name as std`. Defaults to `std`. Used by
- // out-of-tree drivers.
+ /// An optional name to use as the crate for std during std injection,
+ /// written `extern crate name as std`. Defaults to `std`. Used by
+ /// out-of-tree drivers.
alt_std_name: Option<String> [TRACKED],
- // Indicates how the compiler should treat unstable features.
+ /// Indicates how the compiler should treat unstable features.
unstable_features: UnstableFeatures [TRACKED],
- // Indicates whether this run of the compiler is actually rustdoc. This
- // is currently just a hack and will be removed eventually, so please
- // try to not rely on this too much.
+ /// Indicates whether this run of the compiler is actually rustdoc. This
+ /// is currently just a hack and will be removed eventually, so please
+ /// try to not rely on this too much.
actually_rustdoc: bool [TRACKED],
- // Control path trimming.
+ /// Control path trimming.
trimmed_def_paths: TrimmedDefPaths [TRACKED],
- // Specifications of codegen units / ThinLTO which are forced as a
- // result of parsing command line options. These are not necessarily
- // what rustc was invoked with, but massaged a bit to agree with
- // commands like `--emit llvm-ir` which they're often incompatible with
- // if we otherwise use the defaults of rustc.
+ /// Specifications of codegen units / ThinLTO which are forced as a
+ /// result of parsing command line options. These are not necessarily
+ /// what rustc was invoked with, but massaged a bit to agree with
+ /// commands like `--emit llvm-ir` which they're often incompatible with
+ /// if we otherwise use the defaults of rustc.
cli_forced_codegen_units: Option<usize> [UNTRACKED],
cli_forced_thinlto_off: bool [UNTRACKED],
- // Remap source path prefixes in all output (messages, object files, debug, etc.).
- remap_path_prefix: Vec<(PathBuf, PathBuf)> [UNTRACKED],
+ /// Remap source path prefixes in all output (messages, object files, debug, etc.).
+ remap_path_prefix: Vec<(PathBuf, PathBuf)> [TRACKED_NO_CRATE_HASH],
+ /// Base directory containing the `src/` for the Rust standard library, and
+ /// potentially `rustc` as well, if we can can find it. Right now it's always
+ /// `$sysroot/lib/rustlib/src/rust` (i.e. the `rustup` `rust-src` component).
+ ///
+ /// This directory is what the virtual `/rustc/$hash` is translated back to,
+ /// if Rust was built with path remapping to `/rustc/$hash` enabled
+ /// (the `rust.remap-debuginfo` option in `config.toml`).
+ real_rust_source_base_dir: Option<PathBuf> [TRACKED_NO_CRATE_HASH],
edition: Edition [TRACKED],
- // `true` if we're emitting JSON blobs about each artifact produced
- // by the compiler.
+ /// `true` if we're emitting JSON blobs about each artifact produced
+ /// by the compiler.
json_artifact_notifications: bool [TRACKED],
- // `true` if we're emitting a JSON blob containing the unused externs
+ /// `true` if we're emitting a JSON blob containing the unused externs
json_unused_externs: bool [UNTRACKED],
pretty: Option<PpMode> [UNTRACKED],
macro_rules! options {
($struct_name:ident, $setter_name:ident, $defaultfn:ident,
$buildfn:ident, $prefix:expr, $outputname:expr,
- $stat:ident, $mod_desc:ident, $mod_set:ident,
- $($opt:ident : $t:ty = (
+ $stat:ident,
+ $($( #[$attr:meta] )* $opt:ident : $t:ty = (
$init:expr,
$parse:ident,
- [$dep_tracking_marker:ident $(($dep_warn_val:expr, $dep_warn_text:expr))*],
+ [$dep_tracking_marker:ident],
$desc:expr)
),* ,) =>
(
pub struct $struct_name { $(pub $opt: $t),* }
pub fn $defaultfn() -> $struct_name {
- $struct_name { $($opt: $init),* }
+ $struct_name { $( $( #[$attr] )* $opt: $init),* }
}
pub fn $buildfn(matches: &getopts::Matches, error_format: ErrorOutputType) -> $struct_name
return op;
}
- impl dep_tracking::DepTrackingHash for $struct_name {
- fn hash(&self, hasher: &mut DefaultHasher, error_format: ErrorOutputType) {
+ impl $struct_name {
+ fn dep_tracking_hash(&self, _for_crate_hash: bool, error_format: ErrorOutputType) -> u64 {
let mut sub_hashes = BTreeMap::new();
$({
- hash_option!($opt,
- &self.$opt,
- &mut sub_hashes,
- [$dep_tracking_marker $($dep_warn_val,
- $dep_warn_text,
- error_format)*]);
+ hash_opt!($opt,
+ &self.$opt,
+ &mut sub_hashes,
+ _for_crate_hash,
+ [$dep_tracking_marker]);
})*
- dep_tracking::stable_hash(sub_hashes, hasher, error_format);
+ let mut hasher = DefaultHasher::new();
+ dep_tracking::stable_hash(sub_hashes,
+ &mut hasher,
+ error_format);
+ hasher.finish()
}
}
pub type $setter_name = fn(&mut $struct_name, v: Option<&str>) -> bool;
pub const $stat: &[(&str, $setter_name, &str, &str)] =
- &[ $( (stringify!($opt), $mod_set::$opt, $mod_desc::$parse, $desc) ),* ];
-
- #[allow(non_upper_case_globals, dead_code)]
- mod $mod_desc {
- pub const parse_no_flag: &str = "no value";
- pub const parse_bool: &str = "one of: `y`, `yes`, `on`, `n`, `no`, or `off`";
- pub const parse_opt_bool: &str = parse_bool;
- pub const parse_string: &str = "a string";
- pub const parse_opt_string: &str = parse_string;
- pub const parse_string_push: &str = parse_string;
- pub const parse_opt_pathbuf: &str = "a path";
- pub const parse_pathbuf_push: &str = parse_opt_pathbuf;
- pub const parse_list: &str = "a space-separated list of strings";
- pub const parse_opt_list: &str = parse_list;
- pub const parse_opt_comma_list: &str = "a comma-separated list of strings";
- pub const parse_number: &str = "a number";
- pub const parse_opt_number: &str = parse_number;
- pub const parse_threads: &str = parse_number;
- pub const parse_passes: &str = "a space-separated list of passes, or `all`";
- pub const parse_panic_strategy: &str = "either `unwind` or `abort`";
- pub const parse_relro_level: &str = "one of: `full`, `partial`, or `off`";
- pub const parse_sanitizers: &str = "comma separated list of sanitizers: `address`, `hwaddress`, `leak`, `memory` or `thread`";
- pub const parse_sanitizer_memory_track_origins: &str = "0, 1, or 2";
- pub const parse_cfguard: &str =
- "either a boolean (`yes`, `no`, `on`, `off`, etc), `checks`, or `nochecks`";
- pub const parse_strip: &str = "either `none`, `debuginfo`, or `symbols`";
- pub const parse_linker_flavor: &str = ::rustc_target::spec::LinkerFlavor::one_of();
- pub const parse_optimization_fuel: &str = "crate=integer";
- pub const parse_mir_spanview: &str = "`statement` (default), `terminator`, or `block`";
- pub const parse_instrument_coverage: &str = "`all` (default), `except-unused-generics`, `except-unused-functions`, or `off`";
- pub const parse_unpretty: &str = "`string` or `string=string`";
- pub const parse_treat_err_as_bug: &str = "either no value or a number bigger than 0";
- pub const parse_lto: &str =
- "either a boolean (`yes`, `no`, `on`, `off`, etc), `thin`, `fat`, or omitted";
- pub const parse_linker_plugin_lto: &str =
- "either a boolean (`yes`, `no`, `on`, `off`, etc), or the path to the linker plugin";
- pub const parse_switch_with_opt_path: &str =
- "an optional path to the profiling data output directory";
- pub const parse_merge_functions: &str = "one of: `disabled`, `trampolines`, or `aliases`";
- pub const parse_symbol_mangling_version: &str = "either `legacy` or `v0` (RFC 2603)";
- pub const parse_src_file_hash: &str = "either `md5` or `sha1`";
- pub const parse_relocation_model: &str =
- "one of supported relocation models (`rustc --print relocation-models`)";
- pub const parse_code_model: &str =
- "one of supported code models (`rustc --print code-models`)";
- pub const parse_tls_model: &str =
- "one of supported TLS models (`rustc --print tls-models`)";
- pub const parse_target_feature: &str = parse_string;
- pub const parse_wasi_exec_model: &str = "either `command` or `reactor`";
- pub const parse_split_debuginfo: &str =
- "one of supported split-debuginfo modes (`off` or `dsymutil`)";
+ &[ $( (stringify!($opt), $crate::options::parse::$opt, $crate::options::desc::$parse, $desc) ),* ];
+
+ // Sometimes different options need to build a common structure.
+ // That structure can kept in one of the options' fields, the others become dummy.
+ macro_rules! redirect_field {
+ ($cg:ident.link_arg) => { $cg.link_args };
+ ($cg:ident.pre_link_arg) => { $cg.pre_link_args };
+ ($cg:ident.$field:ident) => { $cg.$field };
}
- #[allow(dead_code)]
- mod $mod_set {
- use super::*;
- use std::str::FromStr;
-
- // Sometimes different options need to build a common structure.
- // That structure can kept in one of the options' fields, the others become dummy.
- macro_rules! redirect_field {
- ($cg:ident.link_arg) => { $cg.link_args };
- ($cg:ident.pre_link_arg) => { $cg.pre_link_args };
- ($cg:ident.$field:ident) => { $cg.$field };
+ $(
+ pub fn $opt(cg: &mut $struct_name, v: Option<&str>) -> bool {
+ $crate::options::parse::$parse(&mut redirect_field!(cg.$opt), v)
}
+ )*
- $(
- pub fn $opt(cg: &mut $struct_name, v: Option<&str>) -> bool {
- $parse(&mut redirect_field!(cg.$opt), v)
- }
- )*
-
- /// This is for boolean options that don't take a value and start with
- /// `no-`. This style of option is deprecated.
- fn parse_no_flag(slot: &mut bool, v: Option<&str>) -> bool {
- match v {
- None => { *slot = true; true }
- Some(_) => false,
- }
- }
+) }
- /// Use this for any boolean option that has a static default.
- fn parse_bool(slot: &mut bool, v: Option<&str>) -> bool {
- match v {
- Some("y") | Some("yes") | Some("on") | None => { *slot = true; true }
- Some("n") | Some("no") | Some("off") => { *slot = false; true }
- _ => false,
- }
- }
+#[allow(non_upper_case_globals)]
+mod desc {
+ pub const parse_no_flag: &str = "no value";
+ pub const parse_bool: &str = "one of: `y`, `yes`, `on`, `n`, `no`, or `off`";
+ pub const parse_opt_bool: &str = parse_bool;
+ pub const parse_string: &str = "a string";
+ pub const parse_opt_string: &str = parse_string;
+ pub const parse_string_push: &str = parse_string;
+ pub const parse_opt_pathbuf: &str = "a path";
+ pub const parse_list: &str = "a space-separated list of strings";
+ pub const parse_opt_comma_list: &str = "a comma-separated list of strings";
+ pub const parse_number: &str = "a number";
+ pub const parse_opt_number: &str = parse_number;
+ pub const parse_threads: &str = parse_number;
+ pub const parse_passes: &str = "a space-separated list of passes, or `all`";
+ pub const parse_panic_strategy: &str = "either `unwind` or `abort`";
+ pub const parse_relro_level: &str = "one of: `full`, `partial`, or `off`";
+ pub const parse_sanitizers: &str =
+ "comma separated list of sanitizers: `address`, `hwaddress`, `leak`, `memory` or `thread`";
+ pub const parse_sanitizer_memory_track_origins: &str = "0, 1, or 2";
+ pub const parse_cfguard: &str =
+ "either a boolean (`yes`, `no`, `on`, `off`, etc), `checks`, or `nochecks`";
+ pub const parse_strip: &str = "either `none`, `debuginfo`, or `symbols`";
+ pub const parse_linker_flavor: &str = ::rustc_target::spec::LinkerFlavor::one_of();
+ pub const parse_optimization_fuel: &str = "crate=integer";
+ pub const parse_mir_spanview: &str = "`statement` (default), `terminator`, or `block`";
+ pub const parse_instrument_coverage: &str =
+ "`all` (default), `except-unused-generics`, `except-unused-functions`, or `off`";
+ pub const parse_unpretty: &str = "`string` or `string=string`";
+ pub const parse_treat_err_as_bug: &str = "either no value or a number bigger than 0";
+ pub const parse_lto: &str =
+ "either a boolean (`yes`, `no`, `on`, `off`, etc), `thin`, `fat`, or omitted";
+ pub const parse_linker_plugin_lto: &str =
+ "either a boolean (`yes`, `no`, `on`, `off`, etc), or the path to the linker plugin";
+ pub const parse_switch_with_opt_path: &str =
+ "an optional path to the profiling data output directory";
+ pub const parse_merge_functions: &str = "one of: `disabled`, `trampolines`, or `aliases`";
+ pub const parse_symbol_mangling_version: &str = "either `legacy` or `v0` (RFC 2603)";
+ pub const parse_src_file_hash: &str = "either `md5` or `sha1`";
+ pub const parse_relocation_model: &str =
+ "one of supported relocation models (`rustc --print relocation-models`)";
+ pub const parse_code_model: &str = "one of supported code models (`rustc --print code-models`)";
+ pub const parse_tls_model: &str = "one of supported TLS models (`rustc --print tls-models`)";
+ pub const parse_target_feature: &str = parse_string;
+ pub const parse_wasi_exec_model: &str = "either `command` or `reactor`";
+ pub const parse_split_debuginfo: &str =
+ "one of supported split-debuginfo modes (`off` or `dsymutil`)";
+}
- /// Use this for any boolean option that lacks a static default. (The
- /// actions taken when such an option is not specified will depend on
- /// other factors, such as other options, or target options.)
- fn parse_opt_bool(slot: &mut Option<bool>, v: Option<&str>) -> bool {
- match v {
- Some("y") | Some("yes") | Some("on") | None => { *slot = Some(true); true }
- Some("n") | Some("no") | Some("off") => { *slot = Some(false); true }
- _ => false,
+mod parse {
+ crate use super::*;
+ use std::str::FromStr;
+
+ /// This is for boolean options that don't take a value and start with
+ /// `no-`. This style of option is deprecated.
+ crate fn parse_no_flag(slot: &mut bool, v: Option<&str>) -> bool {
+ match v {
+ None => {
+ *slot = true;
+ true
}
+ Some(_) => false,
}
+ }
- /// Use this for any string option that has a static default.
- fn parse_string(slot: &mut String, v: Option<&str>) -> bool {
- match v {
- Some(s) => { *slot = s.to_string(); true },
- None => false,
+ /// Use this for any boolean option that has a static default.
+ crate fn parse_bool(slot: &mut bool, v: Option<&str>) -> bool {
+ match v {
+ Some("y") | Some("yes") | Some("on") | None => {
+ *slot = true;
+ true
}
+ Some("n") | Some("no") | Some("off") => {
+ *slot = false;
+ true
+ }
+ _ => false,
}
+ }
- /// Use this for any string option that lacks a static default.
- fn parse_opt_string(slot: &mut Option<String>, v: Option<&str>) -> bool {
- match v {
- Some(s) => { *slot = Some(s.to_string()); true },
- None => false,
+ /// Use this for any boolean option that lacks a static default. (The
+ /// actions taken when such an option is not specified will depend on
+ /// other factors, such as other options, or target options.)
+ crate fn parse_opt_bool(slot: &mut Option<bool>, v: Option<&str>) -> bool {
+ match v {
+ Some("y") | Some("yes") | Some("on") | None => {
+ *slot = Some(true);
+ true
+ }
+ Some("n") | Some("no") | Some("off") => {
+ *slot = Some(false);
+ true
}
+ _ => false,
}
+ }
- fn parse_opt_pathbuf(slot: &mut Option<PathBuf>, v: Option<&str>) -> bool {
- match v {
- Some(s) => { *slot = Some(PathBuf::from(s)); true },
- None => false,
+ /// Use this for any string option that has a static default.
+ crate fn parse_string(slot: &mut String, v: Option<&str>) -> bool {
+ match v {
+ Some(s) => {
+ *slot = s.to_string();
+ true
}
+ None => false,
}
+ }
- fn parse_string_push(slot: &mut Vec<String>, v: Option<&str>) -> bool {
- match v {
- Some(s) => { slot.push(s.to_string()); true },
- None => false,
+ /// Use this for any string option that lacks a static default.
+ crate fn parse_opt_string(slot: &mut Option<String>, v: Option<&str>) -> bool {
+ match v {
+ Some(s) => {
+ *slot = Some(s.to_string());
+ true
}
+ None => false,
}
+ }
- fn parse_pathbuf_push(slot: &mut Vec<PathBuf>, v: Option<&str>) -> bool {
- match v {
- Some(s) => { slot.push(PathBuf::from(s)); true },
- None => false,
+ crate fn parse_opt_pathbuf(slot: &mut Option<PathBuf>, v: Option<&str>) -> bool {
+ match v {
+ Some(s) => {
+ *slot = Some(PathBuf::from(s));
+ true
}
+ None => false,
}
+ }
- fn parse_list(slot: &mut Vec<String>, v: Option<&str>)
- -> bool {
- match v {
- Some(s) => {
- slot.extend(s.split_whitespace().map(|s| s.to_string()));
- true
- },
- None => false,
+ crate fn parse_string_push(slot: &mut Vec<String>, v: Option<&str>) -> bool {
+ match v {
+ Some(s) => {
+ slot.push(s.to_string());
+ true
}
+ None => false,
}
+ }
- fn parse_opt_list(slot: &mut Option<Vec<String>>, v: Option<&str>)
- -> bool {
- match v {
- Some(s) => {
- let v = s.split_whitespace().map(|s| s.to_string()).collect();
- *slot = Some(v);
- true
- },
- None => false,
+ crate fn parse_list(slot: &mut Vec<String>, v: Option<&str>) -> bool {
+ match v {
+ Some(s) => {
+ slot.extend(s.split_whitespace().map(|s| s.to_string()));
+ true
}
+ None => false,
}
+ }
- fn parse_opt_comma_list(slot: &mut Option<Vec<String>>, v: Option<&str>)
- -> bool {
- match v {
- Some(s) => {
- let v = s.split(',').map(|s| s.to_string()).collect();
- *slot = Some(v);
- true
- },
- None => false,
+ crate fn parse_opt_comma_list(slot: &mut Option<Vec<String>>, v: Option<&str>) -> bool {
+ match v {
+ Some(s) => {
+ let mut v: Vec<_> = s.split(',').map(|s| s.to_string()).collect();
+ v.sort_unstable();
+ *slot = Some(v);
+ true
}
+ None => false,
}
+ }
- fn parse_threads(slot: &mut usize, v: Option<&str>) -> bool {
- match v.and_then(|s| s.parse().ok()) {
- Some(0) => { *slot = ::num_cpus::get(); true },
- Some(i) => { *slot = i; true },
- None => false
+ crate fn parse_threads(slot: &mut usize, v: Option<&str>) -> bool {
+ match v.and_then(|s| s.parse().ok()) {
+ Some(0) => {
+ *slot = ::num_cpus::get();
+ true
+ }
+ Some(i) => {
+ *slot = i;
+ true
}
+ None => false,
}
+ }
- /// Use this for any numeric option that has a static default.
- fn parse_number<T: Copy + FromStr>(slot: &mut T, v: Option<&str>) -> bool {
- match v.and_then(|s| s.parse().ok()) {
- Some(i) => { *slot = i; true },
- None => false
+ /// Use this for any numeric option that has a static default.
+ crate fn parse_number<T: Copy + FromStr>(slot: &mut T, v: Option<&str>) -> bool {
+ match v.and_then(|s| s.parse().ok()) {
+ Some(i) => {
+ *slot = i;
+ true
}
+ None => false,
}
+ }
- /// Use this for any numeric option that lacks a static default.
- fn parse_opt_number<T: Copy + FromStr>(slot: &mut Option<T>, v: Option<&str>) -> bool {
- match v {
- Some(s) => { *slot = s.parse().ok(); slot.is_some() }
- None => false
+ /// Use this for any numeric option that lacks a static default.
+ crate fn parse_opt_number<T: Copy + FromStr>(slot: &mut Option<T>, v: Option<&str>) -> bool {
+ match v {
+ Some(s) => {
+ *slot = s.parse().ok();
+ slot.is_some()
}
+ None => false,
}
+ }
- fn parse_passes(slot: &mut Passes, v: Option<&str>) -> bool {
- match v {
- Some("all") => {
- *slot = Passes::All;
+ crate fn parse_passes(slot: &mut Passes, v: Option<&str>) -> bool {
+ match v {
+ Some("all") => {
+ *slot = Passes::All;
+ true
+ }
+ v => {
+ let mut passes = vec![];
+ if parse_list(&mut passes, v) {
+ *slot = Passes::Some(passes);
true
- }
- v => {
- let mut passes = vec![];
- if parse_list(&mut passes, v) {
- *slot = Passes::Some(passes);
- true
- } else {
- false
- }
+ } else {
+ false
}
}
}
+ }
- fn parse_panic_strategy(slot: &mut Option<PanicStrategy>, v: Option<&str>) -> bool {
- match v {
- Some("unwind") => *slot = Some(PanicStrategy::Unwind),
- Some("abort") => *slot = Some(PanicStrategy::Abort),
- _ => return false
- }
- true
+ crate fn parse_panic_strategy(slot: &mut Option<PanicStrategy>, v: Option<&str>) -> bool {
+ match v {
+ Some("unwind") => *slot = Some(PanicStrategy::Unwind),
+ Some("abort") => *slot = Some(PanicStrategy::Abort),
+ _ => return false,
}
+ true
+ }
- fn parse_relro_level(slot: &mut Option<RelroLevel>, v: Option<&str>) -> bool {
- match v {
- Some(s) => {
- match s.parse::<RelroLevel>() {
- Ok(level) => *slot = Some(level),
- _ => return false
- }
- },
- _ => return false
- }
- true
+ crate fn parse_relro_level(slot: &mut Option<RelroLevel>, v: Option<&str>) -> bool {
+ match v {
+ Some(s) => match s.parse::<RelroLevel>() {
+ Ok(level) => *slot = Some(level),
+ _ => return false,
+ },
+ _ => return false,
}
+ true
+ }
- fn parse_sanitizers(slot: &mut SanitizerSet, v: Option<&str>) -> bool {
- if let Some(v) = v {
- for s in v.split(',') {
- *slot |= match s {
- "address" => SanitizerSet::ADDRESS,
- "leak" => SanitizerSet::LEAK,
- "memory" => SanitizerSet::MEMORY,
- "thread" => SanitizerSet::THREAD,
- "hwaddress" => SanitizerSet::HWADDRESS,
- _ => return false,
- }
+ crate fn parse_sanitizers(slot: &mut SanitizerSet, v: Option<&str>) -> bool {
+ if let Some(v) = v {
+ for s in v.split(',') {
+ *slot |= match s {
+ "address" => SanitizerSet::ADDRESS,
+ "leak" => SanitizerSet::LEAK,
+ "memory" => SanitizerSet::MEMORY,
+ "thread" => SanitizerSet::THREAD,
+ "hwaddress" => SanitizerSet::HWADDRESS,
+ _ => return false,
}
- true
- } else {
- false
}
+ true
+ } else {
+ false
}
+ }
- fn parse_sanitizer_memory_track_origins(slot: &mut usize, v: Option<&str>) -> bool {
- match v {
- Some("2") | None => { *slot = 2; true }
- Some("1") => { *slot = 1; true }
- Some("0") => { *slot = 0; true }
- Some(_) => false,
+ crate fn parse_sanitizer_memory_track_origins(slot: &mut usize, v: Option<&str>) -> bool {
+ match v {
+ Some("2") | None => {
+ *slot = 2;
+ true
+ }
+ Some("1") => {
+ *slot = 1;
+ true
+ }
+ Some("0") => {
+ *slot = 0;
+ true
}
+ Some(_) => false,
}
+ }
- fn parse_strip(slot: &mut Strip, v: Option<&str>) -> bool {
- match v {
- Some("none") => *slot = Strip::None,
- Some("debuginfo") => *slot = Strip::Debuginfo,
- Some("symbols") => *slot = Strip::Symbols,
- _ => return false,
- }
- true
+ crate fn parse_strip(slot: &mut Strip, v: Option<&str>) -> bool {
+ match v {
+ Some("none") => *slot = Strip::None,
+ Some("debuginfo") => *slot = Strip::Debuginfo,
+ Some("symbols") => *slot = Strip::Symbols,
+ _ => return false,
}
+ true
+ }
- fn parse_cfguard(slot: &mut CFGuard, v: Option<&str>) -> bool {
- if v.is_some() {
- let mut bool_arg = None;
- if parse_opt_bool(&mut bool_arg, v) {
- *slot = if bool_arg.unwrap() {
- CFGuard::Checks
- } else {
- CFGuard::Disabled
- };
- return true
- }
+ crate fn parse_cfguard(slot: &mut CFGuard, v: Option<&str>) -> bool {
+ if v.is_some() {
+ let mut bool_arg = None;
+ if parse_opt_bool(&mut bool_arg, v) {
+ *slot = if bool_arg.unwrap() { CFGuard::Checks } else { CFGuard::Disabled };
+ return true;
}
-
- *slot = match v {
- None => CFGuard::Checks,
- Some("checks") => CFGuard::Checks,
- Some("nochecks") => CFGuard::NoChecks,
- Some(_) => return false,
- };
- true
}
- fn parse_linker_flavor(slote: &mut Option<LinkerFlavor>, v: Option<&str>) -> bool {
- match v.and_then(LinkerFlavor::from_str) {
- Some(lf) => *slote = Some(lf),
- _ => return false,
- }
- true
+ *slot = match v {
+ None => CFGuard::Checks,
+ Some("checks") => CFGuard::Checks,
+ Some("nochecks") => CFGuard::NoChecks,
+ Some(_) => return false,
+ };
+ true
+ }
+
+ crate fn parse_linker_flavor(slote: &mut Option<LinkerFlavor>, v: Option<&str>) -> bool {
+ match v.and_then(LinkerFlavor::from_str) {
+ Some(lf) => *slote = Some(lf),
+ _ => return false,
}
+ true
+ }
- fn parse_optimization_fuel(slot: &mut Option<(String, u64)>, v: Option<&str>) -> bool {
- match v {
- None => false,
- Some(s) => {
- let parts = s.split('=').collect::<Vec<_>>();
- if parts.len() != 2 { return false; }
- let crate_name = parts[0].to_string();
- let fuel = parts[1].parse::<u64>();
- if fuel.is_err() { return false; }
- *slot = Some((crate_name, fuel.unwrap()));
- true
+ crate fn parse_optimization_fuel(slot: &mut Option<(String, u64)>, v: Option<&str>) -> bool {
+ match v {
+ None => false,
+ Some(s) => {
+ let parts = s.split('=').collect::<Vec<_>>();
+ if parts.len() != 2 {
+ return false;
+ }
+ let crate_name = parts[0].to_string();
+ let fuel = parts[1].parse::<u64>();
+ if fuel.is_err() {
+ return false;
}
+ *slot = Some((crate_name, fuel.unwrap()));
+ true
}
}
+ }
- fn parse_unpretty(slot: &mut Option<String>, v: Option<&str>) -> bool {
- match v {
- None => false,
- Some(s) if s.split('=').count() <= 2 => {
- *slot = Some(s.to_string());
- true
- }
- _ => false,
+ crate fn parse_unpretty(slot: &mut Option<String>, v: Option<&str>) -> bool {
+ match v {
+ None => false,
+ Some(s) if s.split('=').count() <= 2 => {
+ *slot = Some(s.to_string());
+ true
}
+ _ => false,
}
+ }
- fn parse_mir_spanview(slot: &mut Option<MirSpanview>, v: Option<&str>) -> bool {
- if v.is_some() {
- let mut bool_arg = None;
- if parse_opt_bool(&mut bool_arg, v) {
- *slot = if bool_arg.unwrap() {
- Some(MirSpanview::Statement)
- } else {
- None
- };
- return true
- }
+ crate fn parse_mir_spanview(slot: &mut Option<MirSpanview>, v: Option<&str>) -> bool {
+ if v.is_some() {
+ let mut bool_arg = None;
+ if parse_opt_bool(&mut bool_arg, v) {
+ *slot = if bool_arg.unwrap() { Some(MirSpanview::Statement) } else { None };
+ return true;
}
-
- let v = match v {
- None => {
- *slot = Some(MirSpanview::Statement);
- return true;
- }
- Some(v) => v,
- };
-
- *slot = Some(match v.trim_end_matches("s") {
- "statement" | "stmt" => MirSpanview::Statement,
- "terminator" | "term" => MirSpanview::Terminator,
- "block" | "basicblock" => MirSpanview::Block,
- _ => return false,
- });
- true
}
- fn parse_instrument_coverage(slot: &mut Option<InstrumentCoverage>, v: Option<&str>) -> bool {
- if v.is_some() {
- let mut bool_arg = None;
- if parse_opt_bool(&mut bool_arg, v) {
- *slot = if bool_arg.unwrap() {
- Some(InstrumentCoverage::All)
- } else {
- None
- };
- return true
- }
+ let v = match v {
+ None => {
+ *slot = Some(MirSpanview::Statement);
+ return true;
}
+ Some(v) => v,
+ };
+
+ *slot = Some(match v.trim_end_matches("s") {
+ "statement" | "stmt" => MirSpanview::Statement,
+ "terminator" | "term" => MirSpanview::Terminator,
+ "block" | "basicblock" => MirSpanview::Block,
+ _ => return false,
+ });
+ true
+ }
- let v = match v {
- None => {
- *slot = Some(InstrumentCoverage::All);
- return true;
- }
- Some(v) => v,
- };
-
- *slot = Some(match v {
- "all" => InstrumentCoverage::All,
- "except-unused-generics" | "except_unused_generics" => {
- InstrumentCoverage::ExceptUnusedGenerics
- }
- "except-unused-functions" | "except_unused_functions" => {
- InstrumentCoverage::ExceptUnusedFunctions
- }
- "off" | "no" | "n" | "false" | "0" => InstrumentCoverage::Off,
- _ => return false,
- });
- true
+ crate fn parse_instrument_coverage(
+ slot: &mut Option<InstrumentCoverage>,
+ v: Option<&str>,
+ ) -> bool {
+ if v.is_some() {
+ let mut bool_arg = None;
+ if parse_opt_bool(&mut bool_arg, v) {
+ *slot = if bool_arg.unwrap() { Some(InstrumentCoverage::All) } else { None };
+ return true;
+ }
}
- fn parse_treat_err_as_bug(slot: &mut Option<NonZeroUsize>, v: Option<&str>) -> bool {
- match v {
- Some(s) => { *slot = s.parse().ok(); slot.is_some() }
- None => { *slot = NonZeroUsize::new(1); true }
+ let v = match v {
+ None => {
+ *slot = Some(InstrumentCoverage::All);
+ return true;
}
- }
+ Some(v) => v,
+ };
- fn parse_lto(slot: &mut LtoCli, v: Option<&str>) -> bool {
- if v.is_some() {
- let mut bool_arg = None;
- if parse_opt_bool(&mut bool_arg, v) {
- *slot = if bool_arg.unwrap() {
- LtoCli::Yes
- } else {
- LtoCli::No
- };
- return true
- }
+ *slot = Some(match v {
+ "all" => InstrumentCoverage::All,
+ "except-unused-generics" | "except_unused_generics" => {
+ InstrumentCoverage::ExceptUnusedGenerics
}
+ "except-unused-functions" | "except_unused_functions" => {
+ InstrumentCoverage::ExceptUnusedFunctions
+ }
+ "off" | "no" | "n" | "false" | "0" => InstrumentCoverage::Off,
+ _ => return false,
+ });
+ true
+ }
- *slot = match v {
- None => LtoCli::NoParam,
- Some("thin") => LtoCli::Thin,
- Some("fat") => LtoCli::Fat,
- Some(_) => return false,
- };
- true
+ crate fn parse_treat_err_as_bug(slot: &mut Option<NonZeroUsize>, v: Option<&str>) -> bool {
+ match v {
+ Some(s) => {
+ *slot = s.parse().ok();
+ slot.is_some()
+ }
+ None => {
+ *slot = NonZeroUsize::new(1);
+ true
+ }
}
+ }
- fn parse_linker_plugin_lto(slot: &mut LinkerPluginLto, v: Option<&str>) -> bool {
- if v.is_some() {
- let mut bool_arg = None;
- if parse_opt_bool(&mut bool_arg, v) {
- *slot = if bool_arg.unwrap() {
- LinkerPluginLto::LinkerPluginAuto
- } else {
- LinkerPluginLto::Disabled
- };
- return true
- }
+ crate fn parse_lto(slot: &mut LtoCli, v: Option<&str>) -> bool {
+ if v.is_some() {
+ let mut bool_arg = None;
+ if parse_opt_bool(&mut bool_arg, v) {
+ *slot = if bool_arg.unwrap() { LtoCli::Yes } else { LtoCli::No };
+ return true;
}
-
- *slot = match v {
- None => LinkerPluginLto::LinkerPluginAuto,
- Some(path) => LinkerPluginLto::LinkerPlugin(PathBuf::from(path)),
- };
- true
}
- fn parse_switch_with_opt_path(slot: &mut SwitchWithOptPath, v: Option<&str>) -> bool {
- *slot = match v {
- None => SwitchWithOptPath::Enabled(None),
- Some(path) => SwitchWithOptPath::Enabled(Some(PathBuf::from(path))),
- };
- true
- }
+ *slot = match v {
+ None => LtoCli::NoParam,
+ Some("thin") => LtoCli::Thin,
+ Some("fat") => LtoCli::Fat,
+ Some(_) => return false,
+ };
+ true
+ }
- fn parse_merge_functions(slot: &mut Option<MergeFunctions>, v: Option<&str>) -> bool {
- match v.and_then(|s| MergeFunctions::from_str(s).ok()) {
- Some(mergefunc) => *slot = Some(mergefunc),
- _ => return false,
+ crate fn parse_linker_plugin_lto(slot: &mut LinkerPluginLto, v: Option<&str>) -> bool {
+ if v.is_some() {
+ let mut bool_arg = None;
+ if parse_opt_bool(&mut bool_arg, v) {
+ *slot = if bool_arg.unwrap() {
+ LinkerPluginLto::LinkerPluginAuto
+ } else {
+ LinkerPluginLto::Disabled
+ };
+ return true;
}
- true
}
- fn parse_relocation_model(slot: &mut Option<RelocModel>, v: Option<&str>) -> bool {
- match v.and_then(|s| RelocModel::from_str(s).ok()) {
- Some(relocation_model) => *slot = Some(relocation_model),
- None if v == Some("default") => *slot = None,
- _ => return false,
- }
- true
+ *slot = match v {
+ None => LinkerPluginLto::LinkerPluginAuto,
+ Some(path) => LinkerPluginLto::LinkerPlugin(PathBuf::from(path)),
+ };
+ true
+ }
+
+ crate fn parse_switch_with_opt_path(slot: &mut SwitchWithOptPath, v: Option<&str>) -> bool {
+ *slot = match v {
+ None => SwitchWithOptPath::Enabled(None),
+ Some(path) => SwitchWithOptPath::Enabled(Some(PathBuf::from(path))),
+ };
+ true
+ }
+
+ crate fn parse_merge_functions(slot: &mut Option<MergeFunctions>, v: Option<&str>) -> bool {
+ match v.and_then(|s| MergeFunctions::from_str(s).ok()) {
+ Some(mergefunc) => *slot = Some(mergefunc),
+ _ => return false,
}
+ true
+ }
- fn parse_code_model(slot: &mut Option<CodeModel>, v: Option<&str>) -> bool {
- match v.and_then(|s| CodeModel::from_str(s).ok()) {
- Some(code_model) => *slot = Some(code_model),
- _ => return false,
- }
- true
+ crate fn parse_relocation_model(slot: &mut Option<RelocModel>, v: Option<&str>) -> bool {
+ match v.and_then(|s| RelocModel::from_str(s).ok()) {
+ Some(relocation_model) => *slot = Some(relocation_model),
+ None if v == Some("default") => *slot = None,
+ _ => return false,
}
+ true
+ }
- fn parse_tls_model(slot: &mut Option<TlsModel>, v: Option<&str>) -> bool {
- match v.and_then(|s| TlsModel::from_str(s).ok()) {
- Some(tls_model) => *slot = Some(tls_model),
- _ => return false,
- }
- true
+ crate fn parse_code_model(slot: &mut Option<CodeModel>, v: Option<&str>) -> bool {
+ match v.and_then(|s| CodeModel::from_str(s).ok()) {
+ Some(code_model) => *slot = Some(code_model),
+ _ => return false,
}
+ true
+ }
- fn parse_symbol_mangling_version(
- slot: &mut Option<SymbolManglingVersion>,
- v: Option<&str>,
- ) -> bool {
- *slot = match v {
- Some("legacy") => Some(SymbolManglingVersion::Legacy),
- Some("v0") => Some(SymbolManglingVersion::V0),
- _ => return false,
- };
- true
+ crate fn parse_tls_model(slot: &mut Option<TlsModel>, v: Option<&str>) -> bool {
+ match v.and_then(|s| TlsModel::from_str(s).ok()) {
+ Some(tls_model) => *slot = Some(tls_model),
+ _ => return false,
}
+ true
+ }
- fn parse_src_file_hash(slot: &mut Option<SourceFileHashAlgorithm>, v: Option<&str>) -> bool {
- match v.and_then(|s| SourceFileHashAlgorithm::from_str(s).ok()) {
- Some(hash_kind) => *slot = Some(hash_kind),
- _ => return false,
- }
- true
+ crate fn parse_symbol_mangling_version(
+ slot: &mut Option<SymbolManglingVersion>,
+ v: Option<&str>,
+ ) -> bool {
+ *slot = match v {
+ Some("legacy") => Some(SymbolManglingVersion::Legacy),
+ Some("v0") => Some(SymbolManglingVersion::V0),
+ _ => return false,
+ };
+ true
+ }
+
+ crate fn parse_src_file_hash(
+ slot: &mut Option<SourceFileHashAlgorithm>,
+ v: Option<&str>,
+ ) -> bool {
+ match v.and_then(|s| SourceFileHashAlgorithm::from_str(s).ok()) {
+ Some(hash_kind) => *slot = Some(hash_kind),
+ _ => return false,
}
+ true
+ }
- fn parse_target_feature(slot: &mut String, v: Option<&str>) -> bool {
- match v {
- Some(s) => {
- if !slot.is_empty() {
- slot.push_str(",");
- }
- slot.push_str(s);
- true
+ crate fn parse_target_feature(slot: &mut String, v: Option<&str>) -> bool {
+ match v {
+ Some(s) => {
+ if !slot.is_empty() {
+ slot.push_str(",");
}
- None => false,
+ slot.push_str(s);
+ true
}
+ None => false,
}
+ }
- fn parse_wasi_exec_model(slot: &mut Option<WasiExecModel>, v: Option<&str>) -> bool {
- match v {
- Some("command") => *slot = Some(WasiExecModel::Command),
- Some("reactor") => *slot = Some(WasiExecModel::Reactor),
- _ => return false,
- }
- true
+ crate fn parse_wasi_exec_model(slot: &mut Option<WasiExecModel>, v: Option<&str>) -> bool {
+ match v {
+ Some("command") => *slot = Some(WasiExecModel::Command),
+ Some("reactor") => *slot = Some(WasiExecModel::Reactor),
+ _ => return false,
}
+ true
+ }
- fn parse_split_debuginfo(slot: &mut Option<SplitDebuginfo>, v: Option<&str>) -> bool {
- match v.and_then(|s| SplitDebuginfo::from_str(s).ok()) {
- Some(e) => *slot = Some(e),
- _ => return false,
- }
- true
+ crate fn parse_split_debuginfo(slot: &mut Option<SplitDebuginfo>, v: Option<&str>) -> bool {
+ match v.and_then(|s| SplitDebuginfo::from_str(s).ok()) {
+ Some(e) => *slot = Some(e),
+ _ => return false,
}
+ true
}
-) }
+}
options! {CodegenOptions, CodegenSetter, basic_codegen_options,
build_codegen_options, "C", "codegen",
- CG_OPTIONS, cg_type_desc, cgsetters,
+ CG_OPTIONS,
// This list is in alphabetical order.
//
options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
build_debugging_options, "Z", "debugging",
- DB_OPTIONS, db_type_desc, dbsetters,
+ DB_OPTIONS,
// This list is in alphabetical order.
//
"gather statistics about the input (default: no)"),
instrument_coverage: Option<InstrumentCoverage> = (None, parse_instrument_coverage, [TRACKED],
"instrument the generated code to support LLVM source-based code coverage \
- reports (note, the compiler build config must include `profiler = true`, \
- and is mutually exclusive with `-C profile-generate`/`-C profile-use`); \
- implies `-Z symbol-mangling-version=v0`; disables/overrides some Rust \
- optimizations. Optional values are: `=all` (default coverage), \
- `=except-unused-generics`, `=except-unused-functions`, or `=off` \
- (default: instrument-coverage=off)"),
+ reports (note, the compiler build config must include `profiler = true`); \
+ implies `-Z symbol-mangling-version=v0`. Optional values are:
+ `=all` (implicit value)
+ `=except-unused-generics`
+ `=except-unused-functions`
+ `=off` (default)"),
instrument_mcount: bool = (false, parse_bool, [TRACKED],
"insert function instrument code for mcount-based tracing (default: no)"),
keep_hygiene_data: bool = (false, parse_bool, [UNTRACKED],
self_profile: SwitchWithOptPath = (SwitchWithOptPath::Disabled,
parse_switch_with_opt_path, [UNTRACKED],
"run the self profiler and output the raw event data"),
- // keep this in sync with the event filter names in librustc_data_structures/profiling.rs
+ /// keep this in sync with the event filter names in librustc_data_structures/profiling.rs
self_profile_events: Option<Vec<String>> = (None, parse_opt_comma_list, [UNTRACKED],
"specify the events recorded by the self profiler;
for example: `-Z self-profile-events=default,query-keys`
"show spans for compiler debugging (expr|pat|ty)"),
span_debug: bool = (false, parse_bool, [UNTRACKED],
"forward proc_macro::Span's `Debug` impl to `Span`"),
- // o/w tests have closure@path
+ /// o/w tests have closure@path
span_free_formats: bool = (false, parse_bool, [UNTRACKED],
"exclude spans when debug-printing compiler state (default: no)"),
src_hash_algorithm: Option<SourceFileHashAlgorithm> = (None, parse_src_file_hash, [TRACKED],
"select processor to schedule for (`rustc --print target-cpus` for details)"),
thinlto: Option<bool> = (None, parse_opt_bool, [TRACKED],
"enable ThinLTO when possible"),
- // We default to 1 here since we want to behave like
- // a sequential compiler for now. This'll likely be adjusted
- // in the future. Note that -Zthreads=0 is the way to get
- // the num_cpus behavior.
+ /// We default to 1 here since we want to behave like
+ /// a sequential compiler for now. This'll likely be adjusted
+ /// in the future. Note that -Zthreads=0 is the way to get
+ /// the num_cpus behavior.
threads: usize = (1, parse_threads, [UNTRACKED],
"use a thread pool with N threads"),
time: bool = (false, parse_bool, [UNTRACKED],
// - compiler/rustc_interface/src/tests.rs
}
-#[derive(Clone, Hash)]
+#[derive(Clone, Hash, PartialEq, Eq, Debug)]
pub enum WasiExecModel {
Command,
Reactor,
/// drown everything else in noise.
miri_unleashed_features: Lock<Vec<(Span, Option<Symbol>)>>,
- /// Base directory containing the `src/` for the Rust standard library, and
- /// potentially `rustc` as well, if we can can find it. Right now it's always
- /// `$sysroot/lib/rustlib/src/rust` (i.e. the `rustup` `rust-src` component).
- ///
- /// This directory is what the virtual `/rustc/$hash` is translated back to,
- /// if Rust was built with path remapping to `/rustc/$hash` enabled
- /// (the `rust.remap-debuginfo` option in `config.toml`).
- pub real_rust_source_base_dir: Option<PathBuf>,
-
/// Architecture to use for interpreting asm!.
pub asm_arch: Option<InlineAsmArch>,
_ => CtfeBacktrace::Disabled,
});
- // Try to find a directory containing the Rust `src`, for more details see
- // the doc comment on the `real_rust_source_base_dir` field.
- let real_rust_source_base_dir = {
- // This is the location used by the `rust-src` `rustup` component.
- let mut candidate = sysroot.join("lib/rustlib/src/rust");
- if let Ok(metadata) = candidate.symlink_metadata() {
- // Replace the symlink rustbuild creates, with its destination.
- // We could try to use `fs::canonicalize` instead, but that might
- // produce unnecessarily verbose path.
- if metadata.file_type().is_symlink() {
- if let Ok(symlink_dest) = std::fs::read_link(&candidate) {
- candidate = symlink_dest;
- }
- }
- }
-
- // Only use this directory if it has a file we can expect to always find.
- if candidate.join("library/std/src/lib.rs").is_file() { Some(candidate) } else { None }
- };
-
let asm_arch =
if target_cfg.allow_asm { InlineAsmArch::from_str(&target_cfg.arch).ok() } else { None };
system_library_path: OneThread::new(RefCell::new(Default::default())),
ctfe_backtrace,
miri_unleashed_features: Lock::new(Default::default()),
- real_rust_source_base_dir,
asm_arch,
target_features: FxHashSet::default(),
known_attrs: Lock::new(MarkedAttrs::new()),
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Encodable, Decodable)]
pub enum NativeLibKind {
- /// Static library (e.g. `libfoo.a` on Linux or `foo.lib` on Windows/MSVC) included
- /// when linking a final binary, but not when archiving an rlib.
- StaticNoBundle,
- /// Static library (e.g. `libfoo.a` on Linux or `foo.lib` on Windows/MSVC) included
- /// when linking a final binary, but also included when archiving an rlib.
- StaticBundle,
+ /// Static library (e.g. `libfoo.a` on Linux or `foo.lib` on Windows/MSVC)
+ Static {
+ /// Whether to bundle objects from static library into produced rlib
+ bundle: Option<bool>,
+ /// Whether to link static library without throwing any object files away
+ whole_archive: Option<bool>,
+ },
/// Dynamic library (e.g. `libfoo.so` on Linux)
/// or an import library corresponding to a dynamic library (e.g. `foo.lib` on Windows/MSVC).
- Dylib,
+ Dylib {
+ /// Whether the dynamic library will be linked only if it satifies some undefined symbols
+ as_needed: Option<bool>,
+ },
/// Dynamic library (e.g. `foo.dll` on Windows) without a corresponding import library.
RawDylib,
/// A macOS-specific kind of dynamic libraries.
- Framework,
+ Framework {
+ /// Whether the framework will be linked only if it satifies some undefined symbols
+ as_needed: Option<bool>,
+ },
/// The library kind wasn't specified, `Dylib` is currently used as a default.
Unspecified,
}
rustc_data_structures::impl_stable_hash_via_hash!(NativeLibKind);
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Encodable, Decodable)]
+pub struct NativeLib {
+ pub name: String,
+ pub new_name: Option<String>,
+ pub kind: NativeLibKind,
+ pub verbatim: Option<bool>,
+}
+
+rustc_data_structures::impl_stable_hash_via_hash!(NativeLib);
+
/// A path that has been canonicalized along with its original, non-canonicalized form
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub struct CanonicalizedPath {
// This cache is only used by `DummyHashStableContext`,
// so we won't pollute the cache values of the normal `StableHashingContext`
thread_local! {
- static CACHE: ExpnIdCache = Default::default();
+ static CACHE: ExpnIdCache = const { ExpnIdCache::new(Vec::new()) };
}
&CACHE
#![feature(negative_impls)]
#![feature(nll)]
#![feature(min_specialization)]
+#![feature(thread_local_const_init)]
#[macro_use]
extern crate rustc_macros;
impl_macros,
impl_trait_in_bindings,
import_shadowing,
+ imported_main,
in_band_lifetimes,
include,
include_bytes,
minnumf64,
mips_target_feature,
misc,
+ modifiers,
module,
module_path,
more_struct_aliases,
naked,
naked_functions,
name,
+ native_link_modifiers,
+ native_link_modifiers_as_needed,
+ native_link_modifiers_bundle,
+ native_link_modifiers_verbatim,
+ native_link_modifiers_whole_archive,
ne,
nearbyintf32,
nearbyintf64,
x15: reg = ["x15", "w15"],
x16: reg = ["x16", "w16"],
x17: reg = ["x17", "w17"],
- x18: reg = ["x18", "w18"],
- x19: reg = ["x19", "w19"],
x20: reg = ["x20", "w20"],
x21: reg = ["x21", "w21"],
x22: reg = ["x22", "w22"],
x26: reg = ["x26", "w26"],
x27: reg = ["x27", "w27"],
x28: reg = ["x28", "w28"],
- x30: reg = ["x30", "w30", "lr"],
+ x30: reg = ["x30", "w30", "lr", "wlr"],
v0: vreg, vreg_low16 = ["v0", "b0", "h0", "s0", "d0", "q0"],
v1: vreg, vreg_low16 = ["v1", "b1", "h1", "s1", "d1", "q1"],
v2: vreg, vreg_low16 = ["v2", "b2", "h2", "s2", "d2", "q2"],
v29: vreg = ["v29", "b29", "h29", "s29", "d29", "q29"],
v30: vreg = ["v30", "b30", "h30", "s30", "d30", "q30"],
v31: vreg = ["v31", "b31", "h31", "s31", "d31", "q31"],
- #error = ["x29", "fp"] =>
+ #error = ["x18", "w18"] =>
+ "x18 is used as a reserved register on some targets and cannot be used as an operand for inline asm",
+ #error = ["x19", "w19"] =>
+ "x19 is used internally by LLVM and cannot be used as an operand for inline asm",
+ #error = ["x29", "w29", "fp", "wfp"] =>
"the frame pointer cannot be used as an operand for inline asm",
#error = ["sp", "wsp"] =>
"the stack pointer cannot be used as an operand for inline asm",
r5: reg, reg_thumb = ["r5", "v2"],
r7: reg, reg_thumb = ["r7", "v4"] % frame_pointer_r7,
r8: reg = ["r8", "v5"],
- r9: reg = ["r9", "v6", "rfp"],
r10: reg = ["r10", "sl"],
r11: reg = ["r11", "fp"] % frame_pointer_r11,
r12: reg = ["r12", "ip"],
q15: qreg = ["q15"],
#error = ["r6", "v3"] =>
"r6 is used internally by LLVM and cannot be used as an operand for inline asm",
+ #error = ["r9", "v6", "rfp"] =>
+ "r9 is used internally by LLVM and cannot be used as an operand for inline asm",
#error = ["r13", "sp"] =>
"the stack pointer cannot be used as an operand for inline asm",
#error = ["r15", "pc"] =>
r16: reg = ["r16"],
r17: reg = ["r17"],
r18: reg = ["r18"],
- r19: reg = ["r19"],
r20: reg = ["r20"],
r21: reg = ["r21"],
r22: reg = ["r22"],
r26: reg = ["r26"],
r27: reg = ["r27"],
r28: reg = ["r28"],
+ #error = ["r19"] =>
+ "r19 is used internally by LLVM and cannot be used as an operand for inline asm",
#error = ["r29", "sp"] =>
"the stack pointer cannot be used as an operand for inline asm",
#error = ["r30", "fr"] =>
x5: reg = ["x5", "t0"],
x6: reg = ["x6", "t1"],
x7: reg = ["x7", "t2"],
- x9: reg = ["x9", "s1"],
x10: reg = ["x10", "a0"],
x11: reg = ["x11", "a1"],
x12: reg = ["x12", "a2"],
f29: freg = ["f29", "ft9"],
f30: freg = ["f30", "ft10"],
f31: freg = ["f31", "ft11"],
+ #error = ["x9", "s1"] =>
+ "s1 is used internally by LLVM and cannot be used as an operand for inline asm",
#error = ["x8", "s0", "fp"] =>
"the frame pointer cannot be used as an operand for inline asm",
#error = ["x2", "sp"] =>
}
}
+fn rbx_reserved(
+ arch: InlineAsmArch,
+ _has_feature: impl FnMut(&str) -> bool,
+ _target: &Target,
+) -> Result<(), &'static str> {
+ match arch {
+ InlineAsmArch::X86 => Ok(()),
+ InlineAsmArch::X86_64 => {
+ Err("rbx is used internally by LLVM and cannot be used as an operand for inline asm")
+ }
+ _ => unreachable!(),
+ }
+}
+
+fn esi_reserved(
+ arch: InlineAsmArch,
+ _has_feature: impl FnMut(&str) -> bool,
+ _target: &Target,
+) -> Result<(), &'static str> {
+ match arch {
+ InlineAsmArch::X86 => {
+ Err("esi is used internally by LLVM and cannot be used as an operand for inline asm")
+ }
+ InlineAsmArch::X86_64 => Ok(()),
+ _ => unreachable!(),
+ }
+}
+
def_regs! {
X86 X86InlineAsmReg X86InlineAsmRegClass {
ax: reg, reg_abcd = ["ax", "eax", "rax"],
- bx: reg, reg_abcd = ["bx", "ebx", "rbx"],
+ bx: reg, reg_abcd = ["bx", "ebx", "rbx"] % rbx_reserved,
cx: reg, reg_abcd = ["cx", "ecx", "rcx"],
dx: reg, reg_abcd = ["dx", "edx", "rdx"],
- si: reg = ["si", "esi", "rsi"],
+ si: reg = ["si", "esi", "rsi"] % esi_reserved,
di: reg = ["di", "edi", "rdi"],
r8: reg = ["r8", "r8w", "r8d"] % x86_64_only,
r9: reg = ["r9", "r9w", "r9d"] % x86_64_only,
function_sections: false,
dynamic_linking: true,
executables: true,
- os_family: Some("unix".to_string()),
+ families: vec!["unix".to_string()],
is_like_osx: true,
dwarf_version: Some(2),
has_rpath: true,
os: "dragonfly".to_string(),
dynamic_linking: true,
executables: true,
- os_family: Some("unix".to_string()),
+ families: vec!["unix".to_string()],
linker_is_gnu: true,
has_rpath: true,
position_independent_executables: true,
os: "freebsd".to_string(),
dynamic_linking: true,
executables: true,
- os_family: Some("unix".to_string()),
+ families: vec!["unix".to_string()],
linker_is_gnu: true,
has_rpath: true,
position_independent_executables: true,
linker: Some("rust-lld".to_owned()),
dynamic_linking: true,
executables: true,
- os_family: Some("unix".to_string()),
+ families: vec!["unix".to_string()],
is_like_fuchsia: true,
linker_is_gnu: true,
pre_link_args,
os: "haiku".to_string(),
dynamic_linking: true,
executables: true,
- os_family: Some("unix".to_string()),
+ families: vec!["unix".to_string()],
relro_level: RelroLevel::Full,
linker_is_gnu: true,
..Default::default()
arch: "x86".to_string(),
options: TargetOptions {
max_atomic_width: Some(64),
- stack_probes: StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) },
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ stack_probes: StackProbeType::Call,
..base
},
}
base.max_atomic_width = Some(64);
base.pre_link_args.insert(LinkerFlavor::Gcc, vec!["-m32".to_string()]);
base.link_env_remove.extend(super::apple_base::macos_link_env_remove());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
base.eliminate_frame_pointer = false;
// Clang automatically chooses a more specific target based on
// http://developer.android.com/ndk/guides/abis.html#x86
base.cpu = "pentiumpro".to_string();
base.features = "+mmx,+sse,+sse2,+sse3,+ssse3".to_string();
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "i686-linux-android".to_string(),
let pre_link_args = base.pre_link_args.entry(LinkerFlavor::Gcc).or_default();
pre_link_args.push("-m32".to_string());
pre_link_args.push("-Wl,-znotext".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "i686-unknown-freebsd".to_string(),
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.insert(LinkerFlavor::Gcc, vec!["-m32".to_string()]);
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "i686-unknown-haiku".to_string(),
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "i686-unknown-linux-gnu".to_string(),
base.max_atomic_width = Some(64);
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".to_string());
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-Wl,-melf_i386".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
// The unwinder used by i686-unknown-linux-musl, the LLVM libunwind
// implementation, apparently relies on frame pointers existing... somehow.
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "i686-unknown-netbsdelf".to_string(),
base.max_atomic_width = Some(64);
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".to_string());
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-fuse-ld=lld".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "i686-unknown-openbsd".to_string(),
base.cpu = "pentium4".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m32".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "i686-unknown-linux-gnu".to_string(),
late_link_args.insert(
LinkerFlavor::Gcc,
vec![
+ // The illumos libc contains a stack unwinding implementation, as
+ // does libgcc_s. The latter implementation includes several
+ // additional symbols that are not always in base libc. To force
+ // the consistent use of just one unwinder, we ensure libc appears
+ // after libgcc_s in the NEEDED list for the resultant binary by
+ // ignoring any attempts to add it as a dynamic dependency until the
+ // very end.
+ // FIXME: This should be replaced by a more complete and generic
+ // mechanism for controlling the order of library arguments passed
+ // to the linker.
+ "-lc".to_string(),
// LLVM will insert calls to the stack protector functions
// "__stack_chk_fail" and "__stack_chk_guard" into code in native
// object files. Some platforms include these symbols directly in
dynamic_linking: true,
executables: true,
has_rpath: true,
- os_family: Some("unix".to_string()),
+ families: vec!["unix".to_string()],
is_like_solaris: true,
limit_rdylib_exports: false, // Linker doesn't support this
eliminate_frame_pointer: false,
executables: true,
panic_strategy: PanicStrategy::Abort,
linker: Some("ld".to_string()),
- os_family: Some("unix".to_string()),
+ families: vec!["unix".to_string()],
..Default::default()
}
}
os: "linux".to_string(),
dynamic_linking: true,
executables: true,
- os_family: Some("unix".to_string()),
+ families: vec!["unix".to_string()],
linker_is_gnu: true,
has_rpath: true,
position_independent_executables: true,
env: "gnu".to_string(),
disable_redzone: true,
panic_strategy: PanicStrategy::Abort,
- stack_probes: StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) },
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ stack_probes: StackProbeType::Call,
eliminate_frame_pointer: false,
linker_is_gnu: true,
position_independent_executables: true,
pub staticlib_prefix: String,
/// String to append to the name of every static library. Defaults to ".a".
pub staticlib_suffix: String,
- /// OS family to use for conditional compilation. Valid options: "unix", "windows".
- pub os_family: Option<String>,
+ /// Values of the `target_family` cfg set for this target.
+ ///
+ /// Common options are: "unix", "windows". Defaults to no families.
+ ///
+ /// See <https://doc.rust-lang.org/reference/conditional-compilation.html#target_family>.
+ pub families: Vec<String>,
/// Whether the target toolchain's ABI supports returning small structs as an integer.
pub abi_return_struct_as_int: bool,
/// Whether the target toolchain is like macOS's. Only useful for compiling against iOS/macOS,
exe_suffix: String::new(),
staticlib_prefix: "lib".to_string(),
staticlib_suffix: ".a".to_string(),
- os_family: None,
+ families: Vec::new(),
abi_return_struct_as_int: false,
is_like_osx: false,
is_like_solaris: false,
.map(|s| s.to_string() );
}
} );
- ($key_name:ident = $json_name:expr, optional) => ( {
- let name = $json_name;
- if let Some(o) = obj.find(name) {
- base.$key_name = o
- .as_string()
- .map(|s| s.to_string() );
- }
- } );
($key_name:ident, LldFlavor) => ( {
let name = (stringify!($key_name)).replace("_", "-");
obj.find(&name[..]).and_then(|o| o.as_string().and_then(|s| {
Some(Ok(()))
})).unwrap_or(Ok(()))
} );
+ ($key_name:ident, TargetFamilies) => ( {
+ let value = obj.find("target-family");
+ if let Some(v) = value.and_then(Json::as_array) {
+ base.$key_name = v.iter()
+ .map(|a| a.as_string().unwrap().to_string())
+ .collect();
+ } else if let Some(v) = value.and_then(Json::as_string) {
+ base.$key_name = vec![v.to_string()];
+ }
+ } );
}
if let Some(s) = obj.find("target-endian").and_then(Json::as_string) {
key!(exe_suffix);
key!(staticlib_prefix);
key!(staticlib_suffix);
- key!(os_family = "target-family", optional);
+ key!(families, TargetFamilies);
key!(abi_return_struct_as_int, bool);
key!(is_like_osx, bool);
key!(is_like_solaris, bool);
target_option_val!(exe_suffix);
target_option_val!(staticlib_prefix);
target_option_val!(staticlib_suffix);
- target_option_val!(os_family, "target-family");
+ target_option_val!(families, "target-family");
target_option_val!(abi_return_struct_as_int);
target_option_val!(is_like_osx);
target_option_val!(is_like_solaris);
os: "netbsd".to_string(),
dynamic_linking: true,
executables: true,
- os_family: Some("unix".to_string()),
+ families: vec!["unix".to_string()],
linker_is_gnu: true,
no_default_libraries: false,
has_rpath: true,
os: "openbsd".to_string(),
dynamic_linking: true,
executables: true,
- os_family: Some("unix".to_string()),
+ families: vec!["unix".to_string()],
linker_is_gnu: true,
has_rpath: true,
abi_return_struct_as_int: true,
env: "relibc".to_string(),
dynamic_linking: true,
executables: true,
- os_family: Some("unix".to_string()),
+ families: vec!["unix".to_string()],
linker_is_gnu: true,
has_rpath: true,
position_independent_executables: true,
dynamic_linking: true,
executables: true,
has_rpath: true,
- os_family: Some("unix".to_string()),
+ families: vec!["unix".to_string()],
is_like_solaris: true,
limit_rdylib_exports: false, // Linker doesn't support this
eh_frame_header: false,
exe_suffix: ".vxe".to_string(),
dynamic_linking: true,
executables: true,
- os_family: Some("unix".to_string()),
+ families: vec!["unix".to_string()],
linker_is_gnu: true,
has_rpath: true,
has_elf_tls: true,
is_like_emscripten: true,
panic_strategy: PanicStrategy::Unwind,
post_link_args,
- os_family: Some("unix".to_string()),
+ families: vec!["unix".to_string()],
..options
};
Target {
TargetOptions {
is_like_wasm: true,
+ families: vec!["wasm".to_string()],
// we allow dynamic linking, but only cdylibs. Basically we allow a
// final library artifact that exports some symbols (a wasm module) but
dll_prefix: String::new(),
dll_suffix: ".dll".to_string(),
exe_suffix: ".exe".to_string(),
- os_family: Some("windows".to_string()),
+ families: vec!["windows".to_string()],
is_like_windows: true,
allows_weak_linkage: false,
pre_link_args,
exe_suffix: ".exe".to_string(),
staticlib_prefix: String::new(),
staticlib_suffix: ".lib".to_string(),
- os_family: Some("windows".to_string()),
+ families: vec!["windows".to_string()],
crt_static_allows_dylibs: true,
crt_static_respected: true,
requires_uwtable: true,
vec!["-m64".to_string(), "-arch".to_string(), "x86_64".to_string()],
);
base.link_env_remove.extend(super::apple_base::macos_link_env_remove());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::LEAK | SanitizerSet::THREAD;
// Clang automatically chooses a more specific target based on
arch: "x86_64".to_string(),
options: TargetOptions {
max_atomic_width: Some(64),
- stack_probes: StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) },
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ stack_probes: StackProbeType::Call,
..base
},
}
arch: "x86_64".to_string(),
options: TargetOptions {
max_atomic_width: Some(64),
- stack_probes: StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) },
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ stack_probes: StackProbeType::Call,
..base
},
}
arch: "x86_64".to_string(),
options: TargetOptions {
max_atomic_width: Some(64),
- stack_probes: StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) },
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ stack_probes: StackProbeType::Call,
..base
},
}
let mut base = super::fuchsia_base::opts();
base.cpu = "x86-64".to_string();
base.max_atomic_width = Some(64);
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
base.supported_sanitizers = SanitizerSet::ADDRESS;
Target {
base.features = "+mmx,+sse,+sse2,+sse3,+ssse3,+sse4.1,+sse4.2,+popcnt".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m64".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "x86_64-linux-android".to_string(),
base.cpu = "x86-64".to_string();
base.vendor = "pc".to_string();
base.max_atomic_width = Some(64);
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "x86_64-pc-solaris".to_string(),
base.cpu = "x86-64".to_string();
base.vendor = "sun".to_string();
base.max_atomic_width = Some(64);
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "x86_64-pc-solaris".to_string(),
base.cpu = "x86-64".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m64".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "x86_64-unknown-dragonfly".to_string(),
base.cpu = "x86-64".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m64".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
base.supported_sanitizers = SanitizerSet::ADDRESS | SanitizerSet::MEMORY | SanitizerSet::THREAD;
Target {
base.cpu = "x86-64".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.insert(LinkerFlavor::Gcc, vec!["-m64".to_string()]);
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
// This option is required to build executables on Haiku x86_64
base.position_independent_executables = true;
base.cpu = "x86-64".to_string();
base.max_atomic_width = Some(64);
base.features = "+rdrnd,+rdseed".to_string();
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "x86_64-unknown-hermit".to_string(),
base.cpu = "x86-64".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m64".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
base.supported_sanitizers =
SanitizerSet::ADDRESS | SanitizerSet::LEAK | SanitizerSet::MEMORY | SanitizerSet::THREAD;
base.cpu = "x86-64".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-mx32".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
base.has_elf_tls = false;
// BUG(GabrielMajeri): disabling the PLT on x86_64 Linux with x32 ABI
// breaks code gen. See LLVM bug 36743
base.cpu = "x86-64".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m64".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
base.static_position_independent_executables = true;
base.supported_sanitizers =
SanitizerSet::ADDRESS | SanitizerSet::LEAK | SanitizerSet::MEMORY | SanitizerSet::THREAD;
base.cpu = "x86-64".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m64".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "x86_64-unknown-netbsd".to_string(),
base.features =
"-mmx,-sse,-sse2,-sse3,-ssse3,-sse4.1,-sse4.2,-3dnow,-3dnowa,-avx,-avx2,+soft-float"
.to_string();
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "x86_64-unknown-none-elf".to_string(),
base.cpu = "x86-64".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m64".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "x86_64-unknown-openbsd".to_string(),
base.cpu = "x86-64".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m64".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
Target {
llvm_target: "x86_64-unknown-redox".to_string(),
base.cpu = "x86-64".to_string();
base.max_atomic_width = Some(64);
base.pre_link_args.entry(LinkerFlavor::Gcc).or_default().push("-m64".to_string());
- base.stack_probes = StackProbeType::InlineOrCall { min_llvm_version_for_inline: (11, 0, 1) };
+ // don't use probe-stack=inline-asm until rust#83139 and rust#84667 are resolved
+ base.stack_probes = StackProbeType::Call;
base.disable_redzone = true;
Target {
}
/// Returns `true` if the global caches can be used.
- /// Do note that if the type itself is not in the
- /// global tcx, the local caches will be used.
fn can_use_global_caches(&self, param_env: ty::ParamEnv<'tcx>) -> bool {
// If there are any inference variables in the `ParamEnv`, then we
// always use a cache local to this particular scope. Otherwise, we
) => false,
(ParamCandidate(other), ParamCandidate(victim)) => {
- if other.value == victim.value && victim.constness == Constness::NotConst {
+ let value_same_except_bound_vars = other.value.skip_binder()
+ == victim.value.skip_binder()
+ && !other.value.skip_binder().has_escaping_bound_vars();
+ if value_same_except_bound_vars {
+ // See issue #84398. In short, we can generate multiple ParamCandidates which are
+ // the same except for unused bound vars. Just pick the one with the fewest bound vars
+ // or the current one if tied (they should both evaluate to the same answer). This is
+ // probably best characterized as a "hack", since we might prefer to just do our
+ // best to *not* create essentially duplicate candidates in the first place.
+ other.value.bound_vars().len() <= victim.value.bound_vars().len()
+ } else if other.value == victim.value && victim.constness == Constness::NotConst {
// Drop otherwise equivalent non-const candidates in favor of const candidates.
true
} else {
use rustc_data_structures::fx::FxIndexSet;
-use rustc_data_structures::svh::Svh;
use rustc_hir as hir;
use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
use rustc_middle::hir::map as hir_map;
tcx.crate_name
}
-fn crate_hash(tcx: TyCtxt<'_>, crate_num: CrateNum) -> Svh {
- tcx.index_hir(crate_num).crate_hash
-}
-
fn instance_def_size_estimate<'tcx>(
tcx: TyCtxt<'tcx>,
instance_def: ty::InstanceDef<'tcx>,
trait_of_item,
crate_disambiguator,
original_crate_name,
- crate_hash,
instance_def_size_estimate,
issue33140_self_ty,
impl_defaultness,
| TypeFlags::HAS_CT_INFER.bits
| TypeFlags::HAS_TY_PLACEHOLDER.bits
| TypeFlags::HAS_CT_PLACEHOLDER.bits
+ // We consider 'freshened' types and constants
+ // to depend on a particular fn.
+ // The freshening process throws away information,
+ // which can make things unsuitable for use in a global
+ // cache. Note that there is no 'fresh lifetime' flag -
+ // freshening replaces all lifetimes with `ReErased`,
+ // which is different from how types/const are freshened.
+ | TypeFlags::HAS_TY_FRESH.bits
+ | TypeFlags::HAS_CT_FRESH.bits
| TypeFlags::HAS_FREE_LOCAL_REGIONS.bits;
/// Does this have `Projection`?
/// Does this value have parameters/placeholders/inference variables which could be
/// replaced later, in a way that would change the results of `impl` specialization?
const STILL_FURTHER_SPECIALIZABLE = 1 << 17;
+
+ /// Does this value have `InferTy::FreshTy/FreshIntTy/FreshFloatTy`?
+ const HAS_TY_FRESH = 1 << 18;
+
+ /// Does this value have `InferConst::Fresh`?
+ const HAS_CT_FRESH = 1 << 19;
}
}
// another. This is an error. However, if we already know that
// the arguments don't match up with the parameters, we won't issue
// an additional error, as the user already knows what's wrong.
- if arg_count.correct.is_ok()
- && arg_count.explicit_late_bound == ExplicitLateBound::No
- {
+ if arg_count.correct.is_ok() {
// We're going to iterate over the parameters to sort them out, and
// show that order to the user as a possible order for the parameters
let mut param_types_present = defs
}
if silent {
- return false;
+ return true;
}
if provided > expected_max {
use rustc_attr as attr;
use rustc_errors::{Applicability, ErrorReported};
use rustc_hir as hir;
-use rustc_hir::def_id::{DefId, LocalDefId, LOCAL_CRATE};
+use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_hir::intravisit::Visitor;
use rustc_hir::lang_items::LangItem;
use rustc_hir::{def::Res, ItemKind, Node, PathSegment};
use rustc_middle::ty::layout::MAX_SIMD_LANES;
use rustc_middle::ty::subst::GenericArgKind;
use rustc_middle::ty::util::{Discr, IntTypeExt};
-use rustc_middle::ty::{self, ParamEnv, RegionKind, ToPredicate, Ty, TyCtxt};
-use rustc_session::config::EntryFnType;
+use rustc_middle::ty::{self, ParamEnv, RegionKind, Ty, TyCtxt};
use rustc_session::lint::builtin::UNINHABITED_STATIC;
use rustc_span::symbol::sym;
use rustc_span::{self, MultiSpan, Span};
use rustc_target::spec::abi::Abi;
use rustc_trait_selection::opaque_types::InferCtxtExt as _;
+use rustc_trait_selection::traits;
use rustc_trait_selection::traits::error_reporting::InferCtxtExt as _;
-use rustc_trait_selection::traits::{self, ObligationCauseCode};
use rustc_ty_utils::representability::{self, Representability};
use std::iter;
}
fcx.demand_suptype(span, revealed_ret_ty, actual_return_ty);
- // Check that the main return type implements the termination trait.
- if let Some(term_id) = tcx.lang_items().termination() {
- if let Some((def_id, EntryFnType::Main)) = tcx.entry_fn(LOCAL_CRATE) {
- let main_id = hir.local_def_id_to_hir_id(def_id);
- if main_id == fn_id {
- let substs = tcx.mk_substs_trait(declared_ret_ty, &[]);
- let trait_ref = ty::TraitRef::new(term_id, substs);
- let return_ty_span = decl.output.span();
- let cause = traits::ObligationCause::new(
- return_ty_span,
- fn_id,
- ObligationCauseCode::MainFunctionType,
- );
-
- inherited.register_predicate(traits::Obligation::new(
- cause,
- param_env,
- trait_ref.without_const().to_predicate(tcx),
- ));
- }
- }
- }
-
// Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
if let Some(panic_impl_did) = tcx.lang_items().panic_impl() {
if panic_impl_did == hir.local_def_id(fn_id).to_def_id() {
use rustc_session::lint;
use rustc_session::lint::builtin::BARE_TRAIT_OBJECTS;
use rustc_session::parse::feature_err;
+use rustc_span::edition::Edition;
use rustc_span::source_map::{original_sp, DUMMY_SP};
use rustc_span::symbol::{kw, sym, Ident};
use rustc_span::{self, BytePos, MultiSpan, Span};
if let TyKind::TraitObject([poly_trait_ref, ..], _, TraitObjectSyntax::None) =
self_ty.kind
{
- self.tcx.struct_span_lint_hir(BARE_TRAIT_OBJECTS, hir_id, self_ty.span, |lint| {
- let mut db = lint
- .build(&format!("trait objects without an explicit `dyn` are deprecated"));
- let (sugg, app) = match self.tcx.sess.source_map().span_to_snippet(self_ty.span)
- {
- Ok(s) if poly_trait_ref.trait_ref.path.is_global() => {
- (format!("<dyn ({})>", s), Applicability::MachineApplicable)
- }
- Ok(s) => (format!("<dyn {}>", s), Applicability::MachineApplicable),
- Err(_) => ("<dyn <type>>".to_string(), Applicability::HasPlaceholders),
- };
- db.span_suggestion(self_ty.span, "use `dyn`", sugg, app);
- db.emit()
- });
+ let msg = "trait objects without an explicit `dyn` are deprecated";
+ let (sugg, app) = match self.tcx.sess.source_map().span_to_snippet(self_ty.span) {
+ Ok(s) if poly_trait_ref.trait_ref.path.is_global() => {
+ (format!("<dyn ({})>", s), Applicability::MachineApplicable)
+ }
+ Ok(s) => (format!("<dyn {}>", s), Applicability::MachineApplicable),
+ Err(_) => ("<dyn <type>>".to_string(), Applicability::HasPlaceholders),
+ };
+ let replace = String::from("use `dyn`");
+ if self.sess().edition() >= Edition::Edition2021 {
+ let mut err = rustc_errors::struct_span_err!(
+ self.sess(),
+ self_ty.span,
+ E0783,
+ "{}",
+ msg,
+ );
+ err.span_suggestion(
+ self_ty.span,
+ &sugg,
+ replace,
+ Applicability::MachineApplicable,
+ )
+ .emit();
+ } else {
+ self.tcx.struct_span_lint_hir(
+ BARE_TRAIT_OBJECTS,
+ hir_id,
+ self_ty.span,
+ |lint| {
+ let mut db = lint.build(msg);
+ db.span_suggestion(self_ty.span, &replace, sugg, app);
+ db.emit()
+ },
+ );
+ }
}
}
}
let mut infer_args_for_err = FxHashSet::default();
+ let mut explicit_late_bound = ExplicitLateBound::No;
for &PathSeg(def_id, index) in &path_segs {
let seg = &segments[index];
let generics = tcx.generics_of(def_id);
// parameter internally, but we don't allow users to specify the
// parameter's value explicitly, so we have to do some error-
// checking here.
- if let GenericArgCountResult {
- correct: Err(GenericArgCountMismatch { reported: Some(_), .. }),
- ..
- } = <dyn AstConv<'_>>::check_generic_arg_count_for_call(
+ let arg_count = <dyn AstConv<'_>>::check_generic_arg_count_for_call(
tcx,
span,
def_id,
&generics,
seg,
IsMethodCall::No,
- ) {
+ );
+
+ if let ExplicitLateBound::Yes = arg_count.explicit_late_bound {
+ explicit_late_bound = ExplicitLateBound::Yes;
+ }
+
+ if let Err(GenericArgCountMismatch { reported: Some(_), .. }) = arg_count.correct {
infer_args_for_err.insert(index);
self.set_tainted_by_errors(); // See issue #53251.
}
let ty = tcx.type_of(def_id);
let arg_count = GenericArgCountResult {
- explicit_late_bound: ExplicitLateBound::No,
+ explicit_late_bound,
correct: if infer_args_for_err.is_empty() {
Ok(())
} else {
}
let mut restrict_type_params = false;
+ let mut unsatisfied_bounds = false;
if !unsatisfied_predicates.is_empty() {
let def_span = |def_id| {
self.tcx.sess.source_map().guess_head_span(self.tcx.def_span(def_id))
err.note(&format!(
"the following trait bounds were not satisfied:\n{bound_list}"
));
+ unsatisfied_bounds = true;
}
}
source,
out_of_scope_traits,
&unsatisfied_predicates,
+ unsatisfied_bounds,
);
}
source: SelfSource<'tcx>,
valid_out_of_scope_traits: Vec<DefId>,
unsatisfied_predicates: &[(ty::Predicate<'tcx>, Option<ty::Predicate<'tcx>>)],
+ unsatisfied_bounds: bool,
) {
let mut alt_rcvr_sugg = false;
- if let SelfSource::MethodCall(rcvr) = source {
+ if let (SelfSource::MethodCall(rcvr), false) = (source, unsatisfied_bounds) {
debug!(?span, ?item_name, ?rcvr_ty, ?rcvr);
let skippable = [
self.tcx.lang_items().clone_trait(),
use rustc_middle::ty::query::Providers;
use rustc_middle::ty::subst::GenericArgKind;
use rustc_middle::ty::subst::{InternalSubsts, Subst, SubstsRef};
-use rustc_middle::ty::WithConstness;
use rustc_middle::ty::{self, RegionKind, Ty, TyCtxt, UserType};
use rustc_session::config;
use rustc_session::parse::feature_err;
),
)
} else {
- tcx.sess
- .struct_span_err(
- hir_ty.span,
- &format!(
- "{} is forbidden as the type of a const generic parameter",
- unsupported_type
- ),
- )
- .note("the only supported types are integers, `bool` and `char`")
- .help("more complex types are supported with `#![feature(const_generics)]`")
- .emit()
+ let mut err = tcx.sess.struct_span_err(
+ hir_ty.span,
+ &format!(
+ "{} is forbidden as the type of a const generic parameter",
+ unsupported_type
+ ),
+ );
+ err.note("the only supported types are integers, `bool` and `char`");
+ if tcx.sess.is_nightly_build() {
+ err.help(
+ "more complex types are supported with `#![feature(const_generics)]`",
+ );
+ }
+ err.emit()
}
};
match param.name {
hir::ParamName::Error => {}
- _ => report_bivariance(tcx, param.span, param.name.ident().name),
+ _ => report_bivariance(tcx, param),
}
}
}
-fn report_bivariance(tcx: TyCtxt<'_>, span: Span, param_name: Symbol) {
+fn report_bivariance(tcx: TyCtxt<'_>, param: &rustc_hir::GenericParam<'_>) {
+ let span = param.span;
+ let param_name = param.name.ident().name;
let mut err = error_392(tcx, span, param_name);
let suggested_marker_id = tcx.lang_items().phantom_data();
format!("consider removing `{}` or referring to it in a field", param_name)
};
err.help(&msg);
- err.emit();
+
+ if matches!(param.kind, rustc_hir::GenericParamKind::Type { .. }) {
+ err.help(&format!(
+ "if you intended `{0}` to be a const parameter, use `const {0}: usize` instead",
+ param_name
+ ));
+ }
+ err.emit()
}
/// Feature gates RFC 2056 -- trivial bounds, checking for global bounds that
let mut inline_span = None;
let mut link_ordinal_span = None;
let mut no_sanitize_span = None;
- let mut no_coverage_feature_enabled = false;
- let mut no_coverage_attr = None;
for attr in attrs.iter() {
if tcx.sess.check_name(attr, sym::cold) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::COLD;
codegen_fn_attrs.flags |= CodegenFnAttrFlags::NAKED;
} else if tcx.sess.check_name(attr, sym::no_mangle) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_MANGLE;
- } else if attr.has_name(sym::feature) {
- if let Some(list) = attr.meta_item_list() {
- if list.iter().any(|nested_meta_item| nested_meta_item.has_name(sym::no_coverage)) {
- tcx.sess.mark_attr_used(attr);
- no_coverage_feature_enabled = true;
- }
- }
} else if tcx.sess.check_name(attr, sym::no_coverage) {
- no_coverage_attr = Some(attr);
+ codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_COVERAGE;
} else if tcx.sess.check_name(attr, sym::rustc_std_internal_symbol) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL;
} else if tcx.sess.check_name(attr, sym::used) {
}
}
- if let Some(no_coverage_attr) = no_coverage_attr {
- if tcx.sess.features_untracked().no_coverage || no_coverage_feature_enabled {
- codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_COVERAGE
- } else {
- let mut err = feature_err(
- &tcx.sess.parse_sess,
- sym::no_coverage,
- no_coverage_attr.span,
- "the `#[no_coverage]` attribute is an experimental feature",
- );
- if tcx.sess.parse_sess.unstable_features.is_nightly_build() {
- err.help("or, alternatively, add `#[feature(no_coverage)]` to the function");
- }
- err.emit();
- }
- }
-
codegen_fn_attrs.inline = attrs.iter().fold(InlineAttr::None, |ia, attr| {
if !attr.has_name(sym::inline) {
return ia;
Res::Def(DefKind::Ctor(..), def_id) => {
tcx.generics_of(tcx.parent(def_id).unwrap())
}
- Res::Def(_, def_id) => tcx.generics_of(def_id),
+ // Other `DefKind`s don't have generics and would ICE when calling
+ // `generics_of`.
+ Res::Def(
+ DefKind::Struct
+ | DefKind::Union
+ | DefKind::Enum
+ | DefKind::Variant
+ | DefKind::Trait
+ | DefKind::OpaqueTy
+ | DefKind::TyAlias
+ | DefKind::ForeignTy
+ | DefKind::TraitAlias
+ | DefKind::AssocTy
+ | DefKind::Fn
+ | DefKind::AssocFn
+ | DefKind::AssocConst
+ | DefKind::Impl,
+ def_id,
+ ) => tcx.generics_of(def_id),
Res::Err => {
tcx.sess.delay_span_bug(tcx.def_span(def_id), "anon const with Res::Err");
return None;
PlaceBase::Local(*var_hir_id)
};
let place_with_id = PlaceWithHirId::new(
- capture_info.path_expr_id.unwrap_or(closure_expr.hir_id),
+ capture_info.path_expr_id.unwrap_or(
+ capture_info.capture_kind_expr_id.unwrap_or(closure_expr.hir_id),
+ ),
place.base_ty,
place_base,
place.projections.clone(),
use rustc_errors::{struct_span_err, ErrorReported};
use rustc_hir as hir;
-use rustc_hir::def_id::{LocalDefId, LOCAL_CRATE};
-use rustc_hir::Node;
+use rustc_hir::def_id::{DefId, LOCAL_CRATE};
+use rustc_hir::{Node, CRATE_HIR_ID};
use rustc_infer::infer::{InferOk, TyCtxtInferExt};
use rustc_infer::traits::TraitEngineExt as _;
use rustc_middle::middle;
use rustc_target::spec::abi::Abi;
use rustc_trait_selection::traits::error_reporting::InferCtxtExt as _;
use rustc_trait_selection::traits::{
- ObligationCause, ObligationCauseCode, TraitEngine, TraitEngineExt as _,
+ self, ObligationCause, ObligationCauseCode, TraitEngine, TraitEngineExt as _,
};
use std::iter;
})
}
-fn check_main_fn_ty(tcx: TyCtxt<'_>, main_def_id: LocalDefId) {
- let main_id = tcx.hir().local_def_id_to_hir_id(main_def_id);
+fn check_main_fn_ty(tcx: TyCtxt<'_>, main_def_id: DefId) {
+ let main_fnsig = tcx.fn_sig(main_def_id);
let main_span = tcx.def_span(main_def_id);
- let main_t = tcx.type_of(main_def_id);
- match main_t.kind() {
- ty::FnDef(..) => {
- if let Some(Node::Item(it)) = tcx.hir().find(main_id) {
- if let hir::ItemKind::Fn(ref sig, ref generics, _) = it.kind {
- let mut error = false;
- if !generics.params.is_empty() {
- let msg = "`main` function is not allowed to have generic \
- parameters"
- .to_owned();
- let label = "`main` cannot have generic parameters".to_string();
- struct_span_err!(tcx.sess, generics.span, E0131, "{}", msg)
- .span_label(generics.span, label)
- .emit();
- error = true;
- }
- if let Some(sp) = generics.where_clause.span() {
- struct_span_err!(
- tcx.sess,
- sp,
- E0646,
- "`main` function is not allowed to have a `where` clause"
- )
- .span_label(sp, "`main` cannot have a `where` clause")
- .emit();
- error = true;
- }
- if let hir::IsAsync::Async = sig.header.asyncness {
- let span = tcx.sess.source_map().guess_head_span(it.span);
- struct_span_err!(
- tcx.sess,
- span,
- E0752,
- "`main` function is not allowed to be `async`"
- )
- .span_label(span, "`main` function is not allowed to be `async`")
- .emit();
- error = true;
- }
- let attrs = tcx.hir().attrs(main_id);
- for attr in attrs {
- if tcx.sess.check_name(attr, sym::track_caller) {
- tcx.sess
- .struct_span_err(
- attr.span,
- "`main` function is not allowed to be `#[track_caller]`",
- )
- .span_label(
- main_span,
- "`main` function is not allowed to be `#[track_caller]`",
- )
- .emit();
- error = true;
- }
- }
+ fn main_fn_diagnostics_hir_id(tcx: TyCtxt<'_>, def_id: DefId, sp: Span) -> hir::HirId {
+ if let Some(local_def_id) = def_id.as_local() {
+ let hir_id = tcx.hir().local_def_id_to_hir_id(local_def_id);
+ let hir_type = tcx.type_of(local_def_id);
+ if !matches!(hir_type.kind(), ty::FnDef(..)) {
+ span_bug!(sp, "main has a non-function type: found `{}`", hir_type);
+ }
+ hir_id
+ } else {
+ CRATE_HIR_ID
+ }
+ }
- if error {
- return;
- }
- }
+ fn main_fn_generics_params_span(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Span> {
+ if !def_id.is_local() {
+ return None;
+ }
+ let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
+ match tcx.hir().find(hir_id) {
+ Some(Node::Item(hir::Item { kind: hir::ItemKind::Fn(_, ref generics, _), .. })) => {
+ let generics_param_span =
+ if !generics.params.is_empty() { Some(generics.span) } else { None };
+ generics_param_span
+ }
+ _ => {
+ span_bug!(tcx.def_span(def_id), "main has a non-function type");
}
+ }
+ }
- let actual = tcx.fn_sig(main_def_id);
- let expected_return_type = if tcx.lang_items().termination().is_some() {
- // we take the return type of the given main function, the real check is done
- // in `check_fn`
- actual.output()
- } else {
- // standard () main return type
- ty::Binder::dummy(tcx.mk_unit())
- };
-
- let se_ty = tcx.mk_fn_ptr(expected_return_type.map_bound(|expected_return_type| {
- tcx.mk_fn_sig(
- iter::empty(),
- expected_return_type,
- false,
- hir::Unsafety::Normal,
- Abi::Rust,
- )
- }));
+ fn main_fn_where_clauses_span(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Span> {
+ if !def_id.is_local() {
+ return None;
+ }
+ let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
+ match tcx.hir().find(hir_id) {
+ Some(Node::Item(hir::Item { kind: hir::ItemKind::Fn(_, ref generics, _), .. })) => {
+ generics.where_clause.span()
+ }
+ _ => {
+ span_bug!(tcx.def_span(def_id), "main has a non-function type");
+ }
+ }
+ }
- require_same_types(
- tcx,
- &ObligationCause::new(main_span, main_id, ObligationCauseCode::MainFunctionType),
- se_ty,
- tcx.mk_fn_ptr(actual),
- );
+ fn main_fn_asyncness_span(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Span> {
+ if !def_id.is_local() {
+ return None;
}
- _ => {
- span_bug!(main_span, "main has a non-function type: found `{}`", main_t);
+ let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
+ match tcx.hir().find(hir_id) {
+ Some(Node::Item(hir::Item { span: item_span, .. })) => {
+ Some(tcx.sess.source_map().guess_head_span(*item_span))
+ }
+ _ => {
+ span_bug!(tcx.def_span(def_id), "main has a non-function type");
+ }
}
}
-}
-fn check_start_fn_ty(tcx: TyCtxt<'_>, start_def_id: LocalDefId) {
+ fn main_fn_return_type_span(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Span> {
+ if !def_id.is_local() {
+ return None;
+ }
+ let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
+ match tcx.hir().find(hir_id) {
+ Some(Node::Item(hir::Item { kind: hir::ItemKind::Fn(ref fn_sig, _, _), .. })) => {
+ Some(fn_sig.decl.output.span())
+ }
+ _ => {
+ span_bug!(tcx.def_span(def_id), "main has a non-function type");
+ }
+ }
+ }
+
+ let mut error = false;
+ let main_diagnostics_hir_id = main_fn_diagnostics_hir_id(tcx, main_def_id, main_span);
+ let main_fn_generics = tcx.generics_of(main_def_id);
+ let main_fn_predicates = tcx.predicates_of(main_def_id);
+ if main_fn_generics.count() != 0 || !main_fnsig.bound_vars().is_empty() {
+ let generics_param_span = main_fn_generics_params_span(tcx, main_def_id);
+ let msg = "`main` function is not allowed to have generic \
+ parameters";
+ let mut diag =
+ struct_span_err!(tcx.sess, generics_param_span.unwrap_or(main_span), E0131, "{}", msg);
+ if let Some(generics_param_span) = generics_param_span {
+ let label = "`main` cannot have generic parameters".to_string();
+ diag.span_label(generics_param_span, label);
+ }
+ diag.emit();
+ error = true;
+ } else if !main_fn_predicates.predicates.is_empty() {
+ // generics may bring in implicit predicates, so we skip this check if generics is present.
+ let generics_where_clauses_span = main_fn_where_clauses_span(tcx, main_def_id);
+ let mut diag = struct_span_err!(
+ tcx.sess,
+ generics_where_clauses_span.unwrap_or(main_span),
+ E0646,
+ "`main` function is not allowed to have a `where` clause"
+ );
+ if let Some(generics_where_clauses_span) = generics_where_clauses_span {
+ diag.span_label(generics_where_clauses_span, "`main` cannot have a `where` clause");
+ }
+ diag.emit();
+ error = true;
+ }
+
+ let main_asyncness = tcx.asyncness(main_def_id);
+ if let hir::IsAsync::Async = main_asyncness {
+ let mut diag = struct_span_err!(
+ tcx.sess,
+ main_span,
+ E0752,
+ "`main` function is not allowed to be `async`"
+ );
+ let asyncness_span = main_fn_asyncness_span(tcx, main_def_id);
+ if let Some(asyncness_span) = asyncness_span {
+ diag.span_label(asyncness_span, "`main` function is not allowed to be `async`");
+ }
+ diag.emit();
+ error = true;
+ }
+
+ for attr in tcx.get_attrs(main_def_id) {
+ if tcx.sess.check_name(attr, sym::track_caller) {
+ tcx.sess
+ .struct_span_err(
+ attr.span,
+ "`main` function is not allowed to be `#[track_caller]`",
+ )
+ .span_label(main_span, "`main` function is not allowed to be `#[track_caller]`")
+ .emit();
+ error = true;
+ }
+ }
+
+ if error {
+ return;
+ }
+
+ let expected_return_type;
+ if let Some(term_id) = tcx.lang_items().termination() {
+ let return_ty = main_fnsig.output();
+ let return_ty_span = main_fn_return_type_span(tcx, main_def_id).unwrap_or(main_span);
+ if !return_ty.bound_vars().is_empty() {
+ let msg = "`main` function return type is not allowed to have generic \
+ parameters"
+ .to_owned();
+ struct_span_err!(tcx.sess, return_ty_span, E0131, "{}", msg).emit();
+ error = true;
+ }
+ let return_ty = return_ty.skip_binder();
+ tcx.infer_ctxt().enter(|infcx| {
+ let cause = traits::ObligationCause::new(
+ return_ty_span,
+ main_diagnostics_hir_id,
+ ObligationCauseCode::MainFunctionType,
+ );
+ let mut fulfillment_cx = traits::FulfillmentContext::new();
+ fulfillment_cx.register_bound(&infcx, ty::ParamEnv::empty(), return_ty, term_id, cause);
+ if let Err(err) = fulfillment_cx.select_all_or_error(&infcx) {
+ infcx.report_fulfillment_errors(&err, None, false);
+ error = true;
+ }
+ });
+ // now we can take the return type of the given main function
+ expected_return_type = main_fnsig.output();
+ } else {
+ // standard () main return type
+ expected_return_type = ty::Binder::dummy(tcx.mk_unit());
+ }
+
+ if error {
+ return;
+ }
+
+ let se_ty = tcx.mk_fn_ptr(expected_return_type.map_bound(|expected_return_type| {
+ tcx.mk_fn_sig(iter::empty(), expected_return_type, false, hir::Unsafety::Normal, Abi::Rust)
+ }));
+
+ require_same_types(
+ tcx,
+ &ObligationCause::new(
+ main_span,
+ main_diagnostics_hir_id,
+ ObligationCauseCode::MainFunctionType,
+ ),
+ se_ty,
+ tcx.mk_fn_ptr(main_fnsig),
+ );
+}
+fn check_start_fn_ty(tcx: TyCtxt<'_>, start_def_id: DefId) {
+ let start_def_id = start_def_id.expect_local();
let start_id = tcx.hir().local_def_id_to_hir_id(start_def_id);
let start_span = tcx.def_span(start_def_id);
let start_t = tcx.type_of(start_def_id);
/// The allocator for unique pointers.
// This function must not unwind. If it does, MIR codegen will fail.
-#[cfg(not(test))]
+#[cfg(all(not(no_global_oom_handling), not(test)))]
#[lang = "exchange_malloc"]
#[inline]
unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
// # Allocation error handler
+#[cfg(not(no_global_oom_handling))]
extern "Rust" {
// This is the magic symbol to call the global alloc error handler. rustc generates
// it to call `__rg_oom` if there is a `#[alloc_error_handler]`, or to call the
/// [`set_alloc_error_hook`]: ../../std/alloc/fn.set_alloc_error_hook.html
/// [`take_alloc_error_hook`]: ../../std/alloc/fn.take_alloc_error_hook.html
#[stable(feature = "global_alloc", since = "1.28.0")]
-#[cfg(not(test))]
+#[cfg(all(not(no_global_oom_handling), not(test)))]
#[rustc_allocator_nounwind]
#[cold]
pub fn handle_alloc_error(layout: Layout) -> ! {
}
// For alloc test `std::alloc::handle_alloc_error` can be used directly.
-#[cfg(test)]
+#[cfg(all(not(no_global_oom_handling), test))]
pub use std::alloc::handle_alloc_error;
-#[cfg(not(any(target_os = "hermit", test)))]
+#[cfg(all(not(no_global_oom_handling), not(any(target_os = "hermit", test))))]
#[doc(hidden)]
#[allow(unused_attributes)]
#[unstable(feature = "alloc_internals", issue = "none")]
use core::cmp::Ordering;
use core::hash::{Hash, Hasher};
-use core::ops::{Add, AddAssign, Deref};
+use core::ops::Deref;
+#[cfg(not(no_global_oom_handling))]
+use core::ops::{Add, AddAssign};
#[stable(feature = "rust1", since = "1.0.0")]
pub use core::borrow::{Borrow, BorrowMut};
use crate::fmt;
+#[cfg(not(no_global_oom_handling))]
use crate::string::String;
use Cow::*;
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_add", since = "1.14.0")]
impl<'a> Add<&'a str> for Cow<'a, str> {
type Output = Cow<'a, str>;
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_add", since = "1.14.0")]
impl<'a> Add<Cow<'a, str>> for Cow<'a, str> {
type Output = Cow<'a, str>;
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_add", since = "1.14.0")]
impl<'a> AddAssign<&'a str> for Cow<'a, str> {
fn add_assign(&mut self, rhs: &'a str) {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_add", since = "1.14.0")]
impl<'a> AddAssign<Cow<'a, str>> for Cow<'a, str> {
fn add_assign(&mut self, rhs: Cow<'a, str>) {
//! /* Returns ownership to the caller */
//! struct Foo* foo_new(void);
//!
-//! /* Takes ownership from the caller; no-op when invoked with NULL */
+//! /* Takes ownership from the caller; no-op when invoked with null */
//! void foo_delete(struct Foo*);
//! ```
//!
use core::fmt;
use core::future::Future;
use core::hash::{Hash, Hasher};
-use core::iter::{FromIterator, FusedIterator, Iterator};
+#[cfg(not(no_global_oom_handling))]
+use core::iter::FromIterator;
+use core::iter::{FusedIterator, Iterator};
use core::marker::{Unpin, Unsize};
use core::mem;
use core::ops::{
use core::stream::Stream;
use core::task::{Context, Poll};
-use crate::alloc::{handle_alloc_error, AllocError, Allocator, Global, Layout, WriteCloneIntoRaw};
+#[cfg(not(no_global_oom_handling))]
+use crate::alloc::{handle_alloc_error, WriteCloneIntoRaw};
+use crate::alloc::{AllocError, Allocator, Global, Layout};
+#[cfg(not(no_global_oom_handling))]
use crate::borrow::Cow;
+#[cfg(not(no_global_oom_handling))]
use crate::raw_vec::RawVec;
+#[cfg(not(no_global_oom_handling))]
use crate::str::from_boxed_utf8_unchecked;
+#[cfg(not(no_global_oom_handling))]
use crate::vec::Vec;
/// A pointer type for heap allocation.
/// ```
/// let five = Box::new(5);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline(always)]
#[doc(alias = "alloc")]
#[doc(alias = "malloc")]
///
/// assert_eq!(*five, 5)
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
#[inline]
pub fn new_uninit() -> Box<mem::MaybeUninit<T>> {
/// ```
///
/// [zeroed]: mem::MaybeUninit::zeroed
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[doc(alias = "calloc")]
#[unstable(feature = "new_uninit", issue = "63291")]
/// Constructs a new `Pin<Box<T>>`. If `T` does not implement `Unpin`, then
/// `x` will be pinned in memory and unable to be moved.
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "pin", since = "1.33.0")]
#[inline(always)]
pub fn pin(x: T) -> Pin<Box<T>> {
///
/// let five = Box::new_in(5, System);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "allocator_api", issue = "32838")]
#[inline]
pub fn new_in(x: T, alloc: A) -> Self {
/// assert_eq!(*five, 5)
/// ```
#[unstable(feature = "allocator_api", issue = "32838")]
+ #[cfg(not(no_global_oom_handling))]
// #[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_uninit_in(alloc: A) -> Box<mem::MaybeUninit<T>, A> {
let layout = Layout::new::<mem::MaybeUninit<T>>();
///
/// [zeroed]: mem::MaybeUninit::zeroed
#[unstable(feature = "allocator_api", issue = "32838")]
+ #[cfg(not(no_global_oom_handling))]
// #[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_zeroed_in(alloc: A) -> Box<mem::MaybeUninit<T>, A> {
let layout = Layout::new::<mem::MaybeUninit<T>>();
/// Constructs a new `Pin<Box<T, A>>`. If `T` does not implement `Unpin`, then
/// `x` will be pinned in memory and unable to be moved.
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "allocator_api", issue = "32838")]
#[inline(always)]
pub fn pin_in(x: T, alloc: A) -> Pin<Self>
///
/// assert_eq!(*values, [1, 2, 3])
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
unsafe { RawVec::with_capacity(len).into_box(len) }
/// ```
///
/// [zeroed]: mem::MaybeUninit::zeroed
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_zeroed_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
unsafe { RawVec::with_capacity_zeroed(len).into_box(len) }
///
/// assert_eq!(*values, [1, 2, 3])
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "allocator_api", issue = "32838")]
// #[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
/// ```
///
/// [zeroed]: mem::MaybeUninit::zeroed
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "allocator_api", issue = "32838")]
// #[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> Default for Box<[T]> {
fn default() -> Self {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "default_box_extra", since = "1.17.0")]
impl Default for Box<str> {
fn default() -> Self {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Clone, A: Allocator + Clone> Clone for Box<T, A> {
/// Returns a new box with a `clone()` of this box's contents.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "box_slice_clone", since = "1.3.0")]
impl Clone for Box<str> {
fn clone(&self) -> Self {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "from_for_ptrs", since = "1.6.0")]
impl<T> From<T> for Box<T> {
/// Converts a generic type `T` into a `Box<T>`
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "box_from_slice", since = "1.17.0")]
impl<T: Copy> From<&[T]> for Box<[T]> {
/// Converts a `&[T]` into a `Box<[T]>`
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "box_from_cow", since = "1.45.0")]
impl<T: Copy> From<Cow<'_, [T]>> for Box<[T]> {
#[inline]
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "box_from_slice", since = "1.17.0")]
impl From<&str> for Box<str> {
/// Converts a `&str` into a `Box<str>`
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "box_from_cow", since = "1.45.0")]
impl From<Cow<'_, str>> for Box<str> {
#[inline]
#[unstable(feature = "dispatch_from_dyn", issue = "none")]
impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Box<U>> for Box<T, Global> {}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "boxed_slice_from_iter", since = "1.32.0")]
impl<I> FromIterator<I> for Box<[I]> {
fn from_iter<T: IntoIterator<Item = I>>(iter: T) -> Self {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "box_slice_clone", since = "1.3.0")]
impl<T: Clone, A: Allocator + Clone> Clone for Box<[T], A> {
fn clone(&self) -> Self {
/// See its documentation for more.
///
/// [`into_keys`]: BTreeMap::into_keys
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
pub struct IntoKeys<K, V> {
inner: IntoIter<K, V>,
}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K: fmt::Debug, V> fmt::Debug for IntoKeys<K, V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(self.inner.iter().map(|(key, _)| key)).finish()
/// See its documentation for more.
///
/// [`into_values`]: BTreeMap::into_values
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
pub struct IntoValues<K, V> {
inner: IntoIter<K, V>,
}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V: fmt::Debug> fmt::Debug for IntoValues<K, V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(self.inner.iter().map(|(_, val)| val)).finish()
/// # Examples
///
/// ```
- /// #![feature(map_into_keys_values)]
/// use std::collections::BTreeMap;
///
/// let mut a = BTreeMap::new();
/// assert_eq!(keys, [1, 2]);
/// ```
#[inline]
- #[unstable(feature = "map_into_keys_values", issue = "75294")]
+ #[stable(feature = "map_into_keys_values", since = "1.54.0")]
pub fn into_keys(self) -> IntoKeys<K, V> {
IntoKeys { inner: self.into_iter() }
}
/// # Examples
///
/// ```
- /// #![feature(map_into_keys_values)]
/// use std::collections::BTreeMap;
///
/// let mut a = BTreeMap::new();
/// assert_eq!(values, ["hello", "goodbye"]);
/// ```
#[inline]
- #[unstable(feature = "map_into_keys_values", issue = "75294")]
+ #[stable(feature = "map_into_keys_values", since = "1.54.0")]
pub fn into_values(self) -> IntoValues<K, V> {
IntoValues { inner: self.into_iter() }
}
}
}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V> Iterator for IntoKeys<K, V> {
type Item = K;
}
}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V> DoubleEndedIterator for IntoKeys<K, V> {
fn next_back(&mut self) -> Option<K> {
self.inner.next_back().map(|(k, _)| k)
}
}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V> ExactSizeIterator for IntoKeys<K, V> {
fn len(&self) -> usize {
self.inner.len()
}
}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V> FusedIterator for IntoKeys<K, V> {}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V> Iterator for IntoValues<K, V> {
type Item = V;
}
}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V> DoubleEndedIterator for IntoValues<K, V> {
fn next_back(&mut self) -> Option<V> {
self.inner.next_back().map(|(_, v)| v)
}
}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V> ExactSizeIterator for IntoValues<K, V> {
fn len(&self) -> usize {
self.inner.len()
}
}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V> FusedIterator for IntoValues<K, V> {}
#[stable(feature = "btree_range", since = "1.17.0")]
/// The underlying representation of internal nodes. As with `LeafNode`s, these should be hidden
/// behind `BoxedNode`s to prevent dropping uninitialized keys and values. Any pointer to an
-/// `InternalNode` can be directly casted to a pointer to the underlying `LeafNode` portion of the
+/// `InternalNode` can be directly cast to a pointer to the underlying `LeafNode` portion of the
/// node, allowing code to act on leaf and internal nodes generically without having to even check
/// which of the two a pointer is pointing at. This property is enabled by the use of `repr(C)`.
#[repr(C)]
}
impl<'a, K, V, Type> NodeRef<marker::Mut<'a>, K, V, Type> {
- /// Temporarily takes out another, mutable reference to the same node. Beware, as
+ /// Temporarily takes out another mutable reference to the same node. Beware, as
/// this method is very dangerous, doubly so since it may not immediately appear
/// dangerous.
///
impl<BorrowType, K, V, NodeType, HandleType>
Handle<NodeRef<BorrowType, K, V, NodeType>, HandleType>
{
- /// Temporarily takes out another, immutable handle on the same location.
+ /// Temporarily takes out another immutable handle on the same location.
pub fn reborrow(&self) -> Handle<NodeRef<marker::Immut<'_>, K, V, NodeType>, HandleType> {
// We can't use Handle::new_kv or Handle::new_edge because we don't know our type
Handle { node: self.node.reborrow(), idx: self.idx, _marker: PhantomData }
}
impl<'a, K, V, NodeType, HandleType> Handle<NodeRef<marker::Mut<'a>, K, V, NodeType>, HandleType> {
- /// Temporarily takes out another, mutable handle on the same location. Beware, as
+ /// Temporarily takes out another mutable handle on the same location. Beware, as
/// this method is very dangerous, doubly so since it may not immediately appear
/// dangerous.
///
#![stable(feature = "rust1", since = "1.0.0")]
+#[cfg(not(no_global_oom_handling))]
pub mod binary_heap;
+#[cfg(not(no_global_oom_handling))]
mod btree;
+#[cfg(not(no_global_oom_handling))]
pub mod linked_list;
+#[cfg(not(no_global_oom_handling))]
pub mod vec_deque;
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
pub mod btree_map {
//! A map based on a B-Tree.
pub use super::btree::map::*;
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
pub mod btree_set {
//! A set based on a B-Tree.
pub use super::btree::set::*;
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(no_inline)]
pub use binary_heap::BinaryHeap;
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(no_inline)]
pub use btree_map::BTreeMap;
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(no_inline)]
pub use btree_set::BTreeSet;
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(no_inline)]
pub use linked_list::LinkedList;
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(no_inline)]
pub use vec_deque::VecDeque;
#[stable(feature = "rust1", since = "1.0.0")]
pub use core::fmt::{LowerHex, Pointer, UpperHex};
+#[cfg(not(no_global_oom_handling))]
use crate::string;
/// The `format` function takes an [`Arguments`] struct and returns the resulting
///
/// [`format_args!`]: core::format_args
/// [`format!`]: crate::format
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn format(args: Arguments<'_>) -> string::String {
let capacity = args.estimated_capacity();
#![feature(cfg_sanitize)]
#![feature(cfg_target_has_atomic)]
#![feature(coerce_unsized)]
-#![feature(const_btree_new)]
+#![cfg_attr(not(no_global_oom_handling), feature(const_btree_new))]
#![cfg_attr(bootstrap, feature(const_fn))]
#![cfg_attr(not(bootstrap), feature(const_fn_trait_bound))]
#![feature(cow_is_borrowed)]
pub mod string;
#[cfg(target_has_atomic = "ptr")]
pub mod sync;
-#[cfg(target_has_atomic = "ptr")]
+#[cfg(all(not(no_global_oom_handling), target_has_atomic = "ptr"))]
pub mod task;
#[cfg(test)]
mod tests;
use core::ptr::{self, NonNull, Unique};
use core::slice;
-use crate::alloc::{handle_alloc_error, Allocator, Global, Layout};
+#[cfg(not(no_global_oom_handling))]
+use crate::alloc::handle_alloc_error;
+use crate::alloc::{Allocator, Global, Layout};
use crate::boxed::Box;
use crate::collections::TryReserveError::{self, *};
#[cfg(test)]
mod tests;
+#[cfg(not(no_global_oom_handling))]
enum AllocInit {
/// The contents of the new memory are uninitialized.
Uninitialized,
/// # Aborts
///
/// Aborts on OOM.
+ #[cfg(not(no_global_oom_handling))]
#[inline]
pub fn with_capacity(capacity: usize) -> Self {
Self::with_capacity_in(capacity, Global)
}
/// Like `with_capacity`, but guarantees the buffer is zeroed.
+ #[cfg(not(no_global_oom_handling))]
#[inline]
pub fn with_capacity_zeroed(capacity: usize) -> Self {
Self::with_capacity_zeroed_in(capacity, Global)
/// Like `with_capacity`, but parameterized over the choice of
/// allocator for the returned `RawVec`.
+ #[cfg(not(no_global_oom_handling))]
#[inline]
pub fn with_capacity_in(capacity: usize, alloc: A) -> Self {
Self::allocate_in(capacity, AllocInit::Uninitialized, alloc)
/// Like `with_capacity_zeroed`, but parameterized over the choice
/// of allocator for the returned `RawVec`.
+ #[cfg(not(no_global_oom_handling))]
#[inline]
pub fn with_capacity_zeroed_in(capacity: usize, alloc: A) -> Self {
Self::allocate_in(capacity, AllocInit::Zeroed, alloc)
}
}
+ #[cfg(not(no_global_oom_handling))]
fn allocate_in(capacity: usize, init: AllocInit, alloc: A) -> Self {
if mem::size_of::<T>() == 0 {
Self::new_in(alloc)
/// # vector.push_all(&[1, 3, 5, 7, 9]);
/// # }
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
pub fn reserve(&mut self, len: usize, additional: usize) {
// Callers expect this function to be very cheap when there is already sufficient capacity.
/// # Aborts
///
/// Aborts on OOM.
+ #[cfg(not(no_global_oom_handling))]
pub fn reserve_exact(&mut self, len: usize, additional: usize) {
handle_reserve(self.try_reserve_exact(len, additional));
}
/// # Aborts
///
/// Aborts on OOM.
+ #[cfg(not(no_global_oom_handling))]
pub fn shrink_to_fit(&mut self, amount: usize) {
handle_reserve(self.shrink(amount));
}
Ok(())
}
+ #[cfg(not(no_global_oom_handling))]
fn shrink(&mut self, amount: usize) -> Result<(), TryReserveError> {
assert!(amount <= self.capacity(), "Tried to shrink to a larger capacity");
}
// Central function for reserve error handling.
+#[cfg(not(no_global_oom_handling))]
#[inline]
fn handle_reserve(result: Result<(), TryReserveError>) {
match result {
// One central function responsible for reporting capacity overflows. This'll
// ensure that the code generation related to these panics is minimal as there's
// only one location which panics rather than a bunch throughout the module.
+#[cfg(not(no_global_oom_handling))]
fn capacity_overflow() -> ! {
panic!("capacity overflow");
}
use core::fmt;
use core::hash::{Hash, Hasher};
use core::intrinsics::abort;
+#[cfg(not(no_global_oom_handling))]
use core::iter;
use core::marker::{self, PhantomData, Unpin, Unsize};
-use core::mem::{self, align_of_val_raw, forget, size_of_val};
+#[cfg(not(no_global_oom_handling))]
+use core::mem::size_of_val;
+use core::mem::{self, align_of_val_raw, forget};
use core::ops::{CoerceUnsized, Deref, DispatchFromDyn, Receiver};
use core::pin::Pin;
use core::ptr::{self, NonNull};
+#[cfg(not(no_global_oom_handling))]
use core::slice::from_raw_parts_mut;
-use crate::alloc::{
- box_free, handle_alloc_error, AllocError, Allocator, Global, Layout, WriteCloneIntoRaw,
-};
+#[cfg(not(no_global_oom_handling))]
+use crate::alloc::handle_alloc_error;
+#[cfg(not(no_global_oom_handling))]
+use crate::alloc::{box_free, WriteCloneIntoRaw};
+use crate::alloc::{AllocError, Allocator, Global, Layout};
use crate::borrow::{Cow, ToOwned};
+#[cfg(not(no_global_oom_handling))]
use crate::string::String;
+#[cfg(not(no_global_oom_handling))]
use crate::vec::Vec;
#[cfg(test)]
///
/// assert_eq!(*five, 5)
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_uninit() -> Rc<mem::MaybeUninit<T>> {
unsafe {
/// ```
///
/// [zeroed]: mem::MaybeUninit::zeroed
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_zeroed() -> Rc<mem::MaybeUninit<T>> {
unsafe {
///
/// assert_eq!(*values, [1, 2, 3])
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_uninit_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
unsafe { Rc::from_ptr(Rc::allocate_for_slice(len)) }
/// ```
///
/// [zeroed]: mem::MaybeUninit::zeroed
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_zeroed_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
unsafe {
/// assert!(76 == *data);
/// assert!(weak.upgrade().is_none());
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[stable(feature = "rc_unique", since = "1.4.0")]
pub fn make_mut(this: &mut Self) -> &mut T {
///
/// The function `mem_to_rcbox` is called with the data pointer
/// and must return back a (potentially fat)-pointer for the `RcBox<T>`.
+ #[cfg(not(no_global_oom_handling))]
unsafe fn allocate_for_layout(
value_layout: Layout,
allocate: impl FnOnce(Layout) -> Result<NonNull<[u8]>, AllocError>,
}
/// Allocates an `RcBox<T>` with sufficient space for an unsized inner value
+ #[cfg(not(no_global_oom_handling))]
unsafe fn allocate_for_ptr(ptr: *const T) -> *mut RcBox<T> {
// Allocate for the `RcBox<T>` using the given value.
unsafe {
}
}
+ #[cfg(not(no_global_oom_handling))]
fn from_box(v: Box<T>) -> Rc<T> {
unsafe {
let (box_unique, alloc) = Box::into_unique(v);
impl<T> Rc<[T]> {
/// Allocates an `RcBox<[T]>` with the given length.
+ #[cfg(not(no_global_oom_handling))]
unsafe fn allocate_for_slice(len: usize) -> *mut RcBox<[T]> {
unsafe {
Self::allocate_for_layout(
/// Copy elements from slice into newly allocated Rc<\[T\]>
///
/// Unsafe because the caller must either take ownership or bind `T: Copy`
+ #[cfg(not(no_global_oom_handling))]
unsafe fn copy_from_slice(v: &[T]) -> Rc<[T]> {
unsafe {
let ptr = Self::allocate_for_slice(v.len());
/// Constructs an `Rc<[T]>` from an iterator known to be of a certain size.
///
/// Behavior is undefined should the size be wrong.
+ #[cfg(not(no_global_oom_handling))]
unsafe fn from_iter_exact(iter: impl iter::Iterator<Item = T>, len: usize) -> Rc<[T]> {
// Panic guard while cloning T elements.
// In the event of a panic, elements that have been written
fn from_slice(slice: &[T]) -> Self;
}
+#[cfg(not(no_global_oom_handling))]
impl<T: Clone> RcFromSlice<T> for Rc<[T]> {
#[inline]
default fn from_slice(v: &[T]) -> Self {
}
}
+#[cfg(not(no_global_oom_handling))]
impl<T: Copy> RcFromSlice<T> for Rc<[T]> {
#[inline]
fn from_slice(v: &[T]) -> Self {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "shared_from_slice", since = "1.21.0")]
impl<T: Clone> From<&[T]> for Rc<[T]> {
/// Allocate a reference-counted slice and fill it by cloning `v`'s items.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "shared_from_slice", since = "1.21.0")]
impl From<&str> for Rc<str> {
/// Allocate a reference-counted string slice and copy `v` into it.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "shared_from_slice", since = "1.21.0")]
impl From<String> for Rc<str> {
/// Allocate a reference-counted string slice and copy `v` into it.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "shared_from_slice", since = "1.21.0")]
impl<T: ?Sized> From<Box<T>> for Rc<T> {
/// Move a boxed object to a new, reference counted, allocation.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "shared_from_slice", since = "1.21.0")]
impl<T> From<Vec<T>> for Rc<[T]> {
/// Allocate a reference-counted slice and move `v`'s items into it.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "shared_from_iter", since = "1.37.0")]
impl<T> iter::FromIterator<T> for Rc<[T]> {
/// Takes each element in the `Iterator` and collects it into an `Rc<[T]>`.
}
/// Specialization trait used for collecting into `Rc<[T]>`.
+#[cfg(not(no_global_oom_handling))]
trait ToRcSlice<T>: Iterator<Item = T> + Sized {
fn to_rc_slice(self) -> Rc<[T]>;
}
+#[cfg(not(no_global_oom_handling))]
impl<T, I: Iterator<Item = T>> ToRcSlice<T> for I {
default fn to_rc_slice(self) -> Rc<[T]> {
self.collect::<Vec<T>>().into()
}
}
+#[cfg(not(no_global_oom_handling))]
impl<T, I: iter::TrustedLen<Item = T>> ToRcSlice<T> for I {
fn to_rc_slice(self) -> Rc<[T]> {
// This is the case for a `TrustedLen` iterator.
#![cfg_attr(test, allow(unused_imports, dead_code))]
use core::borrow::{Borrow, BorrowMut};
+#[cfg(not(no_global_oom_handling))]
use core::cmp::Ordering::{self, Less};
-use core::mem::{self, size_of};
+#[cfg(not(no_global_oom_handling))]
+use core::mem;
+#[cfg(not(no_global_oom_handling))]
+use core::mem::size_of;
+#[cfg(not(no_global_oom_handling))]
use core::ptr;
-use crate::alloc::{Allocator, Global};
+use crate::alloc::Allocator;
+#[cfg(not(no_global_oom_handling))]
+use crate::alloc::Global;
+#[cfg(not(no_global_oom_handling))]
use crate::borrow::ToOwned;
use crate::boxed::Box;
use crate::vec::Vec;
}
}
+ #[cfg(not(no_global_oom_handling))]
#[inline]
pub fn to_vec<T: ConvertVec, A: Allocator>(s: &[T], alloc: A) -> Vec<T, A> {
T::to_vec(s, alloc)
}
+ #[cfg(not(no_global_oom_handling))]
pub trait ConvertVec {
fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A>
where
Self: Sized;
}
+ #[cfg(not(no_global_oom_handling))]
impl<T: Clone> ConvertVec for T {
#[inline]
default fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A> {
}
}
+ #[cfg(not(no_global_oom_handling))]
impl<T: Copy> ConvertVec for T {
#[inline]
fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A> {
/// v.sort();
/// assert!(v == [-5, -3, 1, 2, 4]);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn sort(&mut self)
/// v.sort_by(|a, b| b.cmp(a));
/// assert!(v == [5, 4, 3, 2, 1]);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn sort_by<F>(&mut self, mut compare: F)
/// v.sort_by_key(|k| k.abs());
/// assert!(v == [1, 2, -3, 4, -5]);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "slice_sort_by_key", since = "1.7.0")]
#[inline]
pub fn sort_by_key<K, F>(&mut self, mut f: F)
/// ```
///
/// [pdqsort]: https://github.com/orlp/pdqsort
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "slice_sort_by_cached_key", since = "1.34.0")]
#[inline]
pub fn sort_by_cached_key<K, F>(&mut self, f: F)
/// let x = s.to_vec();
/// // Here, `s` and `x` can be modified independently.
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[rustc_conversion_suggestion]
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
/// let x = s.to_vec_in(System);
/// // Here, `s` and `x` can be modified independently.
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[unstable(feature = "allocator_api", issue = "32838")]
pub fn to_vec_in<A: Allocator>(&self, alloc: A) -> Vec<T, A>
/// // this will panic at runtime
/// b"0123456789abcdef".repeat(usize::MAX);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "repeat_generic_slice", since = "1.40.0")]
pub fn repeat(&self, n: usize) -> Vec<T>
where
/// To uppercase the value in-place, use [`make_ascii_uppercase`].
///
/// [`make_ascii_uppercase`]: slice::make_ascii_uppercase
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")]
#[inline]
pub fn to_ascii_uppercase(&self) -> Vec<u8> {
/// To lowercase the value in-place, use [`make_ascii_lowercase`].
///
/// [`make_ascii_lowercase`]: slice::make_ascii_lowercase
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")]
#[inline]
pub fn to_ascii_lowercase(&self) -> Vec<u8> {
fn join(slice: &Self, sep: Separator) -> Self::Output;
}
+#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "slice_concat_ext", issue = "27747")]
impl<T: Clone, V: Borrow<[T]>> Concat<T> for [V] {
type Output = Vec<T>;
}
}
+#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "slice_concat_ext", issue = "27747")]
impl<T: Clone, V: Borrow<[T]>> Join<&T> for [V] {
type Output = Vec<T>;
}
}
+#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "slice_concat_ext", issue = "27747")]
impl<T: Clone, V: Borrow<[T]>> Join<&[T]> for [V] {
type Output = Vec<T>;
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Clone> ToOwned for [T] {
type Owned = Vec<T>;
/// Inserts `v[0]` into pre-sorted sequence `v[1..]` so that whole `v[..]` becomes sorted.
///
/// This is the integral subroutine of insertion sort.
+#[cfg(not(no_global_oom_handling))]
fn insert_head<T, F>(v: &mut [T], is_less: &mut F)
where
F: FnMut(&T, &T) -> bool,
///
/// The two slices must be non-empty and `mid` must be in bounds. Buffer `buf` must be long enough
/// to hold a copy of the shorter slice. Also, `T` must not be a zero-sized type.
+#[cfg(not(no_global_oom_handling))]
unsafe fn merge<T, F>(v: &mut [T], mid: usize, buf: *mut T, is_less: &mut F)
where
F: FnMut(&T, &T) -> bool,
/// 2. for every `i` in `2..runs.len()`: `runs[i - 2].len > runs[i - 1].len + runs[i].len`
///
/// The invariants ensure that the total running time is *O*(*n* \* log(*n*)) worst-case.
+#[cfg(not(no_global_oom_handling))]
fn merge_sort<T, F>(v: &mut [T], mut is_less: F)
where
F: FnMut(&T, &T) -> bool,
/// Note: `str` in `Concat<str>` is not meaningful here.
/// This type parameter of the trait only exists to enable another impl.
+#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "slice_concat_ext", issue = "27747")]
impl<S: Borrow<str>> Concat<str> for [S] {
type Output = String;
}
}
+#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "slice_concat_ext", issue = "27747")]
impl<S: Borrow<str>> Join<&str> for [S] {
type Output = String;
}
}
+#[cfg(not(no_global_oom_handling))]
macro_rules! specialize_for_lengths {
($separator:expr, $target:expr, $iter:expr; $($num:expr),*) => {{
let mut target = $target;
}}
}
+#[cfg(not(no_global_oom_handling))]
macro_rules! copy_slice_and_advance {
($target:expr, $bytes:expr) => {
let len = $bytes.len();
// the bounds for String-join are S: Borrow<str> and for Vec-join Borrow<[T]>
// [T] and str both impl AsRef<[T]> for some T
// => s.borrow().as_ref() and we always have slices
+#[cfg(not(no_global_oom_handling))]
fn join_generic_copy<B, T, S>(slice: &[S], sep: &[T]) -> Vec<T>
where
T: Copy,
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl ToOwned for str {
type Owned = String;
/// let s = "this is old";
/// assert_eq!(s, s.replace("cookie monster", "little lamb"));
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[must_use = "this returns the replaced string as a new allocation, \
without modifying the original"]
#[stable(feature = "rust1", since = "1.0.0")]
/// let s = "this is old";
/// assert_eq!(s, s.replacen("cookie monster", "little lamb", 10));
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[must_use = "this returns the replaced string as a new allocation, \
without modifying the original"]
#[stable(feature = "str_replacen", since = "1.16.0")]
///
/// assert_eq!(new_year, new_year.to_lowercase());
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "unicode_case_mapping", since = "1.2.0")]
pub fn to_lowercase(&self) -> String {
let mut s = String::with_capacity(self.len());
///
/// assert_eq!("TSCHÜSS", s.to_uppercase());
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "unicode_case_mapping", since = "1.2.0")]
pub fn to_uppercase(&self) -> String {
let mut s = String::with_capacity(self.len());
/// // this will panic at runtime
/// "0123456789abcdef".repeat(usize::MAX);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "repeat_str", since = "1.16.0")]
pub fn repeat(&self, n: usize) -> String {
unsafe { String::from_utf8_unchecked(self.as_bytes().repeat(n)) }
///
/// [`make_ascii_uppercase`]: str::make_ascii_uppercase
/// [`to_uppercase`]: #method.to_uppercase
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")]
#[inline]
pub fn to_ascii_uppercase(&self) -> String {
///
/// [`make_ascii_lowercase`]: str::make_ascii_lowercase
/// [`to_lowercase`]: #method.to_lowercase
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")]
#[inline]
pub fn to_ascii_lowercase(&self) -> String {
#![stable(feature = "rust1", since = "1.0.0")]
+#[cfg(not(no_global_oom_handling))]
use core::char::{decode_utf16, REPLACEMENT_CHARACTER};
use core::fmt;
use core::hash;
-use core::iter::{FromIterator, FusedIterator};
+#[cfg(not(no_global_oom_handling))]
+use core::iter::FromIterator;
+use core::iter::FusedIterator;
+#[cfg(not(no_global_oom_handling))]
+use core::ops::Add;
+#[cfg(not(no_global_oom_handling))]
+use core::ops::AddAssign;
+#[cfg(not(no_global_oom_handling))]
use core::ops::Bound::{Excluded, Included, Unbounded};
-use core::ops::{self, Add, AddAssign, Index, IndexMut, Range, RangeBounds};
+use core::ops::{self, Index, IndexMut, Range, RangeBounds};
use core::ptr;
use core::slice;
-use core::str::{lossy, pattern::Pattern};
+#[cfg(not(no_global_oom_handling))]
+use core::str::lossy;
+use core::str::pattern::Pattern;
+#[cfg(not(no_global_oom_handling))]
use crate::borrow::{Cow, ToOwned};
use crate::boxed::Box;
use crate::collections::TryReserveError;
-use crate::str::{self, from_boxed_utf8_unchecked, Chars, FromStr, Utf8Error};
+use crate::str::{self, Chars, Utf8Error};
+#[cfg(not(no_global_oom_handling))]
+use crate::str::{from_boxed_utf8_unchecked, FromStr};
use crate::vec::Vec;
/// A UTF-8–encoded, growable string.
/// assert_eq!(vec![0, 159], value.unwrap_err().into_bytes());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(not(no_global_oom_handling), derive(Clone))]
+#[derive(Debug, PartialEq, Eq)]
pub struct FromUtf8Error {
bytes: Vec<u8>,
error: Utf8Error,
/// // ...but this may make the string reallocate
/// s.push('a');
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[doc(alias = "alloc")]
#[doc(alias = "malloc")]
///
/// assert_eq!("Hello �World", output);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str> {
let mut iter = lossy::Utf8Lossy::from_bytes(v).chunks();
/// 0xD800, 0x0069, 0x0063];
/// assert!(String::from_utf16(v).is_err());
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error> {
// This isn't done via collect::<Result<_, _>>() for performance reasons.
/// assert_eq!(String::from("𝄞mus\u{FFFD}ic\u{FFFD}"),
/// String::from_utf16_lossy(v));
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn from_utf16_lossy(v: &[u16]) -> String {
///
/// assert_eq!("foobar", s);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn push_str(&mut self, string: &str) {
/// // ... doesn't actually increase.
/// assert_eq!(10, s.capacity());
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn reserve(&mut self, additional: usize) {
/// // ... doesn't actually increase.
/// assert_eq!(10, s.capacity());
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn reserve_exact(&mut self, additional: usize) {
/// s.shrink_to_fit();
/// assert_eq!(3, s.capacity());
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn shrink_to_fit(&mut self) {
/// s.shrink_to(0);
/// assert!(s.capacity() >= 3);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[unstable(feature = "shrink_to", reason = "new API", issue = "56431")]
pub fn shrink_to(&mut self, min_capacity: usize) {
///
/// assert_eq!("abc123", s);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn push(&mut self, ch: char) {
/// s.remove_matches("ana");
/// assert_eq!("bna", s);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "string_remove_matches", reason = "new API", issue = "72826")]
pub fn remove_matches<'a, P>(&'a mut self, pat: P)
where
///
/// assert_eq!("foo", s);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn insert(&mut self, idx: usize, ch: char) {
}
}
+ #[cfg(not(no_global_oom_handling))]
unsafe fn insert_bytes(&mut self, idx: usize, bytes: &[u8]) {
let len = self.len();
let amt = bytes.len();
///
/// assert_eq!("foobar", s);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[stable(feature = "insert_str", since = "1.16.0")]
pub fn insert_str(&mut self, idx: usize, string: &str) {
/// assert_eq!(world, "World!");
/// # }
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[stable(feature = "string_split_off", since = "1.16.0")]
#[must_use = "use `.truncate()` if you don't need the other half"]
/// s.replace_range(..beta_offset, "Α is capital alpha; ");
/// assert_eq!(s, "Α is capital alpha; β is beta");
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "splice", since = "1.27.0")]
pub fn replace_range<R>(&mut self, range: R, replace_with: &str)
where
///
/// let b = s.into_boxed_str();
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "box_str", since = "1.4.0")]
#[inline]
pub fn into_boxed_str(self) -> Box<str> {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl Clone for String {
fn clone(&self) -> Self {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl FromIterator<char> for String {
fn from_iter<I: IntoIterator<Item = char>>(iter: I) -> String {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "string_from_iter_by_ref", since = "1.17.0")]
impl<'a> FromIterator<&'a char> for String {
fn from_iter<I: IntoIterator<Item = &'a char>>(iter: I) -> String {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> FromIterator<&'a str> for String {
fn from_iter<I: IntoIterator<Item = &'a str>>(iter: I) -> String {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "extend_string", since = "1.4.0")]
impl FromIterator<String> for String {
fn from_iter<I: IntoIterator<Item = String>>(iter: I) -> String {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "box_str2", since = "1.45.0")]
impl FromIterator<Box<str>> for String {
fn from_iter<I: IntoIterator<Item = Box<str>>>(iter: I) -> String {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "herd_cows", since = "1.19.0")]
impl<'a> FromIterator<Cow<'a, str>> for String {
fn from_iter<I: IntoIterator<Item = Cow<'a, str>>>(iter: I) -> String {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl Extend<char> for String {
fn extend<I: IntoIterator<Item = char>>(&mut self, iter: I) {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "extend_ref", since = "1.2.0")]
impl<'a> Extend<&'a char> for String {
fn extend<I: IntoIterator<Item = &'a char>>(&mut self, iter: I) {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Extend<&'a str> for String {
fn extend<I: IntoIterator<Item = &'a str>>(&mut self, iter: I) {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "box_str2", since = "1.45.0")]
impl Extend<Box<str>> for String {
fn extend<I: IntoIterator<Item = Box<str>>>(&mut self, iter: I) {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "extend_string", since = "1.4.0")]
impl Extend<String> for String {
fn extend<I: IntoIterator<Item = String>>(&mut self, iter: I) {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "herd_cows", since = "1.19.0")]
impl<'a> Extend<Cow<'a, str>> for String {
fn extend<I: IntoIterator<Item = Cow<'a, str>>>(&mut self, iter: I) {
impl_eq! { String, str }
impl_eq! { String, &'a str }
+#[cfg(not(no_global_oom_handling))]
impl_eq! { Cow<'a, str>, str }
+#[cfg(not(no_global_oom_handling))]
impl_eq! { Cow<'a, str>, &'b str }
+#[cfg(not(no_global_oom_handling))]
impl_eq! { Cow<'a, str>, String }
#[stable(feature = "rust1", since = "1.0.0")]
/// let b = " world";
/// let c = a.to_string() + b;
/// ```
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl Add<&str> for String {
type Output = String;
/// Implements the `+=` operator for appending to a `String`.
///
/// This has the same behavior as the [`push_str`][String::push_str] method.
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "stringaddassign", since = "1.12.0")]
impl AddAssign<&str> for String {
#[inline]
#[stable(feature = "str_parse_error", since = "1.5.0")]
pub type ParseError = core::convert::Infallible;
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl FromStr for String {
type Err = core::convert::Infallible;
/// if the `Display` implementation returns an error.
/// This indicates an incorrect `Display` implementation
/// since `fmt::Write for String` never returns an error itself.
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: fmt::Display + ?Sized> ToString for T {
// A common guideline is to not inline generic functions. However,
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "char_to_string_specialization", since = "1.46.0")]
impl ToString for char {
#[inline]
}
}
+#[cfg(not(no_global_oom_handling))]
+#[stable(feature = "u8_to_string_specialization", since = "1.54.0")]
+impl ToString for u8 {
+ #[inline]
+ fn to_string(&self) -> String {
+ let mut buf = String::with_capacity(3);
+ let mut n = *self;
+ if n >= 10 {
+ if n >= 100 {
+ buf.push((b'0' + n / 100) as char);
+ n %= 100;
+ }
+ buf.push((b'0' + n / 10) as char);
+ n %= 10;
+ }
+ buf.push((b'0' + n) as char);
+ buf
+ }
+}
+
+#[cfg(not(no_global_oom_handling))]
+#[stable(feature = "i8_to_string_specialization", since = "1.54.0")]
+impl ToString for i8 {
+ #[inline]
+ fn to_string(&self) -> String {
+ let mut buf = String::with_capacity(4);
+ if self.is_negative() {
+ buf.push('-');
+ }
+ let mut n = self.unsigned_abs();
+ if n >= 10 {
+ if n >= 100 {
+ buf.push('1');
+ n -= 100;
+ }
+ buf.push((b'0' + n / 10) as char);
+ n %= 10;
+ }
+ buf.push((b'0' + n) as char);
+ buf
+ }
+}
+
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "str_to_string_specialization", since = "1.9.0")]
impl ToString for str {
#[inline]
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_str_to_string_specialization", since = "1.17.0")]
impl ToString for Cow<'_, str> {
#[inline]
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "string_to_string_specialization", since = "1.17.0")]
impl ToString for String {
#[inline]
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl From<&str> for String {
#[inline]
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "from_mut_str_for_string", since = "1.44.0")]
impl From<&mut str> for String {
/// Converts a `&mut str` into a `String`.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "from_ref_string", since = "1.35.0")]
impl From<&String> for String {
#[inline]
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "box_from_str", since = "1.20.0")]
impl From<String> for Box<str> {
/// Converts the given `String` to a boxed `str` slice that is owned.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "string_from_cow_str", since = "1.14.0")]
impl<'a> From<Cow<'a, str>> for String {
fn from(s: Cow<'a, str>) -> String {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> From<&'a str> for Cow<'a, str> {
/// Converts a string slice into a Borrowed variant.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> From<String> for Cow<'a, str> {
/// Converts a String into an Owned variant.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_from_string_ref", since = "1.28.0")]
impl<'a> From<&'a String> for Cow<'a, str> {
/// Converts a String reference into a Borrowed variant.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_str_from_iter", since = "1.12.0")]
impl<'a> FromIterator<char> for Cow<'a, str> {
fn from_iter<I: IntoIterator<Item = char>>(it: I) -> Cow<'a, str> {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_str_from_iter", since = "1.12.0")]
impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str> {
fn from_iter<I: IntoIterator<Item = &'b str>>(it: I) -> Cow<'a, str> {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_str_from_iter", since = "1.12.0")]
impl<'a> FromIterator<String> for Cow<'a, str> {
fn from_iter<I: IntoIterator<Item = String>>(it: I) -> Cow<'a, str> {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl fmt::Write for String {
#[inline]
#[stable(feature = "fused", since = "1.26.0")]
impl FusedIterator for Drain<'_> {}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "from_char_for_string", since = "1.46.0")]
impl From<char> for String {
#[inline]
use core::hash::{Hash, Hasher};
use core::hint;
use core::intrinsics::abort;
+#[cfg(not(no_global_oom_handling))]
use core::iter;
use core::marker::{PhantomData, Unpin, Unsize};
-use core::mem::{self, align_of_val_raw, size_of_val};
+#[cfg(not(no_global_oom_handling))]
+use core::mem::size_of_val;
+use core::mem::{self, align_of_val_raw};
use core::ops::{CoerceUnsized, Deref, DispatchFromDyn, Receiver};
use core::pin::Pin;
use core::ptr::{self, NonNull};
+#[cfg(not(no_global_oom_handling))]
use core::slice::from_raw_parts_mut;
use core::sync::atomic;
use core::sync::atomic::Ordering::{Acquire, Relaxed, Release, SeqCst};
-use crate::alloc::{
- box_free, handle_alloc_error, AllocError, Allocator, Global, Layout, WriteCloneIntoRaw,
-};
+#[cfg(not(no_global_oom_handling))]
+use crate::alloc::handle_alloc_error;
+#[cfg(not(no_global_oom_handling))]
+use crate::alloc::{box_free, WriteCloneIntoRaw};
+use crate::alloc::{AllocError, Allocator, Global, Layout};
use crate::borrow::{Cow, ToOwned};
use crate::boxed::Box;
use crate::rc::is_dangling;
+#[cfg(not(no_global_oom_handling))]
use crate::string::String;
+#[cfg(not(no_global_oom_handling))]
use crate::vec::Vec;
#[cfg(test)]
///
/// assert_eq!(*five, 5)
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_uninit() -> Arc<mem::MaybeUninit<T>> {
unsafe {
/// ```
///
/// [zeroed]: ../../std/mem/union.MaybeUninit.html#method.zeroed
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_zeroed() -> Arc<mem::MaybeUninit<T>> {
unsafe {
///
/// assert_eq!(*values, [1, 2, 3])
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_uninit_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
unsafe { Arc::from_ptr(Arc::allocate_for_slice(len)) }
/// ```
///
/// [zeroed]: ../../std/mem/union.MaybeUninit.html#method.zeroed
+ #[cfg(not(no_global_oom_handling))]
#[unstable(feature = "new_uninit", issue = "63291")]
pub fn new_zeroed_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
unsafe {
///
/// The function `mem_to_arcinner` is called with the data pointer
/// and must return back a (potentially fat)-pointer for the `ArcInner<T>`.
+ #[cfg(not(no_global_oom_handling))]
unsafe fn allocate_for_layout(
value_layout: Layout,
allocate: impl FnOnce(Layout) -> Result<NonNull<[u8]>, AllocError>,
}
/// Allocates an `ArcInner<T>` with sufficient space for an unsized inner value.
+ #[cfg(not(no_global_oom_handling))]
unsafe fn allocate_for_ptr(ptr: *const T) -> *mut ArcInner<T> {
// Allocate for the `ArcInner<T>` using the given value.
unsafe {
}
}
+ #[cfg(not(no_global_oom_handling))]
fn from_box(v: Box<T>) -> Arc<T> {
unsafe {
let (box_unique, alloc) = Box::into_unique(v);
impl<T> Arc<[T]> {
/// Allocates an `ArcInner<[T]>` with the given length.
+ #[cfg(not(no_global_oom_handling))]
unsafe fn allocate_for_slice(len: usize) -> *mut ArcInner<[T]> {
unsafe {
Self::allocate_for_layout(
/// Copy elements from slice into newly allocated Arc<\[T\]>
///
/// Unsafe because the caller must either take ownership or bind `T: Copy`.
+ #[cfg(not(no_global_oom_handling))]
unsafe fn copy_from_slice(v: &[T]) -> Arc<[T]> {
unsafe {
let ptr = Self::allocate_for_slice(v.len());
/// Constructs an `Arc<[T]>` from an iterator known to be of a certain size.
///
/// Behavior is undefined should the size be wrong.
+ #[cfg(not(no_global_oom_handling))]
unsafe fn from_iter_exact(iter: impl iter::Iterator<Item = T>, len: usize) -> Arc<[T]> {
// Panic guard while cloning T elements.
// In the event of a panic, elements that have been written
}
/// Specialization trait used for `From<&[T]>`.
+#[cfg(not(no_global_oom_handling))]
trait ArcFromSlice<T> {
fn from_slice(slice: &[T]) -> Self;
}
+#[cfg(not(no_global_oom_handling))]
impl<T: Clone> ArcFromSlice<T> for Arc<[T]> {
#[inline]
default fn from_slice(v: &[T]) -> Self {
}
}
+#[cfg(not(no_global_oom_handling))]
impl<T: Copy> ArcFromSlice<T> for Arc<[T]> {
#[inline]
fn from_slice(v: &[T]) -> Self {
/// assert_eq!(*data, 8);
/// assert_eq!(*other_data, 12);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[stable(feature = "arc_unique", since = "1.4.0")]
pub fn make_mut(this: &mut Self) -> &mut T {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "shared_from_slice", since = "1.21.0")]
impl<T: Clone> From<&[T]> for Arc<[T]> {
/// Allocate a reference-counted slice and fill it by cloning `v`'s items.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "shared_from_slice", since = "1.21.0")]
impl From<&str> for Arc<str> {
/// Allocate a reference-counted `str` and copy `v` into it.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "shared_from_slice", since = "1.21.0")]
impl From<String> for Arc<str> {
/// Allocate a reference-counted `str` and copy `v` into it.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "shared_from_slice", since = "1.21.0")]
impl<T: ?Sized> From<Box<T>> for Arc<T> {
/// Move a boxed object to a new, reference-counted allocation.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "shared_from_slice", since = "1.21.0")]
impl<T> From<Vec<T>> for Arc<[T]> {
/// Allocate a reference-counted slice and move `v`'s items into it.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "shared_from_iter", since = "1.37.0")]
impl<T> iter::FromIterator<T> for Arc<[T]> {
/// Takes each element in the `Iterator` and collects it into an `Arc<[T]>`.
fn to_arc_slice(self) -> Arc<[T]>;
}
+#[cfg(not(no_global_oom_handling))]
impl<T, I: Iterator<Item = T>> ToArcSlice<T> for I {
default fn to_arc_slice(self) -> Arc<[T]> {
self.collect::<Vec<T>>().into()
}
}
+#[cfg(not(no_global_oom_handling))]
impl<T, I: iter::TrustedLen<Item = T>> ToArcSlice<T> for I {
fn to_arc_slice(self) -> Arc<[T]> {
// This is the case for a `TrustedLen` iterator.
/// (&mut into_iter).for_each(core::mem::drop);
/// unsafe { core::ptr::write(&mut into_iter, Vec::new().into_iter()); }
/// ```
+ #[cfg(not(no_global_oom_handling))]
pub(super) fn forget_allocation_drop_remaining(&mut self) {
let remaining = self.as_raw_mut_slice();
const MAY_HAVE_SIDE_EFFECT: bool = false;
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "vec_into_iter_clone", since = "1.8.0")]
impl<T: Clone, A: Allocator + Clone> Clone for IntoIter<T, A> {
#[cfg(not(test))]
#![stable(feature = "rust1", since = "1.0.0")]
-use core::cmp::{self, Ordering};
+#[cfg(not(no_global_oom_handling))]
+use core::cmp;
+use core::cmp::Ordering;
use core::convert::TryFrom;
use core::fmt;
use core::hash::{Hash, Hasher};
use core::intrinsics::{arith_offset, assume};
-use core::iter::{self, FromIterator};
+use core::iter;
+#[cfg(not(no_global_oom_handling))]
+use core::iter::FromIterator;
use core::marker::PhantomData;
use core::mem::{self, ManuallyDrop, MaybeUninit};
use core::ops::{self, Index, IndexMut, Range, RangeBounds};
mod drain_filter;
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "vec_splice", since = "1.21.0")]
pub use self::splice::Splice;
+#[cfg(not(no_global_oom_handling))]
mod splice;
#[stable(feature = "drain", since = "1.6.0")]
mod drain;
+#[cfg(not(no_global_oom_handling))]
mod cow;
+#[cfg(not(no_global_oom_handling))]
pub(crate) use self::into_iter::AsIntoIter;
#[stable(feature = "rust1", since = "1.0.0")]
pub use self::into_iter::IntoIter;
mod into_iter;
+#[cfg(not(no_global_oom_handling))]
use self::is_zero::IsZero;
mod is_zero;
+#[cfg(not(no_global_oom_handling))]
mod source_iter_marker;
mod partial_eq;
+#[cfg(not(no_global_oom_handling))]
use self::spec_from_elem::SpecFromElem;
+#[cfg(not(no_global_oom_handling))]
mod spec_from_elem;
+#[cfg(not(no_global_oom_handling))]
use self::set_len_on_drop::SetLenOnDrop;
+#[cfg(not(no_global_oom_handling))]
mod set_len_on_drop;
+#[cfg(not(no_global_oom_handling))]
use self::in_place_drop::InPlaceDrop;
+#[cfg(not(no_global_oom_handling))]
mod in_place_drop;
+#[cfg(not(no_global_oom_handling))]
use self::spec_from_iter_nested::SpecFromIterNested;
+#[cfg(not(no_global_oom_handling))]
mod spec_from_iter_nested;
+#[cfg(not(no_global_oom_handling))]
use self::spec_from_iter::SpecFromIter;
+#[cfg(not(no_global_oom_handling))]
mod spec_from_iter;
+#[cfg(not(no_global_oom_handling))]
use self::spec_extend::SpecExtend;
+#[cfg(not(no_global_oom_handling))]
mod spec_extend;
/// A contiguous growable array type, written as `Vec<T>` and pronounced 'vector'.
/// assert_eq!(vec.len(), 11);
/// assert!(vec.capacity() >= 11);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[doc(alias = "malloc")]
#[stable(feature = "rust1", since = "1.0.0")]
/// assert_eq!(vec.len(), 11);
/// assert!(vec.capacity() >= 11);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[unstable(feature = "allocator_api", issue = "32838")]
pub fn with_capacity_in(capacity: usize, alloc: A) -> Self {
/// vec.reserve(10);
/// assert!(vec.capacity() >= 11);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[doc(alias = "realloc")]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn reserve(&mut self, additional: usize) {
/// vec.reserve_exact(10);
/// assert!(vec.capacity() >= 11);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[doc(alias = "realloc")]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn reserve_exact(&mut self, additional: usize) {
/// vec.shrink_to_fit();
/// assert!(vec.capacity() >= 3);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[doc(alias = "realloc")]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn shrink_to_fit(&mut self) {
/// vec.shrink_to(0);
/// assert!(vec.capacity() >= 3);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[doc(alias = "realloc")]
#[unstable(feature = "shrink_to", reason = "new API", issue = "56431")]
pub fn shrink_to(&mut self, min_capacity: usize) {
/// let slice = vec.into_boxed_slice();
/// assert_eq!(slice.into_vec().capacity(), 3);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn into_boxed_slice(mut self) -> Box<[T], A> {
unsafe {
/// vec.insert(4, 5);
/// assert_eq!(vec, [1, 4, 2, 3, 5]);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn insert(&mut self, index: usize, element: T) {
#[cold]
/// vec.push(3);
/// assert_eq!(vec, [1, 2, 3]);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn push(&mut self, value: T) {
/// assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
/// assert_eq!(vec2, []);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[stable(feature = "append", since = "1.4.0")]
pub fn append(&mut self, other: &mut Self) {
}
/// Appends elements to `Self` from other buffer.
+ #[cfg(not(no_global_oom_handling))]
#[inline]
unsafe fn append_elements(&mut self, other: *const [T]) {
let count = unsafe { (*other).len() };
/// assert_eq!(vec, [1]);
/// assert_eq!(vec2, [2, 3]);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[must_use = "use `.truncate()` if you don't need the other half"]
#[stable(feature = "split_off", since = "1.4.0")]
/// vec.resize_with(4, || { p *= 2; p });
/// assert_eq!(vec, [2, 4, 8, 16]);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "vec_resize_with", since = "1.33.0")]
pub fn resize_with<F>(&mut self, new_len: usize, f: F)
where
/// static_ref[0] += 1;
/// assert_eq!(static_ref, &[2, 2, 3]);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "vec_leak", since = "1.47.0")]
#[inline]
pub fn leak<'a>(self) -> &'a mut [T]
/// vec.resize(2, 0);
/// assert_eq!(vec, [1, 2]);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "vec_resize", since = "1.5.0")]
pub fn resize(&mut self, new_len: usize, value: T) {
let len = self.len();
/// ```
///
/// [`extend`]: Vec::extend
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "vec_extend_from_slice", since = "1.6.0")]
pub fn extend_from_slice(&mut self, other: &[T]) {
self.spec_extend(other.iter())
/// vec.extend_from_within(4..8);
/// assert_eq!(vec, [0, 1, 2, 3, 4, 2, 3, 4, 0, 1, 4, 2, 3, 4]);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[stable(feature = "vec_extend_from_within", since = "1.53.0")]
pub fn extend_from_within<R>(&mut self, src: R)
where
}
impl<T, A: Allocator> Vec<T, A> {
+ #[cfg(not(no_global_oom_handling))]
/// Extend the vector by `n` values, using the given generator.
fn extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) {
self.reserve(n);
////////////////////////////////////////////////////////////////////////////////
#[doc(hidden)]
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn from_elem<T: Clone>(elem: T, n: usize) -> Vec<T> {
<T as SpecFromElem>::from_elem(elem, n, Global)
}
#[doc(hidden)]
+#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "allocator_api", issue = "32838")]
pub fn from_elem_in<T: Clone, A: Allocator>(elem: T, n: usize, alloc: A) -> Vec<T, A> {
<T as SpecFromElem>::from_elem(elem, n, alloc)
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Clone, A: Allocator + Clone> Clone for Vec<T, A> {
#[cfg(not(test))]
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> FromIterator<T> for Vec<T> {
#[inline]
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<T, A: Allocator> Extend<T> for Vec<T, A> {
#[inline]
impl<T, A: Allocator> Vec<T, A> {
// leaf method to which various SpecFrom/SpecExtend implementations delegate when
// they have no further optimizations to apply
+ #[cfg(not(no_global_oom_handling))]
fn extend_desugared<I: Iterator<Item = T>>(&mut self, mut iterator: I) {
// This is the case for a general iterator.
//
/// assert_eq!(v, &[7, 8, 3]);
/// assert_eq!(u, &[1, 2]);
/// ```
+ #[cfg(not(no_global_oom_handling))]
#[inline]
#[stable(feature = "vec_splice", since = "1.21.0")]
pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter, A>
/// append the entire slice at once.
///
/// [`copy_from_slice`]: slice::copy_from_slice
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "extend_ref", since = "1.2.0")]
impl<'a, T: Copy + 'a, A: Allocator + 'a> Extend<&'a T> for Vec<T, A> {
fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Clone> From<&[T]> for Vec<T> {
/// Allocate a `Vec<T>` and fill it by cloning `s`'s items.
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "vec_from_mut", since = "1.19.0")]
impl<T: Clone> From<&mut [T]> for Vec<T> {
/// Allocate a `Vec<T>` and fill it by cloning `s`'s items.
}
// note: test pulls in libstd, which causes errors here
+#[cfg(not(no_global_oom_handling))]
#[cfg(not(test))]
#[stable(feature = "box_from_vec", since = "1.20.0")]
impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A> {
}
}
+#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
impl From<&str> for Vec<u8> {
/// Allocate a `Vec<u8>` and fill it with a UTF-8 string.
use crate::alloc::Allocator;
+#[cfg(not(no_global_oom_handling))]
use crate::borrow::Cow;
use super::Vec;
__impl_slice_eq1! { [A: Allocator] &mut [T], Vec<U, A>, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")] }
__impl_slice_eq1! { [A: Allocator] Vec<T, A>, [U], #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")] }
__impl_slice_eq1! { [A: Allocator] [T], Vec<U, A>, #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")] }
+#[cfg(not(no_global_oom_handling))]
__impl_slice_eq1! { [A: Allocator] Cow<'_, [T]>, Vec<U, A> where T: Clone, #[stable(feature = "rust1", since = "1.0.0")] }
+#[cfg(not(no_global_oom_handling))]
__impl_slice_eq1! { [] Cow<'_, [T]>, &[U] where T: Clone, #[stable(feature = "rust1", since = "1.0.0")] }
+#[cfg(not(no_global_oom_handling))]
__impl_slice_eq1! { [] Cow<'_, [T]>, &mut [U] where T: Clone, #[stable(feature = "rust1", since = "1.0.0")] }
__impl_slice_eq1! { [A: Allocator, const N: usize] Vec<T, A>, [U; N], #[stable(feature = "rust1", since = "1.0.0")] }
__impl_slice_eq1! { [A: Allocator, const N: usize] Vec<T, A>, &[U; N], #[stable(feature = "rust1", since = "1.0.0")] }
//
// This should never be implemented by hand.
#[doc(hidden)]
- #[cfg_attr(not(bootstrap), feature(no_coverage))]
- #[cfg_attr(not(bootstrap), no_coverage)]
+ #[cfg_attr(not(bootstrap), no_coverage)] // rust-lang/rust#84605
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn assert_receiver_is_total_eq(&self) {}
/// Derive macro generating an impl of the trait `Eq`.
#[rustc_builtin_macro]
#[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
-#[allow_internal_unstable(core_intrinsics, derive_eq, structural_match)]
+#[allow_internal_unstable(core_intrinsics, derive_eq, structural_match, no_coverage)]
pub macro Eq($item:item) {
/* compiler built-in */
}
#[cfg(target_arch = "aarch64")]
{
// SAFETY: the `cfg` attr ensures that we only execute this on aarch64 targets.
- unsafe { crate::arch::aarch64::__yield() };
+ unsafe { crate::arch::aarch64::__isb(crate::arch::aarch64::SY) };
}
#[cfg(target_arch = "arm")]
{
/// macro, which panics when it is executed, it is *undefined behavior* to
/// reach code marked with this function.
///
- /// The stabilized version of this intrinsic is [`core::hint::unreachable_unchecked`](crate::hint::unreachable_unchecked).
+ /// The stabilized version of this intrinsic is [`core::hint::unreachable_unchecked`].
#[rustc_const_unstable(feature = "const_unreachable_unchecked", issue = "53188")]
pub fn unreachable() -> !;
/// More specifically, this is the offset in bytes between successive
/// items of the same type, including alignment padding.
///
- /// The stabilized version of this intrinsic is [`core::mem::size_of`](crate::mem::size_of).
+ /// The stabilized version of this intrinsic is [`core::mem::size_of`].
#[rustc_const_stable(feature = "const_size_of", since = "1.40.0")]
pub fn size_of<T>() -> usize;
/// The minimum alignment of a type.
///
- /// The stabilized version of this intrinsic is [`core::mem::align_of`](crate::mem::align_of).
+ /// The stabilized version of this intrinsic is [`core::mem::align_of`].
#[rustc_const_stable(feature = "const_min_align_of", since = "1.40.0")]
pub fn min_align_of<T>() -> usize;
/// The preferred alignment of a type.
pub fn size_of_val<T: ?Sized>(_: *const T) -> usize;
/// The required alignment of the referenced value.
///
- /// The stabilized version of this intrinsic is [`core::mem::align_of_val`](crate::mem::align_of_val).
+ /// The stabilized version of this intrinsic is [`core::mem::align_of_val`].
#[rustc_const_unstable(feature = "const_align_of_val", issue = "46571")]
pub fn min_align_of_val<T: ?Sized>(_: *const T) -> usize;
/// Gets a static string slice containing the name of a type.
///
- /// The stabilized version of this intrinsic is [`core::any::type_name`](crate::any::type_name).
+ /// The stabilized version of this intrinsic is [`core::any::type_name`].
#[rustc_const_unstable(feature = "const_type_name", issue = "63084")]
pub fn type_name<T: ?Sized>() -> &'static str;
/// function will return the same value for a type regardless of whichever
/// crate it is invoked in.
///
- /// The stabilized version of this intrinsic is [`core::any::TypeId::of`](crate::any::TypeId::of).
+ /// The stabilized version of this intrinsic is [`core::any::TypeId::of`].
#[rustc_const_unstable(feature = "const_type_id", issue = "77125")]
pub fn type_id<T: ?Sized + 'static>() -> u64;
/// Gets a reference to a static `Location` indicating where it was called.
///
- /// Consider using [`core::panic::Location::caller`](crate::panic::Location::caller) instead.
+ /// Consider using [`core::panic::Location::caller`] instead.
#[rustc_const_unstable(feature = "const_caller_location", issue = "76156")]
pub fn caller_location() -> &'static crate::panic::Location<'static>;
/// Performs a volatile load from the `src` pointer.
///
- /// The stabilized version of this intrinsic is [`core::ptr::read_volatile`](crate::ptr::read_volatile).
+ /// The stabilized version of this intrinsic is [`core::ptr::read_volatile`].
pub fn volatile_load<T>(src: *const T) -> T;
/// Performs a volatile store to the `dst` pointer.
///
- /// The stabilized version of this intrinsic is [`core::ptr::write_volatile`](crate::ptr::write_volatile).
+ /// The stabilized version of this intrinsic is [`core::ptr::write_volatile`].
pub fn volatile_store<T>(dst: *mut T, val: T);
/// Performs a volatile load from the `src` pointer
/// Returns the value of the discriminant for the variant in 'v';
/// if `T` has no discriminant, returns `0`.
///
- /// The stabilized version of this intrinsic is [`core::mem::discriminant`](crate::mem::discriminant).
+ /// The stabilized version of this intrinsic is [`core::mem::discriminant`].
#[rustc_const_unstable(feature = "const_discriminant", issue = "69821")]
pub fn discriminant_value<T>(v: &T) -> <T as DiscriminantKind>::Discriminant;
/// [violate memory safety][read-ownership].
///
/// Note that even if the effectively copied size (`count * size_of::<T>()`) is
- /// `0`, the pointers must be non-NULL and properly aligned.
+ /// `0`, the pointers must be non-null and properly aligned.
///
/// [`read`]: crate::ptr::read
/// [read-ownership]: crate::ptr::read#ownership-of-the-returned-value
/// [violate memory safety][read-ownership].
///
/// Note that even if the effectively copied size (`count * size_of::<T>()`) is
- /// `0`, the pointers must be non-NULL and properly aligned.
+ /// `0`, the pointers must be non-null and properly aligned.
///
/// [`read`]: crate::ptr::read
/// [read-ownership]: crate::ptr::read#ownership-of-the-returned-value
/// invalid value of `T` is undefined behavior.
///
/// Note that even if the effectively copied size (`count * size_of::<T>()`) is
-/// `0`, the pointer must be non-NULL and properly aligned.
+/// `0`, the pointer must be non-null and properly aligned.
///
/// [valid]: crate::ptr#safety
///
/// ```
///
/// [`reduce()`]: Iterator::reduce
- #[doc(alias = "reduce")]
#[doc(alias = "inject")]
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#![feature(const_caller_location)]
#![feature(slice_ptr_get)]
#![feature(no_niche)] // rust-lang/rust#68303
+#![cfg_attr(not(bootstrap), feature(no_coverage))] // rust-lang/rust#84605
#![feature(int_error_matching)]
#![deny(unsafe_op_in_unsafe_fn)]
+// allow using `core::` in intra-doc links
+#[allow(unused_extern_crates)]
+extern crate self as core;
+
#[prelude_import]
#[allow(unused)]
use prelude::v1::*;
///
/// The compiler, in general, assumes that a variable is properly initialized
/// according to the requirements of the variable's type. For example, a variable of
-/// reference type must be aligned and non-NULL. This is an invariant that must
+/// 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][ub],
/// no matter whether that reference ever gets used to access memory:
// SAFETY:
// * The caller guarantees that all elements of the array are initialized
// * `MaybeUninit<T>` and T are guaranteed to have the same layout
- // * MaybeUnint does not drop, so there are no double-frees
+ // * `MaybeUninit` does not drop, so there are no double-frees
// And thus the conversion is safe
unsafe {
intrinsics::assert_inhabited::<[T; N]>();
pub fn from_small(v: $ty) -> $name {
let mut base = [0; $n];
base[0] = v;
- $name { size: 1, base: base }
+ $name { size: 1, base }
}
/// Makes a bignum from `u64` value.
v >>= <$ty>::BITS;
sz += 1;
}
- $name { size: sz, base: base }
+ $name { size: sz, base }
}
/// Returns the internal digits as a slice `[a, b, c, ...]` such that the numeric
///
/// # Safety
///
- /// When calling this method, you have to ensure that *either* the pointer is NULL *or*
+ /// When calling this method, you have to ensure that *either* the pointer is null *or*
/// all of the following is true:
///
/// * The pointer must be properly aligned.
///
/// # Safety
///
- /// When calling this method, you have to ensure that *either* the pointer is NULL *or*
+ /// When calling this method, you have to ensure that *either* the pointer is null *or*
/// all of the following is true:
///
/// * The pointer must be properly aligned.
///
/// # Safety
///
- /// When calling this method, you have to ensure that *either* the pointer is NULL *or*
+ /// When calling this method, you have to ensure that *either* the pointer is null *or*
/// all of the following is true:
///
/// * The pointer must be [valid] for reads for `ptr.len() * mem::size_of::<T>()` many bytes,
/// again. [`write()`] can be used to overwrite data without causing it to be
/// dropped.
///
-/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.
+/// Note that even if `T` has size `0`, the pointer must be non-null and properly aligned.
///
/// [valid]: self#safety
///
///
/// * Both `x` and `y` must be properly aligned.
///
-/// Note that even if `T` has size `0`, the pointers must be non-NULL and properly aligned.
+/// Note that even if `T` has size `0`, the pointers must be non-null and properly aligned.
///
/// [valid]: self#safety
///
/// beginning at `y` with the same size.
///
/// Note that even if the effectively copied size (`count * size_of::<T>()`) is `0`,
-/// the pointers must be non-NULL and properly aligned.
+/// the pointers must be non-null and properly aligned.
///
/// [valid]: self#safety
///
///
/// * `dst` must point to a properly initialized value of type `T`.
///
-/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.
+/// Note that even if `T` has size `0`, the pointer must be non-null and properly aligned.
///
/// [valid]: self#safety
///
///
/// * `src` must point to a properly initialized value of type `T`.
///
-/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.
+/// Note that even if `T` has size `0`, the pointer must be non-null and properly aligned.
///
/// # Examples
///
/// 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.
+/// Note that even if `T` has size `0`, the pointer must be non-null.
///
/// [read-ownership]: read#ownership-of-the-returned-value
/// [valid]: self#safety
///
/// ## On `packed` structs
///
-/// It is currently impossible to create raw pointers to unaligned fields
-/// of a packed struct.
-///
/// Attempting to create a raw pointer to an `unaligned` struct field with
/// an expression such as `&packed.unaligned as *const FieldType` creates an
/// intermediate unaligned reference before converting that to a raw pointer.
/// As a result, using `&packed.unaligned as *const FieldType` causes immediate
/// *undefined behavior* in your program.
///
+/// Instead you must use the [`ptr::addr_of!`](addr_of) macro to
+/// create the pointer. You may use that returned pointer together with this
+/// function.
+///
/// An example of what not to do and how this relates to `read_unaligned` is:
///
-/// ```no_run
+/// ```
/// #[repr(packed, C)]
/// struct Packed {
/// _padding: u8,
/// unaligned: 0x01020304,
/// };
///
-/// #[allow(unaligned_references)]
-/// let v = unsafe {
-/// // Here we attempt to take the address of a 32-bit integer which is not aligned.
-/// let unaligned =
-/// // A temporary unaligned reference is created here which results in
-/// // undefined behavior regardless of whether the reference is used or not.
-/// &packed.unaligned
-/// // Casting to a raw pointer doesn't help; the mistake already happened.
-/// as *const u32;
+/// // Take the address of a 32-bit integer which is not aligned.
+/// // In contrast to `&packed.unaligned as *const _`, this has no undefined behavior.
+/// let unaligned = std::ptr::addr_of!(packed.unaligned);
///
-/// let v = std::ptr::read_unaligned(unaligned);
-///
-/// v
-/// };
+/// let v = unsafe { std::ptr::read_unaligned(unaligned) };
+/// assert_eq!(v, 0x01020304);
/// ```
///
/// Accessing unaligned fields directly with e.g. `packed.unaligned` is safe however.
-// FIXME: Update docs based on outcome of RFC #2582 and friends.
///
/// # Examples
///
/// * `dst` must be properly aligned. Use [`write_unaligned`] if this is not the
/// case.
///
-/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.
+/// Note that even if `T` has size `0`, the pointer must be non-null and properly aligned.
///
/// [valid]: self#safety
///
///
/// * `dst` must be [valid] for writes.
///
-/// Note that even if `T` has size `0`, the pointer must be non-NULL.
+/// Note that even if `T` has size `0`, the pointer must be non-null.
///
/// [valid]: self#safety
///
/// ## On `packed` structs
///
-/// It is currently impossible to create raw pointers to unaligned fields
-/// of a packed struct.
-///
/// Attempting to create a raw pointer to an `unaligned` struct field with
/// an expression such as `&packed.unaligned as *const FieldType` creates an
/// intermediate unaligned reference before converting that to a raw pointer.
/// As a result, using `&packed.unaligned as *const FieldType` causes immediate
/// *undefined behavior* in your program.
///
-/// An example of what not to do and how this relates to `write_unaligned` is:
+/// Instead you must use the [`ptr::addr_of_mut!`](addr_of_mut)
+/// macro to create the pointer. You may use that returned pointer together with
+/// this function.
+///
+/// An example of how to do it and how this relates to `write_unaligned` is:
///
-/// ```no_run
+/// ```
/// #[repr(packed, C)]
/// struct Packed {
/// _padding: u8,
/// unaligned: u32,
/// }
///
-/// let v = 0x01020304;
/// let mut packed: Packed = unsafe { std::mem::zeroed() };
///
-/// #[allow(unaligned_references)]
-/// let v = unsafe {
-/// // Here we attempt to take the address of a 32-bit integer which is not aligned.
-/// let unaligned =
-/// // A temporary unaligned reference is created here which results in
-/// // undefined behavior regardless of whether the reference is used or not.
-/// &mut packed.unaligned
-/// // Casting to a raw pointer doesn't help; the mistake already happened.
-/// as *mut u32;
+/// // Take the address of a 32-bit integer which is not aligned.
+/// // In contrast to `&packed.unaligned as *mut _`, this has no undefined behavior.
+/// let unaligned = std::ptr::addr_of_mut!(packed.unaligned);
///
-/// std::ptr::write_unaligned(unaligned, v);
+/// unsafe { std::ptr::write_unaligned(unaligned, 42) };
///
-/// v
-/// };
+/// assert_eq!({packed.unaligned}, 42); // `{...}` forces copying the field instead of creating a reference.
/// ```
///
-/// Accessing unaligned fields directly with e.g. `packed.unaligned` is safe however.
-// FIXME: Update docs based on outcome of RFC #2582 and friends.
+/// Accessing unaligned fields directly with e.g. `packed.unaligned` is safe however
+/// (as can be seen in the `assert_eq!` above).
///
/// # Examples
///
/// However, storing non-[`Copy`] types in volatile memory is almost certainly
/// incorrect.
///
-/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.
+/// Note that even if `T` has size `0`, the pointer must be non-null and properly aligned.
///
/// [valid]: self#safety
/// [read-ownership]: read#ownership-of-the-returned-value
///
/// * `dst` must be properly aligned.
///
-/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.
+/// Note that even if `T` has size `0`, the pointer must be non-null and properly aligned.
///
/// [valid]: self#safety
///
///
/// Note, however, that the `expr` in `addr_of!(expr)` is still subject to all
/// the usual rules. In particular, `addr_of!(*ptr::null())` is Undefined
-/// Behavior because it dereferences a NULL pointer.
+/// Behavior because it dereferences a null pointer.
///
/// # Example
///
///
/// Note, however, that the `expr` in `addr_of_mut!(expr)` is still subject to all
/// the usual rules. In particular, `addr_of_mut!(*ptr::null_mut())` is Undefined
-/// Behavior because it dereferences a NULL pointer.
+/// Behavior because it dereferences a null pointer.
///
/// # Examples
///
///
/// # Safety
///
- /// When calling this method, you have to ensure that *either* the pointer is NULL *or*
+ /// When calling this method, you have to ensure that *either* the pointer is null *or*
/// all of the following is true:
///
/// * The pointer must be properly aligned.
///
/// # Safety
///
- /// When calling this method, you have to ensure that *either* the pointer is NULL *or*
+ /// When calling this method, you have to ensure that *either* the pointer is null *or*
/// all of the following is true:
///
/// * The pointer must be properly aligned.
///
/// # Safety
///
- /// When calling this method, you have to ensure that *either* the pointer is NULL *or*
+ /// When calling this method, you have to ensure that *either* the pointer is null *or*
/// all of the following is true:
///
/// * The pointer must be properly aligned.
///
/// # Safety
///
- /// When calling this method, you have to ensure that *either* the pointer is NULL *or*
+ /// When calling this method, you have to ensure that *either* the pointer is null *or*
/// all of the following is true:
///
/// * The pointer must be properly aligned.
///
/// # Safety
///
- /// When calling this method, you have to ensure that *either* the pointer is NULL *or*
+ /// When calling this method, you have to ensure that *either* the pointer is null *or*
/// all of the following is true:
///
/// * The pointer must be [valid] for reads for `ptr.len() * mem::size_of::<T>()` many bytes,
///
/// # Safety
///
- /// When calling this method, you have to ensure that *either* the pointer is NULL *or*
+ /// When calling this method, you have to ensure that *either* the pointer is null *or*
/// all of the following is true:
///
/// * The pointer must be [valid] for reads and writes for `ptr.len() * mem::size_of::<T>()`
I: SliceIndex<[T]>,
{
// SAFETY: the caller ensures that `self` is dereferencable and `index` in-bounds.
- // As a consequence, the resulting pointer cannot be NULL.
+ // As a consequence, the resulting pointer cannot be null.
unsafe { NonNull::new_unchecked(self.as_ptr().get_unchecked_mut(index)) }
}
}
/// assert!(!v.contains(&50));
/// ```
///
- /// If you do not have an `&T`, but just an `&U` such that `T: Borrow<U>`
- /// (e.g. `String: Borrow<str>`), you can use `iter().any`:
+ /// If you do not have a `&T`, but some other value that you can compare
+ /// with one (for example, `String` implements `PartialEq<str>`), you can
+ /// use `iter().any`:
///
/// ```
/// let v = [String::from("hello"), String::from("world")]; // slice of `String`
if let Some(mut secs) = self.secs.checked_sub(rhs.secs) {
let nanos = if self.nanos >= rhs.nanos {
self.nanos - rhs.nanos
+ } else if let Some(sub_secs) = secs.checked_sub(1) {
+ secs = sub_secs;
+ self.nanos + NANOS_PER_SEC - rhs.nanos
} else {
- if let Some(sub_secs) = secs.checked_sub(1) {
- secs = sub_secs;
- self.nanos + NANOS_PER_SEC - rhs.nanos
- } else {
- return None;
- }
+ return None;
};
debug_assert!(nanos < NANOS_PER_SEC);
Some(Duration { secs, nanos })
}
pub unsafe fn cleanup(payload: *mut u8) -> Box<dyn Any + Send> {
- // A NULL payload here means that we got here from the catch (...) of
+ // A null payload here means that we got here from the catch (...) of
// __rust_try. This happens when a non-Rust foreign exception is caught.
if payload.is_null() {
super::__rust_foreign_exception();
#![feature(rustc_allow_const_fn_unstable)]
#![feature(nll)]
#![feature(staged_api)]
-#![feature(const_fn)]
+#![cfg_attr(bootstrap, feature(const_fn))]
+#![cfg_attr(not(bootstrap), feature(const_fn_trait_bound))]
#![feature(const_fn_fn_ptr_basics)]
#![feature(allow_internal_unstable)]
#![feature(decl_macro)]
/// # Examples
///
/// ```
- /// #![feature(map_into_keys_values)]
/// use std::collections::HashMap;
///
/// let mut map = HashMap::new();
/// let vec: Vec<&str> = map.into_keys().collect();
/// ```
#[inline]
- #[unstable(feature = "map_into_keys_values", issue = "75294")]
+ #[stable(feature = "map_into_keys_values", since = "1.54.0")]
pub fn into_keys(self) -> IntoKeys<K, V> {
IntoKeys { inner: self.into_iter() }
}
/// # Examples
///
/// ```
- /// #![feature(map_into_keys_values)]
/// use std::collections::HashMap;
///
/// let mut map = HashMap::new();
/// let vec: Vec<i32> = map.into_values().collect();
/// ```
#[inline]
- #[unstable(feature = "map_into_keys_values", issue = "75294")]
+ #[stable(feature = "map_into_keys_values", since = "1.54.0")]
pub fn into_values(self) -> IntoValues<K, V> {
IntoValues { inner: self.into_iter() }
}
/// # Example
///
/// ```
-/// #![feature(map_into_keys_values)]
-///
/// use std::collections::HashMap;
///
/// let mut map = HashMap::new();
/// map.insert("a", 1);
/// let iter_keys = map.into_keys();
/// ```
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
pub struct IntoKeys<K, V> {
inner: IntoIter<K, V>,
}
/// # Example
///
/// ```
-/// #![feature(map_into_keys_values)]
-///
/// use std::collections::HashMap;
///
/// let mut map = HashMap::new();
/// map.insert("a", 1);
/// let iter_keys = map.into_values();
/// ```
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
pub struct IntoValues<K, V> {
inner: IntoIter<K, V>,
}
}
}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V> Iterator for IntoKeys<K, V> {
type Item = K;
self.inner.size_hint()
}
}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V> ExactSizeIterator for IntoKeys<K, V> {
#[inline]
fn len(&self) -> usize {
self.inner.len()
}
}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V> FusedIterator for IntoKeys<K, V> {}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K: Debug, V> fmt::Debug for IntoKeys<K, V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(self.inner.iter().map(|(k, _)| k)).finish()
}
}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V> Iterator for IntoValues<K, V> {
type Item = V;
self.inner.size_hint()
}
}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V> ExactSizeIterator for IntoValues<K, V> {
#[inline]
fn len(&self) -> usize {
self.inner.len()
}
}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V> FusedIterator for IntoValues<K, V> {}
-#[unstable(feature = "map_into_keys_values", issue = "75294")]
+#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V: Debug> fmt::Debug for IntoValues<K, V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(self.inner.iter().map(|(_, v)| v)).finish()
/// assert!(env::set_current_dir(&root).is_ok());
/// println!("Successfully changed working directory to {}!", root.display());
/// ```
+#[doc(alias = "chdir")]
#[stable(feature = "env", since = "1.0.0")]
pub fn set_current_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
os_imp::chdir(path.as_ref())
/// variables at the time of this invocation. Modifications to environment
/// variables afterwards will not be reflected in the returned iterator.
///
+/// Note that the returned iterator will not check if the environment variables
+/// are valid Unicode. If you want to panic on invalid UTF-8,
+/// use the [`vars`] function instead.
+///
/// # Examples
///
/// ```
///
/// # Errors
///
-/// * Environment variable is not present
-/// * Environment variable is not valid unicode
+/// Errors if the environment variable is not present.
+/// Errors if the environment variable is not valid Unicode. If this is not desired, consider using
+/// [`var_os`].
///
/// # Panics
///
/// `'='` or the NUL character `'\0'`, or when the value contains the NUL
/// character.
///
+/// Note that the method will not check if the environment variable
+/// is valid Unicode. If you want to have an error on invalid UTF-8,
+/// use the [`var`] function instead.
+///
/// # Examples
///
/// ```
/// Failure to call [`CString::from_raw`] will lead to a memory leak.
///
/// The C side must **not** modify the length of the string (by writing a
- /// `NULL` somewhere inside the string or removing the final one) before
+ /// `null` somewhere inside the string or removing the final one) before
/// it makes it back into Rust using [`CString::from_raw`]. See the safety section
/// in [`CString::from_raw`].
///
self, Error, ErrorKind, IntoInnerError, IoSlice, Seek, SeekFrom, Write, DEFAULT_BUF_SIZE,
};
use crate::mem;
+use crate::ptr;
/// Wraps a writer and buffers its output.
///
#[stable(feature = "rust1", since = "1.0.0")]
pub struct BufWriter<W: Write> {
inner: Option<W>,
+ // The buffer. Avoid using this like a normal `Vec` in common code paths.
+ // That is, don't use `buf.push`, `buf.extend_from_slice`, or any other
+ // methods that require bounds checking or the like. This makes an enormous
+ // difference to performance (we may want to stop using a `Vec` entirely).
buf: Vec<u8>,
// #30888: If the inner writer panics in a call to write, we don't want to
// write the buffered data a second time in BufWriter's destructor. This
/// data. Writes as much as possible without exceeding capacity. Returns
/// the number of bytes written.
pub(super) fn write_to_buf(&mut self, buf: &[u8]) -> usize {
- let available = self.buf.capacity() - self.buf.len();
+ let available = self.spare_capacity();
let amt_to_buffer = available.min(buf.len());
- self.buf.extend_from_slice(&buf[..amt_to_buffer]);
+
+ // SAFETY: `amt_to_buffer` is <= buffer's spare capacity by construction.
+ unsafe {
+ self.write_to_buffer_unchecked(&buf[..amt_to_buffer]);
+ }
+
amt_to_buffer
}
let buf = if !self.panicked { Ok(buf) } else { Err(WriterPanicked { buf }) };
(self.inner.take().unwrap(), buf)
}
+
+ // Ensure this function does not get inlined into `write`, so that it
+ // remains inlineable and its common path remains as short as possible.
+ // If this function ends up being called frequently relative to `write`,
+ // it's likely a sign that the client is using an improperly sized buffer
+ // or their write patterns are somewhat pathological.
+ #[cold]
+ #[inline(never)]
+ fn write_cold(&mut self, buf: &[u8]) -> io::Result<usize> {
+ if buf.len() > self.spare_capacity() {
+ self.flush_buf()?;
+ }
+
+ // Why not len > capacity? To avoid a needless trip through the buffer when the input
+ // exactly fills it. We'd just need to flush it to the underlying writer anyway.
+ if buf.len() >= self.buf.capacity() {
+ self.panicked = true;
+ let r = self.get_mut().write(buf);
+ self.panicked = false;
+ r
+ } else {
+ // Write to the buffer. In this case, we write to the buffer even if it fills it
+ // exactly. Doing otherwise would mean flushing the buffer, then writing this
+ // input to the inner writer, which in many cases would be a worse strategy.
+
+ // SAFETY: There was either enough spare capacity already, or there wasn't and we
+ // flushed the buffer to ensure that there is. In the latter case, we know that there
+ // is because flushing ensured that our entire buffer is spare capacity, and we entered
+ // this block because the input buffer length is less than that capacity. In either
+ // case, it's safe to write the input buffer to our buffer.
+ unsafe {
+ self.write_to_buffer_unchecked(buf);
+ }
+
+ Ok(buf.len())
+ }
+ }
+
+ // Ensure this function does not get inlined into `write_all`, so that it
+ // remains inlineable and its common path remains as short as possible.
+ // If this function ends up being called frequently relative to `write_all`,
+ // it's likely a sign that the client is using an improperly sized buffer
+ // or their write patterns are somewhat pathological.
+ #[cold]
+ #[inline(never)]
+ fn write_all_cold(&mut self, buf: &[u8]) -> io::Result<()> {
+ // Normally, `write_all` just calls `write` in a loop. We can do better
+ // by calling `self.get_mut().write_all()` directly, which avoids
+ // round trips through the buffer in the event of a series of partial
+ // writes in some circumstances.
+
+ if buf.len() > self.spare_capacity() {
+ self.flush_buf()?;
+ }
+
+ // Why not len > capacity? To avoid a needless trip through the buffer when the input
+ // exactly fills it. We'd just need to flush it to the underlying writer anyway.
+ if buf.len() >= self.buf.capacity() {
+ self.panicked = true;
+ let r = self.get_mut().write_all(buf);
+ self.panicked = false;
+ r
+ } else {
+ // Write to the buffer. In this case, we write to the buffer even if it fills it
+ // exactly. Doing otherwise would mean flushing the buffer, then writing this
+ // input to the inner writer, which in many cases would be a worse strategy.
+
+ // SAFETY: There was either enough spare capacity already, or there wasn't and we
+ // flushed the buffer to ensure that there is. In the latter case, we know that there
+ // is because flushing ensured that our entire buffer is spare capacity, and we entered
+ // this block because the input buffer length is less than that capacity. In either
+ // case, it's safe to write the input buffer to our buffer.
+ unsafe {
+ self.write_to_buffer_unchecked(buf);
+ }
+
+ Ok(())
+ }
+ }
+
+ // SAFETY: Requires `buf.len() <= self.buf.capacity() - self.buf.len()`,
+ // i.e., that input buffer length is less than or equal to spare capacity.
+ #[inline]
+ unsafe fn write_to_buffer_unchecked(&mut self, buf: &[u8]) {
+ debug_assert!(buf.len() <= self.spare_capacity());
+ let old_len = self.buf.len();
+ let buf_len = buf.len();
+ let src = buf.as_ptr();
+ let dst = self.buf.as_mut_ptr().add(old_len);
+ ptr::copy_nonoverlapping(src, dst, buf_len);
+ self.buf.set_len(old_len + buf_len);
+ }
+
+ #[inline]
+ fn spare_capacity(&self) -> usize {
+ self.buf.capacity() - self.buf.len()
+ }
}
#[unstable(feature = "bufwriter_into_raw_parts", issue = "80690")]
#[stable(feature = "rust1", since = "1.0.0")]
impl<W: Write> Write for BufWriter<W> {
+ #[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
- if self.buf.len() + buf.len() > self.buf.capacity() {
- self.flush_buf()?;
- }
- // FIXME: Why no len > capacity? Why not buffer len == capacity? #72919
- if buf.len() >= self.buf.capacity() {
- self.panicked = true;
- let r = self.get_mut().write(buf);
- self.panicked = false;
- r
- } else {
- self.buf.extend_from_slice(buf);
+ // Use < instead of <= to avoid a needless trip through the buffer in some cases.
+ // See `write_cold` for details.
+ if buf.len() < self.spare_capacity() {
+ // SAFETY: safe by above conditional.
+ unsafe {
+ self.write_to_buffer_unchecked(buf);
+ }
+
Ok(buf.len())
+ } else {
+ self.write_cold(buf)
}
}
+ #[inline]
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
- // Normally, `write_all` just calls `write` in a loop. We can do better
- // by calling `self.get_mut().write_all()` directly, which avoids
- // round trips through the buffer in the event of a series of partial
- // writes in some circumstances.
- if self.buf.len() + buf.len() > self.buf.capacity() {
- self.flush_buf()?;
- }
- // FIXME: Why no len > capacity? Why not buffer len == capacity? #72919
- if buf.len() >= self.buf.capacity() {
- self.panicked = true;
- let r = self.get_mut().write_all(buf);
- self.panicked = false;
- r
- } else {
- self.buf.extend_from_slice(buf);
+ // Use < instead of <= to avoid a needless trip through the buffer in some cases.
+ // See `write_all_cold` for details.
+ if buf.len() < self.spare_capacity() {
+ // SAFETY: safe by above conditional.
+ unsafe {
+ self.write_to_buffer_unchecked(buf);
+ }
+
Ok(())
+ } else {
+ self.write_all_cold(buf)
}
}
fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+ // FIXME: Consider applying `#[inline]` / `#[inline(never)]` optimizations already applied
+ // to `write` and `write_all`. The performance benefits can be significant. See #79930.
if self.get_ref().is_write_vectored() {
- let total_len = bufs.iter().map(|b| b.len()).sum::<usize>();
- if self.buf.len() + total_len > self.buf.capacity() {
+ // We have to handle the possibility that the total length of the buffers overflows
+ // `usize` (even though this can only happen if multiple `IoSlice`s reference the
+ // same underlying buffer, as otherwise the buffers wouldn't fit in memory). If the
+ // computation overflows, then surely the input cannot fit in our buffer, so we forward
+ // to the inner writer's `write_vectored` method to let it handle it appropriately.
+ let saturated_total_len =
+ bufs.iter().fold(0usize, |acc, b| acc.saturating_add(b.len()));
+
+ if saturated_total_len > self.spare_capacity() {
+ // Flush if the total length of the input exceeds our buffer's spare capacity.
+ // If we would have overflowed, this condition also holds, and we need to flush.
self.flush_buf()?;
}
- if total_len >= self.buf.capacity() {
+
+ if saturated_total_len >= self.buf.capacity() {
+ // Forward to our inner writer if the total length of the input is greater than or
+ // equal to our buffer capacity. If we would have overflowed, this condition also
+ // holds, and we punt to the inner writer.
self.panicked = true;
let r = self.get_mut().write_vectored(bufs);
self.panicked = false;
r
} else {
- bufs.iter().for_each(|b| self.buf.extend_from_slice(b));
- Ok(total_len)
+ // `saturated_total_len < self.buf.capacity()` implies that we did not saturate.
+
+ // SAFETY: We checked whether or not the spare capacity was large enough above. If
+ // it was, then we're safe already. If it wasn't, we flushed, making sufficient
+ // room for any input <= the buffer size, which includes this input.
+ unsafe {
+ bufs.iter().for_each(|b| self.write_to_buffer_unchecked(b));
+ };
+
+ Ok(saturated_total_len)
}
} else {
let mut iter = bufs.iter();
let mut total_written = if let Some(buf) = iter.by_ref().find(|&buf| !buf.is_empty()) {
// This is the first non-empty slice to write, so if it does
// not fit in the buffer, we still get to flush and proceed.
- if self.buf.len() + buf.len() > self.buf.capacity() {
+ if buf.len() > self.spare_capacity() {
self.flush_buf()?;
}
if buf.len() >= self.buf.capacity() {
self.panicked = false;
return r;
} else {
- self.buf.extend_from_slice(buf);
+ // SAFETY: We checked whether or not the spare capacity was large enough above.
+ // If it was, then we're safe already. If it wasn't, we flushed, making
+ // sufficient room for any input <= the buffer size, which includes this input.
+ unsafe {
+ self.write_to_buffer_unchecked(buf);
+ }
+
buf.len()
}
} else {
};
debug_assert!(total_written != 0);
for buf in iter {
- if self.buf.len() + buf.len() > self.buf.capacity() {
- break;
- } else {
- self.buf.extend_from_slice(buf);
+ if buf.len() <= self.spare_capacity() {
+ // SAFETY: safe by above conditional.
+ unsafe {
+ self.write_to_buffer_unchecked(buf);
+ }
+
+ // This cannot overflow `usize`. If we are here, we've written all of the bytes
+ // so far to our buffer, and we've ensured that we never exceed the buffer's
+ // capacity. Therefore, `total_written` <= `self.buf.capacity()` <= `usize::MAX`.
total_written += buf.len();
+ } else {
+ break;
}
}
Ok(total_written)
/// This means that the operation can never succeed.
#[stable(feature = "unsupported_error", since = "1.53.0")]
Unsupported,
+
+ /// An operation could not be completed, because it failed
+ /// to allocate enough memory.
+ #[stable(feature = "out_of_memory_error", since = "1.54.0")]
+ OutOfMemory,
}
impl ErrorKind {
ErrorKind::Other => "other os error",
ErrorKind::UnexpectedEof => "unexpected end of file",
ErrorKind::Unsupported => "unsupported",
+ ErrorKind::OutOfMemory => "out of memory",
}
}
}
/// This will return an error when the IP version of the local socket
/// does not match that returned from [`ToSocketAddrs`].
///
- /// See issue #34202 for more details.
+ /// See [Issue #34202] for more details.
///
/// # Examples
///
/// let socket = UdpSocket::bind("127.0.0.1:34254").expect("couldn't bind to address");
/// socket.send_to(&[0; 10], "127.0.0.1:4242").expect("couldn't send data");
/// ```
+ ///
+ /// [Issue #34202]: https://github.com/rust-lang/rust/issues/34202
#[stable(feature = "rust1", since = "1.0.0")]
pub fn send_to<A: ToSocketAddrs>(&self, buf: &[u8], addr: A) -> io::Result<usize> {
match addr.to_socket_addrs()?.next() {
--- /dev/null
+//! SGX-specific access to architectural features.
+//!
+//! The functionality in this module is further documented in the Intel
+//! Software Developer's Manual, Volume 3, Chapter 40.
+#![unstable(feature = "sgx_platform", issue = "56975")]
+
+use crate::mem::MaybeUninit;
+
+/// Wrapper struct to force 16-byte alignment.
+#[repr(align(16))]
+#[unstable(feature = "sgx_platform", issue = "56975")]
+pub struct Align16<T>(pub T);
+
+/// Wrapper struct to force 128-byte alignment.
+#[repr(align(128))]
+#[unstable(feature = "sgx_platform", issue = "56975")]
+pub struct Align128<T>(pub T);
+
+/// Wrapper struct to force 512-byte alignment.
+#[repr(align(512))]
+#[unstable(feature = "sgx_platform", issue = "56975")]
+pub struct Align512<T>(pub T);
+
+const ENCLU_EREPORT: u32 = 0;
+const ENCLU_EGETKEY: u32 = 1;
+
+/// Call the `EGETKEY` instruction to obtain a 128-bit secret key.
+#[unstable(feature = "sgx_platform", issue = "56975")]
+pub fn egetkey(request: &Align512<[u8; 512]>) -> Result<Align16<[u8; 16]>, u32> {
+ unsafe {
+ let mut out = MaybeUninit::uninit();
+ let error;
+
+ asm!(
+ // rbx is reserved by LLVM
+ "xchg {0}, rbx",
+ "enclu",
+ "mov rbx, {0}",
+ inout(reg) request => _,
+ inlateout("eax") ENCLU_EGETKEY => error,
+ in("rcx") out.as_mut_ptr(),
+ options(nostack),
+ );
+
+ match error {
+ 0 => Ok(out.assume_init()),
+ err => Err(err),
+ }
+ }
+}
+
+/// Call the `EREPORT` instruction.
+///
+/// This creates a cryptographic report describing the contents of the current
+/// enclave. The report may be verified by the enclave described in
+/// `targetinfo`.
+#[unstable(feature = "sgx_platform", issue = "56975")]
+pub fn ereport(
+ targetinfo: &Align512<[u8; 512]>,
+ reportdata: &Align128<[u8; 64]>,
+) -> Align512<[u8; 432]> {
+ unsafe {
+ let mut report = MaybeUninit::uninit();
+
+ asm!(
+ // rbx is reserved by LLVM
+ "xchg {0}, rbx",
+ "enclu",
+ "mov rbx, {0}",
+ inout(reg) targetinfo => _,
+ in("eax") ENCLU_EREPORT,
+ in("rcx") reportdata,
+ in("rdx") report.as_mut_ptr(),
+ options(preserves_flags, nostack),
+ );
+
+ report.assume_init()
+ }
+}
--- /dev/null
+//! SGX-specific extension to the primitives in the `std::ffi` module
+//!
+//! # Examples
+//!
+//! ```
+//! use std::ffi::OsString;
+//! use std::os::fortanix_sgx::ffi::OsStringExt;
+//!
+//! let bytes = b"foo".to_vec();
+//!
+//! // OsStringExt::from_vec
+//! let os_string = OsString::from_vec(bytes);
+//! assert_eq!(os_string.to_str(), Some("foo"));
+//!
+//! // OsStringExt::into_vec
+//! let bytes = os_string.into_vec();
+//! assert_eq!(bytes, b"foo");
+//! ```
+//!
+//! ```
+//! use std::ffi::OsStr;
+//! use std::os::fortanix_sgx::ffi::OsStrExt;
+//!
+//! let bytes = b"foo";
+//!
+//! // OsStrExt::from_bytes
+//! let os_str = OsStr::from_bytes(bytes);
+//! assert_eq!(os_str.to_str(), Some("foo"));
+//!
+//! // OsStrExt::as_bytes
+//! let bytes = os_str.as_bytes();
+//! assert_eq!(bytes, b"foo");
+//! ```
+
+#![unstable(feature = "sgx_platform", issue = "56975")]
+
+#[unstable(feature = "sgx_platform", issue = "56975")]
+pub use crate::sys_common::os_str_bytes::*;
--- /dev/null
+//! SGX-specific extensions to general I/O primitives
+//!
+//! SGX file descriptors behave differently from Unix file descriptors. See the
+//! description of [`TryIntoRawFd`] for more details.
+#![unstable(feature = "sgx_platform", issue = "56975")]
+
+use crate::net;
+pub use crate::sys::abi::usercalls::raw::Fd as RawFd;
+use crate::sys::{self, AsInner, FromInner, IntoInner, TryIntoInner};
+
+/// A trait to extract the raw SGX file descriptor from an underlying
+/// object.
+#[unstable(feature = "sgx_platform", issue = "56975")]
+pub trait AsRawFd {
+ /// Extracts the raw file descriptor.
+ ///
+ /// This method does **not** pass ownership of the raw file descriptor
+ /// to the caller. The descriptor is only guaranteed to be valid while
+ /// the original object has not yet been destroyed.
+ #[unstable(feature = "sgx_platform", issue = "56975")]
+ fn as_raw_fd(&self) -> RawFd;
+}
+
+/// A trait to express the ability to construct an object from a raw file
+/// descriptor.
+#[unstable(feature = "sgx_platform", issue = "56975")]
+pub trait FromRawFd {
+ /// An associated type that contains relevant metadata for `Self`.
+ type Metadata: Default;
+
+ /// Constructs a new instance of `Self` from the given raw file
+ /// descriptor and metadata.
+ ///
+ /// This function **consumes ownership** of the specified file
+ /// descriptor. The returned object will take responsibility for closing
+ /// it when the object goes out of scope.
+ ///
+ /// This function is also unsafe as the primitives currently returned
+ /// have the contract that they are the sole owner of the file
+ /// descriptor they are wrapping. Usage of this function could
+ /// accidentally allow violating this contract which can cause memory
+ /// unsafety in code that relies on it being true.
+ #[unstable(feature = "sgx_platform", issue = "56975")]
+ unsafe fn from_raw_fd(fd: RawFd, metadata: Self::Metadata) -> Self;
+}
+
+/// A trait to express the ability to consume an object and acquire ownership of
+/// its raw file descriptor.
+#[unstable(feature = "sgx_platform", issue = "56975")]
+pub trait TryIntoRawFd: Sized {
+ /// Consumes this object, returning the raw underlying file descriptor, if
+ /// this object is not cloned.
+ ///
+ /// This function **transfers ownership** of the underlying file descriptor
+ /// to the caller. Callers are then the unique owners of the file descriptor
+ /// and must close the descriptor once it's no longer needed.
+ ///
+ /// Unlike other platforms, on SGX, the file descriptor is shared between
+ /// all clones of an object. To avoid race conditions, this function will
+ /// only return `Ok` when called on the final clone.
+ #[unstable(feature = "sgx_platform", issue = "56975")]
+ fn try_into_raw_fd(self) -> Result<RawFd, Self>;
+}
+
+impl AsRawFd for net::TcpStream {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ *self.as_inner().as_inner().as_inner().as_inner()
+ }
+}
+
+impl AsRawFd for net::TcpListener {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ *self.as_inner().as_inner().as_inner().as_inner()
+ }
+}
+
+/// Metadata for `TcpStream`.
+#[derive(Debug, Clone, Default)]
+#[unstable(feature = "sgx_platform", issue = "56975")]
+pub struct TcpStreamMetadata {
+ /// Local address of the TCP stream
+ pub local_addr: Option<String>,
+ /// Peer address of the TCP stream
+ pub peer_addr: Option<String>,
+}
+
+impl FromRawFd for net::TcpStream {
+ type Metadata = TcpStreamMetadata;
+
+ #[inline]
+ unsafe fn from_raw_fd(fd: RawFd, metadata: Self::Metadata) -> net::TcpStream {
+ let fd = sys::fd::FileDesc::from_inner(fd);
+ let socket = sys::net::Socket::from_inner((fd, metadata.local_addr));
+ net::TcpStream::from_inner(sys::net::TcpStream::from_inner((socket, metadata.peer_addr)))
+ }
+}
+
+/// Metadata for `TcpListener`.
+#[derive(Debug, Clone, Default)]
+#[unstable(feature = "sgx_platform", issue = "56975")]
+pub struct TcpListenerMetadata {
+ /// Local address of the TCP listener
+ pub local_addr: Option<String>,
+}
+
+impl FromRawFd for net::TcpListener {
+ type Metadata = TcpListenerMetadata;
+
+ #[inline]
+ unsafe fn from_raw_fd(fd: RawFd, metadata: Self::Metadata) -> net::TcpListener {
+ let fd = sys::fd::FileDesc::from_inner(fd);
+ let socket = sys::net::Socket::from_inner((fd, metadata.local_addr));
+ net::TcpListener::from_inner(sys::net::TcpListener::from_inner(socket))
+ }
+}
+
+impl TryIntoRawFd for net::TcpStream {
+ #[inline]
+ fn try_into_raw_fd(self) -> Result<RawFd, Self> {
+ let (socket, peer_addr) = self.into_inner().into_inner();
+ match socket.try_into_inner() {
+ Ok(fd) => Ok(fd.into_inner()),
+ Err(socket) => {
+ let sys = sys::net::TcpStream::from_inner((socket, peer_addr));
+ Err(net::TcpStream::from_inner(sys))
+ }
+ }
+ }
+}
+
+impl TryIntoRawFd for net::TcpListener {
+ #[inline]
+ fn try_into_raw_fd(self) -> Result<RawFd, Self> {
+ match self.into_inner().into_inner().try_into_inner() {
+ Ok(fd) => Ok(fd.into_inner()),
+ Err(socket) => {
+ let sys = sys::net::TcpListener::from_inner(socket);
+ Err(net::TcpListener::from_inner(sys))
+ }
+ }
+ }
+}
//! This includes functions to deal with memory isolation, usercalls, and the
//! SGX instruction set.
-#![deny(missing_docs, missing_debug_implementations)]
+#![deny(missing_docs)]
#![unstable(feature = "sgx_platform", issue = "56975")]
/// Low-level interfaces to usercalls. See the [ABI documentation] for more
pub use crate::sys::abi::mem::*;
}
-pub use crate::sys::ext::{arch, ffi, io};
+pub mod arch;
+pub mod ffi;
+pub mod io;
/// Functions for querying thread-related information.
pub mod thread {
--- /dev/null
+//! HermitCore-specific extension to the primitives in the `std::ffi` module
+//!
+//! # Examples
+//!
+//! ```
+//! use std::ffi::OsString;
+//! use std::os::hermit::ffi::OsStringExt;
+//!
+//! let bytes = b"foo".to_vec();
+//!
+//! // OsStringExt::from_vec
+//! let os_string = OsString::from_vec(bytes);
+//! assert_eq!(os_string.to_str(), Some("foo"));
+//!
+//! // OsStringExt::into_vec
+//! let bytes = os_string.into_vec();
+//! assert_eq!(bytes, b"foo");
+//! ```
+//!
+//! ```
+//! use std::ffi::OsStr;
+//! use std::os::hermit::ffi::OsStrExt;
+//!
+//! let bytes = b"foo";
+//!
+//! // OsStrExt::from_bytes
+//! let os_str = OsStr::from_bytes(bytes);
+//! assert_eq!(os_str.to_str(), Some("foo"));
+//!
+//! // OsStrExt::as_bytes
+//! let bytes = os_str.as_bytes();
+//! assert_eq!(bytes, b"foo");
+//! ```
+
+#![stable(feature = "rust1", since = "1.0.0")]
+
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use crate::sys_common::os_str_bytes::*;
--- /dev/null
+#![stable(feature = "rust1", since = "1.0.0")]
+
+pub mod ffi;
+
+/// A prelude for conveniently writing platform-specific code.
+///
+/// Includes all extension traits, and some important type definitions.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub mod prelude {
+ #[doc(no_inline)]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub use super::ffi::{OsStrExt, OsStringExt};
+}
//! Linux-specific definitions.
#![stable(feature = "raw_ext", since = "1.1.0")]
+#![doc(cfg(target_os = "linux"))]
pub mod fs;
pub mod raw;
definitions"
)]
#![allow(deprecated)]
-#![allow(missing_debug_implementations)]
use crate::os::raw::c_ulong;
#![stable(feature = "os", since = "1.0.0")]
#![allow(missing_docs, nonstandard_style, missing_debug_implementations)]
-// When documenting libstd we want to show unix/windows/linux/wasi modules as these are the "main
-// modules" that are used across platforms, so all modules are enabled when `cfg(doc)` is set.
-// This should help show platform-specific functionality in a hopefully cross-platform way in the
-// documentation.
-// Note that we deliberately avoid `cfg_if!` here to work around a rust-analyzer bug that would make
-// `std::os` submodules unusable: https://github.com/rust-analyzer/rust-analyzer/issues/6038
+pub mod raw;
-#[cfg(doc)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use crate::sys::unix_ext as unix;
+// The code below could be written clearer using `cfg_if!`. However, the items below are
+// publicly exported by `std` and external tools can have trouble analysing them because of the use
+// of a macro that is not vendored by Rust and included in the toolchain.
+// See https://github.com/rust-analyzer/rust-analyzer/issues/6038.
-#[cfg(doc)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use crate::sys::windows_ext as windows;
+#[cfg(all(
+ doc,
+ not(any(
+ all(target_arch = "wasm32", not(target_os = "wasi")),
+ all(target_vendor = "fortanix", target_env = "sgx")
+ ))
+))]
+#[path = "."]
+mod doc {
+ // When documenting std we want to show the `unix`, `windows`, `linux` and `wasi`
+ // modules as these are the "main modules" that are used across platforms,
+ // so these modules are enabled when `cfg(doc)` is set.
+ // This should help show platform-specific functionality in a hopefully cross-platform
+ // way in the documentation.
-#[cfg(doc)]
-#[doc(cfg(target_os = "linux"))]
-pub mod linux;
+ pub mod unix;
-#[cfg(doc)]
-#[stable(feature = "wasi_ext_doc", since = "1.35.0")]
-pub use crate::sys::wasi_ext as wasi;
+ pub mod linux;
-// If we're not documenting libstd then we just expose the main modules as we otherwise would.
+ pub mod wasi;
-#[cfg(not(doc))]
-#[cfg(any(unix, target_os = "hermit"))]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use crate::sys::ext as unix;
+ pub mod windows;
+}
+#[cfg(all(
+ doc,
+ any(
+ all(target_arch = "wasm32", not(target_os = "wasi")),
+ all(target_vendor = "fortanix", target_env = "sgx")
+ )
+))]
+mod doc {
+ // On certain platforms right now the "main modules" modules that are
+ // documented don't compile (missing things in `libc` which is empty),
+ // so just omit them with an empty module.
-#[cfg(not(doc))]
-#[cfg(windows)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use crate::sys::ext as windows;
+ #[unstable(issue = "none", feature = "std_internals")]
+ pub mod unix {}
-#[cfg(not(doc))]
-#[cfg(any(target_os = "linux", target_os = "l4re"))]
-pub mod linux;
+ #[unstable(issue = "none", feature = "std_internals")]
+ pub mod linux {}
+
+ #[unstable(issue = "none", feature = "std_internals")]
+ pub mod wasi {}
+
+ #[unstable(issue = "none", feature = "std_internals")]
+ pub mod windows {}
+}
+#[cfg(doc)]
+#[stable(feature = "os", since = "1.0.0")]
+pub use doc::*;
#[cfg(not(doc))]
-#[cfg(target_os = "wasi")]
-pub mod wasi;
-
-#[cfg(target_os = "android")]
-pub mod android;
-#[cfg(target_os = "dragonfly")]
-pub mod dragonfly;
-#[cfg(target_os = "emscripten")]
-pub mod emscripten;
-#[cfg(all(target_vendor = "fortanix", target_env = "sgx"))]
-pub mod fortanix_sgx;
-#[cfg(target_os = "freebsd")]
-pub mod freebsd;
-#[cfg(target_os = "fuchsia")]
-pub mod fuchsia;
-#[cfg(target_os = "haiku")]
-pub mod haiku;
-#[cfg(target_os = "illumos")]
-pub mod illumos;
-#[cfg(target_os = "ios")]
-pub mod ios;
-#[cfg(target_os = "macos")]
-pub mod macos;
-#[cfg(target_os = "netbsd")]
-pub mod netbsd;
-#[cfg(target_os = "openbsd")]
-pub mod openbsd;
-#[cfg(target_os = "redox")]
-pub mod redox;
-#[cfg(target_os = "solaris")]
-pub mod solaris;
-#[cfg(target_os = "vxworks")]
-pub mod vxworks;
+#[path = "."]
+mod imp {
+ // If we're not documenting std then we only expose modules appropriate for the
+ // current platform.
-pub mod raw;
+ #[cfg(all(target_vendor = "fortanix", target_env = "sgx"))]
+ pub mod fortanix_sgx;
+
+ #[cfg(target_os = "hermit")]
+ #[path = "hermit/mod.rs"]
+ pub mod unix;
+
+ #[cfg(target_os = "android")]
+ pub mod android;
+ #[cfg(target_os = "dragonfly")]
+ pub mod dragonfly;
+ #[cfg(target_os = "emscripten")]
+ pub mod emscripten;
+ #[cfg(target_os = "freebsd")]
+ pub mod freebsd;
+ #[cfg(target_os = "fuchsia")]
+ pub mod fuchsia;
+ #[cfg(target_os = "haiku")]
+ pub mod haiku;
+ #[cfg(target_os = "illumos")]
+ pub mod illumos;
+ #[cfg(target_os = "ios")]
+ pub mod ios;
+ #[cfg(target_os = "l4re")]
+ pub mod linux;
+ #[cfg(target_os = "linux")]
+ pub mod linux;
+ #[cfg(target_os = "macos")]
+ pub mod macos;
+ #[cfg(target_os = "netbsd")]
+ pub mod netbsd;
+ #[cfg(target_os = "openbsd")]
+ pub mod openbsd;
+ #[cfg(target_os = "redox")]
+ pub mod redox;
+ #[cfg(target_os = "solaris")]
+ pub mod solaris;
+ #[cfg(unix)]
+ pub mod unix;
+
+ #[cfg(target_os = "vxworks")]
+ pub mod vxworks;
+
+ #[cfg(target_os = "wasi")]
+ pub mod wasi;
+
+ #[cfg(windows)]
+ pub mod windows;
+}
+#[cfg(not(doc))]
+#[stable(feature = "os", since = "1.0.0")]
+pub use imp::*;
definitions"
)]
#![allow(deprecated)]
-#![allow(missing_debug_implementations)]
use crate::os::raw::{c_char, c_int, c_long, c_ulong, c_void};
--- /dev/null
+//! Unix-specific extension to the primitives in the `std::ffi` module.
+//!
+//! # Examples
+//!
+//! ```
+//! use std::ffi::OsString;
+//! use std::os::unix::ffi::OsStringExt;
+//!
+//! let bytes = b"foo".to_vec();
+//!
+//! // OsStringExt::from_vec
+//! let os_string = OsString::from_vec(bytes);
+//! assert_eq!(os_string.to_str(), Some("foo"));
+//!
+//! // OsStringExt::into_vec
+//! let bytes = os_string.into_vec();
+//! assert_eq!(bytes, b"foo");
+//! ```
+//!
+//! ```
+//! use std::ffi::OsStr;
+//! use std::os::unix::ffi::OsStrExt;
+//!
+//! let bytes = b"foo";
+//!
+//! // OsStrExt::from_bytes
+//! let os_str = OsStr::from_bytes(bytes);
+//! assert_eq!(os_str.to_str(), Some("foo"));
+//!
+//! // OsStrExt::as_bytes
+//! let bytes = os_str.as_bytes();
+//! assert_eq!(bytes, b"foo");
+//! ```
+
+#![stable(feature = "rust1", since = "1.0.0")]
+
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use crate::sys_common::os_str_bytes::*;
--- /dev/null
+//! Unix-specific extensions to primitives in the `std::fs` module.
+
+#![stable(feature = "rust1", since = "1.0.0")]
+
+use super::platform::fs::MetadataExt as _;
+use crate::fs::{self, OpenOptions, Permissions};
+use crate::io;
+use crate::path::Path;
+use crate::sys;
+use crate::sys_common::{AsInner, AsInnerMut, FromInner};
+// Used for `File::read` on intra-doc links
+#[allow(unused_imports)]
+use io::{Read, Write};
+
+/// Unix-specific extensions to [`fs::File`].
+#[stable(feature = "file_offset", since = "1.15.0")]
+pub trait FileExt {
+ /// Reads a number of bytes starting from a given offset.
+ ///
+ /// Returns the number of bytes read.
+ ///
+ /// The offset is relative to the start of the file and thus independent
+ /// from the current cursor.
+ ///
+ /// The current file cursor is not affected by this function.
+ ///
+ /// Note that similar to [`File::read`], it is not an error to return with a
+ /// short read.
+ ///
+ /// [`File::read`]: fs::File::read
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::io;
+ /// use std::fs::File;
+ /// use std::os::unix::prelude::FileExt;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let mut buf = [0u8; 8];
+ /// let file = File::open("foo.txt")?;
+ ///
+ /// // We now read 8 bytes from the offset 10.
+ /// let num_bytes_read = file.read_at(&mut buf, 10)?;
+ /// println!("read {} bytes: {:?}", num_bytes_read, buf);
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "file_offset", since = "1.15.0")]
+ fn read_at(&self, buf: &mut [u8], offset: u64) -> io::Result<usize>;
+
+ /// Reads the exact number of byte required to fill `buf` from the given offset.
+ ///
+ /// The offset is relative to the start of the file and thus independent
+ /// from the current cursor.
+ ///
+ /// The current file cursor is not affected by this function.
+ ///
+ /// Similar to [`io::Read::read_exact`] but uses [`read_at`] instead of `read`.
+ ///
+ /// [`read_at`]: FileExt::read_at
+ ///
+ /// # Errors
+ ///
+ /// If this function encounters an error of the kind
+ /// [`io::ErrorKind::Interrupted`] then the error is ignored and the operation
+ /// will continue.
+ ///
+ /// If this function encounters an "end of file" before completely filling
+ /// the buffer, it returns an error of the kind [`io::ErrorKind::UnexpectedEof`].
+ /// The contents of `buf` are unspecified in this case.
+ ///
+ /// If any other read error is encountered then this function immediately
+ /// returns. The contents of `buf` are unspecified in this case.
+ ///
+ /// If this function returns an error, it is unspecified how many bytes it
+ /// has read, but it will never read more than would be necessary to
+ /// completely fill the buffer.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::io;
+ /// use std::fs::File;
+ /// use std::os::unix::prelude::FileExt;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let mut buf = [0u8; 8];
+ /// let file = File::open("foo.txt")?;
+ ///
+ /// // We now read exactly 8 bytes from the offset 10.
+ /// file.read_exact_at(&mut buf, 10)?;
+ /// println!("read {} bytes: {:?}", buf.len(), buf);
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "rw_exact_all_at", since = "1.33.0")]
+ fn read_exact_at(&self, mut buf: &mut [u8], mut offset: u64) -> io::Result<()> {
+ while !buf.is_empty() {
+ match self.read_at(buf, offset) {
+ Ok(0) => break,
+ Ok(n) => {
+ let tmp = buf;
+ buf = &mut tmp[n..];
+ offset += n as u64;
+ }
+ Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
+ Err(e) => return Err(e),
+ }
+ }
+ if !buf.is_empty() {
+ Err(io::Error::new_const(io::ErrorKind::UnexpectedEof, &"failed to fill whole buffer"))
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Writes a number of bytes starting from a given offset.
+ ///
+ /// Returns the number of bytes written.
+ ///
+ /// The offset is relative to the start of the file and thus independent
+ /// from the current cursor.
+ ///
+ /// The current file cursor is not affected by this function.
+ ///
+ /// When writing beyond the end of the file, the file is appropriately
+ /// extended and the intermediate bytes are initialized with the value 0.
+ ///
+ /// Note that similar to [`File::write`], it is not an error to return a
+ /// short write.
+ ///
+ /// [`File::write`]: fs::File::write
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs::File;
+ /// use std::io;
+ /// use std::os::unix::prelude::FileExt;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let file = File::open("foo.txt")?;
+ ///
+ /// // We now write at the offset 10.
+ /// file.write_at(b"sushi", 10)?;
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "file_offset", since = "1.15.0")]
+ fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize>;
+
+ /// Attempts to write an entire buffer starting from a given offset.
+ ///
+ /// The offset is relative to the start of the file and thus independent
+ /// from the current cursor.
+ ///
+ /// The current file cursor is not affected by this function.
+ ///
+ /// This method will continuously call [`write_at`] until there is no more data
+ /// to be written or an error of non-[`io::ErrorKind::Interrupted`] kind is
+ /// returned. This method will not return until the entire buffer has been
+ /// successfully written or such an error occurs. The first error that is
+ /// not of [`io::ErrorKind::Interrupted`] kind generated from this method will be
+ /// returned.
+ ///
+ /// # Errors
+ ///
+ /// This function will return the first error of
+ /// non-[`io::ErrorKind::Interrupted`] kind that [`write_at`] returns.
+ ///
+ /// [`write_at`]: FileExt::write_at
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs::File;
+ /// use std::io;
+ /// use std::os::unix::prelude::FileExt;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let file = File::open("foo.txt")?;
+ ///
+ /// // We now write at the offset 10.
+ /// file.write_all_at(b"sushi", 10)?;
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "rw_exact_all_at", since = "1.33.0")]
+ fn write_all_at(&self, mut buf: &[u8], mut offset: u64) -> io::Result<()> {
+ while !buf.is_empty() {
+ match self.write_at(buf, offset) {
+ Ok(0) => {
+ return Err(io::Error::new_const(
+ io::ErrorKind::WriteZero,
+ &"failed to write whole buffer",
+ ));
+ }
+ Ok(n) => {
+ buf = &buf[n..];
+ offset += n as u64
+ }
+ Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
+ Err(e) => return Err(e),
+ }
+ }
+ Ok(())
+ }
+}
+
+#[stable(feature = "file_offset", since = "1.15.0")]
+impl FileExt for fs::File {
+ fn read_at(&self, buf: &mut [u8], offset: u64) -> io::Result<usize> {
+ self.as_inner().read_at(buf, offset)
+ }
+ fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
+ self.as_inner().write_at(buf, offset)
+ }
+}
+
+/// Unix-specific extensions to [`fs::Permissions`].
+#[stable(feature = "fs_ext", since = "1.1.0")]
+pub trait PermissionsExt {
+ /// Returns the underlying raw `st_mode` bits that contain the standard
+ /// Unix permissions for this file.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs::File;
+ /// use std::os::unix::fs::PermissionsExt;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let f = File::create("foo.txt")?;
+ /// let metadata = f.metadata()?;
+ /// let permissions = metadata.permissions();
+ ///
+ /// println!("permissions: {:o}", permissions.mode());
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "fs_ext", since = "1.1.0")]
+ fn mode(&self) -> u32;
+
+ /// Sets the underlying raw bits for this set of permissions.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs::File;
+ /// use std::os::unix::fs::PermissionsExt;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let f = File::create("foo.txt")?;
+ /// let metadata = f.metadata()?;
+ /// let mut permissions = metadata.permissions();
+ ///
+ /// permissions.set_mode(0o644); // Read/write for owner and read for others.
+ /// assert_eq!(permissions.mode(), 0o644);
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "fs_ext", since = "1.1.0")]
+ fn set_mode(&mut self, mode: u32);
+
+ /// Creates a new instance of `Permissions` from the given set of Unix
+ /// permission bits.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::fs::Permissions;
+ /// use std::os::unix::fs::PermissionsExt;
+ ///
+ /// // Read/write for owner and read for others.
+ /// let permissions = Permissions::from_mode(0o644);
+ /// assert_eq!(permissions.mode(), 0o644);
+ /// ```
+ #[stable(feature = "fs_ext", since = "1.1.0")]
+ fn from_mode(mode: u32) -> Self;
+}
+
+#[stable(feature = "fs_ext", since = "1.1.0")]
+impl PermissionsExt for Permissions {
+ fn mode(&self) -> u32 {
+ self.as_inner().mode()
+ }
+
+ fn set_mode(&mut self, mode: u32) {
+ *self = Permissions::from_inner(FromInner::from_inner(mode));
+ }
+
+ fn from_mode(mode: u32) -> Permissions {
+ Permissions::from_inner(FromInner::from_inner(mode))
+ }
+}
+
+/// Unix-specific extensions to [`fs::OpenOptions`].
+#[stable(feature = "fs_ext", since = "1.1.0")]
+pub trait OpenOptionsExt {
+ /// Sets the mode bits that a new file will be created with.
+ ///
+ /// If a new file is created as part of an `OpenOptions::open` call then this
+ /// specified `mode` will be used as the permission bits for the new file.
+ /// If no `mode` is set, the default of `0o666` will be used.
+ /// The operating system masks out bits with the system's `umask`, to produce
+ /// the final permissions.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs::OpenOptions;
+ /// use std::os::unix::fs::OpenOptionsExt;
+ ///
+ /// # fn main() {
+ /// let mut options = OpenOptions::new();
+ /// options.mode(0o644); // Give read/write for owner and read for others.
+ /// let file = options.open("foo.txt");
+ /// # }
+ /// ```
+ #[stable(feature = "fs_ext", since = "1.1.0")]
+ fn mode(&mut self, mode: u32) -> &mut Self;
+
+ /// Pass custom flags to the `flags` argument of `open`.
+ ///
+ /// The bits that define the access mode are masked out with `O_ACCMODE`, to
+ /// ensure they do not interfere with the access mode set by Rusts options.
+ ///
+ /// Custom flags can only set flags, not remove flags set by Rusts options.
+ /// This options overwrites any previously set custom flags.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// # #![feature(rustc_private)]
+ /// extern crate libc;
+ /// use std::fs::OpenOptions;
+ /// use std::os::unix::fs::OpenOptionsExt;
+ ///
+ /// # fn main() {
+ /// let mut options = OpenOptions::new();
+ /// options.write(true);
+ /// if cfg!(unix) {
+ /// options.custom_flags(libc::O_NOFOLLOW);
+ /// }
+ /// let file = options.open("foo.txt");
+ /// # }
+ /// ```
+ #[stable(feature = "open_options_ext", since = "1.10.0")]
+ fn custom_flags(&mut self, flags: i32) -> &mut Self;
+}
+
+#[stable(feature = "fs_ext", since = "1.1.0")]
+impl OpenOptionsExt for OpenOptions {
+ fn mode(&mut self, mode: u32) -> &mut OpenOptions {
+ self.as_inner_mut().mode(mode);
+ self
+ }
+
+ fn custom_flags(&mut self, flags: i32) -> &mut OpenOptions {
+ self.as_inner_mut().custom_flags(flags);
+ self
+ }
+}
+
+/// Unix-specific extensions to [`fs::Metadata`].
+#[stable(feature = "metadata_ext", since = "1.1.0")]
+pub trait MetadataExt {
+ /// Returns the ID of the device containing the file.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::io;
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let dev_id = meta.dev();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn dev(&self) -> u64;
+ /// Returns the inode number.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let inode = meta.ino();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn ino(&self) -> u64;
+ /// Returns the rights applied to this file.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let mode = meta.mode();
+ /// let user_has_write_access = mode & 0o200;
+ /// let user_has_read_write_access = mode & 0o600;
+ /// let group_has_read_access = mode & 0o040;
+ /// let others_have_exec_access = mode & 0o001;
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn mode(&self) -> u32;
+ /// Returns the number of hard links pointing to this file.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let nb_hard_links = meta.nlink();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn nlink(&self) -> u64;
+ /// Returns the user ID of the owner of this file.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let user_id = meta.uid();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn uid(&self) -> u32;
+ /// Returns the group ID of the owner of this file.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let group_id = meta.gid();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn gid(&self) -> u32;
+ /// Returns the device ID of this file (if it is a special one).
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let device_id = meta.rdev();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn rdev(&self) -> u64;
+ /// Returns the total size of this file in bytes.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let file_size = meta.size();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn size(&self) -> u64;
+ /// Returns the last access time of the file, in seconds since Unix Epoch.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let last_access_time = meta.atime();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn atime(&self) -> i64;
+ /// Returns the last access time of the file, in nanoseconds since [`atime`].
+ ///
+ /// [`atime`]: MetadataExt::atime
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let nano_last_access_time = meta.atime_nsec();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn atime_nsec(&self) -> i64;
+ /// Returns the last modification time of the file, in seconds since Unix Epoch.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let last_modification_time = meta.mtime();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn mtime(&self) -> i64;
+ /// Returns the last modification time of the file, in nanoseconds since [`mtime`].
+ ///
+ /// [`mtime`]: MetadataExt::mtime
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let nano_last_modification_time = meta.mtime_nsec();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn mtime_nsec(&self) -> i64;
+ /// Returns the last status change time of the file, in seconds since Unix Epoch.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let last_status_change_time = meta.ctime();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn ctime(&self) -> i64;
+ /// Returns the last status change time of the file, in nanoseconds since [`ctime`].
+ ///
+ /// [`ctime`]: MetadataExt::ctime
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let nano_last_status_change_time = meta.ctime_nsec();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn ctime_nsec(&self) -> i64;
+ /// Returns the block size for filesystem I/O.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let block_size = meta.blksize();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn blksize(&self) -> u64;
+ /// Returns the number of blocks allocated to the file, in 512-byte units.
+ ///
+ /// Please note that this may be smaller than `st_size / 512` when the file has holes.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::MetadataExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("some_file")?;
+ /// let blocks = meta.blocks();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn blocks(&self) -> u64;
+ #[cfg(target_os = "vxworks")]
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn attrib(&self) -> u8;
+}
+
+#[stable(feature = "metadata_ext", since = "1.1.0")]
+impl MetadataExt for fs::Metadata {
+ fn dev(&self) -> u64 {
+ self.st_dev()
+ }
+ fn ino(&self) -> u64 {
+ self.st_ino()
+ }
+ fn mode(&self) -> u32 {
+ self.st_mode()
+ }
+ fn nlink(&self) -> u64 {
+ self.st_nlink()
+ }
+ fn uid(&self) -> u32 {
+ self.st_uid()
+ }
+ fn gid(&self) -> u32 {
+ self.st_gid()
+ }
+ fn rdev(&self) -> u64 {
+ self.st_rdev()
+ }
+ fn size(&self) -> u64 {
+ self.st_size()
+ }
+ fn atime(&self) -> i64 {
+ self.st_atime()
+ }
+ fn atime_nsec(&self) -> i64 {
+ self.st_atime_nsec()
+ }
+ fn mtime(&self) -> i64 {
+ self.st_mtime()
+ }
+ fn mtime_nsec(&self) -> i64 {
+ self.st_mtime_nsec()
+ }
+ fn ctime(&self) -> i64 {
+ self.st_ctime()
+ }
+ fn ctime_nsec(&self) -> i64 {
+ self.st_ctime_nsec()
+ }
+ fn blksize(&self) -> u64 {
+ self.st_blksize()
+ }
+ fn blocks(&self) -> u64 {
+ self.st_blocks()
+ }
+ #[cfg(target_os = "vxworks")]
+ fn attrib(&self) -> u8 {
+ self.st_attrib()
+ }
+}
+
+/// Unix-specific extensions for [`fs::FileType`].
+///
+/// Adds support for special Unix file types such as block/character devices,
+/// pipes, and sockets.
+#[stable(feature = "file_type_ext", since = "1.5.0")]
+pub trait FileTypeExt {
+ /// Returns `true` if this file type is a block device.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::FileTypeExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("block_device_file")?;
+ /// let file_type = meta.file_type();
+ /// assert!(file_type.is_block_device());
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "file_type_ext", since = "1.5.0")]
+ fn is_block_device(&self) -> bool;
+ /// Returns `true` if this file type is a char device.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::FileTypeExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("char_device_file")?;
+ /// let file_type = meta.file_type();
+ /// assert!(file_type.is_char_device());
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "file_type_ext", since = "1.5.0")]
+ fn is_char_device(&self) -> bool;
+ /// Returns `true` if this file type is a fifo.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::FileTypeExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("fifo_file")?;
+ /// let file_type = meta.file_type();
+ /// assert!(file_type.is_fifo());
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "file_type_ext", since = "1.5.0")]
+ fn is_fifo(&self) -> bool;
+ /// Returns `true` if this file type is a socket.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs;
+ /// use std::os::unix::fs::FileTypeExt;
+ /// use std::io;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let meta = fs::metadata("unix.socket")?;
+ /// let file_type = meta.file_type();
+ /// assert!(file_type.is_socket());
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "file_type_ext", since = "1.5.0")]
+ fn is_socket(&self) -> bool;
+}
+
+#[stable(feature = "file_type_ext", since = "1.5.0")]
+impl FileTypeExt for fs::FileType {
+ fn is_block_device(&self) -> bool {
+ self.as_inner().is(libc::S_IFBLK)
+ }
+ fn is_char_device(&self) -> bool {
+ self.as_inner().is(libc::S_IFCHR)
+ }
+ fn is_fifo(&self) -> bool {
+ self.as_inner().is(libc::S_IFIFO)
+ }
+ fn is_socket(&self) -> bool {
+ self.as_inner().is(libc::S_IFSOCK)
+ }
+}
+
+/// Unix-specific extension methods for [`fs::DirEntry`].
+#[stable(feature = "dir_entry_ext", since = "1.1.0")]
+pub trait DirEntryExt {
+ /// Returns the underlying `d_ino` field in the contained `dirent`
+ /// structure.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::fs;
+ /// use std::os::unix::fs::DirEntryExt;
+ ///
+ /// if let Ok(entries) = fs::read_dir(".") {
+ /// for entry in entries {
+ /// if let Ok(entry) = entry {
+ /// // Here, `entry` is a `DirEntry`.
+ /// println!("{:?}: {}", entry.file_name(), entry.ino());
+ /// }
+ /// }
+ /// }
+ /// ```
+ #[stable(feature = "dir_entry_ext", since = "1.1.0")]
+ fn ino(&self) -> u64;
+}
+
+#[stable(feature = "dir_entry_ext", since = "1.1.0")]
+impl DirEntryExt for fs::DirEntry {
+ fn ino(&self) -> u64 {
+ self.as_inner().ino()
+ }
+}
+
+/// Creates a new symbolic link on the filesystem.
+///
+/// The `link` path will be a symbolic link pointing to the `original` path.
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::os::unix::fs;
+///
+/// fn main() -> std::io::Result<()> {
+/// fs::symlink("a.txt", "b.txt")?;
+/// Ok(())
+/// }
+/// ```
+#[stable(feature = "symlink", since = "1.1.0")]
+pub fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Result<()> {
+ sys::fs::symlink(original.as_ref(), link.as_ref())
+}
+
+/// Unix-specific extensions to [`fs::DirBuilder`].
+#[stable(feature = "dir_builder", since = "1.6.0")]
+pub trait DirBuilderExt {
+ /// Sets the mode to create new directories with. This option defaults to
+ /// 0o777.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs::DirBuilder;
+ /// use std::os::unix::fs::DirBuilderExt;
+ ///
+ /// let mut builder = DirBuilder::new();
+ /// builder.mode(0o755);
+ /// ```
+ #[stable(feature = "dir_builder", since = "1.6.0")]
+ fn mode(&mut self, mode: u32) -> &mut Self;
+}
+
+#[stable(feature = "dir_builder", since = "1.6.0")]
+impl DirBuilderExt for fs::DirBuilder {
+ fn mode(&mut self, mode: u32) -> &mut fs::DirBuilder {
+ self.as_inner_mut().set_mode(mode);
+ self
+ }
+}
+
+/// Change the root directory of the current process to the specified path.
+///
+/// This typically requires privileges, such as root or a specific capability.
+///
+/// This does not change the current working directory; you should call
+/// [`std::env::set_current_dir`][`crate::env::set_current_dir`] afterwards.
+///
+/// # Examples
+///
+/// ```no_run
+/// #![feature(unix_chroot)]
+/// use std::os::unix::fs;
+///
+/// fn main() -> std::io::Result<()> {
+/// fs::chroot("/sandbox")?;
+/// std::env::set_current_dir("/")?;
+/// // continue working in sandbox
+/// Ok(())
+/// }
+/// ```
+#[unstable(feature = "unix_chroot", issue = "84715")]
+#[cfg(not(target_os = "fuchsia"))]
+pub fn chroot<P: AsRef<Path>>(dir: P) -> io::Result<()> {
+ sys::fs::chroot(dir.as_ref())
+}
--- /dev/null
+//! Unix-specific extensions to general I/O primitives.
+
+#![stable(feature = "rust1", since = "1.0.0")]
+
+use crate::fs;
+use crate::io;
+use crate::os::raw;
+use crate::sys;
+use crate::sys_common::{AsInner, FromInner, IntoInner};
+
+/// Raw file descriptors.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub type RawFd = raw::c_int;
+
+/// A trait to extract the raw unix file descriptor from an underlying
+/// object.
+///
+/// This is only available on unix platforms and must be imported in order
+/// to call the method. Windows platforms have a corresponding `AsRawHandle`
+/// and `AsRawSocket` set of traits.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub trait AsRawFd {
+ /// Extracts the raw file descriptor.
+ ///
+ /// This method does **not** pass ownership of the raw file descriptor
+ /// to the caller. The descriptor is only guaranteed to be valid while
+ /// the original object has not yet been destroyed.
+ ///
+ /// # Example
+ ///
+ /// ```no_run
+ /// use std::fs::File;
+ /// # use std::io;
+ /// use std::os::unix::io::{AsRawFd, RawFd};
+ ///
+ /// let mut f = File::open("foo.txt")?;
+ /// // Note that `raw_fd` is only valid as long as `f` exists.
+ /// let raw_fd: RawFd = f.as_raw_fd();
+ /// # Ok::<(), io::Error>(())
+ /// ```
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn as_raw_fd(&self) -> RawFd;
+}
+
+/// A trait to express the ability to construct an object from a raw file
+/// descriptor.
+#[stable(feature = "from_raw_os", since = "1.1.0")]
+pub trait FromRawFd {
+ /// Constructs a new instance of `Self` from the given raw file
+ /// descriptor.
+ ///
+ /// This function **consumes ownership** of the specified file
+ /// descriptor. The returned object will take responsibility for closing
+ /// it when the object goes out of scope.
+ ///
+ /// This function is also unsafe as the primitives currently returned
+ /// have the contract that they are the sole owner of the file
+ /// descriptor they are wrapping. Usage of this function could
+ /// accidentally allow violating this contract which can cause memory
+ /// unsafety in code that relies on it being true.
+ ///
+ /// # Example
+ ///
+ /// ```no_run
+ /// use std::fs::File;
+ /// # use std::io;
+ /// use std::os::unix::io::{FromRawFd, IntoRawFd, RawFd};
+ ///
+ /// let f = File::open("foo.txt")?;
+ /// let raw_fd: RawFd = f.into_raw_fd();
+ /// // SAFETY: no other functions should call `from_raw_fd`, so there
+ /// // is only one owner for the file descriptor.
+ /// let f = unsafe { File::from_raw_fd(raw_fd) };
+ /// # Ok::<(), io::Error>(())
+ /// ```
+ #[stable(feature = "from_raw_os", since = "1.1.0")]
+ unsafe fn from_raw_fd(fd: RawFd) -> Self;
+}
+
+/// A trait to express the ability to consume an object and acquire ownership of
+/// its raw file descriptor.
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+pub trait IntoRawFd {
+ /// Consumes this object, returning the raw underlying file descriptor.
+ ///
+ /// This function **transfers ownership** of the underlying file descriptor
+ /// to the caller. Callers are then the unique owners of the file descriptor
+ /// and must close the descriptor once it's no longer needed.
+ ///
+ /// # Example
+ ///
+ /// ```no_run
+ /// use std::fs::File;
+ /// # use std::io;
+ /// use std::os::unix::io::{IntoRawFd, RawFd};
+ ///
+ /// let f = File::open("foo.txt")?;
+ /// let raw_fd: RawFd = f.into_raw_fd();
+ /// # Ok::<(), io::Error>(())
+ /// ```
+ #[stable(feature = "into_raw_os", since = "1.4.0")]
+ fn into_raw_fd(self) -> RawFd;
+}
+
+#[stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")]
+impl AsRawFd for RawFd {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ *self
+ }
+}
+#[stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")]
+impl IntoRawFd for RawFd {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self
+ }
+}
+#[stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")]
+impl FromRawFd for RawFd {
+ #[inline]
+ unsafe fn from_raw_fd(fd: RawFd) -> RawFd {
+ fd
+ }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl AsRawFd for fs::File {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ self.as_inner().fd().raw()
+ }
+}
+#[stable(feature = "from_raw_os", since = "1.1.0")]
+impl FromRawFd for fs::File {
+ #[inline]
+ unsafe fn from_raw_fd(fd: RawFd) -> fs::File {
+ fs::File::from_inner(sys::fs::File::from_inner(fd))
+ }
+}
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+impl IntoRawFd for fs::File {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self.into_inner().into_fd().into_raw()
+ }
+}
+
+#[stable(feature = "asraw_stdio", since = "1.21.0")]
+impl AsRawFd for io::Stdin {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ libc::STDIN_FILENO
+ }
+}
+
+#[stable(feature = "asraw_stdio", since = "1.21.0")]
+impl AsRawFd for io::Stdout {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ libc::STDOUT_FILENO
+ }
+}
+
+#[stable(feature = "asraw_stdio", since = "1.21.0")]
+impl AsRawFd for io::Stderr {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ libc::STDERR_FILENO
+ }
+}
+
+#[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
+impl<'a> AsRawFd for io::StdinLock<'a> {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ libc::STDIN_FILENO
+ }
+}
+
+#[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
+impl<'a> AsRawFd for io::StdoutLock<'a> {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ libc::STDOUT_FILENO
+ }
+}
+
+#[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
+impl<'a> AsRawFd for io::StderrLock<'a> {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ libc::STDERR_FILENO
+ }
+}
--- /dev/null
+//! Platform-specific extensions to `std` for Unix platforms.
+//!
+//! Provides access to platform-level information on Unix platforms, and
+//! exposes Unix-specific functions that would otherwise be inappropriate as
+//! part of the core `std` library.
+//!
+//! It exposes more ways to deal with platform-specific strings (`OsStr`,
+//! `OsString`), allows to set permissions more granularly, extract low-level
+//! file descriptors from files and sockets, and has platform-specific helpers
+//! for spawning processes.
+//!
+//! # Examples
+//!
+//! ```no_run
+//! use std::fs::File;
+//! use std::os::unix::prelude::*;
+//!
+//! fn main() -> std::io::Result<()> {
+//! let f = File::create("foo.txt")?;
+//! let fd = f.as_raw_fd();
+//!
+//! // use fd with native unix bindings
+//!
+//! Ok(())
+//! }
+//! ```
+
+#![stable(feature = "rust1", since = "1.0.0")]
+#![doc(cfg(unix))]
+
+// Use linux as the default platform when documenting on other platforms like Windows
+#[cfg(doc)]
+use crate::os::linux as platform;
+
+#[cfg(not(doc))]
+mod platform {
+ #[cfg(target_os = "android")]
+ pub use crate::os::android::*;
+ #[cfg(target_os = "dragonfly")]
+ pub use crate::os::dragonfly::*;
+ #[cfg(target_os = "emscripten")]
+ pub use crate::os::emscripten::*;
+ #[cfg(target_os = "freebsd")]
+ pub use crate::os::freebsd::*;
+ #[cfg(target_os = "fuchsia")]
+ pub use crate::os::fuchsia::*;
+ #[cfg(target_os = "haiku")]
+ pub use crate::os::haiku::*;
+ #[cfg(target_os = "illumos")]
+ pub use crate::os::illumos::*;
+ #[cfg(target_os = "ios")]
+ pub use crate::os::ios::*;
+ #[cfg(any(target_os = "linux", target_os = "l4re"))]
+ pub use crate::os::linux::*;
+ #[cfg(target_os = "macos")]
+ pub use crate::os::macos::*;
+ #[cfg(target_os = "netbsd")]
+ pub use crate::os::netbsd::*;
+ #[cfg(target_os = "openbsd")]
+ pub use crate::os::openbsd::*;
+ #[cfg(target_os = "redox")]
+ pub use crate::os::redox::*;
+ #[cfg(target_os = "solaris")]
+ pub use crate::os::solaris::*;
+ #[cfg(target_os = "vxworks")]
+ pub use crate::os::vxworks::*;
+}
+
+pub mod ffi;
+pub mod fs;
+pub mod io;
+pub mod net;
+pub mod process;
+pub mod raw;
+pub mod thread;
+
+#[unstable(feature = "peer_credentials_unix_socket", issue = "42839", reason = "unstable")]
+#[cfg(any(
+ target_os = "android",
+ target_os = "linux",
+ target_os = "dragonfly",
+ target_os = "freebsd",
+ target_os = "ios",
+ target_os = "macos",
+ target_os = "openbsd"
+))]
+pub mod ucred;
+
+/// A prelude for conveniently writing platform-specific code.
+///
+/// Includes all extension traits, and some important type definitions.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub mod prelude {
+ #[doc(no_inline)]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub use super::ffi::{OsStrExt, OsStringExt};
+ #[doc(no_inline)]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub use super::fs::DirEntryExt;
+ #[doc(no_inline)]
+ #[stable(feature = "file_offset", since = "1.15.0")]
+ pub use super::fs::FileExt;
+ #[doc(no_inline)]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub use super::fs::{FileTypeExt, MetadataExt, OpenOptionsExt, PermissionsExt};
+ #[doc(no_inline)]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub use super::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
+ #[doc(no_inline)]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub use super::process::{CommandExt, ExitStatusExt};
+ #[doc(no_inline)]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub use super::thread::JoinHandleExt;
+}
--- /dev/null
+use crate::ffi::OsStr;
+use crate::os::unix::ffi::OsStrExt;
+use crate::path::Path;
+use crate::sys::cvt;
+use crate::{ascii, fmt, io, iter, mem};
+
+// FIXME(#43348): Make libc adapt #[doc(cfg(...))] so we don't need these fake definitions here?
+#[cfg(not(unix))]
+#[allow(non_camel_case_types)]
+mod libc {
+ pub use libc::c_int;
+ pub type socklen_t = u32;
+ pub struct sockaddr;
+ #[derive(Clone)]
+ pub struct sockaddr_un;
+}
+
+fn sun_path_offset(addr: &libc::sockaddr_un) -> usize {
+ // Work with an actual instance of the type since using a null pointer is UB
+ let base = addr as *const _ as usize;
+ let path = &addr.sun_path as *const _ as usize;
+ path - base
+}
+
+pub(super) unsafe fn sockaddr_un(path: &Path) -> io::Result<(libc::sockaddr_un, libc::socklen_t)> {
+ let mut addr: libc::sockaddr_un = mem::zeroed();
+ addr.sun_family = libc::AF_UNIX as libc::sa_family_t;
+
+ let bytes = path.as_os_str().as_bytes();
+
+ if bytes.contains(&0) {
+ return Err(io::Error::new_const(
+ io::ErrorKind::InvalidInput,
+ &"paths may not contain interior null bytes",
+ ));
+ }
+
+ if bytes.len() >= addr.sun_path.len() {
+ return Err(io::Error::new_const(
+ io::ErrorKind::InvalidInput,
+ &"path must be shorter than SUN_LEN",
+ ));
+ }
+ for (dst, src) in iter::zip(&mut addr.sun_path, bytes) {
+ *dst = *src as libc::c_char;
+ }
+ // null byte for pathname addresses is already there because we zeroed the
+ // struct
+
+ let mut len = sun_path_offset(&addr) + bytes.len();
+ match bytes.get(0) {
+ Some(&0) | None => {}
+ Some(_) => len += 1,
+ }
+ Ok((addr, len as libc::socklen_t))
+}
+
+enum AddressKind<'a> {
+ Unnamed,
+ Pathname(&'a Path),
+ Abstract(&'a [u8]),
+}
+
+struct AsciiEscaped<'a>(&'a [u8]);
+
+impl<'a> fmt::Display for AsciiEscaped<'a> {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(fmt, "\"")?;
+ for byte in self.0.iter().cloned().flat_map(ascii::escape_default) {
+ write!(fmt, "{}", byte as char)?;
+ }
+ write!(fmt, "\"")
+ }
+}
+
+/// An address associated with a Unix socket.
+///
+/// # Examples
+///
+/// ```
+/// use std::os::unix::net::UnixListener;
+///
+/// let socket = match UnixListener::bind("/tmp/sock") {
+/// Ok(sock) => sock,
+/// Err(e) => {
+/// println!("Couldn't bind: {:?}", e);
+/// return
+/// }
+/// };
+/// let addr = socket.local_addr().expect("Couldn't get local address");
+/// ```
+#[derive(Clone)]
+#[stable(feature = "unix_socket", since = "1.10.0")]
+pub struct SocketAddr {
+ addr: libc::sockaddr_un,
+ len: libc::socklen_t,
+}
+
+impl SocketAddr {
+ pub(super) fn new<F>(f: F) -> io::Result<SocketAddr>
+ where
+ F: FnOnce(*mut libc::sockaddr, *mut libc::socklen_t) -> libc::c_int,
+ {
+ unsafe {
+ let mut addr: libc::sockaddr_un = mem::zeroed();
+ let mut len = mem::size_of::<libc::sockaddr_un>() as libc::socklen_t;
+ cvt(f(&mut addr as *mut _ as *mut _, &mut len))?;
+ SocketAddr::from_parts(addr, len)
+ }
+ }
+
+ pub(super) fn from_parts(
+ addr: libc::sockaddr_un,
+ mut len: libc::socklen_t,
+ ) -> io::Result<SocketAddr> {
+ if len == 0 {
+ // When there is a datagram from unnamed unix socket
+ // linux returns zero bytes of address
+ len = sun_path_offset(&addr) as libc::socklen_t; // i.e., zero-length address
+ } else if addr.sun_family != libc::AF_UNIX as libc::sa_family_t {
+ return Err(io::Error::new_const(
+ io::ErrorKind::InvalidInput,
+ &"file descriptor did not correspond to a Unix socket",
+ ));
+ }
+
+ Ok(SocketAddr { addr, len })
+ }
+
+ /// Returns `true` if the address is unnamed.
+ ///
+ /// # Examples
+ ///
+ /// A named address:
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixListener;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixListener::bind("/tmp/sock")?;
+ /// let addr = socket.local_addr().expect("Couldn't get local address");
+ /// assert_eq!(addr.is_unnamed(), false);
+ /// Ok(())
+ /// }
+ /// ```
+ ///
+ /// An unnamed address:
+ ///
+ /// ```
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixDatagram::unbound()?;
+ /// let addr = socket.local_addr().expect("Couldn't get local address");
+ /// assert_eq!(addr.is_unnamed(), true);
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn is_unnamed(&self) -> bool {
+ if let AddressKind::Unnamed = self.address() { true } else { false }
+ }
+
+ /// Returns the contents of this address if it is a `pathname` address.
+ ///
+ /// # Examples
+ ///
+ /// With a pathname:
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixListener;
+ /// use std::path::Path;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixListener::bind("/tmp/sock")?;
+ /// let addr = socket.local_addr().expect("Couldn't get local address");
+ /// assert_eq!(addr.as_pathname(), Some(Path::new("/tmp/sock")));
+ /// Ok(())
+ /// }
+ /// ```
+ ///
+ /// Without a pathname:
+ ///
+ /// ```
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixDatagram::unbound()?;
+ /// let addr = socket.local_addr().expect("Couldn't get local address");
+ /// assert_eq!(addr.as_pathname(), None);
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn as_pathname(&self) -> Option<&Path> {
+ if let AddressKind::Pathname(path) = self.address() { Some(path) } else { None }
+ }
+
+ fn address(&self) -> AddressKind<'_> {
+ let len = self.len as usize - sun_path_offset(&self.addr);
+ let path = unsafe { mem::transmute::<&[libc::c_char], &[u8]>(&self.addr.sun_path) };
+
+ // macOS seems to return a len of 16 and a zeroed sun_path for unnamed addresses
+ if len == 0
+ || (cfg!(not(any(target_os = "linux", target_os = "android")))
+ && self.addr.sun_path[0] == 0)
+ {
+ AddressKind::Unnamed
+ } else if self.addr.sun_path[0] == 0 {
+ AddressKind::Abstract(&path[1..len])
+ } else {
+ AddressKind::Pathname(OsStr::from_bytes(&path[..len - 1]).as_ref())
+ }
+ }
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl fmt::Debug for SocketAddr {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self.address() {
+ AddressKind::Unnamed => write!(fmt, "(unnamed)"),
+ AddressKind::Abstract(name) => write!(fmt, "{} (abstract)", AsciiEscaped(name)),
+ AddressKind::Pathname(path) => write!(fmt, "{:?} (pathname)", path),
+ }
+ }
+}
--- /dev/null
+use super::{sockaddr_un, SocketAddr};
+use crate::convert::TryFrom;
+use crate::io::{self, IoSlice, IoSliceMut};
+use crate::marker::PhantomData;
+use crate::mem::{size_of, zeroed};
+use crate::os::unix::io::RawFd;
+use crate::path::Path;
+use crate::ptr::{eq, read_unaligned};
+use crate::slice::from_raw_parts;
+use crate::sys::net::Socket;
+
+// FIXME(#43348): Make libc adapt #[doc(cfg(...))] so we don't need these fake definitions here?
+#[cfg(all(doc, not(target_os = "linux"), not(target_os = "android")))]
+#[allow(non_camel_case_types)]
+mod libc {
+ pub use libc::c_int;
+ pub struct ucred;
+ pub struct cmsghdr;
+ pub type pid_t = i32;
+ pub type gid_t = u32;
+ pub type uid_t = u32;
+}
+
+pub(super) fn recv_vectored_with_ancillary_from(
+ socket: &Socket,
+ bufs: &mut [IoSliceMut<'_>],
+ ancillary: &mut SocketAncillary<'_>,
+) -> io::Result<(usize, bool, io::Result<SocketAddr>)> {
+ unsafe {
+ let mut msg_name: libc::sockaddr_un = zeroed();
+ let mut msg: libc::msghdr = zeroed();
+ msg.msg_name = &mut msg_name as *mut _ as *mut _;
+ msg.msg_namelen = size_of::<libc::sockaddr_un>() as libc::socklen_t;
+ msg.msg_iov = bufs.as_mut_ptr().cast();
+ cfg_if::cfg_if! {
+ if #[cfg(any(target_os = "android", all(target_os = "linux", target_env = "gnu")))] {
+ msg.msg_iovlen = bufs.len() as libc::size_t;
+ msg.msg_controllen = ancillary.buffer.len() as libc::size_t;
+ } else if #[cfg(any(
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ all(target_os = "linux", target_env = "musl",),
+ target_os = "macos",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ ))] {
+ msg.msg_iovlen = bufs.len() as libc::c_int;
+ msg.msg_controllen = ancillary.buffer.len() as libc::socklen_t;
+ }
+ }
+ // macos requires that the control pointer is null when the len is 0.
+ if msg.msg_controllen > 0 {
+ msg.msg_control = ancillary.buffer.as_mut_ptr().cast();
+ }
+
+ let count = socket.recv_msg(&mut msg)?;
+
+ ancillary.length = msg.msg_controllen as usize;
+ ancillary.truncated = msg.msg_flags & libc::MSG_CTRUNC == libc::MSG_CTRUNC;
+
+ let truncated = msg.msg_flags & libc::MSG_TRUNC == libc::MSG_TRUNC;
+ let addr = SocketAddr::from_parts(msg_name, msg.msg_namelen);
+
+ Ok((count, truncated, addr))
+ }
+}
+
+pub(super) fn send_vectored_with_ancillary_to(
+ socket: &Socket,
+ path: Option<&Path>,
+ bufs: &[IoSlice<'_>],
+ ancillary: &mut SocketAncillary<'_>,
+) -> io::Result<usize> {
+ unsafe {
+ let (mut msg_name, msg_namelen) =
+ if let Some(path) = path { sockaddr_un(path)? } else { (zeroed(), 0) };
+
+ let mut msg: libc::msghdr = zeroed();
+ msg.msg_name = &mut msg_name as *mut _ as *mut _;
+ msg.msg_namelen = msg_namelen;
+ msg.msg_iov = bufs.as_ptr() as *mut _;
+ cfg_if::cfg_if! {
+ if #[cfg(any(target_os = "android", all(target_os = "linux", target_env = "gnu")))] {
+ msg.msg_iovlen = bufs.len() as libc::size_t;
+ msg.msg_controllen = ancillary.length as libc::size_t;
+ } else if #[cfg(any(
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ all(target_os = "linux", target_env = "musl",),
+ target_os = "macos",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ ))] {
+ msg.msg_iovlen = bufs.len() as libc::c_int;
+ msg.msg_controllen = ancillary.length as libc::socklen_t;
+ }
+ }
+ // macos requires that the control pointer is null when the len is 0.
+ if msg.msg_controllen > 0 {
+ msg.msg_control = ancillary.buffer.as_mut_ptr().cast();
+ }
+
+ ancillary.truncated = false;
+
+ socket.send_msg(&mut msg)
+ }
+}
+
+fn add_to_ancillary_data<T>(
+ buffer: &mut [u8],
+ length: &mut usize,
+ source: &[T],
+ cmsg_level: libc::c_int,
+ cmsg_type: libc::c_int,
+) -> bool {
+ let source_len = if let Some(source_len) = source.len().checked_mul(size_of::<T>()) {
+ if let Ok(source_len) = u32::try_from(source_len) {
+ source_len
+ } else {
+ return false;
+ }
+ } else {
+ return false;
+ };
+
+ unsafe {
+ let additional_space = libc::CMSG_SPACE(source_len) as usize;
+
+ let new_length = if let Some(new_length) = additional_space.checked_add(*length) {
+ new_length
+ } else {
+ return false;
+ };
+
+ if new_length > buffer.len() {
+ return false;
+ }
+
+ buffer[*length..new_length].fill(0);
+
+ *length = new_length;
+
+ let mut msg: libc::msghdr = zeroed();
+ msg.msg_control = buffer.as_mut_ptr().cast();
+ cfg_if::cfg_if! {
+ if #[cfg(any(target_os = "android", all(target_os = "linux", target_env = "gnu")))] {
+ msg.msg_controllen = *length as libc::size_t;
+ } else if #[cfg(any(
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ all(target_os = "linux", target_env = "musl",),
+ target_os = "macos",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ ))] {
+ msg.msg_controllen = *length as libc::socklen_t;
+ }
+ }
+
+ let mut cmsg = libc::CMSG_FIRSTHDR(&msg);
+ let mut previous_cmsg = cmsg;
+ while !cmsg.is_null() {
+ previous_cmsg = cmsg;
+ cmsg = libc::CMSG_NXTHDR(&msg, cmsg);
+
+ // Most operating systems, but not Linux or emscripten, return the previous pointer
+ // when its length is zero. Therefore, check if the previous pointer is the same as
+ // the current one.
+ if eq(cmsg, previous_cmsg) {
+ break;
+ }
+ }
+
+ if previous_cmsg.is_null() {
+ return false;
+ }
+
+ (*previous_cmsg).cmsg_level = cmsg_level;
+ (*previous_cmsg).cmsg_type = cmsg_type;
+ cfg_if::cfg_if! {
+ if #[cfg(any(target_os = "android", all(target_os = "linux", target_env = "gnu")))] {
+ (*previous_cmsg).cmsg_len = libc::CMSG_LEN(source_len) as libc::size_t;
+ } else if #[cfg(any(
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ all(target_os = "linux", target_env = "musl",),
+ target_os = "macos",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ ))] {
+ (*previous_cmsg).cmsg_len = libc::CMSG_LEN(source_len) as libc::socklen_t;
+ }
+ }
+
+ let data = libc::CMSG_DATA(previous_cmsg).cast();
+
+ libc::memcpy(data, source.as_ptr().cast(), source_len as usize);
+ }
+ true
+}
+
+struct AncillaryDataIter<'a, T> {
+ data: &'a [u8],
+ phantom: PhantomData<T>,
+}
+
+impl<'a, T> AncillaryDataIter<'a, T> {
+ /// Create `AncillaryDataIter` struct to iterate through the data unit in the control message.
+ ///
+ /// # Safety
+ ///
+ /// `data` must contain a valid control message.
+ unsafe fn new(data: &'a [u8]) -> AncillaryDataIter<'a, T> {
+ AncillaryDataIter { data, phantom: PhantomData }
+ }
+}
+
+impl<'a, T> Iterator for AncillaryDataIter<'a, T> {
+ type Item = T;
+
+ fn next(&mut self) -> Option<T> {
+ if size_of::<T>() <= self.data.len() {
+ unsafe {
+ let unit = read_unaligned(self.data.as_ptr().cast());
+ self.data = &self.data[size_of::<T>()..];
+ Some(unit)
+ }
+ } else {
+ None
+ }
+ }
+}
+
+/// Unix credential.
+#[cfg(any(doc, target_os = "android", target_os = "linux",))]
+#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+#[derive(Clone)]
+pub struct SocketCred(libc::ucred);
+
+#[cfg(any(doc, target_os = "android", target_os = "linux",))]
+impl SocketCred {
+ /// Create a Unix credential struct.
+ ///
+ /// PID, UID and GID is set to 0.
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn new() -> SocketCred {
+ SocketCred(libc::ucred { pid: 0, uid: 0, gid: 0 })
+ }
+
+ /// Set the PID.
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn set_pid(&mut self, pid: libc::pid_t) {
+ self.0.pid = pid;
+ }
+
+ /// Get the current PID.
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn get_pid(&self) -> libc::pid_t {
+ self.0.pid
+ }
+
+ /// Set the UID.
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn set_uid(&mut self, uid: libc::uid_t) {
+ self.0.uid = uid;
+ }
+
+ /// Get the current UID.
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn get_uid(&self) -> libc::uid_t {
+ self.0.uid
+ }
+
+ /// Set the GID.
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn set_gid(&mut self, gid: libc::gid_t) {
+ self.0.gid = gid;
+ }
+
+ /// Get the current GID.
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn get_gid(&self) -> libc::gid_t {
+ self.0.gid
+ }
+}
+
+/// This control message contains file descriptors.
+///
+/// The level is equal to `SOL_SOCKET` and the type is equal to `SCM_RIGHTS`.
+#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+pub struct ScmRights<'a>(AncillaryDataIter<'a, RawFd>);
+
+#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+impl<'a> Iterator for ScmRights<'a> {
+ type Item = RawFd;
+
+ fn next(&mut self) -> Option<RawFd> {
+ self.0.next()
+ }
+}
+
+/// This control message contains unix credentials.
+///
+/// The level is equal to `SOL_SOCKET` and the type is equal to `SCM_CREDENTIALS` or `SCM_CREDS`.
+#[cfg(any(doc, target_os = "android", target_os = "linux",))]
+#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+pub struct ScmCredentials<'a>(AncillaryDataIter<'a, libc::ucred>);
+
+#[cfg(any(doc, target_os = "android", target_os = "linux",))]
+#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+impl<'a> Iterator for ScmCredentials<'a> {
+ type Item = SocketCred;
+
+ fn next(&mut self) -> Option<SocketCred> {
+ Some(SocketCred(self.0.next()?))
+ }
+}
+
+/// The error type which is returned from parsing the type a control message.
+#[non_exhaustive]
+#[derive(Debug)]
+#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+pub enum AncillaryError {
+ Unknown { cmsg_level: i32, cmsg_type: i32 },
+}
+
+/// This enum represent one control message of variable type.
+#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+pub enum AncillaryData<'a> {
+ ScmRights(ScmRights<'a>),
+ #[cfg(any(doc, target_os = "android", target_os = "linux",))]
+ ScmCredentials(ScmCredentials<'a>),
+}
+
+impl<'a> AncillaryData<'a> {
+ /// Create a `AncillaryData::ScmRights` variant.
+ ///
+ /// # Safety
+ ///
+ /// `data` must contain a valid control message and the control message must be type of
+ /// `SOL_SOCKET` and level of `SCM_RIGHTS`.
+ unsafe fn as_rights(data: &'a [u8]) -> Self {
+ let ancillary_data_iter = AncillaryDataIter::new(data);
+ let scm_rights = ScmRights(ancillary_data_iter);
+ AncillaryData::ScmRights(scm_rights)
+ }
+
+ /// Create a `AncillaryData::ScmCredentials` variant.
+ ///
+ /// # Safety
+ ///
+ /// `data` must contain a valid control message and the control message must be type of
+ /// `SOL_SOCKET` and level of `SCM_CREDENTIALS` or `SCM_CREDENTIALS`.
+ #[cfg(any(doc, target_os = "android", target_os = "linux",))]
+ unsafe fn as_credentials(data: &'a [u8]) -> Self {
+ let ancillary_data_iter = AncillaryDataIter::new(data);
+ let scm_credentials = ScmCredentials(ancillary_data_iter);
+ AncillaryData::ScmCredentials(scm_credentials)
+ }
+
+ fn try_from_cmsghdr(cmsg: &'a libc::cmsghdr) -> Result<Self, AncillaryError> {
+ unsafe {
+ cfg_if::cfg_if! {
+ if #[cfg(any(
+ target_os = "android",
+ all(target_os = "linux", target_env = "gnu"),
+ all(target_os = "linux", target_env = "uclibc"),
+ ))] {
+ let cmsg_len_zero = libc::CMSG_LEN(0) as libc::size_t;
+ } else if #[cfg(any(
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ all(target_os = "linux", target_env = "musl",),
+ target_os = "macos",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ ))] {
+ let cmsg_len_zero = libc::CMSG_LEN(0) as libc::socklen_t;
+ }
+ }
+ let data_len = (*cmsg).cmsg_len - cmsg_len_zero;
+ let data = libc::CMSG_DATA(cmsg).cast();
+ let data = from_raw_parts(data, data_len as usize);
+
+ match (*cmsg).cmsg_level {
+ libc::SOL_SOCKET => match (*cmsg).cmsg_type {
+ libc::SCM_RIGHTS => Ok(AncillaryData::as_rights(data)),
+ #[cfg(any(target_os = "android", target_os = "linux",))]
+ libc::SCM_CREDENTIALS => Ok(AncillaryData::as_credentials(data)),
+ cmsg_type => {
+ Err(AncillaryError::Unknown { cmsg_level: libc::SOL_SOCKET, cmsg_type })
+ }
+ },
+ cmsg_level => {
+ Err(AncillaryError::Unknown { cmsg_level, cmsg_type: (*cmsg).cmsg_type })
+ }
+ }
+ }
+ }
+}
+
+/// This struct is used to iterate through the control messages.
+#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+pub struct Messages<'a> {
+ buffer: &'a [u8],
+ current: Option<&'a libc::cmsghdr>,
+}
+
+#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+impl<'a> Iterator for Messages<'a> {
+ type Item = Result<AncillaryData<'a>, AncillaryError>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ unsafe {
+ let mut msg: libc::msghdr = zeroed();
+ msg.msg_control = self.buffer.as_ptr() as *mut _;
+ cfg_if::cfg_if! {
+ if #[cfg(any(target_os = "android", all(target_os = "linux", target_env = "gnu")))] {
+ msg.msg_controllen = self.buffer.len() as libc::size_t;
+ } else if #[cfg(any(
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ all(target_os = "linux", target_env = "musl",),
+ target_os = "macos",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ ))] {
+ msg.msg_controllen = self.buffer.len() as libc::socklen_t;
+ }
+ }
+
+ let cmsg = if let Some(current) = self.current {
+ libc::CMSG_NXTHDR(&msg, current)
+ } else {
+ libc::CMSG_FIRSTHDR(&msg)
+ };
+
+ let cmsg = cmsg.as_ref()?;
+
+ // Most operating systems, but not Linux or emscripten, return the previous pointer
+ // when its length is zero. Therefore, check if the previous pointer is the same as
+ // the current one.
+ if let Some(current) = self.current {
+ if eq(current, cmsg) {
+ return None;
+ }
+ }
+
+ self.current = Some(cmsg);
+ let ancillary_result = AncillaryData::try_from_cmsghdr(cmsg);
+ Some(ancillary_result)
+ }
+ }
+}
+
+/// A Unix socket Ancillary data struct.
+///
+/// # Example
+/// ```no_run
+/// #![feature(unix_socket_ancillary_data)]
+/// use std::os::unix::net::{UnixStream, SocketAncillary, AncillaryData};
+/// use std::io::IoSliceMut;
+///
+/// fn main() -> std::io::Result<()> {
+/// let sock = UnixStream::connect("/tmp/sock")?;
+///
+/// let mut fds = [0; 8];
+/// let mut ancillary_buffer = [0; 128];
+/// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
+///
+/// let mut buf = [1; 8];
+/// let mut bufs = &mut [IoSliceMut::new(&mut buf[..])][..];
+/// sock.recv_vectored_with_ancillary(bufs, &mut ancillary)?;
+///
+/// for ancillary_result in ancillary.messages() {
+/// if let AncillaryData::ScmRights(scm_rights) = ancillary_result.unwrap() {
+/// for fd in scm_rights {
+/// println!("receive file descriptor: {}", fd);
+/// }
+/// }
+/// }
+/// Ok(())
+/// }
+/// ```
+#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+#[derive(Debug)]
+pub struct SocketAncillary<'a> {
+ buffer: &'a mut [u8],
+ length: usize,
+ truncated: bool,
+}
+
+impl<'a> SocketAncillary<'a> {
+ /// Create an ancillary data with the given buffer.
+ ///
+ /// # Example
+ ///
+ /// ```no_run
+ /// # #![allow(unused_mut)]
+ /// #![feature(unix_socket_ancillary_data)]
+ /// use std::os::unix::net::SocketAncillary;
+ /// let mut ancillary_buffer = [0; 128];
+ /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
+ /// ```
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn new(buffer: &'a mut [u8]) -> Self {
+ SocketAncillary { buffer, length: 0, truncated: false }
+ }
+
+ /// Returns the capacity of the buffer.
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn capacity(&self) -> usize {
+ self.buffer.len()
+ }
+
+ /// Returns `true` if the ancillary data is empty.
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn is_empty(&self) -> bool {
+ self.length == 0
+ }
+
+ /// Returns the number of used bytes.
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn len(&self) -> usize {
+ self.length
+ }
+
+ /// Returns the iterator of the control messages.
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn messages(&self) -> Messages<'_> {
+ Messages { buffer: &self.buffer[..self.length], current: None }
+ }
+
+ /// Is `true` if during a recv operation the ancillary was truncated.
+ ///
+ /// # Example
+ ///
+ /// ```no_run
+ /// #![feature(unix_socket_ancillary_data)]
+ /// use std::os::unix::net::{UnixStream, SocketAncillary};
+ /// use std::io::IoSliceMut;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixStream::connect("/tmp/sock")?;
+ ///
+ /// let mut ancillary_buffer = [0; 128];
+ /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
+ ///
+ /// let mut buf = [1; 8];
+ /// let mut bufs = &mut [IoSliceMut::new(&mut buf[..])][..];
+ /// sock.recv_vectored_with_ancillary(bufs, &mut ancillary)?;
+ ///
+ /// println!("Is truncated: {}", ancillary.truncated());
+ /// Ok(())
+ /// }
+ /// ```
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn truncated(&self) -> bool {
+ self.truncated
+ }
+
+ /// Add file descriptors to the ancillary data.
+ ///
+ /// The function returns `true` if there was enough space in the buffer.
+ /// If there was not enough space then no file descriptors was appended.
+ /// Technically, that means this operation adds a control message with the level `SOL_SOCKET`
+ /// and type `SCM_RIGHTS`.
+ ///
+ /// # Example
+ ///
+ /// ```no_run
+ /// #![feature(unix_socket_ancillary_data)]
+ /// use std::os::unix::net::{UnixStream, SocketAncillary};
+ /// use std::os::unix::io::AsRawFd;
+ /// use std::io::IoSlice;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixStream::connect("/tmp/sock")?;
+ ///
+ /// let mut ancillary_buffer = [0; 128];
+ /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
+ /// ancillary.add_fds(&[sock.as_raw_fd()][..]);
+ ///
+ /// let mut buf = [1; 8];
+ /// let mut bufs = &mut [IoSlice::new(&mut buf[..])][..];
+ /// sock.send_vectored_with_ancillary(bufs, &mut ancillary)?;
+ /// Ok(())
+ /// }
+ /// ```
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn add_fds(&mut self, fds: &[RawFd]) -> bool {
+ self.truncated = false;
+ add_to_ancillary_data(
+ &mut self.buffer,
+ &mut self.length,
+ fds,
+ libc::SOL_SOCKET,
+ libc::SCM_RIGHTS,
+ )
+ }
+
+ /// Add credentials to the ancillary data.
+ ///
+ /// The function returns `true` if there was enough space in the buffer.
+ /// If there was not enough space then no credentials was appended.
+ /// Technically, that means this operation adds a control message with the level `SOL_SOCKET`
+ /// and type `SCM_CREDENTIALS` or `SCM_CREDS`.
+ ///
+ #[cfg(any(doc, target_os = "android", target_os = "linux",))]
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn add_creds(&mut self, creds: &[SocketCred]) -> bool {
+ self.truncated = false;
+ add_to_ancillary_data(
+ &mut self.buffer,
+ &mut self.length,
+ creds,
+ libc::SOL_SOCKET,
+ libc::SCM_CREDENTIALS,
+ )
+ }
+
+ /// Clears the ancillary data, removing all values.
+ ///
+ /// # Example
+ ///
+ /// ```no_run
+ /// #![feature(unix_socket_ancillary_data)]
+ /// use std::os::unix::net::{UnixStream, SocketAncillary, AncillaryData};
+ /// use std::io::IoSliceMut;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixStream::connect("/tmp/sock")?;
+ ///
+ /// let mut fds1 = [0; 8];
+ /// let mut fds2 = [0; 8];
+ /// let mut ancillary_buffer = [0; 128];
+ /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
+ ///
+ /// let mut buf = [1; 8];
+ /// let mut bufs = &mut [IoSliceMut::new(&mut buf[..])][..];
+ ///
+ /// sock.recv_vectored_with_ancillary(bufs, &mut ancillary)?;
+ /// for ancillary_result in ancillary.messages() {
+ /// if let AncillaryData::ScmRights(scm_rights) = ancillary_result.unwrap() {
+ /// for fd in scm_rights {
+ /// println!("receive file descriptor: {}", fd);
+ /// }
+ /// }
+ /// }
+ ///
+ /// ancillary.clear();
+ ///
+ /// sock.recv_vectored_with_ancillary(bufs, &mut ancillary)?;
+ /// for ancillary_result in ancillary.messages() {
+ /// if let AncillaryData::ScmRights(scm_rights) = ancillary_result.unwrap() {
+ /// for fd in scm_rights {
+ /// println!("receive file descriptor: {}", fd);
+ /// }
+ /// }
+ /// }
+ /// Ok(())
+ /// }
+ /// ```
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn clear(&mut self) {
+ self.length = 0;
+ self.truncated = false;
+ }
+}
--- /dev/null
+#[cfg(any(
+ doc,
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+))]
+use super::{recv_vectored_with_ancillary_from, send_vectored_with_ancillary_to, SocketAncillary};
+use super::{sockaddr_un, SocketAddr};
+#[cfg(any(
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+))]
+use crate::io::{IoSlice, IoSliceMut};
+use crate::net::Shutdown;
+use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
+use crate::path::Path;
+use crate::sys::cvt;
+use crate::sys::net::Socket;
+use crate::sys_common::{AsInner, FromInner, IntoInner};
+use crate::time::Duration;
+use crate::{fmt, io};
+
+#[cfg(any(
+ target_os = "linux",
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "freebsd",
+ target_os = "openbsd",
+ target_os = "netbsd",
+ target_os = "haiku"
+))]
+use libc::MSG_NOSIGNAL;
+#[cfg(not(any(
+ target_os = "linux",
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "freebsd",
+ target_os = "openbsd",
+ target_os = "netbsd",
+ target_os = "haiku"
+)))]
+const MSG_NOSIGNAL: libc::c_int = 0x0;
+
+/// A Unix datagram socket.
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::os::unix::net::UnixDatagram;
+///
+/// fn main() -> std::io::Result<()> {
+/// let socket = UnixDatagram::bind("/path/to/my/socket")?;
+/// socket.send_to(b"hello world", "/path/to/other/socket")?;
+/// let mut buf = [0; 100];
+/// let (count, address) = socket.recv_from(&mut buf)?;
+/// println!("socket {:?} sent {:?}", address, &buf[..count]);
+/// Ok(())
+/// }
+/// ```
+#[stable(feature = "unix_socket", since = "1.10.0")]
+pub struct UnixDatagram(Socket);
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl fmt::Debug for UnixDatagram {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let mut builder = fmt.debug_struct("UnixDatagram");
+ builder.field("fd", self.0.as_inner());
+ if let Ok(addr) = self.local_addr() {
+ builder.field("local", &addr);
+ }
+ if let Ok(addr) = self.peer_addr() {
+ builder.field("peer", &addr);
+ }
+ builder.finish()
+ }
+}
+
+impl UnixDatagram {
+ /// Creates a Unix datagram socket bound to the given path.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// let sock = match UnixDatagram::bind("/path/to/the/socket") {
+ /// Ok(sock) => sock,
+ /// Err(e) => {
+ /// println!("Couldn't bind: {:?}", e);
+ /// return
+ /// }
+ /// };
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixDatagram> {
+ unsafe {
+ let socket = UnixDatagram::unbound()?;
+ let (addr, len) = sockaddr_un(path.as_ref())?;
+
+ cvt(libc::bind(*socket.0.as_inner(), &addr as *const _ as *const _, len as _))?;
+
+ Ok(socket)
+ }
+ }
+
+ /// Creates a Unix Datagram socket which is not bound to any address.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// let sock = match UnixDatagram::unbound() {
+ /// Ok(sock) => sock,
+ /// Err(e) => {
+ /// println!("Couldn't unbound: {:?}", e);
+ /// return
+ /// }
+ /// };
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn unbound() -> io::Result<UnixDatagram> {
+ let inner = Socket::new_raw(libc::AF_UNIX, libc::SOCK_DGRAM)?;
+ Ok(UnixDatagram(inner))
+ }
+
+ /// Creates an unnamed pair of connected sockets.
+ ///
+ /// Returns two `UnixDatagrams`s which are connected to each other.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// let (sock1, sock2) = match UnixDatagram::pair() {
+ /// Ok((sock1, sock2)) => (sock1, sock2),
+ /// Err(e) => {
+ /// println!("Couldn't unbound: {:?}", e);
+ /// return
+ /// }
+ /// };
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn pair() -> io::Result<(UnixDatagram, UnixDatagram)> {
+ let (i1, i2) = Socket::new_pair(libc::AF_UNIX, libc::SOCK_DGRAM)?;
+ Ok((UnixDatagram(i1), UnixDatagram(i2)))
+ }
+
+ /// Connects the socket to the specified address.
+ ///
+ /// The [`send`] method may be used to send data to the specified address.
+ /// [`recv`] and [`recv_from`] will only receive data from that address.
+ ///
+ /// [`send`]: UnixDatagram::send
+ /// [`recv`]: UnixDatagram::recv
+ /// [`recv_from`]: UnixDatagram::recv_from
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// match sock.connect("/path/to/the/socket") {
+ /// Ok(sock) => sock,
+ /// Err(e) => {
+ /// println!("Couldn't connect: {:?}", e);
+ /// return Err(e)
+ /// }
+ /// };
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn connect<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
+ unsafe {
+ let (addr, len) = sockaddr_un(path.as_ref())?;
+
+ cvt(libc::connect(*self.0.as_inner(), &addr as *const _ as *const _, len))?;
+ }
+ Ok(())
+ }
+
+ /// Creates a new independently owned handle to the underlying socket.
+ ///
+ /// The returned `UnixDatagram` is a reference to the same socket that this
+ /// object references. Both handles can be used to accept incoming
+ /// connections and options set on one side will affect the other.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::bind("/path/to/the/socket")?;
+ /// let sock_copy = sock.try_clone().expect("try_clone failed");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn try_clone(&self) -> io::Result<UnixDatagram> {
+ self.0.duplicate().map(UnixDatagram)
+ }
+
+ /// Returns the address of this socket.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::bind("/path/to/the/socket")?;
+ /// let addr = sock.local_addr().expect("Couldn't get local address");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn local_addr(&self) -> io::Result<SocketAddr> {
+ SocketAddr::new(|addr, len| unsafe { libc::getsockname(*self.0.as_inner(), addr, len) })
+ }
+
+ /// Returns the address of this socket's peer.
+ ///
+ /// The [`connect`] method will connect the socket to a peer.
+ ///
+ /// [`connect`]: UnixDatagram::connect
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// sock.connect("/path/to/the/socket")?;
+ ///
+ /// let addr = sock.peer_addr().expect("Couldn't get peer address");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn peer_addr(&self) -> io::Result<SocketAddr> {
+ SocketAddr::new(|addr, len| unsafe { libc::getpeername(*self.0.as_inner(), addr, len) })
+ }
+
+ fn recv_from_flags(
+ &self,
+ buf: &mut [u8],
+ flags: libc::c_int,
+ ) -> io::Result<(usize, SocketAddr)> {
+ let mut count = 0;
+ let addr = SocketAddr::new(|addr, len| unsafe {
+ count = libc::recvfrom(
+ *self.0.as_inner(),
+ buf.as_mut_ptr() as *mut _,
+ buf.len(),
+ flags,
+ addr,
+ len,
+ );
+ if count > 0 {
+ 1
+ } else if count == 0 {
+ 0
+ } else {
+ -1
+ }
+ })?;
+
+ Ok((count as usize, addr))
+ }
+
+ /// Receives data from the socket.
+ ///
+ /// On success, returns the number of bytes read and the address from
+ /// whence the data came.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// let mut buf = vec![0; 10];
+ /// let (size, sender) = sock.recv_from(buf.as_mut_slice())?;
+ /// println!("received {} bytes from {:?}", size, sender);
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
+ self.recv_from_flags(buf, 0)
+ }
+
+ /// Receives data from the socket.
+ ///
+ /// On success, returns the number of bytes read.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::bind("/path/to/the/socket")?;
+ /// let mut buf = vec![0; 10];
+ /// sock.recv(buf.as_mut_slice()).expect("recv function failed");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
+ self.0.read(buf)
+ }
+
+ /// Receives data and ancillary data from socket.
+ ///
+ /// On success, returns the number of bytes read, if the data was truncated and the address from whence the msg came.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// #![feature(unix_socket_ancillary_data)]
+ /// use std::os::unix::net::{UnixDatagram, SocketAncillary, AncillaryData};
+ /// use std::io::IoSliceMut;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// let mut buf1 = [1; 8];
+ /// let mut buf2 = [2; 16];
+ /// let mut buf3 = [3; 8];
+ /// let mut bufs = &mut [
+ /// IoSliceMut::new(&mut buf1),
+ /// IoSliceMut::new(&mut buf2),
+ /// IoSliceMut::new(&mut buf3),
+ /// ][..];
+ /// let mut fds = [0; 8];
+ /// let mut ancillary_buffer = [0; 128];
+ /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
+ /// let (size, _truncated, sender) = sock.recv_vectored_with_ancillary_from(bufs, &mut ancillary)?;
+ /// println!("received {}", size);
+ /// for ancillary_result in ancillary.messages() {
+ /// if let AncillaryData::ScmRights(scm_rights) = ancillary_result.unwrap() {
+ /// for fd in scm_rights {
+ /// println!("receive file descriptor: {}", fd);
+ /// }
+ /// }
+ /// }
+ /// Ok(())
+ /// }
+ /// ```
+ #[cfg(any(
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ ))]
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn recv_vectored_with_ancillary_from(
+ &self,
+ bufs: &mut [IoSliceMut<'_>],
+ ancillary: &mut SocketAncillary<'_>,
+ ) -> io::Result<(usize, bool, SocketAddr)> {
+ let (count, truncated, addr) = recv_vectored_with_ancillary_from(&self.0, bufs, ancillary)?;
+ let addr = addr?;
+
+ Ok((count, truncated, addr))
+ }
+
+ /// Receives data and ancillary data from socket.
+ ///
+ /// On success, returns the number of bytes read and if the data was truncated.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// #![feature(unix_socket_ancillary_data)]
+ /// use std::os::unix::net::{UnixDatagram, SocketAncillary, AncillaryData};
+ /// use std::io::IoSliceMut;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// let mut buf1 = [1; 8];
+ /// let mut buf2 = [2; 16];
+ /// let mut buf3 = [3; 8];
+ /// let mut bufs = &mut [
+ /// IoSliceMut::new(&mut buf1),
+ /// IoSliceMut::new(&mut buf2),
+ /// IoSliceMut::new(&mut buf3),
+ /// ][..];
+ /// let mut fds = [0; 8];
+ /// let mut ancillary_buffer = [0; 128];
+ /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
+ /// let (size, _truncated) = sock.recv_vectored_with_ancillary(bufs, &mut ancillary)?;
+ /// println!("received {}", size);
+ /// for ancillary_result in ancillary.messages() {
+ /// if let AncillaryData::ScmRights(scm_rights) = ancillary_result.unwrap() {
+ /// for fd in scm_rights {
+ /// println!("receive file descriptor: {}", fd);
+ /// }
+ /// }
+ /// }
+ /// Ok(())
+ /// }
+ /// ```
+ #[cfg(any(
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ ))]
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn recv_vectored_with_ancillary(
+ &self,
+ bufs: &mut [IoSliceMut<'_>],
+ ancillary: &mut SocketAncillary<'_>,
+ ) -> io::Result<(usize, bool)> {
+ let (count, truncated, addr) = recv_vectored_with_ancillary_from(&self.0, bufs, ancillary)?;
+ addr?;
+
+ Ok((count, truncated))
+ }
+
+ /// Sends data on the socket to the specified address.
+ ///
+ /// On success, returns the number of bytes written.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// sock.send_to(b"omelette au fromage", "/some/sock").expect("send_to function failed");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn send_to<P: AsRef<Path>>(&self, buf: &[u8], path: P) -> io::Result<usize> {
+ unsafe {
+ let (addr, len) = sockaddr_un(path.as_ref())?;
+
+ let count = cvt(libc::sendto(
+ *self.0.as_inner(),
+ buf.as_ptr() as *const _,
+ buf.len(),
+ MSG_NOSIGNAL,
+ &addr as *const _ as *const _,
+ len,
+ ))?;
+ Ok(count as usize)
+ }
+ }
+
+ /// Sends data on the socket to the socket's peer.
+ ///
+ /// The peer address may be set by the `connect` method, and this method
+ /// will return an error if the socket has not already been connected.
+ ///
+ /// On success, returns the number of bytes written.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// sock.connect("/some/sock").expect("Couldn't connect");
+ /// sock.send(b"omelette au fromage").expect("send_to function failed");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn send(&self, buf: &[u8]) -> io::Result<usize> {
+ self.0.write(buf)
+ }
+
+ /// Sends data and ancillary data on the socket to the specified address.
+ ///
+ /// On success, returns the number of bytes written.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// #![feature(unix_socket_ancillary_data)]
+ /// use std::os::unix::net::{UnixDatagram, SocketAncillary};
+ /// use std::io::IoSlice;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// let buf1 = [1; 8];
+ /// let buf2 = [2; 16];
+ /// let buf3 = [3; 8];
+ /// let bufs = &[
+ /// IoSlice::new(&buf1),
+ /// IoSlice::new(&buf2),
+ /// IoSlice::new(&buf3),
+ /// ][..];
+ /// let fds = [0, 1, 2];
+ /// let mut ancillary_buffer = [0; 128];
+ /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
+ /// ancillary.add_fds(&fds[..]);
+ /// sock.send_vectored_with_ancillary_to(bufs, &mut ancillary, "/some/sock")
+ /// .expect("send_vectored_with_ancillary_to function failed");
+ /// Ok(())
+ /// }
+ /// ```
+ #[cfg(any(
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ ))]
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn send_vectored_with_ancillary_to<P: AsRef<Path>>(
+ &self,
+ bufs: &[IoSlice<'_>],
+ ancillary: &mut SocketAncillary<'_>,
+ path: P,
+ ) -> io::Result<usize> {
+ send_vectored_with_ancillary_to(&self.0, Some(path.as_ref()), bufs, ancillary)
+ }
+
+ /// Sends data and ancillary data on the socket.
+ ///
+ /// On success, returns the number of bytes written.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// #![feature(unix_socket_ancillary_data)]
+ /// use std::os::unix::net::{UnixDatagram, SocketAncillary};
+ /// use std::io::IoSlice;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// let buf1 = [1; 8];
+ /// let buf2 = [2; 16];
+ /// let buf3 = [3; 8];
+ /// let bufs = &[
+ /// IoSlice::new(&buf1),
+ /// IoSlice::new(&buf2),
+ /// IoSlice::new(&buf3),
+ /// ][..];
+ /// let fds = [0, 1, 2];
+ /// let mut ancillary_buffer = [0; 128];
+ /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
+ /// ancillary.add_fds(&fds[..]);
+ /// sock.send_vectored_with_ancillary(bufs, &mut ancillary)
+ /// .expect("send_vectored_with_ancillary function failed");
+ /// Ok(())
+ /// }
+ /// ```
+ #[cfg(any(
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ ))]
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn send_vectored_with_ancillary(
+ &self,
+ bufs: &[IoSlice<'_>],
+ ancillary: &mut SocketAncillary<'_>,
+ ) -> io::Result<usize> {
+ send_vectored_with_ancillary_to(&self.0, None, bufs, ancillary)
+ }
+
+ /// Sets the read timeout for the socket.
+ ///
+ /// If the provided value is [`None`], then [`recv`] and [`recv_from`] calls will
+ /// block indefinitely. An [`Err`] is returned if the zero [`Duration`]
+ /// is passed to this method.
+ ///
+ /// [`recv`]: UnixDatagram::recv
+ /// [`recv_from`]: UnixDatagram::recv_from
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::os::unix::net::UnixDatagram;
+ /// use std::time::Duration;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// sock.set_read_timeout(Some(Duration::new(1, 0)))
+ /// .expect("set_read_timeout function failed");
+ /// Ok(())
+ /// }
+ /// ```
+ ///
+ /// An [`Err`] is returned if the zero [`Duration`] is passed to this
+ /// method:
+ ///
+ /// ```no_run
+ /// use std::io;
+ /// use std::os::unix::net::UnixDatagram;
+ /// use std::time::Duration;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixDatagram::unbound()?;
+ /// let result = socket.set_read_timeout(Some(Duration::new(0, 0)));
+ /// let err = result.unwrap_err();
+ /// assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn set_read_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
+ self.0.set_timeout(timeout, libc::SO_RCVTIMEO)
+ }
+
+ /// Sets the write timeout for the socket.
+ ///
+ /// If the provided value is [`None`], then [`send`] and [`send_to`] calls will
+ /// block indefinitely. An [`Err`] is returned if the zero [`Duration`] is passed to this
+ /// method.
+ ///
+ /// [`send`]: UnixDatagram::send
+ /// [`send_to`]: UnixDatagram::send_to
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::os::unix::net::UnixDatagram;
+ /// use std::time::Duration;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// sock.set_write_timeout(Some(Duration::new(1, 0)))
+ /// .expect("set_write_timeout function failed");
+ /// Ok(())
+ /// }
+ /// ```
+ ///
+ /// An [`Err`] is returned if the zero [`Duration`] is passed to this
+ /// method:
+ ///
+ /// ```no_run
+ /// use std::io;
+ /// use std::os::unix::net::UnixDatagram;
+ /// use std::time::Duration;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixDatagram::unbound()?;
+ /// let result = socket.set_write_timeout(Some(Duration::new(0, 0)));
+ /// let err = result.unwrap_err();
+ /// assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn set_write_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
+ self.0.set_timeout(timeout, libc::SO_SNDTIMEO)
+ }
+
+ /// Returns the read timeout of this socket.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::os::unix::net::UnixDatagram;
+ /// use std::time::Duration;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// sock.set_read_timeout(Some(Duration::new(1, 0)))
+ /// .expect("set_read_timeout function failed");
+ /// assert_eq!(sock.read_timeout()?, Some(Duration::new(1, 0)));
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
+ self.0.timeout(libc::SO_RCVTIMEO)
+ }
+
+ /// Returns the write timeout of this socket.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::os::unix::net::UnixDatagram;
+ /// use std::time::Duration;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// sock.set_write_timeout(Some(Duration::new(1, 0)))
+ /// .expect("set_write_timeout function failed");
+ /// assert_eq!(sock.write_timeout()?, Some(Duration::new(1, 0)));
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
+ self.0.timeout(libc::SO_SNDTIMEO)
+ }
+
+ /// Moves the socket into or out of nonblocking mode.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// sock.set_nonblocking(true).expect("set_nonblocking function failed");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
+ self.0.set_nonblocking(nonblocking)
+ }
+
+ /// Moves the socket to pass unix credentials as control message in [`SocketAncillary`].
+ ///
+ /// Set the socket option `SO_PASSCRED`.
+ ///
+ /// # Examples
+ ///
+ #[cfg_attr(any(target_os = "android", target_os = "linux"), doc = "```no_run")]
+ #[cfg_attr(not(any(target_os = "android", target_os = "linux")), doc = "```ignore")]
+ /// #![feature(unix_socket_ancillary_data)]
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// sock.set_passcred(true).expect("set_passcred function failed");
+ /// Ok(())
+ /// }
+ /// ```
+ #[cfg(any(doc, target_os = "android", target_os = "linux",))]
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn set_passcred(&self, passcred: bool) -> io::Result<()> {
+ self.0.set_passcred(passcred)
+ }
+
+ /// Get the current value of the socket for passing unix credentials in [`SocketAncillary`].
+ /// This value can be change by [`set_passcred`].
+ ///
+ /// Get the socket option `SO_PASSCRED`.
+ ///
+ /// [`set_passcred`]: UnixDatagram::set_passcred
+ #[cfg(any(doc, target_os = "android", target_os = "linux",))]
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn passcred(&self) -> io::Result<bool> {
+ self.0.passcred()
+ }
+
+ /// Returns the value of the `SO_ERROR` option.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// if let Ok(Some(err)) = sock.take_error() {
+ /// println!("Got error: {:?}", err);
+ /// }
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn take_error(&self) -> io::Result<Option<io::Error>> {
+ self.0.take_error()
+ }
+
+ /// Shut down the read, write, or both halves of this connection.
+ ///
+ /// This function will cause all pending and future I/O calls on the
+ /// specified portions to immediately return with an appropriate value
+ /// (see the documentation of [`Shutdown`]).
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixDatagram;
+ /// use std::net::Shutdown;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let sock = UnixDatagram::unbound()?;
+ /// sock.shutdown(Shutdown::Both).expect("shutdown function failed");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
+ self.0.shutdown(how)
+ }
+
+ /// Receives data on the socket from the remote address to which it is
+ /// connected, without removing that data from the queue. On success,
+ /// returns the number of bytes peeked.
+ ///
+ /// Successive calls return the same data. This is accomplished by passing
+ /// `MSG_PEEK` as a flag to the underlying `recv` system call.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// #![feature(unix_socket_peek)]
+ ///
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixDatagram::bind("/tmp/sock")?;
+ /// let mut buf = [0; 10];
+ /// let len = socket.peek(&mut buf).expect("peek failed");
+ /// Ok(())
+ /// }
+ /// ```
+ #[unstable(feature = "unix_socket_peek", issue = "76923")]
+ pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
+ self.0.peek(buf)
+ }
+
+ /// Receives a single datagram message on the socket, without removing it from the
+ /// queue. On success, returns the number of bytes read and the origin.
+ ///
+ /// The function must be called with valid byte array `buf` of sufficient size to
+ /// hold the message bytes. If a message is too long to fit in the supplied buffer,
+ /// excess bytes may be discarded.
+ ///
+ /// Successive calls return the same data. This is accomplished by passing
+ /// `MSG_PEEK` as a flag to the underlying `recvfrom` system call.
+ ///
+ /// Do not use this function to implement busy waiting, instead use `libc::poll` to
+ /// synchronize IO events on one or more sockets.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// #![feature(unix_socket_peek)]
+ ///
+ /// use std::os::unix::net::UnixDatagram;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixDatagram::bind("/tmp/sock")?;
+ /// let mut buf = [0; 10];
+ /// let (len, addr) = socket.peek_from(&mut buf).expect("peek failed");
+ /// Ok(())
+ /// }
+ /// ```
+ #[unstable(feature = "unix_socket_peek", issue = "76923")]
+ pub fn peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
+ self.recv_from_flags(buf, libc::MSG_PEEK)
+ }
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl AsRawFd for UnixDatagram {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ *self.0.as_inner()
+ }
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl FromRawFd for UnixDatagram {
+ #[inline]
+ unsafe fn from_raw_fd(fd: RawFd) -> UnixDatagram {
+ UnixDatagram(Socket::from_inner(fd))
+ }
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl IntoRawFd for UnixDatagram {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self.0.into_inner()
+ }
+}
--- /dev/null
+use super::{sockaddr_un, SocketAddr, UnixStream};
+use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
+use crate::path::Path;
+use crate::sys::cvt;
+use crate::sys::net::Socket;
+use crate::sys_common::{AsInner, FromInner, IntoInner};
+use crate::{fmt, io, mem};
+
+/// A structure representing a Unix domain socket server.
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::thread;
+/// use std::os::unix::net::{UnixStream, UnixListener};
+///
+/// fn handle_client(stream: UnixStream) {
+/// // ...
+/// }
+///
+/// fn main() -> std::io::Result<()> {
+/// let listener = UnixListener::bind("/path/to/the/socket")?;
+///
+/// // accept connections and process them, spawning a new thread for each one
+/// for stream in listener.incoming() {
+/// match stream {
+/// Ok(stream) => {
+/// /* connection succeeded */
+/// thread::spawn(|| handle_client(stream));
+/// }
+/// Err(err) => {
+/// /* connection failed */
+/// break;
+/// }
+/// }
+/// }
+/// Ok(())
+/// }
+/// ```
+#[stable(feature = "unix_socket", since = "1.10.0")]
+pub struct UnixListener(Socket);
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl fmt::Debug for UnixListener {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let mut builder = fmt.debug_struct("UnixListener");
+ builder.field("fd", self.0.as_inner());
+ if let Ok(addr) = self.local_addr() {
+ builder.field("local", &addr);
+ }
+ builder.finish()
+ }
+}
+
+impl UnixListener {
+ /// Creates a new `UnixListener` bound to the specified socket.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixListener;
+ ///
+ /// let listener = match UnixListener::bind("/path/to/the/socket") {
+ /// Ok(sock) => sock,
+ /// Err(e) => {
+ /// println!("Couldn't connect: {:?}", e);
+ /// return
+ /// }
+ /// };
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixListener> {
+ unsafe {
+ let inner = Socket::new_raw(libc::AF_UNIX, libc::SOCK_STREAM)?;
+ let (addr, len) = sockaddr_un(path.as_ref())?;
+
+ cvt(libc::bind(*inner.as_inner(), &addr as *const _ as *const _, len as _))?;
+ cvt(libc::listen(*inner.as_inner(), 128))?;
+
+ Ok(UnixListener(inner))
+ }
+ }
+
+ /// Accepts a new incoming connection to this listener.
+ ///
+ /// This function will block the calling thread until a new Unix connection
+ /// is established. When established, the corresponding [`UnixStream`] and
+ /// the remote peer's address will be returned.
+ ///
+ /// [`UnixStream`]: crate::os::unix::net::UnixStream
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixListener;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let listener = UnixListener::bind("/path/to/the/socket")?;
+ ///
+ /// match listener.accept() {
+ /// Ok((socket, addr)) => println!("Got a client: {:?}", addr),
+ /// Err(e) => println!("accept function failed: {:?}", e),
+ /// }
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn accept(&self) -> io::Result<(UnixStream, SocketAddr)> {
+ let mut storage: libc::sockaddr_un = unsafe { mem::zeroed() };
+ let mut len = mem::size_of_val(&storage) as libc::socklen_t;
+ let sock = self.0.accept(&mut storage as *mut _ as *mut _, &mut len)?;
+ let addr = SocketAddr::from_parts(storage, len)?;
+ Ok((UnixStream(sock), addr))
+ }
+
+ /// Creates a new independently owned handle to the underlying socket.
+ ///
+ /// The returned `UnixListener` is a reference to the same socket that this
+ /// object references. Both handles can be used to accept incoming
+ /// connections and options set on one listener will affect the other.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixListener;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let listener = UnixListener::bind("/path/to/the/socket")?;
+ /// let listener_copy = listener.try_clone().expect("try_clone failed");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn try_clone(&self) -> io::Result<UnixListener> {
+ self.0.duplicate().map(UnixListener)
+ }
+
+ /// Returns the local socket address of this listener.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixListener;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let listener = UnixListener::bind("/path/to/the/socket")?;
+ /// let addr = listener.local_addr().expect("Couldn't get local address");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn local_addr(&self) -> io::Result<SocketAddr> {
+ SocketAddr::new(|addr, len| unsafe { libc::getsockname(*self.0.as_inner(), addr, len) })
+ }
+
+ /// Moves the socket into or out of nonblocking mode.
+ ///
+ /// This will result in the `accept` operation becoming nonblocking,
+ /// i.e., immediately returning from their calls. If the IO operation is
+ /// successful, `Ok` is returned and no further action is required. If the
+ /// IO operation could not be completed and needs to be retried, an error
+ /// with kind [`io::ErrorKind::WouldBlock`] is returned.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixListener;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let listener = UnixListener::bind("/path/to/the/socket")?;
+ /// listener.set_nonblocking(true).expect("Couldn't set non blocking");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
+ self.0.set_nonblocking(nonblocking)
+ }
+
+ /// Returns the value of the `SO_ERROR` option.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixListener;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let listener = UnixListener::bind("/tmp/sock")?;
+ ///
+ /// if let Ok(Some(err)) = listener.take_error() {
+ /// println!("Got error: {:?}", err);
+ /// }
+ /// Ok(())
+ /// }
+ /// ```
+ ///
+ /// # Platform specific
+ /// On Redox this always returns `None`.
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn take_error(&self) -> io::Result<Option<io::Error>> {
+ self.0.take_error()
+ }
+
+ /// Returns an iterator over incoming connections.
+ ///
+ /// The iterator will never return [`None`] and will also not yield the
+ /// peer's [`SocketAddr`] structure.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::thread;
+ /// use std::os::unix::net::{UnixStream, UnixListener};
+ ///
+ /// fn handle_client(stream: UnixStream) {
+ /// // ...
+ /// }
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let listener = UnixListener::bind("/path/to/the/socket")?;
+ ///
+ /// for stream in listener.incoming() {
+ /// match stream {
+ /// Ok(stream) => {
+ /// thread::spawn(|| handle_client(stream));
+ /// }
+ /// Err(err) => {
+ /// break;
+ /// }
+ /// }
+ /// }
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn incoming(&self) -> Incoming<'_> {
+ Incoming { listener: self }
+ }
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl AsRawFd for UnixListener {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ *self.0.as_inner()
+ }
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl FromRawFd for UnixListener {
+ #[inline]
+ unsafe fn from_raw_fd(fd: RawFd) -> UnixListener {
+ UnixListener(Socket::from_inner(fd))
+ }
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl IntoRawFd for UnixListener {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self.0.into_inner()
+ }
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl<'a> IntoIterator for &'a UnixListener {
+ type Item = io::Result<UnixStream>;
+ type IntoIter = Incoming<'a>;
+
+ fn into_iter(self) -> Incoming<'a> {
+ self.incoming()
+ }
+}
+
+/// An iterator over incoming connections to a [`UnixListener`].
+///
+/// It will never return [`None`].
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::thread;
+/// use std::os::unix::net::{UnixStream, UnixListener};
+///
+/// fn handle_client(stream: UnixStream) {
+/// // ...
+/// }
+///
+/// fn main() -> std::io::Result<()> {
+/// let listener = UnixListener::bind("/path/to/the/socket")?;
+///
+/// for stream in listener.incoming() {
+/// match stream {
+/// Ok(stream) => {
+/// thread::spawn(|| handle_client(stream));
+/// }
+/// Err(err) => {
+/// break;
+/// }
+/// }
+/// }
+/// Ok(())
+/// }
+/// ```
+#[derive(Debug)]
+#[stable(feature = "unix_socket", since = "1.10.0")]
+pub struct Incoming<'a> {
+ listener: &'a UnixListener,
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl<'a> Iterator for Incoming<'a> {
+ type Item = io::Result<UnixStream>;
+
+ fn next(&mut self) -> Option<io::Result<UnixStream>> {
+ Some(self.listener.accept().map(|s| s.0))
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ (usize::MAX, None)
+ }
+}
--- /dev/null
+//! Unix-specific networking functionality
+
+#![stable(feature = "unix_socket", since = "1.10.0")]
+
+mod addr;
+#[doc(cfg(any(
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+)))]
+#[cfg(any(
+ doc,
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+))]
+mod ancillary;
+mod datagram;
+mod listener;
+mod raw_fd;
+mod stream;
+#[cfg(all(test, not(target_os = "emscripten")))]
+mod tests;
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+pub use self::addr::*;
+#[cfg(any(
+ doc,
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+))]
+#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+pub use self::ancillary::*;
+#[stable(feature = "unix_socket", since = "1.10.0")]
+pub use self::datagram::*;
+#[stable(feature = "unix_socket", since = "1.10.0")]
+pub use self::listener::*;
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use self::raw_fd::*;
+#[stable(feature = "unix_socket", since = "1.10.0")]
+pub use self::stream::*;
--- /dev/null
+use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
+use crate::sys_common::{self, AsInner, FromInner, IntoInner};
+use crate::{net, sys};
+
+macro_rules! impl_as_raw_fd {
+ ($($t:ident)*) => {$(
+ #[stable(feature = "rust1", since = "1.0.0")]
+ impl AsRawFd for net::$t {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ *self.as_inner().socket().as_inner()
+ }
+ }
+ )*};
+}
+impl_as_raw_fd! { TcpStream TcpListener UdpSocket }
+
+macro_rules! impl_from_raw_fd {
+ ($($t:ident)*) => {$(
+ #[stable(feature = "from_raw_os", since = "1.1.0")]
+ impl FromRawFd for net::$t {
+ #[inline]
+ unsafe fn from_raw_fd(fd: RawFd) -> net::$t {
+ let socket = sys::net::Socket::from_inner(fd);
+ net::$t::from_inner(sys_common::net::$t::from_inner(socket))
+ }
+ }
+ )*};
+}
+impl_from_raw_fd! { TcpStream TcpListener UdpSocket }
+
+macro_rules! impl_into_raw_fd {
+ ($($t:ident)*) => {$(
+ #[stable(feature = "into_raw_os", since = "1.4.0")]
+ impl IntoRawFd for net::$t {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self.into_inner().into_socket().into_inner()
+ }
+ }
+ )*};
+}
+impl_into_raw_fd! { TcpStream TcpListener UdpSocket }
--- /dev/null
+#[cfg(any(
+ doc,
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+))]
+use super::{recv_vectored_with_ancillary_from, send_vectored_with_ancillary_to, SocketAncillary};
+use super::{sockaddr_un, SocketAddr};
+use crate::fmt;
+use crate::io::{self, Initializer, IoSlice, IoSliceMut};
+use crate::net::Shutdown;
+use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
+#[cfg(any(
+ target_os = "android",
+ target_os = "linux",
+ target_os = "dragonfly",
+ target_os = "freebsd",
+ target_os = "ios",
+ target_os = "macos",
+ target_os = "openbsd"
+))]
+use crate::os::unix::ucred;
+use crate::path::Path;
+use crate::sys::cvt;
+use crate::sys::net::Socket;
+use crate::sys_common::{AsInner, FromInner, IntoInner};
+use crate::time::Duration;
+
+#[unstable(feature = "peer_credentials_unix_socket", issue = "42839", reason = "unstable")]
+#[cfg(any(
+ target_os = "android",
+ target_os = "linux",
+ target_os = "dragonfly",
+ target_os = "freebsd",
+ target_os = "ios",
+ target_os = "macos",
+ target_os = "openbsd"
+))]
+pub use ucred::UCred;
+
+/// A Unix stream socket.
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::os::unix::net::UnixStream;
+/// use std::io::prelude::*;
+///
+/// fn main() -> std::io::Result<()> {
+/// let mut stream = UnixStream::connect("/path/to/my/socket")?;
+/// stream.write_all(b"hello world")?;
+/// let mut response = String::new();
+/// stream.read_to_string(&mut response)?;
+/// println!("{}", response);
+/// Ok(())
+/// }
+/// ```
+#[stable(feature = "unix_socket", since = "1.10.0")]
+pub struct UnixStream(pub(super) Socket);
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl fmt::Debug for UnixStream {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let mut builder = fmt.debug_struct("UnixStream");
+ builder.field("fd", self.0.as_inner());
+ if let Ok(addr) = self.local_addr() {
+ builder.field("local", &addr);
+ }
+ if let Ok(addr) = self.peer_addr() {
+ builder.field("peer", &addr);
+ }
+ builder.finish()
+ }
+}
+
+impl UnixStream {
+ /// Connects to the socket named by `path`.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixStream;
+ ///
+ /// let socket = match UnixStream::connect("/tmp/sock") {
+ /// Ok(sock) => sock,
+ /// Err(e) => {
+ /// println!("Couldn't connect: {:?}", e);
+ /// return
+ /// }
+ /// };
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn connect<P: AsRef<Path>>(path: P) -> io::Result<UnixStream> {
+ unsafe {
+ let inner = Socket::new_raw(libc::AF_UNIX, libc::SOCK_STREAM)?;
+ let (addr, len) = sockaddr_un(path.as_ref())?;
+
+ cvt(libc::connect(*inner.as_inner(), &addr as *const _ as *const _, len))?;
+ Ok(UnixStream(inner))
+ }
+ }
+
+ /// Creates an unnamed pair of connected sockets.
+ ///
+ /// Returns two `UnixStream`s which are connected to each other.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixStream;
+ ///
+ /// let (sock1, sock2) = match UnixStream::pair() {
+ /// Ok((sock1, sock2)) => (sock1, sock2),
+ /// Err(e) => {
+ /// println!("Couldn't create a pair of sockets: {:?}", e);
+ /// return
+ /// }
+ /// };
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn pair() -> io::Result<(UnixStream, UnixStream)> {
+ let (i1, i2) = Socket::new_pair(libc::AF_UNIX, libc::SOCK_STREAM)?;
+ Ok((UnixStream(i1), UnixStream(i2)))
+ }
+
+ /// Creates a new independently owned handle to the underlying socket.
+ ///
+ /// The returned `UnixStream` is a reference to the same stream that this
+ /// object references. Both handles will read and write the same stream of
+ /// data, and options set on one stream will be propagated to the other
+ /// stream.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixStream;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// let sock_copy = socket.try_clone().expect("Couldn't clone socket");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn try_clone(&self) -> io::Result<UnixStream> {
+ self.0.duplicate().map(UnixStream)
+ }
+
+ /// Returns the socket address of the local half of this connection.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixStream;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// let addr = socket.local_addr().expect("Couldn't get local address");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn local_addr(&self) -> io::Result<SocketAddr> {
+ SocketAddr::new(|addr, len| unsafe { libc::getsockname(*self.0.as_inner(), addr, len) })
+ }
+
+ /// Returns the socket address of the remote half of this connection.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixStream;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// let addr = socket.peer_addr().expect("Couldn't get peer address");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn peer_addr(&self) -> io::Result<SocketAddr> {
+ SocketAddr::new(|addr, len| unsafe { libc::getpeername(*self.0.as_inner(), addr, len) })
+ }
+
+ /// Gets the peer credentials for this Unix domain socket.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// #![feature(peer_credentials_unix_socket)]
+ /// use std::os::unix::net::UnixStream;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// let peer_cred = socket.peer_cred().expect("Couldn't get peer credentials");
+ /// Ok(())
+ /// }
+ /// ```
+ #[unstable(feature = "peer_credentials_unix_socket", issue = "42839", reason = "unstable")]
+ #[cfg(any(
+ target_os = "android",
+ target_os = "linux",
+ target_os = "dragonfly",
+ target_os = "freebsd",
+ target_os = "ios",
+ target_os = "macos",
+ target_os = "openbsd"
+ ))]
+ pub fn peer_cred(&self) -> io::Result<UCred> {
+ ucred::peer_cred(self)
+ }
+
+ /// Sets the read timeout for the socket.
+ ///
+ /// If the provided value is [`None`], then [`read`] calls will block
+ /// indefinitely. An [`Err`] is returned if the zero [`Duration`] is passed to this
+ /// method.
+ ///
+ /// [`read`]: io::Read::read
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixStream;
+ /// use std::time::Duration;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// socket.set_read_timeout(Some(Duration::new(1, 0))).expect("Couldn't set read timeout");
+ /// Ok(())
+ /// }
+ /// ```
+ ///
+ /// An [`Err`] is returned if the zero [`Duration`] is passed to this
+ /// method:
+ ///
+ /// ```no_run
+ /// use std::io;
+ /// use std::os::unix::net::UnixStream;
+ /// use std::time::Duration;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// let result = socket.set_read_timeout(Some(Duration::new(0, 0)));
+ /// let err = result.unwrap_err();
+ /// assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn set_read_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
+ self.0.set_timeout(timeout, libc::SO_RCVTIMEO)
+ }
+
+ /// Sets the write timeout for the socket.
+ ///
+ /// If the provided value is [`None`], then [`write`] calls will block
+ /// indefinitely. An [`Err`] is returned if the zero [`Duration`] is
+ /// passed to this method.
+ ///
+ /// [`read`]: io::Read::read
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixStream;
+ /// use std::time::Duration;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// socket.set_write_timeout(Some(Duration::new(1, 0)))
+ /// .expect("Couldn't set write timeout");
+ /// Ok(())
+ /// }
+ /// ```
+ ///
+ /// An [`Err`] is returned if the zero [`Duration`] is passed to this
+ /// method:
+ ///
+ /// ```no_run
+ /// use std::io;
+ /// use std::net::UdpSocket;
+ /// use std::time::Duration;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UdpSocket::bind("127.0.0.1:34254")?;
+ /// let result = socket.set_write_timeout(Some(Duration::new(0, 0)));
+ /// let err = result.unwrap_err();
+ /// assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn set_write_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
+ self.0.set_timeout(timeout, libc::SO_SNDTIMEO)
+ }
+
+ /// Returns the read timeout of this socket.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixStream;
+ /// use std::time::Duration;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// socket.set_read_timeout(Some(Duration::new(1, 0))).expect("Couldn't set read timeout");
+ /// assert_eq!(socket.read_timeout()?, Some(Duration::new(1, 0)));
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
+ self.0.timeout(libc::SO_RCVTIMEO)
+ }
+
+ /// Returns the write timeout of this socket.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixStream;
+ /// use std::time::Duration;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// socket.set_write_timeout(Some(Duration::new(1, 0)))
+ /// .expect("Couldn't set write timeout");
+ /// assert_eq!(socket.write_timeout()?, Some(Duration::new(1, 0)));
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
+ self.0.timeout(libc::SO_SNDTIMEO)
+ }
+
+ /// Moves the socket into or out of nonblocking mode.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixStream;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// socket.set_nonblocking(true).expect("Couldn't set nonblocking");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
+ self.0.set_nonblocking(nonblocking)
+ }
+
+ /// Moves the socket to pass unix credentials as control message in [`SocketAncillary`].
+ ///
+ /// Set the socket option `SO_PASSCRED`.
+ ///
+ /// # Examples
+ ///
+ #[cfg_attr(any(target_os = "android", target_os = "linux"), doc = "```no_run")]
+ #[cfg_attr(not(any(target_os = "android", target_os = "linux")), doc = "```ignore")]
+ /// #![feature(unix_socket_ancillary_data)]
+ /// use std::os::unix::net::UnixStream;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// socket.set_passcred(true).expect("Couldn't set passcred");
+ /// Ok(())
+ /// }
+ /// ```
+ #[cfg(any(doc, target_os = "android", target_os = "linux",))]
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn set_passcred(&self, passcred: bool) -> io::Result<()> {
+ self.0.set_passcred(passcred)
+ }
+
+ /// Get the current value of the socket for passing unix credentials in [`SocketAncillary`].
+ /// This value can be change by [`set_passcred`].
+ ///
+ /// Get the socket option `SO_PASSCRED`.
+ ///
+ /// [`set_passcred`]: UnixStream::set_passcred
+ #[cfg(any(doc, target_os = "android", target_os = "linux",))]
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn passcred(&self) -> io::Result<bool> {
+ self.0.passcred()
+ }
+
+ /// Returns the value of the `SO_ERROR` option.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixStream;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// if let Ok(Some(err)) = socket.take_error() {
+ /// println!("Got error: {:?}", err);
+ /// }
+ /// Ok(())
+ /// }
+ /// ```
+ ///
+ /// # Platform specific
+ /// On Redox this always returns `None`.
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn take_error(&self) -> io::Result<Option<io::Error>> {
+ self.0.take_error()
+ }
+
+ /// Shuts down the read, write, or both halves of this connection.
+ ///
+ /// This function will cause all pending and future I/O calls on the
+ /// specified portions to immediately return with an appropriate value
+ /// (see the documentation of [`Shutdown`]).
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::os::unix::net::UnixStream;
+ /// use std::net::Shutdown;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// socket.shutdown(Shutdown::Both).expect("shutdown function failed");
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "unix_socket", since = "1.10.0")]
+ pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
+ self.0.shutdown(how)
+ }
+
+ /// Receives data on the socket from the remote address to which it is
+ /// connected, without removing that data from the queue. On success,
+ /// returns the number of bytes peeked.
+ ///
+ /// Successive calls return the same data. This is accomplished by passing
+ /// `MSG_PEEK` as a flag to the underlying `recv` system call.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// #![feature(unix_socket_peek)]
+ ///
+ /// use std::os::unix::net::UnixStream;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// let mut buf = [0; 10];
+ /// let len = socket.peek(&mut buf).expect("peek failed");
+ /// Ok(())
+ /// }
+ /// ```
+ #[unstable(feature = "unix_socket_peek", issue = "76923")]
+ pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
+ self.0.peek(buf)
+ }
+
+ /// Receives data and ancillary data from socket.
+ ///
+ /// On success, returns the number of bytes read.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// #![feature(unix_socket_ancillary_data)]
+ /// use std::os::unix::net::{UnixStream, SocketAncillary, AncillaryData};
+ /// use std::io::IoSliceMut;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// let mut buf1 = [1; 8];
+ /// let mut buf2 = [2; 16];
+ /// let mut buf3 = [3; 8];
+ /// let mut bufs = &mut [
+ /// IoSliceMut::new(&mut buf1),
+ /// IoSliceMut::new(&mut buf2),
+ /// IoSliceMut::new(&mut buf3),
+ /// ][..];
+ /// let mut fds = [0; 8];
+ /// let mut ancillary_buffer = [0; 128];
+ /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
+ /// let size = socket.recv_vectored_with_ancillary(bufs, &mut ancillary)?;
+ /// println!("received {}", size);
+ /// for ancillary_result in ancillary.messages() {
+ /// if let AncillaryData::ScmRights(scm_rights) = ancillary_result.unwrap() {
+ /// for fd in scm_rights {
+ /// println!("receive file descriptor: {}", fd);
+ /// }
+ /// }
+ /// }
+ /// Ok(())
+ /// }
+ /// ```
+ #[cfg(any(
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ ))]
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn recv_vectored_with_ancillary(
+ &self,
+ bufs: &mut [IoSliceMut<'_>],
+ ancillary: &mut SocketAncillary<'_>,
+ ) -> io::Result<usize> {
+ let (count, _, _) = recv_vectored_with_ancillary_from(&self.0, bufs, ancillary)?;
+
+ Ok(count)
+ }
+
+ /// Sends data and ancillary data on the socket.
+ ///
+ /// On success, returns the number of bytes written.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// #![feature(unix_socket_ancillary_data)]
+ /// use std::os::unix::net::{UnixStream, SocketAncillary};
+ /// use std::io::IoSlice;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let socket = UnixStream::connect("/tmp/sock")?;
+ /// let buf1 = [1; 8];
+ /// let buf2 = [2; 16];
+ /// let buf3 = [3; 8];
+ /// let bufs = &[
+ /// IoSlice::new(&buf1),
+ /// IoSlice::new(&buf2),
+ /// IoSlice::new(&buf3),
+ /// ][..];
+ /// let fds = [0, 1, 2];
+ /// let mut ancillary_buffer = [0; 128];
+ /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
+ /// ancillary.add_fds(&fds[..]);
+ /// socket.send_vectored_with_ancillary(bufs, &mut ancillary)
+ /// .expect("send_vectored_with_ancillary function failed");
+ /// Ok(())
+ /// }
+ /// ```
+ #[cfg(any(
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ ))]
+ #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+ pub fn send_vectored_with_ancillary(
+ &self,
+ bufs: &[IoSlice<'_>],
+ ancillary: &mut SocketAncillary<'_>,
+ ) -> io::Result<usize> {
+ send_vectored_with_ancillary_to(&self.0, None, bufs, ancillary)
+ }
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl io::Read for UnixStream {
+ fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+ io::Read::read(&mut &*self, buf)
+ }
+
+ fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+ io::Read::read_vectored(&mut &*self, bufs)
+ }
+
+ #[inline]
+ fn is_read_vectored(&self) -> bool {
+ io::Read::is_read_vectored(&&*self)
+ }
+
+ #[inline]
+ unsafe fn initializer(&self) -> Initializer {
+ Initializer::nop()
+ }
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl<'a> io::Read for &'a UnixStream {
+ fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+ self.0.read(buf)
+ }
+
+ fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
+ self.0.read_vectored(bufs)
+ }
+
+ #[inline]
+ fn is_read_vectored(&self) -> bool {
+ self.0.is_read_vectored()
+ }
+
+ #[inline]
+ unsafe fn initializer(&self) -> Initializer {
+ Initializer::nop()
+ }
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl io::Write for UnixStream {
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+ io::Write::write(&mut &*self, buf)
+ }
+
+ fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+ io::Write::write_vectored(&mut &*self, bufs)
+ }
+
+ #[inline]
+ fn is_write_vectored(&self) -> bool {
+ io::Write::is_write_vectored(&&*self)
+ }
+
+ fn flush(&mut self) -> io::Result<()> {
+ io::Write::flush(&mut &*self)
+ }
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl<'a> io::Write for &'a UnixStream {
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+ self.0.write(buf)
+ }
+
+ fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+ self.0.write_vectored(bufs)
+ }
+
+ #[inline]
+ fn is_write_vectored(&self) -> bool {
+ self.0.is_write_vectored()
+ }
+
+ fn flush(&mut self) -> io::Result<()> {
+ Ok(())
+ }
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl AsRawFd for UnixStream {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ *self.0.as_inner()
+ }
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl FromRawFd for UnixStream {
+ #[inline]
+ unsafe fn from_raw_fd(fd: RawFd) -> UnixStream {
+ UnixStream(Socket::from_inner(fd))
+ }
+}
+
+#[stable(feature = "unix_socket", since = "1.10.0")]
+impl IntoRawFd for UnixStream {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self.0.into_inner()
+ }
+}
--- /dev/null
+use super::*;
+use crate::io::prelude::*;
+use crate::io::{self, ErrorKind, IoSlice, IoSliceMut};
+#[cfg(any(
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+))]
+use crate::iter::FromIterator;
+#[cfg(any(
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+))]
+use crate::os::unix::io::AsRawFd;
+use crate::sys_common::io::test::tmpdir;
+use crate::thread;
+use crate::time::Duration;
+
+macro_rules! or_panic {
+ ($e:expr) => {
+ match $e {
+ Ok(e) => e,
+ Err(e) => panic!("{}", e),
+ }
+ };
+}
+
+#[test]
+fn basic() {
+ let dir = tmpdir();
+ let socket_path = dir.path().join("sock");
+ let msg1 = b"hello";
+ let msg2 = b"world!";
+
+ let listener = or_panic!(UnixListener::bind(&socket_path));
+ let thread = thread::spawn(move || {
+ let mut stream = or_panic!(listener.accept()).0;
+ let mut buf = [0; 5];
+ or_panic!(stream.read(&mut buf));
+ assert_eq!(&msg1[..], &buf[..]);
+ or_panic!(stream.write_all(msg2));
+ });
+
+ let mut stream = or_panic!(UnixStream::connect(&socket_path));
+ assert_eq!(Some(&*socket_path), stream.peer_addr().unwrap().as_pathname());
+ or_panic!(stream.write_all(msg1));
+ let mut buf = vec![];
+ or_panic!(stream.read_to_end(&mut buf));
+ assert_eq!(&msg2[..], &buf[..]);
+ drop(stream);
+
+ thread.join().unwrap();
+}
+
+#[test]
+fn vectored() {
+ let (mut s1, mut s2) = or_panic!(UnixStream::pair());
+
+ let len = or_panic!(s1.write_vectored(&[
+ IoSlice::new(b"hello"),
+ IoSlice::new(b" "),
+ IoSlice::new(b"world!")
+ ],));
+ assert_eq!(len, 12);
+
+ let mut buf1 = [0; 6];
+ let mut buf2 = [0; 7];
+ let len =
+ or_panic!(s2.read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],));
+ assert_eq!(len, 12);
+ assert_eq!(&buf1, b"hello ");
+ assert_eq!(&buf2, b"world!\0");
+}
+
+#[test]
+fn pair() {
+ let msg1 = b"hello";
+ let msg2 = b"world!";
+
+ let (mut s1, mut s2) = or_panic!(UnixStream::pair());
+ let thread = thread::spawn(move || {
+ // s1 must be moved in or the test will hang!
+ let mut buf = [0; 5];
+ or_panic!(s1.read(&mut buf));
+ assert_eq!(&msg1[..], &buf[..]);
+ or_panic!(s1.write_all(msg2));
+ });
+
+ or_panic!(s2.write_all(msg1));
+ let mut buf = vec![];
+ or_panic!(s2.read_to_end(&mut buf));
+ assert_eq!(&msg2[..], &buf[..]);
+ drop(s2);
+
+ thread.join().unwrap();
+}
+
+#[test]
+fn try_clone() {
+ let dir = tmpdir();
+ let socket_path = dir.path().join("sock");
+ let msg1 = b"hello";
+ let msg2 = b"world";
+
+ let listener = or_panic!(UnixListener::bind(&socket_path));
+ let thread = thread::spawn(move || {
+ let mut stream = or_panic!(listener.accept()).0;
+ or_panic!(stream.write_all(msg1));
+ or_panic!(stream.write_all(msg2));
+ });
+
+ let mut stream = or_panic!(UnixStream::connect(&socket_path));
+ let mut stream2 = or_panic!(stream.try_clone());
+
+ let mut buf = [0; 5];
+ or_panic!(stream.read(&mut buf));
+ assert_eq!(&msg1[..], &buf[..]);
+ or_panic!(stream2.read(&mut buf));
+ assert_eq!(&msg2[..], &buf[..]);
+
+ thread.join().unwrap();
+}
+
+#[test]
+fn iter() {
+ let dir = tmpdir();
+ let socket_path = dir.path().join("sock");
+
+ let listener = or_panic!(UnixListener::bind(&socket_path));
+ let thread = thread::spawn(move || {
+ for stream in listener.incoming().take(2) {
+ let mut stream = or_panic!(stream);
+ let mut buf = [0];
+ or_panic!(stream.read(&mut buf));
+ }
+ });
+
+ for _ in 0..2 {
+ let mut stream = or_panic!(UnixStream::connect(&socket_path));
+ or_panic!(stream.write_all(&[0]));
+ }
+
+ thread.join().unwrap();
+}
+
+#[test]
+fn long_path() {
+ let dir = tmpdir();
+ let socket_path = dir.path().join(
+ "asdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfa\
+ sasdfasdfasdasdfasdfasdfadfasdfasdfasdfasdfasdf",
+ );
+ match UnixStream::connect(&socket_path) {
+ Err(ref e) if e.kind() == io::ErrorKind::InvalidInput => {}
+ Err(e) => panic!("unexpected error {}", e),
+ Ok(_) => panic!("unexpected success"),
+ }
+
+ match UnixListener::bind(&socket_path) {
+ Err(ref e) if e.kind() == io::ErrorKind::InvalidInput => {}
+ Err(e) => panic!("unexpected error {}", e),
+ Ok(_) => panic!("unexpected success"),
+ }
+
+ match UnixDatagram::bind(&socket_path) {
+ Err(ref e) if e.kind() == io::ErrorKind::InvalidInput => {}
+ Err(e) => panic!("unexpected error {}", e),
+ Ok(_) => panic!("unexpected success"),
+ }
+}
+
+#[test]
+fn timeouts() {
+ let dir = tmpdir();
+ let socket_path = dir.path().join("sock");
+
+ let _listener = or_panic!(UnixListener::bind(&socket_path));
+
+ let stream = or_panic!(UnixStream::connect(&socket_path));
+ let dur = Duration::new(15410, 0);
+
+ assert_eq!(None, or_panic!(stream.read_timeout()));
+
+ or_panic!(stream.set_read_timeout(Some(dur)));
+ assert_eq!(Some(dur), or_panic!(stream.read_timeout()));
+
+ assert_eq!(None, or_panic!(stream.write_timeout()));
+
+ or_panic!(stream.set_write_timeout(Some(dur)));
+ assert_eq!(Some(dur), or_panic!(stream.write_timeout()));
+
+ or_panic!(stream.set_read_timeout(None));
+ assert_eq!(None, or_panic!(stream.read_timeout()));
+
+ or_panic!(stream.set_write_timeout(None));
+ assert_eq!(None, or_panic!(stream.write_timeout()));
+}
+
+#[test]
+fn test_read_timeout() {
+ let dir = tmpdir();
+ let socket_path = dir.path().join("sock");
+
+ let _listener = or_panic!(UnixListener::bind(&socket_path));
+
+ let mut stream = or_panic!(UnixStream::connect(&socket_path));
+ or_panic!(stream.set_read_timeout(Some(Duration::from_millis(1000))));
+
+ let mut buf = [0; 10];
+ let kind = stream.read_exact(&mut buf).err().expect("expected error").kind();
+ assert!(
+ kind == ErrorKind::WouldBlock || kind == ErrorKind::TimedOut,
+ "unexpected_error: {:?}",
+ kind
+ );
+}
+
+#[test]
+fn test_read_with_timeout() {
+ let dir = tmpdir();
+ let socket_path = dir.path().join("sock");
+
+ let listener = or_panic!(UnixListener::bind(&socket_path));
+
+ let mut stream = or_panic!(UnixStream::connect(&socket_path));
+ or_panic!(stream.set_read_timeout(Some(Duration::from_millis(1000))));
+
+ let mut other_end = or_panic!(listener.accept()).0;
+ or_panic!(other_end.write_all(b"hello world"));
+
+ let mut buf = [0; 11];
+ or_panic!(stream.read(&mut buf));
+ assert_eq!(b"hello world", &buf[..]);
+
+ let kind = stream.read_exact(&mut buf).err().expect("expected error").kind();
+ assert!(
+ kind == ErrorKind::WouldBlock || kind == ErrorKind::TimedOut,
+ "unexpected_error: {:?}",
+ kind
+ );
+}
+
+// Ensure the `set_read_timeout` and `set_write_timeout` calls return errors
+// when passed zero Durations
+#[test]
+fn test_unix_stream_timeout_zero_duration() {
+ let dir = tmpdir();
+ let socket_path = dir.path().join("sock");
+
+ let listener = or_panic!(UnixListener::bind(&socket_path));
+ let stream = or_panic!(UnixStream::connect(&socket_path));
+
+ let result = stream.set_write_timeout(Some(Duration::new(0, 0)));
+ let err = result.unwrap_err();
+ assert_eq!(err.kind(), ErrorKind::InvalidInput);
+
+ let result = stream.set_read_timeout(Some(Duration::new(0, 0)));
+ let err = result.unwrap_err();
+ assert_eq!(err.kind(), ErrorKind::InvalidInput);
+
+ drop(listener);
+}
+
+#[test]
+fn test_unix_datagram() {
+ let dir = tmpdir();
+ let path1 = dir.path().join("sock1");
+ let path2 = dir.path().join("sock2");
+
+ let sock1 = or_panic!(UnixDatagram::bind(&path1));
+ let sock2 = or_panic!(UnixDatagram::bind(&path2));
+
+ let msg = b"hello world";
+ or_panic!(sock1.send_to(msg, &path2));
+ let mut buf = [0; 11];
+ or_panic!(sock2.recv_from(&mut buf));
+ assert_eq!(msg, &buf[..]);
+}
+
+#[test]
+fn test_unnamed_unix_datagram() {
+ let dir = tmpdir();
+ let path1 = dir.path().join("sock1");
+
+ let sock1 = or_panic!(UnixDatagram::bind(&path1));
+ let sock2 = or_panic!(UnixDatagram::unbound());
+
+ let msg = b"hello world";
+ or_panic!(sock2.send_to(msg, &path1));
+ let mut buf = [0; 11];
+ let (usize, addr) = or_panic!(sock1.recv_from(&mut buf));
+ assert_eq!(usize, 11);
+ assert!(addr.is_unnamed());
+ assert_eq!(msg, &buf[..]);
+}
+
+#[test]
+fn test_connect_unix_datagram() {
+ let dir = tmpdir();
+ let path1 = dir.path().join("sock1");
+ let path2 = dir.path().join("sock2");
+
+ let bsock1 = or_panic!(UnixDatagram::bind(&path1));
+ let bsock2 = or_panic!(UnixDatagram::bind(&path2));
+ let sock = or_panic!(UnixDatagram::unbound());
+ or_panic!(sock.connect(&path1));
+
+ // Check send()
+ let msg = b"hello there";
+ or_panic!(sock.send(msg));
+ let mut buf = [0; 11];
+ let (usize, addr) = or_panic!(bsock1.recv_from(&mut buf));
+ assert_eq!(usize, 11);
+ assert!(addr.is_unnamed());
+ assert_eq!(msg, &buf[..]);
+
+ // Changing default socket works too
+ or_panic!(sock.connect(&path2));
+ or_panic!(sock.send(msg));
+ or_panic!(bsock2.recv_from(&mut buf));
+}
+
+#[test]
+fn test_unix_datagram_recv() {
+ let dir = tmpdir();
+ let path1 = dir.path().join("sock1");
+
+ let sock1 = or_panic!(UnixDatagram::bind(&path1));
+ let sock2 = or_panic!(UnixDatagram::unbound());
+ or_panic!(sock2.connect(&path1));
+
+ let msg = b"hello world";
+ or_panic!(sock2.send(msg));
+ let mut buf = [0; 11];
+ let size = or_panic!(sock1.recv(&mut buf));
+ assert_eq!(size, 11);
+ assert_eq!(msg, &buf[..]);
+}
+
+#[test]
+fn datagram_pair() {
+ let msg1 = b"hello";
+ let msg2 = b"world!";
+
+ let (s1, s2) = or_panic!(UnixDatagram::pair());
+ let thread = thread::spawn(move || {
+ // s1 must be moved in or the test will hang!
+ let mut buf = [0; 5];
+ or_panic!(s1.recv(&mut buf));
+ assert_eq!(&msg1[..], &buf[..]);
+ or_panic!(s1.send(msg2));
+ });
+
+ or_panic!(s2.send(msg1));
+ let mut buf = [0; 6];
+ or_panic!(s2.recv(&mut buf));
+ assert_eq!(&msg2[..], &buf[..]);
+ drop(s2);
+
+ thread.join().unwrap();
+}
+
+// Ensure the `set_read_timeout` and `set_write_timeout` calls return errors
+// when passed zero Durations
+#[test]
+fn test_unix_datagram_timeout_zero_duration() {
+ let dir = tmpdir();
+ let path = dir.path().join("sock");
+
+ let datagram = or_panic!(UnixDatagram::bind(&path));
+
+ let result = datagram.set_write_timeout(Some(Duration::new(0, 0)));
+ let err = result.unwrap_err();
+ assert_eq!(err.kind(), ErrorKind::InvalidInput);
+
+ let result = datagram.set_read_timeout(Some(Duration::new(0, 0)));
+ let err = result.unwrap_err();
+ assert_eq!(err.kind(), ErrorKind::InvalidInput);
+}
+
+#[test]
+fn abstract_namespace_not_allowed() {
+ assert!(UnixStream::connect("\0asdf").is_err());
+}
+
+#[test]
+fn test_unix_stream_peek() {
+ let (txdone, rxdone) = crate::sync::mpsc::channel();
+
+ let dir = tmpdir();
+ let path = dir.path().join("sock");
+
+ let listener = or_panic!(UnixListener::bind(&path));
+ let thread = thread::spawn(move || {
+ let mut stream = or_panic!(listener.accept()).0;
+ or_panic!(stream.write_all(&[1, 3, 3, 7]));
+ or_panic!(rxdone.recv());
+ });
+
+ let mut stream = or_panic!(UnixStream::connect(&path));
+ let mut buf = [0; 10];
+ for _ in 0..2 {
+ assert_eq!(or_panic!(stream.peek(&mut buf)), 4);
+ }
+ assert_eq!(or_panic!(stream.read(&mut buf)), 4);
+
+ or_panic!(stream.set_nonblocking(true));
+ match stream.peek(&mut buf) {
+ Ok(_) => panic!("expected error"),
+ Err(ref e) if e.kind() == ErrorKind::WouldBlock => {}
+ Err(e) => panic!("unexpected error: {}", e),
+ }
+
+ or_panic!(txdone.send(()));
+ thread.join().unwrap();
+}
+
+#[test]
+fn test_unix_datagram_peek() {
+ let dir = tmpdir();
+ let path1 = dir.path().join("sock");
+
+ let sock1 = or_panic!(UnixDatagram::bind(&path1));
+ let sock2 = or_panic!(UnixDatagram::unbound());
+ or_panic!(sock2.connect(&path1));
+
+ let msg = b"hello world";
+ or_panic!(sock2.send(msg));
+ for _ in 0..2 {
+ let mut buf = [0; 11];
+ let size = or_panic!(sock1.peek(&mut buf));
+ assert_eq!(size, 11);
+ assert_eq!(msg, &buf[..]);
+ }
+
+ let mut buf = [0; 11];
+ let size = or_panic!(sock1.recv(&mut buf));
+ assert_eq!(size, 11);
+ assert_eq!(msg, &buf[..]);
+}
+
+#[test]
+fn test_unix_datagram_peek_from() {
+ let dir = tmpdir();
+ let path1 = dir.path().join("sock");
+
+ let sock1 = or_panic!(UnixDatagram::bind(&path1));
+ let sock2 = or_panic!(UnixDatagram::unbound());
+ or_panic!(sock2.connect(&path1));
+
+ let msg = b"hello world";
+ or_panic!(sock2.send(msg));
+ for _ in 0..2 {
+ let mut buf = [0; 11];
+ let (size, _) = or_panic!(sock1.peek_from(&mut buf));
+ assert_eq!(size, 11);
+ assert_eq!(msg, &buf[..]);
+ }
+
+ let mut buf = [0; 11];
+ let size = or_panic!(sock1.recv(&mut buf));
+ assert_eq!(size, 11);
+ assert_eq!(msg, &buf[..]);
+}
+
+#[cfg(any(
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+))]
+#[test]
+fn test_send_vectored_fds_unix_stream() {
+ let (s1, s2) = or_panic!(UnixStream::pair());
+
+ let buf1 = [1; 8];
+ let bufs_send = &[IoSlice::new(&buf1[..])][..];
+
+ let mut ancillary1_buffer = [0; 128];
+ let mut ancillary1 = SocketAncillary::new(&mut ancillary1_buffer[..]);
+ assert!(ancillary1.add_fds(&[s1.as_raw_fd()][..]));
+
+ let usize = or_panic!(s1.send_vectored_with_ancillary(&bufs_send, &mut ancillary1));
+ assert_eq!(usize, 8);
+
+ let mut buf2 = [0; 8];
+ let mut bufs_recv = &mut [IoSliceMut::new(&mut buf2[..])][..];
+
+ let mut ancillary2_buffer = [0; 128];
+ let mut ancillary2 = SocketAncillary::new(&mut ancillary2_buffer[..]);
+
+ let usize = or_panic!(s2.recv_vectored_with_ancillary(&mut bufs_recv, &mut ancillary2));
+ assert_eq!(usize, 8);
+ assert_eq!(buf1, buf2);
+
+ let mut ancillary_data_vec = Vec::from_iter(ancillary2.messages());
+ assert_eq!(ancillary_data_vec.len(), 1);
+ if let AncillaryData::ScmRights(scm_rights) = ancillary_data_vec.pop().unwrap().unwrap() {
+ let fd_vec = Vec::from_iter(scm_rights);
+ assert_eq!(fd_vec.len(), 1);
+ unsafe {
+ libc::close(fd_vec[0]);
+ }
+ } else {
+ unreachable!("must be ScmRights");
+ }
+}
+
+#[cfg(any(target_os = "android", target_os = "emscripten", target_os = "linux",))]
+#[test]
+fn test_send_vectored_with_ancillary_to_unix_datagram() {
+ fn getpid() -> libc::pid_t {
+ unsafe { libc::getpid() }
+ }
+
+ fn getuid() -> libc::uid_t {
+ unsafe { libc::getuid() }
+ }
+
+ fn getgid() -> libc::gid_t {
+ unsafe { libc::getgid() }
+ }
+
+ let dir = tmpdir();
+ let path1 = dir.path().join("sock1");
+ let path2 = dir.path().join("sock2");
+
+ let bsock1 = or_panic!(UnixDatagram::bind(&path1));
+ let bsock2 = or_panic!(UnixDatagram::bind(&path2));
+
+ or_panic!(bsock2.set_passcred(true));
+
+ let buf1 = [1; 8];
+ let bufs_send = &[IoSlice::new(&buf1[..])][..];
+
+ let mut ancillary1_buffer = [0; 128];
+ let mut ancillary1 = SocketAncillary::new(&mut ancillary1_buffer[..]);
+ let mut cred1 = SocketCred::new();
+ cred1.set_pid(getpid());
+ cred1.set_uid(getuid());
+ cred1.set_gid(getgid());
+ assert!(ancillary1.add_creds(&[cred1.clone()][..]));
+
+ let usize =
+ or_panic!(bsock1.send_vectored_with_ancillary_to(&bufs_send, &mut ancillary1, &path2));
+ assert_eq!(usize, 8);
+
+ let mut buf2 = [0; 8];
+ let mut bufs_recv = &mut [IoSliceMut::new(&mut buf2[..])][..];
+
+ let mut ancillary2_buffer = [0; 128];
+ let mut ancillary2 = SocketAncillary::new(&mut ancillary2_buffer[..]);
+
+ let (usize, truncated, _addr) =
+ or_panic!(bsock2.recv_vectored_with_ancillary_from(&mut bufs_recv, &mut ancillary2));
+ assert_eq!(ancillary2.truncated(), false);
+ assert_eq!(usize, 8);
+ assert_eq!(truncated, false);
+ assert_eq!(buf1, buf2);
+
+ let mut ancillary_data_vec = Vec::from_iter(ancillary2.messages());
+ assert_eq!(ancillary_data_vec.len(), 1);
+ if let AncillaryData::ScmCredentials(scm_credentials) =
+ ancillary_data_vec.pop().unwrap().unwrap()
+ {
+ let cred_vec = Vec::from_iter(scm_credentials);
+ assert_eq!(cred_vec.len(), 1);
+ assert_eq!(cred1.get_pid(), cred_vec[0].get_pid());
+ assert_eq!(cred1.get_uid(), cred_vec[0].get_uid());
+ assert_eq!(cred1.get_gid(), cred_vec[0].get_gid());
+ } else {
+ unreachable!("must be ScmCredentials");
+ }
+}
+
+#[cfg(any(
+ target_os = "android",
+ target_os = "dragonfly",
+ target_os = "emscripten",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+))]
+#[test]
+fn test_send_vectored_with_ancillary_unix_datagram() {
+ let dir = tmpdir();
+ let path1 = dir.path().join("sock1");
+ let path2 = dir.path().join("sock2");
+
+ let bsock1 = or_panic!(UnixDatagram::bind(&path1));
+ let bsock2 = or_panic!(UnixDatagram::bind(&path2));
+
+ let buf1 = [1; 8];
+ let bufs_send = &[IoSlice::new(&buf1[..])][..];
+
+ let mut ancillary1_buffer = [0; 128];
+ let mut ancillary1 = SocketAncillary::new(&mut ancillary1_buffer[..]);
+ assert!(ancillary1.add_fds(&[bsock1.as_raw_fd()][..]));
+
+ or_panic!(bsock1.connect(&path2));
+ let usize = or_panic!(bsock1.send_vectored_with_ancillary(&bufs_send, &mut ancillary1));
+ assert_eq!(usize, 8);
+
+ let mut buf2 = [0; 8];
+ let mut bufs_recv = &mut [IoSliceMut::new(&mut buf2[..])][..];
+
+ let mut ancillary2_buffer = [0; 128];
+ let mut ancillary2 = SocketAncillary::new(&mut ancillary2_buffer[..]);
+
+ let (usize, truncated) =
+ or_panic!(bsock2.recv_vectored_with_ancillary(&mut bufs_recv, &mut ancillary2));
+ assert_eq!(usize, 8);
+ assert_eq!(truncated, false);
+ assert_eq!(buf1, buf2);
+
+ let mut ancillary_data_vec = Vec::from_iter(ancillary2.messages());
+ assert_eq!(ancillary_data_vec.len(), 1);
+ if let AncillaryData::ScmRights(scm_rights) = ancillary_data_vec.pop().unwrap().unwrap() {
+ let fd_vec = Vec::from_iter(scm_rights);
+ assert_eq!(fd_vec.len(), 1);
+ unsafe {
+ libc::close(fd_vec[0]);
+ }
+ } else {
+ unreachable!("must be ScmRights");
+ }
+}
--- /dev/null
+//! Unix-specific extensions to primitives in the `std::process` module.
+
+#![stable(feature = "rust1", since = "1.0.0")]
+
+use crate::ffi::OsStr;
+use crate::io;
+use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
+use crate::process;
+use crate::sealed::Sealed;
+use crate::sys;
+use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
+
+/// Unix-specific extensions to the [`process::Command`] builder.
+///
+/// This trait is sealed: it cannot be implemented outside the standard library.
+/// This is so that future additional methods are not breaking changes.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub trait CommandExt: Sealed {
+ /// Sets the child process's user ID. This translates to a
+ /// `setuid` call in the child process. Failure in the `setuid`
+ /// call will cause the spawn to fail.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn uid(
+ &mut self,
+ #[cfg(not(target_os = "vxworks"))] id: u32,
+ #[cfg(target_os = "vxworks")] id: u16,
+ ) -> &mut process::Command;
+
+ /// Similar to `uid`, but sets the group ID of the child process. This has
+ /// the same semantics as the `uid` field.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn gid(
+ &mut self,
+ #[cfg(not(target_os = "vxworks"))] id: u32,
+ #[cfg(target_os = "vxworks")] id: u16,
+ ) -> &mut process::Command;
+
+ /// Sets the supplementary group IDs for the calling process. Translates to
+ /// a `setgroups` call in the child process.
+ #[unstable(feature = "setgroups", issue = "38527", reason = "")]
+ fn groups(
+ &mut self,
+ #[cfg(not(target_os = "vxworks"))] groups: &[u32],
+ #[cfg(target_os = "vxworks")] groups: &[u16],
+ ) -> &mut process::Command;
+
+ /// Schedules a closure to be run just before the `exec` function is
+ /// invoked.
+ ///
+ /// The closure is allowed to return an I/O error whose OS error code will
+ /// be communicated back to the parent and returned as an error from when
+ /// the spawn was requested.
+ ///
+ /// Multiple closures can be registered and they will be called in order of
+ /// their registration. If a closure returns `Err` then no further closures
+ /// will be called and the spawn operation will immediately return with a
+ /// failure.
+ ///
+ /// # Notes and Safety
+ ///
+ /// This closure will be run in the context of the child process after a
+ /// `fork`. This primarily means that any modifications made to memory on
+ /// behalf of this closure will **not** be visible to the parent process.
+ /// This is often a very constrained environment where normal operations
+ /// like `malloc`, accessing environment variables through [`std::env`]
+ /// or acquiring a mutex are not guaranteed to work (due to
+ /// other threads perhaps still running when the `fork` was run).
+ ///
+ /// For further details refer to the [POSIX fork() specification]
+ /// and the equivalent documentation for any targeted
+ /// platform, especially the requirements around *async-signal-safety*.
+ ///
+ /// This also means that all resources such as file descriptors and
+ /// memory-mapped regions got duplicated. It is your responsibility to make
+ /// sure that the closure does not violate library invariants by making
+ /// invalid use of these duplicates.
+ ///
+ /// When this closure is run, aspects such as the stdio file descriptors and
+ /// working directory have successfully been changed, so output to these
+ /// locations may not appear where intended.
+ ///
+ /// [POSIX fork() specification]:
+ /// https://pubs.opengroup.org/onlinepubs/9699919799/functions/fork.html
+ /// [`std::env`]: mod@crate::env
+ #[stable(feature = "process_pre_exec", since = "1.34.0")]
+ unsafe fn pre_exec<F>(&mut self, f: F) -> &mut process::Command
+ where
+ F: FnMut() -> io::Result<()> + Send + Sync + 'static;
+
+ /// Schedules a closure to be run just before the `exec` function is
+ /// invoked.
+ ///
+ /// This method is stable and usable, but it should be unsafe. To fix
+ /// that, it got deprecated in favor of the unsafe [`pre_exec`].
+ ///
+ /// [`pre_exec`]: CommandExt::pre_exec
+ #[stable(feature = "process_exec", since = "1.15.0")]
+ #[rustc_deprecated(since = "1.37.0", reason = "should be unsafe, use `pre_exec` instead")]
+ fn before_exec<F>(&mut self, f: F) -> &mut process::Command
+ where
+ F: FnMut() -> io::Result<()> + Send + Sync + 'static,
+ {
+ unsafe { self.pre_exec(f) }
+ }
+
+ /// Performs all the required setup by this `Command`, followed by calling
+ /// the `execvp` syscall.
+ ///
+ /// On success this function will not return, and otherwise it will return
+ /// an error indicating why the exec (or another part of the setup of the
+ /// `Command`) failed.
+ ///
+ /// `exec` not returning has the same implications as calling
+ /// [`process::exit`] – no destructors on the current stack or any other
+ /// thread’s stack will be run. Therefore, it is recommended to only call
+ /// `exec` at a point where it is fine to not run any destructors. Note,
+ /// that the `execvp` syscall independently guarantees that all memory is
+ /// freed and all file descriptors with the `CLOEXEC` option (set by default
+ /// on all file descriptors opened by the standard library) are closed.
+ ///
+ /// This function, unlike `spawn`, will **not** `fork` the process to create
+ /// a new child. Like spawn, however, the default behavior for the stdio
+ /// descriptors will be to inherited from the current process.
+ ///
+ /// # Notes
+ ///
+ /// The process may be in a "broken state" if this function returns in
+ /// error. For example the working directory, environment variables, signal
+ /// handling settings, various user/group information, or aspects of stdio
+ /// file descriptors may have changed. If a "transactional spawn" is
+ /// required to gracefully handle errors it is recommended to use the
+ /// cross-platform `spawn` instead.
+ #[stable(feature = "process_exec2", since = "1.9.0")]
+ fn exec(&mut self) -> io::Error;
+
+ /// Set executable argument
+ ///
+ /// Set the first process argument, `argv[0]`, to something other than the
+ /// default executable path.
+ #[stable(feature = "process_set_argv0", since = "1.45.0")]
+ fn arg0<S>(&mut self, arg: S) -> &mut process::Command
+ where
+ S: AsRef<OsStr>;
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl CommandExt for process::Command {
+ fn uid(
+ &mut self,
+ #[cfg(not(target_os = "vxworks"))] id: u32,
+ #[cfg(target_os = "vxworks")] id: u16,
+ ) -> &mut process::Command {
+ self.as_inner_mut().uid(id);
+ self
+ }
+
+ fn gid(
+ &mut self,
+ #[cfg(not(target_os = "vxworks"))] id: u32,
+ #[cfg(target_os = "vxworks")] id: u16,
+ ) -> &mut process::Command {
+ self.as_inner_mut().gid(id);
+ self
+ }
+
+ fn groups(
+ &mut self,
+ #[cfg(not(target_os = "vxworks"))] groups: &[u32],
+ #[cfg(target_os = "vxworks")] groups: &[u16],
+ ) -> &mut process::Command {
+ self.as_inner_mut().groups(groups);
+ self
+ }
+
+ unsafe fn pre_exec<F>(&mut self, f: F) -> &mut process::Command
+ where
+ F: FnMut() -> io::Result<()> + Send + Sync + 'static,
+ {
+ self.as_inner_mut().pre_exec(Box::new(f));
+ self
+ }
+
+ fn exec(&mut self) -> io::Error {
+ // NOTE: This may *not* be safe to call after `libc::fork`, because it
+ // may allocate. That may be worth fixing at some point in the future.
+ self.as_inner_mut().exec(sys::process::Stdio::Inherit)
+ }
+
+ fn arg0<S>(&mut self, arg: S) -> &mut process::Command
+ where
+ S: AsRef<OsStr>,
+ {
+ self.as_inner_mut().set_arg_0(arg.as_ref());
+ self
+ }
+}
+
+/// Unix-specific extensions to [`process::ExitStatus`].
+///
+/// On Unix, `ExitStatus` **does not necessarily represent an exit status**, as passed to the
+/// `exit` system call or returned by [`ExitStatus::code()`](crate::process::ExitStatus::code).
+/// It represents **any wait status**, as returned by one of the `wait` family of system calls.
+///
+/// This is because a Unix wait status (a Rust `ExitStatus`) can represent a Unix exit status, but
+/// can also represent other kinds of process event.
+///
+/// This trait is sealed: it cannot be implemented outside the standard library.
+/// This is so that future additional methods are not breaking changes.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub trait ExitStatusExt: Sealed {
+ /// Creates a new `ExitStatus` from the raw underlying integer status value from `wait`
+ ///
+ /// The value should be a **wait status, not an exit status**.
+ #[stable(feature = "exit_status_from", since = "1.12.0")]
+ fn from_raw(raw: i32) -> Self;
+
+ /// If the process was terminated by a signal, returns that signal.
+ ///
+ /// In other words, if `WIFSIGNALED`, this returns `WTERMSIG`.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn signal(&self) -> Option<i32>;
+
+ /// If the process was terminated by a signal, says whether it dumped core.
+ #[unstable(feature = "unix_process_wait_more", issue = "80695")]
+ fn core_dumped(&self) -> bool;
+
+ /// If the process was stopped by a signal, returns that signal.
+ ///
+ /// In other words, if `WIFSTOPPED`, this returns `WSTOPSIG`. This is only possible if the status came from
+ /// a `wait` system call which was passed `WUNTRACED`, and was then converted into an `ExitStatus`.
+ #[unstable(feature = "unix_process_wait_more", issue = "80695")]
+ fn stopped_signal(&self) -> Option<i32>;
+
+ /// Whether the process was continued from a stopped status.
+ ///
+ /// Ie, `WIFCONTINUED`. This is only possible if the status came from a `wait` system call
+ /// which was passed `WCONTINUED`, and was then converted into an `ExitStatus`.
+ #[unstable(feature = "unix_process_wait_more", issue = "80695")]
+ fn continued(&self) -> bool;
+
+ /// Returns the underlying raw `wait` status.
+ ///
+ /// The returned integer is a **wait status, not an exit status**.
+ #[unstable(feature = "unix_process_wait_more", issue = "80695")]
+ fn into_raw(self) -> i32;
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl ExitStatusExt for process::ExitStatus {
+ fn from_raw(raw: i32) -> Self {
+ process::ExitStatus::from_inner(From::from(raw))
+ }
+
+ fn signal(&self) -> Option<i32> {
+ self.as_inner().signal()
+ }
+
+ fn core_dumped(&self) -> bool {
+ self.as_inner().core_dumped()
+ }
+
+ fn stopped_signal(&self) -> Option<i32> {
+ self.as_inner().stopped_signal()
+ }
+
+ fn continued(&self) -> bool {
+ self.as_inner().continued()
+ }
+
+ fn into_raw(self) -> i32 {
+ self.as_inner().into_raw().into()
+ }
+}
+
+#[stable(feature = "process_extensions", since = "1.2.0")]
+impl FromRawFd for process::Stdio {
+ #[inline]
+ unsafe fn from_raw_fd(fd: RawFd) -> process::Stdio {
+ let fd = sys::fd::FileDesc::new(fd);
+ let io = sys::process::Stdio::Fd(fd);
+ process::Stdio::from_inner(io)
+ }
+}
+
+#[stable(feature = "process_extensions", since = "1.2.0")]
+impl AsRawFd for process::ChildStdin {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ self.as_inner().fd().raw()
+ }
+}
+
+#[stable(feature = "process_extensions", since = "1.2.0")]
+impl AsRawFd for process::ChildStdout {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ self.as_inner().fd().raw()
+ }
+}
+
+#[stable(feature = "process_extensions", since = "1.2.0")]
+impl AsRawFd for process::ChildStderr {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ self.as_inner().fd().raw()
+ }
+}
+
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+impl IntoRawFd for process::ChildStdin {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self.into_inner().into_fd().into_raw()
+ }
+}
+
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+impl IntoRawFd for process::ChildStdout {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self.into_inner().into_fd().into_raw()
+ }
+}
+
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+impl IntoRawFd for process::ChildStderr {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self.into_inner().into_fd().into_raw()
+ }
+}
+
+/// Returns the OS-assigned process identifier associated with this process's parent.
+#[stable(feature = "unix_ppid", since = "1.27.0")]
+pub fn parent_id() -> u32 {
+ crate::sys::os::getppid()
+}
--- /dev/null
+//! Unix-specific primitives available on all unix platforms.
+
+#![stable(feature = "raw_ext", since = "1.1.0")]
+#![rustc_deprecated(
+ since = "1.8.0",
+ reason = "these type aliases are no longer supported by \
+ the standard library, the `libc` crate on \
+ crates.io should be used instead for the correct \
+ definitions"
+)]
+#![allow(deprecated)]
+
+#[stable(feature = "raw_ext", since = "1.1.0")]
+#[allow(non_camel_case_types)]
+pub type uid_t = u32;
+
+#[stable(feature = "raw_ext", since = "1.1.0")]
+#[allow(non_camel_case_types)]
+pub type gid_t = u32;
+
+#[stable(feature = "raw_ext", since = "1.1.0")]
+#[allow(non_camel_case_types)]
+pub type pid_t = i32;
+
+#[doc(inline)]
+#[stable(feature = "pthread_t", since = "1.8.0")]
+pub use super::platform::raw::pthread_t;
+#[doc(inline)]
+#[stable(feature = "raw_ext", since = "1.1.0")]
+pub use super::platform::raw::{blkcnt_t, time_t};
+#[doc(inline)]
+#[stable(feature = "raw_ext", since = "1.1.0")]
+pub use super::platform::raw::{blksize_t, dev_t, ino_t, mode_t, nlink_t, off_t};
--- /dev/null
+//! Unix-specific extensions to primitives in the `std::thread` module.
+
+#![stable(feature = "thread_extensions", since = "1.9.0")]
+
+#[allow(deprecated)]
+use crate::os::unix::raw::pthread_t;
+use crate::sys_common::{AsInner, IntoInner};
+use crate::thread::JoinHandle;
+
+#[stable(feature = "thread_extensions", since = "1.9.0")]
+#[allow(deprecated)]
+pub type RawPthread = pthread_t;
+
+/// Unix-specific extensions to [`JoinHandle`].
+#[stable(feature = "thread_extensions", since = "1.9.0")]
+pub trait JoinHandleExt {
+ /// Extracts the raw pthread_t without taking ownership
+ #[stable(feature = "thread_extensions", since = "1.9.0")]
+ fn as_pthread_t(&self) -> RawPthread;
+
+ /// Consumes the thread, returning the raw pthread_t
+ ///
+ /// This function **transfers ownership** of the underlying pthread_t to
+ /// the caller. Callers are then the unique owners of the pthread_t and
+ /// must either detach or join the pthread_t once it's no longer needed.
+ #[stable(feature = "thread_extensions", since = "1.9.0")]
+ fn into_pthread_t(self) -> RawPthread;
+}
+
+#[stable(feature = "thread_extensions", since = "1.9.0")]
+impl<T> JoinHandleExt for JoinHandle<T> {
+ fn as_pthread_t(&self) -> RawPthread {
+ self.as_inner().id() as RawPthread
+ }
+
+ fn into_pthread_t(self) -> RawPthread {
+ self.into_inner().into_id() as RawPthread
+ }
+}
--- /dev/null
+//! Unix peer credentials.
+
+// NOTE: Code in this file is heavily based on work done in PR 13 from the tokio-uds repository on
+// GitHub.
+//
+// For reference, the link is here: https://github.com/tokio-rs/tokio-uds/pull/13
+// Credit to Martin Habovštiak (GitHub username Kixunil) and contributors for this work.
+
+use libc::{gid_t, pid_t, uid_t};
+
+/// Credentials for a UNIX process for credentials passing.
+#[unstable(feature = "peer_credentials_unix_socket", issue = "42839", reason = "unstable")]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub struct UCred {
+ /// The UID part of the peer credential. This is the effective UID of the process at the domain
+ /// socket's endpoint.
+ pub uid: uid_t,
+ /// The GID part of the peer credential. This is the effective GID of the process at the domain
+ /// socket's endpoint.
+ pub gid: gid_t,
+ /// The PID part of the peer credential. This field is optional because the PID part of the
+ /// peer credentials is not supported on every platform. On platforms where the mechanism to
+ /// discover the PID exists, this field will be populated to the PID of the process at the
+ /// domain socket's endpoint. Otherwise, it will be set to None.
+ pub pid: Option<pid_t>,
+}
+
+#[cfg(any(target_os = "android", target_os = "linux"))]
+pub use self::impl_linux::peer_cred;
+
+#[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
+pub use self::impl_bsd::peer_cred;
+
+#[cfg(any(target_os = "macos", target_os = "ios",))]
+pub use self::impl_mac::peer_cred;
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+pub mod impl_linux {
+ use super::UCred;
+ use crate::os::unix::io::AsRawFd;
+ use crate::os::unix::net::UnixStream;
+ use crate::{io, mem};
+ use libc::{c_void, getsockopt, socklen_t, ucred, SOL_SOCKET, SO_PEERCRED};
+
+ pub fn peer_cred(socket: &UnixStream) -> io::Result<UCred> {
+ let ucred_size = mem::size_of::<ucred>();
+
+ // Trivial sanity checks.
+ assert!(mem::size_of::<u32>() <= mem::size_of::<usize>());
+ assert!(ucred_size <= u32::MAX as usize);
+
+ let mut ucred_size = ucred_size as socklen_t;
+ let mut ucred: ucred = ucred { pid: 1, uid: 1, gid: 1 };
+
+ unsafe {
+ let ret = getsockopt(
+ socket.as_raw_fd(),
+ SOL_SOCKET,
+ SO_PEERCRED,
+ &mut ucred as *mut ucred as *mut c_void,
+ &mut ucred_size,
+ );
+
+ if ret == 0 && ucred_size as usize == mem::size_of::<ucred>() {
+ Ok(UCred { uid: ucred.uid, gid: ucred.gid, pid: Some(ucred.pid) })
+ } else {
+ Err(io::Error::last_os_error())
+ }
+ }
+ }
+}
+
+#[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
+pub mod impl_bsd {
+ use super::UCred;
+ use crate::io;
+ use crate::os::unix::io::AsRawFd;
+ use crate::os::unix::net::UnixStream;
+
+ pub fn peer_cred(socket: &UnixStream) -> io::Result<UCred> {
+ let mut cred = UCred { uid: 1, gid: 1, pid: None };
+ unsafe {
+ let ret = libc::getpeereid(socket.as_raw_fd(), &mut cred.uid, &mut cred.gid);
+
+ if ret == 0 { Ok(cred) } else { Err(io::Error::last_os_error()) }
+ }
+ }
+}
+
+#[cfg(any(target_os = "macos", target_os = "ios",))]
+pub mod impl_mac {
+ use super::UCred;
+ use crate::os::unix::io::AsRawFd;
+ use crate::os::unix::net::UnixStream;
+ use crate::{io, mem};
+ use libc::{c_void, getpeereid, getsockopt, pid_t, socklen_t, LOCAL_PEERPID, SOL_LOCAL};
+
+ pub fn peer_cred(socket: &UnixStream) -> io::Result<UCred> {
+ let mut cred = UCred { uid: 1, gid: 1, pid: None };
+ unsafe {
+ let ret = getpeereid(socket.as_raw_fd(), &mut cred.uid, &mut cred.gid);
+
+ if ret != 0 {
+ return Err(io::Error::last_os_error());
+ }
+
+ let mut pid: pid_t = 1;
+ let mut pid_size = mem::size_of::<pid_t>() as socklen_t;
+
+ let ret = getsockopt(
+ socket.as_raw_fd(),
+ SOL_LOCAL,
+ LOCAL_PEERPID,
+ &mut pid as *mut pid_t as *mut c_void,
+ &mut pid_size,
+ );
+
+ if ret == 0 && pid_size as usize == mem::size_of::<pid_t>() {
+ cred.pid = Some(pid);
+ Ok(cred)
+ } else {
+ Err(io::Error::last_os_error())
+ }
+ }
+ }
+}
--- /dev/null
+use crate::os::unix::net::UnixStream;
+use libc::{getegid, geteuid, getpid};
+
+#[test]
+#[cfg(any(
+ target_os = "android",
+ target_os = "linux",
+ target_os = "dragonfly",
+ target_os = "freebsd",
+ target_os = "ios",
+ target_os = "macos",
+ target_os = "openbsd"
+))]
+fn test_socket_pair() {
+ // Create two connected sockets and get their peer credentials. They should be equal.
+ let (sock_a, sock_b) = UnixStream::pair().unwrap();
+ let (cred_a, cred_b) = (sock_a.peer_cred().unwrap(), sock_b.peer_cred().unwrap());
+ assert_eq!(cred_a, cred_b);
+
+ // Check that the UID and GIDs match up.
+ let uid = unsafe { geteuid() };
+ let gid = unsafe { getegid() };
+ assert_eq!(cred_a.uid, uid);
+ assert_eq!(cred_a.gid, gid);
+}
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "ios", target_os = "macos",))]
+fn test_socket_pair_pids(arg: Type) -> RetType {
+ // Create two connected sockets and get their peer credentials.
+ let (sock_a, sock_b) = UnixStream::pair().unwrap();
+ let (cred_a, cred_b) = (sock_a.peer_cred().unwrap(), sock_b.peer_cred().unwrap());
+
+ // On supported platforms (see the cfg above), the credentials should always include the PID.
+ let pid = unsafe { getpid() };
+ assert_eq!(cred_a.pid, Some(pid));
+ assert_eq!(cred_b.pid, Some(pid));
+}
+++ /dev/null
-//! WASI-specific definitions
-
-#![stable(feature = "raw_ext", since = "1.1.0")]
-
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use crate::sys::ext::*;
--- /dev/null
+//! WASI-specific extension to the primitives in the `std::ffi` module
+
+#![stable(feature = "rust1", since = "1.0.0")]
+
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use crate::sys_common::os_str_bytes::*;
--- /dev/null
+//! WASI-specific extensions to primitives in the `std::fs` module.
+
+#![deny(unsafe_op_in_unsafe_fn)]
+#![unstable(feature = "wasi_ext", issue = "none")]
+
+use crate::ffi::OsStr;
+use crate::fs::{self, File, Metadata, OpenOptions};
+use crate::io::{self, IoSlice, IoSliceMut};
+use crate::path::{Path, PathBuf};
+use crate::sys_common::{AsInner, AsInnerMut, FromInner};
+// Used for `File::read` on intra-doc links
+#[allow(unused_imports)]
+use io::{Read, Write};
+
+/// WASI-specific extensions to [`File`].
+pub trait FileExt {
+ /// Reads a number of bytes starting from a given offset.
+ ///
+ /// Returns the number of bytes read.
+ ///
+ /// The offset is relative to the start of the file and thus independent
+ /// from the current cursor.
+ ///
+ /// The current file cursor is not affected by this function.
+ ///
+ /// Note that similar to [`File::read`], it is not an error to return with a
+ /// short read.
+ fn read_at(&self, buf: &mut [u8], offset: u64) -> io::Result<usize> {
+ let bufs = &mut [IoSliceMut::new(buf)];
+ self.read_vectored_at(bufs, offset)
+ }
+
+ /// Reads a number of bytes starting from a given offset.
+ ///
+ /// Returns the number of bytes read.
+ ///
+ /// The offset is relative to the start of the file and thus independent
+ /// from the current cursor.
+ ///
+ /// The current file cursor is not affected by this function.
+ ///
+ /// Note that similar to [`File::read_vectored`], it is not an error to
+ /// return with a short read.
+ fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize>;
+
+ /// Reads the exact number of byte required to fill `buf` from the given offset.
+ ///
+ /// The offset is relative to the start of the file and thus independent
+ /// from the current cursor.
+ ///
+ /// The current file cursor is not affected by this function.
+ ///
+ /// Similar to [`Read::read_exact`] but uses [`read_at`] instead of `read`.
+ ///
+ /// [`read_at`]: FileExt::read_at
+ ///
+ /// # Errors
+ ///
+ /// If this function encounters an error of the kind
+ /// [`io::ErrorKind::Interrupted`] then the error is ignored and the operation
+ /// will continue.
+ ///
+ /// If this function encounters an "end of file" before completely filling
+ /// the buffer, it returns an error of the kind [`io::ErrorKind::UnexpectedEof`].
+ /// The contents of `buf` are unspecified in this case.
+ ///
+ /// If any other read error is encountered then this function immediately
+ /// returns. The contents of `buf` are unspecified in this case.
+ ///
+ /// If this function returns an error, it is unspecified how many bytes it
+ /// has read, but it will never read more than would be necessary to
+ /// completely fill the buffer.
+ #[stable(feature = "rw_exact_all_at", since = "1.33.0")]
+ fn read_exact_at(&self, mut buf: &mut [u8], mut offset: u64) -> io::Result<()> {
+ while !buf.is_empty() {
+ match self.read_at(buf, offset) {
+ Ok(0) => break,
+ Ok(n) => {
+ let tmp = buf;
+ buf = &mut tmp[n..];
+ offset += n as u64;
+ }
+ Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
+ Err(e) => return Err(e),
+ }
+ }
+ if !buf.is_empty() {
+ Err(io::Error::new_const(io::ErrorKind::UnexpectedEof, &"failed to fill whole buffer"))
+ } else {
+ Ok(())
+ }
+ }
+
+ /// Writes a number of bytes starting from a given offset.
+ ///
+ /// Returns the number of bytes written.
+ ///
+ /// The offset is relative to the start of the file and thus independent
+ /// from the current cursor.
+ ///
+ /// The current file cursor is not affected by this function.
+ ///
+ /// When writing beyond the end of the file, the file is appropriately
+ /// extended and the intermediate bytes are initialized with the value 0.
+ ///
+ /// Note that similar to [`File::write`], it is not an error to return a
+ /// short write.
+ fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
+ let bufs = &[IoSlice::new(buf)];
+ self.write_vectored_at(bufs, offset)
+ }
+
+ /// Writes a number of bytes starting from a given offset.
+ ///
+ /// Returns the number of bytes written.
+ ///
+ /// The offset is relative to the start of the file and thus independent
+ /// from the current cursor.
+ ///
+ /// The current file cursor is not affected by this function.
+ ///
+ /// When writing beyond the end of the file, the file is appropriately
+ /// extended and the intermediate bytes are initialized with the value 0.
+ ///
+ /// Note that similar to [`File::write_vectored`], it is not an error to return a
+ /// short write.
+ fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize>;
+
+ /// Attempts to write an entire buffer starting from a given offset.
+ ///
+ /// The offset is relative to the start of the file and thus independent
+ /// from the current cursor.
+ ///
+ /// The current file cursor is not affected by this function.
+ ///
+ /// This method will continuously call [`write_at`] until there is no more data
+ /// to be written or an error of non-[`io::ErrorKind::Interrupted`] kind is
+ /// returned. This method will not return until the entire buffer has been
+ /// successfully written or such an error occurs. The first error that is
+ /// not of [`io::ErrorKind::Interrupted`] kind generated from this method will be
+ /// returned.
+ ///
+ /// # Errors
+ ///
+ /// This function will return the first error of
+ /// non-[`io::ErrorKind::Interrupted`] kind that [`write_at`] returns.
+ ///
+ /// [`write_at`]: FileExt::write_at
+ #[stable(feature = "rw_exact_all_at", since = "1.33.0")]
+ fn write_all_at(&self, mut buf: &[u8], mut offset: u64) -> io::Result<()> {
+ while !buf.is_empty() {
+ match self.write_at(buf, offset) {
+ Ok(0) => {
+ return Err(io::Error::new_const(
+ io::ErrorKind::WriteZero,
+ &"failed to write whole buffer",
+ ));
+ }
+ Ok(n) => {
+ buf = &buf[n..];
+ offset += n as u64
+ }
+ Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
+ Err(e) => return Err(e),
+ }
+ }
+ Ok(())
+ }
+
+ /// Returns the current position within the file.
+ ///
+ /// This corresponds to the `fd_tell` syscall and is similar to
+ /// `seek` where you offset 0 bytes from the current position.
+ fn tell(&self) -> io::Result<u64>;
+
+ /// Adjust the flags associated with this file.
+ ///
+ /// This corresponds to the `fd_fdstat_set_flags` syscall.
+ fn fdstat_set_flags(&self, flags: u16) -> io::Result<()>;
+
+ /// Adjust the rights associated with this file.
+ ///
+ /// This corresponds to the `fd_fdstat_set_rights` syscall.
+ fn fdstat_set_rights(&self, rights: u64, inheriting: u64) -> io::Result<()>;
+
+ /// Provide file advisory information on a file descriptor.
+ ///
+ /// This corresponds to the `fd_advise` syscall.
+ fn advise(&self, offset: u64, len: u64, advice: u8) -> io::Result<()>;
+
+ /// Force the allocation of space in a file.
+ ///
+ /// This corresponds to the `fd_allocate` syscall.
+ fn allocate(&self, offset: u64, len: u64) -> io::Result<()>;
+
+ /// Create a directory.
+ ///
+ /// This corresponds to the `path_create_directory` syscall.
+ fn create_directory<P: AsRef<Path>>(&self, dir: P) -> io::Result<()>;
+
+ /// Read the contents of a symbolic link.
+ ///
+ /// This corresponds to the `path_readlink` syscall.
+ fn read_link<P: AsRef<Path>>(&self, path: P) -> io::Result<PathBuf>;
+
+ /// Return the attributes of a file or directory.
+ ///
+ /// This corresponds to the `path_filestat_get` syscall.
+ fn metadata_at<P: AsRef<Path>>(&self, lookup_flags: u32, path: P) -> io::Result<Metadata>;
+
+ /// Unlink a file.
+ ///
+ /// This corresponds to the `path_unlink_file` syscall.
+ fn remove_file<P: AsRef<Path>>(&self, path: P) -> io::Result<()>;
+
+ /// Remove a directory.
+ ///
+ /// This corresponds to the `path_remove_directory` syscall.
+ fn remove_directory<P: AsRef<Path>>(&self, path: P) -> io::Result<()>;
+}
+
+// FIXME: bind fd_fdstat_get - need to define a custom return type
+// FIXME: bind fd_readdir - can't return `ReadDir` since we only have entry name
+// FIXME: bind fd_filestat_set_times maybe? - on crates.io for unix
+// FIXME: bind path_filestat_set_times maybe? - on crates.io for unix
+// FIXME: bind poll_oneoff maybe? - probably should wait for I/O to settle
+// FIXME: bind random_get maybe? - on crates.io for unix
+
+impl FileExt for fs::File {
+ fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
+ self.as_inner().fd().pread(bufs, offset)
+ }
+
+ fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
+ self.as_inner().fd().pwrite(bufs, offset)
+ }
+
+ fn tell(&self) -> io::Result<u64> {
+ self.as_inner().fd().tell()
+ }
+
+ fn fdstat_set_flags(&self, flags: u16) -> io::Result<()> {
+ self.as_inner().fd().set_flags(flags)
+ }
+
+ fn fdstat_set_rights(&self, rights: u64, inheriting: u64) -> io::Result<()> {
+ self.as_inner().fd().set_rights(rights, inheriting)
+ }
+
+ fn advise(&self, offset: u64, len: u64, advice: u8) -> io::Result<()> {
+ self.as_inner().fd().advise(offset, len, advice)
+ }
+
+ fn allocate(&self, offset: u64, len: u64) -> io::Result<()> {
+ self.as_inner().fd().allocate(offset, len)
+ }
+
+ fn create_directory<P: AsRef<Path>>(&self, dir: P) -> io::Result<()> {
+ self.as_inner().fd().create_directory(osstr2str(dir.as_ref().as_ref())?)
+ }
+
+ fn read_link<P: AsRef<Path>>(&self, path: P) -> io::Result<PathBuf> {
+ self.as_inner().read_link(path.as_ref())
+ }
+
+ fn metadata_at<P: AsRef<Path>>(&self, lookup_flags: u32, path: P) -> io::Result<Metadata> {
+ let m = self.as_inner().metadata_at(lookup_flags, path.as_ref())?;
+ Ok(FromInner::from_inner(m))
+ }
+
+ fn remove_file<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
+ self.as_inner().fd().unlink_file(osstr2str(path.as_ref().as_ref())?)
+ }
+
+ fn remove_directory<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
+ self.as_inner().fd().remove_directory(osstr2str(path.as_ref().as_ref())?)
+ }
+}
+
+/// WASI-specific extensions to [`fs::OpenOptions`].
+pub trait OpenOptionsExt {
+ /// Pass custom `dirflags` argument to `path_open`.
+ ///
+ /// This option configures the `dirflags` argument to the
+ /// `path_open` syscall which `OpenOptions` will eventually call. The
+ /// `dirflags` argument configures how the file is looked up, currently
+ /// primarily affecting whether symlinks are followed or not.
+ ///
+ /// By default this value is `__WASI_LOOKUP_SYMLINK_FOLLOW`, or symlinks are
+ /// followed. You can call this method with 0 to disable following symlinks
+ fn lookup_flags(&mut self, flags: u32) -> &mut Self;
+
+ /// Indicates whether `OpenOptions` must open a directory or not.
+ ///
+ /// This method will configure whether the `__WASI_O_DIRECTORY` flag is
+ /// passed when opening a file. When passed it will require that the opened
+ /// path is a directory.
+ ///
+ /// This option is by default `false`
+ fn directory(&mut self, dir: bool) -> &mut Self;
+
+ /// Indicates whether `__WASI_FDFLAG_DSYNC` is passed in the `fs_flags`
+ /// field of `path_open`.
+ ///
+ /// This option is by default `false`
+ fn dsync(&mut self, dsync: bool) -> &mut Self;
+
+ /// Indicates whether `__WASI_FDFLAG_NONBLOCK` is passed in the `fs_flags`
+ /// field of `path_open`.
+ ///
+ /// This option is by default `false`
+ fn nonblock(&mut self, nonblock: bool) -> &mut Self;
+
+ /// Indicates whether `__WASI_FDFLAG_RSYNC` is passed in the `fs_flags`
+ /// field of `path_open`.
+ ///
+ /// This option is by default `false`
+ fn rsync(&mut self, rsync: bool) -> &mut Self;
+
+ /// Indicates whether `__WASI_FDFLAG_SYNC` is passed in the `fs_flags`
+ /// field of `path_open`.
+ ///
+ /// This option is by default `false`
+ fn sync(&mut self, sync: bool) -> &mut Self;
+
+ /// Indicates the value that should be passed in for the `fs_rights_base`
+ /// parameter of `path_open`.
+ ///
+ /// This option defaults based on the `read` and `write` configuration of
+ /// this `OpenOptions` builder. If this method is called, however, the
+ /// exact mask passed in will be used instead.
+ fn fs_rights_base(&mut self, rights: u64) -> &mut Self;
+
+ /// Indicates the value that should be passed in for the
+ /// `fs_rights_inheriting` parameter of `path_open`.
+ ///
+ /// The default for this option is the same value as what will be passed
+ /// for the `fs_rights_base` parameter but if this method is called then
+ /// the specified value will be used instead.
+ fn fs_rights_inheriting(&mut self, rights: u64) -> &mut Self;
+
+ /// Open a file or directory.
+ ///
+ /// This corresponds to the `path_open` syscall.
+ fn open_at<P: AsRef<Path>>(&self, file: &File, path: P) -> io::Result<File>;
+}
+
+impl OpenOptionsExt for OpenOptions {
+ fn lookup_flags(&mut self, flags: u32) -> &mut OpenOptions {
+ self.as_inner_mut().lookup_flags(flags);
+ self
+ }
+
+ fn directory(&mut self, dir: bool) -> &mut OpenOptions {
+ self.as_inner_mut().directory(dir);
+ self
+ }
+
+ fn dsync(&mut self, enabled: bool) -> &mut OpenOptions {
+ self.as_inner_mut().dsync(enabled);
+ self
+ }
+
+ fn nonblock(&mut self, enabled: bool) -> &mut OpenOptions {
+ self.as_inner_mut().nonblock(enabled);
+ self
+ }
+
+ fn rsync(&mut self, enabled: bool) -> &mut OpenOptions {
+ self.as_inner_mut().rsync(enabled);
+ self
+ }
+
+ fn sync(&mut self, enabled: bool) -> &mut OpenOptions {
+ self.as_inner_mut().sync(enabled);
+ self
+ }
+
+ fn fs_rights_base(&mut self, rights: u64) -> &mut OpenOptions {
+ self.as_inner_mut().fs_rights_base(rights);
+ self
+ }
+
+ fn fs_rights_inheriting(&mut self, rights: u64) -> &mut OpenOptions {
+ self.as_inner_mut().fs_rights_inheriting(rights);
+ self
+ }
+
+ fn open_at<P: AsRef<Path>>(&self, file: &File, path: P) -> io::Result<File> {
+ let inner = file.as_inner().open_at(path.as_ref(), self.as_inner())?;
+ Ok(File::from_inner(inner))
+ }
+}
+
+/// WASI-specific extensions to [`fs::Metadata`].
+pub trait MetadataExt {
+ /// Returns the `st_dev` field of the internal `filestat_t`
+ fn dev(&self) -> u64;
+ /// Returns the `st_ino` field of the internal `filestat_t`
+ fn ino(&self) -> u64;
+ /// Returns the `st_nlink` field of the internal `filestat_t`
+ fn nlink(&self) -> u64;
+ /// Returns the `st_size` field of the internal `filestat_t`
+ fn size(&self) -> u64;
+ /// Returns the `st_atim` field of the internal `filestat_t`
+ fn atim(&self) -> u64;
+ /// Returns the `st_mtim` field of the internal `filestat_t`
+ fn mtim(&self) -> u64;
+ /// Returns the `st_ctim` field of the internal `filestat_t`
+ fn ctim(&self) -> u64;
+}
+
+impl MetadataExt for fs::Metadata {
+ fn dev(&self) -> u64 {
+ self.as_inner().as_wasi().dev
+ }
+ fn ino(&self) -> u64 {
+ self.as_inner().as_wasi().ino
+ }
+ fn nlink(&self) -> u64 {
+ self.as_inner().as_wasi().nlink
+ }
+ fn size(&self) -> u64 {
+ self.as_inner().as_wasi().size
+ }
+ fn atim(&self) -> u64 {
+ self.as_inner().as_wasi().atim
+ }
+ fn mtim(&self) -> u64 {
+ self.as_inner().as_wasi().mtim
+ }
+ fn ctim(&self) -> u64 {
+ self.as_inner().as_wasi().ctim
+ }
+}
+
+/// WASI-specific extensions for [`fs::FileType`].
+///
+/// Adds support for special WASI file types such as block/character devices,
+/// pipes, and sockets.
+pub trait FileTypeExt {
+ /// Returns `true` if this file type is a block device.
+ fn is_block_device(&self) -> bool;
+ /// Returns `true` if this file type is a character device.
+ fn is_character_device(&self) -> bool;
+ /// Returns `true` if this file type is a socket datagram.
+ fn is_socket_dgram(&self) -> bool;
+ /// Returns `true` if this file type is a socket stream.
+ fn is_socket_stream(&self) -> bool;
+}
+
+impl FileTypeExt for fs::FileType {
+ fn is_block_device(&self) -> bool {
+ self.as_inner().bits() == wasi::FILETYPE_BLOCK_DEVICE
+ }
+ fn is_character_device(&self) -> bool {
+ self.as_inner().bits() == wasi::FILETYPE_CHARACTER_DEVICE
+ }
+ fn is_socket_dgram(&self) -> bool {
+ self.as_inner().bits() == wasi::FILETYPE_SOCKET_DGRAM
+ }
+ fn is_socket_stream(&self) -> bool {
+ self.as_inner().bits() == wasi::FILETYPE_SOCKET_STREAM
+ }
+}
+
+/// WASI-specific extension methods for [`fs::DirEntry`].
+pub trait DirEntryExt {
+ /// Returns the underlying `d_ino` field of the `dirent_t`
+ fn ino(&self) -> u64;
+}
+
+impl DirEntryExt for fs::DirEntry {
+ fn ino(&self) -> u64 {
+ self.as_inner().ino()
+ }
+}
+
+/// Create a hard link.
+///
+/// This corresponds to the `path_link` syscall.
+pub fn link<P: AsRef<Path>, U: AsRef<Path>>(
+ old_fd: &File,
+ old_flags: u32,
+ old_path: P,
+ new_fd: &File,
+ new_path: U,
+) -> io::Result<()> {
+ old_fd.as_inner().fd().link(
+ old_flags,
+ osstr2str(old_path.as_ref().as_ref())?,
+ new_fd.as_inner().fd(),
+ osstr2str(new_path.as_ref().as_ref())?,
+ )
+}
+
+/// Rename a file or directory.
+///
+/// This corresponds to the `path_rename` syscall.
+pub fn rename<P: AsRef<Path>, U: AsRef<Path>>(
+ old_fd: &File,
+ old_path: P,
+ new_fd: &File,
+ new_path: U,
+) -> io::Result<()> {
+ old_fd.as_inner().fd().rename(
+ osstr2str(old_path.as_ref().as_ref())?,
+ new_fd.as_inner().fd(),
+ osstr2str(new_path.as_ref().as_ref())?,
+ )
+}
+
+/// Create a symbolic link.
+///
+/// This corresponds to the `path_symlink` syscall.
+pub fn symlink<P: AsRef<Path>, U: AsRef<Path>>(
+ old_path: P,
+ fd: &File,
+ new_path: U,
+) -> io::Result<()> {
+ fd.as_inner()
+ .fd()
+ .symlink(osstr2str(old_path.as_ref().as_ref())?, osstr2str(new_path.as_ref().as_ref())?)
+}
+
+/// Create a symbolic link.
+///
+/// This is a convenience API similar to `std::os::unix::fs::symlink` and
+/// `std::os::windows::fs::symlink_file` and `std::os::windows::fs::symlink_dir`.
+pub fn symlink_path<P: AsRef<Path>, U: AsRef<Path>>(old_path: P, new_path: U) -> io::Result<()> {
+ crate::sys::fs::symlink(old_path.as_ref(), new_path.as_ref())
+}
+
+fn osstr2str(f: &OsStr) -> io::Result<&str> {
+ f.to_str().ok_or_else(|| io::Error::new_const(io::ErrorKind::Other, &"input must be utf-8"))
+}
--- /dev/null
+//! WASI-specific extensions to general I/O primitives
+
+#![deny(unsafe_op_in_unsafe_fn)]
+#![unstable(feature = "wasi_ext", issue = "none")]
+
+use crate::fs;
+use crate::io;
+use crate::net;
+use crate::sys;
+use crate::sys_common::{AsInner, FromInner, IntoInner};
+
+/// Raw file descriptors.
+pub type RawFd = u32;
+
+/// A trait to extract the raw WASI file descriptor from an underlying
+/// object.
+pub trait AsRawFd {
+ /// Extracts the raw file descriptor.
+ ///
+ /// This method does **not** pass ownership of the raw file descriptor
+ /// to the caller. The descriptor is only guaranteed to be valid while
+ /// the original object has not yet been destroyed.
+ fn as_raw_fd(&self) -> RawFd;
+}
+
+/// A trait to express the ability to construct an object from a raw file
+/// descriptor.
+pub trait FromRawFd {
+ /// Constructs a new instance of `Self` from the given raw file
+ /// descriptor.
+ ///
+ /// This function **consumes ownership** of the specified file
+ /// descriptor. The returned object will take responsibility for closing
+ /// it when the object goes out of scope.
+ ///
+ /// This function is also unsafe as the primitives currently returned
+ /// have the contract that they are the sole owner of the file
+ /// descriptor they are wrapping. Usage of this function could
+ /// accidentally allow violating this contract which can cause memory
+ /// unsafety in code that relies on it being true.
+ unsafe fn from_raw_fd(fd: RawFd) -> Self;
+}
+
+/// A trait to express the ability to consume an object and acquire ownership of
+/// its raw file descriptor.
+pub trait IntoRawFd {
+ /// Consumes this object, returning the raw underlying file descriptor.
+ ///
+ /// This function **transfers ownership** of the underlying file descriptor
+ /// to the caller. Callers are then the unique owners of the file descriptor
+ /// and must close the descriptor once it's no longer needed.
+ fn into_raw_fd(self) -> RawFd;
+}
+
+#[stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")]
+impl AsRawFd for RawFd {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ *self
+ }
+}
+#[stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")]
+impl IntoRawFd for RawFd {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self
+ }
+}
+#[stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")]
+impl FromRawFd for RawFd {
+ #[inline]
+ unsafe fn from_raw_fd(fd: RawFd) -> RawFd {
+ fd
+ }
+}
+
+impl AsRawFd for net::TcpStream {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ self.as_inner().fd().as_raw()
+ }
+}
+
+impl FromRawFd for net::TcpStream {
+ #[inline]
+ unsafe fn from_raw_fd(fd: RawFd) -> net::TcpStream {
+ net::TcpStream::from_inner(sys::net::TcpStream::from_inner(fd))
+ }
+}
+
+impl IntoRawFd for net::TcpStream {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self.into_inner().into_fd().into_raw()
+ }
+}
+
+impl AsRawFd for net::TcpListener {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ self.as_inner().fd().as_raw()
+ }
+}
+
+impl FromRawFd for net::TcpListener {
+ #[inline]
+ unsafe fn from_raw_fd(fd: RawFd) -> net::TcpListener {
+ net::TcpListener::from_inner(sys::net::TcpListener::from_inner(fd))
+ }
+}
+
+impl IntoRawFd for net::TcpListener {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self.into_inner().into_fd().into_raw()
+ }
+}
+
+impl AsRawFd for net::UdpSocket {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ self.as_inner().fd().as_raw()
+ }
+}
+
+impl FromRawFd for net::UdpSocket {
+ #[inline]
+ unsafe fn from_raw_fd(fd: RawFd) -> net::UdpSocket {
+ net::UdpSocket::from_inner(sys::net::UdpSocket::from_inner(fd))
+ }
+}
+
+impl IntoRawFd for net::UdpSocket {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self.into_inner().into_fd().into_raw()
+ }
+}
+
+impl AsRawFd for fs::File {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ self.as_inner().fd().as_raw()
+ }
+}
+
+impl FromRawFd for fs::File {
+ #[inline]
+ unsafe fn from_raw_fd(fd: RawFd) -> fs::File {
+ fs::File::from_inner(sys::fs::File::from_inner(fd))
+ }
+}
+
+impl IntoRawFd for fs::File {
+ #[inline]
+ fn into_raw_fd(self) -> RawFd {
+ self.into_inner().into_fd().into_raw()
+ }
+}
+
+impl AsRawFd for io::Stdin {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ libc::STDIN_FILENO as RawFd
+ }
+}
+
+impl AsRawFd for io::Stdout {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ libc::STDOUT_FILENO as RawFd
+ }
+}
+
+impl AsRawFd for io::Stderr {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ libc::STDERR_FILENO as RawFd
+ }
+}
+
+impl<'a> AsRawFd for io::StdinLock<'a> {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ libc::STDIN_FILENO as RawFd
+ }
+}
+
+impl<'a> AsRawFd for io::StdoutLock<'a> {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ libc::STDOUT_FILENO as RawFd
+ }
+}
+
+impl<'a> AsRawFd for io::StderrLock<'a> {
+ #[inline]
+ fn as_raw_fd(&self) -> RawFd {
+ libc::STDERR_FILENO as RawFd
+ }
+}
--- /dev/null
+//! Platform-specific extensions to `std` for WASI.
+//!
+//! Provides access to platform-level information on WASI, and exposes
+//! WASI-specific functions that would otherwise be inappropriate as
+//! part of the core `std` library.
+//!
+//! It exposes more ways to deal with platform-specific strings (`OsStr`,
+//! `OsString`), allows to set permissions more granularly, extract low-level
+//! file descriptors from files and sockets, and has platform-specific helpers
+//! for spawning processes.
+//!
+//! # Examples
+//!
+//! ```no_run
+//! use std::fs::File;
+//! use std::os::wasi::prelude::*;
+//!
+//! fn main() -> std::io::Result<()> {
+//! let f = File::create("foo.txt")?;
+//! let fd = f.as_raw_fd();
+//!
+//! // use fd with native WASI bindings
+//!
+//! Ok(())
+//! }
+//! ```
+
+#![stable(feature = "rust1", since = "1.0.0")]
+#![deny(unsafe_op_in_unsafe_fn)]
+#![doc(cfg(target_os = "wasi"))]
+
+pub mod ffi;
+pub mod fs;
+pub mod io;
+
+/// A prelude for conveniently writing platform-specific code.
+///
+/// Includes all extension traits, and some important type definitions.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub mod prelude {
+ #[doc(no_inline)]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub use super::ffi::{OsStrExt, OsStringExt};
+ #[doc(no_inline)]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub use super::fs::FileTypeExt;
+ #[doc(no_inline)]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub use super::fs::{DirEntryExt, FileExt, MetadataExt, OpenOptionsExt};
+ #[doc(no_inline)]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub use super::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
+}
--- /dev/null
+//! Windows-specific extensions to the primitives in the `std::ffi` module.
+//!
+//! # Overview
+//!
+//! For historical reasons, the Windows API uses a form of potentially
+//! ill-formed UTF-16 encoding for strings. Specifically, the 16-bit
+//! code units in Windows strings may contain [isolated surrogate code
+//! points which are not paired together][ill-formed-utf-16]. The
+//! Unicode standard requires that surrogate code points (those in the
+//! range U+D800 to U+DFFF) always be *paired*, because in the UTF-16
+//! encoding a *surrogate code unit pair* is used to encode a single
+//! character. For compatibility with code that does not enforce
+//! these pairings, Windows does not enforce them, either.
+//!
+//! While it is not always possible to convert such a string losslessly into
+//! a valid UTF-16 string (or even UTF-8), it is often desirable to be
+//! able to round-trip such a string from and to Windows APIs
+//! losslessly. For example, some Rust code may be "bridging" some
+//! Windows APIs together, just passing `WCHAR` strings among those
+//! APIs without ever really looking into the strings.
+//!
+//! If Rust code *does* need to look into those strings, it can
+//! convert them to valid UTF-8, possibly lossily, by substituting
+//! invalid sequences with [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD], as is
+//! conventionally done in other Rust APIs that deal with string
+//! encodings.
+//!
+//! # `OsStringExt` and `OsStrExt`
+//!
+//! [`OsString`] is the Rust wrapper for owned strings in the
+//! preferred representation of the operating system. On Windows,
+//! this struct gets augmented with an implementation of the
+//! [`OsStringExt`] trait, which has a [`OsStringExt::from_wide`] method. This
+//! lets you create an [`OsString`] from a `&[u16]` slice; presumably
+//! you get such a slice out of a `WCHAR` Windows API.
+//!
+//! Similarly, [`OsStr`] is the Rust wrapper for borrowed strings from
+//! preferred representation of the operating system. On Windows, the
+//! [`OsStrExt`] trait provides the [`OsStrExt::encode_wide`] method, which
+//! outputs an [`EncodeWide`] iterator. You can [`collect`] this
+//! iterator, for example, to obtain a `Vec<u16>`; you can later get a
+//! pointer to this vector's contents and feed it to Windows APIs.
+//!
+//! These traits, along with [`OsString`] and [`OsStr`], work in
+//! conjunction so that it is possible to **round-trip** strings from
+//! Windows and back, with no loss of data, even if the strings are
+//! ill-formed UTF-16.
+//!
+//! [ill-formed-utf-16]: https://simonsapin.github.io/wtf-8/#ill-formed-utf-16
+//! [`collect`]: crate::iter::Iterator::collect
+//! [U+FFFD]: crate::char::REPLACEMENT_CHARACTER
+
+#![stable(feature = "rust1", since = "1.0.0")]
+
+use crate::ffi::{OsStr, OsString};
+use crate::sealed::Sealed;
+use crate::sys::os_str::Buf;
+use crate::sys_common::wtf8::Wtf8Buf;
+use crate::sys_common::{AsInner, FromInner};
+
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use crate::sys_common::wtf8::EncodeWide;
+
+/// Windows-specific extensions to [`OsString`].
+///
+/// This trait is sealed: it cannot be implemented outside the standard library.
+/// This is so that future additional methods are not breaking changes.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub trait OsStringExt: Sealed {
+ /// Creates an `OsString` from a potentially ill-formed UTF-16 slice of
+ /// 16-bit code units.
+ ///
+ /// This is lossless: calling [`OsStrExt::encode_wide`] on the resulting string
+ /// will always return the original code units.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::ffi::OsString;
+ /// use std::os::windows::prelude::*;
+ ///
+ /// // UTF-16 encoding for "Unicode".
+ /// let source = [0x0055, 0x006E, 0x0069, 0x0063, 0x006F, 0x0064, 0x0065];
+ ///
+ /// let string = OsString::from_wide(&source[..]);
+ /// ```
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn from_wide(wide: &[u16]) -> Self;
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl OsStringExt for OsString {
+ fn from_wide(wide: &[u16]) -> OsString {
+ FromInner::from_inner(Buf { inner: Wtf8Buf::from_wide(wide) })
+ }
+}
+
+/// Windows-specific extensions to [`OsStr`].
+///
+/// This trait is sealed: it cannot be implemented outside the standard library.
+/// This is so that future additional methods are not breaking changes.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub trait OsStrExt: Sealed {
+ /// Re-encodes an `OsStr` as a wide character sequence, i.e., potentially
+ /// ill-formed UTF-16.
+ ///
+ /// This is lossless: calling [`OsStringExt::from_wide`] and then
+ /// `encode_wide` on the result will yield the original code units.
+ /// Note that the encoding does not add a final null terminator.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use std::ffi::OsString;
+ /// use std::os::windows::prelude::*;
+ ///
+ /// // UTF-16 encoding for "Unicode".
+ /// let source = [0x0055, 0x006E, 0x0069, 0x0063, 0x006F, 0x0064, 0x0065];
+ ///
+ /// let string = OsString::from_wide(&source[..]);
+ ///
+ /// let result: Vec<u16> = string.encode_wide().collect();
+ /// assert_eq!(&source[..], &result[..]);
+ /// ```
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn encode_wide(&self) -> EncodeWide<'_>;
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl OsStrExt for OsStr {
+ fn encode_wide(&self) -> EncodeWide<'_> {
+ self.as_inner().inner.encode_wide()
+ }
+}
--- /dev/null
+//! Windows-specific extensions for the primitives in the `std::fs` module.
+
+#![stable(feature = "rust1", since = "1.0.0")]
+
+use crate::fs::{self, Metadata, OpenOptions};
+use crate::io;
+use crate::path::Path;
+use crate::sys;
+use crate::sys_common::{AsInner, AsInnerMut};
+
+/// Windows-specific extensions to [`fs::File`].
+#[stable(feature = "file_offset", since = "1.15.0")]
+pub trait FileExt {
+ /// Seeks to a given position and reads a number of bytes.
+ ///
+ /// Returns the number of bytes read.
+ ///
+ /// The offset is relative to the start of the file and thus independent
+ /// from the current cursor. The current cursor **is** affected by this
+ /// function, it is set to the end of the read.
+ ///
+ /// Reading beyond the end of the file will always return with a length of
+ /// 0\.
+ ///
+ /// Note that similar to `File::read`, it is not an error to return with a
+ /// short read. When returning from such a short read, the file pointer is
+ /// still updated.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::io;
+ /// use std::fs::File;
+ /// use std::os::windows::prelude::*;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let mut file = File::open("foo.txt")?;
+ /// let mut buffer = [0; 10];
+ ///
+ /// // Read 10 bytes, starting 72 bytes from the
+ /// // start of the file.
+ /// file.seek_read(&mut buffer[..], 72)?;
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "file_offset", since = "1.15.0")]
+ fn seek_read(&self, buf: &mut [u8], offset: u64) -> io::Result<usize>;
+
+ /// Seeks to a given position and writes a number of bytes.
+ ///
+ /// Returns the number of bytes written.
+ ///
+ /// The offset is relative to the start of the file and thus independent
+ /// from the current cursor. The current cursor **is** affected by this
+ /// function, it is set to the end of the write.
+ ///
+ /// When writing beyond the end of the file, the file is appropriately
+ /// extended and the intermediate bytes are left uninitialized.
+ ///
+ /// Note that similar to `File::write`, it is not an error to return a
+ /// short write. When returning from such a short write, the file pointer
+ /// is still updated.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs::File;
+ /// use std::os::windows::prelude::*;
+ ///
+ /// fn main() -> std::io::Result<()> {
+ /// let mut buffer = File::create("foo.txt")?;
+ ///
+ /// // Write a byte string starting 72 bytes from
+ /// // the start of the file.
+ /// buffer.seek_write(b"some bytes", 72)?;
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "file_offset", since = "1.15.0")]
+ fn seek_write(&self, buf: &[u8], offset: u64) -> io::Result<usize>;
+}
+
+#[stable(feature = "file_offset", since = "1.15.0")]
+impl FileExt for fs::File {
+ fn seek_read(&self, buf: &mut [u8], offset: u64) -> io::Result<usize> {
+ self.as_inner().read_at(buf, offset)
+ }
+
+ fn seek_write(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
+ self.as_inner().write_at(buf, offset)
+ }
+}
+
+/// Windows-specific extensions to [`fs::OpenOptions`].
+#[stable(feature = "open_options_ext", since = "1.10.0")]
+pub trait OpenOptionsExt {
+ /// Overrides the `dwDesiredAccess` argument to the call to [`CreateFile`]
+ /// with the specified value.
+ ///
+ /// This will override the `read`, `write`, and `append` flags on the
+ /// `OpenOptions` structure. This method provides fine-grained control over
+ /// the permissions to read, write and append data, attributes (like hidden
+ /// and system), and extended attributes.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs::OpenOptions;
+ /// use std::os::windows::prelude::*;
+ ///
+ /// // Open without read and write permission, for example if you only need
+ /// // to call `stat` on the file
+ /// let file = OpenOptions::new().access_mode(0).open("foo.txt");
+ /// ```
+ ///
+ /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea
+ #[stable(feature = "open_options_ext", since = "1.10.0")]
+ fn access_mode(&mut self, access: u32) -> &mut Self;
+
+ /// Overrides the `dwShareMode` argument to the call to [`CreateFile`] with
+ /// the specified value.
+ ///
+ /// By default `share_mode` is set to
+ /// `FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE`. This allows
+ /// other processes to read, write, and delete/rename the same file
+ /// while it is open. Removing any of the flags will prevent other
+ /// processes from performing the corresponding operation until the file
+ /// handle is closed.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::fs::OpenOptions;
+ /// use std::os::windows::prelude::*;
+ ///
+ /// // Do not allow others to read or modify this file while we have it open
+ /// // for writing.
+ /// let file = OpenOptions::new()
+ /// .write(true)
+ /// .share_mode(0)
+ /// .open("foo.txt");
+ /// ```
+ ///
+ /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea
+ #[stable(feature = "open_options_ext", since = "1.10.0")]
+ fn share_mode(&mut self, val: u32) -> &mut Self;
+
+ /// Sets extra flags for the `dwFileFlags` argument to the call to
+ /// [`CreateFile2`] to the specified value (or combines it with
+ /// `attributes` and `security_qos_flags` to set the `dwFlagsAndAttributes`
+ /// for [`CreateFile`]).
+ ///
+ /// Custom flags can only set flags, not remove flags set by Rust's options.
+ /// This option overwrites any previously set custom flags.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// # #[cfg(for_demonstration_only)]
+ /// extern crate winapi;
+ /// # mod winapi { pub const FILE_FLAG_DELETE_ON_CLOSE: u32 = 0x04000000; }
+ ///
+ /// use std::fs::OpenOptions;
+ /// use std::os::windows::prelude::*;
+ ///
+ /// let file = OpenOptions::new()
+ /// .create(true)
+ /// .write(true)
+ /// .custom_flags(winapi::FILE_FLAG_DELETE_ON_CLOSE)
+ /// .open("foo.txt");
+ /// ```
+ ///
+ /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea
+ /// [`CreateFile2`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfile2
+ #[stable(feature = "open_options_ext", since = "1.10.0")]
+ fn custom_flags(&mut self, flags: u32) -> &mut Self;
+
+ /// Sets the `dwFileAttributes` argument to the call to [`CreateFile2`] to
+ /// the specified value (or combines it with `custom_flags` and
+ /// `security_qos_flags` to set the `dwFlagsAndAttributes` for
+ /// [`CreateFile`]).
+ ///
+ /// If a _new_ file is created because it does not yet exist and
+ /// `.create(true)` or `.create_new(true)` are specified, the new file is
+ /// given the attributes declared with `.attributes()`.
+ ///
+ /// If an _existing_ file is opened with `.create(true).truncate(true)`, its
+ /// existing attributes are preserved and combined with the ones declared
+ /// with `.attributes()`.
+ ///
+ /// In all other cases the attributes get ignored.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// # #[cfg(for_demonstration_only)]
+ /// extern crate winapi;
+ /// # mod winapi { pub const FILE_ATTRIBUTE_HIDDEN: u32 = 2; }
+ ///
+ /// use std::fs::OpenOptions;
+ /// use std::os::windows::prelude::*;
+ ///
+ /// let file = OpenOptions::new()
+ /// .write(true)
+ /// .create(true)
+ /// .attributes(winapi::FILE_ATTRIBUTE_HIDDEN)
+ /// .open("foo.txt");
+ /// ```
+ ///
+ /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea
+ /// [`CreateFile2`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfile2
+ #[stable(feature = "open_options_ext", since = "1.10.0")]
+ fn attributes(&mut self, val: u32) -> &mut Self;
+
+ /// Sets the `dwSecurityQosFlags` argument to the call to [`CreateFile2`] to
+ /// the specified value (or combines it with `custom_flags` and `attributes`
+ /// to set the `dwFlagsAndAttributes` for [`CreateFile`]).
+ ///
+ /// By default `security_qos_flags` is not set. It should be specified when
+ /// opening a named pipe, to control to which degree a server process can
+ /// act on behalf of a client process (security impersonation level).
+ ///
+ /// When `security_qos_flags` is not set, a malicious program can gain the
+ /// elevated privileges of a privileged Rust process when it allows opening
+ /// user-specified paths, by tricking it into opening a named pipe. So
+ /// arguably `security_qos_flags` should also be set when opening arbitrary
+ /// paths. However the bits can then conflict with other flags, specifically
+ /// `FILE_FLAG_OPEN_NO_RECALL`.
+ ///
+ /// For information about possible values, see [Impersonation Levels] on the
+ /// Windows Dev Center site. The `SECURITY_SQOS_PRESENT` flag is set
+ /// automatically when using this method.
+
+ /// # Examples
+ ///
+ /// ```no_run
+ /// # #[cfg(for_demonstration_only)]
+ /// extern crate winapi;
+ /// # mod winapi { pub const SECURITY_IDENTIFICATION: u32 = 0; }
+ /// use std::fs::OpenOptions;
+ /// use std::os::windows::prelude::*;
+ ///
+ /// let file = OpenOptions::new()
+ /// .write(true)
+ /// .create(true)
+ ///
+ /// // Sets the flag value to `SecurityIdentification`.
+ /// .security_qos_flags(winapi::SECURITY_IDENTIFICATION)
+ ///
+ /// .open(r"\\.\pipe\MyPipe");
+ /// ```
+ ///
+ /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea
+ /// [`CreateFile2`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfile2
+ /// [Impersonation Levels]:
+ /// https://docs.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-security_impersonation_level
+ #[stable(feature = "open_options_ext", since = "1.10.0")]
+ fn security_qos_flags(&mut self, flags: u32) -> &mut Self;
+}
+
+#[stable(feature = "open_options_ext", since = "1.10.0")]
+impl OpenOptionsExt for OpenOptions {
+ fn access_mode(&mut self, access: u32) -> &mut OpenOptions {
+ self.as_inner_mut().access_mode(access);
+ self
+ }
+
+ fn share_mode(&mut self, share: u32) -> &mut OpenOptions {
+ self.as_inner_mut().share_mode(share);
+ self
+ }
+
+ fn custom_flags(&mut self, flags: u32) -> &mut OpenOptions {
+ self.as_inner_mut().custom_flags(flags);
+ self
+ }
+
+ fn attributes(&mut self, attributes: u32) -> &mut OpenOptions {
+ self.as_inner_mut().attributes(attributes);
+ self
+ }
+
+ fn security_qos_flags(&mut self, flags: u32) -> &mut OpenOptions {
+ self.as_inner_mut().security_qos_flags(flags);
+ self
+ }
+}
+
+/// Windows-specific extensions to [`fs::Metadata`].
+///
+/// The data members that this trait exposes correspond to the members
+/// of the [`BY_HANDLE_FILE_INFORMATION`] structure.
+///
+/// [`BY_HANDLE_FILE_INFORMATION`]:
+/// https://docs.microsoft.com/en-us/windows/win32/api/fileapi/ns-fileapi-by_handle_file_information
+#[stable(feature = "metadata_ext", since = "1.1.0")]
+pub trait MetadataExt {
+ /// Returns the value of the `dwFileAttributes` field of this metadata.
+ ///
+ /// This field contains the file system attribute information for a file
+ /// or directory. For possible values and their descriptions, see
+ /// [File Attribute Constants] in the Windows Dev Center.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::io;
+ /// use std::fs;
+ /// use std::os::windows::prelude::*;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let metadata = fs::metadata("foo.txt")?;
+ /// let attributes = metadata.file_attributes();
+ /// Ok(())
+ /// }
+ /// ```
+ ///
+ /// [File Attribute Constants]:
+ /// https://docs.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn file_attributes(&self) -> u32;
+
+ /// Returns the value of the `ftCreationTime` field of this metadata.
+ ///
+ /// The returned 64-bit value is equivalent to a [`FILETIME`] struct,
+ /// which represents the number of 100-nanosecond intervals since
+ /// January 1, 1601 (UTC). The struct is automatically
+ /// converted to a `u64` value, as that is the recommended way
+ /// to use it.
+ ///
+ /// If the underlying filesystem does not support creation time, the
+ /// returned value is 0.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::io;
+ /// use std::fs;
+ /// use std::os::windows::prelude::*;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let metadata = fs::metadata("foo.txt")?;
+ /// let creation_time = metadata.creation_time();
+ /// Ok(())
+ /// }
+ /// ```
+ ///
+ /// [`FILETIME`]: https://docs.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-filetime
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn creation_time(&self) -> u64;
+
+ /// Returns the value of the `ftLastAccessTime` field of this metadata.
+ ///
+ /// The returned 64-bit value is equivalent to a [`FILETIME`] struct,
+ /// which represents the number of 100-nanosecond intervals since
+ /// January 1, 1601 (UTC). The struct is automatically
+ /// converted to a `u64` value, as that is the recommended way
+ /// to use it.
+ ///
+ /// For a file, the value specifies the last time that a file was read
+ /// from or written to. For a directory, the value specifies when
+ /// the directory was created. For both files and directories, the
+ /// specified date is correct, but the time of day is always set to
+ /// midnight.
+ ///
+ /// If the underlying filesystem does not support last access time, the
+ /// returned value is 0.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::io;
+ /// use std::fs;
+ /// use std::os::windows::prelude::*;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let metadata = fs::metadata("foo.txt")?;
+ /// let last_access_time = metadata.last_access_time();
+ /// Ok(())
+ /// }
+ /// ```
+ ///
+ /// [`FILETIME`]: https://docs.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-filetime
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn last_access_time(&self) -> u64;
+
+ /// Returns the value of the `ftLastWriteTime` field of this metadata.
+ ///
+ /// The returned 64-bit value is equivalent to a [`FILETIME`] struct,
+ /// which represents the number of 100-nanosecond intervals since
+ /// January 1, 1601 (UTC). The struct is automatically
+ /// converted to a `u64` value, as that is the recommended way
+ /// to use it.
+ ///
+ /// For a file, the value specifies the last time that a file was written
+ /// to. For a directory, the structure specifies when the directory was
+ /// created.
+ ///
+ /// If the underlying filesystem does not support the last write time,
+ /// the returned value is 0.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::io;
+ /// use std::fs;
+ /// use std::os::windows::prelude::*;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let metadata = fs::metadata("foo.txt")?;
+ /// let last_write_time = metadata.last_write_time();
+ /// Ok(())
+ /// }
+ /// ```
+ ///
+ /// [`FILETIME`]: https://docs.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-filetime
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn last_write_time(&self) -> u64;
+
+ /// Returns the value of the `nFileSize{High,Low}` fields of this
+ /// metadata.
+ ///
+ /// The returned value does not have meaning for directories.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use std::io;
+ /// use std::fs;
+ /// use std::os::windows::prelude::*;
+ ///
+ /// fn main() -> io::Result<()> {
+ /// let metadata = fs::metadata("foo.txt")?;
+ /// let file_size = metadata.file_size();
+ /// Ok(())
+ /// }
+ /// ```
+ #[stable(feature = "metadata_ext", since = "1.1.0")]
+ fn file_size(&self) -> u64;
+
+ /// Returns the value of the `dwVolumeSerialNumber` field of this
+ /// metadata.
+ ///
+ /// This will return `None` if the `Metadata` instance was created from a
+ /// call to `DirEntry::metadata`. If this `Metadata` was created by using
+ /// `fs::metadata` or `File::metadata`, then this will return `Some`.
+ #[unstable(feature = "windows_by_handle", issue = "63010")]
+ fn volume_serial_number(&self) -> Option<u32>;
+
+ /// Returns the value of the `nNumberOfLinks` field of this
+ /// metadata.
+ ///
+ /// This will return `None` if the `Metadata` instance was created from a
+ /// call to `DirEntry::metadata`. If this `Metadata` was created by using
+ /// `fs::metadata` or `File::metadata`, then this will return `Some`.
+ #[unstable(feature = "windows_by_handle", issue = "63010")]
+ fn number_of_links(&self) -> Option<u32>;
+
+ /// Returns the value of the `nFileIndex{Low,High}` fields of this
+ /// metadata.
+ ///
+ /// This will return `None` if the `Metadata` instance was created from a
+ /// call to `DirEntry::metadata`. If this `Metadata` was created by using
+ /// `fs::metadata` or `File::metadata`, then this will return `Some`.
+ #[unstable(feature = "windows_by_handle", issue = "63010")]
+ fn file_index(&self) -> Option<u64>;
+}
+
+#[stable(feature = "metadata_ext", since = "1.1.0")]
+impl MetadataExt for Metadata {
+ fn file_attributes(&self) -> u32 {
+ self.as_inner().attrs()
+ }
+ fn creation_time(&self) -> u64 {
+ self.as_inner().created_u64()
+ }
+ fn last_access_time(&self) -> u64 {
+ self.as_inner().accessed_u64()
+ }
+ fn last_write_time(&self) -> u64 {
+ self.as_inner().modified_u64()
+ }
+ fn file_size(&self) -> u64 {
+ self.as_inner().size()
+ }
+ fn volume_serial_number(&self) -> Option<u32> {
+ self.as_inner().volume_serial_number()
+ }
+ fn number_of_links(&self) -> Option<u32> {
+ self.as_inner().number_of_links()
+ }
+ fn file_index(&self) -> Option<u64> {
+ self.as_inner().file_index()
+ }
+}
+
+/// Windows-specific extensions to [`fs::FileType`].
+///
+/// On Windows, a symbolic link knows whether it is a file or directory.
+#[unstable(feature = "windows_file_type_ext", issue = "none")]
+pub trait FileTypeExt {
+ /// Returns `true` if this file type is a symbolic link that is also a directory.
+ #[unstable(feature = "windows_file_type_ext", issue = "none")]
+ fn is_symlink_dir(&self) -> bool;
+ /// Returns `true` if this file type is a symbolic link that is also a file.
+ #[unstable(feature = "windows_file_type_ext", issue = "none")]
+ fn is_symlink_file(&self) -> bool;
+}
+
+#[unstable(feature = "windows_file_type_ext", issue = "none")]
+impl FileTypeExt for fs::FileType {
+ fn is_symlink_dir(&self) -> bool {
+ self.as_inner().is_symlink_dir()
+ }
+ fn is_symlink_file(&self) -> bool {
+ self.as_inner().is_symlink_file()
+ }
+}
+
+/// Creates a new file symbolic link on the filesystem.
+///
+/// The `link` path will be a file symbolic link pointing to the `original`
+/// path.
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::os::windows::fs;
+///
+/// fn main() -> std::io::Result<()> {
+/// fs::symlink_file("a.txt", "b.txt")?;
+/// Ok(())
+/// }
+/// ```
+#[stable(feature = "symlink", since = "1.1.0")]
+pub fn symlink_file<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Result<()> {
+ sys::fs::symlink_inner(original.as_ref(), link.as_ref(), false)
+}
+
+/// Creates a new directory symlink on the filesystem.
+///
+/// The `link` path will be a directory symbolic link pointing to the `original`
+/// path.
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::os::windows::fs;
+///
+/// fn main() -> std::io::Result<()> {
+/// fs::symlink_dir("a", "b")?;
+/// Ok(())
+/// }
+/// ```
+#[stable(feature = "symlink", since = "1.1.0")]
+pub fn symlink_dir<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Result<()> {
+ sys::fs::symlink_inner(original.as_ref(), link.as_ref(), true)
+}
--- /dev/null
+//! Windows-specific extensions to general I/O primitives.
+
+#![stable(feature = "rust1", since = "1.0.0")]
+
+use crate::fs;
+use crate::io;
+use crate::net;
+use crate::os::windows::raw;
+use crate::sys;
+use crate::sys::c;
+use crate::sys_common::{self, AsInner, FromInner, IntoInner};
+
+/// Raw HANDLEs.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub type RawHandle = raw::HANDLE;
+
+/// Raw SOCKETs.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub type RawSocket = raw::SOCKET;
+
+/// Extracts raw handles.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub trait AsRawHandle {
+ /// Extracts the raw handle, without taking any ownership.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn as_raw_handle(&self) -> RawHandle;
+}
+
+/// Construct I/O objects from raw handles.
+#[stable(feature = "from_raw_os", since = "1.1.0")]
+pub trait FromRawHandle {
+ /// Constructs a new I/O object from the specified raw handle.
+ ///
+ /// This function will **consume ownership** of the handle given,
+ /// passing responsibility for closing the handle to the returned
+ /// object.
+ ///
+ /// This function is also unsafe as the primitives currently returned
+ /// have the contract that they are the sole owner of the file
+ /// descriptor they are wrapping. Usage of this function could
+ /// accidentally allow violating this contract which can cause memory
+ /// unsafety in code that relies on it being true.
+ #[stable(feature = "from_raw_os", since = "1.1.0")]
+ unsafe fn from_raw_handle(handle: RawHandle) -> Self;
+}
+
+/// A trait to express the ability to consume an object and acquire ownership of
+/// its raw `HANDLE`.
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+pub trait IntoRawHandle {
+ /// Consumes this object, returning the raw underlying handle.
+ ///
+ /// This function **transfers ownership** of the underlying handle to the
+ /// caller. Callers are then the unique owners of the handle and must close
+ /// it once it's no longer needed.
+ #[stable(feature = "into_raw_os", since = "1.4.0")]
+ fn into_raw_handle(self) -> RawHandle;
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl AsRawHandle for fs::File {
+ #[inline]
+ fn as_raw_handle(&self) -> RawHandle {
+ self.as_inner().handle().raw() as RawHandle
+ }
+}
+
+#[stable(feature = "asraw_stdio", since = "1.21.0")]
+impl AsRawHandle for io::Stdin {
+ fn as_raw_handle(&self) -> RawHandle {
+ unsafe { c::GetStdHandle(c::STD_INPUT_HANDLE) as RawHandle }
+ }
+}
+
+#[stable(feature = "asraw_stdio", since = "1.21.0")]
+impl AsRawHandle for io::Stdout {
+ fn as_raw_handle(&self) -> RawHandle {
+ unsafe { c::GetStdHandle(c::STD_OUTPUT_HANDLE) as RawHandle }
+ }
+}
+
+#[stable(feature = "asraw_stdio", since = "1.21.0")]
+impl AsRawHandle for io::Stderr {
+ fn as_raw_handle(&self) -> RawHandle {
+ unsafe { c::GetStdHandle(c::STD_ERROR_HANDLE) as RawHandle }
+ }
+}
+
+#[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
+impl<'a> AsRawHandle for io::StdinLock<'a> {
+ fn as_raw_handle(&self) -> RawHandle {
+ unsafe { c::GetStdHandle(c::STD_INPUT_HANDLE) as RawHandle }
+ }
+}
+
+#[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
+impl<'a> AsRawHandle for io::StdoutLock<'a> {
+ fn as_raw_handle(&self) -> RawHandle {
+ unsafe { c::GetStdHandle(c::STD_OUTPUT_HANDLE) as RawHandle }
+ }
+}
+
+#[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
+impl<'a> AsRawHandle for io::StderrLock<'a> {
+ fn as_raw_handle(&self) -> RawHandle {
+ unsafe { c::GetStdHandle(c::STD_ERROR_HANDLE) as RawHandle }
+ }
+}
+
+#[stable(feature = "from_raw_os", since = "1.1.0")]
+impl FromRawHandle for fs::File {
+ #[inline]
+ unsafe fn from_raw_handle(handle: RawHandle) -> fs::File {
+ let handle = handle as c::HANDLE;
+ fs::File::from_inner(sys::fs::File::from_inner(handle))
+ }
+}
+
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+impl IntoRawHandle for fs::File {
+ #[inline]
+ fn into_raw_handle(self) -> RawHandle {
+ self.into_inner().into_handle().into_raw() as *mut _
+ }
+}
+
+/// Extracts raw sockets.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub trait AsRawSocket {
+ /// Extracts the underlying raw socket from this object.
+ #[stable(feature = "rust1", since = "1.0.0")]
+ fn as_raw_socket(&self) -> RawSocket;
+}
+
+/// Creates I/O objects from raw sockets.
+#[stable(feature = "from_raw_os", since = "1.1.0")]
+pub trait FromRawSocket {
+ /// Creates a new I/O object from the given raw socket.
+ ///
+ /// This function will **consume ownership** of the socket provided and
+ /// it will be closed when the returned object goes out of scope.
+ ///
+ /// This function is also unsafe as the primitives currently returned
+ /// have the contract that they are the sole owner of the file
+ /// descriptor they are wrapping. Usage of this function could
+ /// accidentally allow violating this contract which can cause memory
+ /// unsafety in code that relies on it being true.
+ #[stable(feature = "from_raw_os", since = "1.1.0")]
+ unsafe fn from_raw_socket(sock: RawSocket) -> Self;
+}
+
+/// A trait to express the ability to consume an object and acquire ownership of
+/// its raw `SOCKET`.
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+pub trait IntoRawSocket {
+ /// Consumes this object, returning the raw underlying socket.
+ ///
+ /// This function **transfers ownership** of the underlying socket to the
+ /// caller. Callers are then the unique owners of the socket and must close
+ /// it once it's no longer needed.
+ #[stable(feature = "into_raw_os", since = "1.4.0")]
+ fn into_raw_socket(self) -> RawSocket;
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl AsRawSocket for net::TcpStream {
+ #[inline]
+ fn as_raw_socket(&self) -> RawSocket {
+ *self.as_inner().socket().as_inner()
+ }
+}
+#[stable(feature = "rust1", since = "1.0.0")]
+impl AsRawSocket for net::TcpListener {
+ #[inline]
+ fn as_raw_socket(&self) -> RawSocket {
+ *self.as_inner().socket().as_inner()
+ }
+}
+#[stable(feature = "rust1", since = "1.0.0")]
+impl AsRawSocket for net::UdpSocket {
+ #[inline]
+ fn as_raw_socket(&self) -> RawSocket {
+ *self.as_inner().socket().as_inner()
+ }
+}
+
+#[stable(feature = "from_raw_os", since = "1.1.0")]
+impl FromRawSocket for net::TcpStream {
+ #[inline]
+ unsafe fn from_raw_socket(sock: RawSocket) -> net::TcpStream {
+ let sock = sys::net::Socket::from_inner(sock);
+ net::TcpStream::from_inner(sys_common::net::TcpStream::from_inner(sock))
+ }
+}
+#[stable(feature = "from_raw_os", since = "1.1.0")]
+impl FromRawSocket for net::TcpListener {
+ #[inline]
+ unsafe fn from_raw_socket(sock: RawSocket) -> net::TcpListener {
+ let sock = sys::net::Socket::from_inner(sock);
+ net::TcpListener::from_inner(sys_common::net::TcpListener::from_inner(sock))
+ }
+}
+#[stable(feature = "from_raw_os", since = "1.1.0")]
+impl FromRawSocket for net::UdpSocket {
+ #[inline]
+ unsafe fn from_raw_socket(sock: RawSocket) -> net::UdpSocket {
+ let sock = sys::net::Socket::from_inner(sock);
+ net::UdpSocket::from_inner(sys_common::net::UdpSocket::from_inner(sock))
+ }
+}
+
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+impl IntoRawSocket for net::TcpStream {
+ #[inline]
+ fn into_raw_socket(self) -> RawSocket {
+ self.into_inner().into_socket().into_inner()
+ }
+}
+
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+impl IntoRawSocket for net::TcpListener {
+ #[inline]
+ fn into_raw_socket(self) -> RawSocket {
+ self.into_inner().into_socket().into_inner()
+ }
+}
+
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+impl IntoRawSocket for net::UdpSocket {
+ #[inline]
+ fn into_raw_socket(self) -> RawSocket {
+ self.into_inner().into_socket().into_inner()
+ }
+}
--- /dev/null
+//! Platform-specific extensions to `std` for Windows.
+//!
+//! Provides access to platform-level information for Windows, and exposes
+//! Windows-specific idioms that would otherwise be inappropriate as part
+//! the core `std` library. These extensions allow developers to use
+//! `std` types and idioms with Windows in a way that the normal
+//! platform-agnostic idioms would not normally support.
+
+#![stable(feature = "rust1", since = "1.0.0")]
+#![doc(cfg(windows))]
+
+pub mod ffi;
+pub mod fs;
+pub mod io;
+pub mod process;
+pub mod raw;
+pub mod thread;
+
+/// A prelude for conveniently writing platform-specific code.
+///
+/// Includes all extension traits, and some important type definitions.
+#[stable(feature = "rust1", since = "1.0.0")]
+pub mod prelude {
+ #[doc(no_inline)]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub use super::ffi::{OsStrExt, OsStringExt};
+ #[doc(no_inline)]
+ #[stable(feature = "file_offset", since = "1.15.0")]
+ pub use super::fs::FileExt;
+ #[doc(no_inline)]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub use super::fs::{MetadataExt, OpenOptionsExt};
+ #[doc(no_inline)]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub use super::io::{AsRawHandle, AsRawSocket, RawHandle, RawSocket};
+ #[doc(no_inline)]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub use super::io::{FromRawHandle, FromRawSocket, IntoRawHandle, IntoRawSocket};
+}
--- /dev/null
+//! Extensions to `std::process` for Windows.
+
+#![stable(feature = "process_extensions", since = "1.2.0")]
+
+use crate::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
+use crate::process;
+use crate::sealed::Sealed;
+use crate::sys;
+use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
+
+#[stable(feature = "process_extensions", since = "1.2.0")]
+impl FromRawHandle for process::Stdio {
+ unsafe fn from_raw_handle(handle: RawHandle) -> process::Stdio {
+ let handle = sys::handle::Handle::new(handle as *mut _);
+ let io = sys::process::Stdio::Handle(handle);
+ process::Stdio::from_inner(io)
+ }
+}
+
+#[stable(feature = "process_extensions", since = "1.2.0")]
+impl AsRawHandle for process::Child {
+ #[inline]
+ fn as_raw_handle(&self) -> RawHandle {
+ self.as_inner().handle().raw() as *mut _
+ }
+}
+
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+impl IntoRawHandle for process::Child {
+ fn into_raw_handle(self) -> RawHandle {
+ self.into_inner().into_handle().into_raw() as *mut _
+ }
+}
+
+#[stable(feature = "process_extensions", since = "1.2.0")]
+impl AsRawHandle for process::ChildStdin {
+ #[inline]
+ fn as_raw_handle(&self) -> RawHandle {
+ self.as_inner().handle().raw() as *mut _
+ }
+}
+
+#[stable(feature = "process_extensions", since = "1.2.0")]
+impl AsRawHandle for process::ChildStdout {
+ #[inline]
+ fn as_raw_handle(&self) -> RawHandle {
+ self.as_inner().handle().raw() as *mut _
+ }
+}
+
+#[stable(feature = "process_extensions", since = "1.2.0")]
+impl AsRawHandle for process::ChildStderr {
+ #[inline]
+ fn as_raw_handle(&self) -> RawHandle {
+ self.as_inner().handle().raw() as *mut _
+ }
+}
+
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+impl IntoRawHandle for process::ChildStdin {
+ fn into_raw_handle(self) -> RawHandle {
+ self.into_inner().into_handle().into_raw() as *mut _
+ }
+}
+
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+impl IntoRawHandle for process::ChildStdout {
+ fn into_raw_handle(self) -> RawHandle {
+ self.into_inner().into_handle().into_raw() as *mut _
+ }
+}
+
+#[stable(feature = "into_raw_os", since = "1.4.0")]
+impl IntoRawHandle for process::ChildStderr {
+ fn into_raw_handle(self) -> RawHandle {
+ self.into_inner().into_handle().into_raw() as *mut _
+ }
+}
+
+/// Windows-specific extensions to [`process::ExitStatus`].
+///
+/// This trait is sealed: it cannot be implemented outside the standard library.
+/// This is so that future additional methods are not breaking changes.
+#[stable(feature = "exit_status_from", since = "1.12.0")]
+pub trait ExitStatusExt: Sealed {
+ /// Creates a new `ExitStatus` from the raw underlying `u32` return value of
+ /// a process.
+ #[stable(feature = "exit_status_from", since = "1.12.0")]
+ fn from_raw(raw: u32) -> Self;
+}
+
+#[stable(feature = "exit_status_from", since = "1.12.0")]
+impl ExitStatusExt for process::ExitStatus {
+ fn from_raw(raw: u32) -> Self {
+ process::ExitStatus::from_inner(From::from(raw))
+ }
+}
+
+/// Windows-specific extensions to the [`process::Command`] builder.
+///
+/// This trait is sealed: it cannot be implemented outside the standard library.
+/// This is so that future additional methods are not breaking changes.
+#[stable(feature = "windows_process_extensions", since = "1.16.0")]
+pub trait CommandExt: Sealed {
+ /// Sets the [process creation flags][1] to be passed to `CreateProcess`.
+ ///
+ /// These will always be ORed with `CREATE_UNICODE_ENVIRONMENT`.
+ ///
+ /// [1]: https://docs.microsoft.com/en-us/windows/win32/procthread/process-creation-flags
+ #[stable(feature = "windows_process_extensions", since = "1.16.0")]
+ fn creation_flags(&mut self, flags: u32) -> &mut process::Command;
+
+ /// Forces all arguments to be wrapped in quote (`"`) characters.
+ ///
+ /// This is useful for passing arguments to [MSYS2/Cygwin][1] based
+ /// executables: these programs will expand unquoted arguments containing
+ /// wildcard characters (`?` and `*`) by searching for any file paths
+ /// matching the wildcard pattern.
+ ///
+ /// Adding quotes has no effect when passing arguments to programs
+ /// that use [msvcrt][2]. This includes programs built with both
+ /// MinGW and MSVC.
+ ///
+ /// [1]: <https://github.com/msys2/MSYS2-packages/issues/2176>
+ /// [2]: <https://msdn.microsoft.com/en-us/library/17w5ykft.aspx>
+ #[unstable(feature = "windows_process_extensions_force_quotes", issue = "82227")]
+ fn force_quotes(&mut self, enabled: bool) -> &mut process::Command;
+}
+
+#[stable(feature = "windows_process_extensions", since = "1.16.0")]
+impl CommandExt for process::Command {
+ fn creation_flags(&mut self, flags: u32) -> &mut process::Command {
+ self.as_inner_mut().creation_flags(flags);
+ self
+ }
+
+ fn force_quotes(&mut self, enabled: bool) -> &mut process::Command {
+ self.as_inner_mut().force_quotes(enabled);
+ self
+ }
+}
--- /dev/null
+//! Windows-specific primitives.
+
+#![stable(feature = "raw_ext", since = "1.1.0")]
+
+use crate::os::raw::c_void;
+
+#[stable(feature = "raw_ext", since = "1.1.0")]
+pub type HANDLE = *mut c_void;
+#[cfg(target_pointer_width = "32")]
+#[stable(feature = "raw_ext", since = "1.1.0")]
+pub type SOCKET = u32;
+#[cfg(target_pointer_width = "64")]
+#[stable(feature = "raw_ext", since = "1.1.0")]
+pub type SOCKET = u64;
--- /dev/null
+//! Extensions to `std::thread` for Windows.
+
+#![stable(feature = "thread_extensions", since = "1.9.0")]
+
+use crate::os::windows::io::{AsRawHandle, IntoRawHandle, RawHandle};
+use crate::sys_common::{AsInner, IntoInner};
+use crate::thread;
+
+#[stable(feature = "thread_extensions", since = "1.9.0")]
+impl<T> AsRawHandle for thread::JoinHandle<T> {
+ #[inline]
+ fn as_raw_handle(&self) -> RawHandle {
+ self.as_inner().handle().raw() as *mut _
+ }
+}
+
+#[stable(feature = "thread_extensions", since = "1.9.0")]
+impl<T> IntoRawHandle for thread::JoinHandle<T> {
+ #[inline]
+ fn into_raw_handle(self) -> RawHandle {
+ self.into_inner().into_handle().into_raw() as *mut _
+ }
+}
/// Note that here the call to [`drop`] is for clarity - it indicates
/// that we are done with the given value and it should be destroyed.
///
-/// ## 3. Get it from C.
+/// ## 3. Create it using `ptr::addr_of!`
+///
+/// Instead of coercing a reference to a raw pointer, you can use the macros
+/// [`ptr::addr_of!`] (for `*const T`) and [`ptr::addr_of_mut!`] (for `*mut T`).
+/// These macros allow you to create raw pointers to fields to which you cannot
+/// create a reference (without causing undefined behaviour), such as an
+/// unaligned field. This might be necessary if packed structs or uninitialized
+/// memory is involved.
+///
+/// ```
+/// #[derive(Debug, Default, Copy, Clone)]
+/// #[repr(C, packed)]
+/// struct S {
+/// aligned: u8,
+/// unaligned: u32,
+/// }
+/// let s = S::default();
+/// let p = std::ptr::addr_of!(s.unaligned); // not allowed with coercion
+/// ```
+///
+/// ## 4. Get it from C.
///
/// ```
/// # #![feature(rustc_private)]
/// # Editions
///
/// Prior to Rust 1.53, arrays did not implement `IntoIterator` by value, so the method call
-/// `array.into_iter()` auto-referenced into a slice iterator. That behavior is preserved in the
-/// 2015 and 2018 editions of Rust for compatability, ignoring `IntoIterator` by value.
+/// `array.into_iter()` auto-referenced into a slice iterator. Right now, the old behavior
+/// is preserved in the 2015 and 2018 editions of Rust for compatibility, ignoring
+/// `IntoIterator` by value. In the future, the behavior on the 2015 and 2018 edition
+/// might be made consistent to the behavior of later editions.
///
#[cfg_attr(bootstrap, doc = "```rust,edition2018,ignore")]
#[cfg_attr(not(bootstrap), doc = "```rust,edition2018")]
/// }
/// ```
///
+/// Future language versions might start treating the `array.into_iter()`
+/// syntax on editions 2015 and 2018 the same as on edition 2021. So code using
+/// those older editions should still be written with this change in mind, to
+/// prevent breakage in the future. The safest way to accomplish this is to
+/// avoid the `into_iter` syntax on those editions. If an edition update is not
+/// viable/desired, there are multiple alternatives:
+/// * use `iter`, equivalent to the old behavior, creating references
+/// * use [`array::IntoIter`], equivalent to the post-2021 behavior (Rust 1.51+)
+/// * replace `for ... in array.into_iter() {` with `for ... in array {`,
+/// equivalent to the post-2021 behavior (Rust 1.53+)
+///
+#[cfg_attr(bootstrap, doc = "```rust,edition2018,ignore")]
+#[cfg_attr(not(bootstrap), doc = "```rust,edition2018")]
+/// use std::array::IntoIter;
+///
+/// let array: [i32; 3] = [0; 3];
+///
+/// // This iterates by reference:
+/// for item in array.iter() {
+/// let x: &i32 = item;
+/// println!("{}", x);
+/// }
+///
+/// // This iterates by value:
+/// for item in IntoIter::new(array) {
+/// let x: i32 = item;
+/// println!("{}", x);
+/// }
+///
+/// // This iterates by value:
+/// for item in array {
+/// let x: i32 = item;
+/// println!("{}", x);
+/// }
+///
+/// // IntoIter can also start a chain.
+/// // This iterates by value:
+/// for item in IntoIter::new(array).enumerate() {
+/// let (i, x): (usize, i32) = item;
+/// println!("array[{}] = {}", i, x);
+/// }
+/// ```
+///
/// [slice]: prim@slice
/// [`Debug`]: fmt::Debug
/// [`Hash`]: hash::Hash
+++ /dev/null
-// These symbols are all defined in `compiler-builtins`
-extern "C" {
- pub fn acos(n: f64) -> f64;
- pub fn acosf(n: f32) -> f32;
- pub fn asin(n: f64) -> f64;
- pub fn asinf(n: f32) -> f32;
- pub fn atan(n: f64) -> f64;
- pub fn atan2(a: f64, b: f64) -> f64;
- pub fn atan2f(a: f32, b: f32) -> f32;
- pub fn atanf(n: f32) -> f32;
- pub fn cbrt(n: f64) -> f64;
- pub fn cbrtf(n: f32) -> f32;
- pub fn cosh(n: f64) -> f64;
- pub fn coshf(n: f32) -> f32;
- pub fn expm1(n: f64) -> f64;
- pub fn expm1f(n: f32) -> f32;
- pub fn fdim(a: f64, b: f64) -> f64;
- pub fn fdimf(a: f32, b: f32) -> f32;
- pub fn hypot(x: f64, y: f64) -> f64;
- pub fn hypotf(x: f32, y: f32) -> f32;
- pub fn log1p(n: f64) -> f64;
- pub fn log1pf(n: f32) -> f32;
- pub fn sinh(n: f64) -> f64;
- pub fn sinhf(n: f32) -> f32;
- pub fn tan(n: f64) -> f64;
- pub fn tanf(n: f32) -> f32;
- pub fn tanh(n: f64) -> f64;
- pub fn tanhf(n: f32) -> f32;
-}
+++ /dev/null
-//! HermitCore-specific extension to the primitives in the `std::ffi` module
-//!
-//! # Examples
-//!
-//! ```
-//! use std::ffi::OsString;
-//! use std::os::hermit::ffi::OsStringExt;
-//!
-//! let bytes = b"foo".to_vec();
-//!
-//! // OsStringExt::from_vec
-//! let os_string = OsString::from_vec(bytes);
-//! assert_eq!(os_string.to_str(), Some("foo"));
-//!
-//! // OsStringExt::into_vec
-//! let bytes = os_string.into_vec();
-//! assert_eq!(bytes, b"foo");
-//! ```
-//!
-//! ```
-//! use std::ffi::OsStr;
-//! use std::os::hermit::ffi::OsStrExt;
-//!
-//! let bytes = b"foo";
-//!
-//! // OsStrExt::from_bytes
-//! let os_str = OsStr::from_bytes(bytes);
-//! assert_eq!(os_str.to_str(), Some("foo"));
-//!
-//! // OsStrExt::as_bytes
-//! let bytes = os_str.as_bytes();
-//! assert_eq!(bytes, b"foo");
-//! ```
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use crate::sys_common::os_str_bytes::*;
+++ /dev/null
-#![stable(feature = "rust1", since = "1.0.0")]
-#![allow(missing_docs)]
-
-pub mod ffi;
-
-/// A prelude for conveniently writing platform-specific code.
-///
-/// Includes all extension traits, and some important type definitions.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub mod prelude {
- #[doc(no_inline)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use super::ffi::{OsStrExt, OsStringExt};
-}
pub mod alloc;
pub mod args;
+#[path = "../unix/cmath.rs"]
pub mod cmath;
pub mod condvar;
pub mod env;
-pub mod ext;
pub mod fd;
pub mod fs;
#[path = "../unsupported/io.rs"]
}
}
-// Import essential modules from both platforms when documenting. These are
-// then later used in the `std::os` module when documenting, for example,
-// Windows when we're compiling for Linux.
+// Import essential modules from platforms used in `std::os` when documenting.
+//
+// Note that on some platforms those modules don't compile
+// (missing things in `libc` which is empty), so they are not included in `std::os` and can be
+// omitted here as well.
#[cfg(doc)]
+#[cfg(not(any(
+ all(target_arch = "wasm32", not(target_os = "wasi")),
+ all(target_vendor = "fortanix", target_env = "sgx")
+)))]
cfg_if::cfg_if! {
- if #[cfg(unix)] {
- // On unix we'll document what's already available
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use self::ext as unix_ext;
- } else if #[cfg(any(target_os = "hermit",
- all(target_arch = "wasm32", not(target_os = "wasi")),
- all(target_vendor = "fortanix", target_env = "sgx")))] {
- // On non-WASI wasm right now the module below doesn't compile
- // (missing things in `libc` which is empty) so just omit everything
- // with an empty module
- #[unstable(issue = "none", feature = "std_internals")]
- #[allow(missing_docs)]
- pub mod unix_ext {}
- } else {
- #[path = "unix/ext/mod.rs"]
- pub mod unix_ext;
- }
-}
-
-#[cfg(doc)]
-cfg_if::cfg_if! {
- if #[cfg(windows)] {
- // On windows we'll just be documenting what's already available
- #[allow(missing_docs)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use self::ext as windows_ext;
- } else if #[cfg(any(target_os = "hermit",
- all(target_arch = "wasm32", not(target_os = "wasi")),
- all(target_vendor = "fortanix", target_env = "sgx")))] {
- // On non-WASI wasm right now the shim below doesn't compile, so
- // just omit it
- #[unstable(issue = "none", feature = "std_internals")]
- #[allow(missing_docs)]
- pub mod windows_ext {}
- } else {
- // On all other platforms (aka linux/osx/etc) then pull in a "minimal"
+ if #[cfg(not(windows))] {
+ // On non-Windows platforms (aka linux/osx/etc) pull in a "minimal"
// amount of windows goop which ends up compiling
+
#[macro_use]
#[path = "windows/compat.rs"]
- mod compat;
+ pub mod compat;
#[path = "windows/c.rs"]
- mod c;
-
- #[path = "windows/ext/mod.rs"]
- pub mod windows_ext;
- }
-}
-
-#[cfg(doc)]
-cfg_if::cfg_if! {
- if #[cfg(target_os = "wasi")] {
- // On WASI we'll document what's already available
- #[stable(feature = "wasi_ext_doc", since = "1.35.0")]
- pub use self::ext as wasi_ext;
- } else if #[cfg(any(target_os = "hermit",
- target_arch = "wasm32",
- all(target_vendor = "fortanix", target_env = "sgx")))] {
- // On non-WASI wasm right now the module below doesn't compile
- // (missing things in `libc` which is empty) so just omit everything
- // with an empty module
- #[unstable(issue = "none", feature = "std_internals")]
- #[allow(missing_docs)]
- pub mod wasi_ext {}
- } else {
- // On other platforms like Windows document the bare bones of WASI
- #[path = "wasi/ext/mod.rs"]
- #[stable(feature = "wasi_ext_doc", since = "1.35.0")]
- pub mod wasi_ext;
+ pub mod c;
}
}
extern "C" fn entry(p1: u64, p2: u64, p3: u64, secondary: bool, p4: u64, p5: u64) -> EntryReturn {
// FIXME: how to support TLS in library mode?
let tls = Box::new(tls::Tls::new());
- let _tls_guard = unsafe { tls.activate() };
+ let tls_guard = unsafe { tls.activate() };
if secondary {
- super::thread::Thread::entry();
+ let join_notifier = super::thread::Thread::entry();
+ drop(tls_guard);
+ drop(join_notifier);
EntryReturn(0, 0)
} else {
+++ /dev/null
-#![cfg(not(test))]
-
-// These symbols are all defined in `compiler-builtins`
-extern "C" {
- pub fn acos(n: f64) -> f64;
- pub fn acosf(n: f32) -> f32;
- pub fn asin(n: f64) -> f64;
- pub fn asinf(n: f32) -> f32;
- pub fn atan(n: f64) -> f64;
- pub fn atan2(a: f64, b: f64) -> f64;
- pub fn atan2f(a: f32, b: f32) -> f32;
- pub fn atanf(n: f32) -> f32;
- pub fn cbrt(n: f64) -> f64;
- pub fn cbrtf(n: f32) -> f32;
- pub fn cosh(n: f64) -> f64;
- pub fn coshf(n: f32) -> f32;
- pub fn expm1(n: f64) -> f64;
- pub fn expm1f(n: f32) -> f32;
- pub fn fdim(a: f64, b: f64) -> f64;
- pub fn fdimf(a: f32, b: f32) -> f32;
- pub fn hypot(x: f64, y: f64) -> f64;
- pub fn hypotf(x: f32, y: f32) -> f32;
- pub fn log1p(n: f64) -> f64;
- pub fn log1pf(n: f32) -> f32;
- pub fn sinh(n: f64) -> f64;
- pub fn sinhf(n: f32) -> f32;
- pub fn tan(n: f64) -> f64;
- pub fn tanf(n: f32) -> f32;
- pub fn tanh(n: f64) -> f64;
- pub fn tanhf(n: f32) -> f32;
-}
+++ /dev/null
-//! SGX-specific access to architectural features.
-//!
-//! The functionality in this module is further documented in the Intel
-//! Software Developer's Manual, Volume 3, Chapter 40.
-#![unstable(feature = "sgx_platform", issue = "56975")]
-
-use crate::mem::MaybeUninit;
-
-/// Wrapper struct to force 16-byte alignment.
-#[repr(align(16))]
-#[unstable(feature = "sgx_platform", issue = "56975")]
-pub struct Align16<T>(pub T);
-
-/// Wrapper struct to force 128-byte alignment.
-#[repr(align(128))]
-#[unstable(feature = "sgx_platform", issue = "56975")]
-pub struct Align128<T>(pub T);
-
-/// Wrapper struct to force 512-byte alignment.
-#[repr(align(512))]
-#[unstable(feature = "sgx_platform", issue = "56975")]
-pub struct Align512<T>(pub T);
-
-const ENCLU_EREPORT: u32 = 0;
-const ENCLU_EGETKEY: u32 = 1;
-
-/// Call the `EGETKEY` instruction to obtain a 128-bit secret key.
-#[unstable(feature = "sgx_platform", issue = "56975")]
-pub fn egetkey(request: &Align512<[u8; 512]>) -> Result<Align16<[u8; 16]>, u32> {
- unsafe {
- let mut out = MaybeUninit::uninit();
- let error;
-
- asm!(
- "enclu",
- inlateout("eax") ENCLU_EGETKEY => error,
- in("rbx") request,
- in("rcx") out.as_mut_ptr(),
- options(nostack),
- );
-
- match error {
- 0 => Ok(out.assume_init()),
- err => Err(err),
- }
- }
-}
-
-/// Call the `EREPORT` instruction.
-///
-/// This creates a cryptographic report describing the contents of the current
-/// enclave. The report may be verified by the enclave described in
-/// `targetinfo`.
-#[unstable(feature = "sgx_platform", issue = "56975")]
-pub fn ereport(
- targetinfo: &Align512<[u8; 512]>,
- reportdata: &Align128<[u8; 64]>,
-) -> Align512<[u8; 432]> {
- unsafe {
- let mut report = MaybeUninit::uninit();
-
- asm!(
- "enclu",
- in("eax") ENCLU_EREPORT,
- in("rbx") targetinfo,
- in("rcx") reportdata,
- in("rdx") report.as_mut_ptr(),
- options(preserves_flags, nostack),
- );
-
- report.assume_init()
- }
-}
+++ /dev/null
-//! SGX-specific extension to the primitives in the `std::ffi` module
-//!
-//! # Examples
-//!
-//! ```
-//! use std::ffi::OsString;
-//! use std::os::fortanix_sgx::ffi::OsStringExt;
-//!
-//! let bytes = b"foo".to_vec();
-//!
-//! // OsStringExt::from_vec
-//! let os_string = OsString::from_vec(bytes);
-//! assert_eq!(os_string.to_str(), Some("foo"));
-//!
-//! // OsStringExt::into_vec
-//! let bytes = os_string.into_vec();
-//! assert_eq!(bytes, b"foo");
-//! ```
-//!
-//! ```
-//! use std::ffi::OsStr;
-//! use std::os::fortanix_sgx::ffi::OsStrExt;
-//!
-//! let bytes = b"foo";
-//!
-//! // OsStrExt::from_bytes
-//! let os_str = OsStr::from_bytes(bytes);
-//! assert_eq!(os_str.to_str(), Some("foo"));
-//!
-//! // OsStrExt::as_bytes
-//! let bytes = os_str.as_bytes();
-//! assert_eq!(bytes, b"foo");
-//! ```
-
-#![unstable(feature = "sgx_platform", issue = "56975")]
-
-#[unstable(feature = "sgx_platform", issue = "56975")]
-pub use crate::sys_common::os_str_bytes::*;
+++ /dev/null
-//! SGX-specific extensions to general I/O primitives
-//!
-//! SGX file descriptors behave differently from Unix file descriptors. See the
-//! description of [`TryIntoRawFd`] for more details.
-#![unstable(feature = "sgx_platform", issue = "56975")]
-
-use crate::net;
-pub use crate::sys::abi::usercalls::raw::Fd as RawFd;
-use crate::sys::{self, AsInner, FromInner, IntoInner, TryIntoInner};
-
-/// A trait to extract the raw SGX file descriptor from an underlying
-/// object.
-#[unstable(feature = "sgx_platform", issue = "56975")]
-pub trait AsRawFd {
- /// Extracts the raw file descriptor.
- ///
- /// This method does **not** pass ownership of the raw file descriptor
- /// to the caller. The descriptor is only guaranteed to be valid while
- /// the original object has not yet been destroyed.
- #[unstable(feature = "sgx_platform", issue = "56975")]
- fn as_raw_fd(&self) -> RawFd;
-}
-
-/// A trait to express the ability to construct an object from a raw file
-/// descriptor.
-#[unstable(feature = "sgx_platform", issue = "56975")]
-pub trait FromRawFd {
- /// An associated type that contains relevant metadata for `Self`.
- type Metadata: Default;
-
- /// Constructs a new instance of `Self` from the given raw file
- /// descriptor and metadata.
- ///
- /// This function **consumes ownership** of the specified file
- /// descriptor. The returned object will take responsibility for closing
- /// it when the object goes out of scope.
- ///
- /// This function is also unsafe as the primitives currently returned
- /// have the contract that they are the sole owner of the file
- /// descriptor they are wrapping. Usage of this function could
- /// accidentally allow violating this contract which can cause memory
- /// unsafety in code that relies on it being true.
- #[unstable(feature = "sgx_platform", issue = "56975")]
- unsafe fn from_raw_fd(fd: RawFd, metadata: Self::Metadata) -> Self;
-}
-
-/// A trait to express the ability to consume an object and acquire ownership of
-/// its raw file descriptor.
-#[unstable(feature = "sgx_platform", issue = "56975")]
-pub trait TryIntoRawFd: Sized {
- /// Consumes this object, returning the raw underlying file descriptor, if
- /// this object is not cloned.
- ///
- /// This function **transfers ownership** of the underlying file descriptor
- /// to the caller. Callers are then the unique owners of the file descriptor
- /// and must close the descriptor once it's no longer needed.
- ///
- /// Unlike other platforms, on SGX, the file descriptor is shared between
- /// all clones of an object. To avoid race conditions, this function will
- /// only return `Ok` when called on the final clone.
- #[unstable(feature = "sgx_platform", issue = "56975")]
- fn try_into_raw_fd(self) -> Result<RawFd, Self>;
-}
-
-impl AsRawFd for net::TcpStream {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- *self.as_inner().as_inner().as_inner().as_inner()
- }
-}
-
-impl AsRawFd for net::TcpListener {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- *self.as_inner().as_inner().as_inner().as_inner()
- }
-}
-
-/// Metadata for `TcpStream`.
-#[derive(Debug, Clone, Default)]
-#[unstable(feature = "sgx_platform", issue = "56975")]
-pub struct TcpStreamMetadata {
- /// Local address of the TCP stream
- pub local_addr: Option<String>,
- /// Peer address of the TCP stream
- pub peer_addr: Option<String>,
-}
-
-impl FromRawFd for net::TcpStream {
- type Metadata = TcpStreamMetadata;
-
- #[inline]
- unsafe fn from_raw_fd(fd: RawFd, metadata: Self::Metadata) -> net::TcpStream {
- let fd = sys::fd::FileDesc::from_inner(fd);
- let socket = sys::net::Socket::from_inner((fd, metadata.local_addr));
- net::TcpStream::from_inner(sys::net::TcpStream::from_inner((socket, metadata.peer_addr)))
- }
-}
-
-/// Metadata for `TcpListener`.
-#[derive(Debug, Clone, Default)]
-#[unstable(feature = "sgx_platform", issue = "56975")]
-pub struct TcpListenerMetadata {
- /// Local address of the TCP listener
- pub local_addr: Option<String>,
-}
-
-impl FromRawFd for net::TcpListener {
- type Metadata = TcpListenerMetadata;
-
- #[inline]
- unsafe fn from_raw_fd(fd: RawFd, metadata: Self::Metadata) -> net::TcpListener {
- let fd = sys::fd::FileDesc::from_inner(fd);
- let socket = sys::net::Socket::from_inner((fd, metadata.local_addr));
- net::TcpListener::from_inner(sys::net::TcpListener::from_inner(socket))
- }
-}
-
-impl TryIntoRawFd for net::TcpStream {
- #[inline]
- fn try_into_raw_fd(self) -> Result<RawFd, Self> {
- let (socket, peer_addr) = self.into_inner().into_inner();
- match socket.try_into_inner() {
- Ok(fd) => Ok(fd.into_inner()),
- Err(socket) => {
- let sys = sys::net::TcpStream::from_inner((socket, peer_addr));
- Err(net::TcpStream::from_inner(sys))
- }
- }
- }
-}
-
-impl TryIntoRawFd for net::TcpListener {
- #[inline]
- fn try_into_raw_fd(self) -> Result<RawFd, Self> {
- match self.into_inner().into_inner().try_into_inner() {
- Ok(fd) => Ok(fd.into_inner()),
- Err(socket) => {
- let sys = sys::net::TcpListener::from_inner(socket);
- Err(net::TcpListener::from_inner(sys))
- }
- }
- }
-}
+++ /dev/null
-#![unstable(feature = "sgx_platform", issue = "56975")]
-
-pub mod arch;
-pub mod ffi;
-pub mod io;
pub mod alloc;
pub mod args;
+#[path = "../unix/cmath.rs"]
pub mod cmath;
pub mod condvar;
pub mod env;
-pub mod ext;
pub mod fd;
#[path = "../unsupported/fs.rs"]
pub mod fs;
pub const DEFAULT_MIN_STACK_SIZE: usize = 4096;
+pub use self::task_queue::JoinNotifier;
+
mod task_queue {
- use crate::sync::mpsc;
+ use super::wait_notify;
use crate::sync::{Mutex, MutexGuard, Once};
- pub type JoinHandle = mpsc::Receiver<()>;
+ pub type JoinHandle = wait_notify::Waiter;
+
+ pub struct JoinNotifier(Option<wait_notify::Notifier>);
+
+ impl Drop for JoinNotifier {
+ fn drop(&mut self) {
+ self.0.take().unwrap().notify();
+ }
+ }
pub(super) struct Task {
p: Box<dyn FnOnce()>,
- done: mpsc::Sender<()>,
+ done: JoinNotifier,
}
impl Task {
pub(super) fn new(p: Box<dyn FnOnce()>) -> (Task, JoinHandle) {
- let (done, recv) = mpsc::channel();
+ let (done, recv) = wait_notify::new();
+ let done = JoinNotifier(Some(done));
(Task { p, done }, recv)
}
- pub(super) fn run(self) {
+ pub(super) fn run(self) -> JoinNotifier {
(self.p)();
- let _ = self.done.send(());
+ self.done
}
}
}
}
+/// This module provides a synchronization primitive that does not use thread
+/// local variables. This is needed for signaling that a thread has finished
+/// execution. The signal is sent once all TLS destructors have finished at
+/// which point no new thread locals should be created.
+pub mod wait_notify {
+ use super::super::waitqueue::{SpinMutex, WaitQueue, WaitVariable};
+ use crate::sync::Arc;
+
+ pub struct Notifier(Arc<SpinMutex<WaitVariable<bool>>>);
+
+ impl Notifier {
+ /// Notify the waiter. The waiter is either notified right away (if
+ /// currently blocked in `Waiter::wait()`) or later when it calls the
+ /// `Waiter::wait()` method.
+ pub fn notify(self) {
+ let mut guard = self.0.lock();
+ *guard.lock_var_mut() = true;
+ let _ = WaitQueue::notify_one(guard);
+ }
+ }
+
+ pub struct Waiter(Arc<SpinMutex<WaitVariable<bool>>>);
+
+ impl Waiter {
+ /// Wait for a notification. If `Notifier::notify()` has already been
+ /// called, this will return immediately, otherwise the current thread
+ /// is blocked until notified.
+ pub fn wait(self) {
+ let guard = self.0.lock();
+ if *guard.lock_var() {
+ return;
+ }
+ WaitQueue::wait(guard, || {});
+ }
+ }
+
+ pub fn new() -> (Notifier, Waiter) {
+ let inner = Arc::new(SpinMutex::new(WaitVariable::new(false)));
+ (Notifier(inner.clone()), Waiter(inner))
+ }
+}
+
impl Thread {
// unsafe: see thread::Builder::spawn_unchecked for safety requirements
pub unsafe fn new(_stack: usize, p: Box<dyn FnOnce()>) -> io::Result<Thread> {
Ok(Thread(handle))
}
- pub(super) fn entry() {
+ pub(super) fn entry() -> JoinNotifier {
let mut pending_tasks = task_queue::lock();
let task = rtunwrap!(Some, pending_tasks.pop());
drop(pending_tasks); // make sure to not hold the task queue lock longer than necessary
}
pub fn join(self) {
- let _ = self.0.recv();
+ self.0.wait();
}
}
#![cfg(not(test))]
-use libc::{c_double, c_float};
+// These symbols are all defined by `libm`,
+// or by `compiler-builtins` on unsupported platforms.
extern "C" {
- pub fn acos(n: c_double) -> c_double;
- pub fn acosf(n: c_float) -> c_float;
- pub fn asin(n: c_double) -> c_double;
- pub fn asinf(n: c_float) -> c_float;
- pub fn atan(n: c_double) -> c_double;
- pub fn atan2(a: c_double, b: c_double) -> c_double;
- pub fn atan2f(a: c_float, b: c_float) -> c_float;
- pub fn atanf(n: c_float) -> c_float;
- pub fn cbrt(n: c_double) -> c_double;
- pub fn cbrtf(n: c_float) -> c_float;
- pub fn cosh(n: c_double) -> c_double;
- pub fn coshf(n: c_float) -> c_float;
- pub fn expm1(n: c_double) -> c_double;
- pub fn expm1f(n: c_float) -> c_float;
- pub fn fdim(a: c_double, b: c_double) -> c_double;
- pub fn fdimf(a: c_float, b: c_float) -> c_float;
- pub fn hypot(x: c_double, y: c_double) -> c_double;
- pub fn hypotf(x: c_float, y: c_float) -> c_float;
- pub fn log1p(n: c_double) -> c_double;
- pub fn log1pf(n: c_float) -> c_float;
- pub fn sinh(n: c_double) -> c_double;
- pub fn sinhf(n: c_float) -> c_float;
- pub fn tan(n: c_double) -> c_double;
- pub fn tanf(n: c_float) -> c_float;
- pub fn tanh(n: c_double) -> c_double;
- pub fn tanhf(n: c_float) -> c_float;
+ pub fn acos(n: f64) -> f64;
+ pub fn acosf(n: f32) -> f32;
+ pub fn asin(n: f64) -> f64;
+ pub fn asinf(n: f32) -> f32;
+ pub fn atan(n: f64) -> f64;
+ pub fn atan2(a: f64, b: f64) -> f64;
+ pub fn atan2f(a: f32, b: f32) -> f32;
+ pub fn atanf(n: f32) -> f32;
+ pub fn cbrt(n: f64) -> f64;
+ pub fn cbrtf(n: f32) -> f32;
+ pub fn cosh(n: f64) -> f64;
+ pub fn coshf(n: f32) -> f32;
+ pub fn expm1(n: f64) -> f64;
+ pub fn expm1f(n: f32) -> f32;
+ pub fn fdim(a: f64, b: f64) -> f64;
+ pub fn fdimf(a: f32, b: f32) -> f32;
+ pub fn hypot(x: f64, y: f64) -> f64;
+ pub fn hypotf(x: f32, y: f32) -> f32;
+ pub fn log1p(n: f64) -> f64;
+ pub fn log1pf(n: f32) -> f32;
+ pub fn sinh(n: f64) -> f64;
+ pub fn sinhf(n: f32) -> f32;
+ pub fn tan(n: f64) -> f64;
+ pub fn tanf(n: f32) -> f32;
+ pub fn tanh(n: f64) -> f64;
+ pub fn tanhf(n: f32) -> f32;
}
+++ /dev/null
-//! Unix-specific extension to the primitives in the `std::ffi` module.
-//!
-//! # Examples
-//!
-//! ```
-//! use std::ffi::OsString;
-//! use std::os::unix::ffi::OsStringExt;
-//!
-//! let bytes = b"foo".to_vec();
-//!
-//! // OsStringExt::from_vec
-//! let os_string = OsString::from_vec(bytes);
-//! assert_eq!(os_string.to_str(), Some("foo"));
-//!
-//! // OsStringExt::into_vec
-//! let bytes = os_string.into_vec();
-//! assert_eq!(bytes, b"foo");
-//! ```
-//!
-//! ```
-//! use std::ffi::OsStr;
-//! use std::os::unix::ffi::OsStrExt;
-//!
-//! let bytes = b"foo";
-//!
-//! // OsStrExt::from_bytes
-//! let os_str = OsStr::from_bytes(bytes);
-//! assert_eq!(os_str.to_str(), Some("foo"));
-//!
-//! // OsStrExt::as_bytes
-//! let bytes = os_str.as_bytes();
-//! assert_eq!(bytes, b"foo");
-//! ```
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use crate::sys_common::os_str_bytes::*;
+++ /dev/null
-//! Unix-specific extensions to primitives in the `std::fs` module.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-use super::platform::fs::MetadataExt as _;
-use crate::fs::{self, OpenOptions, Permissions};
-use crate::io;
-use crate::path::Path;
-use crate::sys;
-use crate::sys_common::{AsInner, AsInnerMut, FromInner};
-// Used for `File::read` on intra-doc links
-#[allow(unused_imports)]
-use io::{Read, Write};
-
-/// Unix-specific extensions to [`fs::File`].
-#[stable(feature = "file_offset", since = "1.15.0")]
-pub trait FileExt {
- /// Reads a number of bytes starting from a given offset.
- ///
- /// Returns the number of bytes read.
- ///
- /// The offset is relative to the start of the file and thus independent
- /// from the current cursor.
- ///
- /// The current file cursor is not affected by this function.
- ///
- /// Note that similar to [`File::read`], it is not an error to return with a
- /// short read.
- ///
- /// [`File::read`]: fs::File::read
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::io;
- /// use std::fs::File;
- /// use std::os::unix::prelude::FileExt;
- ///
- /// fn main() -> io::Result<()> {
- /// let mut buf = [0u8; 8];
- /// let file = File::open("foo.txt")?;
- ///
- /// // We now read 8 bytes from the offset 10.
- /// let num_bytes_read = file.read_at(&mut buf, 10)?;
- /// println!("read {} bytes: {:?}", num_bytes_read, buf);
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "file_offset", since = "1.15.0")]
- fn read_at(&self, buf: &mut [u8], offset: u64) -> io::Result<usize>;
-
- /// Reads the exact number of byte required to fill `buf` from the given offset.
- ///
- /// The offset is relative to the start of the file and thus independent
- /// from the current cursor.
- ///
- /// The current file cursor is not affected by this function.
- ///
- /// Similar to [`io::Read::read_exact`] but uses [`read_at`] instead of `read`.
- ///
- /// [`read_at`]: FileExt::read_at
- ///
- /// # Errors
- ///
- /// If this function encounters an error of the kind
- /// [`io::ErrorKind::Interrupted`] then the error is ignored and the operation
- /// will continue.
- ///
- /// If this function encounters an "end of file" before completely filling
- /// the buffer, it returns an error of the kind [`io::ErrorKind::UnexpectedEof`].
- /// The contents of `buf` are unspecified in this case.
- ///
- /// If any other read error is encountered then this function immediately
- /// returns. The contents of `buf` are unspecified in this case.
- ///
- /// If this function returns an error, it is unspecified how many bytes it
- /// has read, but it will never read more than would be necessary to
- /// completely fill the buffer.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::io;
- /// use std::fs::File;
- /// use std::os::unix::prelude::FileExt;
- ///
- /// fn main() -> io::Result<()> {
- /// let mut buf = [0u8; 8];
- /// let file = File::open("foo.txt")?;
- ///
- /// // We now read exactly 8 bytes from the offset 10.
- /// file.read_exact_at(&mut buf, 10)?;
- /// println!("read {} bytes: {:?}", buf.len(), buf);
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "rw_exact_all_at", since = "1.33.0")]
- fn read_exact_at(&self, mut buf: &mut [u8], mut offset: u64) -> io::Result<()> {
- while !buf.is_empty() {
- match self.read_at(buf, offset) {
- Ok(0) => break,
- Ok(n) => {
- let tmp = buf;
- buf = &mut tmp[n..];
- offset += n as u64;
- }
- Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
- Err(e) => return Err(e),
- }
- }
- if !buf.is_empty() {
- Err(io::Error::new_const(io::ErrorKind::UnexpectedEof, &"failed to fill whole buffer"))
- } else {
- Ok(())
- }
- }
-
- /// Writes a number of bytes starting from a given offset.
- ///
- /// Returns the number of bytes written.
- ///
- /// The offset is relative to the start of the file and thus independent
- /// from the current cursor.
- ///
- /// The current file cursor is not affected by this function.
- ///
- /// When writing beyond the end of the file, the file is appropriately
- /// extended and the intermediate bytes are initialized with the value 0.
- ///
- /// Note that similar to [`File::write`], it is not an error to return a
- /// short write.
- ///
- /// [`File::write`]: fs::File::write
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs::File;
- /// use std::io;
- /// use std::os::unix::prelude::FileExt;
- ///
- /// fn main() -> io::Result<()> {
- /// let file = File::open("foo.txt")?;
- ///
- /// // We now write at the offset 10.
- /// file.write_at(b"sushi", 10)?;
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "file_offset", since = "1.15.0")]
- fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize>;
-
- /// Attempts to write an entire buffer starting from a given offset.
- ///
- /// The offset is relative to the start of the file and thus independent
- /// from the current cursor.
- ///
- /// The current file cursor is not affected by this function.
- ///
- /// This method will continuously call [`write_at`] until there is no more data
- /// to be written or an error of non-[`io::ErrorKind::Interrupted`] kind is
- /// returned. This method will not return until the entire buffer has been
- /// successfully written or such an error occurs. The first error that is
- /// not of [`io::ErrorKind::Interrupted`] kind generated from this method will be
- /// returned.
- ///
- /// # Errors
- ///
- /// This function will return the first error of
- /// non-[`io::ErrorKind::Interrupted`] kind that [`write_at`] returns.
- ///
- /// [`write_at`]: FileExt::write_at
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs::File;
- /// use std::io;
- /// use std::os::unix::prelude::FileExt;
- ///
- /// fn main() -> io::Result<()> {
- /// let file = File::open("foo.txt")?;
- ///
- /// // We now write at the offset 10.
- /// file.write_all_at(b"sushi", 10)?;
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "rw_exact_all_at", since = "1.33.0")]
- fn write_all_at(&self, mut buf: &[u8], mut offset: u64) -> io::Result<()> {
- while !buf.is_empty() {
- match self.write_at(buf, offset) {
- Ok(0) => {
- return Err(io::Error::new_const(
- io::ErrorKind::WriteZero,
- &"failed to write whole buffer",
- ));
- }
- Ok(n) => {
- buf = &buf[n..];
- offset += n as u64
- }
- Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
- Err(e) => return Err(e),
- }
- }
- Ok(())
- }
-}
-
-#[stable(feature = "file_offset", since = "1.15.0")]
-impl FileExt for fs::File {
- fn read_at(&self, buf: &mut [u8], offset: u64) -> io::Result<usize> {
- self.as_inner().read_at(buf, offset)
- }
- fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
- self.as_inner().write_at(buf, offset)
- }
-}
-
-/// Unix-specific extensions to [`fs::Permissions`].
-#[stable(feature = "fs_ext", since = "1.1.0")]
-pub trait PermissionsExt {
- /// Returns the underlying raw `st_mode` bits that contain the standard
- /// Unix permissions for this file.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs::File;
- /// use std::os::unix::fs::PermissionsExt;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let f = File::create("foo.txt")?;
- /// let metadata = f.metadata()?;
- /// let permissions = metadata.permissions();
- ///
- /// println!("permissions: {:o}", permissions.mode());
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "fs_ext", since = "1.1.0")]
- fn mode(&self) -> u32;
-
- /// Sets the underlying raw bits for this set of permissions.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs::File;
- /// use std::os::unix::fs::PermissionsExt;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let f = File::create("foo.txt")?;
- /// let metadata = f.metadata()?;
- /// let mut permissions = metadata.permissions();
- ///
- /// permissions.set_mode(0o644); // Read/write for owner and read for others.
- /// assert_eq!(permissions.mode(), 0o644);
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "fs_ext", since = "1.1.0")]
- fn set_mode(&mut self, mode: u32);
-
- /// Creates a new instance of `Permissions` from the given set of Unix
- /// permission bits.
- ///
- /// # Examples
- ///
- /// ```
- /// use std::fs::Permissions;
- /// use std::os::unix::fs::PermissionsExt;
- ///
- /// // Read/write for owner and read for others.
- /// let permissions = Permissions::from_mode(0o644);
- /// assert_eq!(permissions.mode(), 0o644);
- /// ```
- #[stable(feature = "fs_ext", since = "1.1.0")]
- fn from_mode(mode: u32) -> Self;
-}
-
-#[stable(feature = "fs_ext", since = "1.1.0")]
-impl PermissionsExt for Permissions {
- fn mode(&self) -> u32 {
- self.as_inner().mode()
- }
-
- fn set_mode(&mut self, mode: u32) {
- *self = Permissions::from_inner(FromInner::from_inner(mode));
- }
-
- fn from_mode(mode: u32) -> Permissions {
- Permissions::from_inner(FromInner::from_inner(mode))
- }
-}
-
-/// Unix-specific extensions to [`fs::OpenOptions`].
-#[stable(feature = "fs_ext", since = "1.1.0")]
-pub trait OpenOptionsExt {
- /// Sets the mode bits that a new file will be created with.
- ///
- /// If a new file is created as part of an `OpenOptions::open` call then this
- /// specified `mode` will be used as the permission bits for the new file.
- /// If no `mode` is set, the default of `0o666` will be used.
- /// The operating system masks out bits with the system's `umask`, to produce
- /// the final permissions.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs::OpenOptions;
- /// use std::os::unix::fs::OpenOptionsExt;
- ///
- /// # fn main() {
- /// let mut options = OpenOptions::new();
- /// options.mode(0o644); // Give read/write for owner and read for others.
- /// let file = options.open("foo.txt");
- /// # }
- /// ```
- #[stable(feature = "fs_ext", since = "1.1.0")]
- fn mode(&mut self, mode: u32) -> &mut Self;
-
- /// Pass custom flags to the `flags` argument of `open`.
- ///
- /// The bits that define the access mode are masked out with `O_ACCMODE`, to
- /// ensure they do not interfere with the access mode set by Rusts options.
- ///
- /// Custom flags can only set flags, not remove flags set by Rusts options.
- /// This options overwrites any previously set custom flags.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// # #![feature(rustc_private)]
- /// extern crate libc;
- /// use std::fs::OpenOptions;
- /// use std::os::unix::fs::OpenOptionsExt;
- ///
- /// # fn main() {
- /// let mut options = OpenOptions::new();
- /// options.write(true);
- /// if cfg!(unix) {
- /// options.custom_flags(libc::O_NOFOLLOW);
- /// }
- /// let file = options.open("foo.txt");
- /// # }
- /// ```
- #[stable(feature = "open_options_ext", since = "1.10.0")]
- fn custom_flags(&mut self, flags: i32) -> &mut Self;
-}
-
-#[stable(feature = "fs_ext", since = "1.1.0")]
-impl OpenOptionsExt for OpenOptions {
- fn mode(&mut self, mode: u32) -> &mut OpenOptions {
- self.as_inner_mut().mode(mode);
- self
- }
-
- fn custom_flags(&mut self, flags: i32) -> &mut OpenOptions {
- self.as_inner_mut().custom_flags(flags);
- self
- }
-}
-
-/// Unix-specific extensions to [`fs::Metadata`].
-#[stable(feature = "metadata_ext", since = "1.1.0")]
-pub trait MetadataExt {
- /// Returns the ID of the device containing the file.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::io;
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let dev_id = meta.dev();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn dev(&self) -> u64;
- /// Returns the inode number.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let inode = meta.ino();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn ino(&self) -> u64;
- /// Returns the rights applied to this file.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let mode = meta.mode();
- /// let user_has_write_access = mode & 0o200;
- /// let user_has_read_write_access = mode & 0o600;
- /// let group_has_read_access = mode & 0o040;
- /// let others_have_exec_access = mode & 0o001;
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn mode(&self) -> u32;
- /// Returns the number of hard links pointing to this file.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let nb_hard_links = meta.nlink();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn nlink(&self) -> u64;
- /// Returns the user ID of the owner of this file.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let user_id = meta.uid();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn uid(&self) -> u32;
- /// Returns the group ID of the owner of this file.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let group_id = meta.gid();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn gid(&self) -> u32;
- /// Returns the device ID of this file (if it is a special one).
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let device_id = meta.rdev();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn rdev(&self) -> u64;
- /// Returns the total size of this file in bytes.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let file_size = meta.size();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn size(&self) -> u64;
- /// Returns the last access time of the file, in seconds since Unix Epoch.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let last_access_time = meta.atime();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn atime(&self) -> i64;
- /// Returns the last access time of the file, in nanoseconds since [`atime`].
- ///
- /// [`atime`]: MetadataExt::atime
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let nano_last_access_time = meta.atime_nsec();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn atime_nsec(&self) -> i64;
- /// Returns the last modification time of the file, in seconds since Unix Epoch.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let last_modification_time = meta.mtime();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn mtime(&self) -> i64;
- /// Returns the last modification time of the file, in nanoseconds since [`mtime`].
- ///
- /// [`mtime`]: MetadataExt::mtime
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let nano_last_modification_time = meta.mtime_nsec();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn mtime_nsec(&self) -> i64;
- /// Returns the last status change time of the file, in seconds since Unix Epoch.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let last_status_change_time = meta.ctime();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn ctime(&self) -> i64;
- /// Returns the last status change time of the file, in nanoseconds since [`ctime`].
- ///
- /// [`ctime`]: MetadataExt::ctime
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let nano_last_status_change_time = meta.ctime_nsec();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn ctime_nsec(&self) -> i64;
- /// Returns the block size for filesystem I/O.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let block_size = meta.blksize();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn blksize(&self) -> u64;
- /// Returns the number of blocks allocated to the file, in 512-byte units.
- ///
- /// Please note that this may be smaller than `st_size / 512` when the file has holes.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::MetadataExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("some_file")?;
- /// let blocks = meta.blocks();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn blocks(&self) -> u64;
- #[cfg(target_os = "vxworks")]
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn attrib(&self) -> u8;
-}
-
-#[stable(feature = "metadata_ext", since = "1.1.0")]
-impl MetadataExt for fs::Metadata {
- fn dev(&self) -> u64 {
- self.st_dev()
- }
- fn ino(&self) -> u64 {
- self.st_ino()
- }
- fn mode(&self) -> u32 {
- self.st_mode()
- }
- fn nlink(&self) -> u64 {
- self.st_nlink()
- }
- fn uid(&self) -> u32 {
- self.st_uid()
- }
- fn gid(&self) -> u32 {
- self.st_gid()
- }
- fn rdev(&self) -> u64 {
- self.st_rdev()
- }
- fn size(&self) -> u64 {
- self.st_size()
- }
- fn atime(&self) -> i64 {
- self.st_atime()
- }
- fn atime_nsec(&self) -> i64 {
- self.st_atime_nsec()
- }
- fn mtime(&self) -> i64 {
- self.st_mtime()
- }
- fn mtime_nsec(&self) -> i64 {
- self.st_mtime_nsec()
- }
- fn ctime(&self) -> i64 {
- self.st_ctime()
- }
- fn ctime_nsec(&self) -> i64 {
- self.st_ctime_nsec()
- }
- fn blksize(&self) -> u64 {
- self.st_blksize()
- }
- fn blocks(&self) -> u64 {
- self.st_blocks()
- }
- #[cfg(target_os = "vxworks")]
- fn attrib(&self) -> u8 {
- self.st_attrib()
- }
-}
-
-/// Unix-specific extensions for [`fs::FileType`].
-///
-/// Adds support for special Unix file types such as block/character devices,
-/// pipes, and sockets.
-#[stable(feature = "file_type_ext", since = "1.5.0")]
-pub trait FileTypeExt {
- /// Returns `true` if this file type is a block device.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::FileTypeExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("block_device_file")?;
- /// let file_type = meta.file_type();
- /// assert!(file_type.is_block_device());
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "file_type_ext", since = "1.5.0")]
- fn is_block_device(&self) -> bool;
- /// Returns `true` if this file type is a char device.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::FileTypeExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("char_device_file")?;
- /// let file_type = meta.file_type();
- /// assert!(file_type.is_char_device());
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "file_type_ext", since = "1.5.0")]
- fn is_char_device(&self) -> bool;
- /// Returns `true` if this file type is a fifo.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::FileTypeExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("fifo_file")?;
- /// let file_type = meta.file_type();
- /// assert!(file_type.is_fifo());
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "file_type_ext", since = "1.5.0")]
- fn is_fifo(&self) -> bool;
- /// Returns `true` if this file type is a socket.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs;
- /// use std::os::unix::fs::FileTypeExt;
- /// use std::io;
- ///
- /// fn main() -> io::Result<()> {
- /// let meta = fs::metadata("unix.socket")?;
- /// let file_type = meta.file_type();
- /// assert!(file_type.is_socket());
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "file_type_ext", since = "1.5.0")]
- fn is_socket(&self) -> bool;
-}
-
-#[stable(feature = "file_type_ext", since = "1.5.0")]
-impl FileTypeExt for fs::FileType {
- fn is_block_device(&self) -> bool {
- self.as_inner().is(libc::S_IFBLK)
- }
- fn is_char_device(&self) -> bool {
- self.as_inner().is(libc::S_IFCHR)
- }
- fn is_fifo(&self) -> bool {
- self.as_inner().is(libc::S_IFIFO)
- }
- fn is_socket(&self) -> bool {
- self.as_inner().is(libc::S_IFSOCK)
- }
-}
-
-/// Unix-specific extension methods for [`fs::DirEntry`].
-#[stable(feature = "dir_entry_ext", since = "1.1.0")]
-pub trait DirEntryExt {
- /// Returns the underlying `d_ino` field in the contained `dirent`
- /// structure.
- ///
- /// # Examples
- ///
- /// ```
- /// use std::fs;
- /// use std::os::unix::fs::DirEntryExt;
- ///
- /// if let Ok(entries) = fs::read_dir(".") {
- /// for entry in entries {
- /// if let Ok(entry) = entry {
- /// // Here, `entry` is a `DirEntry`.
- /// println!("{:?}: {}", entry.file_name(), entry.ino());
- /// }
- /// }
- /// }
- /// ```
- #[stable(feature = "dir_entry_ext", since = "1.1.0")]
- fn ino(&self) -> u64;
-}
-
-#[stable(feature = "dir_entry_ext", since = "1.1.0")]
-impl DirEntryExt for fs::DirEntry {
- fn ino(&self) -> u64 {
- self.as_inner().ino()
- }
-}
-
-/// Creates a new symbolic link on the filesystem.
-///
-/// The `link` path will be a symbolic link pointing to the `original` path.
-///
-/// # Examples
-///
-/// ```no_run
-/// use std::os::unix::fs;
-///
-/// fn main() -> std::io::Result<()> {
-/// fs::symlink("a.txt", "b.txt")?;
-/// Ok(())
-/// }
-/// ```
-#[stable(feature = "symlink", since = "1.1.0")]
-pub fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Result<()> {
- sys::fs::symlink(original.as_ref(), link.as_ref())
-}
-
-/// Unix-specific extensions to [`fs::DirBuilder`].
-#[stable(feature = "dir_builder", since = "1.6.0")]
-pub trait DirBuilderExt {
- /// Sets the mode to create new directories with. This option defaults to
- /// 0o777.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs::DirBuilder;
- /// use std::os::unix::fs::DirBuilderExt;
- ///
- /// let mut builder = DirBuilder::new();
- /// builder.mode(0o755);
- /// ```
- #[stable(feature = "dir_builder", since = "1.6.0")]
- fn mode(&mut self, mode: u32) -> &mut Self;
-}
-
-#[stable(feature = "dir_builder", since = "1.6.0")]
-impl DirBuilderExt for fs::DirBuilder {
- fn mode(&mut self, mode: u32) -> &mut fs::DirBuilder {
- self.as_inner_mut().set_mode(mode);
- self
- }
-}
+++ /dev/null
-//! Unix-specific extensions to general I/O primitives.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-use crate::fs;
-use crate::io;
-use crate::os::raw;
-use crate::sys;
-use crate::sys_common::{AsInner, FromInner, IntoInner};
-
-/// Raw file descriptors.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub type RawFd = raw::c_int;
-
-/// A trait to extract the raw unix file descriptor from an underlying
-/// object.
-///
-/// This is only available on unix platforms and must be imported in order
-/// to call the method. Windows platforms have a corresponding `AsRawHandle`
-/// and `AsRawSocket` set of traits.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub trait AsRawFd {
- /// Extracts the raw file descriptor.
- ///
- /// This method does **not** pass ownership of the raw file descriptor
- /// to the caller. The descriptor is only guaranteed to be valid while
- /// the original object has not yet been destroyed.
- ///
- /// # Example
- ///
- /// ```no_run
- /// use std::fs::File;
- /// # use std::io;
- /// use std::os::unix::io::{AsRawFd, RawFd};
- ///
- /// let mut f = File::open("foo.txt")?;
- /// // Note that `raw_fd` is only valid as long as `f` exists.
- /// let raw_fd: RawFd = f.as_raw_fd();
- /// # Ok::<(), io::Error>(())
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn as_raw_fd(&self) -> RawFd;
-}
-
-/// A trait to express the ability to construct an object from a raw file
-/// descriptor.
-#[stable(feature = "from_raw_os", since = "1.1.0")]
-pub trait FromRawFd {
- /// Constructs a new instance of `Self` from the given raw file
- /// descriptor.
- ///
- /// This function **consumes ownership** of the specified file
- /// descriptor. The returned object will take responsibility for closing
- /// it when the object goes out of scope.
- ///
- /// This function is also unsafe as the primitives currently returned
- /// have the contract that they are the sole owner of the file
- /// descriptor they are wrapping. Usage of this function could
- /// accidentally allow violating this contract which can cause memory
- /// unsafety in code that relies on it being true.
- ///
- /// # Example
- ///
- /// ```no_run
- /// use std::fs::File;
- /// # use std::io;
- /// use std::os::unix::io::{FromRawFd, IntoRawFd, RawFd};
- ///
- /// let f = File::open("foo.txt")?;
- /// let raw_fd: RawFd = f.into_raw_fd();
- /// // SAFETY: no other functions should call `from_raw_fd`, so there
- /// // is only one owner for the file descriptor.
- /// let f = unsafe { File::from_raw_fd(raw_fd) };
- /// # Ok::<(), io::Error>(())
- /// ```
- #[stable(feature = "from_raw_os", since = "1.1.0")]
- unsafe fn from_raw_fd(fd: RawFd) -> Self;
-}
-
-/// A trait to express the ability to consume an object and acquire ownership of
-/// its raw file descriptor.
-#[stable(feature = "into_raw_os", since = "1.4.0")]
-pub trait IntoRawFd {
- /// Consumes this object, returning the raw underlying file descriptor.
- ///
- /// This function **transfers ownership** of the underlying file descriptor
- /// to the caller. Callers are then the unique owners of the file descriptor
- /// and must close the descriptor once it's no longer needed.
- ///
- /// # Example
- ///
- /// ```no_run
- /// use std::fs::File;
- /// # use std::io;
- /// use std::os::unix::io::{IntoRawFd, RawFd};
- ///
- /// let f = File::open("foo.txt")?;
- /// let raw_fd: RawFd = f.into_raw_fd();
- /// # Ok::<(), io::Error>(())
- /// ```
- #[stable(feature = "into_raw_os", since = "1.4.0")]
- fn into_raw_fd(self) -> RawFd;
-}
-
-#[stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")]
-impl AsRawFd for RawFd {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- *self
- }
-}
-#[stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")]
-impl IntoRawFd for RawFd {
- #[inline]
- fn into_raw_fd(self) -> RawFd {
- self
- }
-}
-#[stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")]
-impl FromRawFd for RawFd {
- #[inline]
- unsafe fn from_raw_fd(fd: RawFd) -> RawFd {
- fd
- }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl AsRawFd for fs::File {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- self.as_inner().fd().raw()
- }
-}
-#[stable(feature = "from_raw_os", since = "1.1.0")]
-impl FromRawFd for fs::File {
- #[inline]
- unsafe fn from_raw_fd(fd: RawFd) -> fs::File {
- fs::File::from_inner(sys::fs::File::from_inner(fd))
- }
-}
-#[stable(feature = "into_raw_os", since = "1.4.0")]
-impl IntoRawFd for fs::File {
- #[inline]
- fn into_raw_fd(self) -> RawFd {
- self.into_inner().into_fd().into_raw()
- }
-}
-
-#[stable(feature = "asraw_stdio", since = "1.21.0")]
-impl AsRawFd for io::Stdin {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- libc::STDIN_FILENO
- }
-}
-
-#[stable(feature = "asraw_stdio", since = "1.21.0")]
-impl AsRawFd for io::Stdout {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- libc::STDOUT_FILENO
- }
-}
-
-#[stable(feature = "asraw_stdio", since = "1.21.0")]
-impl AsRawFd for io::Stderr {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- libc::STDERR_FILENO
- }
-}
-
-#[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
-impl<'a> AsRawFd for io::StdinLock<'a> {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- libc::STDIN_FILENO
- }
-}
-
-#[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
-impl<'a> AsRawFd for io::StdoutLock<'a> {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- libc::STDOUT_FILENO
- }
-}
-
-#[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
-impl<'a> AsRawFd for io::StderrLock<'a> {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- libc::STDERR_FILENO
- }
-}
+++ /dev/null
-//! Platform-specific extensions to `std` for Unix platforms.
-//!
-//! Provides access to platform-level information on Unix platforms, and
-//! exposes Unix-specific functions that would otherwise be inappropriate as
-//! part of the core `std` library.
-//!
-//! It exposes more ways to deal with platform-specific strings (`OsStr`,
-//! `OsString`), allows to set permissions more granularly, extract low-level
-//! file descriptors from files and sockets, and has platform-specific helpers
-//! for spawning processes.
-//!
-//! # Examples
-//!
-//! ```no_run
-//! use std::fs::File;
-//! use std::os::unix::prelude::*;
-//!
-//! fn main() -> std::io::Result<()> {
-//! let f = File::create("foo.txt")?;
-//! let fd = f.as_raw_fd();
-//!
-//! // use fd with native unix bindings
-//!
-//! Ok(())
-//! }
-//! ```
-
-#![stable(feature = "rust1", since = "1.0.0")]
-#![doc(cfg(unix))]
-#![allow(missing_docs)]
-
-cfg_if::cfg_if! {
- if #[cfg(doc)] {
- // Use linux as the default platform when documenting on other platforms like Windows
- use crate::os::linux as platform;
- } else {
- #[cfg(target_os = "android")]
- use crate::os::android as platform;
- #[cfg(target_os = "dragonfly")]
- use crate::os::dragonfly as platform;
- #[cfg(target_os = "emscripten")]
- use crate::os::emscripten as platform;
- #[cfg(target_os = "freebsd")]
- use crate::os::freebsd as platform;
- #[cfg(target_os = "fuchsia")]
- use crate::os::fuchsia as platform;
- #[cfg(target_os = "haiku")]
- use crate::os::haiku as platform;
- #[cfg(target_os = "illumos")]
- use crate::os::illumos as platform;
- #[cfg(target_os = "ios")]
- use crate::os::ios as platform;
- #[cfg(any(target_os = "linux", target_os = "l4re"))]
- use crate::os::linux as platform;
- #[cfg(target_os = "macos")]
- use crate::os::macos as platform;
- #[cfg(target_os = "netbsd")]
- use crate::os::netbsd as platform;
- #[cfg(target_os = "openbsd")]
- use crate::os::openbsd as platform;
- #[cfg(target_os = "redox")]
- use crate::os::redox as platform;
- #[cfg(target_os = "solaris")]
- use crate::os::solaris as platform;
- #[cfg(target_os = "vxworks")]
- use crate::os::vxworks as platform;
- }
-}
-
-pub mod ffi;
-pub mod fs;
-pub mod io;
-pub mod net;
-pub mod process;
-pub mod raw;
-pub mod thread;
-
-#[unstable(feature = "peer_credentials_unix_socket", issue = "42839", reason = "unstable")]
-#[cfg(any(
- target_os = "android",
- target_os = "linux",
- target_os = "dragonfly",
- target_os = "freebsd",
- target_os = "ios",
- target_os = "macos",
- target_os = "openbsd"
-))]
-pub mod ucred;
-
-/// A prelude for conveniently writing platform-specific code.
-///
-/// Includes all extension traits, and some important type definitions.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub mod prelude {
- #[doc(no_inline)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use super::ffi::{OsStrExt, OsStringExt};
- #[doc(no_inline)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use super::fs::DirEntryExt;
- #[doc(no_inline)]
- #[stable(feature = "file_offset", since = "1.15.0")]
- pub use super::fs::FileExt;
- #[doc(no_inline)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use super::fs::{FileTypeExt, MetadataExt, OpenOptionsExt, PermissionsExt};
- #[doc(no_inline)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use super::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
- #[doc(no_inline)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use super::process::{CommandExt, ExitStatusExt};
- #[doc(no_inline)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use super::thread::JoinHandleExt;
-}
+++ /dev/null
-use crate::ffi::OsStr;
-use crate::os::unix::ffi::OsStrExt;
-use crate::path::Path;
-use crate::sys::cvt;
-use crate::{ascii, fmt, io, iter, mem};
-
-// FIXME(#43348): Make libc adapt #[doc(cfg(...))] so we don't need these fake definitions here?
-#[cfg(not(unix))]
-#[allow(non_camel_case_types)]
-mod libc {
- pub use libc::c_int;
- pub type socklen_t = u32;
- pub struct sockaddr;
- #[derive(Clone)]
- pub struct sockaddr_un;
-}
-
-fn sun_path_offset(addr: &libc::sockaddr_un) -> usize {
- // Work with an actual instance of the type since using a null pointer is UB
- let base = addr as *const _ as usize;
- let path = &addr.sun_path as *const _ as usize;
- path - base
-}
-
-pub(super) unsafe fn sockaddr_un(path: &Path) -> io::Result<(libc::sockaddr_un, libc::socklen_t)> {
- let mut addr: libc::sockaddr_un = mem::zeroed();
- addr.sun_family = libc::AF_UNIX as libc::sa_family_t;
-
- let bytes = path.as_os_str().as_bytes();
-
- if bytes.contains(&0) {
- return Err(io::Error::new_const(
- io::ErrorKind::InvalidInput,
- &"paths may not contain interior null bytes",
- ));
- }
-
- if bytes.len() >= addr.sun_path.len() {
- return Err(io::Error::new_const(
- io::ErrorKind::InvalidInput,
- &"path must be shorter than SUN_LEN",
- ));
- }
- for (dst, src) in iter::zip(&mut addr.sun_path, bytes) {
- *dst = *src as libc::c_char;
- }
- // null byte for pathname addresses is already there because we zeroed the
- // struct
-
- let mut len = sun_path_offset(&addr) + bytes.len();
- match bytes.get(0) {
- Some(&0) | None => {}
- Some(_) => len += 1,
- }
- Ok((addr, len as libc::socklen_t))
-}
-
-enum AddressKind<'a> {
- Unnamed,
- Pathname(&'a Path),
- Abstract(&'a [u8]),
-}
-
-struct AsciiEscaped<'a>(&'a [u8]);
-
-impl<'a> fmt::Display for AsciiEscaped<'a> {
- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
- write!(fmt, "\"")?;
- for byte in self.0.iter().cloned().flat_map(ascii::escape_default) {
- write!(fmt, "{}", byte as char)?;
- }
- write!(fmt, "\"")
- }
-}
-
-/// An address associated with a Unix socket.
-///
-/// # Examples
-///
-/// ```
-/// use std::os::unix::net::UnixListener;
-///
-/// let socket = match UnixListener::bind("/tmp/sock") {
-/// Ok(sock) => sock,
-/// Err(e) => {
-/// println!("Couldn't bind: {:?}", e);
-/// return
-/// }
-/// };
-/// let addr = socket.local_addr().expect("Couldn't get local address");
-/// ```
-#[derive(Clone)]
-#[stable(feature = "unix_socket", since = "1.10.0")]
-pub struct SocketAddr {
- addr: libc::sockaddr_un,
- len: libc::socklen_t,
-}
-
-impl SocketAddr {
- pub(super) fn new<F>(f: F) -> io::Result<SocketAddr>
- where
- F: FnOnce(*mut libc::sockaddr, *mut libc::socklen_t) -> libc::c_int,
- {
- unsafe {
- let mut addr: libc::sockaddr_un = mem::zeroed();
- let mut len = mem::size_of::<libc::sockaddr_un>() as libc::socklen_t;
- cvt(f(&mut addr as *mut _ as *mut _, &mut len))?;
- SocketAddr::from_parts(addr, len)
- }
- }
-
- pub(super) fn from_parts(
- addr: libc::sockaddr_un,
- mut len: libc::socklen_t,
- ) -> io::Result<SocketAddr> {
- if len == 0 {
- // When there is a datagram from unnamed unix socket
- // linux returns zero bytes of address
- len = sun_path_offset(&addr) as libc::socklen_t; // i.e., zero-length address
- } else if addr.sun_family != libc::AF_UNIX as libc::sa_family_t {
- return Err(io::Error::new_const(
- io::ErrorKind::InvalidInput,
- &"file descriptor did not correspond to a Unix socket",
- ));
- }
-
- Ok(SocketAddr { addr, len })
- }
-
- /// Returns `true` if the address is unnamed.
- ///
- /// # Examples
- ///
- /// A named address:
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixListener;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixListener::bind("/tmp/sock")?;
- /// let addr = socket.local_addr().expect("Couldn't get local address");
- /// assert_eq!(addr.is_unnamed(), false);
- /// Ok(())
- /// }
- /// ```
- ///
- /// An unnamed address:
- ///
- /// ```
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixDatagram::unbound()?;
- /// let addr = socket.local_addr().expect("Couldn't get local address");
- /// assert_eq!(addr.is_unnamed(), true);
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn is_unnamed(&self) -> bool {
- if let AddressKind::Unnamed = self.address() { true } else { false }
- }
-
- /// Returns the contents of this address if it is a `pathname` address.
- ///
- /// # Examples
- ///
- /// With a pathname:
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixListener;
- /// use std::path::Path;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixListener::bind("/tmp/sock")?;
- /// let addr = socket.local_addr().expect("Couldn't get local address");
- /// assert_eq!(addr.as_pathname(), Some(Path::new("/tmp/sock")));
- /// Ok(())
- /// }
- /// ```
- ///
- /// Without a pathname:
- ///
- /// ```
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixDatagram::unbound()?;
- /// let addr = socket.local_addr().expect("Couldn't get local address");
- /// assert_eq!(addr.as_pathname(), None);
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn as_pathname(&self) -> Option<&Path> {
- if let AddressKind::Pathname(path) = self.address() { Some(path) } else { None }
- }
-
- fn address(&self) -> AddressKind<'_> {
- let len = self.len as usize - sun_path_offset(&self.addr);
- let path = unsafe { mem::transmute::<&[libc::c_char], &[u8]>(&self.addr.sun_path) };
-
- // macOS seems to return a len of 16 and a zeroed sun_path for unnamed addresses
- if len == 0
- || (cfg!(not(any(target_os = "linux", target_os = "android")))
- && self.addr.sun_path[0] == 0)
- {
- AddressKind::Unnamed
- } else if self.addr.sun_path[0] == 0 {
- AddressKind::Abstract(&path[1..len])
- } else {
- AddressKind::Pathname(OsStr::from_bytes(&path[..len - 1]).as_ref())
- }
- }
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl fmt::Debug for SocketAddr {
- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
- match self.address() {
- AddressKind::Unnamed => write!(fmt, "(unnamed)"),
- AddressKind::Abstract(name) => write!(fmt, "{} (abstract)", AsciiEscaped(name)),
- AddressKind::Pathname(path) => write!(fmt, "{:?} (pathname)", path),
- }
- }
-}
+++ /dev/null
-use super::{sockaddr_un, SocketAddr};
-use crate::convert::TryFrom;
-use crate::io::{self, IoSlice, IoSliceMut};
-use crate::marker::PhantomData;
-use crate::mem::{size_of, zeroed};
-use crate::os::unix::io::RawFd;
-use crate::path::Path;
-use crate::ptr::{eq, read_unaligned};
-use crate::slice::from_raw_parts;
-use crate::sys::net::Socket;
-
-// FIXME(#43348): Make libc adapt #[doc(cfg(...))] so we don't need these fake definitions here?
-#[cfg(all(doc, not(target_os = "linux"), not(target_os = "android")))]
-#[allow(non_camel_case_types)]
-mod libc {
- pub use libc::c_int;
- pub struct ucred;
- pub struct cmsghdr;
- pub type pid_t = i32;
- pub type gid_t = u32;
- pub type uid_t = u32;
-}
-
-pub(super) fn recv_vectored_with_ancillary_from(
- socket: &Socket,
- bufs: &mut [IoSliceMut<'_>],
- ancillary: &mut SocketAncillary<'_>,
-) -> io::Result<(usize, bool, io::Result<SocketAddr>)> {
- unsafe {
- let mut msg_name: libc::sockaddr_un = zeroed();
- let mut msg: libc::msghdr = zeroed();
- msg.msg_name = &mut msg_name as *mut _ as *mut _;
- msg.msg_namelen = size_of::<libc::sockaddr_un>() as libc::socklen_t;
- msg.msg_iov = bufs.as_mut_ptr().cast();
- cfg_if::cfg_if! {
- if #[cfg(any(target_os = "android", all(target_os = "linux", target_env = "gnu")))] {
- msg.msg_iovlen = bufs.len() as libc::size_t;
- msg.msg_controllen = ancillary.buffer.len() as libc::size_t;
- } else if #[cfg(any(
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- all(target_os = "linux", target_env = "musl",),
- target_os = "macos",
- target_os = "netbsd",
- target_os = "openbsd",
- ))] {
- msg.msg_iovlen = bufs.len() as libc::c_int;
- msg.msg_controllen = ancillary.buffer.len() as libc::socklen_t;
- }
- }
- // macos requires that the control pointer is NULL when the len is 0.
- if msg.msg_controllen > 0 {
- msg.msg_control = ancillary.buffer.as_mut_ptr().cast();
- }
-
- let count = socket.recv_msg(&mut msg)?;
-
- ancillary.length = msg.msg_controllen as usize;
- ancillary.truncated = msg.msg_flags & libc::MSG_CTRUNC == libc::MSG_CTRUNC;
-
- let truncated = msg.msg_flags & libc::MSG_TRUNC == libc::MSG_TRUNC;
- let addr = SocketAddr::from_parts(msg_name, msg.msg_namelen);
-
- Ok((count, truncated, addr))
- }
-}
-
-pub(super) fn send_vectored_with_ancillary_to(
- socket: &Socket,
- path: Option<&Path>,
- bufs: &[IoSlice<'_>],
- ancillary: &mut SocketAncillary<'_>,
-) -> io::Result<usize> {
- unsafe {
- let (mut msg_name, msg_namelen) =
- if let Some(path) = path { sockaddr_un(path)? } else { (zeroed(), 0) };
-
- let mut msg: libc::msghdr = zeroed();
- msg.msg_name = &mut msg_name as *mut _ as *mut _;
- msg.msg_namelen = msg_namelen;
- msg.msg_iov = bufs.as_ptr() as *mut _;
- cfg_if::cfg_if! {
- if #[cfg(any(target_os = "android", all(target_os = "linux", target_env = "gnu")))] {
- msg.msg_iovlen = bufs.len() as libc::size_t;
- msg.msg_controllen = ancillary.length as libc::size_t;
- } else if #[cfg(any(
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- all(target_os = "linux", target_env = "musl",),
- target_os = "macos",
- target_os = "netbsd",
- target_os = "openbsd",
- ))] {
- msg.msg_iovlen = bufs.len() as libc::c_int;
- msg.msg_controllen = ancillary.length as libc::socklen_t;
- }
- }
- // macos requires that the control pointer is NULL when the len is 0.
- if msg.msg_controllen > 0 {
- msg.msg_control = ancillary.buffer.as_mut_ptr().cast();
- }
-
- ancillary.truncated = false;
-
- socket.send_msg(&mut msg)
- }
-}
-
-fn add_to_ancillary_data<T>(
- buffer: &mut [u8],
- length: &mut usize,
- source: &[T],
- cmsg_level: libc::c_int,
- cmsg_type: libc::c_int,
-) -> bool {
- let source_len = if let Some(source_len) = source.len().checked_mul(size_of::<T>()) {
- if let Ok(source_len) = u32::try_from(source_len) {
- source_len
- } else {
- return false;
- }
- } else {
- return false;
- };
-
- unsafe {
- let additional_space = libc::CMSG_SPACE(source_len) as usize;
-
- let new_length = if let Some(new_length) = additional_space.checked_add(*length) {
- new_length
- } else {
- return false;
- };
-
- if new_length > buffer.len() {
- return false;
- }
-
- buffer[*length..new_length].fill(0);
-
- *length = new_length;
-
- let mut msg: libc::msghdr = zeroed();
- msg.msg_control = buffer.as_mut_ptr().cast();
- cfg_if::cfg_if! {
- if #[cfg(any(target_os = "android", all(target_os = "linux", target_env = "gnu")))] {
- msg.msg_controllen = *length as libc::size_t;
- } else if #[cfg(any(
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- all(target_os = "linux", target_env = "musl",),
- target_os = "macos",
- target_os = "netbsd",
- target_os = "openbsd",
- ))] {
- msg.msg_controllen = *length as libc::socklen_t;
- }
- }
-
- let mut cmsg = libc::CMSG_FIRSTHDR(&msg);
- let mut previous_cmsg = cmsg;
- while !cmsg.is_null() {
- previous_cmsg = cmsg;
- cmsg = libc::CMSG_NXTHDR(&msg, cmsg);
-
- // Most operating systems, but not Linux or emscripten, return the previous pointer
- // when its length is zero. Therefore, check if the previous pointer is the same as
- // the current one.
- if eq(cmsg, previous_cmsg) {
- break;
- }
- }
-
- if previous_cmsg.is_null() {
- return false;
- }
-
- (*previous_cmsg).cmsg_level = cmsg_level;
- (*previous_cmsg).cmsg_type = cmsg_type;
- cfg_if::cfg_if! {
- if #[cfg(any(target_os = "android", all(target_os = "linux", target_env = "gnu")))] {
- (*previous_cmsg).cmsg_len = libc::CMSG_LEN(source_len) as libc::size_t;
- } else if #[cfg(any(
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- all(target_os = "linux", target_env = "musl",),
- target_os = "macos",
- target_os = "netbsd",
- target_os = "openbsd",
- ))] {
- (*previous_cmsg).cmsg_len = libc::CMSG_LEN(source_len) as libc::socklen_t;
- }
- }
-
- let data = libc::CMSG_DATA(previous_cmsg).cast();
-
- libc::memcpy(data, source.as_ptr().cast(), source_len as usize);
- }
- true
-}
-
-struct AncillaryDataIter<'a, T> {
- data: &'a [u8],
- phantom: PhantomData<T>,
-}
-
-impl<'a, T> AncillaryDataIter<'a, T> {
- /// Create `AncillaryDataIter` struct to iterate through the data unit in the control message.
- ///
- /// # Safety
- ///
- /// `data` must contain a valid control message.
- unsafe fn new(data: &'a [u8]) -> AncillaryDataIter<'a, T> {
- AncillaryDataIter { data, phantom: PhantomData }
- }
-}
-
-impl<'a, T> Iterator for AncillaryDataIter<'a, T> {
- type Item = T;
-
- fn next(&mut self) -> Option<T> {
- if size_of::<T>() <= self.data.len() {
- unsafe {
- let unit = read_unaligned(self.data.as_ptr().cast());
- self.data = &self.data[size_of::<T>()..];
- Some(unit)
- }
- } else {
- None
- }
- }
-}
-
-/// Unix credential.
-#[cfg(any(doc, target_os = "android", target_os = "linux",))]
-#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
-#[derive(Clone)]
-pub struct SocketCred(libc::ucred);
-
-#[cfg(any(doc, target_os = "android", target_os = "linux",))]
-impl SocketCred {
- /// Create a Unix credential struct.
- ///
- /// PID, UID and GID is set to 0.
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn new() -> SocketCred {
- SocketCred(libc::ucred { pid: 0, uid: 0, gid: 0 })
- }
-
- /// Set the PID.
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn set_pid(&mut self, pid: libc::pid_t) {
- self.0.pid = pid;
- }
-
- /// Get the current PID.
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn get_pid(&self) -> libc::pid_t {
- self.0.pid
- }
-
- /// Set the UID.
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn set_uid(&mut self, uid: libc::uid_t) {
- self.0.uid = uid;
- }
-
- /// Get the current UID.
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn get_uid(&self) -> libc::uid_t {
- self.0.uid
- }
-
- /// Set the GID.
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn set_gid(&mut self, gid: libc::gid_t) {
- self.0.gid = gid;
- }
-
- /// Get the current GID.
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn get_gid(&self) -> libc::gid_t {
- self.0.gid
- }
-}
-
-/// This control message contains file descriptors.
-///
-/// The level is equal to `SOL_SOCKET` and the type is equal to `SCM_RIGHTS`.
-#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
-pub struct ScmRights<'a>(AncillaryDataIter<'a, RawFd>);
-
-#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
-impl<'a> Iterator for ScmRights<'a> {
- type Item = RawFd;
-
- fn next(&mut self) -> Option<RawFd> {
- self.0.next()
- }
-}
-
-/// This control message contains unix credentials.
-///
-/// The level is equal to `SOL_SOCKET` and the type is equal to `SCM_CREDENTIALS` or `SCM_CREDS`.
-#[cfg(any(doc, target_os = "android", target_os = "linux",))]
-#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
-pub struct ScmCredentials<'a>(AncillaryDataIter<'a, libc::ucred>);
-
-#[cfg(any(doc, target_os = "android", target_os = "linux",))]
-#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
-impl<'a> Iterator for ScmCredentials<'a> {
- type Item = SocketCred;
-
- fn next(&mut self) -> Option<SocketCred> {
- Some(SocketCred(self.0.next()?))
- }
-}
-
-/// The error type which is returned from parsing the type a control message.
-#[non_exhaustive]
-#[derive(Debug)]
-#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
-pub enum AncillaryError {
- Unknown { cmsg_level: i32, cmsg_type: i32 },
-}
-
-/// This enum represent one control message of variable type.
-#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
-pub enum AncillaryData<'a> {
- ScmRights(ScmRights<'a>),
- #[cfg(any(doc, target_os = "android", target_os = "linux",))]
- ScmCredentials(ScmCredentials<'a>),
-}
-
-impl<'a> AncillaryData<'a> {
- /// Create a `AncillaryData::ScmRights` variant.
- ///
- /// # Safety
- ///
- /// `data` must contain a valid control message and the control message must be type of
- /// `SOL_SOCKET` and level of `SCM_RIGHTS`.
- unsafe fn as_rights(data: &'a [u8]) -> Self {
- let ancillary_data_iter = AncillaryDataIter::new(data);
- let scm_rights = ScmRights(ancillary_data_iter);
- AncillaryData::ScmRights(scm_rights)
- }
-
- /// Create a `AncillaryData::ScmCredentials` variant.
- ///
- /// # Safety
- ///
- /// `data` must contain a valid control message and the control message must be type of
- /// `SOL_SOCKET` and level of `SCM_CREDENTIALS` or `SCM_CREDENTIALS`.
- #[cfg(any(doc, target_os = "android", target_os = "linux",))]
- unsafe fn as_credentials(data: &'a [u8]) -> Self {
- let ancillary_data_iter = AncillaryDataIter::new(data);
- let scm_credentials = ScmCredentials(ancillary_data_iter);
- AncillaryData::ScmCredentials(scm_credentials)
- }
-
- fn try_from_cmsghdr(cmsg: &'a libc::cmsghdr) -> Result<Self, AncillaryError> {
- unsafe {
- cfg_if::cfg_if! {
- if #[cfg(any(
- target_os = "android",
- all(target_os = "linux", target_env = "gnu"),
- all(target_os = "linux", target_env = "uclibc"),
- ))] {
- let cmsg_len_zero = libc::CMSG_LEN(0) as libc::size_t;
- } else if #[cfg(any(
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- all(target_os = "linux", target_env = "musl",),
- target_os = "macos",
- target_os = "netbsd",
- target_os = "openbsd",
- ))] {
- let cmsg_len_zero = libc::CMSG_LEN(0) as libc::socklen_t;
- }
- }
- let data_len = (*cmsg).cmsg_len - cmsg_len_zero;
- let data = libc::CMSG_DATA(cmsg).cast();
- let data = from_raw_parts(data, data_len as usize);
-
- match (*cmsg).cmsg_level {
- libc::SOL_SOCKET => match (*cmsg).cmsg_type {
- libc::SCM_RIGHTS => Ok(AncillaryData::as_rights(data)),
- #[cfg(any(target_os = "android", target_os = "linux",))]
- libc::SCM_CREDENTIALS => Ok(AncillaryData::as_credentials(data)),
- cmsg_type => {
- Err(AncillaryError::Unknown { cmsg_level: libc::SOL_SOCKET, cmsg_type })
- }
- },
- cmsg_level => {
- Err(AncillaryError::Unknown { cmsg_level, cmsg_type: (*cmsg).cmsg_type })
- }
- }
- }
- }
-}
-
-/// This struct is used to iterate through the control messages.
-#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
-pub struct Messages<'a> {
- buffer: &'a [u8],
- current: Option<&'a libc::cmsghdr>,
-}
-
-#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
-impl<'a> Iterator for Messages<'a> {
- type Item = Result<AncillaryData<'a>, AncillaryError>;
-
- fn next(&mut self) -> Option<Self::Item> {
- unsafe {
- let mut msg: libc::msghdr = zeroed();
- msg.msg_control = self.buffer.as_ptr() as *mut _;
- cfg_if::cfg_if! {
- if #[cfg(any(target_os = "android", all(target_os = "linux", target_env = "gnu")))] {
- msg.msg_controllen = self.buffer.len() as libc::size_t;
- } else if #[cfg(any(
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- all(target_os = "linux", target_env = "musl",),
- target_os = "macos",
- target_os = "netbsd",
- target_os = "openbsd",
- ))] {
- msg.msg_controllen = self.buffer.len() as libc::socklen_t;
- }
- }
-
- let cmsg = if let Some(current) = self.current {
- libc::CMSG_NXTHDR(&msg, current)
- } else {
- libc::CMSG_FIRSTHDR(&msg)
- };
-
- let cmsg = cmsg.as_ref()?;
-
- // Most operating systems, but not Linux or emscripten, return the previous pointer
- // when its length is zero. Therefore, check if the previous pointer is the same as
- // the current one.
- if let Some(current) = self.current {
- if eq(current, cmsg) {
- return None;
- }
- }
-
- self.current = Some(cmsg);
- let ancillary_result = AncillaryData::try_from_cmsghdr(cmsg);
- Some(ancillary_result)
- }
- }
-}
-
-/// A Unix socket Ancillary data struct.
-///
-/// # Example
-/// ```no_run
-/// #![feature(unix_socket_ancillary_data)]
-/// use std::os::unix::net::{UnixStream, SocketAncillary, AncillaryData};
-/// use std::io::IoSliceMut;
-///
-/// fn main() -> std::io::Result<()> {
-/// let sock = UnixStream::connect("/tmp/sock")?;
-///
-/// let mut fds = [0; 8];
-/// let mut ancillary_buffer = [0; 128];
-/// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
-///
-/// let mut buf = [1; 8];
-/// let mut bufs = &mut [IoSliceMut::new(&mut buf[..])][..];
-/// sock.recv_vectored_with_ancillary(bufs, &mut ancillary)?;
-///
-/// for ancillary_result in ancillary.messages() {
-/// if let AncillaryData::ScmRights(scm_rights) = ancillary_result.unwrap() {
-/// for fd in scm_rights {
-/// println!("receive file descriptor: {}", fd);
-/// }
-/// }
-/// }
-/// Ok(())
-/// }
-/// ```
-#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
-#[derive(Debug)]
-pub struct SocketAncillary<'a> {
- buffer: &'a mut [u8],
- length: usize,
- truncated: bool,
-}
-
-impl<'a> SocketAncillary<'a> {
- /// Create an ancillary data with the given buffer.
- ///
- /// # Example
- ///
- /// ```no_run
- /// # #![allow(unused_mut)]
- /// #![feature(unix_socket_ancillary_data)]
- /// use std::os::unix::net::SocketAncillary;
- /// let mut ancillary_buffer = [0; 128];
- /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
- /// ```
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn new(buffer: &'a mut [u8]) -> Self {
- SocketAncillary { buffer, length: 0, truncated: false }
- }
-
- /// Returns the capacity of the buffer.
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn capacity(&self) -> usize {
- self.buffer.len()
- }
-
- /// Returns `true` if the ancillary data is empty.
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn is_empty(&self) -> bool {
- self.length == 0
- }
-
- /// Returns the number of used bytes.
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn len(&self) -> usize {
- self.length
- }
-
- /// Returns the iterator of the control messages.
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn messages(&self) -> Messages<'_> {
- Messages { buffer: &self.buffer[..self.length], current: None }
- }
-
- /// Is `true` if during a recv operation the ancillary was truncated.
- ///
- /// # Example
- ///
- /// ```no_run
- /// #![feature(unix_socket_ancillary_data)]
- /// use std::os::unix::net::{UnixStream, SocketAncillary};
- /// use std::io::IoSliceMut;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixStream::connect("/tmp/sock")?;
- ///
- /// let mut ancillary_buffer = [0; 128];
- /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
- ///
- /// let mut buf = [1; 8];
- /// let mut bufs = &mut [IoSliceMut::new(&mut buf[..])][..];
- /// sock.recv_vectored_with_ancillary(bufs, &mut ancillary)?;
- ///
- /// println!("Is truncated: {}", ancillary.truncated());
- /// Ok(())
- /// }
- /// ```
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn truncated(&self) -> bool {
- self.truncated
- }
-
- /// Add file descriptors to the ancillary data.
- ///
- /// The function returns `true` if there was enough space in the buffer.
- /// If there was not enough space then no file descriptors was appended.
- /// Technically, that means this operation adds a control message with the level `SOL_SOCKET`
- /// and type `SCM_RIGHTS`.
- ///
- /// # Example
- ///
- /// ```no_run
- /// #![feature(unix_socket_ancillary_data)]
- /// use std::os::unix::net::{UnixStream, SocketAncillary};
- /// use std::os::unix::io::AsRawFd;
- /// use std::io::IoSlice;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixStream::connect("/tmp/sock")?;
- ///
- /// let mut ancillary_buffer = [0; 128];
- /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
- /// ancillary.add_fds(&[sock.as_raw_fd()][..]);
- ///
- /// let mut buf = [1; 8];
- /// let mut bufs = &mut [IoSlice::new(&mut buf[..])][..];
- /// sock.send_vectored_with_ancillary(bufs, &mut ancillary)?;
- /// Ok(())
- /// }
- /// ```
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn add_fds(&mut self, fds: &[RawFd]) -> bool {
- self.truncated = false;
- add_to_ancillary_data(
- &mut self.buffer,
- &mut self.length,
- fds,
- libc::SOL_SOCKET,
- libc::SCM_RIGHTS,
- )
- }
-
- /// Add credentials to the ancillary data.
- ///
- /// The function returns `true` if there was enough space in the buffer.
- /// If there was not enough space then no credentials was appended.
- /// Technically, that means this operation adds a control message with the level `SOL_SOCKET`
- /// and type `SCM_CREDENTIALS` or `SCM_CREDS`.
- ///
- #[cfg(any(doc, target_os = "android", target_os = "linux",))]
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn add_creds(&mut self, creds: &[SocketCred]) -> bool {
- self.truncated = false;
- add_to_ancillary_data(
- &mut self.buffer,
- &mut self.length,
- creds,
- libc::SOL_SOCKET,
- libc::SCM_CREDENTIALS,
- )
- }
-
- /// Clears the ancillary data, removing all values.
- ///
- /// # Example
- ///
- /// ```no_run
- /// #![feature(unix_socket_ancillary_data)]
- /// use std::os::unix::net::{UnixStream, SocketAncillary, AncillaryData};
- /// use std::io::IoSliceMut;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixStream::connect("/tmp/sock")?;
- ///
- /// let mut fds1 = [0; 8];
- /// let mut fds2 = [0; 8];
- /// let mut ancillary_buffer = [0; 128];
- /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
- ///
- /// let mut buf = [1; 8];
- /// let mut bufs = &mut [IoSliceMut::new(&mut buf[..])][..];
- ///
- /// sock.recv_vectored_with_ancillary(bufs, &mut ancillary)?;
- /// for ancillary_result in ancillary.messages() {
- /// if let AncillaryData::ScmRights(scm_rights) = ancillary_result.unwrap() {
- /// for fd in scm_rights {
- /// println!("receive file descriptor: {}", fd);
- /// }
- /// }
- /// }
- ///
- /// ancillary.clear();
- ///
- /// sock.recv_vectored_with_ancillary(bufs, &mut ancillary)?;
- /// for ancillary_result in ancillary.messages() {
- /// if let AncillaryData::ScmRights(scm_rights) = ancillary_result.unwrap() {
- /// for fd in scm_rights {
- /// println!("receive file descriptor: {}", fd);
- /// }
- /// }
- /// }
- /// Ok(())
- /// }
- /// ```
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn clear(&mut self) {
- self.length = 0;
- self.truncated = false;
- }
-}
+++ /dev/null
-#[cfg(any(
- doc,
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
-))]
-use super::{recv_vectored_with_ancillary_from, send_vectored_with_ancillary_to, SocketAncillary};
-use super::{sockaddr_un, SocketAddr};
-#[cfg(any(
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
-))]
-use crate::io::{IoSlice, IoSliceMut};
-use crate::net::Shutdown;
-use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
-use crate::path::Path;
-use crate::sys::cvt;
-use crate::sys::net::Socket;
-use crate::sys_common::{AsInner, FromInner, IntoInner};
-use crate::time::Duration;
-use crate::{fmt, io};
-
-#[cfg(any(
- target_os = "linux",
- target_os = "android",
- target_os = "dragonfly",
- target_os = "freebsd",
- target_os = "openbsd",
- target_os = "netbsd",
- target_os = "haiku"
-))]
-use libc::MSG_NOSIGNAL;
-#[cfg(not(any(
- target_os = "linux",
- target_os = "android",
- target_os = "dragonfly",
- target_os = "freebsd",
- target_os = "openbsd",
- target_os = "netbsd",
- target_os = "haiku"
-)))]
-const MSG_NOSIGNAL: libc::c_int = 0x0;
-
-/// A Unix datagram socket.
-///
-/// # Examples
-///
-/// ```no_run
-/// use std::os::unix::net::UnixDatagram;
-///
-/// fn main() -> std::io::Result<()> {
-/// let socket = UnixDatagram::bind("/path/to/my/socket")?;
-/// socket.send_to(b"hello world", "/path/to/other/socket")?;
-/// let mut buf = [0; 100];
-/// let (count, address) = socket.recv_from(&mut buf)?;
-/// println!("socket {:?} sent {:?}", address, &buf[..count]);
-/// Ok(())
-/// }
-/// ```
-#[stable(feature = "unix_socket", since = "1.10.0")]
-pub struct UnixDatagram(Socket);
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl fmt::Debug for UnixDatagram {
- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
- let mut builder = fmt.debug_struct("UnixDatagram");
- builder.field("fd", self.0.as_inner());
- if let Ok(addr) = self.local_addr() {
- builder.field("local", &addr);
- }
- if let Ok(addr) = self.peer_addr() {
- builder.field("peer", &addr);
- }
- builder.finish()
- }
-}
-
-impl UnixDatagram {
- /// Creates a Unix datagram socket bound to the given path.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// let sock = match UnixDatagram::bind("/path/to/the/socket") {
- /// Ok(sock) => sock,
- /// Err(e) => {
- /// println!("Couldn't bind: {:?}", e);
- /// return
- /// }
- /// };
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixDatagram> {
- unsafe {
- let socket = UnixDatagram::unbound()?;
- let (addr, len) = sockaddr_un(path.as_ref())?;
-
- cvt(libc::bind(*socket.0.as_inner(), &addr as *const _ as *const _, len as _))?;
-
- Ok(socket)
- }
- }
-
- /// Creates a Unix Datagram socket which is not bound to any address.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// let sock = match UnixDatagram::unbound() {
- /// Ok(sock) => sock,
- /// Err(e) => {
- /// println!("Couldn't unbound: {:?}", e);
- /// return
- /// }
- /// };
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn unbound() -> io::Result<UnixDatagram> {
- let inner = Socket::new_raw(libc::AF_UNIX, libc::SOCK_DGRAM)?;
- Ok(UnixDatagram(inner))
- }
-
- /// Creates an unnamed pair of connected sockets.
- ///
- /// Returns two `UnixDatagrams`s which are connected to each other.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// let (sock1, sock2) = match UnixDatagram::pair() {
- /// Ok((sock1, sock2)) => (sock1, sock2),
- /// Err(e) => {
- /// println!("Couldn't unbound: {:?}", e);
- /// return
- /// }
- /// };
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn pair() -> io::Result<(UnixDatagram, UnixDatagram)> {
- let (i1, i2) = Socket::new_pair(libc::AF_UNIX, libc::SOCK_DGRAM)?;
- Ok((UnixDatagram(i1), UnixDatagram(i2)))
- }
-
- /// Connects the socket to the specified address.
- ///
- /// The [`send`] method may be used to send data to the specified address.
- /// [`recv`] and [`recv_from`] will only receive data from that address.
- ///
- /// [`send`]: UnixDatagram::send
- /// [`recv`]: UnixDatagram::recv
- /// [`recv_from`]: UnixDatagram::recv_from
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// match sock.connect("/path/to/the/socket") {
- /// Ok(sock) => sock,
- /// Err(e) => {
- /// println!("Couldn't connect: {:?}", e);
- /// return Err(e)
- /// }
- /// };
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn connect<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
- unsafe {
- let (addr, len) = sockaddr_un(path.as_ref())?;
-
- cvt(libc::connect(*self.0.as_inner(), &addr as *const _ as *const _, len))?;
- }
- Ok(())
- }
-
- /// Creates a new independently owned handle to the underlying socket.
- ///
- /// The returned `UnixDatagram` is a reference to the same socket that this
- /// object references. Both handles can be used to accept incoming
- /// connections and options set on one side will affect the other.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::bind("/path/to/the/socket")?;
- /// let sock_copy = sock.try_clone().expect("try_clone failed");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn try_clone(&self) -> io::Result<UnixDatagram> {
- self.0.duplicate().map(UnixDatagram)
- }
-
- /// Returns the address of this socket.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::bind("/path/to/the/socket")?;
- /// let addr = sock.local_addr().expect("Couldn't get local address");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn local_addr(&self) -> io::Result<SocketAddr> {
- SocketAddr::new(|addr, len| unsafe { libc::getsockname(*self.0.as_inner(), addr, len) })
- }
-
- /// Returns the address of this socket's peer.
- ///
- /// The [`connect`] method will connect the socket to a peer.
- ///
- /// [`connect`]: UnixDatagram::connect
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// sock.connect("/path/to/the/socket")?;
- ///
- /// let addr = sock.peer_addr().expect("Couldn't get peer address");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn peer_addr(&self) -> io::Result<SocketAddr> {
- SocketAddr::new(|addr, len| unsafe { libc::getpeername(*self.0.as_inner(), addr, len) })
- }
-
- fn recv_from_flags(
- &self,
- buf: &mut [u8],
- flags: libc::c_int,
- ) -> io::Result<(usize, SocketAddr)> {
- let mut count = 0;
- let addr = SocketAddr::new(|addr, len| unsafe {
- count = libc::recvfrom(
- *self.0.as_inner(),
- buf.as_mut_ptr() as *mut _,
- buf.len(),
- flags,
- addr,
- len,
- );
- if count > 0 {
- 1
- } else if count == 0 {
- 0
- } else {
- -1
- }
- })?;
-
- Ok((count as usize, addr))
- }
-
- /// Receives data from the socket.
- ///
- /// On success, returns the number of bytes read and the address from
- /// whence the data came.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// let mut buf = vec![0; 10];
- /// let (size, sender) = sock.recv_from(buf.as_mut_slice())?;
- /// println!("received {} bytes from {:?}", size, sender);
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
- self.recv_from_flags(buf, 0)
- }
-
- /// Receives data from the socket.
- ///
- /// On success, returns the number of bytes read.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::bind("/path/to/the/socket")?;
- /// let mut buf = vec![0; 10];
- /// sock.recv(buf.as_mut_slice()).expect("recv function failed");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn recv(&self, buf: &mut [u8]) -> io::Result<usize> {
- self.0.read(buf)
- }
-
- /// Receives data and ancillary data from socket.
- ///
- /// On success, returns the number of bytes read, if the data was truncated and the address from whence the msg came.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// #![feature(unix_socket_ancillary_data)]
- /// use std::os::unix::net::{UnixDatagram, SocketAncillary, AncillaryData};
- /// use std::io::IoSliceMut;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// let mut buf1 = [1; 8];
- /// let mut buf2 = [2; 16];
- /// let mut buf3 = [3; 8];
- /// let mut bufs = &mut [
- /// IoSliceMut::new(&mut buf1),
- /// IoSliceMut::new(&mut buf2),
- /// IoSliceMut::new(&mut buf3),
- /// ][..];
- /// let mut fds = [0; 8];
- /// let mut ancillary_buffer = [0; 128];
- /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
- /// let (size, _truncated, sender) = sock.recv_vectored_with_ancillary_from(bufs, &mut ancillary)?;
- /// println!("received {}", size);
- /// for ancillary_result in ancillary.messages() {
- /// if let AncillaryData::ScmRights(scm_rights) = ancillary_result.unwrap() {
- /// for fd in scm_rights {
- /// println!("receive file descriptor: {}", fd);
- /// }
- /// }
- /// }
- /// Ok(())
- /// }
- /// ```
- #[cfg(any(
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
- ))]
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn recv_vectored_with_ancillary_from(
- &self,
- bufs: &mut [IoSliceMut<'_>],
- ancillary: &mut SocketAncillary<'_>,
- ) -> io::Result<(usize, bool, SocketAddr)> {
- let (count, truncated, addr) = recv_vectored_with_ancillary_from(&self.0, bufs, ancillary)?;
- let addr = addr?;
-
- Ok((count, truncated, addr))
- }
-
- /// Receives data and ancillary data from socket.
- ///
- /// On success, returns the number of bytes read and if the data was truncated.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// #![feature(unix_socket_ancillary_data)]
- /// use std::os::unix::net::{UnixDatagram, SocketAncillary, AncillaryData};
- /// use std::io::IoSliceMut;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// let mut buf1 = [1; 8];
- /// let mut buf2 = [2; 16];
- /// let mut buf3 = [3; 8];
- /// let mut bufs = &mut [
- /// IoSliceMut::new(&mut buf1),
- /// IoSliceMut::new(&mut buf2),
- /// IoSliceMut::new(&mut buf3),
- /// ][..];
- /// let mut fds = [0; 8];
- /// let mut ancillary_buffer = [0; 128];
- /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
- /// let (size, _truncated) = sock.recv_vectored_with_ancillary(bufs, &mut ancillary)?;
- /// println!("received {}", size);
- /// for ancillary_result in ancillary.messages() {
- /// if let AncillaryData::ScmRights(scm_rights) = ancillary_result.unwrap() {
- /// for fd in scm_rights {
- /// println!("receive file descriptor: {}", fd);
- /// }
- /// }
- /// }
- /// Ok(())
- /// }
- /// ```
- #[cfg(any(
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
- ))]
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn recv_vectored_with_ancillary(
- &self,
- bufs: &mut [IoSliceMut<'_>],
- ancillary: &mut SocketAncillary<'_>,
- ) -> io::Result<(usize, bool)> {
- let (count, truncated, addr) = recv_vectored_with_ancillary_from(&self.0, bufs, ancillary)?;
- addr?;
-
- Ok((count, truncated))
- }
-
- /// Sends data on the socket to the specified address.
- ///
- /// On success, returns the number of bytes written.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// sock.send_to(b"omelette au fromage", "/some/sock").expect("send_to function failed");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn send_to<P: AsRef<Path>>(&self, buf: &[u8], path: P) -> io::Result<usize> {
- unsafe {
- let (addr, len) = sockaddr_un(path.as_ref())?;
-
- let count = cvt(libc::sendto(
- *self.0.as_inner(),
- buf.as_ptr() as *const _,
- buf.len(),
- MSG_NOSIGNAL,
- &addr as *const _ as *const _,
- len,
- ))?;
- Ok(count as usize)
- }
- }
-
- /// Sends data on the socket to the socket's peer.
- ///
- /// The peer address may be set by the `connect` method, and this method
- /// will return an error if the socket has not already been connected.
- ///
- /// On success, returns the number of bytes written.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// sock.connect("/some/sock").expect("Couldn't connect");
- /// sock.send(b"omelette au fromage").expect("send_to function failed");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn send(&self, buf: &[u8]) -> io::Result<usize> {
- self.0.write(buf)
- }
-
- /// Sends data and ancillary data on the socket to the specified address.
- ///
- /// On success, returns the number of bytes written.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// #![feature(unix_socket_ancillary_data)]
- /// use std::os::unix::net::{UnixDatagram, SocketAncillary};
- /// use std::io::IoSlice;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// let buf1 = [1; 8];
- /// let buf2 = [2; 16];
- /// let buf3 = [3; 8];
- /// let bufs = &[
- /// IoSlice::new(&buf1),
- /// IoSlice::new(&buf2),
- /// IoSlice::new(&buf3),
- /// ][..];
- /// let fds = [0, 1, 2];
- /// let mut ancillary_buffer = [0; 128];
- /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
- /// ancillary.add_fds(&fds[..]);
- /// sock.send_vectored_with_ancillary_to(bufs, &mut ancillary, "/some/sock")
- /// .expect("send_vectored_with_ancillary_to function failed");
- /// Ok(())
- /// }
- /// ```
- #[cfg(any(
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
- ))]
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn send_vectored_with_ancillary_to<P: AsRef<Path>>(
- &self,
- bufs: &[IoSlice<'_>],
- ancillary: &mut SocketAncillary<'_>,
- path: P,
- ) -> io::Result<usize> {
- send_vectored_with_ancillary_to(&self.0, Some(path.as_ref()), bufs, ancillary)
- }
-
- /// Sends data and ancillary data on the socket.
- ///
- /// On success, returns the number of bytes written.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// #![feature(unix_socket_ancillary_data)]
- /// use std::os::unix::net::{UnixDatagram, SocketAncillary};
- /// use std::io::IoSlice;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// let buf1 = [1; 8];
- /// let buf2 = [2; 16];
- /// let buf3 = [3; 8];
- /// let bufs = &[
- /// IoSlice::new(&buf1),
- /// IoSlice::new(&buf2),
- /// IoSlice::new(&buf3),
- /// ][..];
- /// let fds = [0, 1, 2];
- /// let mut ancillary_buffer = [0; 128];
- /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
- /// ancillary.add_fds(&fds[..]);
- /// sock.send_vectored_with_ancillary(bufs, &mut ancillary)
- /// .expect("send_vectored_with_ancillary function failed");
- /// Ok(())
- /// }
- /// ```
- #[cfg(any(
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
- ))]
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn send_vectored_with_ancillary(
- &self,
- bufs: &[IoSlice<'_>],
- ancillary: &mut SocketAncillary<'_>,
- ) -> io::Result<usize> {
- send_vectored_with_ancillary_to(&self.0, None, bufs, ancillary)
- }
-
- /// Sets the read timeout for the socket.
- ///
- /// If the provided value is [`None`], then [`recv`] and [`recv_from`] calls will
- /// block indefinitely. An [`Err`] is returned if the zero [`Duration`]
- /// is passed to this method.
- ///
- /// [`recv`]: UnixDatagram::recv
- /// [`recv_from`]: UnixDatagram::recv_from
- ///
- /// # Examples
- ///
- /// ```
- /// use std::os::unix::net::UnixDatagram;
- /// use std::time::Duration;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// sock.set_read_timeout(Some(Duration::new(1, 0)))
- /// .expect("set_read_timeout function failed");
- /// Ok(())
- /// }
- /// ```
- ///
- /// An [`Err`] is returned if the zero [`Duration`] is passed to this
- /// method:
- ///
- /// ```no_run
- /// use std::io;
- /// use std::os::unix::net::UnixDatagram;
- /// use std::time::Duration;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixDatagram::unbound()?;
- /// let result = socket.set_read_timeout(Some(Duration::new(0, 0)));
- /// let err = result.unwrap_err();
- /// assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn set_read_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
- self.0.set_timeout(timeout, libc::SO_RCVTIMEO)
- }
-
- /// Sets the write timeout for the socket.
- ///
- /// If the provided value is [`None`], then [`send`] and [`send_to`] calls will
- /// block indefinitely. An [`Err`] is returned if the zero [`Duration`] is passed to this
- /// method.
- ///
- /// [`send`]: UnixDatagram::send
- /// [`send_to`]: UnixDatagram::send_to
- ///
- /// # Examples
- ///
- /// ```
- /// use std::os::unix::net::UnixDatagram;
- /// use std::time::Duration;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// sock.set_write_timeout(Some(Duration::new(1, 0)))
- /// .expect("set_write_timeout function failed");
- /// Ok(())
- /// }
- /// ```
- ///
- /// An [`Err`] is returned if the zero [`Duration`] is passed to this
- /// method:
- ///
- /// ```no_run
- /// use std::io;
- /// use std::os::unix::net::UnixDatagram;
- /// use std::time::Duration;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixDatagram::unbound()?;
- /// let result = socket.set_write_timeout(Some(Duration::new(0, 0)));
- /// let err = result.unwrap_err();
- /// assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn set_write_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
- self.0.set_timeout(timeout, libc::SO_SNDTIMEO)
- }
-
- /// Returns the read timeout of this socket.
- ///
- /// # Examples
- ///
- /// ```
- /// use std::os::unix::net::UnixDatagram;
- /// use std::time::Duration;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// sock.set_read_timeout(Some(Duration::new(1, 0)))
- /// .expect("set_read_timeout function failed");
- /// assert_eq!(sock.read_timeout()?, Some(Duration::new(1, 0)));
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
- self.0.timeout(libc::SO_RCVTIMEO)
- }
-
- /// Returns the write timeout of this socket.
- ///
- /// # Examples
- ///
- /// ```
- /// use std::os::unix::net::UnixDatagram;
- /// use std::time::Duration;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// sock.set_write_timeout(Some(Duration::new(1, 0)))
- /// .expect("set_write_timeout function failed");
- /// assert_eq!(sock.write_timeout()?, Some(Duration::new(1, 0)));
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
- self.0.timeout(libc::SO_SNDTIMEO)
- }
-
- /// Moves the socket into or out of nonblocking mode.
- ///
- /// # Examples
- ///
- /// ```
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// sock.set_nonblocking(true).expect("set_nonblocking function failed");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
- self.0.set_nonblocking(nonblocking)
- }
-
- /// Moves the socket to pass unix credentials as control message in [`SocketAncillary`].
- ///
- /// Set the socket option `SO_PASSCRED`.
- ///
- /// # Examples
- ///
- #[cfg_attr(any(target_os = "android", target_os = "linux"), doc = "```no_run")]
- #[cfg_attr(not(any(target_os = "android", target_os = "linux")), doc = "```ignore")]
- /// #![feature(unix_socket_ancillary_data)]
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// sock.set_passcred(true).expect("set_passcred function failed");
- /// Ok(())
- /// }
- /// ```
- #[cfg(any(doc, target_os = "android", target_os = "linux",))]
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn set_passcred(&self, passcred: bool) -> io::Result<()> {
- self.0.set_passcred(passcred)
- }
-
- /// Get the current value of the socket for passing unix credentials in [`SocketAncillary`].
- /// This value can be change by [`set_passcred`].
- ///
- /// Get the socket option `SO_PASSCRED`.
- ///
- /// [`set_passcred`]: UnixDatagram::set_passcred
- #[cfg(any(doc, target_os = "android", target_os = "linux",))]
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn passcred(&self) -> io::Result<bool> {
- self.0.passcred()
- }
-
- /// Returns the value of the `SO_ERROR` option.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// if let Ok(Some(err)) = sock.take_error() {
- /// println!("Got error: {:?}", err);
- /// }
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn take_error(&self) -> io::Result<Option<io::Error>> {
- self.0.take_error()
- }
-
- /// Shut down the read, write, or both halves of this connection.
- ///
- /// This function will cause all pending and future I/O calls on the
- /// specified portions to immediately return with an appropriate value
- /// (see the documentation of [`Shutdown`]).
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixDatagram;
- /// use std::net::Shutdown;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let sock = UnixDatagram::unbound()?;
- /// sock.shutdown(Shutdown::Both).expect("shutdown function failed");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
- self.0.shutdown(how)
- }
-
- /// Receives data on the socket from the remote address to which it is
- /// connected, without removing that data from the queue. On success,
- /// returns the number of bytes peeked.
- ///
- /// Successive calls return the same data. This is accomplished by passing
- /// `MSG_PEEK` as a flag to the underlying `recv` system call.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// #![feature(unix_socket_peek)]
- ///
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixDatagram::bind("/tmp/sock")?;
- /// let mut buf = [0; 10];
- /// let len = socket.peek(&mut buf).expect("peek failed");
- /// Ok(())
- /// }
- /// ```
- #[unstable(feature = "unix_socket_peek", issue = "76923")]
- pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
- self.0.peek(buf)
- }
-
- /// Receives a single datagram message on the socket, without removing it from the
- /// queue. On success, returns the number of bytes read and the origin.
- ///
- /// The function must be called with valid byte array `buf` of sufficient size to
- /// hold the message bytes. If a message is too long to fit in the supplied buffer,
- /// excess bytes may be discarded.
- ///
- /// Successive calls return the same data. This is accomplished by passing
- /// `MSG_PEEK` as a flag to the underlying `recvfrom` system call.
- ///
- /// Do not use this function to implement busy waiting, instead use `libc::poll` to
- /// synchronize IO events on one or more sockets.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// #![feature(unix_socket_peek)]
- ///
- /// use std::os::unix::net::UnixDatagram;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixDatagram::bind("/tmp/sock")?;
- /// let mut buf = [0; 10];
- /// let (len, addr) = socket.peek_from(&mut buf).expect("peek failed");
- /// Ok(())
- /// }
- /// ```
- #[unstable(feature = "unix_socket_peek", issue = "76923")]
- pub fn peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
- self.recv_from_flags(buf, libc::MSG_PEEK)
- }
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl AsRawFd for UnixDatagram {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- *self.0.as_inner()
- }
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl FromRawFd for UnixDatagram {
- #[inline]
- unsafe fn from_raw_fd(fd: RawFd) -> UnixDatagram {
- UnixDatagram(Socket::from_inner(fd))
- }
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl IntoRawFd for UnixDatagram {
- #[inline]
- fn into_raw_fd(self) -> RawFd {
- self.0.into_inner()
- }
-}
+++ /dev/null
-use super::{sockaddr_un, SocketAddr, UnixStream};
-use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
-use crate::path::Path;
-use crate::sys::cvt;
-use crate::sys::net::Socket;
-use crate::sys_common::{AsInner, FromInner, IntoInner};
-use crate::{fmt, io, mem};
-
-/// A structure representing a Unix domain socket server.
-///
-/// # Examples
-///
-/// ```no_run
-/// use std::thread;
-/// use std::os::unix::net::{UnixStream, UnixListener};
-///
-/// fn handle_client(stream: UnixStream) {
-/// // ...
-/// }
-///
-/// fn main() -> std::io::Result<()> {
-/// let listener = UnixListener::bind("/path/to/the/socket")?;
-///
-/// // accept connections and process them, spawning a new thread for each one
-/// for stream in listener.incoming() {
-/// match stream {
-/// Ok(stream) => {
-/// /* connection succeeded */
-/// thread::spawn(|| handle_client(stream));
-/// }
-/// Err(err) => {
-/// /* connection failed */
-/// break;
-/// }
-/// }
-/// }
-/// Ok(())
-/// }
-/// ```
-#[stable(feature = "unix_socket", since = "1.10.0")]
-pub struct UnixListener(Socket);
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl fmt::Debug for UnixListener {
- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
- let mut builder = fmt.debug_struct("UnixListener");
- builder.field("fd", self.0.as_inner());
- if let Ok(addr) = self.local_addr() {
- builder.field("local", &addr);
- }
- builder.finish()
- }
-}
-
-impl UnixListener {
- /// Creates a new `UnixListener` bound to the specified socket.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixListener;
- ///
- /// let listener = match UnixListener::bind("/path/to/the/socket") {
- /// Ok(sock) => sock,
- /// Err(e) => {
- /// println!("Couldn't connect: {:?}", e);
- /// return
- /// }
- /// };
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixListener> {
- unsafe {
- let inner = Socket::new_raw(libc::AF_UNIX, libc::SOCK_STREAM)?;
- let (addr, len) = sockaddr_un(path.as_ref())?;
-
- cvt(libc::bind(*inner.as_inner(), &addr as *const _ as *const _, len as _))?;
- cvt(libc::listen(*inner.as_inner(), 128))?;
-
- Ok(UnixListener(inner))
- }
- }
-
- /// Accepts a new incoming connection to this listener.
- ///
- /// This function will block the calling thread until a new Unix connection
- /// is established. When established, the corresponding [`UnixStream`] and
- /// the remote peer's address will be returned.
- ///
- /// [`UnixStream`]: crate::os::unix::net::UnixStream
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixListener;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let listener = UnixListener::bind("/path/to/the/socket")?;
- ///
- /// match listener.accept() {
- /// Ok((socket, addr)) => println!("Got a client: {:?}", addr),
- /// Err(e) => println!("accept function failed: {:?}", e),
- /// }
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn accept(&self) -> io::Result<(UnixStream, SocketAddr)> {
- let mut storage: libc::sockaddr_un = unsafe { mem::zeroed() };
- let mut len = mem::size_of_val(&storage) as libc::socklen_t;
- let sock = self.0.accept(&mut storage as *mut _ as *mut _, &mut len)?;
- let addr = SocketAddr::from_parts(storage, len)?;
- Ok((UnixStream(sock), addr))
- }
-
- /// Creates a new independently owned handle to the underlying socket.
- ///
- /// The returned `UnixListener` is a reference to the same socket that this
- /// object references. Both handles can be used to accept incoming
- /// connections and options set on one listener will affect the other.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixListener;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let listener = UnixListener::bind("/path/to/the/socket")?;
- /// let listener_copy = listener.try_clone().expect("try_clone failed");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn try_clone(&self) -> io::Result<UnixListener> {
- self.0.duplicate().map(UnixListener)
- }
-
- /// Returns the local socket address of this listener.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixListener;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let listener = UnixListener::bind("/path/to/the/socket")?;
- /// let addr = listener.local_addr().expect("Couldn't get local address");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn local_addr(&self) -> io::Result<SocketAddr> {
- SocketAddr::new(|addr, len| unsafe { libc::getsockname(*self.0.as_inner(), addr, len) })
- }
-
- /// Moves the socket into or out of nonblocking mode.
- ///
- /// This will result in the `accept` operation becoming nonblocking,
- /// i.e., immediately returning from their calls. If the IO operation is
- /// successful, `Ok` is returned and no further action is required. If the
- /// IO operation could not be completed and needs to be retried, an error
- /// with kind [`io::ErrorKind::WouldBlock`] is returned.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixListener;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let listener = UnixListener::bind("/path/to/the/socket")?;
- /// listener.set_nonblocking(true).expect("Couldn't set non blocking");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
- self.0.set_nonblocking(nonblocking)
- }
-
- /// Returns the value of the `SO_ERROR` option.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixListener;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let listener = UnixListener::bind("/tmp/sock")?;
- ///
- /// if let Ok(Some(err)) = listener.take_error() {
- /// println!("Got error: {:?}", err);
- /// }
- /// Ok(())
- /// }
- /// ```
- ///
- /// # Platform specific
- /// On Redox this always returns `None`.
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn take_error(&self) -> io::Result<Option<io::Error>> {
- self.0.take_error()
- }
-
- /// Returns an iterator over incoming connections.
- ///
- /// The iterator will never return [`None`] and will also not yield the
- /// peer's [`SocketAddr`] structure.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::thread;
- /// use std::os::unix::net::{UnixStream, UnixListener};
- ///
- /// fn handle_client(stream: UnixStream) {
- /// // ...
- /// }
- ///
- /// fn main() -> std::io::Result<()> {
- /// let listener = UnixListener::bind("/path/to/the/socket")?;
- ///
- /// for stream in listener.incoming() {
- /// match stream {
- /// Ok(stream) => {
- /// thread::spawn(|| handle_client(stream));
- /// }
- /// Err(err) => {
- /// break;
- /// }
- /// }
- /// }
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn incoming(&self) -> Incoming<'_> {
- Incoming { listener: self }
- }
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl AsRawFd for UnixListener {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- *self.0.as_inner()
- }
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl FromRawFd for UnixListener {
- #[inline]
- unsafe fn from_raw_fd(fd: RawFd) -> UnixListener {
- UnixListener(Socket::from_inner(fd))
- }
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl IntoRawFd for UnixListener {
- #[inline]
- fn into_raw_fd(self) -> RawFd {
- self.0.into_inner()
- }
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl<'a> IntoIterator for &'a UnixListener {
- type Item = io::Result<UnixStream>;
- type IntoIter = Incoming<'a>;
-
- fn into_iter(self) -> Incoming<'a> {
- self.incoming()
- }
-}
-
-/// An iterator over incoming connections to a [`UnixListener`].
-///
-/// It will never return [`None`].
-///
-/// # Examples
-///
-/// ```no_run
-/// use std::thread;
-/// use std::os::unix::net::{UnixStream, UnixListener};
-///
-/// fn handle_client(stream: UnixStream) {
-/// // ...
-/// }
-///
-/// fn main() -> std::io::Result<()> {
-/// let listener = UnixListener::bind("/path/to/the/socket")?;
-///
-/// for stream in listener.incoming() {
-/// match stream {
-/// Ok(stream) => {
-/// thread::spawn(|| handle_client(stream));
-/// }
-/// Err(err) => {
-/// break;
-/// }
-/// }
-/// }
-/// Ok(())
-/// }
-/// ```
-#[derive(Debug)]
-#[stable(feature = "unix_socket", since = "1.10.0")]
-pub struct Incoming<'a> {
- listener: &'a UnixListener,
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl<'a> Iterator for Incoming<'a> {
- type Item = io::Result<UnixStream>;
-
- fn next(&mut self) -> Option<io::Result<UnixStream>> {
- Some(self.listener.accept().map(|s| s.0))
- }
-
- fn size_hint(&self) -> (usize, Option<usize>) {
- (usize::MAX, None)
- }
-}
+++ /dev/null
-//! Unix-specific networking functionality
-
-#![stable(feature = "unix_socket", since = "1.10.0")]
-
-mod addr;
-#[doc(cfg(any(
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
-)))]
-#[cfg(any(
- doc,
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
-))]
-mod ancillary;
-mod datagram;
-mod listener;
-mod raw_fd;
-mod stream;
-#[cfg(all(test, not(target_os = "emscripten")))]
-mod tests;
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-pub use self::addr::*;
-#[cfg(any(
- doc,
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
-))]
-#[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
-pub use self::ancillary::*;
-#[stable(feature = "unix_socket", since = "1.10.0")]
-pub use self::datagram::*;
-#[stable(feature = "unix_socket", since = "1.10.0")]
-pub use self::listener::*;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use self::raw_fd::*;
-#[stable(feature = "unix_socket", since = "1.10.0")]
-pub use self::stream::*;
+++ /dev/null
-use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
-use crate::sys_common::{self, AsInner, FromInner, IntoInner};
-use crate::{net, sys};
-
-macro_rules! impl_as_raw_fd {
- ($($t:ident)*) => {$(
- #[stable(feature = "rust1", since = "1.0.0")]
- impl AsRawFd for net::$t {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- *self.as_inner().socket().as_inner()
- }
- }
- )*};
-}
-impl_as_raw_fd! { TcpStream TcpListener UdpSocket }
-
-macro_rules! impl_from_raw_fd {
- ($($t:ident)*) => {$(
- #[stable(feature = "from_raw_os", since = "1.1.0")]
- impl FromRawFd for net::$t {
- #[inline]
- unsafe fn from_raw_fd(fd: RawFd) -> net::$t {
- let socket = sys::net::Socket::from_inner(fd);
- net::$t::from_inner(sys_common::net::$t::from_inner(socket))
- }
- }
- )*};
-}
-impl_from_raw_fd! { TcpStream TcpListener UdpSocket }
-
-macro_rules! impl_into_raw_fd {
- ($($t:ident)*) => {$(
- #[stable(feature = "into_raw_os", since = "1.4.0")]
- impl IntoRawFd for net::$t {
- #[inline]
- fn into_raw_fd(self) -> RawFd {
- self.into_inner().into_socket().into_inner()
- }
- }
- )*};
-}
-impl_into_raw_fd! { TcpStream TcpListener UdpSocket }
+++ /dev/null
-#[cfg(any(
- doc,
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
-))]
-use super::{recv_vectored_with_ancillary_from, send_vectored_with_ancillary_to, SocketAncillary};
-use super::{sockaddr_un, SocketAddr};
-use crate::fmt;
-use crate::io::{self, Initializer, IoSlice, IoSliceMut};
-use crate::net::Shutdown;
-use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
-#[cfg(any(
- target_os = "android",
- target_os = "linux",
- target_os = "dragonfly",
- target_os = "freebsd",
- target_os = "ios",
- target_os = "macos",
- target_os = "openbsd"
-))]
-use crate::os::unix::ucred;
-use crate::path::Path;
-use crate::sys::cvt;
-use crate::sys::net::Socket;
-use crate::sys_common::{AsInner, FromInner, IntoInner};
-use crate::time::Duration;
-
-#[unstable(feature = "peer_credentials_unix_socket", issue = "42839", reason = "unstable")]
-#[cfg(any(
- target_os = "android",
- target_os = "linux",
- target_os = "dragonfly",
- target_os = "freebsd",
- target_os = "ios",
- target_os = "macos",
- target_os = "openbsd"
-))]
-pub use ucred::UCred;
-
-/// A Unix stream socket.
-///
-/// # Examples
-///
-/// ```no_run
-/// use std::os::unix::net::UnixStream;
-/// use std::io::prelude::*;
-///
-/// fn main() -> std::io::Result<()> {
-/// let mut stream = UnixStream::connect("/path/to/my/socket")?;
-/// stream.write_all(b"hello world")?;
-/// let mut response = String::new();
-/// stream.read_to_string(&mut response)?;
-/// println!("{}", response);
-/// Ok(())
-/// }
-/// ```
-#[stable(feature = "unix_socket", since = "1.10.0")]
-pub struct UnixStream(pub(super) Socket);
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl fmt::Debug for UnixStream {
- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
- let mut builder = fmt.debug_struct("UnixStream");
- builder.field("fd", self.0.as_inner());
- if let Ok(addr) = self.local_addr() {
- builder.field("local", &addr);
- }
- if let Ok(addr) = self.peer_addr() {
- builder.field("peer", &addr);
- }
- builder.finish()
- }
-}
-
-impl UnixStream {
- /// Connects to the socket named by `path`.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixStream;
- ///
- /// let socket = match UnixStream::connect("/tmp/sock") {
- /// Ok(sock) => sock,
- /// Err(e) => {
- /// println!("Couldn't connect: {:?}", e);
- /// return
- /// }
- /// };
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn connect<P: AsRef<Path>>(path: P) -> io::Result<UnixStream> {
- unsafe {
- let inner = Socket::new_raw(libc::AF_UNIX, libc::SOCK_STREAM)?;
- let (addr, len) = sockaddr_un(path.as_ref())?;
-
- cvt(libc::connect(*inner.as_inner(), &addr as *const _ as *const _, len))?;
- Ok(UnixStream(inner))
- }
- }
-
- /// Creates an unnamed pair of connected sockets.
- ///
- /// Returns two `UnixStream`s which are connected to each other.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixStream;
- ///
- /// let (sock1, sock2) = match UnixStream::pair() {
- /// Ok((sock1, sock2)) => (sock1, sock2),
- /// Err(e) => {
- /// println!("Couldn't create a pair of sockets: {:?}", e);
- /// return
- /// }
- /// };
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn pair() -> io::Result<(UnixStream, UnixStream)> {
- let (i1, i2) = Socket::new_pair(libc::AF_UNIX, libc::SOCK_STREAM)?;
- Ok((UnixStream(i1), UnixStream(i2)))
- }
-
- /// Creates a new independently owned handle to the underlying socket.
- ///
- /// The returned `UnixStream` is a reference to the same stream that this
- /// object references. Both handles will read and write the same stream of
- /// data, and options set on one stream will be propagated to the other
- /// stream.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixStream;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// let sock_copy = socket.try_clone().expect("Couldn't clone socket");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn try_clone(&self) -> io::Result<UnixStream> {
- self.0.duplicate().map(UnixStream)
- }
-
- /// Returns the socket address of the local half of this connection.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixStream;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// let addr = socket.local_addr().expect("Couldn't get local address");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn local_addr(&self) -> io::Result<SocketAddr> {
- SocketAddr::new(|addr, len| unsafe { libc::getsockname(*self.0.as_inner(), addr, len) })
- }
-
- /// Returns the socket address of the remote half of this connection.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixStream;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// let addr = socket.peer_addr().expect("Couldn't get peer address");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn peer_addr(&self) -> io::Result<SocketAddr> {
- SocketAddr::new(|addr, len| unsafe { libc::getpeername(*self.0.as_inner(), addr, len) })
- }
-
- /// Gets the peer credentials for this Unix domain socket.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// #![feature(peer_credentials_unix_socket)]
- /// use std::os::unix::net::UnixStream;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// let peer_cred = socket.peer_cred().expect("Couldn't get peer credentials");
- /// Ok(())
- /// }
- /// ```
- #[unstable(feature = "peer_credentials_unix_socket", issue = "42839", reason = "unstable")]
- #[cfg(any(
- target_os = "android",
- target_os = "linux",
- target_os = "dragonfly",
- target_os = "freebsd",
- target_os = "ios",
- target_os = "macos",
- target_os = "openbsd"
- ))]
- pub fn peer_cred(&self) -> io::Result<UCred> {
- ucred::peer_cred(self)
- }
-
- /// Sets the read timeout for the socket.
- ///
- /// If the provided value is [`None`], then [`read`] calls will block
- /// indefinitely. An [`Err`] is returned if the zero [`Duration`] is passed to this
- /// method.
- ///
- /// [`read`]: io::Read::read
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixStream;
- /// use std::time::Duration;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// socket.set_read_timeout(Some(Duration::new(1, 0))).expect("Couldn't set read timeout");
- /// Ok(())
- /// }
- /// ```
- ///
- /// An [`Err`] is returned if the zero [`Duration`] is passed to this
- /// method:
- ///
- /// ```no_run
- /// use std::io;
- /// use std::os::unix::net::UnixStream;
- /// use std::time::Duration;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// let result = socket.set_read_timeout(Some(Duration::new(0, 0)));
- /// let err = result.unwrap_err();
- /// assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn set_read_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
- self.0.set_timeout(timeout, libc::SO_RCVTIMEO)
- }
-
- /// Sets the write timeout for the socket.
- ///
- /// If the provided value is [`None`], then [`write`] calls will block
- /// indefinitely. An [`Err`] is returned if the zero [`Duration`] is
- /// passed to this method.
- ///
- /// [`read`]: io::Read::read
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixStream;
- /// use std::time::Duration;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// socket.set_write_timeout(Some(Duration::new(1, 0)))
- /// .expect("Couldn't set write timeout");
- /// Ok(())
- /// }
- /// ```
- ///
- /// An [`Err`] is returned if the zero [`Duration`] is passed to this
- /// method:
- ///
- /// ```no_run
- /// use std::io;
- /// use std::net::UdpSocket;
- /// use std::time::Duration;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UdpSocket::bind("127.0.0.1:34254")?;
- /// let result = socket.set_write_timeout(Some(Duration::new(0, 0)));
- /// let err = result.unwrap_err();
- /// assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn set_write_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
- self.0.set_timeout(timeout, libc::SO_SNDTIMEO)
- }
-
- /// Returns the read timeout of this socket.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixStream;
- /// use std::time::Duration;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// socket.set_read_timeout(Some(Duration::new(1, 0))).expect("Couldn't set read timeout");
- /// assert_eq!(socket.read_timeout()?, Some(Duration::new(1, 0)));
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn read_timeout(&self) -> io::Result<Option<Duration>> {
- self.0.timeout(libc::SO_RCVTIMEO)
- }
-
- /// Returns the write timeout of this socket.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixStream;
- /// use std::time::Duration;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// socket.set_write_timeout(Some(Duration::new(1, 0)))
- /// .expect("Couldn't set write timeout");
- /// assert_eq!(socket.write_timeout()?, Some(Duration::new(1, 0)));
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn write_timeout(&self) -> io::Result<Option<Duration>> {
- self.0.timeout(libc::SO_SNDTIMEO)
- }
-
- /// Moves the socket into or out of nonblocking mode.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixStream;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// socket.set_nonblocking(true).expect("Couldn't set nonblocking");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
- self.0.set_nonblocking(nonblocking)
- }
-
- /// Moves the socket to pass unix credentials as control message in [`SocketAncillary`].
- ///
- /// Set the socket option `SO_PASSCRED`.
- ///
- /// # Examples
- ///
- #[cfg_attr(any(target_os = "android", target_os = "linux"), doc = "```no_run")]
- #[cfg_attr(not(any(target_os = "android", target_os = "linux")), doc = "```ignore")]
- /// #![feature(unix_socket_ancillary_data)]
- /// use std::os::unix::net::UnixStream;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// socket.set_passcred(true).expect("Couldn't set passcred");
- /// Ok(())
- /// }
- /// ```
- #[cfg(any(doc, target_os = "android", target_os = "linux",))]
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn set_passcred(&self, passcred: bool) -> io::Result<()> {
- self.0.set_passcred(passcred)
- }
-
- /// Get the current value of the socket for passing unix credentials in [`SocketAncillary`].
- /// This value can be change by [`set_passcred`].
- ///
- /// Get the socket option `SO_PASSCRED`.
- ///
- /// [`set_passcred`]: UnixStream::set_passcred
- #[cfg(any(doc, target_os = "android", target_os = "linux",))]
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn passcred(&self) -> io::Result<bool> {
- self.0.passcred()
- }
-
- /// Returns the value of the `SO_ERROR` option.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixStream;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// if let Ok(Some(err)) = socket.take_error() {
- /// println!("Got error: {:?}", err);
- /// }
- /// Ok(())
- /// }
- /// ```
- ///
- /// # Platform specific
- /// On Redox this always returns `None`.
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn take_error(&self) -> io::Result<Option<io::Error>> {
- self.0.take_error()
- }
-
- /// Shuts down the read, write, or both halves of this connection.
- ///
- /// This function will cause all pending and future I/O calls on the
- /// specified portions to immediately return with an appropriate value
- /// (see the documentation of [`Shutdown`]).
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::os::unix::net::UnixStream;
- /// use std::net::Shutdown;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// socket.shutdown(Shutdown::Both).expect("shutdown function failed");
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "unix_socket", since = "1.10.0")]
- pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
- self.0.shutdown(how)
- }
-
- /// Receives data on the socket from the remote address to which it is
- /// connected, without removing that data from the queue. On success,
- /// returns the number of bytes peeked.
- ///
- /// Successive calls return the same data. This is accomplished by passing
- /// `MSG_PEEK` as a flag to the underlying `recv` system call.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// #![feature(unix_socket_peek)]
- ///
- /// use std::os::unix::net::UnixStream;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// let mut buf = [0; 10];
- /// let len = socket.peek(&mut buf).expect("peek failed");
- /// Ok(())
- /// }
- /// ```
- #[unstable(feature = "unix_socket_peek", issue = "76923")]
- pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
- self.0.peek(buf)
- }
-
- /// Receives data and ancillary data from socket.
- ///
- /// On success, returns the number of bytes read.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// #![feature(unix_socket_ancillary_data)]
- /// use std::os::unix::net::{UnixStream, SocketAncillary, AncillaryData};
- /// use std::io::IoSliceMut;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// let mut buf1 = [1; 8];
- /// let mut buf2 = [2; 16];
- /// let mut buf3 = [3; 8];
- /// let mut bufs = &mut [
- /// IoSliceMut::new(&mut buf1),
- /// IoSliceMut::new(&mut buf2),
- /// IoSliceMut::new(&mut buf3),
- /// ][..];
- /// let mut fds = [0; 8];
- /// let mut ancillary_buffer = [0; 128];
- /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
- /// let size = socket.recv_vectored_with_ancillary(bufs, &mut ancillary)?;
- /// println!("received {}", size);
- /// for ancillary_result in ancillary.messages() {
- /// if let AncillaryData::ScmRights(scm_rights) = ancillary_result.unwrap() {
- /// for fd in scm_rights {
- /// println!("receive file descriptor: {}", fd);
- /// }
- /// }
- /// }
- /// Ok(())
- /// }
- /// ```
- #[cfg(any(
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
- ))]
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn recv_vectored_with_ancillary(
- &self,
- bufs: &mut [IoSliceMut<'_>],
- ancillary: &mut SocketAncillary<'_>,
- ) -> io::Result<usize> {
- let (count, _, _) = recv_vectored_with_ancillary_from(&self.0, bufs, ancillary)?;
-
- Ok(count)
- }
-
- /// Sends data and ancillary data on the socket.
- ///
- /// On success, returns the number of bytes written.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// #![feature(unix_socket_ancillary_data)]
- /// use std::os::unix::net::{UnixStream, SocketAncillary};
- /// use std::io::IoSlice;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let socket = UnixStream::connect("/tmp/sock")?;
- /// let buf1 = [1; 8];
- /// let buf2 = [2; 16];
- /// let buf3 = [3; 8];
- /// let bufs = &[
- /// IoSlice::new(&buf1),
- /// IoSlice::new(&buf2),
- /// IoSlice::new(&buf3),
- /// ][..];
- /// let fds = [0, 1, 2];
- /// let mut ancillary_buffer = [0; 128];
- /// let mut ancillary = SocketAncillary::new(&mut ancillary_buffer[..]);
- /// ancillary.add_fds(&fds[..]);
- /// socket.send_vectored_with_ancillary(bufs, &mut ancillary)
- /// .expect("send_vectored_with_ancillary function failed");
- /// Ok(())
- /// }
- /// ```
- #[cfg(any(
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
- ))]
- #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
- pub fn send_vectored_with_ancillary(
- &self,
- bufs: &[IoSlice<'_>],
- ancillary: &mut SocketAncillary<'_>,
- ) -> io::Result<usize> {
- send_vectored_with_ancillary_to(&self.0, None, bufs, ancillary)
- }
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl io::Read for UnixStream {
- fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
- io::Read::read(&mut &*self, buf)
- }
-
- fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
- io::Read::read_vectored(&mut &*self, bufs)
- }
-
- #[inline]
- fn is_read_vectored(&self) -> bool {
- io::Read::is_read_vectored(&&*self)
- }
-
- #[inline]
- unsafe fn initializer(&self) -> Initializer {
- Initializer::nop()
- }
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl<'a> io::Read for &'a UnixStream {
- fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
- self.0.read(buf)
- }
-
- fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
- self.0.read_vectored(bufs)
- }
-
- #[inline]
- fn is_read_vectored(&self) -> bool {
- self.0.is_read_vectored()
- }
-
- #[inline]
- unsafe fn initializer(&self) -> Initializer {
- Initializer::nop()
- }
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl io::Write for UnixStream {
- fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
- io::Write::write(&mut &*self, buf)
- }
-
- fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
- io::Write::write_vectored(&mut &*self, bufs)
- }
-
- #[inline]
- fn is_write_vectored(&self) -> bool {
- io::Write::is_write_vectored(&&*self)
- }
-
- fn flush(&mut self) -> io::Result<()> {
- io::Write::flush(&mut &*self)
- }
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl<'a> io::Write for &'a UnixStream {
- fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
- self.0.write(buf)
- }
-
- fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
- self.0.write_vectored(bufs)
- }
-
- #[inline]
- fn is_write_vectored(&self) -> bool {
- self.0.is_write_vectored()
- }
-
- fn flush(&mut self) -> io::Result<()> {
- Ok(())
- }
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl AsRawFd for UnixStream {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- *self.0.as_inner()
- }
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl FromRawFd for UnixStream {
- #[inline]
- unsafe fn from_raw_fd(fd: RawFd) -> UnixStream {
- UnixStream(Socket::from_inner(fd))
- }
-}
-
-#[stable(feature = "unix_socket", since = "1.10.0")]
-impl IntoRawFd for UnixStream {
- #[inline]
- fn into_raw_fd(self) -> RawFd {
- self.0.into_inner()
- }
-}
+++ /dev/null
-use super::*;
-use crate::io::prelude::*;
-use crate::io::{self, ErrorKind, IoSlice, IoSliceMut};
-#[cfg(any(
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
-))]
-use crate::iter::FromIterator;
-#[cfg(any(
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
-))]
-use crate::os::unix::io::AsRawFd;
-use crate::sys_common::io::test::tmpdir;
-use crate::thread;
-use crate::time::Duration;
-
-macro_rules! or_panic {
- ($e:expr) => {
- match $e {
- Ok(e) => e,
- Err(e) => panic!("{}", e),
- }
- };
-}
-
-#[test]
-fn basic() {
- let dir = tmpdir();
- let socket_path = dir.path().join("sock");
- let msg1 = b"hello";
- let msg2 = b"world!";
-
- let listener = or_panic!(UnixListener::bind(&socket_path));
- let thread = thread::spawn(move || {
- let mut stream = or_panic!(listener.accept()).0;
- let mut buf = [0; 5];
- or_panic!(stream.read(&mut buf));
- assert_eq!(&msg1[..], &buf[..]);
- or_panic!(stream.write_all(msg2));
- });
-
- let mut stream = or_panic!(UnixStream::connect(&socket_path));
- assert_eq!(Some(&*socket_path), stream.peer_addr().unwrap().as_pathname());
- or_panic!(stream.write_all(msg1));
- let mut buf = vec![];
- or_panic!(stream.read_to_end(&mut buf));
- assert_eq!(&msg2[..], &buf[..]);
- drop(stream);
-
- thread.join().unwrap();
-}
-
-#[test]
-fn vectored() {
- let (mut s1, mut s2) = or_panic!(UnixStream::pair());
-
- let len = or_panic!(s1.write_vectored(&[
- IoSlice::new(b"hello"),
- IoSlice::new(b" "),
- IoSlice::new(b"world!")
- ],));
- assert_eq!(len, 12);
-
- let mut buf1 = [0; 6];
- let mut buf2 = [0; 7];
- let len =
- or_panic!(s2.read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],));
- assert_eq!(len, 12);
- assert_eq!(&buf1, b"hello ");
- assert_eq!(&buf2, b"world!\0");
-}
-
-#[test]
-fn pair() {
- let msg1 = b"hello";
- let msg2 = b"world!";
-
- let (mut s1, mut s2) = or_panic!(UnixStream::pair());
- let thread = thread::spawn(move || {
- // s1 must be moved in or the test will hang!
- let mut buf = [0; 5];
- or_panic!(s1.read(&mut buf));
- assert_eq!(&msg1[..], &buf[..]);
- or_panic!(s1.write_all(msg2));
- });
-
- or_panic!(s2.write_all(msg1));
- let mut buf = vec![];
- or_panic!(s2.read_to_end(&mut buf));
- assert_eq!(&msg2[..], &buf[..]);
- drop(s2);
-
- thread.join().unwrap();
-}
-
-#[test]
-fn try_clone() {
- let dir = tmpdir();
- let socket_path = dir.path().join("sock");
- let msg1 = b"hello";
- let msg2 = b"world";
-
- let listener = or_panic!(UnixListener::bind(&socket_path));
- let thread = thread::spawn(move || {
- let mut stream = or_panic!(listener.accept()).0;
- or_panic!(stream.write_all(msg1));
- or_panic!(stream.write_all(msg2));
- });
-
- let mut stream = or_panic!(UnixStream::connect(&socket_path));
- let mut stream2 = or_panic!(stream.try_clone());
-
- let mut buf = [0; 5];
- or_panic!(stream.read(&mut buf));
- assert_eq!(&msg1[..], &buf[..]);
- or_panic!(stream2.read(&mut buf));
- assert_eq!(&msg2[..], &buf[..]);
-
- thread.join().unwrap();
-}
-
-#[test]
-fn iter() {
- let dir = tmpdir();
- let socket_path = dir.path().join("sock");
-
- let listener = or_panic!(UnixListener::bind(&socket_path));
- let thread = thread::spawn(move || {
- for stream in listener.incoming().take(2) {
- let mut stream = or_panic!(stream);
- let mut buf = [0];
- or_panic!(stream.read(&mut buf));
- }
- });
-
- for _ in 0..2 {
- let mut stream = or_panic!(UnixStream::connect(&socket_path));
- or_panic!(stream.write_all(&[0]));
- }
-
- thread.join().unwrap();
-}
-
-#[test]
-fn long_path() {
- let dir = tmpdir();
- let socket_path = dir.path().join(
- "asdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasdfa\
- sasdfasdfasdasdfasdfasdfadfasdfasdfasdfasdfasdf",
- );
- match UnixStream::connect(&socket_path) {
- Err(ref e) if e.kind() == io::ErrorKind::InvalidInput => {}
- Err(e) => panic!("unexpected error {}", e),
- Ok(_) => panic!("unexpected success"),
- }
-
- match UnixListener::bind(&socket_path) {
- Err(ref e) if e.kind() == io::ErrorKind::InvalidInput => {}
- Err(e) => panic!("unexpected error {}", e),
- Ok(_) => panic!("unexpected success"),
- }
-
- match UnixDatagram::bind(&socket_path) {
- Err(ref e) if e.kind() == io::ErrorKind::InvalidInput => {}
- Err(e) => panic!("unexpected error {}", e),
- Ok(_) => panic!("unexpected success"),
- }
-}
-
-#[test]
-fn timeouts() {
- let dir = tmpdir();
- let socket_path = dir.path().join("sock");
-
- let _listener = or_panic!(UnixListener::bind(&socket_path));
-
- let stream = or_panic!(UnixStream::connect(&socket_path));
- let dur = Duration::new(15410, 0);
-
- assert_eq!(None, or_panic!(stream.read_timeout()));
-
- or_panic!(stream.set_read_timeout(Some(dur)));
- assert_eq!(Some(dur), or_panic!(stream.read_timeout()));
-
- assert_eq!(None, or_panic!(stream.write_timeout()));
-
- or_panic!(stream.set_write_timeout(Some(dur)));
- assert_eq!(Some(dur), or_panic!(stream.write_timeout()));
-
- or_panic!(stream.set_read_timeout(None));
- assert_eq!(None, or_panic!(stream.read_timeout()));
-
- or_panic!(stream.set_write_timeout(None));
- assert_eq!(None, or_panic!(stream.write_timeout()));
-}
-
-#[test]
-fn test_read_timeout() {
- let dir = tmpdir();
- let socket_path = dir.path().join("sock");
-
- let _listener = or_panic!(UnixListener::bind(&socket_path));
-
- let mut stream = or_panic!(UnixStream::connect(&socket_path));
- or_panic!(stream.set_read_timeout(Some(Duration::from_millis(1000))));
-
- let mut buf = [0; 10];
- let kind = stream.read_exact(&mut buf).err().expect("expected error").kind();
- assert!(
- kind == ErrorKind::WouldBlock || kind == ErrorKind::TimedOut,
- "unexpected_error: {:?}",
- kind
- );
-}
-
-#[test]
-fn test_read_with_timeout() {
- let dir = tmpdir();
- let socket_path = dir.path().join("sock");
-
- let listener = or_panic!(UnixListener::bind(&socket_path));
-
- let mut stream = or_panic!(UnixStream::connect(&socket_path));
- or_panic!(stream.set_read_timeout(Some(Duration::from_millis(1000))));
-
- let mut other_end = or_panic!(listener.accept()).0;
- or_panic!(other_end.write_all(b"hello world"));
-
- let mut buf = [0; 11];
- or_panic!(stream.read(&mut buf));
- assert_eq!(b"hello world", &buf[..]);
-
- let kind = stream.read_exact(&mut buf).err().expect("expected error").kind();
- assert!(
- kind == ErrorKind::WouldBlock || kind == ErrorKind::TimedOut,
- "unexpected_error: {:?}",
- kind
- );
-}
-
-// Ensure the `set_read_timeout` and `set_write_timeout` calls return errors
-// when passed zero Durations
-#[test]
-fn test_unix_stream_timeout_zero_duration() {
- let dir = tmpdir();
- let socket_path = dir.path().join("sock");
-
- let listener = or_panic!(UnixListener::bind(&socket_path));
- let stream = or_panic!(UnixStream::connect(&socket_path));
-
- let result = stream.set_write_timeout(Some(Duration::new(0, 0)));
- let err = result.unwrap_err();
- assert_eq!(err.kind(), ErrorKind::InvalidInput);
-
- let result = stream.set_read_timeout(Some(Duration::new(0, 0)));
- let err = result.unwrap_err();
- assert_eq!(err.kind(), ErrorKind::InvalidInput);
-
- drop(listener);
-}
-
-#[test]
-fn test_unix_datagram() {
- let dir = tmpdir();
- let path1 = dir.path().join("sock1");
- let path2 = dir.path().join("sock2");
-
- let sock1 = or_panic!(UnixDatagram::bind(&path1));
- let sock2 = or_panic!(UnixDatagram::bind(&path2));
-
- let msg = b"hello world";
- or_panic!(sock1.send_to(msg, &path2));
- let mut buf = [0; 11];
- or_panic!(sock2.recv_from(&mut buf));
- assert_eq!(msg, &buf[..]);
-}
-
-#[test]
-fn test_unnamed_unix_datagram() {
- let dir = tmpdir();
- let path1 = dir.path().join("sock1");
-
- let sock1 = or_panic!(UnixDatagram::bind(&path1));
- let sock2 = or_panic!(UnixDatagram::unbound());
-
- let msg = b"hello world";
- or_panic!(sock2.send_to(msg, &path1));
- let mut buf = [0; 11];
- let (usize, addr) = or_panic!(sock1.recv_from(&mut buf));
- assert_eq!(usize, 11);
- assert!(addr.is_unnamed());
- assert_eq!(msg, &buf[..]);
-}
-
-#[test]
-fn test_connect_unix_datagram() {
- let dir = tmpdir();
- let path1 = dir.path().join("sock1");
- let path2 = dir.path().join("sock2");
-
- let bsock1 = or_panic!(UnixDatagram::bind(&path1));
- let bsock2 = or_panic!(UnixDatagram::bind(&path2));
- let sock = or_panic!(UnixDatagram::unbound());
- or_panic!(sock.connect(&path1));
-
- // Check send()
- let msg = b"hello there";
- or_panic!(sock.send(msg));
- let mut buf = [0; 11];
- let (usize, addr) = or_panic!(bsock1.recv_from(&mut buf));
- assert_eq!(usize, 11);
- assert!(addr.is_unnamed());
- assert_eq!(msg, &buf[..]);
-
- // Changing default socket works too
- or_panic!(sock.connect(&path2));
- or_panic!(sock.send(msg));
- or_panic!(bsock2.recv_from(&mut buf));
-}
-
-#[test]
-fn test_unix_datagram_recv() {
- let dir = tmpdir();
- let path1 = dir.path().join("sock1");
-
- let sock1 = or_panic!(UnixDatagram::bind(&path1));
- let sock2 = or_panic!(UnixDatagram::unbound());
- or_panic!(sock2.connect(&path1));
-
- let msg = b"hello world";
- or_panic!(sock2.send(msg));
- let mut buf = [0; 11];
- let size = or_panic!(sock1.recv(&mut buf));
- assert_eq!(size, 11);
- assert_eq!(msg, &buf[..]);
-}
-
-#[test]
-fn datagram_pair() {
- let msg1 = b"hello";
- let msg2 = b"world!";
-
- let (s1, s2) = or_panic!(UnixDatagram::pair());
- let thread = thread::spawn(move || {
- // s1 must be moved in or the test will hang!
- let mut buf = [0; 5];
- or_panic!(s1.recv(&mut buf));
- assert_eq!(&msg1[..], &buf[..]);
- or_panic!(s1.send(msg2));
- });
-
- or_panic!(s2.send(msg1));
- let mut buf = [0; 6];
- or_panic!(s2.recv(&mut buf));
- assert_eq!(&msg2[..], &buf[..]);
- drop(s2);
-
- thread.join().unwrap();
-}
-
-// Ensure the `set_read_timeout` and `set_write_timeout` calls return errors
-// when passed zero Durations
-#[test]
-fn test_unix_datagram_timeout_zero_duration() {
- let dir = tmpdir();
- let path = dir.path().join("sock");
-
- let datagram = or_panic!(UnixDatagram::bind(&path));
-
- let result = datagram.set_write_timeout(Some(Duration::new(0, 0)));
- let err = result.unwrap_err();
- assert_eq!(err.kind(), ErrorKind::InvalidInput);
-
- let result = datagram.set_read_timeout(Some(Duration::new(0, 0)));
- let err = result.unwrap_err();
- assert_eq!(err.kind(), ErrorKind::InvalidInput);
-}
-
-#[test]
-fn abstract_namespace_not_allowed() {
- assert!(UnixStream::connect("\0asdf").is_err());
-}
-
-#[test]
-fn test_unix_stream_peek() {
- let (txdone, rxdone) = crate::sync::mpsc::channel();
-
- let dir = tmpdir();
- let path = dir.path().join("sock");
-
- let listener = or_panic!(UnixListener::bind(&path));
- let thread = thread::spawn(move || {
- let mut stream = or_panic!(listener.accept()).0;
- or_panic!(stream.write_all(&[1, 3, 3, 7]));
- or_panic!(rxdone.recv());
- });
-
- let mut stream = or_panic!(UnixStream::connect(&path));
- let mut buf = [0; 10];
- for _ in 0..2 {
- assert_eq!(or_panic!(stream.peek(&mut buf)), 4);
- }
- assert_eq!(or_panic!(stream.read(&mut buf)), 4);
-
- or_panic!(stream.set_nonblocking(true));
- match stream.peek(&mut buf) {
- Ok(_) => panic!("expected error"),
- Err(ref e) if e.kind() == ErrorKind::WouldBlock => {}
- Err(e) => panic!("unexpected error: {}", e),
- }
-
- or_panic!(txdone.send(()));
- thread.join().unwrap();
-}
-
-#[test]
-fn test_unix_datagram_peek() {
- let dir = tmpdir();
- let path1 = dir.path().join("sock");
-
- let sock1 = or_panic!(UnixDatagram::bind(&path1));
- let sock2 = or_panic!(UnixDatagram::unbound());
- or_panic!(sock2.connect(&path1));
-
- let msg = b"hello world";
- or_panic!(sock2.send(msg));
- for _ in 0..2 {
- let mut buf = [0; 11];
- let size = or_panic!(sock1.peek(&mut buf));
- assert_eq!(size, 11);
- assert_eq!(msg, &buf[..]);
- }
-
- let mut buf = [0; 11];
- let size = or_panic!(sock1.recv(&mut buf));
- assert_eq!(size, 11);
- assert_eq!(msg, &buf[..]);
-}
-
-#[test]
-fn test_unix_datagram_peek_from() {
- let dir = tmpdir();
- let path1 = dir.path().join("sock");
-
- let sock1 = or_panic!(UnixDatagram::bind(&path1));
- let sock2 = or_panic!(UnixDatagram::unbound());
- or_panic!(sock2.connect(&path1));
-
- let msg = b"hello world";
- or_panic!(sock2.send(msg));
- for _ in 0..2 {
- let mut buf = [0; 11];
- let (size, _) = or_panic!(sock1.peek_from(&mut buf));
- assert_eq!(size, 11);
- assert_eq!(msg, &buf[..]);
- }
-
- let mut buf = [0; 11];
- let size = or_panic!(sock1.recv(&mut buf));
- assert_eq!(size, 11);
- assert_eq!(msg, &buf[..]);
-}
-
-#[cfg(any(
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
-))]
-#[test]
-fn test_send_vectored_fds_unix_stream() {
- let (s1, s2) = or_panic!(UnixStream::pair());
-
- let buf1 = [1; 8];
- let bufs_send = &[IoSlice::new(&buf1[..])][..];
-
- let mut ancillary1_buffer = [0; 128];
- let mut ancillary1 = SocketAncillary::new(&mut ancillary1_buffer[..]);
- assert!(ancillary1.add_fds(&[s1.as_raw_fd()][..]));
-
- let usize = or_panic!(s1.send_vectored_with_ancillary(&bufs_send, &mut ancillary1));
- assert_eq!(usize, 8);
-
- let mut buf2 = [0; 8];
- let mut bufs_recv = &mut [IoSliceMut::new(&mut buf2[..])][..];
-
- let mut ancillary2_buffer = [0; 128];
- let mut ancillary2 = SocketAncillary::new(&mut ancillary2_buffer[..]);
-
- let usize = or_panic!(s2.recv_vectored_with_ancillary(&mut bufs_recv, &mut ancillary2));
- assert_eq!(usize, 8);
- assert_eq!(buf1, buf2);
-
- let mut ancillary_data_vec = Vec::from_iter(ancillary2.messages());
- assert_eq!(ancillary_data_vec.len(), 1);
- if let AncillaryData::ScmRights(scm_rights) = ancillary_data_vec.pop().unwrap().unwrap() {
- let fd_vec = Vec::from_iter(scm_rights);
- assert_eq!(fd_vec.len(), 1);
- unsafe {
- libc::close(fd_vec[0]);
- }
- } else {
- unreachable!("must be ScmRights");
- }
-}
-
-#[cfg(any(target_os = "android", target_os = "emscripten", target_os = "linux",))]
-#[test]
-fn test_send_vectored_with_ancillary_to_unix_datagram() {
- fn getpid() -> libc::pid_t {
- unsafe { libc::getpid() }
- }
-
- fn getuid() -> libc::uid_t {
- unsafe { libc::getuid() }
- }
-
- fn getgid() -> libc::gid_t {
- unsafe { libc::getgid() }
- }
-
- let dir = tmpdir();
- let path1 = dir.path().join("sock1");
- let path2 = dir.path().join("sock2");
-
- let bsock1 = or_panic!(UnixDatagram::bind(&path1));
- let bsock2 = or_panic!(UnixDatagram::bind(&path2));
-
- or_panic!(bsock2.set_passcred(true));
-
- let buf1 = [1; 8];
- let bufs_send = &[IoSlice::new(&buf1[..])][..];
-
- let mut ancillary1_buffer = [0; 128];
- let mut ancillary1 = SocketAncillary::new(&mut ancillary1_buffer[..]);
- let mut cred1 = SocketCred::new();
- cred1.set_pid(getpid());
- cred1.set_uid(getuid());
- cred1.set_gid(getgid());
- assert!(ancillary1.add_creds(&[cred1.clone()][..]));
-
- let usize =
- or_panic!(bsock1.send_vectored_with_ancillary_to(&bufs_send, &mut ancillary1, &path2));
- assert_eq!(usize, 8);
-
- let mut buf2 = [0; 8];
- let mut bufs_recv = &mut [IoSliceMut::new(&mut buf2[..])][..];
-
- let mut ancillary2_buffer = [0; 128];
- let mut ancillary2 = SocketAncillary::new(&mut ancillary2_buffer[..]);
-
- let (usize, truncated, _addr) =
- or_panic!(bsock2.recv_vectored_with_ancillary_from(&mut bufs_recv, &mut ancillary2));
- assert_eq!(ancillary2.truncated(), false);
- assert_eq!(usize, 8);
- assert_eq!(truncated, false);
- assert_eq!(buf1, buf2);
-
- let mut ancillary_data_vec = Vec::from_iter(ancillary2.messages());
- assert_eq!(ancillary_data_vec.len(), 1);
- if let AncillaryData::ScmCredentials(scm_credentials) =
- ancillary_data_vec.pop().unwrap().unwrap()
- {
- let cred_vec = Vec::from_iter(scm_credentials);
- assert_eq!(cred_vec.len(), 1);
- assert_eq!(cred1.get_pid(), cred_vec[0].get_pid());
- assert_eq!(cred1.get_uid(), cred_vec[0].get_uid());
- assert_eq!(cred1.get_gid(), cred_vec[0].get_gid());
- } else {
- unreachable!("must be ScmCredentials");
- }
-}
-
-#[cfg(any(
- target_os = "android",
- target_os = "dragonfly",
- target_os = "emscripten",
- target_os = "freebsd",
- target_os = "linux",
- target_os = "netbsd",
- target_os = "openbsd",
-))]
-#[test]
-fn test_send_vectored_with_ancillary_unix_datagram() {
- let dir = tmpdir();
- let path1 = dir.path().join("sock1");
- let path2 = dir.path().join("sock2");
-
- let bsock1 = or_panic!(UnixDatagram::bind(&path1));
- let bsock2 = or_panic!(UnixDatagram::bind(&path2));
-
- let buf1 = [1; 8];
- let bufs_send = &[IoSlice::new(&buf1[..])][..];
-
- let mut ancillary1_buffer = [0; 128];
- let mut ancillary1 = SocketAncillary::new(&mut ancillary1_buffer[..]);
- assert!(ancillary1.add_fds(&[bsock1.as_raw_fd()][..]));
-
- or_panic!(bsock1.connect(&path2));
- let usize = or_panic!(bsock1.send_vectored_with_ancillary(&bufs_send, &mut ancillary1));
- assert_eq!(usize, 8);
-
- let mut buf2 = [0; 8];
- let mut bufs_recv = &mut [IoSliceMut::new(&mut buf2[..])][..];
-
- let mut ancillary2_buffer = [0; 128];
- let mut ancillary2 = SocketAncillary::new(&mut ancillary2_buffer[..]);
-
- let (usize, truncated) =
- or_panic!(bsock2.recv_vectored_with_ancillary(&mut bufs_recv, &mut ancillary2));
- assert_eq!(usize, 8);
- assert_eq!(truncated, false);
- assert_eq!(buf1, buf2);
-
- let mut ancillary_data_vec = Vec::from_iter(ancillary2.messages());
- assert_eq!(ancillary_data_vec.len(), 1);
- if let AncillaryData::ScmRights(scm_rights) = ancillary_data_vec.pop().unwrap().unwrap() {
- let fd_vec = Vec::from_iter(scm_rights);
- assert_eq!(fd_vec.len(), 1);
- unsafe {
- libc::close(fd_vec[0]);
- }
- } else {
- unreachable!("must be ScmRights");
- }
-}
+++ /dev/null
-//! Unix-specific extensions to primitives in the `std::process` module.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-use crate::ffi::OsStr;
-use crate::io;
-use crate::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
-use crate::process;
-use crate::sealed::Sealed;
-use crate::sys;
-use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
-
-/// Unix-specific extensions to the [`process::Command`] builder.
-///
-/// This trait is sealed: it cannot be implemented outside the standard library.
-/// This is so that future additional methods are not breaking changes.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub trait CommandExt: Sealed {
- /// Sets the child process's user ID. This translates to a
- /// `setuid` call in the child process. Failure in the `setuid`
- /// call will cause the spawn to fail.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn uid(
- &mut self,
- #[cfg(not(target_os = "vxworks"))] id: u32,
- #[cfg(target_os = "vxworks")] id: u16,
- ) -> &mut process::Command;
-
- /// Similar to `uid`, but sets the group ID of the child process. This has
- /// the same semantics as the `uid` field.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn gid(
- &mut self,
- #[cfg(not(target_os = "vxworks"))] id: u32,
- #[cfg(target_os = "vxworks")] id: u16,
- ) -> &mut process::Command;
-
- /// Sets the supplementary group IDs for the calling process. Translates to
- /// a `setgroups` call in the child process.
- #[unstable(feature = "setgroups", issue = "38527", reason = "")]
- fn groups(
- &mut self,
- #[cfg(not(target_os = "vxworks"))] groups: &[u32],
- #[cfg(target_os = "vxworks")] groups: &[u16],
- ) -> &mut process::Command;
-
- /// Schedules a closure to be run just before the `exec` function is
- /// invoked.
- ///
- /// The closure is allowed to return an I/O error whose OS error code will
- /// be communicated back to the parent and returned as an error from when
- /// the spawn was requested.
- ///
- /// Multiple closures can be registered and they will be called in order of
- /// their registration. If a closure returns `Err` then no further closures
- /// will be called and the spawn operation will immediately return with a
- /// failure.
- ///
- /// # Notes and Safety
- ///
- /// This closure will be run in the context of the child process after a
- /// `fork`. This primarily means that any modifications made to memory on
- /// behalf of this closure will **not** be visible to the parent process.
- /// This is often a very constrained environment where normal operations
- /// like `malloc`, accessing environment variables through [`std::env`]
- /// or acquiring a mutex are not guaranteed to work (due to
- /// other threads perhaps still running when the `fork` was run).
- ///
- /// For further details refer to the [POSIX fork() specification]
- /// and the equivalent documentation for any targeted
- /// platform, especially the requirements around *async-signal-safety*.
- ///
- /// This also means that all resources such as file descriptors and
- /// memory-mapped regions got duplicated. It is your responsibility to make
- /// sure that the closure does not violate library invariants by making
- /// invalid use of these duplicates.
- ///
- /// When this closure is run, aspects such as the stdio file descriptors and
- /// working directory have successfully been changed, so output to these
- /// locations may not appear where intended.
- ///
- /// [POSIX fork() specification]:
- /// https://pubs.opengroup.org/onlinepubs/9699919799/functions/fork.html
- /// [`std::env`]: mod@crate::env
- #[stable(feature = "process_pre_exec", since = "1.34.0")]
- unsafe fn pre_exec<F>(&mut self, f: F) -> &mut process::Command
- where
- F: FnMut() -> io::Result<()> + Send + Sync + 'static;
-
- /// Schedules a closure to be run just before the `exec` function is
- /// invoked.
- ///
- /// This method is stable and usable, but it should be unsafe. To fix
- /// that, it got deprecated in favor of the unsafe [`pre_exec`].
- ///
- /// [`pre_exec`]: CommandExt::pre_exec
- #[stable(feature = "process_exec", since = "1.15.0")]
- #[rustc_deprecated(since = "1.37.0", reason = "should be unsafe, use `pre_exec` instead")]
- fn before_exec<F>(&mut self, f: F) -> &mut process::Command
- where
- F: FnMut() -> io::Result<()> + Send + Sync + 'static,
- {
- unsafe { self.pre_exec(f) }
- }
-
- /// Performs all the required setup by this `Command`, followed by calling
- /// the `execvp` syscall.
- ///
- /// On success this function will not return, and otherwise it will return
- /// an error indicating why the exec (or another part of the setup of the
- /// `Command`) failed.
- ///
- /// `exec` not returning has the same implications as calling
- /// [`process::exit`] – no destructors on the current stack or any other
- /// thread’s stack will be run. Therefore, it is recommended to only call
- /// `exec` at a point where it is fine to not run any destructors. Note,
- /// that the `execvp` syscall independently guarantees that all memory is
- /// freed and all file descriptors with the `CLOEXEC` option (set by default
- /// on all file descriptors opened by the standard library) are closed.
- ///
- /// This function, unlike `spawn`, will **not** `fork` the process to create
- /// a new child. Like spawn, however, the default behavior for the stdio
- /// descriptors will be to inherited from the current process.
- ///
- /// # Notes
- ///
- /// The process may be in a "broken state" if this function returns in
- /// error. For example the working directory, environment variables, signal
- /// handling settings, various user/group information, or aspects of stdio
- /// file descriptors may have changed. If a "transactional spawn" is
- /// required to gracefully handle errors it is recommended to use the
- /// cross-platform `spawn` instead.
- #[stable(feature = "process_exec2", since = "1.9.0")]
- fn exec(&mut self) -> io::Error;
-
- /// Set executable argument
- ///
- /// Set the first process argument, `argv[0]`, to something other than the
- /// default executable path.
- #[stable(feature = "process_set_argv0", since = "1.45.0")]
- fn arg0<S>(&mut self, arg: S) -> &mut process::Command
- where
- S: AsRef<OsStr>;
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl CommandExt for process::Command {
- fn uid(
- &mut self,
- #[cfg(not(target_os = "vxworks"))] id: u32,
- #[cfg(target_os = "vxworks")] id: u16,
- ) -> &mut process::Command {
- self.as_inner_mut().uid(id);
- self
- }
-
- fn gid(
- &mut self,
- #[cfg(not(target_os = "vxworks"))] id: u32,
- #[cfg(target_os = "vxworks")] id: u16,
- ) -> &mut process::Command {
- self.as_inner_mut().gid(id);
- self
- }
-
- fn groups(
- &mut self,
- #[cfg(not(target_os = "vxworks"))] groups: &[u32],
- #[cfg(target_os = "vxworks")] groups: &[u16],
- ) -> &mut process::Command {
- self.as_inner_mut().groups(groups);
- self
- }
-
- unsafe fn pre_exec<F>(&mut self, f: F) -> &mut process::Command
- where
- F: FnMut() -> io::Result<()> + Send + Sync + 'static,
- {
- self.as_inner_mut().pre_exec(Box::new(f));
- self
- }
-
- fn exec(&mut self) -> io::Error {
- // NOTE: This may *not* be safe to call after `libc::fork`, because it
- // may allocate. That may be worth fixing at some point in the future.
- self.as_inner_mut().exec(sys::process::Stdio::Inherit)
- }
-
- fn arg0<S>(&mut self, arg: S) -> &mut process::Command
- where
- S: AsRef<OsStr>,
- {
- self.as_inner_mut().set_arg_0(arg.as_ref());
- self
- }
-}
-
-/// Unix-specific extensions to [`process::ExitStatus`].
-///
-/// On Unix, `ExitStatus` **does not necessarily represent an exit status**, as passed to the
-/// `exit` system call or returned by [`ExitStatus::code()`](crate::process::ExitStatus::code).
-/// It represents **any wait status**, as returned by one of the `wait` family of system calls.
-///
-/// This is because a Unix wait status (a Rust `ExitStatus`) can represent a Unix exit status, but
-/// can also represent other kinds of process event.
-///
-/// This trait is sealed: it cannot be implemented outside the standard library.
-/// This is so that future additional methods are not breaking changes.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub trait ExitStatusExt: Sealed {
- /// Creates a new `ExitStatus` from the raw underlying integer status value from `wait`
- ///
- /// The value should be a **wait status, not an exit status**.
- #[stable(feature = "exit_status_from", since = "1.12.0")]
- fn from_raw(raw: i32) -> Self;
-
- /// If the process was terminated by a signal, returns that signal.
- ///
- /// In other words, if `WIFSIGNALED`, this returns `WTERMSIG`.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn signal(&self) -> Option<i32>;
-
- /// If the process was terminated by a signal, says whether it dumped core.
- #[unstable(feature = "unix_process_wait_more", issue = "80695")]
- fn core_dumped(&self) -> bool;
-
- /// If the process was stopped by a signal, returns that signal.
- ///
- /// In other words, if `WIFSTOPPED`, this returns `WSTOPSIG`. This is only possible if the status came from
- /// a `wait` system call which was passed `WUNTRACED`, and was then converted into an `ExitStatus`.
- #[unstable(feature = "unix_process_wait_more", issue = "80695")]
- fn stopped_signal(&self) -> Option<i32>;
-
- /// Whether the process was continued from a stopped status.
- ///
- /// Ie, `WIFCONTINUED`. This is only possible if the status came from a `wait` system call
- /// which was passed `WCONTINUED`, and was then converted into an `ExitStatus`.
- #[unstable(feature = "unix_process_wait_more", issue = "80695")]
- fn continued(&self) -> bool;
-
- /// Returns the underlying raw `wait` status.
- ///
- /// The returned integer is a **wait status, not an exit status**.
- #[unstable(feature = "unix_process_wait_more", issue = "80695")]
- fn into_raw(self) -> i32;
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl ExitStatusExt for process::ExitStatus {
- fn from_raw(raw: i32) -> Self {
- process::ExitStatus::from_inner(From::from(raw))
- }
-
- fn signal(&self) -> Option<i32> {
- self.as_inner().signal()
- }
-
- fn core_dumped(&self) -> bool {
- self.as_inner().core_dumped()
- }
-
- fn stopped_signal(&self) -> Option<i32> {
- self.as_inner().stopped_signal()
- }
-
- fn continued(&self) -> bool {
- self.as_inner().continued()
- }
-
- fn into_raw(self) -> i32 {
- self.as_inner().into_raw().into()
- }
-}
-
-#[stable(feature = "process_extensions", since = "1.2.0")]
-impl FromRawFd for process::Stdio {
- #[inline]
- unsafe fn from_raw_fd(fd: RawFd) -> process::Stdio {
- let fd = sys::fd::FileDesc::new(fd);
- let io = sys::process::Stdio::Fd(fd);
- process::Stdio::from_inner(io)
- }
-}
-
-#[stable(feature = "process_extensions", since = "1.2.0")]
-impl AsRawFd for process::ChildStdin {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- self.as_inner().fd().raw()
- }
-}
-
-#[stable(feature = "process_extensions", since = "1.2.0")]
-impl AsRawFd for process::ChildStdout {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- self.as_inner().fd().raw()
- }
-}
-
-#[stable(feature = "process_extensions", since = "1.2.0")]
-impl AsRawFd for process::ChildStderr {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- self.as_inner().fd().raw()
- }
-}
-
-#[stable(feature = "into_raw_os", since = "1.4.0")]
-impl IntoRawFd for process::ChildStdin {
- #[inline]
- fn into_raw_fd(self) -> RawFd {
- self.into_inner().into_fd().into_raw()
- }
-}
-
-#[stable(feature = "into_raw_os", since = "1.4.0")]
-impl IntoRawFd for process::ChildStdout {
- #[inline]
- fn into_raw_fd(self) -> RawFd {
- self.into_inner().into_fd().into_raw()
- }
-}
-
-#[stable(feature = "into_raw_os", since = "1.4.0")]
-impl IntoRawFd for process::ChildStderr {
- #[inline]
- fn into_raw_fd(self) -> RawFd {
- self.into_inner().into_fd().into_raw()
- }
-}
-
-/// Returns the OS-assigned process identifier associated with this process's parent.
-#[stable(feature = "unix_ppid", since = "1.27.0")]
-pub fn parent_id() -> u32 {
- crate::sys::os::getppid()
-}
+++ /dev/null
-//! Unix-specific primitives available on all unix platforms.
-
-#![stable(feature = "raw_ext", since = "1.1.0")]
-#![rustc_deprecated(
- since = "1.8.0",
- reason = "these type aliases are no longer supported by \
- the standard library, the `libc` crate on \
- crates.io should be used instead for the correct \
- definitions"
-)]
-#![allow(deprecated)]
-
-#[stable(feature = "raw_ext", since = "1.1.0")]
-#[allow(non_camel_case_types)]
-pub type uid_t = u32;
-
-#[stable(feature = "raw_ext", since = "1.1.0")]
-#[allow(non_camel_case_types)]
-pub type gid_t = u32;
-
-#[stable(feature = "raw_ext", since = "1.1.0")]
-#[allow(non_camel_case_types)]
-pub type pid_t = i32;
-
-#[doc(inline)]
-#[stable(feature = "pthread_t", since = "1.8.0")]
-pub use super::platform::raw::pthread_t;
-#[doc(inline)]
-#[stable(feature = "raw_ext", since = "1.1.0")]
-pub use super::platform::raw::{blkcnt_t, time_t};
-#[doc(inline)]
-#[stable(feature = "raw_ext", since = "1.1.0")]
-pub use super::platform::raw::{blksize_t, dev_t, ino_t, mode_t, nlink_t, off_t};
+++ /dev/null
-//! Unix-specific extensions to primitives in the `std::thread` module.
-
-#![stable(feature = "thread_extensions", since = "1.9.0")]
-
-#[allow(deprecated)]
-use crate::os::unix::raw::pthread_t;
-use crate::sys_common::{AsInner, IntoInner};
-use crate::thread::JoinHandle;
-
-#[stable(feature = "thread_extensions", since = "1.9.0")]
-#[allow(deprecated)]
-pub type RawPthread = pthread_t;
-
-/// Unix-specific extensions to [`JoinHandle`].
-#[stable(feature = "thread_extensions", since = "1.9.0")]
-pub trait JoinHandleExt {
- /// Extracts the raw pthread_t without taking ownership
- #[stable(feature = "thread_extensions", since = "1.9.0")]
- fn as_pthread_t(&self) -> RawPthread;
-
- /// Consumes the thread, returning the raw pthread_t
- ///
- /// This function **transfers ownership** of the underlying pthread_t to
- /// the caller. Callers are then the unique owners of the pthread_t and
- /// must either detach or join the pthread_t once it's no longer needed.
- #[stable(feature = "thread_extensions", since = "1.9.0")]
- fn into_pthread_t(self) -> RawPthread;
-}
-
-#[stable(feature = "thread_extensions", since = "1.9.0")]
-impl<T> JoinHandleExt for JoinHandle<T> {
- fn as_pthread_t(&self) -> RawPthread {
- self.as_inner().id() as RawPthread
- }
-
- fn into_pthread_t(self) -> RawPthread {
- self.into_inner().into_id() as RawPthread
- }
-}
+++ /dev/null
-//! Unix peer credentials.
-
-// NOTE: Code in this file is heavily based on work done in PR 13 from the tokio-uds repository on
-// GitHub.
-//
-// For reference, the link is here: https://github.com/tokio-rs/tokio-uds/pull/13
-// Credit to Martin Habovštiak (GitHub username Kixunil) and contributors for this work.
-
-use libc::{gid_t, pid_t, uid_t};
-
-/// Credentials for a UNIX process for credentials passing.
-#[unstable(feature = "peer_credentials_unix_socket", issue = "42839", reason = "unstable")]
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-pub struct UCred {
- /// The UID part of the peer credential. This is the effective UID of the process at the domain
- /// socket's endpoint.
- pub uid: uid_t,
- /// The GID part of the peer credential. This is the effective GID of the process at the domain
- /// socket's endpoint.
- pub gid: gid_t,
- /// The PID part of the peer credential. This field is optional because the PID part of the
- /// peer credentials is not supported on every platform. On platforms where the mechanism to
- /// discover the PID exists, this field will be populated to the PID of the process at the
- /// domain socket's endpoint. Otherwise, it will be set to None.
- pub pid: Option<pid_t>,
-}
-
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub use self::impl_linux::peer_cred;
-
-#[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
-pub use self::impl_bsd::peer_cred;
-
-#[cfg(any(target_os = "macos", target_os = "ios",))]
-pub use self::impl_mac::peer_cred;
-
-#[cfg(any(target_os = "linux", target_os = "android"))]
-pub mod impl_linux {
- use super::UCred;
- use crate::os::unix::io::AsRawFd;
- use crate::os::unix::net::UnixStream;
- use crate::{io, mem};
- use libc::{c_void, getsockopt, socklen_t, ucred, SOL_SOCKET, SO_PEERCRED};
-
- pub fn peer_cred(socket: &UnixStream) -> io::Result<UCred> {
- let ucred_size = mem::size_of::<ucred>();
-
- // Trivial sanity checks.
- assert!(mem::size_of::<u32>() <= mem::size_of::<usize>());
- assert!(ucred_size <= u32::MAX as usize);
-
- let mut ucred_size = ucred_size as socklen_t;
- let mut ucred: ucred = ucred { pid: 1, uid: 1, gid: 1 };
-
- unsafe {
- let ret = getsockopt(
- socket.as_raw_fd(),
- SOL_SOCKET,
- SO_PEERCRED,
- &mut ucred as *mut ucred as *mut c_void,
- &mut ucred_size,
- );
-
- if ret == 0 && ucred_size as usize == mem::size_of::<ucred>() {
- Ok(UCred { uid: ucred.uid, gid: ucred.gid, pid: Some(ucred.pid) })
- } else {
- Err(io::Error::last_os_error())
- }
- }
- }
-}
-
-#[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
-pub mod impl_bsd {
- use super::UCred;
- use crate::io;
- use crate::os::unix::io::AsRawFd;
- use crate::os::unix::net::UnixStream;
-
- pub fn peer_cred(socket: &UnixStream) -> io::Result<UCred> {
- let mut cred = UCred { uid: 1, gid: 1, pid: None };
- unsafe {
- let ret = libc::getpeereid(socket.as_raw_fd(), &mut cred.uid, &mut cred.gid);
-
- if ret == 0 { Ok(cred) } else { Err(io::Error::last_os_error()) }
- }
- }
-}
-
-#[cfg(any(target_os = "macos", target_os = "ios",))]
-pub mod impl_mac {
- use super::UCred;
- use crate::os::unix::io::AsRawFd;
- use crate::os::unix::net::UnixStream;
- use crate::{io, mem};
- use libc::{c_void, getpeereid, getsockopt, pid_t, socklen_t, LOCAL_PEERPID, SOL_LOCAL};
-
- pub fn peer_cred(socket: &UnixStream) -> io::Result<UCred> {
- let mut cred = UCred { uid: 1, gid: 1, pid: None };
- unsafe {
- let ret = getpeereid(socket.as_raw_fd(), &mut cred.uid, &mut cred.gid);
-
- if ret != 0 {
- return Err(io::Error::last_os_error());
- }
-
- let mut pid: pid_t = 1;
- let mut pid_size = mem::size_of::<pid_t>() as socklen_t;
-
- let ret = getsockopt(
- socket.as_raw_fd(),
- SOL_LOCAL,
- LOCAL_PEERPID,
- &mut pid as *mut pid_t as *mut c_void,
- &mut pid_size,
- );
-
- if ret == 0 && pid_size as usize == mem::size_of::<pid_t>() {
- cred.pid = Some(pid);
- Ok(cred)
- } else {
- Err(io::Error::last_os_error())
- }
- }
- }
-}
+++ /dev/null
-use crate::os::unix::net::UnixStream;
-use libc::{getegid, geteuid, getpid};
-
-#[test]
-#[cfg(any(
- target_os = "android",
- target_os = "linux",
- target_os = "dragonfly",
- target_os = "freebsd",
- target_os = "ios",
- target_os = "macos",
- target_os = "openbsd"
-))]
-fn test_socket_pair() {
- // Create two connected sockets and get their peer credentials. They should be equal.
- let (sock_a, sock_b) = UnixStream::pair().unwrap();
- let (cred_a, cred_b) = (sock_a.peer_cred().unwrap(), sock_b.peer_cred().unwrap());
- assert_eq!(cred_a, cred_b);
-
- // Check that the UID and GIDs match up.
- let uid = unsafe { geteuid() };
- let gid = unsafe { getegid() };
- assert_eq!(cred_a.uid, uid);
- assert_eq!(cred_a.gid, gid);
-}
-
-#[test]
-#[cfg(any(target_os = "linux", target_os = "ios", target_os = "macos",))]
-fn test_socket_pair_pids(arg: Type) -> RetType {
- // Create two connected sockets and get their peer credentials.
- let (sock_a, sock_b) = UnixStream::pair().unwrap();
- let (cred_a, cred_b) = (sock_a.peer_cred().unwrap(), sock_b.peer_cred().unwrap());
-
- // On supported platforms (see the cfg above), the credentials should always include the PID.
- let pid = unsafe { getpid() };
- assert_eq!(cred_a.pid, Some(pid));
- assert_eq!(cred_b.pid, Some(pid));
-}
match STATX_STATE.load(Ordering::Relaxed) {
0 => {
- // It is a trick to call `statx` with NULL pointers to check if the syscall
+ // It is a trick to call `statx` with null pointers to check if the syscall
// is available. According to the manual, it is expected to fail with EFAULT.
// We do this mainly for performance, since it is nearly hundreds times
// faster than a normal successful call.
super::os::set_errno(0);
let entry_ptr = libc::readdir(self.inner.dirp.0);
if entry_ptr.is_null() {
- // NULL can mean either the end is reached or an error occurred.
+ // null can mean either the end is reached or an error occurred.
// So we had to clear errno beforehand to check for an error now.
return match super::os::errno() {
0 => None,
})?;
Ok(bytes_copied as u64)
}
+
+#[cfg(not(target_os = "fuchsia"))]
+pub fn chroot(dir: &Path) -> io::Result<()> {
+ let dir = cstr(dir)?;
+ cvt(unsafe { libc::chroot(dir.as_ptr()) })?;
+ Ok(())
+}
pub mod alloc;
pub mod android;
pub mod args;
+#[path = "../unix/cmath.rs"]
pub mod cmath;
pub mod condvar;
pub mod env;
-pub mod ext;
pub mod fd;
pub mod fs;
pub mod futex;
libc::ETIMEDOUT => ErrorKind::TimedOut,
libc::EEXIST => ErrorKind::AlreadyExists,
libc::ENOSYS => ErrorKind::Unsupported,
+ libc::ENOMEM => ErrorKind::OutOfMemory,
// These two constants can have the same value on some systems,
// but different values on others, so we can't use a match
pub fn chdir(p: &path::Path) -> io::Result<()> {
let p: &OsStr = p.as_ref();
let p = CString::new(p.as_bytes())?;
- unsafe {
- match libc::chdir(p.as_ptr()) == (0 as c_int) {
- true => Ok(()),
- false => Err(io::Error::last_os_error()),
- }
+ if unsafe { libc::chdir(p.as_ptr()) } != 0 {
+ return Err(io::Error::last_os_error());
}
+ Ok(())
}
pub struct SplitPaths<'a> {
}
pub fn arg(&mut self, arg: &OsStr) {
- // Overwrite the trailing NULL pointer in `argv` and then add a new null
+ // Overwrite the trailing null pointer in `argv` and then add a new null
// pointer.
let arg = os2c(arg, &mut self.saw_nul);
self.argv.0[self.args.len()] = arg.as_ptr();
+++ /dev/null
-// These symbols are all defined in `compiler-builtins`
-extern "C" {
- pub fn acos(n: f64) -> f64;
- pub fn acosf(n: f32) -> f32;
- pub fn asin(n: f64) -> f64;
- pub fn asinf(n: f32) -> f32;
- pub fn atan(n: f64) -> f64;
- pub fn atan2(a: f64, b: f64) -> f64;
- pub fn atan2f(a: f32, b: f32) -> f32;
- pub fn atanf(n: f32) -> f32;
- pub fn cbrt(n: f64) -> f64;
- pub fn cbrtf(n: f32) -> f32;
- pub fn cosh(n: f64) -> f64;
- pub fn coshf(n: f32) -> f32;
- pub fn expm1(n: f64) -> f64;
- pub fn expm1f(n: f32) -> f32;
- pub fn fdim(a: f64, b: f64) -> f64;
- pub fn fdimf(a: f32, b: f32) -> f32;
- pub fn hypot(x: f64, y: f64) -> f64;
- pub fn hypotf(x: f32, y: f32) -> f32;
- pub fn log1p(n: f64) -> f64;
- pub fn log1pf(n: f32) -> f32;
- pub fn sinh(n: f64) -> f64;
- pub fn sinhf(n: f32) -> f32;
- pub fn tan(n: f64) -> f64;
- pub fn tanf(n: f32) -> f32;
- pub fn tanh(n: f64) -> f64;
- pub fn tanhf(n: f32) -> f32;
-}
pub mod alloc;
pub mod args;
+#[path = "../unix/cmath.rs"]
pub mod cmath;
pub mod condvar;
pub mod env;
+++ /dev/null
-//! WASI-specific extension to the primitives in the `std::ffi` module
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use crate::sys_common::os_str_bytes::*;
+++ /dev/null
-//! WASI-specific extensions to primitives in the `std::fs` module.
-
-#![deny(unsafe_op_in_unsafe_fn)]
-#![unstable(feature = "wasi_ext", issue = "none")]
-
-use crate::ffi::OsStr;
-use crate::fs::{self, File, Metadata, OpenOptions};
-use crate::io::{self, IoSlice, IoSliceMut};
-use crate::path::{Path, PathBuf};
-use crate::sys_common::{AsInner, AsInnerMut, FromInner};
-// Used for `File::read` on intra-doc links
-#[allow(unused_imports)]
-use io::{Read, Write};
-
-/// WASI-specific extensions to [`File`].
-pub trait FileExt {
- /// Reads a number of bytes starting from a given offset.
- ///
- /// Returns the number of bytes read.
- ///
- /// The offset is relative to the start of the file and thus independent
- /// from the current cursor.
- ///
- /// The current file cursor is not affected by this function.
- ///
- /// Note that similar to [`File::read`], it is not an error to return with a
- /// short read.
- fn read_at(&self, buf: &mut [u8], offset: u64) -> io::Result<usize> {
- let bufs = &mut [IoSliceMut::new(buf)];
- self.read_vectored_at(bufs, offset)
- }
-
- /// Reads a number of bytes starting from a given offset.
- ///
- /// Returns the number of bytes read.
- ///
- /// The offset is relative to the start of the file and thus independent
- /// from the current cursor.
- ///
- /// The current file cursor is not affected by this function.
- ///
- /// Note that similar to [`File::read_vectored`], it is not an error to
- /// return with a short read.
- fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize>;
-
- /// Reads the exact number of byte required to fill `buf` from the given offset.
- ///
- /// The offset is relative to the start of the file and thus independent
- /// from the current cursor.
- ///
- /// The current file cursor is not affected by this function.
- ///
- /// Similar to [`Read::read_exact`] but uses [`read_at`] instead of `read`.
- ///
- /// [`read_at`]: FileExt::read_at
- ///
- /// # Errors
- ///
- /// If this function encounters an error of the kind
- /// [`io::ErrorKind::Interrupted`] then the error is ignored and the operation
- /// will continue.
- ///
- /// If this function encounters an "end of file" before completely filling
- /// the buffer, it returns an error of the kind [`io::ErrorKind::UnexpectedEof`].
- /// The contents of `buf` are unspecified in this case.
- ///
- /// If any other read error is encountered then this function immediately
- /// returns. The contents of `buf` are unspecified in this case.
- ///
- /// If this function returns an error, it is unspecified how many bytes it
- /// has read, but it will never read more than would be necessary to
- /// completely fill the buffer.
- #[stable(feature = "rw_exact_all_at", since = "1.33.0")]
- fn read_exact_at(&self, mut buf: &mut [u8], mut offset: u64) -> io::Result<()> {
- while !buf.is_empty() {
- match self.read_at(buf, offset) {
- Ok(0) => break,
- Ok(n) => {
- let tmp = buf;
- buf = &mut tmp[n..];
- offset += n as u64;
- }
- Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
- Err(e) => return Err(e),
- }
- }
- if !buf.is_empty() {
- Err(io::Error::new_const(io::ErrorKind::UnexpectedEof, &"failed to fill whole buffer"))
- } else {
- Ok(())
- }
- }
-
- /// Writes a number of bytes starting from a given offset.
- ///
- /// Returns the number of bytes written.
- ///
- /// The offset is relative to the start of the file and thus independent
- /// from the current cursor.
- ///
- /// The current file cursor is not affected by this function.
- ///
- /// When writing beyond the end of the file, the file is appropriately
- /// extended and the intermediate bytes are initialized with the value 0.
- ///
- /// Note that similar to [`File::write`], it is not an error to return a
- /// short write.
- fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
- let bufs = &[IoSlice::new(buf)];
- self.write_vectored_at(bufs, offset)
- }
-
- /// Writes a number of bytes starting from a given offset.
- ///
- /// Returns the number of bytes written.
- ///
- /// The offset is relative to the start of the file and thus independent
- /// from the current cursor.
- ///
- /// The current file cursor is not affected by this function.
- ///
- /// When writing beyond the end of the file, the file is appropriately
- /// extended and the intermediate bytes are initialized with the value 0.
- ///
- /// Note that similar to [`File::write_vectored`], it is not an error to return a
- /// short write.
- fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize>;
-
- /// Attempts to write an entire buffer starting from a given offset.
- ///
- /// The offset is relative to the start of the file and thus independent
- /// from the current cursor.
- ///
- /// The current file cursor is not affected by this function.
- ///
- /// This method will continuously call [`write_at`] until there is no more data
- /// to be written or an error of non-[`io::ErrorKind::Interrupted`] kind is
- /// returned. This method will not return until the entire buffer has been
- /// successfully written or such an error occurs. The first error that is
- /// not of [`io::ErrorKind::Interrupted`] kind generated from this method will be
- /// returned.
- ///
- /// # Errors
- ///
- /// This function will return the first error of
- /// non-[`io::ErrorKind::Interrupted`] kind that [`write_at`] returns.
- ///
- /// [`write_at`]: FileExt::write_at
- #[stable(feature = "rw_exact_all_at", since = "1.33.0")]
- fn write_all_at(&self, mut buf: &[u8], mut offset: u64) -> io::Result<()> {
- while !buf.is_empty() {
- match self.write_at(buf, offset) {
- Ok(0) => {
- return Err(io::Error::new_const(
- io::ErrorKind::WriteZero,
- &"failed to write whole buffer",
- ));
- }
- Ok(n) => {
- buf = &buf[n..];
- offset += n as u64
- }
- Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
- Err(e) => return Err(e),
- }
- }
- Ok(())
- }
-
- /// Returns the current position within the file.
- ///
- /// This corresponds to the `fd_tell` syscall and is similar to
- /// `seek` where you offset 0 bytes from the current position.
- fn tell(&self) -> io::Result<u64>;
-
- /// Adjust the flags associated with this file.
- ///
- /// This corresponds to the `fd_fdstat_set_flags` syscall.
- fn fdstat_set_flags(&self, flags: u16) -> io::Result<()>;
-
- /// Adjust the rights associated with this file.
- ///
- /// This corresponds to the `fd_fdstat_set_rights` syscall.
- fn fdstat_set_rights(&self, rights: u64, inheriting: u64) -> io::Result<()>;
-
- /// Provide file advisory information on a file descriptor.
- ///
- /// This corresponds to the `fd_advise` syscall.
- fn advise(&self, offset: u64, len: u64, advice: u8) -> io::Result<()>;
-
- /// Force the allocation of space in a file.
- ///
- /// This corresponds to the `fd_allocate` syscall.
- fn allocate(&self, offset: u64, len: u64) -> io::Result<()>;
-
- /// Create a directory.
- ///
- /// This corresponds to the `path_create_directory` syscall.
- fn create_directory<P: AsRef<Path>>(&self, dir: P) -> io::Result<()>;
-
- /// Read the contents of a symbolic link.
- ///
- /// This corresponds to the `path_readlink` syscall.
- fn read_link<P: AsRef<Path>>(&self, path: P) -> io::Result<PathBuf>;
-
- /// Return the attributes of a file or directory.
- ///
- /// This corresponds to the `path_filestat_get` syscall.
- fn metadata_at<P: AsRef<Path>>(&self, lookup_flags: u32, path: P) -> io::Result<Metadata>;
-
- /// Unlink a file.
- ///
- /// This corresponds to the `path_unlink_file` syscall.
- fn remove_file<P: AsRef<Path>>(&self, path: P) -> io::Result<()>;
-
- /// Remove a directory.
- ///
- /// This corresponds to the `path_remove_directory` syscall.
- fn remove_directory<P: AsRef<Path>>(&self, path: P) -> io::Result<()>;
-}
-
-// FIXME: bind fd_fdstat_get - need to define a custom return type
-// FIXME: bind fd_readdir - can't return `ReadDir` since we only have entry name
-// FIXME: bind fd_filestat_set_times maybe? - on crates.io for unix
-// FIXME: bind path_filestat_set_times maybe? - on crates.io for unix
-// FIXME: bind poll_oneoff maybe? - probably should wait for I/O to settle
-// FIXME: bind random_get maybe? - on crates.io for unix
-
-impl FileExt for fs::File {
- fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
- self.as_inner().fd().pread(bufs, offset)
- }
-
- fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
- self.as_inner().fd().pwrite(bufs, offset)
- }
-
- fn tell(&self) -> io::Result<u64> {
- self.as_inner().fd().tell()
- }
-
- fn fdstat_set_flags(&self, flags: u16) -> io::Result<()> {
- self.as_inner().fd().set_flags(flags)
- }
-
- fn fdstat_set_rights(&self, rights: u64, inheriting: u64) -> io::Result<()> {
- self.as_inner().fd().set_rights(rights, inheriting)
- }
-
- fn advise(&self, offset: u64, len: u64, advice: u8) -> io::Result<()> {
- self.as_inner().fd().advise(offset, len, advice)
- }
-
- fn allocate(&self, offset: u64, len: u64) -> io::Result<()> {
- self.as_inner().fd().allocate(offset, len)
- }
-
- fn create_directory<P: AsRef<Path>>(&self, dir: P) -> io::Result<()> {
- self.as_inner().fd().create_directory(osstr2str(dir.as_ref().as_ref())?)
- }
-
- fn read_link<P: AsRef<Path>>(&self, path: P) -> io::Result<PathBuf> {
- self.as_inner().read_link(path.as_ref())
- }
-
- fn metadata_at<P: AsRef<Path>>(&self, lookup_flags: u32, path: P) -> io::Result<Metadata> {
- let m = self.as_inner().metadata_at(lookup_flags, path.as_ref())?;
- Ok(FromInner::from_inner(m))
- }
-
- fn remove_file<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
- self.as_inner().fd().unlink_file(osstr2str(path.as_ref().as_ref())?)
- }
-
- fn remove_directory<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
- self.as_inner().fd().remove_directory(osstr2str(path.as_ref().as_ref())?)
- }
-}
-
-/// WASI-specific extensions to [`fs::OpenOptions`].
-pub trait OpenOptionsExt {
- /// Pass custom `dirflags` argument to `path_open`.
- ///
- /// This option configures the `dirflags` argument to the
- /// `path_open` syscall which `OpenOptions` will eventually call. The
- /// `dirflags` argument configures how the file is looked up, currently
- /// primarily affecting whether symlinks are followed or not.
- ///
- /// By default this value is `__WASI_LOOKUP_SYMLINK_FOLLOW`, or symlinks are
- /// followed. You can call this method with 0 to disable following symlinks
- fn lookup_flags(&mut self, flags: u32) -> &mut Self;
-
- /// Indicates whether `OpenOptions` must open a directory or not.
- ///
- /// This method will configure whether the `__WASI_O_DIRECTORY` flag is
- /// passed when opening a file. When passed it will require that the opened
- /// path is a directory.
- ///
- /// This option is by default `false`
- fn directory(&mut self, dir: bool) -> &mut Self;
-
- /// Indicates whether `__WASI_FDFLAG_DSYNC` is passed in the `fs_flags`
- /// field of `path_open`.
- ///
- /// This option is by default `false`
- fn dsync(&mut self, dsync: bool) -> &mut Self;
-
- /// Indicates whether `__WASI_FDFLAG_NONBLOCK` is passed in the `fs_flags`
- /// field of `path_open`.
- ///
- /// This option is by default `false`
- fn nonblock(&mut self, nonblock: bool) -> &mut Self;
-
- /// Indicates whether `__WASI_FDFLAG_RSYNC` is passed in the `fs_flags`
- /// field of `path_open`.
- ///
- /// This option is by default `false`
- fn rsync(&mut self, rsync: bool) -> &mut Self;
-
- /// Indicates whether `__WASI_FDFLAG_SYNC` is passed in the `fs_flags`
- /// field of `path_open`.
- ///
- /// This option is by default `false`
- fn sync(&mut self, sync: bool) -> &mut Self;
-
- /// Indicates the value that should be passed in for the `fs_rights_base`
- /// parameter of `path_open`.
- ///
- /// This option defaults based on the `read` and `write` configuration of
- /// this `OpenOptions` builder. If this method is called, however, the
- /// exact mask passed in will be used instead.
- fn fs_rights_base(&mut self, rights: u64) -> &mut Self;
-
- /// Indicates the value that should be passed in for the
- /// `fs_rights_inheriting` parameter of `path_open`.
- ///
- /// The default for this option is the same value as what will be passed
- /// for the `fs_rights_base` parameter but if this method is called then
- /// the specified value will be used instead.
- fn fs_rights_inheriting(&mut self, rights: u64) -> &mut Self;
-
- /// Open a file or directory.
- ///
- /// This corresponds to the `path_open` syscall.
- fn open_at<P: AsRef<Path>>(&self, file: &File, path: P) -> io::Result<File>;
-}
-
-impl OpenOptionsExt for OpenOptions {
- fn lookup_flags(&mut self, flags: u32) -> &mut OpenOptions {
- self.as_inner_mut().lookup_flags(flags);
- self
- }
-
- fn directory(&mut self, dir: bool) -> &mut OpenOptions {
- self.as_inner_mut().directory(dir);
- self
- }
-
- fn dsync(&mut self, enabled: bool) -> &mut OpenOptions {
- self.as_inner_mut().dsync(enabled);
- self
- }
-
- fn nonblock(&mut self, enabled: bool) -> &mut OpenOptions {
- self.as_inner_mut().nonblock(enabled);
- self
- }
-
- fn rsync(&mut self, enabled: bool) -> &mut OpenOptions {
- self.as_inner_mut().rsync(enabled);
- self
- }
-
- fn sync(&mut self, enabled: bool) -> &mut OpenOptions {
- self.as_inner_mut().sync(enabled);
- self
- }
-
- fn fs_rights_base(&mut self, rights: u64) -> &mut OpenOptions {
- self.as_inner_mut().fs_rights_base(rights);
- self
- }
-
- fn fs_rights_inheriting(&mut self, rights: u64) -> &mut OpenOptions {
- self.as_inner_mut().fs_rights_inheriting(rights);
- self
- }
-
- fn open_at<P: AsRef<Path>>(&self, file: &File, path: P) -> io::Result<File> {
- let inner = file.as_inner().open_at(path.as_ref(), self.as_inner())?;
- Ok(File::from_inner(inner))
- }
-}
-
-/// WASI-specific extensions to [`fs::Metadata`].
-pub trait MetadataExt {
- /// Returns the `st_dev` field of the internal `filestat_t`
- fn dev(&self) -> u64;
- /// Returns the `st_ino` field of the internal `filestat_t`
- fn ino(&self) -> u64;
- /// Returns the `st_nlink` field of the internal `filestat_t`
- fn nlink(&self) -> u64;
- /// Returns the `st_size` field of the internal `filestat_t`
- fn size(&self) -> u64;
- /// Returns the `st_atim` field of the internal `filestat_t`
- fn atim(&self) -> u64;
- /// Returns the `st_mtim` field of the internal `filestat_t`
- fn mtim(&self) -> u64;
- /// Returns the `st_ctim` field of the internal `filestat_t`
- fn ctim(&self) -> u64;
-}
-
-impl MetadataExt for fs::Metadata {
- fn dev(&self) -> u64 {
- self.as_inner().as_wasi().dev
- }
- fn ino(&self) -> u64 {
- self.as_inner().as_wasi().ino
- }
- fn nlink(&self) -> u64 {
- self.as_inner().as_wasi().nlink
- }
- fn size(&self) -> u64 {
- self.as_inner().as_wasi().size
- }
- fn atim(&self) -> u64 {
- self.as_inner().as_wasi().atim
- }
- fn mtim(&self) -> u64 {
- self.as_inner().as_wasi().mtim
- }
- fn ctim(&self) -> u64 {
- self.as_inner().as_wasi().ctim
- }
-}
-
-/// WASI-specific extensions for [`fs::FileType`].
-///
-/// Adds support for special WASI file types such as block/character devices,
-/// pipes, and sockets.
-pub trait FileTypeExt {
- /// Returns `true` if this file type is a block device.
- fn is_block_device(&self) -> bool;
- /// Returns `true` if this file type is a character device.
- fn is_character_device(&self) -> bool;
- /// Returns `true` if this file type is a socket datagram.
- fn is_socket_dgram(&self) -> bool;
- /// Returns `true` if this file type is a socket stream.
- fn is_socket_stream(&self) -> bool;
-}
-
-impl FileTypeExt for fs::FileType {
- fn is_block_device(&self) -> bool {
- self.as_inner().bits() == wasi::FILETYPE_BLOCK_DEVICE
- }
- fn is_character_device(&self) -> bool {
- self.as_inner().bits() == wasi::FILETYPE_CHARACTER_DEVICE
- }
- fn is_socket_dgram(&self) -> bool {
- self.as_inner().bits() == wasi::FILETYPE_SOCKET_DGRAM
- }
- fn is_socket_stream(&self) -> bool {
- self.as_inner().bits() == wasi::FILETYPE_SOCKET_STREAM
- }
-}
-
-/// WASI-specific extension methods for [`fs::DirEntry`].
-pub trait DirEntryExt {
- /// Returns the underlying `d_ino` field of the `dirent_t`
- fn ino(&self) -> u64;
-}
-
-impl DirEntryExt for fs::DirEntry {
- fn ino(&self) -> u64 {
- self.as_inner().ino()
- }
-}
-
-/// Create a hard link.
-///
-/// This corresponds to the `path_link` syscall.
-pub fn link<P: AsRef<Path>, U: AsRef<Path>>(
- old_fd: &File,
- old_flags: u32,
- old_path: P,
- new_fd: &File,
- new_path: U,
-) -> io::Result<()> {
- old_fd.as_inner().fd().link(
- old_flags,
- osstr2str(old_path.as_ref().as_ref())?,
- new_fd.as_inner().fd(),
- osstr2str(new_path.as_ref().as_ref())?,
- )
-}
-
-/// Rename a file or directory.
-///
-/// This corresponds to the `path_rename` syscall.
-pub fn rename<P: AsRef<Path>, U: AsRef<Path>>(
- old_fd: &File,
- old_path: P,
- new_fd: &File,
- new_path: U,
-) -> io::Result<()> {
- old_fd.as_inner().fd().rename(
- osstr2str(old_path.as_ref().as_ref())?,
- new_fd.as_inner().fd(),
- osstr2str(new_path.as_ref().as_ref())?,
- )
-}
-
-/// Create a symbolic link.
-///
-/// This corresponds to the `path_symlink` syscall.
-pub fn symlink<P: AsRef<Path>, U: AsRef<Path>>(
- old_path: P,
- fd: &File,
- new_path: U,
-) -> io::Result<()> {
- fd.as_inner()
- .fd()
- .symlink(osstr2str(old_path.as_ref().as_ref())?, osstr2str(new_path.as_ref().as_ref())?)
-}
-
-/// Create a symbolic link.
-///
-/// This is a convenience API similar to `std::os::unix::fs::symlink` and
-/// `std::os::windows::fs::symlink_file` and `std::os::windows::fs::symlink_dir`.
-pub fn symlink_path<P: AsRef<Path>, U: AsRef<Path>>(old_path: P, new_path: U) -> io::Result<()> {
- crate::sys::fs::symlink(old_path.as_ref(), new_path.as_ref())
-}
-
-fn osstr2str(f: &OsStr) -> io::Result<&str> {
- f.to_str().ok_or_else(|| io::Error::new_const(io::ErrorKind::Other, &"input must be utf-8"))
-}
+++ /dev/null
-//! WASI-specific extensions to general I/O primitives
-
-#![deny(unsafe_op_in_unsafe_fn)]
-#![unstable(feature = "wasi_ext", issue = "none")]
-
-use crate::fs;
-use crate::io;
-use crate::net;
-use crate::sys;
-use crate::sys_common::{AsInner, FromInner, IntoInner};
-
-/// Raw file descriptors.
-pub type RawFd = u32;
-
-/// A trait to extract the raw WASI file descriptor from an underlying
-/// object.
-pub trait AsRawFd {
- /// Extracts the raw file descriptor.
- ///
- /// This method does **not** pass ownership of the raw file descriptor
- /// to the caller. The descriptor is only guaranteed to be valid while
- /// the original object has not yet been destroyed.
- fn as_raw_fd(&self) -> RawFd;
-}
-
-/// A trait to express the ability to construct an object from a raw file
-/// descriptor.
-pub trait FromRawFd {
- /// Constructs a new instance of `Self` from the given raw file
- /// descriptor.
- ///
- /// This function **consumes ownership** of the specified file
- /// descriptor. The returned object will take responsibility for closing
- /// it when the object goes out of scope.
- ///
- /// This function is also unsafe as the primitives currently returned
- /// have the contract that they are the sole owner of the file
- /// descriptor they are wrapping. Usage of this function could
- /// accidentally allow violating this contract which can cause memory
- /// unsafety in code that relies on it being true.
- unsafe fn from_raw_fd(fd: RawFd) -> Self;
-}
-
-/// A trait to express the ability to consume an object and acquire ownership of
-/// its raw file descriptor.
-pub trait IntoRawFd {
- /// Consumes this object, returning the raw underlying file descriptor.
- ///
- /// This function **transfers ownership** of the underlying file descriptor
- /// to the caller. Callers are then the unique owners of the file descriptor
- /// and must close the descriptor once it's no longer needed.
- fn into_raw_fd(self) -> RawFd;
-}
-
-#[stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")]
-impl AsRawFd for RawFd {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- *self
- }
-}
-#[stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")]
-impl IntoRawFd for RawFd {
- #[inline]
- fn into_raw_fd(self) -> RawFd {
- self
- }
-}
-#[stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")]
-impl FromRawFd for RawFd {
- #[inline]
- unsafe fn from_raw_fd(fd: RawFd) -> RawFd {
- fd
- }
-}
-
-impl AsRawFd for net::TcpStream {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- self.as_inner().fd().as_raw()
- }
-}
-
-impl FromRawFd for net::TcpStream {
- #[inline]
- unsafe fn from_raw_fd(fd: RawFd) -> net::TcpStream {
- net::TcpStream::from_inner(sys::net::TcpStream::from_inner(fd))
- }
-}
-
-impl IntoRawFd for net::TcpStream {
- #[inline]
- fn into_raw_fd(self) -> RawFd {
- self.into_inner().into_fd().into_raw()
- }
-}
-
-impl AsRawFd for net::TcpListener {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- self.as_inner().fd().as_raw()
- }
-}
-
-impl FromRawFd for net::TcpListener {
- #[inline]
- unsafe fn from_raw_fd(fd: RawFd) -> net::TcpListener {
- net::TcpListener::from_inner(sys::net::TcpListener::from_inner(fd))
- }
-}
-
-impl IntoRawFd for net::TcpListener {
- #[inline]
- fn into_raw_fd(self) -> RawFd {
- self.into_inner().into_fd().into_raw()
- }
-}
-
-impl AsRawFd for net::UdpSocket {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- self.as_inner().fd().as_raw()
- }
-}
-
-impl FromRawFd for net::UdpSocket {
- #[inline]
- unsafe fn from_raw_fd(fd: RawFd) -> net::UdpSocket {
- net::UdpSocket::from_inner(sys::net::UdpSocket::from_inner(fd))
- }
-}
-
-impl IntoRawFd for net::UdpSocket {
- #[inline]
- fn into_raw_fd(self) -> RawFd {
- self.into_inner().into_fd().into_raw()
- }
-}
-
-impl AsRawFd for fs::File {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- self.as_inner().fd().as_raw()
- }
-}
-
-impl FromRawFd for fs::File {
- #[inline]
- unsafe fn from_raw_fd(fd: RawFd) -> fs::File {
- fs::File::from_inner(sys::fs::File::from_inner(fd))
- }
-}
-
-impl IntoRawFd for fs::File {
- #[inline]
- fn into_raw_fd(self) -> RawFd {
- self.into_inner().into_fd().into_raw()
- }
-}
-
-impl AsRawFd for io::Stdin {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- libc::STDIN_FILENO as RawFd
- }
-}
-
-impl AsRawFd for io::Stdout {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- libc::STDOUT_FILENO as RawFd
- }
-}
-
-impl AsRawFd for io::Stderr {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- libc::STDERR_FILENO as RawFd
- }
-}
-
-impl<'a> AsRawFd for io::StdinLock<'a> {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- libc::STDIN_FILENO as RawFd
- }
-}
-
-impl<'a> AsRawFd for io::StdoutLock<'a> {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- libc::STDOUT_FILENO as RawFd
- }
-}
-
-impl<'a> AsRawFd for io::StderrLock<'a> {
- #[inline]
- fn as_raw_fd(&self) -> RawFd {
- libc::STDERR_FILENO as RawFd
- }
-}
+++ /dev/null
-//! Platform-specific extensions to `std` for WASI.
-//!
-//! Provides access to platform-level information on WASI, and exposes
-//! WASI-specific functions that would otherwise be inappropriate as
-//! part of the core `std` library.
-//!
-//! It exposes more ways to deal with platform-specific strings (`OsStr`,
-//! `OsString`), allows to set permissions more granularly, extract low-level
-//! file descriptors from files and sockets, and has platform-specific helpers
-//! for spawning processes.
-//!
-//! # Examples
-//!
-//! ```no_run
-//! use std::fs::File;
-//! use std::os::wasi::prelude::*;
-//!
-//! fn main() -> std::io::Result<()> {
-//! let f = File::create("foo.txt")?;
-//! let fd = f.as_raw_fd();
-//!
-//! // use fd with native WASI bindings
-//!
-//! Ok(())
-//! }
-//! ```
-
-#![deny(unsafe_op_in_unsafe_fn)]
-#![doc(cfg(target_os = "wasi"))]
-
-pub mod ffi;
-pub mod fs;
-pub mod io;
-
-/// A prelude for conveniently writing platform-specific code.
-///
-/// Includes all extension traits, and some important type definitions.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub mod prelude {
- #[doc(no_inline)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use super::ffi::{OsStrExt, OsStringExt};
- #[doc(no_inline)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use super::fs::FileTypeExt;
- #[doc(no_inline)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use super::fs::{DirEntryExt, FileExt, MetadataExt, OpenOptionsExt};
- #[doc(no_inline)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use super::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
-}
#[path = "../unix/alloc.rs"]
pub mod alloc;
pub mod args;
-#[path = "../unsupported/cmath.rs"]
+#[path = "../unix/cmath.rs"]
pub mod cmath;
#[path = "../unsupported/condvar.rs"]
pub mod condvar;
pub mod net;
pub mod os;
pub use crate::sys_common::os_str_bytes as os_str;
-pub mod ext;
#[path = "../unix/path.rs"]
pub mod path;
#[path = "../unsupported/pipe.rs"]
wasi::ERRNO_EXIST => AlreadyExists,
wasi::ERRNO_AGAIN => WouldBlock,
wasi::ERRNO_NOSYS => Unsupported,
+ wasi::ERRNO_NOMEM => OutOfMemory,
_ => Other,
}
}
pub mod alloc;
pub mod args;
-#[path = "../unsupported/cmath.rs"]
+#[path = "../unix/cmath.rs"]
pub mod cmath;
pub mod env;
#[path = "../unsupported/fs.rs"]
pub const ERROR_PATH_NOT_FOUND: DWORD = 3;
pub const ERROR_ACCESS_DENIED: DWORD = 5;
pub const ERROR_INVALID_HANDLE: DWORD = 6;
+pub const ERROR_NOT_ENOUGH_MEMORY: DWORD = 8;
+pub const ERROR_OUTOFMEMORY: DWORD = 14;
pub const ERROR_NO_MORE_FILES: DWORD = 18;
pub const ERROR_HANDLE_EOF: DWORD = 38;
pub const ERROR_FILE_EXISTS: DWORD = 80;
+++ /dev/null
-//! Windows-specific extensions to the primitives in the `std::ffi` module.
-//!
-//! # Overview
-//!
-//! For historical reasons, the Windows API uses a form of potentially
-//! ill-formed UTF-16 encoding for strings. Specifically, the 16-bit
-//! code units in Windows strings may contain [isolated surrogate code
-//! points which are not paired together][ill-formed-utf-16]. The
-//! Unicode standard requires that surrogate code points (those in the
-//! range U+D800 to U+DFFF) always be *paired*, because in the UTF-16
-//! encoding a *surrogate code unit pair* is used to encode a single
-//! character. For compatibility with code that does not enforce
-//! these pairings, Windows does not enforce them, either.
-//!
-//! While it is not always possible to convert such a string losslessly into
-//! a valid UTF-16 string (or even UTF-8), it is often desirable to be
-//! able to round-trip such a string from and to Windows APIs
-//! losslessly. For example, some Rust code may be "bridging" some
-//! Windows APIs together, just passing `WCHAR` strings among those
-//! APIs without ever really looking into the strings.
-//!
-//! If Rust code *does* need to look into those strings, it can
-//! convert them to valid UTF-8, possibly lossily, by substituting
-//! invalid sequences with [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD], as is
-//! conventionally done in other Rust APIs that deal with string
-//! encodings.
-//!
-//! # `OsStringExt` and `OsStrExt`
-//!
-//! [`OsString`] is the Rust wrapper for owned strings in the
-//! preferred representation of the operating system. On Windows,
-//! this struct gets augmented with an implementation of the
-//! [`OsStringExt`] trait, which has a [`OsStringExt::from_wide`] method. This
-//! lets you create an [`OsString`] from a `&[u16]` slice; presumably
-//! you get such a slice out of a `WCHAR` Windows API.
-//!
-//! Similarly, [`OsStr`] is the Rust wrapper for borrowed strings from
-//! preferred representation of the operating system. On Windows, the
-//! [`OsStrExt`] trait provides the [`OsStrExt::encode_wide`] method, which
-//! outputs an [`EncodeWide`] iterator. You can [`collect`] this
-//! iterator, for example, to obtain a `Vec<u16>`; you can later get a
-//! pointer to this vector's contents and feed it to Windows APIs.
-//!
-//! These traits, along with [`OsString`] and [`OsStr`], work in
-//! conjunction so that it is possible to **round-trip** strings from
-//! Windows and back, with no loss of data, even if the strings are
-//! ill-formed UTF-16.
-//!
-//! [ill-formed-utf-16]: https://simonsapin.github.io/wtf-8/#ill-formed-utf-16
-//! [`collect`]: crate::iter::Iterator::collect
-//! [U+FFFD]: crate::char::REPLACEMENT_CHARACTER
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-use crate::ffi::{OsStr, OsString};
-use crate::sealed::Sealed;
-use crate::sys::os_str::Buf;
-use crate::sys_common::wtf8::Wtf8Buf;
-use crate::sys_common::{AsInner, FromInner};
-
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use crate::sys_common::wtf8::EncodeWide;
-
-/// Windows-specific extensions to [`OsString`].
-///
-/// This trait is sealed: it cannot be implemented outside the standard library.
-/// This is so that future additional methods are not breaking changes.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub trait OsStringExt: Sealed {
- /// Creates an `OsString` from a potentially ill-formed UTF-16 slice of
- /// 16-bit code units.
- ///
- /// This is lossless: calling [`OsStrExt::encode_wide`] on the resulting string
- /// will always return the original code units.
- ///
- /// # Examples
- ///
- /// ```
- /// use std::ffi::OsString;
- /// use std::os::windows::prelude::*;
- ///
- /// // UTF-16 encoding for "Unicode".
- /// let source = [0x0055, 0x006E, 0x0069, 0x0063, 0x006F, 0x0064, 0x0065];
- ///
- /// let string = OsString::from_wide(&source[..]);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn from_wide(wide: &[u16]) -> Self;
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl OsStringExt for OsString {
- fn from_wide(wide: &[u16]) -> OsString {
- FromInner::from_inner(Buf { inner: Wtf8Buf::from_wide(wide) })
- }
-}
-
-/// Windows-specific extensions to [`OsStr`].
-///
-/// This trait is sealed: it cannot be implemented outside the standard library.
-/// This is so that future additional methods are not breaking changes.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub trait OsStrExt: Sealed {
- /// Re-encodes an `OsStr` as a wide character sequence, i.e., potentially
- /// ill-formed UTF-16.
- ///
- /// This is lossless: calling [`OsStringExt::from_wide`] and then
- /// `encode_wide` on the result will yield the original code units.
- /// Note that the encoding does not add a final null terminator.
- ///
- /// # Examples
- ///
- /// ```
- /// use std::ffi::OsString;
- /// use std::os::windows::prelude::*;
- ///
- /// // UTF-16 encoding for "Unicode".
- /// let source = [0x0055, 0x006E, 0x0069, 0x0063, 0x006F, 0x0064, 0x0065];
- ///
- /// let string = OsString::from_wide(&source[..]);
- ///
- /// let result: Vec<u16> = string.encode_wide().collect();
- /// assert_eq!(&source[..], &result[..]);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn encode_wide(&self) -> EncodeWide<'_>;
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl OsStrExt for OsStr {
- fn encode_wide(&self) -> EncodeWide<'_> {
- self.as_inner().inner.encode_wide()
- }
-}
+++ /dev/null
-//! Windows-specific extensions for the primitives in the `std::fs` module.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-use crate::fs::{self, Metadata, OpenOptions};
-use crate::io;
-use crate::path::Path;
-use crate::sys;
-use crate::sys_common::{AsInner, AsInnerMut};
-
-/// Windows-specific extensions to [`fs::File`].
-#[stable(feature = "file_offset", since = "1.15.0")]
-pub trait FileExt {
- /// Seeks to a given position and reads a number of bytes.
- ///
- /// Returns the number of bytes read.
- ///
- /// The offset is relative to the start of the file and thus independent
- /// from the current cursor. The current cursor **is** affected by this
- /// function, it is set to the end of the read.
- ///
- /// Reading beyond the end of the file will always return with a length of
- /// 0\.
- ///
- /// Note that similar to `File::read`, it is not an error to return with a
- /// short read. When returning from such a short read, the file pointer is
- /// still updated.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::io;
- /// use std::fs::File;
- /// use std::os::windows::prelude::*;
- ///
- /// fn main() -> io::Result<()> {
- /// let mut file = File::open("foo.txt")?;
- /// let mut buffer = [0; 10];
- ///
- /// // Read 10 bytes, starting 72 bytes from the
- /// // start of the file.
- /// file.seek_read(&mut buffer[..], 72)?;
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "file_offset", since = "1.15.0")]
- fn seek_read(&self, buf: &mut [u8], offset: u64) -> io::Result<usize>;
-
- /// Seeks to a given position and writes a number of bytes.
- ///
- /// Returns the number of bytes written.
- ///
- /// The offset is relative to the start of the file and thus independent
- /// from the current cursor. The current cursor **is** affected by this
- /// function, it is set to the end of the write.
- ///
- /// When writing beyond the end of the file, the file is appropriately
- /// extended and the intermediate bytes are left uninitialized.
- ///
- /// Note that similar to `File::write`, it is not an error to return a
- /// short write. When returning from such a short write, the file pointer
- /// is still updated.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs::File;
- /// use std::os::windows::prelude::*;
- ///
- /// fn main() -> std::io::Result<()> {
- /// let mut buffer = File::create("foo.txt")?;
- ///
- /// // Write a byte string starting 72 bytes from
- /// // the start of the file.
- /// buffer.seek_write(b"some bytes", 72)?;
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "file_offset", since = "1.15.0")]
- fn seek_write(&self, buf: &[u8], offset: u64) -> io::Result<usize>;
-}
-
-#[stable(feature = "file_offset", since = "1.15.0")]
-impl FileExt for fs::File {
- fn seek_read(&self, buf: &mut [u8], offset: u64) -> io::Result<usize> {
- self.as_inner().read_at(buf, offset)
- }
-
- fn seek_write(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
- self.as_inner().write_at(buf, offset)
- }
-}
-
-/// Windows-specific extensions to [`fs::OpenOptions`].
-#[stable(feature = "open_options_ext", since = "1.10.0")]
-pub trait OpenOptionsExt {
- /// Overrides the `dwDesiredAccess` argument to the call to [`CreateFile`]
- /// with the specified value.
- ///
- /// This will override the `read`, `write`, and `append` flags on the
- /// `OpenOptions` structure. This method provides fine-grained control over
- /// the permissions to read, write and append data, attributes (like hidden
- /// and system), and extended attributes.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs::OpenOptions;
- /// use std::os::windows::prelude::*;
- ///
- /// // Open without read and write permission, for example if you only need
- /// // to call `stat` on the file
- /// let file = OpenOptions::new().access_mode(0).open("foo.txt");
- /// ```
- ///
- /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea
- #[stable(feature = "open_options_ext", since = "1.10.0")]
- fn access_mode(&mut self, access: u32) -> &mut Self;
-
- /// Overrides the `dwShareMode` argument to the call to [`CreateFile`] with
- /// the specified value.
- ///
- /// By default `share_mode` is set to
- /// `FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE`. This allows
- /// other processes to read, write, and delete/rename the same file
- /// while it is open. Removing any of the flags will prevent other
- /// processes from performing the corresponding operation until the file
- /// handle is closed.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::fs::OpenOptions;
- /// use std::os::windows::prelude::*;
- ///
- /// // Do not allow others to read or modify this file while we have it open
- /// // for writing.
- /// let file = OpenOptions::new()
- /// .write(true)
- /// .share_mode(0)
- /// .open("foo.txt");
- /// ```
- ///
- /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea
- #[stable(feature = "open_options_ext", since = "1.10.0")]
- fn share_mode(&mut self, val: u32) -> &mut Self;
-
- /// Sets extra flags for the `dwFileFlags` argument to the call to
- /// [`CreateFile2`] to the specified value (or combines it with
- /// `attributes` and `security_qos_flags` to set the `dwFlagsAndAttributes`
- /// for [`CreateFile`]).
- ///
- /// Custom flags can only set flags, not remove flags set by Rust's options.
- /// This option overwrites any previously set custom flags.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// # #[cfg(for_demonstration_only)]
- /// extern crate winapi;
- /// # mod winapi { pub const FILE_FLAG_DELETE_ON_CLOSE: u32 = 0x04000000; }
- ///
- /// use std::fs::OpenOptions;
- /// use std::os::windows::prelude::*;
- ///
- /// let file = OpenOptions::new()
- /// .create(true)
- /// .write(true)
- /// .custom_flags(winapi::FILE_FLAG_DELETE_ON_CLOSE)
- /// .open("foo.txt");
- /// ```
- ///
- /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea
- /// [`CreateFile2`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfile2
- #[stable(feature = "open_options_ext", since = "1.10.0")]
- fn custom_flags(&mut self, flags: u32) -> &mut Self;
-
- /// Sets the `dwFileAttributes` argument to the call to [`CreateFile2`] to
- /// the specified value (or combines it with `custom_flags` and
- /// `security_qos_flags` to set the `dwFlagsAndAttributes` for
- /// [`CreateFile`]).
- ///
- /// If a _new_ file is created because it does not yet exist and
- /// `.create(true)` or `.create_new(true)` are specified, the new file is
- /// given the attributes declared with `.attributes()`.
- ///
- /// If an _existing_ file is opened with `.create(true).truncate(true)`, its
- /// existing attributes are preserved and combined with the ones declared
- /// with `.attributes()`.
- ///
- /// In all other cases the attributes get ignored.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// # #[cfg(for_demonstration_only)]
- /// extern crate winapi;
- /// # mod winapi { pub const FILE_ATTRIBUTE_HIDDEN: u32 = 2; }
- ///
- /// use std::fs::OpenOptions;
- /// use std::os::windows::prelude::*;
- ///
- /// let file = OpenOptions::new()
- /// .write(true)
- /// .create(true)
- /// .attributes(winapi::FILE_ATTRIBUTE_HIDDEN)
- /// .open("foo.txt");
- /// ```
- ///
- /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea
- /// [`CreateFile2`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfile2
- #[stable(feature = "open_options_ext", since = "1.10.0")]
- fn attributes(&mut self, val: u32) -> &mut Self;
-
- /// Sets the `dwSecurityQosFlags` argument to the call to [`CreateFile2`] to
- /// the specified value (or combines it with `custom_flags` and `attributes`
- /// to set the `dwFlagsAndAttributes` for [`CreateFile`]).
- ///
- /// By default `security_qos_flags` is not set. It should be specified when
- /// opening a named pipe, to control to which degree a server process can
- /// act on behalf of a client process (security impersonation level).
- ///
- /// When `security_qos_flags` is not set, a malicious program can gain the
- /// elevated privileges of a privileged Rust process when it allows opening
- /// user-specified paths, by tricking it into opening a named pipe. So
- /// arguably `security_qos_flags` should also be set when opening arbitrary
- /// paths. However the bits can then conflict with other flags, specifically
- /// `FILE_FLAG_OPEN_NO_RECALL`.
- ///
- /// For information about possible values, see [Impersonation Levels] on the
- /// Windows Dev Center site. The `SECURITY_SQOS_PRESENT` flag is set
- /// automatically when using this method.
-
- /// # Examples
- ///
- /// ```no_run
- /// # #[cfg(for_demonstration_only)]
- /// extern crate winapi;
- /// # mod winapi { pub const SECURITY_IDENTIFICATION: u32 = 0; }
- /// use std::fs::OpenOptions;
- /// use std::os::windows::prelude::*;
- ///
- /// let file = OpenOptions::new()
- /// .write(true)
- /// .create(true)
- ///
- /// // Sets the flag value to `SecurityIdentification`.
- /// .security_qos_flags(winapi::SECURITY_IDENTIFICATION)
- ///
- /// .open(r"\\.\pipe\MyPipe");
- /// ```
- ///
- /// [`CreateFile`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea
- /// [`CreateFile2`]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfile2
- /// [Impersonation Levels]:
- /// https://docs.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-security_impersonation_level
- #[stable(feature = "open_options_ext", since = "1.10.0")]
- fn security_qos_flags(&mut self, flags: u32) -> &mut Self;
-}
-
-#[stable(feature = "open_options_ext", since = "1.10.0")]
-impl OpenOptionsExt for OpenOptions {
- fn access_mode(&mut self, access: u32) -> &mut OpenOptions {
- self.as_inner_mut().access_mode(access);
- self
- }
-
- fn share_mode(&mut self, share: u32) -> &mut OpenOptions {
- self.as_inner_mut().share_mode(share);
- self
- }
-
- fn custom_flags(&mut self, flags: u32) -> &mut OpenOptions {
- self.as_inner_mut().custom_flags(flags);
- self
- }
-
- fn attributes(&mut self, attributes: u32) -> &mut OpenOptions {
- self.as_inner_mut().attributes(attributes);
- self
- }
-
- fn security_qos_flags(&mut self, flags: u32) -> &mut OpenOptions {
- self.as_inner_mut().security_qos_flags(flags);
- self
- }
-}
-
-/// Windows-specific extensions to [`fs::Metadata`].
-///
-/// The data members that this trait exposes correspond to the members
-/// of the [`BY_HANDLE_FILE_INFORMATION`] structure.
-///
-/// [`BY_HANDLE_FILE_INFORMATION`]:
-/// https://docs.microsoft.com/en-us/windows/win32/api/fileapi/ns-fileapi-by_handle_file_information
-#[stable(feature = "metadata_ext", since = "1.1.0")]
-pub trait MetadataExt {
- /// Returns the value of the `dwFileAttributes` field of this metadata.
- ///
- /// This field contains the file system attribute information for a file
- /// or directory. For possible values and their descriptions, see
- /// [File Attribute Constants] in the Windows Dev Center.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::io;
- /// use std::fs;
- /// use std::os::windows::prelude::*;
- ///
- /// fn main() -> io::Result<()> {
- /// let metadata = fs::metadata("foo.txt")?;
- /// let attributes = metadata.file_attributes();
- /// Ok(())
- /// }
- /// ```
- ///
- /// [File Attribute Constants]:
- /// https://docs.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn file_attributes(&self) -> u32;
-
- /// Returns the value of the `ftCreationTime` field of this metadata.
- ///
- /// The returned 64-bit value is equivalent to a [`FILETIME`] struct,
- /// which represents the number of 100-nanosecond intervals since
- /// January 1, 1601 (UTC). The struct is automatically
- /// converted to a `u64` value, as that is the recommended way
- /// to use it.
- ///
- /// If the underlying filesystem does not support creation time, the
- /// returned value is 0.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::io;
- /// use std::fs;
- /// use std::os::windows::prelude::*;
- ///
- /// fn main() -> io::Result<()> {
- /// let metadata = fs::metadata("foo.txt")?;
- /// let creation_time = metadata.creation_time();
- /// Ok(())
- /// }
- /// ```
- ///
- /// [`FILETIME`]: https://docs.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-filetime
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn creation_time(&self) -> u64;
-
- /// Returns the value of the `ftLastAccessTime` field of this metadata.
- ///
- /// The returned 64-bit value is equivalent to a [`FILETIME`] struct,
- /// which represents the number of 100-nanosecond intervals since
- /// January 1, 1601 (UTC). The struct is automatically
- /// converted to a `u64` value, as that is the recommended way
- /// to use it.
- ///
- /// For a file, the value specifies the last time that a file was read
- /// from or written to. For a directory, the value specifies when
- /// the directory was created. For both files and directories, the
- /// specified date is correct, but the time of day is always set to
- /// midnight.
- ///
- /// If the underlying filesystem does not support last access time, the
- /// returned value is 0.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::io;
- /// use std::fs;
- /// use std::os::windows::prelude::*;
- ///
- /// fn main() -> io::Result<()> {
- /// let metadata = fs::metadata("foo.txt")?;
- /// let last_access_time = metadata.last_access_time();
- /// Ok(())
- /// }
- /// ```
- ///
- /// [`FILETIME`]: https://docs.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-filetime
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn last_access_time(&self) -> u64;
-
- /// Returns the value of the `ftLastWriteTime` field of this metadata.
- ///
- /// The returned 64-bit value is equivalent to a [`FILETIME`] struct,
- /// which represents the number of 100-nanosecond intervals since
- /// January 1, 1601 (UTC). The struct is automatically
- /// converted to a `u64` value, as that is the recommended way
- /// to use it.
- ///
- /// For a file, the value specifies the last time that a file was written
- /// to. For a directory, the structure specifies when the directory was
- /// created.
- ///
- /// If the underlying filesystem does not support the last write time,
- /// the returned value is 0.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::io;
- /// use std::fs;
- /// use std::os::windows::prelude::*;
- ///
- /// fn main() -> io::Result<()> {
- /// let metadata = fs::metadata("foo.txt")?;
- /// let last_write_time = metadata.last_write_time();
- /// Ok(())
- /// }
- /// ```
- ///
- /// [`FILETIME`]: https://docs.microsoft.com/en-us/windows/win32/api/minwinbase/ns-minwinbase-filetime
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn last_write_time(&self) -> u64;
-
- /// Returns the value of the `nFileSize{High,Low}` fields of this
- /// metadata.
- ///
- /// The returned value does not have meaning for directories.
- ///
- /// # Examples
- ///
- /// ```no_run
- /// use std::io;
- /// use std::fs;
- /// use std::os::windows::prelude::*;
- ///
- /// fn main() -> io::Result<()> {
- /// let metadata = fs::metadata("foo.txt")?;
- /// let file_size = metadata.file_size();
- /// Ok(())
- /// }
- /// ```
- #[stable(feature = "metadata_ext", since = "1.1.0")]
- fn file_size(&self) -> u64;
-
- /// Returns the value of the `dwVolumeSerialNumber` field of this
- /// metadata.
- ///
- /// This will return `None` if the `Metadata` instance was created from a
- /// call to `DirEntry::metadata`. If this `Metadata` was created by using
- /// `fs::metadata` or `File::metadata`, then this will return `Some`.
- #[unstable(feature = "windows_by_handle", issue = "63010")]
- fn volume_serial_number(&self) -> Option<u32>;
-
- /// Returns the value of the `nNumberOfLinks` field of this
- /// metadata.
- ///
- /// This will return `None` if the `Metadata` instance was created from a
- /// call to `DirEntry::metadata`. If this `Metadata` was created by using
- /// `fs::metadata` or `File::metadata`, then this will return `Some`.
- #[unstable(feature = "windows_by_handle", issue = "63010")]
- fn number_of_links(&self) -> Option<u32>;
-
- /// Returns the value of the `nFileIndex{Low,High}` fields of this
- /// metadata.
- ///
- /// This will return `None` if the `Metadata` instance was created from a
- /// call to `DirEntry::metadata`. If this `Metadata` was created by using
- /// `fs::metadata` or `File::metadata`, then this will return `Some`.
- #[unstable(feature = "windows_by_handle", issue = "63010")]
- fn file_index(&self) -> Option<u64>;
-}
-
-#[stable(feature = "metadata_ext", since = "1.1.0")]
-impl MetadataExt for Metadata {
- fn file_attributes(&self) -> u32 {
- self.as_inner().attrs()
- }
- fn creation_time(&self) -> u64 {
- self.as_inner().created_u64()
- }
- fn last_access_time(&self) -> u64 {
- self.as_inner().accessed_u64()
- }
- fn last_write_time(&self) -> u64 {
- self.as_inner().modified_u64()
- }
- fn file_size(&self) -> u64 {
- self.as_inner().size()
- }
- fn volume_serial_number(&self) -> Option<u32> {
- self.as_inner().volume_serial_number()
- }
- fn number_of_links(&self) -> Option<u32> {
- self.as_inner().number_of_links()
- }
- fn file_index(&self) -> Option<u64> {
- self.as_inner().file_index()
- }
-}
-
-/// Windows-specific extensions to [`fs::FileType`].
-///
-/// On Windows, a symbolic link knows whether it is a file or directory.
-#[unstable(feature = "windows_file_type_ext", issue = "none")]
-pub trait FileTypeExt {
- /// Returns `true` if this file type is a symbolic link that is also a directory.
- #[unstable(feature = "windows_file_type_ext", issue = "none")]
- fn is_symlink_dir(&self) -> bool;
- /// Returns `true` if this file type is a symbolic link that is also a file.
- #[unstable(feature = "windows_file_type_ext", issue = "none")]
- fn is_symlink_file(&self) -> bool;
-}
-
-#[unstable(feature = "windows_file_type_ext", issue = "none")]
-impl FileTypeExt for fs::FileType {
- fn is_symlink_dir(&self) -> bool {
- self.as_inner().is_symlink_dir()
- }
- fn is_symlink_file(&self) -> bool {
- self.as_inner().is_symlink_file()
- }
-}
-
-/// Creates a new file symbolic link on the filesystem.
-///
-/// The `link` path will be a file symbolic link pointing to the `original`
-/// path.
-///
-/// # Examples
-///
-/// ```no_run
-/// use std::os::windows::fs;
-///
-/// fn main() -> std::io::Result<()> {
-/// fs::symlink_file("a.txt", "b.txt")?;
-/// Ok(())
-/// }
-/// ```
-#[stable(feature = "symlink", since = "1.1.0")]
-pub fn symlink_file<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Result<()> {
- sys::fs::symlink_inner(original.as_ref(), link.as_ref(), false)
-}
-
-/// Creates a new directory symlink on the filesystem.
-///
-/// The `link` path will be a directory symbolic link pointing to the `original`
-/// path.
-///
-/// # Examples
-///
-/// ```no_run
-/// use std::os::windows::fs;
-///
-/// fn main() -> std::io::Result<()> {
-/// fs::symlink_dir("a", "b")?;
-/// Ok(())
-/// }
-/// ```
-#[stable(feature = "symlink", since = "1.1.0")]
-pub fn symlink_dir<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Result<()> {
- sys::fs::symlink_inner(original.as_ref(), link.as_ref(), true)
-}
+++ /dev/null
-//! Windows-specific extensions to general I/O primitives.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-use crate::fs;
-use crate::io;
-use crate::net;
-use crate::os::windows::raw;
-use crate::sys;
-use crate::sys::c;
-use crate::sys_common::{self, AsInner, FromInner, IntoInner};
-
-/// Raw HANDLEs.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub type RawHandle = raw::HANDLE;
-
-/// Raw SOCKETs.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub type RawSocket = raw::SOCKET;
-
-/// Extracts raw handles.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub trait AsRawHandle {
- /// Extracts the raw handle, without taking any ownership.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn as_raw_handle(&self) -> RawHandle;
-}
-
-/// Construct I/O objects from raw handles.
-#[stable(feature = "from_raw_os", since = "1.1.0")]
-pub trait FromRawHandle {
- /// Constructs a new I/O object from the specified raw handle.
- ///
- /// This function will **consume ownership** of the handle given,
- /// passing responsibility for closing the handle to the returned
- /// object.
- ///
- /// This function is also unsafe as the primitives currently returned
- /// have the contract that they are the sole owner of the file
- /// descriptor they are wrapping. Usage of this function could
- /// accidentally allow violating this contract which can cause memory
- /// unsafety in code that relies on it being true.
- #[stable(feature = "from_raw_os", since = "1.1.0")]
- unsafe fn from_raw_handle(handle: RawHandle) -> Self;
-}
-
-/// A trait to express the ability to consume an object and acquire ownership of
-/// its raw `HANDLE`.
-#[stable(feature = "into_raw_os", since = "1.4.0")]
-pub trait IntoRawHandle {
- /// Consumes this object, returning the raw underlying handle.
- ///
- /// This function **transfers ownership** of the underlying handle to the
- /// caller. Callers are then the unique owners of the handle and must close
- /// it once it's no longer needed.
- #[stable(feature = "into_raw_os", since = "1.4.0")]
- fn into_raw_handle(self) -> RawHandle;
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl AsRawHandle for fs::File {
- #[inline]
- fn as_raw_handle(&self) -> RawHandle {
- self.as_inner().handle().raw() as RawHandle
- }
-}
-
-#[stable(feature = "asraw_stdio", since = "1.21.0")]
-impl AsRawHandle for io::Stdin {
- fn as_raw_handle(&self) -> RawHandle {
- unsafe { c::GetStdHandle(c::STD_INPUT_HANDLE) as RawHandle }
- }
-}
-
-#[stable(feature = "asraw_stdio", since = "1.21.0")]
-impl AsRawHandle for io::Stdout {
- fn as_raw_handle(&self) -> RawHandle {
- unsafe { c::GetStdHandle(c::STD_OUTPUT_HANDLE) as RawHandle }
- }
-}
-
-#[stable(feature = "asraw_stdio", since = "1.21.0")]
-impl AsRawHandle for io::Stderr {
- fn as_raw_handle(&self) -> RawHandle {
- unsafe { c::GetStdHandle(c::STD_ERROR_HANDLE) as RawHandle }
- }
-}
-
-#[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
-impl<'a> AsRawHandle for io::StdinLock<'a> {
- fn as_raw_handle(&self) -> RawHandle {
- unsafe { c::GetStdHandle(c::STD_INPUT_HANDLE) as RawHandle }
- }
-}
-
-#[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
-impl<'a> AsRawHandle for io::StdoutLock<'a> {
- fn as_raw_handle(&self) -> RawHandle {
- unsafe { c::GetStdHandle(c::STD_OUTPUT_HANDLE) as RawHandle }
- }
-}
-
-#[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
-impl<'a> AsRawHandle for io::StderrLock<'a> {
- fn as_raw_handle(&self) -> RawHandle {
- unsafe { c::GetStdHandle(c::STD_ERROR_HANDLE) as RawHandle }
- }
-}
-
-#[stable(feature = "from_raw_os", since = "1.1.0")]
-impl FromRawHandle for fs::File {
- #[inline]
- unsafe fn from_raw_handle(handle: RawHandle) -> fs::File {
- let handle = handle as c::HANDLE;
- fs::File::from_inner(sys::fs::File::from_inner(handle))
- }
-}
-
-#[stable(feature = "into_raw_os", since = "1.4.0")]
-impl IntoRawHandle for fs::File {
- #[inline]
- fn into_raw_handle(self) -> RawHandle {
- self.into_inner().into_handle().into_raw() as *mut _
- }
-}
-
-/// Extracts raw sockets.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub trait AsRawSocket {
- /// Extracts the underlying raw socket from this object.
- #[stable(feature = "rust1", since = "1.0.0")]
- fn as_raw_socket(&self) -> RawSocket;
-}
-
-/// Creates I/O objects from raw sockets.
-#[stable(feature = "from_raw_os", since = "1.1.0")]
-pub trait FromRawSocket {
- /// Creates a new I/O object from the given raw socket.
- ///
- /// This function will **consume ownership** of the socket provided and
- /// it will be closed when the returned object goes out of scope.
- ///
- /// This function is also unsafe as the primitives currently returned
- /// have the contract that they are the sole owner of the file
- /// descriptor they are wrapping. Usage of this function could
- /// accidentally allow violating this contract which can cause memory
- /// unsafety in code that relies on it being true.
- #[stable(feature = "from_raw_os", since = "1.1.0")]
- unsafe fn from_raw_socket(sock: RawSocket) -> Self;
-}
-
-/// A trait to express the ability to consume an object and acquire ownership of
-/// its raw `SOCKET`.
-#[stable(feature = "into_raw_os", since = "1.4.0")]
-pub trait IntoRawSocket {
- /// Consumes this object, returning the raw underlying socket.
- ///
- /// This function **transfers ownership** of the underlying socket to the
- /// caller. Callers are then the unique owners of the socket and must close
- /// it once it's no longer needed.
- #[stable(feature = "into_raw_os", since = "1.4.0")]
- fn into_raw_socket(self) -> RawSocket;
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl AsRawSocket for net::TcpStream {
- #[inline]
- fn as_raw_socket(&self) -> RawSocket {
- *self.as_inner().socket().as_inner()
- }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl AsRawSocket for net::TcpListener {
- #[inline]
- fn as_raw_socket(&self) -> RawSocket {
- *self.as_inner().socket().as_inner()
- }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl AsRawSocket for net::UdpSocket {
- #[inline]
- fn as_raw_socket(&self) -> RawSocket {
- *self.as_inner().socket().as_inner()
- }
-}
-
-#[stable(feature = "from_raw_os", since = "1.1.0")]
-impl FromRawSocket for net::TcpStream {
- #[inline]
- unsafe fn from_raw_socket(sock: RawSocket) -> net::TcpStream {
- let sock = sys::net::Socket::from_inner(sock);
- net::TcpStream::from_inner(sys_common::net::TcpStream::from_inner(sock))
- }
-}
-#[stable(feature = "from_raw_os", since = "1.1.0")]
-impl FromRawSocket for net::TcpListener {
- #[inline]
- unsafe fn from_raw_socket(sock: RawSocket) -> net::TcpListener {
- let sock = sys::net::Socket::from_inner(sock);
- net::TcpListener::from_inner(sys_common::net::TcpListener::from_inner(sock))
- }
-}
-#[stable(feature = "from_raw_os", since = "1.1.0")]
-impl FromRawSocket for net::UdpSocket {
- #[inline]
- unsafe fn from_raw_socket(sock: RawSocket) -> net::UdpSocket {
- let sock = sys::net::Socket::from_inner(sock);
- net::UdpSocket::from_inner(sys_common::net::UdpSocket::from_inner(sock))
- }
-}
-
-#[stable(feature = "into_raw_os", since = "1.4.0")]
-impl IntoRawSocket for net::TcpStream {
- #[inline]
- fn into_raw_socket(self) -> RawSocket {
- self.into_inner().into_socket().into_inner()
- }
-}
-
-#[stable(feature = "into_raw_os", since = "1.4.0")]
-impl IntoRawSocket for net::TcpListener {
- #[inline]
- fn into_raw_socket(self) -> RawSocket {
- self.into_inner().into_socket().into_inner()
- }
-}
-
-#[stable(feature = "into_raw_os", since = "1.4.0")]
-impl IntoRawSocket for net::UdpSocket {
- #[inline]
- fn into_raw_socket(self) -> RawSocket {
- self.into_inner().into_socket().into_inner()
- }
-}
+++ /dev/null
-//! Platform-specific extensions to `std` for Windows.
-//!
-//! Provides access to platform-level information for Windows, and exposes
-//! Windows-specific idioms that would otherwise be inappropriate as part
-//! the core `std` library. These extensions allow developers to use
-//! `std` types and idioms with Windows in a way that the normal
-//! platform-agnostic idioms would not normally support.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-#![doc(cfg(windows))]
-#![allow(missing_docs)]
-
-pub mod ffi;
-pub mod fs;
-pub mod io;
-pub mod process;
-pub mod raw;
-pub mod thread;
-
-/// A prelude for conveniently writing platform-specific code.
-///
-/// Includes all extension traits, and some important type definitions.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub mod prelude {
- #[doc(no_inline)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use super::ffi::{OsStrExt, OsStringExt};
- #[doc(no_inline)]
- #[stable(feature = "file_offset", since = "1.15.0")]
- pub use super::fs::FileExt;
- #[doc(no_inline)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use super::fs::{MetadataExt, OpenOptionsExt};
- #[doc(no_inline)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use super::io::{AsRawHandle, AsRawSocket, RawHandle, RawSocket};
- #[doc(no_inline)]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub use super::io::{FromRawHandle, FromRawSocket, IntoRawHandle, IntoRawSocket};
-}
+++ /dev/null
-//! Extensions to `std::process` for Windows.
-
-#![stable(feature = "process_extensions", since = "1.2.0")]
-
-use crate::os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle};
-use crate::process;
-use crate::sealed::Sealed;
-use crate::sys;
-use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
-
-#[stable(feature = "process_extensions", since = "1.2.0")]
-impl FromRawHandle for process::Stdio {
- unsafe fn from_raw_handle(handle: RawHandle) -> process::Stdio {
- let handle = sys::handle::Handle::new(handle as *mut _);
- let io = sys::process::Stdio::Handle(handle);
- process::Stdio::from_inner(io)
- }
-}
-
-#[stable(feature = "process_extensions", since = "1.2.0")]
-impl AsRawHandle for process::Child {
- #[inline]
- fn as_raw_handle(&self) -> RawHandle {
- self.as_inner().handle().raw() as *mut _
- }
-}
-
-#[stable(feature = "into_raw_os", since = "1.4.0")]
-impl IntoRawHandle for process::Child {
- fn into_raw_handle(self) -> RawHandle {
- self.into_inner().into_handle().into_raw() as *mut _
- }
-}
-
-#[stable(feature = "process_extensions", since = "1.2.0")]
-impl AsRawHandle for process::ChildStdin {
- #[inline]
- fn as_raw_handle(&self) -> RawHandle {
- self.as_inner().handle().raw() as *mut _
- }
-}
-
-#[stable(feature = "process_extensions", since = "1.2.0")]
-impl AsRawHandle for process::ChildStdout {
- #[inline]
- fn as_raw_handle(&self) -> RawHandle {
- self.as_inner().handle().raw() as *mut _
- }
-}
-
-#[stable(feature = "process_extensions", since = "1.2.0")]
-impl AsRawHandle for process::ChildStderr {
- #[inline]
- fn as_raw_handle(&self) -> RawHandle {
- self.as_inner().handle().raw() as *mut _
- }
-}
-
-#[stable(feature = "into_raw_os", since = "1.4.0")]
-impl IntoRawHandle for process::ChildStdin {
- fn into_raw_handle(self) -> RawHandle {
- self.into_inner().into_handle().into_raw() as *mut _
- }
-}
-
-#[stable(feature = "into_raw_os", since = "1.4.0")]
-impl IntoRawHandle for process::ChildStdout {
- fn into_raw_handle(self) -> RawHandle {
- self.into_inner().into_handle().into_raw() as *mut _
- }
-}
-
-#[stable(feature = "into_raw_os", since = "1.4.0")]
-impl IntoRawHandle for process::ChildStderr {
- fn into_raw_handle(self) -> RawHandle {
- self.into_inner().into_handle().into_raw() as *mut _
- }
-}
-
-/// Windows-specific extensions to [`process::ExitStatus`].
-///
-/// This trait is sealed: it cannot be implemented outside the standard library.
-/// This is so that future additional methods are not breaking changes.
-#[stable(feature = "exit_status_from", since = "1.12.0")]
-pub trait ExitStatusExt: Sealed {
- /// Creates a new `ExitStatus` from the raw underlying `u32` return value of
- /// a process.
- #[stable(feature = "exit_status_from", since = "1.12.0")]
- fn from_raw(raw: u32) -> Self;
-}
-
-#[stable(feature = "exit_status_from", since = "1.12.0")]
-impl ExitStatusExt for process::ExitStatus {
- fn from_raw(raw: u32) -> Self {
- process::ExitStatus::from_inner(From::from(raw))
- }
-}
-
-/// Windows-specific extensions to the [`process::Command`] builder.
-///
-/// This trait is sealed: it cannot be implemented outside the standard library.
-/// This is so that future additional methods are not breaking changes.
-#[stable(feature = "windows_process_extensions", since = "1.16.0")]
-pub trait CommandExt: Sealed {
- /// Sets the [process creation flags][1] to be passed to `CreateProcess`.
- ///
- /// These will always be ORed with `CREATE_UNICODE_ENVIRONMENT`.
- ///
- /// [1]: https://docs.microsoft.com/en-us/windows/win32/procthread/process-creation-flags
- #[stable(feature = "windows_process_extensions", since = "1.16.0")]
- fn creation_flags(&mut self, flags: u32) -> &mut process::Command;
-
- /// Forces all arguments to be wrapped in quote (`"`) characters.
- ///
- /// This is useful for passing arguments to [MSYS2/Cygwin][1] based
- /// executables: these programs will expand unquoted arguments containing
- /// wildcard characters (`?` and `*`) by searching for any file paths
- /// matching the wildcard pattern.
- ///
- /// Adding quotes has no effect when passing arguments to programs
- /// that use [msvcrt][2]. This includes programs built with both
- /// MinGW and MSVC.
- ///
- /// [1]: <https://github.com/msys2/MSYS2-packages/issues/2176>
- /// [2]: <https://msdn.microsoft.com/en-us/library/17w5ykft.aspx>
- #[unstable(feature = "windows_process_extensions_force_quotes", issue = "82227")]
- fn force_quotes(&mut self, enabled: bool) -> &mut process::Command;
-}
-
-#[stable(feature = "windows_process_extensions", since = "1.16.0")]
-impl CommandExt for process::Command {
- fn creation_flags(&mut self, flags: u32) -> &mut process::Command {
- self.as_inner_mut().creation_flags(flags);
- self
- }
-
- fn force_quotes(&mut self, enabled: bool) -> &mut process::Command {
- self.as_inner_mut().force_quotes(enabled);
- self
- }
-}
+++ /dev/null
-//! Windows-specific primitives.
-
-#![stable(feature = "raw_ext", since = "1.1.0")]
-
-use crate::os::raw::c_void;
-
-#[stable(feature = "raw_ext", since = "1.1.0")]
-pub type HANDLE = *mut c_void;
-#[cfg(target_pointer_width = "32")]
-#[stable(feature = "raw_ext", since = "1.1.0")]
-pub type SOCKET = u32;
-#[cfg(target_pointer_width = "64")]
-#[stable(feature = "raw_ext", since = "1.1.0")]
-pub type SOCKET = u64;
+++ /dev/null
-//! Extensions to `std::thread` for Windows.
-
-#![stable(feature = "thread_extensions", since = "1.9.0")]
-
-use crate::os::windows::io::{AsRawHandle, IntoRawHandle, RawHandle};
-use crate::sys_common::{AsInner, IntoInner};
-use crate::thread;
-
-#[stable(feature = "thread_extensions", since = "1.9.0")]
-impl<T> AsRawHandle for thread::JoinHandle<T> {
- #[inline]
- fn as_raw_handle(&self) -> RawHandle {
- self.as_inner().handle().raw() as *mut _
- }
-}
-
-#[stable(feature = "thread_extensions", since = "1.9.0")]
-impl<T> IntoRawHandle for thread::JoinHandle<T> {
- #[inline]
- fn into_raw_handle(self) -> RawHandle {
- self.into_inner().into_handle().into_raw() as *mut _
- }
-}
pub mod cmath;
pub mod condvar;
pub mod env;
-pub mod ext;
pub mod fs;
pub mod handle;
pub mod io;
c::ERROR_PATH_NOT_FOUND => return ErrorKind::NotFound,
c::ERROR_NO_DATA => return ErrorKind::BrokenPipe,
c::ERROR_INVALID_PARAMETER => return ErrorKind::InvalidInput,
+ c::ERROR_NOT_ENOUGH_MEMORY | c::ERROR_OUTOFMEMORY => return ErrorKind::OutOfMemory,
c::ERROR_SEM_TIMEOUT
| c::WAIT_TIMEOUT
| c::ERROR_DRIVER_CANCEL_TIMEOUT
unsafe extern "C" fn destroy_value<T: 'static>(ptr: *mut u8) {
// SAFETY:
//
- // The OS TLS ensures that this key contains a NULL value when this
+ // The OS TLS ensures that this key contains a null value when this
// destructor starts to run. We set it back to a sentinel value of 1 to
// ensure that any future calls to `get` for this thread will return
// `None`.
use crate::cell::{Cell, UnsafeCell};
+use crate::sync::atomic::{AtomicU8, Ordering};
use crate::sync::mpsc::{channel, Sender};
use crate::thread::{self, LocalKey};
use crate::thread_local;
});
rx.recv().unwrap();
}
+
+// This test tests that TLS destructors have run before the thread joins. The
+// test has no false positives (meaning: if the test fails, there's actually
+// an ordering problem). It may have false negatives, where the test passes but
+// join is not guaranteed to be after the TLS destructors. However, false
+// negatives should be exceedingly rare due to judicious use of
+// thread::yield_now and running the test several times.
+#[test]
+fn join_orders_after_tls_destructors() {
+ // We emulate a synchronous MPSC rendezvous channel using only atomics and
+ // thread::yield_now. We can't use std::mpsc as the implementation itself
+ // may rely on thread locals.
+ //
+ // The basic state machine for an SPSC rendezvous channel is:
+ // FRESH -> THREAD1_WAITING -> MAIN_THREAD_RENDEZVOUS
+ // where the first transition is done by the “receiving” thread and the 2nd
+ // transition is done by the “sending” thread.
+ //
+ // We add an additional state `THREAD2_LAUNCHED` between `FRESH` and
+ // `THREAD1_WAITING` to block until all threads are actually running.
+ //
+ // A thread that joins on the “receiving” thread completion should never
+ // observe the channel in the `THREAD1_WAITING` state. If this does occur,
+ // we switch to the “poison” state `THREAD2_JOINED` and panic all around.
+ // (This is equivalent to “sending” from an alternate producer thread.)
+ const FRESH: u8 = 0;
+ const THREAD2_LAUNCHED: u8 = 1;
+ const THREAD1_WAITING: u8 = 2;
+ const MAIN_THREAD_RENDEZVOUS: u8 = 3;
+ const THREAD2_JOINED: u8 = 4;
+ static SYNC_STATE: AtomicU8 = AtomicU8::new(FRESH);
+
+ for _ in 0..10 {
+ SYNC_STATE.store(FRESH, Ordering::SeqCst);
+
+ let jh = thread::Builder::new()
+ .name("thread1".into())
+ .spawn(move || {
+ struct TlDrop;
+
+ impl Drop for TlDrop {
+ fn drop(&mut self) {
+ let mut sync_state = SYNC_STATE.swap(THREAD1_WAITING, Ordering::SeqCst);
+ loop {
+ match sync_state {
+ THREAD2_LAUNCHED | THREAD1_WAITING => thread::yield_now(),
+ MAIN_THREAD_RENDEZVOUS => break,
+ THREAD2_JOINED => panic!(
+ "Thread 1 still running after thread 2 joined on thread 1"
+ ),
+ v => unreachable!("sync state: {}", v),
+ }
+ sync_state = SYNC_STATE.load(Ordering::SeqCst);
+ }
+ }
+ }
+
+ thread_local! {
+ static TL_DROP: TlDrop = TlDrop;
+ }
+
+ TL_DROP.with(|_| {});
+
+ loop {
+ match SYNC_STATE.load(Ordering::SeqCst) {
+ FRESH => thread::yield_now(),
+ THREAD2_LAUNCHED => break,
+ v => unreachable!("sync state: {}", v),
+ }
+ }
+ })
+ .unwrap();
+
+ let jh2 = thread::Builder::new()
+ .name("thread2".into())
+ .spawn(move || {
+ assert_eq!(SYNC_STATE.swap(THREAD2_LAUNCHED, Ordering::SeqCst), FRESH);
+ jh.join().unwrap();
+ match SYNC_STATE.swap(THREAD2_JOINED, Ordering::SeqCst) {
+ MAIN_THREAD_RENDEZVOUS => return,
+ THREAD2_LAUNCHED | THREAD1_WAITING => {
+ panic!("Thread 2 running after thread 1 join before main thread rendezvous")
+ }
+ v => unreachable!("sync state: {:?}", v),
+ }
+ })
+ .unwrap();
+
+ loop {
+ match SYNC_STATE.compare_exchange_weak(
+ THREAD1_WAITING,
+ MAIN_THREAD_RENDEZVOUS,
+ Ordering::SeqCst,
+ Ordering::SeqCst,
+ ) {
+ Ok(_) => break,
+ Err(FRESH) => thread::yield_now(),
+ Err(THREAD2_LAUNCHED) => thread::yield_now(),
+ Err(THREAD2_JOINED) => {
+ panic!("Main thread rendezvous after thread 2 joined thread 1")
+ }
+ v => unreachable!("sync state: {:?}", v),
+ }
+ }
+ jh2.join().unwrap();
+ }
+}
filename = "rustc-{}-{}{}".format(rustc_channel, self.build,
tarball_suffix)
self._download_component_helper(filename, "rustc", tarball_suffix, stage0)
- filename = "cargo-{}-{}{}".format(rustc_channel, self.build,
- tarball_suffix)
- self._download_component_helper(filename, "cargo", tarball_suffix)
- if not stage0:
+ # download-rustc doesn't need its own cargo, it can just use beta's.
+ if stage0:
+ filename = "cargo-{}-{}{}".format(rustc_channel, self.build,
+ tarball_suffix)
+ self._download_component_helper(filename, "cargo", tarball_suffix)
+ self.fix_bin_or_dylib("{}/bin/cargo".format(bin_root))
+ else:
filename = "rustc-dev-{}-{}{}".format(rustc_channel, self.build, tarball_suffix)
self._download_component_helper(
filename, "rustc-dev", tarball_suffix, stage0
self.fix_bin_or_dylib("{}/bin/rustc".format(bin_root))
self.fix_bin_or_dylib("{}/bin/rustdoc".format(bin_root))
- self.fix_bin_or_dylib("{}/bin/cargo".format(bin_root))
lib_dir = "{}/lib".format(bin_root)
for lib in os.listdir(lib_dir):
if lib.endswith(".so"):
pub fn add_rustc_lib_path(&mut self, builder: &Builder<'_>, compiler: Compiler) {
builder.add_rustc_lib_path(compiler, &mut self.command);
}
+
+ pub fn current_dir(&mut self, dir: &Path) -> &mut Cargo {
+ self.command.current_dir(dir);
+ self
+ }
}
impl From<Cargo> for Command {
compare_mode: None,
rustfix_coverage: false,
pass: None,
+ run: None,
};
let build = Build::new(config);
compare_mode: None,
rustfix_coverage: false,
pass: None,
+ run: None,
};
let build = Build::new(config);
compare_mode: None,
rustfix_coverage: false,
pass: None,
+ run: None,
};
// Make sure rustfmt binary not being found isn't an error.
config.channel = "beta".to_string();
}
macro_rules! tool_check_step {
- ($name:ident, $path:literal, $($alias:literal, )* $source_type:path) => {
+ ($name:ident, $path:literal, $($alias:literal, )* $source_type:path $(, $default:literal )?) => {
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct $name {
pub target: TargetSelection,
impl Step for $name {
type Output = ();
const ONLY_HOSTS: bool = true;
- const DEFAULT: bool = true;
+ const DEFAULT: bool = true $( && $default )?;
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
run.paths(&[ $path, $($alias),* ])
// rejected.
tool_check_step!(Clippy, "src/tools/clippy", SourceType::InTree);
-tool_check_step!(Bootstrap, "src/bootstrap", SourceType::InTree);
+tool_check_step!(Bootstrap, "src/bootstrap", SourceType::InTree, false);
/// Cargo's output path for the standard library in a given stage, compiled
/// by a particular compiler for the specified target.
bless: bool,
compare_mode: Option<String>,
pass: Option<String>,
+ run: Option<String>,
test_args: Vec<String>,
rustc_args: Vec<String>,
fail_fast: bool,
VALUE overrides the skip-rebuild option in config.toml.",
"VALUE",
);
- opts.optopt("", "rust-profile-generate", "rustc error format", "FORMAT");
- opts.optopt("", "rust-profile-use", "rustc error format", "FORMAT");
+ opts.optopt("", "rust-profile-generate", "generate PGO profile with rustc build", "FORMAT");
+ opts.optopt("", "rust-profile-use", "use PGO profile for rustc build", "FORMAT");
// We can't use getopt to parse the options until we have completed specifying which
// options are valid, but under the current implementation, some options are conditional on
"force {check,build,run}-pass tests to this mode.",
"check | build | run",
);
+ opts.optopt("", "run", "whether to execute run-* tests", "auto | always | never");
opts.optflag(
"",
"rustfix-coverage",
bless: matches.opt_present("bless"),
compare_mode: matches.opt_str("compare-mode"),
pass: matches.opt_str("pass"),
+ run: matches.opt_str("run"),
test_args: matches.opt_strs("test-args"),
rustc_args: matches.opt_strs("rustc-args"),
fail_fast: !matches.opt_present("no-fail-fast"),
}
}
+ pub fn run(&self) -> Option<&str> {
+ match *self {
+ Subcommand::Test { ref run, .. } => run.as_ref().map(|s| &s[..]),
+ _ => None,
+ }
+ }
+
pub fn open(&self) -> bool {
match *self {
Subcommand::Doc { open, .. } => open,
builder,
cmd.arg(&cargo)
.arg(&out_dir)
+ .args(builder.config.cmd.test_args())
.env("RUSTC", builder.rustc(compiler))
.env("RUSTDOC", builder.rustdoc(compiler)),
);
cargo.add_rustc_lib_path(builder, compiler);
+ if builder.try_run(&mut cargo.into()) {
+ // The tests succeeded; nothing to do.
+ return;
+ }
+
+ if !builder.config.cmd.bless() {
+ std::process::exit(1);
+ }
+
+ let mut cargo = builder.cargo(compiler, Mode::ToolRustc, SourceType::InTree, host, "run");
+ cargo.arg("-p").arg("clippy_dev");
+ // clippy_dev gets confused if it can't find `clippy/Cargo.toml`
+ cargo.current_dir(&builder.src.join("src").join("tools").join("clippy"));
+ if builder.config.rust_optimize {
+ cargo.env("PROFILE", "release");
+ } else {
+ cargo.env("PROFILE", "debug");
+ }
+ cargo.arg("--");
+ cargo.arg("bless");
builder.run(&mut cargo.into());
}
}
command.arg("src/test/rustdoc-gui/lib.rs").arg("-o").arg(&out_dir);
builder.run(&mut command);
+ let mut tests = Vec::new();
for file in fs::read_dir("src/test/rustdoc-gui").unwrap() {
let file = file.unwrap();
let file_path = file.path();
if !file_name.to_str().unwrap().ends_with(".goml") {
continue;
}
+ tests.push(file_path);
+ }
+ tests.sort_unstable();
+ for test in tests {
let mut command = Command::new(&nodejs);
command
.arg("src/tools/rustdoc-gui/tester.js")
.arg("--doc-folder")
.arg(out_dir.join("test_docs"))
.arg("--test-file")
- .arg(file_path);
+ .arg(test);
builder.run(&mut command);
}
} else {
compare_mode: Option<&'static str>,
}
+impl Compiletest {
+ fn add_lld_flags(builder: &Builder<'_>, target: TargetSelection, flags: &mut Vec<String>) {
+ if builder.config.use_lld {
+ if builder.is_fuse_ld_lld(target) {
+ flags.push("-Clink-arg=-fuse-ld=lld".to_string());
+ }
+
+ let threads = if target.contains("windows") { "/threads:1" } else { "--threads=1" };
+ flags.push(format!("-Clink-arg=-Wl,{}", threads));
+ }
+ }
+}
+
impl Step for Compiletest {
type Output = ();
cmd.arg(pass);
}
+ if let Some(ref run) = builder.config.cmd.run() {
+ cmd.arg("--run");
+ cmd.arg(run);
+ }
+
if let Some(ref nodejs) = builder.config.nodejs {
cmd.arg("--nodejs").arg(nodejs);
}
let mut hostflags = flags.clone();
hostflags.push(format!("-Lnative={}", builder.test_helpers_out(compiler.host).display()));
- if builder.is_fuse_ld_lld(compiler.host) {
- hostflags.push("-Clink-args=-fuse-ld=lld".to_string());
- hostflags.push("-Clink-arg=-Wl,--threads=1".to_string());
- }
+ Self::add_lld_flags(builder, compiler.host, &mut hostflags);
cmd.arg("--host-rustcflags").arg(hostflags.join(" "));
let mut targetflags = flags;
targetflags.push(format!("-Lnative={}", builder.test_helpers_out(target).display()));
- if builder.is_fuse_ld_lld(target) {
- targetflags.push("-Clink-args=-fuse-ld=lld".to_string());
- targetflags.push("-Clink-arg=-Wl,--threads=1".to_string());
- }
+ Self::add_lld_flags(builder, target, &mut targetflags);
cmd.arg("--target-rustcflags").arg(targetflags.join(" "));
cmd.arg("--docck-python").arg(builder.python());
builder.info(&format!("doc tests for: {}", markdown.display()));
let mut cmd = builder.rustdoc_cmd(compiler);
builder.add_rust_test_threads(&mut cmd);
+ // allow for unstable options such as new editions
+ cmd.arg("-Z");
+ cmd.arg("unstable-options");
cmd.arg("--test");
cmd.arg(markdown);
cmd.env("RUSTC_BOOTSTRAP", "1");
let compiler = builder.compiler(builder.top_stage.saturating_sub(1), builder.config.build);
let mut cmd = Command::new(builder.ensure(ErrorIndex { compiler }));
add_dylib_path(
- vec![PathBuf::from(&builder.sysroot_libdir(compiler, compiler.host))],
+ vec![
+ PathBuf::from(&builder.sysroot_libdir(compiler, compiler.host)),
+ PathBuf::from(builder.rustc_libdir(compiler)),
+ ],
&mut cmd,
);
cmd
source "$(cd "$(dirname "$0")" && pwd)/../shared.sh"
# Update both macOS's and Windows's tarballs when bumping the version here.
-LLVM_VERSION="10.0.0"
+LLVM_VERSION="12.0.0"
if isMacOS; then
# If the job selects a specific Xcode version, use that instead of
bindir="$(xcode-select --print-path)/Toolchains/XcodeDefault.xctoolchain/usr/bin"
else
file="${MIRRORS_BASE}/clang%2Bllvm-${LLVM_VERSION}-x86_64-apple-darwin.tar.xz"
- curl -f "${file}" | tar xJf -
+ retry curl -f "${file}" -o "clang+llvm-${LLVM_VERSION}-x86_64-apple-darwin.tar.xz"
+ tar xJf "clang+llvm-${LLVM_VERSION}-x86_64-apple-darwin.tar.xz"
bindir="$(pwd)/clang+llvm-${LLVM_VERSION}-x86_64-apple-darwin/bin"
fi
# clang has an output mode compatible with MinGW that we need. If it does we
# should switch to clang for MinGW as well!
#
- # Note that the LLVM installer is an NSIS installer
- #
- # Original downloaded here came from:
- #
- # https://github.com/llvm/llvm-project/releases/download/llvmorg-10.0.0/LLVM-10.0.0-win64.exe
- #
- # That installer was run through `wine ./installer.exe /S /NCRC` on Linux
- # and then the resulting installation directory (found in
- # `$HOME/.wine/drive_c/Program Files/LLVM`) was packaged up into a tarball.
- # We've had issues otherwise that the installer will randomly hang, provide
- # not a lot of useful information, pollute global state, etc. In general the
- # tarball is just more confined and easier to deal with when working with
- # various CI environments.
+ # The LLVM installer is an NSIS installer, which we can extract with 7z. We
+ # don't want to run the installer directly; extracting it is more reliable
+ # in CI environments.
- mkdir -p citools
+ mkdir -p citools/clang-rust
cd citools
- curl -f "${MIRRORS_BASE}/LLVM-${LLVM_VERSION}-win64.tar.gz" | tar xzf -
+ retry curl -f "${MIRRORS_BASE}/LLVM-${LLVM_VERSION}-win64.exe" \
+ -o "LLVM-${LLVM_VERSION}-win64.exe"
+ 7z x -oclang-rust/ "LLVM-${LLVM_VERSION}-win64.exe"
ciCommandSetEnv RUST_CONFIGURE_ARGS \
"${RUST_CONFIGURE_ARGS} --set llvm.clang-cl=$(pwd)/clang-rust/bin/clang-cl.exe"
fi
}
</style>
-Support for different platforms are organized into three tiers, each with a
-different set of guarantees. For more information on the policies for targets
-at each tier, see the [Target Tier Policy](target-tier-policy.md).
+Support for different platforms ("targets") are organized into three tiers,
+each with a different set of guarantees. For more information on the policies
+for targets at each tier, see the [Target Tier Policy](target-tier-policy.md).
-Platforms are identified by their "target triple" which is the string to
-inform the compiler what kind of output should be produced. The columns in the
-tables below have the following meanings:
+Targets are identified by their "target triple" which is the string to inform
+the compiler what kind of output should be produced.
-* std:
- * ✓ indicates the full standard library is available.
- * \* indicates the target only supports [`no_std`] development.
- * ? indicates the standard library support is unknown or a work-in-progress.
-* host: A ✓ indicates that `rustc` and `cargo` can run on the host platform.
+## Tier 1 with Host Tools
-[`no_std`]: https://rust-embedded.github.io/book/intro/no-std.html
+Tier 1 targets can be thought of as "guaranteed to work". The Rust project
+builds official binary releases for each tier 1 target, and automated testing
+ensures that each tier 1 target builds and passes tests after each change.
-## Tier 1
+Tier 1 targets with host tools additionally support running tools like `rustc`
+and `cargo` natively on the target, and automated testing ensures that tests
+pass for the host tools as well. This allows the target to be used as a
+development platform, not just a compilation target. For the full requirements,
+see [Tier 1 with Host Tools](target-tier-policy.md#tier-1-with-host-tools) in
+the Target Tier Policy.
-Tier 1 platforms can be thought of as "guaranteed to work".
-Specifically they will each satisfy the following requirements:
+All tier 1 targets with host tools support the full standard library.
-* Official binary releases are provided for the platform.
-* Automated testing is set up to run tests for the platform.
-* Landing changes to the `rust-lang/rust` repository's master branch is gated
- on tests passing.
-* Documentation for how to use and how to build the platform is available.
-
-target | std | host | notes
--------|-----|------|-------
-`aarch64-unknown-linux-gnu` | ✓ | ✓ | ARM64 Linux (kernel 4.2, glibc 2.17+) [^missing-stack-probes]
-`i686-pc-windows-gnu` | ✓ | ✓ | 32-bit MinGW (Windows 7+)
-`i686-pc-windows-msvc` | ✓ | ✓ | 32-bit MSVC (Windows 7+)
-`i686-unknown-linux-gnu` | ✓ | ✓ | 32-bit Linux (kernel 2.6.32+, glibc 2.11+)
-`x86_64-apple-darwin` | ✓ | ✓ | 64-bit macOS (10.7+, Lion+)
-`x86_64-pc-windows-gnu` | ✓ | ✓ | 64-bit MinGW (Windows 7+)
-`x86_64-pc-windows-msvc` | ✓ | ✓ | 64-bit MSVC (Windows 7+)
-`x86_64-unknown-linux-gnu` | ✓ | ✓ | 64-bit Linux (kernel 2.6.32+, glibc 2.11+)
+target | notes
+-------|-------
+`aarch64-unknown-linux-gnu` | ARM64 Linux (kernel 4.2, glibc 2.17+) [^missing-stack-probes]
+`i686-pc-windows-gnu` | 32-bit MinGW (Windows 7+)
+`i686-pc-windows-msvc` | 32-bit MSVC (Windows 7+)
+`i686-unknown-linux-gnu` | 32-bit Linux (kernel 2.6.32+, glibc 2.11+)
+`x86_64-apple-darwin` | 64-bit macOS (10.7+, Lion+)
+`x86_64-pc-windows-gnu` | 64-bit MinGW (Windows 7+)
+`x86_64-pc-windows-msvc` | 64-bit MSVC (Windows 7+)
+`x86_64-unknown-linux-gnu` | 64-bit Linux (kernel 2.6.32+, glibc 2.11+)
[^missing-stack-probes]: Stack probes support is missing on
`aarch64-unknown-linux-gnu`, but it's planned to be implemented in the near
[77071]: https://github.com/rust-lang/rust/issues/77071
+## Tier 1
+
+Tier 1 targets can be thought of as "guaranteed to work". The Rust project
+builds official binary releases for each tier 1 target, and automated testing
+ensures that each tier 1 target builds and passes tests after each change. For
+the full requirements, see [Tier 1 target
+policy](target-tier-policy.md#tier-1-target-policy) in the Target Tier Policy.
+
+At this time, all Tier 1 targets are [Tier 1 with Host
+Tools](#tier-1-with-host-tools).
+
+## Tier 2 with Host Tools
+
+Tier 2 targets can be thought of as "guaranteed to build". The Rust project
+builds official binary releases for each tier 2 target, and automated builds
+ensure that each tier 2 target builds after each change. Automated tests are
+not always run so it's not guaranteed to produce a working build, but tier 2
+targets often work to quite a good degree and patches are always welcome!
+
+Tier 2 targets with host tools additionally support running tools like `rustc`
+and `cargo` natively on the target, and automated builds ensure that the host
+tools build as well. This allows the target to be used as a development
+platform, not just a compilation target. For the full requirements, see [Tier 2
+with Host Tools](target-tier-policy.md#tier-2-with-host-tools) in the Target
+Tier Policy.
+
+All tier 2 targets with host tools support the full standard library.
+
+target | notes
+-------|-------
+`aarch64-apple-darwin` | ARM64 macOS (11.0+, Big Sur+)
+`aarch64-pc-windows-msvc` | ARM64 Windows MSVC
+`aarch64-unknown-linux-musl` | ARM64 Linux with MUSL
+`arm-unknown-linux-gnueabi` | ARMv6 Linux (kernel 3.2, glibc 2.17)
+`arm-unknown-linux-gnueabihf` | ARMv6 Linux, hardfloat (kernel 3.2, glibc 2.17)
+`armv7-unknown-linux-gnueabihf` | ARMv7 Linux, hardfloat (kernel 3.2, glibc 2.17)
+`mips-unknown-linux-gnu` | MIPS Linux (kernel 4.4, glibc 2.23)
+`mips64-unknown-linux-gnuabi64` | MIPS64 Linux, n64 ABI (kernel 4.4, glibc 2.23)
+`mips64el-unknown-linux-gnuabi64` | MIPS64 (LE) Linux, n64 ABI (kernel 4.4, glibc 2.23)
+`mipsel-unknown-linux-gnu` | MIPS (LE) Linux (kernel 4.4, glibc 2.23)
+`powerpc-unknown-linux-gnu` | PowerPC Linux (kernel 2.6.32, glibc 2.11)
+`powerpc64-unknown-linux-gnu` | PPC64 Linux (kernel 2.6.32, glibc 2.11)
+`powerpc64le-unknown-linux-gnu` | PPC64LE Linux (kernel 3.10, glibc 2.17)
+`riscv64gc-unknown-linux-gnu` | RISC-V Linux (kernel 4.20, glibc 2.29)
+`s390x-unknown-linux-gnu` | S390x Linux (kernel 2.6.32, glibc 2.11)
+`x86_64-unknown-freebsd` | 64-bit FreeBSD
+`x86_64-unknown-illumos` | illumos
+`x86_64-unknown-linux-musl` | 64-bit Linux with MUSL
+`x86_64-unknown-netbsd` | NetBSD/amd64
+
## Tier 2
-Tier 2 platforms can be thought of as "guaranteed to build". Automated tests
-are not run so it's not guaranteed to produce a working build, but platforms
-often work to quite a good degree and patches are always welcome!
-Specifically, these platforms are required to have each of the following:
+Tier 2 targets can be thought of as "guaranteed to build". The Rust project
+builds official binary releases for each tier 2 target, and automated builds
+ensure that each tier 2 target builds after each change. Automated tests are
+not always run so it's not guaranteed to produce a working build, but tier 2
+targets often work to quite a good degree and patches are always welcome! For
+the full requirements, see [Tier 2 target
+policy](target-tier-policy.md#tier-2-target-policy) in the Target Tier Policy.
-* Official binary releases are provided for the platform.
-* Automated building is set up, but may not be running tests.
-* Landing changes to the `rust-lang/rust` repository's master branch is gated on
- platforms **building**. For some platforms only the standard library is
- compiled, but for others `rustc` and `cargo` are too.
+The `std` column in the table below has the following meanings:
-target | std | host | notes
--------|-----|------|-------
-`aarch64-apple-darwin` | ✓ | ✓ | ARM64 macOS (11.0+, Big Sur+)
-`aarch64-apple-ios` | ✓ | | ARM64 iOS
-`aarch64-fuchsia` | ✓ | | ARM64 Fuchsia
-`aarch64-linux-android` | ✓ | | ARM64 Android
-`aarch64-pc-windows-msvc` | ✓ | ✓ | ARM64 Windows MSVC
-`aarch64-unknown-linux-musl` | ✓ | ✓ | ARM64 Linux with MUSL
-`aarch64-unknown-none` | * | | Bare ARM64, hardfloat
-`aarch64-unknown-none-softfloat` | * | | Bare ARM64, softfloat
-`arm-linux-androideabi` | ✓ | | ARMv7 Android
-`arm-unknown-linux-gnueabi` | ✓ | ✓ | ARMv6 Linux (kernel 3.2, glibc 2.17)
-`arm-unknown-linux-gnueabihf` | ✓ | ✓ | ARMv6 Linux, hardfloat (kernel 3.2, glibc 2.17)
-`arm-unknown-linux-musleabi` | ✓ | | ARMv6 Linux with MUSL
-`arm-unknown-linux-musleabihf` | ✓ | | ARMv6 Linux with MUSL, hardfloat
-`armebv7r-none-eabi` | * | | Bare ARMv7-R, Big Endian
-`armebv7r-none-eabihf` | * | | Bare ARMv7-R, Big Endian, hardfloat
-`armv5te-unknown-linux-gnueabi` | ✓ | | ARMv5TE Linux (kernel 4.4, glibc 2.23)
-`armv5te-unknown-linux-musleabi` | ✓ | | ARMv5TE Linux with MUSL
-`armv7-linux-androideabi` | ✓ | | ARMv7a Android
-`armv7a-none-eabi` | * | | Bare ARMv7-A
-`armv7r-none-eabi` | * | | Bare ARMv7-R
-`armv7r-none-eabihf` | * | | Bare ARMv7-R, hardfloat
-`armv7-unknown-linux-gnueabi` | ✓ | | ARMv7 Linux (kernel 4.15, glibc 2.27)
-`armv7-unknown-linux-gnueabihf` | ✓ | ✓ | ARMv7 Linux, hardfloat (kernel 3.2, glibc 2.17)
-`armv7-unknown-linux-musleabi` | ✓ | | ARMv7 Linux, MUSL
-`armv7-unknown-linux-musleabihf` | ✓ | | ARMv7 Linux with MUSL
-`asmjs-unknown-emscripten` | ✓ | | asm.js via Emscripten
-`i586-pc-windows-msvc` | ✓ | | 32-bit Windows w/o SSE
-`i586-unknown-linux-gnu` | ✓ | | 32-bit Linux w/o SSE (kernel 4.4, glibc 2.23)
-`i586-unknown-linux-musl` | ✓ | | 32-bit Linux w/o SSE, MUSL
-`i686-linux-android` | ✓ | | 32-bit x86 Android
-`i686-unknown-freebsd` | ✓ | | 32-bit FreeBSD
-`i686-unknown-linux-musl` | ✓ | | 32-bit Linux with MUSL
-`mips-unknown-linux-gnu` | ✓ | ✓ | MIPS Linux (kernel 4.4, glibc 2.23)
-`mips-unknown-linux-musl` | ✓ | | MIPS Linux with MUSL
-`mips64-unknown-linux-gnuabi64` | ✓ | ✓ | MIPS64 Linux, n64 ABI (kernel 4.4, glibc 2.23)
-`mips64-unknown-linux-muslabi64` | ✓ | | MIPS64 Linux, n64 ABI, MUSL
-`mips64el-unknown-linux-gnuabi64` | ✓ | ✓ | MIPS64 (LE) Linux, n64 ABI (kernel 4.4, glibc 2.23)
-`mips64el-unknown-linux-muslabi64` | ✓ | | MIPS64 (LE) Linux, n64 ABI, MUSL
-`mipsel-unknown-linux-gnu` | ✓ | ✓ | MIPS (LE) Linux (kernel 4.4, glibc 2.23)
-`mipsel-unknown-linux-musl` | ✓ | | MIPS (LE) Linux with MUSL
-`nvptx64-nvidia-cuda` | ✓ | | --emit=asm generates PTX code that [runs on NVIDIA GPUs]
-`powerpc-unknown-linux-gnu` | ✓ | ✓ | PowerPC Linux (kernel 2.6.32, glibc 2.11)
-`powerpc64-unknown-linux-gnu` | ✓ | ✓ | PPC64 Linux (kernel 2.6.32, glibc 2.11)
-`powerpc64le-unknown-linux-gnu` | ✓ | ✓ | PPC64LE Linux (kernel 3.10, glibc 2.17)
-`riscv32i-unknown-none-elf` | * | | Bare RISC-V (RV32I ISA)
-`riscv32imac-unknown-none-elf` | * | | Bare RISC-V (RV32IMAC ISA)
-`riscv32imc-unknown-none-elf` | * | | Bare RISC-V (RV32IMC ISA)
-`riscv64gc-unknown-linux-gnu` | ✓ | ✓ | RISC-V Linux (kernel 4.20, glibc 2.29)
-`riscv64gc-unknown-none-elf` | * | | Bare RISC-V (RV64IMAFDC ISA)
-`riscv64imac-unknown-none-elf` | * | | Bare RISC-V (RV64IMAC ISA)
-`s390x-unknown-linux-gnu` | ✓ | ✓ | S390x Linux (kernel 2.6.32, glibc 2.11)
-`sparc64-unknown-linux-gnu` | ✓ | | SPARC Linux (kernel 4.4, glibc 2.23)
-`sparcv9-sun-solaris` | ✓ | | SPARC Solaris 10/11, illumos
-`thumbv6m-none-eabi` | * | | Bare Cortex-M0, M0+, M1
-`thumbv7em-none-eabi` | * | | Bare Cortex-M4, M7
-`thumbv7em-none-eabihf` | * | | Bare Cortex-M4F, M7F, FPU, hardfloat
-`thumbv7m-none-eabi` | * | | Bare Cortex-M3
-`thumbv7neon-linux-androideabi` | ✓ | | Thumb2-mode ARMv7a Android with NEON
-`thumbv7neon-unknown-linux-gnueabihf` | ✓ | | Thumb2-mode ARMv7a Linux with NEON (kernel 4.4, glibc 2.23)
-`thumbv8m.base-none-eabi` | * | | ARMv8-M Baseline
-`thumbv8m.main-none-eabi` | * | | ARMv8-M Mainline
-`thumbv8m.main-none-eabihf` | * | | ARMv8-M Mainline, hardfloat
-`wasm32-unknown-emscripten` | ✓ | | WebAssembly via Emscripten
-`wasm32-unknown-unknown` | ✓ | | WebAssembly
-`wasm32-wasi` | ✓ | | WebAssembly with WASI
-`x86_64-apple-ios` | ✓ | | 64-bit x86 iOS
-`x86_64-fortanix-unknown-sgx` | ✓ | | [Fortanix ABI] for 64-bit Intel SGX
-`x86_64-fuchsia` | ✓ | | 64-bit Fuchsia
-`x86_64-linux-android` | ✓ | | 64-bit x86 Android
-`x86_64-pc-solaris` | ✓ | | 64-bit Solaris 10/11, illumos
-`x86_64-unknown-freebsd` | ✓ | ✓ | 64-bit FreeBSD
-`x86_64-unknown-illumos` | ✓ | ✓ | illumos
-`x86_64-unknown-linux-gnux32` | ✓ | | 64-bit Linux (x32 ABI) (kernel 4.15, glibc 2.27)
-`x86_64-unknown-linux-musl` | ✓ | ✓ | 64-bit Linux with MUSL
-`x86_64-unknown-netbsd` | ✓ | ✓ | NetBSD/amd64
-`x86_64-unknown-redox` | ✓ | | Redox OS
+* ✓ indicates the full standard library is available.
+* \* indicates the target only supports [`no_std`] development.
+
+[`no_std`]: https://rust-embedded.github.io/book/intro/no-std.html
+
+target | std | notes
+-------|:---:|-------
+`aarch64-apple-ios` | ✓ | ARM64 iOS
+`aarch64-fuchsia` | ✓ | ARM64 Fuchsia
+`aarch64-linux-android` | ✓ | ARM64 Android
+`aarch64-unknown-none-softfloat` | * | Bare ARM64, softfloat
+`aarch64-unknown-none` | * | Bare ARM64, hardfloat
+`arm-linux-androideabi` | ✓ | ARMv7 Android
+`arm-unknown-linux-musleabi` | ✓ | ARMv6 Linux with MUSL
+`arm-unknown-linux-musleabihf` | ✓ | ARMv6 Linux with MUSL, hardfloat
+`armebv7r-none-eabi` | * | Bare ARMv7-R, Big Endian
+`armebv7r-none-eabihf` | * | Bare ARMv7-R, Big Endian, hardfloat
+`armv5te-unknown-linux-gnueabi` | ✓ | ARMv5TE Linux (kernel 4.4, glibc 2.23)
+`armv5te-unknown-linux-musleabi` | ✓ | ARMv5TE Linux with MUSL
+`armv7-linux-androideabi` | ✓ | ARMv7a Android
+`armv7-unknown-linux-gnueabi` | ✓ |ARMv7 Linux (kernel 4.15, glibc 2.27)
+`armv7-unknown-linux-musleabi` | ✓ |ARMv7 Linux, MUSL
+`armv7-unknown-linux-musleabihf` | ✓ | ARMv7 Linux with MUSL
+`armv7a-none-eabi` | * | Bare ARMv7-A
+`armv7r-none-eabi` | * | Bare ARMv7-R
+`armv7r-none-eabihf` | * | Bare ARMv7-R, hardfloat
+`asmjs-unknown-emscripten` | ✓ | asm.js via Emscripten
+`i586-pc-windows-msvc` | ✓ | 32-bit Windows w/o SSE
+`i586-unknown-linux-gnu` | ✓ | 32-bit Linux w/o SSE (kernel 4.4, glibc 2.23)
+`i586-unknown-linux-musl` | ✓ | 32-bit Linux w/o SSE, MUSL
+`i686-linux-android` | ✓ | 32-bit x86 Android
+`i686-unknown-freebsd` | ✓ | 32-bit FreeBSD
+`i686-unknown-linux-musl` | ✓ | 32-bit Linux with MUSL
+`mips-unknown-linux-musl` | ✓ | MIPS Linux with MUSL
+`mips64-unknown-linux-muslabi64` | ✓ | MIPS64 Linux, n64 ABI, MUSL
+`mips64el-unknown-linux-muslabi64` | ✓ | MIPS64 (LE) Linux, n64 ABI, MUSL
+`mipsel-unknown-linux-musl` | ✓ | MIPS (LE) Linux with MUSL
+`nvptx64-nvidia-cuda` | ✓ | --emit=asm generates PTX code that [runs on NVIDIA GPUs]
+`riscv32i-unknown-none-elf` | * | Bare RISC-V (RV32I ISA)
+`riscv32imac-unknown-none-elf` | * | Bare RISC-V (RV32IMAC ISA)
+`riscv32imc-unknown-none-elf` | * | Bare RISC-V (RV32IMC ISA)
+`riscv64gc-unknown-none-elf` | * | Bare RISC-V (RV64IMAFDC ISA)
+`riscv64imac-unknown-none-elf` | * | Bare RISC-V (RV64IMAC ISA)
+`sparc64-unknown-linux-gnu` | ✓ | SPARC Linux (kernel 4.4, glibc 2.23)
+`sparcv9-sun-solaris` | ✓ | SPARC Solaris 10/11, illumos
+`thumbv6m-none-eabi` | * | Bare Cortex-M0, M0+, M1
+`thumbv7em-none-eabi` | * | Bare Cortex-M4, M7
+`thumbv7em-none-eabihf` | * | Bare Cortex-M4F, M7F, FPU, hardfloat
+`thumbv7m-none-eabi` | * | Bare Cortex-M3
+`thumbv7neon-linux-androideabi` | ✓ | Thumb2-mode ARMv7a Android with NEON
+`thumbv7neon-unknown-linux-gnueabihf` | ✓ | Thumb2-mode ARMv7a Linux with NEON (kernel 4.4, glibc 2.23)
+`thumbv8m.base-none-eabi` | * | ARMv8-M Baseline
+`thumbv8m.main-none-eabi` | * | ARMv8-M Mainline
+`thumbv8m.main-none-eabihf` | * | ARMv8-M Mainline, hardfloat
+`wasm32-unknown-emscripten` | ✓ | WebAssembly via Emscripten
+`wasm32-unknown-unknown` | ✓ | WebAssembly
+`wasm32-wasi` | ✓ | WebAssembly with WASI
+`x86_64-apple-ios` | ✓ | 64-bit x86 iOS
+`x86_64-fortanix-unknown-sgx` | ✓ | [Fortanix ABI] for 64-bit Intel SGX
+`x86_64-fuchsia` | ✓ | 64-bit Fuchsia
+`x86_64-linux-android` | ✓ | 64-bit x86 Android
+`x86_64-pc-solaris` | ✓ | 64-bit Solaris 10/11, illumos
+`x86_64-unknown-linux-gnux32` | ✓ | 64-bit Linux (x32 ABI) (kernel 4.15, glibc 2.27)
+`x86_64-unknown-redox` | ✓ | Redox OS
[Fortanix ABI]: https://edp.fortanix.com/
## Tier 3
-Tier 3 platforms are those which the Rust codebase has support for, but which
-are not built or tested automatically, and may not work. Official builds are
-not available.
+Tier 3 targets are those which the Rust codebase has support for, but which the
+Rust project does not build or test automatically, so they may or may not work.
+Official builds are not available. For the full requirements, see [Tier 3
+target policy](target-tier-policy.md#tier-3-target-policy) in the Target Tier
+Policy.
+
+The `std` column in the table below has the following meanings:
+
+* ✓ indicates the full standard library is available.
+* \* indicates the target only supports [`no_std`] development.
+* ? indicates the standard library support is unknown or a work-in-progress.
+
+[`no_std`]: https://rust-embedded.github.io/book/intro/no-std.html
+
+The `host` column indicates whether the codebase includes support for building
+host tools.
target | std | host | notes
--------|-----|------|-------
+-------|:---:|:----:|-------
`aarch64-apple-ios-macabi` | ? | | Apple Catalyst on ARM64
`aarch64-apple-ios-sim` | ? | | Apple iOS Simulator on ARM64
`aarch64-apple-tvos` | * | | ARM64 tvOS
`aarch64-unknown-redox` | ? | | ARM64 Redox OS
`aarch64-uwp-windows-msvc` | ? | |
`aarch64-wrs-vxworks` | ? | |
-`aarch64_be-unknown-linux-gnu` | ✓ | ✓ | ARM64 Linux (big-endian)
`aarch64_be-unknown-linux-gnu_ilp32` | ✓ | ✓ | ARM64 Linux (big-endian, ILP32 ABI)
+`aarch64_be-unknown-linux-gnu` | ✓ | ✓ | ARM64 Linux (big-endian)
`armv4t-unknown-linux-gnueabi` | ? | |
`armv5te-unknown-linux-uclibceabi` | ? | | ARMv5TE Linux with uClibc
`armv6-unknown-freebsd` | ✓ | ✓ | ARMv6 FreeBSD
`armv7-wrs-vxworks-eabihf` | ? | |
`armv7a-none-eabihf` | * | | ARM Cortex-A, hardfloat
`armv7s-apple-ios` | ✓ | |
-`avr-unknown-gnu-atmega328` | ✗ | | AVR. Requires `-Z build-std=core`
+`avr-unknown-gnu-atmega328` | * | | AVR. Requires `-Z build-std=core`
`hexagon-unknown-linux-musl` | ? | |
`i386-apple-ios` | ✓ | | 32-bit x86 iOS
`i686-apple-darwin` | ✓ | ✓ | 32-bit macOS (10.7+, Lion+)
`i686-pc-windows-msvc` | ✓ | | 32-bit Windows XP support
-`i686-unknown-uefi` | * | | 32-bit UEFI
`i686-unknown-haiku` | ✓ | ✓ | 32-bit Haiku
`i686-unknown-netbsd` | ✓ | ✓ | NetBSD/i386 with SSE2
`i686-unknown-openbsd` | ✓ | ✓ | 32-bit OpenBSD
+`i686-unknown-uefi` | * | | 32-bit UEFI
`i686-uwp-windows-gnu` | ? | |
`i686-uwp-windows-msvc` | ? | |
`i686-wrs-vxworks` | ? | |
`mips-unknown-linux-uclibc` | ✓ | | MIPS Linux with uClibc
+`mipsel-sony-psp` | * | | MIPS (LE) Sony PlayStation Portable (PSP)
`mipsel-unknown-linux-uclibc` | ✓ | | MIPS (LE) Linux with uClibc
`mipsel-unknown-none` | * | | Bare MIPS (LE) softfloat
-`mipsel-sony-psp` | * | | MIPS (LE) Sony PlayStation Portable (PSP)
`mipsisa32r6-unknown-linux-gnu` | ? | |
`mipsisa32r6el-unknown-linux-gnu` | ? | |
`mipsisa64r6-unknown-linux-gnuabi64` | ? | |
`powerpc-unknown-linux-musl` | ? | |
`powerpc-unknown-netbsd` | ✓ | ✓ |
`powerpc-unknown-openbsd` | ? | |
-`powerpc-wrs-vxworks` | ? | |
`powerpc-wrs-vxworks-spe` | ? | |
+`powerpc-wrs-vxworks` | ? | |
`powerpc64-unknown-freebsd` | ✓ | ✓ | PPC64 FreeBSD (ELFv1 and ELFv2)
`powerpc64-unknown-linux-musl` | ? | |
`powerpc64-wrs-vxworks` | ? | |
`powerpc64le-unknown-linux-musl` | ? | |
-`riscv64gc-unknown-linux-musl` | | | RISC-V Linux (kernel 4.20, musl 1.2.0)
`riscv32gc-unknown-linux-gnu` | | | RISC-V Linux (kernel 5.4, glibc 2.33)
`riscv32gc-unknown-linux-musl` | | | RISC-V Linux (kernel 5.4, musl + RISCV32 support patches)
+`riscv64gc-unknown-linux-musl` | | | RISC-V Linux (kernel 4.20, musl 1.2.0)
`s390x-unknown-linux-musl` | | | S390x Linux (kernel 2.6.32, MUSL)
`sparc-unknown-linux-gnu` | ✓ | | 32-bit SPARC Linux
`sparc64-unknown-netbsd` | ✓ | ✓ | NetBSD/sparc64
`sparc64-unknown-openbsd` | ? | |
+`thumbv4t-none-eabi` | * | | ARMv4T T32
`thumbv7a-pc-windows-msvc` | ? | |
`thumbv7a-uwp-windows-msvc` | ✓ | |
`thumbv7neon-unknown-linux-musleabihf` | ? | | Thumb2-mode ARMv7a Linux with NEON, MUSL
-`thumbv4t-none-eabi` | * | | ARMv4T T32
`wasm64-unknown-unknown` | * | | WebAssembly
`x86_64-apple-ios-macabi` | ✓ | | Apple Catalyst on x86_64
`x86_64-apple-tvos` | * | | x86 64-bit tvOS
-`x86_64-unknown-none-linuxkernel` | * | | Linux kernel modules
-`x86_64-sun-solaris` | ? | | Deprecated target for 64-bit Solaris 10/11, illumos
`x86_64-pc-windows-msvc` | ✓ | | 64-bit Windows XP support
+`x86_64-sun-solaris` | ? | | Deprecated target for 64-bit Solaris 10/11, illumos
`x86_64-unknown-dragonfly` | ✓ | ✓ | 64-bit DragonFlyBSD
`x86_64-unknown-haiku` | ✓ | ✓ | 64-bit Haiku
`x86_64-unknown-hermit` | ? | |
-`x86_64-unknown-none-hermitkernel` | ? | | HermitCore kernel
`x86_64-unknown-l4re-uclibc` | ? | |
+`x86_64-unknown-none-hermitkernel` | ? | | HermitCore kernel
+`x86_64-unknown-none-linuxkernel` | * | | Linux kernel modules
`x86_64-unknown-openbsd` | ✓ | ✓ | 64-bit OpenBSD
`x86_64-unknown-uefi` | * | | 64-bit UEFI
`x86_64-uwp-windows-gnu` | ✓ | |
# Target Tier Policy
+## Table of Contents
+
+* [General](#general)
+* [Tier 3 target policy](#tier-3-target-policy)
+* [Tier 2 target policy](#tier-2-target-policy)
+ * [Tier 2 with host tools](#tier-2-with-host-tools)
+* [Tier 1 target policy](#tier-1-target-policy)
+ * [Tier 1 with host tools](#tier-1-with-host-tools)
+
+## General
+
Rust provides three tiers of target support:
- Rust provides no guarantees about tier 3 targets; they exist in the codebase,
A proposed new tier 3 target must be reviewed and approved by a member of the
compiler team based on these requirements. The reviewer may choose to gauge
-broader compiler team consensus via a Major Change Proposal (MCP).
+broader compiler team consensus via a [Major Change Proposal (MCP)][MCP].
A proposed target or target-specific patch that substantially changes code
shared with other targets (not just target-specific code) must be reviewed and
the target will not block forward progress of the Rust project.
A proposed new tier 2 target must be reviewed and approved by the compiler team
-based on these requirements. Such review and approval may occur via a Major
-Change Proposal (MCP).
+based on these requirements. Such review and approval may occur via a [Major
+Change Proposal (MCP)][MCP].
In addition, the infrastructure team must approve the integration of the target
into Continuous Integration (CI), and the tier 2 CI-related requirements. This
A proposed new tier 2 target with host tools must be reviewed and approved by
the compiler team based on these requirements. Such review and approval may
-occur via a Major Change Proposal (MCP).
+occur via a [Major Change Proposal (MCP)][MCP].
In addition, the infrastructure team must approve the integration of the
target's host tools into Continuous Integration (CI), and the CI-related
RFC process, with approval by the compiler and release teams. Any such proposal
will be communicated widely to the Rust community, both when initially proposed
and before being dropped from a stable release.
+
+[MCP]: https://forge.rust-lang.org/compiler/mcp.html
--- /dev/null
+# `instrument-coverage`
+
+The tracking issue for this feature is: [#79121].
+
+[#79121]: https://github.com/rust-lang/rust/issues/79121
+
+---
+
+## Introduction
+
+The Rust compiler includes two code coverage implementations:
+
+- A GCC-compatible, gcov-based coverage implementation, enabled with `-Z profile`, which derives coverage data based on DebugInfo.
+- A source-based code coverage implementation, enabled with `-Z instrument-coverage`, which uses LLVM's native, efficient coverage instrumentation to generate very precise coverage data.
+
+This document describes how to enable and use the LLVM instrumentation-based coverage, via the `-Z instrument-coverage` compiler flag.
+
+## How it works
+
+When `-Z instrument-coverage` is enabled, the Rust compiler enhances rust-based libraries and binaries by:
+
+- Automatically injecting calls to an LLVM intrinsic ([`llvm.instrprof.increment`]), at functions and branches in compiled code, to increment counters when conditional sections of code are executed.
+- Embedding additional information in the data section of each library and binary (using the [LLVM Code Coverage Mapping Format] _Version 4_, supported _only_ in LLVM 11 and up), to define the code regions (start and end positions in the source code) being counted.
+
+When running a coverage-instrumented program, the counter values are written to a `profraw` file at program termination. LLVM bundles tools that read the counter results, combine those results with the coverage map (embedded in the program binary), and generate coverage reports in multiple formats.
+
+[`llvm.instrprof.increment`]: https://llvm.org/docs/LangRef.html#llvm-instrprof-increment-intrinsic
+[llvm code coverage mapping format]: https://llvm.org/docs/CoverageMappingFormat.html
+
+> **Note**: `-Z instrument-coverage` also automatically enables `-Z symbol-mangling-version=v0` (tracking issue [#60705]). The `v0` symbol mangler is strongly recommended, but be aware that this demangler is also experimental. The `v0` demangler can be overridden by explicitly adding `-Z symbol-mangling-version=legacy`.
+
+[#60705]: https://github.com/rust-lang/rust/issues/60705
+
+## Enable coverage profiling in the Rust compiler
+
+Rust's source-based code coverage requires the Rust "profiler runtime". Without it, compiling with `-Z instrument-coverage` generates an error that the profiler runtime is missing.
+
+The Rust `nightly` distribution channel includes the profiler runtime, by default.
+
+> **Important**: If you are building the Rust compiler from the source distribution, the profiler runtime is _not_ enabled in the default `config.toml.example`. Edit your `config.toml` file and ensure the `profiler` feature is set it to `true` (either under the `[build]` section, or under the settings for an individual `[target.<triple>]`):
+>
+> ```toml
+> # Build the profiler runtime (required when compiling with options that depend
+> # on this runtime, such as `-C profile-generate` or `-Z instrument-coverage`).
+> profiler = true
+> ```
+
+### Building the demangler
+
+LLVM coverage reporting tools generate results that can include function names and other symbol references, and the raw coverage results report symbols using the compiler's "mangled" version of the symbol names, which can be difficult to interpret. To work around this issue, LLVM coverage tools also support a user-specified symbol name demangler.
+
+One option for a Rust demangler is [`rustfilt`], which can be installed with:
+
+```shell
+cargo install rustfilt
+```
+
+Another option, if you are building from the Rust compiler source distribution, is to use the `rust-demangler` tool included in the Rust source distribution, which can be built with:
+
+```shell
+$ ./x.py build rust-demangler
+```
+
+[`rustfilt`]: https://crates.io/crates/rustfilt
+
+## Compiling with coverage enabled
+
+Set the `-Z instrument-coverage` compiler flag in order to enable LLVM source-based code coverage profiling.
+
+The default option generates coverage for all functions, including unused (never called) functions and generics. The compiler flag supports an optional value to tailor this behavior. (See [`-Z instrument-coverage=<options>`](#-z-instrument-coverageoptions), below.)
+
+With `cargo`, you can instrument your program binary _and_ dependencies at the same time.
+
+For example (if your project's Cargo.toml builds a binary by default):
+
+```shell
+$ cd your-project
+$ cargo clean
+$ RUSTFLAGS="-Z instrument-coverage" cargo build
+```
+
+If `cargo` is not configured to use your `profiler`-enabled version of `rustc`, set the path explicitly via the `RUSTC` environment variable. Here is another example, using a `stage1` build of `rustc` to compile an `example` binary (from the [`json5format`] crate):
+
+```shell
+$ RUSTC=$HOME/rust/build/x86_64-unknown-linux-gnu/stage1/bin/rustc \
+ RUSTFLAGS="-Z instrument-coverage" \
+ cargo build --example formatjson5
+```
+
+> **Note**: that some compiler options, combined with `-Z instrument-coverage`, can produce LLVM IR and/or linked binaries that are incompatible with LLVM coverage maps. For example, coverage requires references to actual functions in LLVM IR. If any covered function is optimized out, the coverage tools may not be able to process the coverage results. If you need to pass additional options, with coverage enabled, test them early, to confirm you will get the coverage results you expect.
+
+## Running the instrumented binary to generate raw coverage profiling data
+
+In the previous example, `cargo` generated the coverage-instrumented binary `formatjson5`:
+
+```shell
+$ echo "{some: 'thing'}" | target/debug/examples/formatjson5 -
+```
+
+```json5
+{
+ some: "thing",
+}
+```
+
+After running this program, a new file, `default.profraw`, should be in the current working directory. It's often preferable to set a specific file name or path. You can change the output file using the environment variable `LLVM_PROFILE_FILE`:
+
+```shell
+$ echo "{some: 'thing'}" \
+ | LLVM_PROFILE_FILE="formatjson5.profraw" target/debug/examples/formatjson5 -
+...
+$ ls formatjson5.profraw
+formatjson5.profraw
+```
+
+If `LLVM_PROFILE_FILE` contains a path to a non-existent directory, the missing directory structure will be created. Additionally, the following special pattern strings are rewritten:
+
+- `%p` - The process ID.
+- `%h` - The hostname of the machine running the program.
+- `%t` - The value of the TMPDIR environment variable.
+- `%Nm` - the instrumented binary’s signature: The runtime creates a pool of N raw profiles, used for on-line profile merging. The runtime takes care of selecting a raw profile from the pool, locking it, and updating it before the program exits. `N` must be between `1` and `9`, and defaults to `1` if omitted (with simply `%m`).
+- `%c` - Does not add anything to the filename, but enables a mode (on some platforms, including Darwin) in which profile counter updates are continuously synced to a file. This means that if the instrumented program crashes, or is killed by a signal, perfect coverage information can still be recovered.
+
+## Installing LLVM coverage tools
+
+LLVM's supplies two tools—`llvm-profdata` and `llvm-cov`—that process coverage data and generate reports. There are several ways to find and/or install these tools, but note that the coverage mapping data generated by the Rust compiler requires LLVM version 11 or higher. (`llvm-cov --version` typically shows the tool's LLVM version number.):
+
+- The LLVM tools may be installed (or installable) directly to your OS (such as via `apt-get`, for Linux).
+- If you are building the Rust compiler from source, you can optionally use the bundled LLVM tools, built from source. Those tool binaries can typically be found in your build platform directory at something like: `rust/build/x86_64-unknown-linux-gnu/llvm/bin/llvm-*`.
+- You can install compatible versions of these tools via `rustup`.
+
+The `rustup` option is guaranteed to install a compatible version of the LLVM tools, but they can be hard to find. We recommend [`cargo-binutils`], which installs Rust-specific wrappers around these and other LLVM tools, so you can invoke them via `cargo` commands!
+
+```shell
+$ rustup component add llvm-tools-preview
+$ cargo install cargo-binutils
+$ cargo profdata -- --help # note the additional "--" preceding the tool-specific arguments
+```
+
+[`cargo-binutils`]: https://crates.io/crates/cargo-binutils
+
+## Creating coverage reports
+
+Raw profiles have to be indexed before they can be used to generate coverage reports. This is done using [`llvm-profdata merge`] (or `cargo profdata -- merge`), which can combine multiple raw profiles and index them at the same time:
+
+```shell
+$ llvm-profdata merge -sparse formatjson5.profraw -o formatjson5.profdata
+```
+
+Finally, the `.profdata` file is used, in combination with the coverage map (from the program binary) to generate coverage reports using [`llvm-cov report`] (or `cargo cov -- report`), for a coverage summaries; and [`llvm-cov show`] (or `cargo cov -- show`), to see detailed coverage of lines and regions (character ranges) overlaid on the original source code.
+
+These commands have several display and filtering options. For example:
+
+```shell
+$ llvm-cov show -Xdemangler=rustfilt target/debug/examples/formatjson5 \
+ -instr-profile=formatjson5.profdata \
+ -show-line-counts-or-regions \
+ -show-instantiations \
+ -name=add_quoted_string
+```
+
+<img alt="Screenshot of sample `llvm-cov show` result, for function add_quoted_string" src="img/llvm-cov-show-01.png" class="center"/>
+<br/>
+<br/>
+
+Some of the more notable options in this example include:
+
+- `--Xdemangler=rustfilt` - the command name or path used to demangle Rust symbols (`rustfilt` in the example, but this could also be a path to the `rust-demangler` tool)
+- `target/debug/examples/formatjson5` - the instrumented binary (from which to extract the coverage map)
+- `--instr-profile=<path-to-file>.profdata` - the location of the `.profdata` file created by `llvm-profdata merge` (from the `.profraw` file generated by the instrumented binary)
+- `--name=<exact-function-name>` - to show coverage for a specific function (or, consider using another filter option, such as `--name-regex=<pattern>`)
+
+[`llvm-profdata merge`]: https://llvm.org/docs/CommandGuide/llvm-profdata.html#profdata-merge
+[`llvm-cov report`]: https://llvm.org/docs/CommandGuide/llvm-cov.html#llvm-cov-report
+[`llvm-cov show`]: https://llvm.org/docs/CommandGuide/llvm-cov.html#llvm-cov-show
+
+> **Note**: Coverage can also be disabled on an individual function by annotating the function with the [`no_coverage` attribute] (which requires the feature flag `#![feature(no_coverage)]`).
+
+[`no_coverage` attribute]: ../language-features/no-coverage.md
+
+## Interpreting reports
+
+There are four statistics tracked in a coverage summary:
+
+- Function coverage is the percentage of functions that have been executed at least once. A function is considered to be executed if any of its instantiations are executed.
+- Instantiation coverage is the percentage of function instantiations that have been executed at least once. Generic functions and functions generated from macros are two kinds of functions that may have multiple instantiations.
+- Line coverage is the percentage of code lines that have been executed at least once. Only executable lines within function bodies are considered to be code lines.
+- Region coverage is the percentage of code regions that have been executed at least once. A code region may span multiple lines: for example, in a large function body with no control flow. In other cases, a single line can contain multiple code regions: `return x || (y && z)` has countable code regions for `x` (which may resolve the expression, if `x` is `true`), `|| (y && z)` (executed only if `x` was `false`), and `return` (executed in either situation).
+
+Of these four statistics, function coverage is usually the least granular while region coverage is the most granular. The project-wide totals for each statistic are listed in the summary.
+
+## Test coverage
+
+A typical use case for coverage analysis is test coverage. Rust's source-based coverage tools can both measure your tests' code coverage as percentage, and pinpoint functions and branches not tested.
+
+The following example (using the [`json5format`] crate, for demonstration purposes) show how to generate and analyze coverage results for all tests in a crate.
+
+Since `cargo test` both builds and runs the tests, we set both the additional `RUSTFLAGS`, to add the `-Z instrument-coverage` flag, and `LLVM_PROFILE_FILE`, to set a custom filename for the raw profiling data generated during the test runs. Since there may be more than one test binary, apply `%m` in the filename pattern. This generates unique names for each test binary. (Otherwise, each executed test binary would overwrite the coverage results from the previous binary.)
+
+```shell
+$ RUSTFLAGS="-Z instrument-coverage" \
+ LLVM_PROFILE_FILE="json5format-%m.profraw" \
+ cargo test --tests
+```
+
+Make note of the test binary file paths, displayed after the word "`Running`" in the test output:
+
+```text
+ ...
+ Compiling json5format v0.1.3 ($HOME/json5format)
+ Finished test [unoptimized + debuginfo] target(s) in 14.60s
+
+ Running target/debug/deps/json5format-fececd4653271682
+running 25 tests
+...
+test result: ok. 25 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
+
+ Running target/debug/deps/lib-30768f9c53506dc5
+running 31 tests
+...
+test result: ok. 31 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
+```
+
+You should have one or more `.profraw` files now, one for each test binary. Run the `profdata` tool to merge them:
+
+```shell
+$ cargo profdata -- merge \
+ -sparse json5format-*.profraw -o json5format.profdata
+```
+
+Then run the `cov` tool, with the `profdata` file and all test binaries:
+
+```shell
+$ cargo cov -- report \
+ --use-color --ignore-filename-regex='/.cargo/registry' \
+ --instr-profile=json5format.profdata \
+ --object target/debug/deps/lib-30768f9c53506dc5 \
+ --object target/debug/deps/json5format-fececd4653271682
+$ cargo cov -- show \
+ --use-color --ignore-filename-regex='/.cargo/registry' \
+ --instr-profile=json5format.profdata \
+ --object target/debug/deps/lib-30768f9c53506dc5 \
+ --object target/debug/deps/json5format-fececd4653271682 \
+ --show-instantiations --show-line-counts-or-regions \
+ --Xdemangler=rustfilt | less -R
+```
+
+> **Note**: The command line option `--ignore-filename-regex=/.cargo/registry`, which excludes the sources for dependencies from the coverage results.\_
+
+### Tips for listing the binaries automatically
+
+For `bash` users, one suggested way to automatically complete the `cov` command with the list of binaries is with a command like:
+
+```bash
+$ cargo cov -- report \
+ $( \
+ for file in \
+ $( \
+ RUSTFLAGS="-Z instrument-coverage" \
+ cargo test --tests --no-run --message-format=json \
+ | jq -r "select(.profile.test == true) | .filenames[]" \
+ | grep -v dSYM - \
+ ); \
+ do \
+ printf "%s %s " -object $file; \
+ done \
+ ) \
+ --instr-profile=json5format.profdata --summary-only # and/or other options
+```
+
+Adding `--no-run --message-format=json` to the _same_ `cargo test` command used to run
+the tests (including the same environment variables and flags) generates output in a JSON
+format that `jq` can easily query.
+
+The `printf` command takes this list and generates the `--object <binary>` arguments
+for each listed test binary.
+
+### Including doc tests
+
+The previous examples run `cargo test` with `--tests`, which excludes doc tests.[^79417]
+
+To include doc tests in the coverage results, drop the `--tests` flag, and apply the
+`-Z instrument-coverage` flag, and some doc-test-specific options in the
+`RUSTDOCFLAGS` environment variable. (The `cargo profdata` command does not change.)
+
+```bash
+$ RUSTFLAGS="-Z instrument-coverage" \
+ RUSTDOCFLAGS="-Z instrument-coverage -Z unstable-options --persist-doctests target/debug/doctestbins" \
+ LLVM_PROFILE_FILE="json5format-%m.profraw" \
+ cargo test
+$ cargo profdata -- merge \
+ -sparse json5format-*.profraw -o json5format.profdata
+```
+
+The `-Z unstable-options --persist-doctests` flag is required, to save the test binaries
+(with their coverage maps) for `llvm-cov`.
+
+```bash
+$ cargo cov -- report \
+ $( \
+ for file in \
+ $( \
+ RUSTFLAGS="-Z instrument-coverage" \
+ RUSTDOCFLAGS="-Z instrument-coverage -Z unstable-options --persist-doctests target/debug/doctestbins" \
+ cargo test --no-run --message-format=json \
+ | jq -r "select(.profile.test == true) | .filenames[]" \
+ | grep -v dSYM - \
+ ) \
+ target/debug/doctestbins/*/rust_out; \
+ do \
+ [[ -x $file ]] && printf "%s %s " -object $file; \
+ done \
+ ) \
+ --instr-profile=json5format.profdata --summary-only # and/or other options
+```
+
+> **Note**: The differences in this `cargo cov` command, compared with the version without
+> doc tests, include:
+
+- The `cargo test ... --no-run` command is updated with the same environment variables
+ and flags used to _build_ the tests, _including_ the doc tests. (`LLVM_PROFILE_FILE`
+ is only used when _running_ the tests.)
+- The file glob pattern `target/debug/doctestbins/*/rust_out` adds the `rust_out`
+ binaries generated for doc tests (note, however, that some `rust_out` files may not
+ be executable binaries).
+- `[[ -x $file ]] &&` filters the files passed on to the `printf`, to include only
+ executable binaries.
+
+[^79417]:
+ There is ongoing work to resolve a known issue
+ [(#79417)](https://github.com/rust-lang/rust/issues/79417) that doc test coverage
+ generates incorrect source line numbers in `llvm-cov show` results.
+
+## `-Z instrument-coverage=<options>`
+
+- `-Z instrument-coverage=all`: Instrument all functions, including unused functions and unused generics. (This is the same as `-Z instrument-coverage`, with no value.)
+- `-Z instrument-coverage=except-unused-generics`: Instrument all functions except unused generics.
+- `-Z instrument-coverage=except-unused-functions`: Instrument only used (called) functions and instantiated generic functions.
+- `-Z instrument-coverage=off`: Do not instrument any functions. (This is the same as simply not including the `-Z instrument-coverage` option.)
+
+## Other references
+
+Rust's implementation and workflow for source-based code coverage is based on the same library and tools used to implement [source-based code coverage in Clang]. (This document is partially based on the Clang guide.)
+
+[source-based code coverage in clang]: https://clang.llvm.org/docs/SourceBasedCodeCoverage.html
+[`json5format`]: https://crates.io/crates/json5format
# `source-based-code-coverage`
-The tracking issue for this feature is: [#79121].
+See compiler flag [`-Z instrument-coverage`].
-------------------------
-
-## Introduction
-
-The Rust compiler includes two code coverage implementations:
-
-* A GCC-compatible, gcov-based coverage implementation, enabled with [`-Zprofile`], which operates on DebugInfo.
-* A source-based code coverage implementation, enabled with `-Zinstrument-coverage`, which uses LLVM's native coverage instrumentation to generate very precise coverage data.
-
-This document describes how to enable and use the LLVM instrumentation-based coverage, via the `-Zinstrument-coverage` compiler flag.
-
-## How it works
-
-When `-Zinstrument-coverage` is enabled, the Rust compiler enhances rust-based libraries and binaries by:
-
-* Automatically injecting calls to an LLVM intrinsic ([`llvm.instrprof.increment`]), at functions and branches in compiled code, to increment counters when conditional sections of code are executed.
-* Embedding additional information in the data section of each library and binary (using the [LLVM Code Coverage Mapping Format] _Version 4_, supported _only_ in LLVM 11 and up), to define the code regions (start and end positions in the source code) being counted.
-
-When running a coverage-instrumented program, the counter values are written to a `profraw` file at program termination. LLVM bundles tools that read the counter results, combine those results with the coverage map (embedded in the program binary), and generate coverage reports in multiple formats.
-
-## Enable coverage profiling in the Rust compiler
-
-Rust's source-based code coverage requires the Rust "profiler runtime". Without it, compiling with `-Zinstrument-coverage` generates an error that the profiler runtime is missing.
-
-The Rust `nightly` distribution channel should include the profiler runtime, by default.
-
-*IMPORTANT:* If you are building the Rust compiler from the source distribution, the profiler runtime is *not* enabled in the default `config.toml.example`. Edit your `config.toml` file and ensure the `profiler` feature is set it to `true`:
-
-```toml
-# Build the profiler runtime (required when compiling with options that depend
-# on this runtime, such as `-C profile-generate` or `-Z instrument-coverage`).
-profiler = true
-```
-
-If changed, rebuild the Rust compiler (see [rustc-dev-guide-how-to-build-and-run]).
-
-### Building the demangler
-
-LLVM coverage reporting tools generate results that can include function names and other symbol references, and the raw coverage results report symbols using the compiler's "mangled" version of the symbol names, which can be difficult to interpret. To work around this issue, LLVM coverage tools also support a user-specified symbol name demangler.
-
-One option for a Rust demangler is [`rustfilt`], which can be installed with:
-
-```shell
-cargo install rustfilt
-```
-
-Another option, if you are building from the Rust compiler source distribution, is to use the `rust-demangler` tool included in the Rust source distribution, which can be built with:
-
-```shell
-$ ./x.py build rust-demangler
-```
-
-## Compiling with coverage enabled
-
-Set the `-Zinstrument-coverage` compiler flag in order to enable LLVM source-based code coverage profiling.
-
-With `cargo`, you can instrument your program binary *and* dependencies at the same time.
-
-For example (if your project's Cargo.toml builds a binary by default):
-
-```shell
-$ cd your-project
-$ cargo clean
-$ RUSTFLAGS="-Zinstrument-coverage" cargo build
-```
-
-If `cargo` is not configured to use your `profiler`-enabled version of `rustc`, set the path explicitly via the `RUSTC` environment variable. Here is another example, using a `stage1` build of `rustc` to compile an `example` binary (from the [`json5format`] crate):
-
-```shell
-$ RUSTC=$HOME/rust/build/x86_64-unknown-linux-gnu/stage1/bin/rustc \
- RUSTFLAGS="-Zinstrument-coverage" \
- cargo build --example formatjson5
-```
-
-Note that some compiler options, combined with `-Zinstrument-coverage`, can produce LLVM IR and/or linked binaries that are incompatible with LLVM coverage maps. For example, coverage requires references to actual functions in LLVM IR. If any covered function is optimized out, the coverage tools may not be able to process the coverage results. If you need to pass additional options, with coverage enabled, test them early, to confirm you will get the coverage results you expect.
-
-## Running the instrumented binary to generate raw coverage profiling data
-
-In the previous example, `cargo` generated the coverage-instrumented binary `formatjson5`:
-
-```shell
-$ echo "{some: 'thing'}" | target/debug/examples/formatjson5 -
-```
-```json5
-{
- some: 'thing',
-}
-```
-
-After running this program, a new file, `default.profraw`, should be in the current working directory. It's often preferable to set a specific file name or path. You can change the output file using the environment variable `LLVM_PROFILE_FILE`:
-
-
-```shell
-$ echo "{some: 'thing'}" \
- | LLVM_PROFILE_FILE="formatjson5.profraw" target/debug/examples/formatjson5 -
-...
-$ ls formatjson5.profraw
-formatjson5.profraw
-```
-
-If `LLVM_PROFILE_FILE` contains a path to a non-existent directory, the missing directory structure will be created. Additionally, the following special pattern strings are rewritten:
-
-* `%p` - The process ID.
-* `%h` - The hostname of the machine running the program.
-* `%t` - The value of the TMPDIR environment variable.
-* `%Nm` - the instrumented binary’s signature: The runtime creates a pool of N raw profiles, used for on-line profile merging. The runtime takes care of selecting a raw profile from the pool, locking it, and updating it before the program exits. `N` must be between `1` and `9`, and defaults to `1` if omitted (with simply `%m`).
-* `%c` - Does not add anything to the filename, but enables a mode (on some platforms, including Darwin) in which profile counter updates are continuously synced to a file. This means that if the instrumented program crashes, or is killed by a signal, perfect coverage information can still be recovered.
-
-## Installing LLVM coverage tools
-
-LLVM's supplies two tools—`llvm-profdata` and `llvm-cov`—that process coverage data and generate reports. There are several ways to find and/or install these tools, but note that the coverage mapping data generated by the Rust compiler requires LLVM version 11 or higher. (`llvm-cov --version` typically shows the tool's LLVM version number.):
-
-* The LLVM tools may be installed (or installable) directly to your OS (such as via `apt-get`, for Linux).
-* If you are building the Rust compiler from source, you can optionally use the bundled LLVM tools, built from source. Those tool binaries can typically be found in your build platform directory at something like: `rust/build/x86_64-unknown-linux-gnu/llvm/bin/llvm-*`.
-* You can install compatible versions of these tools via `rustup`.
-
-The `rustup` option is guaranteed to install a compatible version of the LLVM tools, but they can be hard to find. We recommend [`cargo-binutils`], which installs Rust-specific wrappers around these and other LLVM tools, so you can invoke them via `cargo` commands!
-
-```shell
-$ rustup component add llvm-tools-preview
-$ cargo install cargo-binutils
-$ cargo profdata -- --help # note the additional "--" preceding the tool-specific arguments
-```
-
-## Creating coverage reports
-
-Raw profiles have to be indexed before they can be used to generate coverage reports. This is done using [`llvm-profdata merge`] (or `cargo profdata -- merge`), which can combine multiple raw profiles and index them at the same time:
-
-```shell
-$ llvm-profdata merge -sparse formatjson5.profraw -o formatjson5.profdata
-```
-
-Finally, the `.profdata` file is used, in combination with the coverage map (from the program binary) to generate coverage reports using [`llvm-cov report`] (or `cargo cov -- report`), for a coverage summaries; and [`llvm-cov show`] (or `cargo cov -- show`), to see detailed coverage of lines and regions (character ranges) overlaid on the original source code.
-
-These commands have several display and filtering options. For example:
-
-```shell
-$ llvm-cov show -Xdemangler=rustfilt target/debug/examples/formatjson5 \
- -instr-profile=formatjson5.profdata \
- -show-line-counts-or-regions \
- -show-instantiations \
- -name=add_quoted_string
-```
-
-<img alt="Screenshot of sample `llvm-cov show` result, for function add_quoted_string" src="img/llvm-cov-show-01.png" class="center"/>
-<br/>
-<br/>
-
-Some of the more notable options in this example include:
-
-* `--Xdemangler=rustfilt` - the command name or path used to demangle Rust symbols (`rustfilt` in the example, but this could also be a path to the `rust-demangler` tool)
-* `target/debug/examples/formatjson5` - the instrumented binary (from which to extract the coverage map)
-* `--instr-profile=<path-to-file>.profdata` - the location of the `.profdata` file created by `llvm-profdata merge` (from the `.profraw` file generated by the instrumented binary)
-* `--name=<exact-function-name>` - to show coverage for a specific function (or, consider using another filter option, such as `--name-regex=<pattern>`)
-
-## Interpreting reports
-
-There are four statistics tracked in a coverage summary:
-
-* Function coverage is the percentage of functions that have been executed at least once. A function is considered to be executed if any of its instantiations are executed.
-* Instantiation coverage is the percentage of function instantiations that have been executed at least once. Generic functions and functions generated from macros are two kinds of functions that may have multiple instantiations.
-* Line coverage is the percentage of code lines that have been executed at least once. Only executable lines within function bodies are considered to be code lines.
-* Region coverage is the percentage of code regions that have been executed at least once. A code region may span multiple lines: for example, in a large function body with no control flow. In other cases, a single line can contain multiple code regions: `return x || (y && z)` has countable code regions for `x` (which may resolve the expression, if `x` is `true`), `|| (y && z)` (executed only if `x` was `false`), and `return` (executed in either situation).
-
-Of these four statistics, function coverage is usually the least granular while region coverage is the most granular. The project-wide totals for each statistic are listed in the summary.
-
-## Test coverage
-
-A typical use case for coverage analysis is test coverage. Rust's source-based coverage tools can both measure your tests' code coverage as percentage, and pinpoint functions and branches not tested.
-
-The following example (using the [`json5format`] crate, for demonstration purposes) show how to generate and analyze coverage results for all tests in a crate.
-
-Since `cargo test` both builds and runs the tests, we set both the additional `RUSTFLAGS`, to add the `-Zinstrument-coverage` flag, and `LLVM_PROFILE_FILE`, to set a custom filename for the raw profiling data generated during the test runs. Since there may be more than one test binary, apply `%m` in the filename pattern. This generates unique names for each test binary. (Otherwise, each executed test binary would overwrite the coverage results from the previous binary.)
-
-```shell
-$ RUSTFLAGS="-Zinstrument-coverage" \
- LLVM_PROFILE_FILE="json5format-%m.profraw" \
- cargo test --tests
-```
-
-Make note of the test binary file paths, displayed after the word "`Running`" in the test output:
-
-```text
- ...
- Compiling json5format v0.1.3 ($HOME/json5format)
- Finished test [unoptimized + debuginfo] target(s) in 14.60s
-
- Running target/debug/deps/json5format-fececd4653271682
-running 25 tests
-...
-test result: ok. 25 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
-
- Running target/debug/deps/lib-30768f9c53506dc5
-running 31 tests
-...
-test result: ok. 31 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
-```
-
-You should have one ore more `.profraw` files now, one for each test binary. Run the `profdata` tool to merge them:
-
-```shell
-$ cargo profdata -- merge \
- -sparse json5format-*.profraw -o json5format.profdata
-```
-
-Then run the `cov` tool, with the `profdata` file and all test binaries:
-
-```shell
-$ cargo cov -- report \
- --use-color --ignore-filename-regex='/.cargo/registry' \
- --instr-profile=json5format.profdata \
- --object target/debug/deps/lib-30768f9c53506dc5 \
- --object target/debug/deps/json5format-fececd4653271682
-$ cargo cov -- show \
- --use-color --ignore-filename-regex='/.cargo/registry' \
- --instr-profile=json5format.profdata \
- --object target/debug/deps/lib-30768f9c53506dc5 \
- --object target/debug/deps/json5format-fececd4653271682 \
- --show-instantiations --show-line-counts-or-regions \
- --Xdemangler=rustfilt | less -R
-```
-
-_Note the command line option `--ignore-filename-regex=/.cargo/registry`, which excludes the sources for dependencies from the coverage results._
-
-### Tips for listing the binaries automatically
-
-For `bash` users, one suggested way to automatically complete the `cov` command with the list of binaries is with a command like:
-
-```bash
-$ cargo cov -- report \
- $( \
- for file in \
- $( \
- RUSTFLAGS="-Zinstrument-coverage" \
- cargo test --tests --no-run --message-format=json \
- | jq -r "select(.profile.test == true) | .filenames[]" \
- | grep -v dSYM - \
- ); \
- do \
- printf "%s %s " -object $file; \
- done \
- ) \
- --instr-profile=json5format.profdata --summary-only # and/or other options
-```
-
-Adding `--no-run --message-format=json` to the _same_ `cargo test` command used to run
-the tests (including the same environment variables and flags) generates output in a JSON
-format that `jq` can easily query.
-
-The `printf` command takes this list and generates the `--object <binary>` arguments
-for each listed test binary.
-
-### Including doc tests
-
-The previous examples run `cargo test` with `--tests`, which excludes doc tests.[^79417]
-
-To include doc tests in the coverage results, drop the `--tests` flag, and apply the
-`-Zinstrument-coverage` flag, and some doc-test-specific options in the
-`RUSTDOCFLAGS` environment variable. (The `cargo profdata` command does not change.)
-
-```bash
-$ RUSTFLAGS="-Zinstrument-coverage" \
- RUSTDOCFLAGS="-Zinstrument-coverage -Zunstable-options --persist-doctests target/debug/doctestbins" \
- LLVM_PROFILE_FILE="json5format-%m.profraw" \
- cargo test
-$ cargo profdata -- merge \
- -sparse json5format-*.profraw -o json5format.profdata
-```
-
-The `-Zunstable-options --persist-doctests` flag is required, to save the test binaries
-(with their coverage maps) for `llvm-cov`.
-
-```bash
-$ cargo cov -- report \
- $( \
- for file in \
- $( \
- RUSTFLAGS="-Zinstrument-coverage" \
- RUSTDOCFLAGS="-Zinstrument-coverage -Zunstable-options --persist-doctests target/debug/doctestbins" \
- cargo test --no-run --message-format=json \
- | jq -r "select(.profile.test == true) | .filenames[]" \
- | grep -v dSYM - \
- ) \
- target/debug/doctestbins/*/rust_out; \
- do \
- [[ -x $file ]] && printf "%s %s " -object $file; \
- done \
- ) \
- --instr-profile=json5format.profdata --summary-only # and/or other options
-```
-
-Note, the differences in this `cargo cov` command, compared with the version without
-doc tests, include:
-
-* The `cargo test ... --no-run` command is updated with the same environment variables
- and flags used to _build_ the tests, _including_ the doc tests. (`LLVM_PROFILE_FILE`
- is only used when _running_ the tests.)
-* The file glob pattern `target/debug/doctestbins/*/rust_out` adds the `rust_out`
- binaries generated for doc tests (note, however, that some `rust_out` files may not
- be executable binaries).
-* `[[ -x $file ]] &&` filters the files passed on to the `printf`, to include only
- executable binaries.
-
-[^79417]: There is ongoing work to resolve a known issue
-[(#79417)](https://github.com/rust-lang/rust/issues/79417) that doc test coverage
-generates incorrect source line numbers in `llvm-cov show` results.
-
-## Other references
-
-Rust's implementation and workflow for source-based code coverage is based on the same library and tools used to implement [source-based code coverage in Clang]. (This document is partially based on the Clang guide.)
-
-[#79121]: https://github.com/rust-lang/rust/issues/79121
-[`-Zprofile`]: profile.md
-[`llvm.instrprof.increment`]: https://llvm.org/docs/LangRef.html#llvm-instrprof-increment-intrinsic
-[LLVM Code Coverage Mapping Format]: https://llvm.org/docs/CoverageMappingFormat.html
-[rustc-dev-guide-how-to-build-and-run]: https://rustc-dev-guide.rust-lang.org/building/how-to-build-and-run.html
-[`rustfilt`]: https://crates.io/crates/rustfilt
-[`json5format`]: https://crates.io/crates/json5format
-[`cargo-binutils`]: https://crates.io/crates/cargo-binutils
-[`llvm-profdata merge`]: https://llvm.org/docs/CommandGuide/llvm-profdata.html#profdata-merge
-[`llvm-cov report`]: https://llvm.org/docs/CommandGuide/llvm-cov.html#llvm-cov-report
-[`llvm-cov show`]: https://llvm.org/docs/CommandGuide/llvm-cov.html#llvm-cov-show
-[source-based code coverage in Clang]: https://clang.llvm.org/docs/SourceBasedCodeCoverage.html
+[`-z instrument-coverage`]: ./instrument-coverage.html
--- /dev/null
+# `native_link_modifiers_as_needed`
+
+The tracking issue for this feature is: [#81490]
+
+[#81490]: https://github.com/rust-lang/rust/issues/81490
+
+------------------------
+
+The `native_link_modifiers_as_needed` feature allows you to use the `as-needed` modifier.
+
+`as-needed` is only compatible with the `dynamic` and `framework` linking kinds. Using any other kind will result in a compiler error.
+
+`+as-needed` means that the library will be actually linked only if it satisfies some undefined symbols at the point at which it is specified on the command line, making it similar to static libraries in this regard.
+
+This modifier translates to `--as-needed` for ld-like linkers, and to `-dead_strip_dylibs` / `-needed_library` / `-needed_framework` for ld64.
+The modifier does nothing for linkers that don't support it (e.g. `link.exe`).
+
+The default for this modifier is unclear, some targets currently specify it as `+as-needed`, some do not. We may want to try making `+as-needed` a default for all targets.
--- /dev/null
+# `native_link_modifiers_bundle`
+
+The tracking issue for this feature is: [#81490]
+
+[#81490]: https://github.com/rust-lang/rust/issues/81490
+
+------------------------
+
+The `native_link_modifiers_bundle` feature allows you to use the `bundle` modifier.
+
+Only compatible with the `static` linking kind. Using any other kind will result in a compiler error.
+
+`+bundle` means objects from the static library are bundled into the produced crate (a rlib, for example) and are used from this crate later during linking of the final binary.
+
+`-bundle` means the static library is included into the produced rlib "by name" and object files from it are included only during linking of the final binary, the file search by that name is also performed during final linking.
+
+This modifier is supposed to supersede the `static-nobundle` linking kind defined by [RFC 1717](https://github.com/rust-lang/rfcs/pull/1717).
+
+The default for this modifier is currently `+bundle`, but it could be changed later on some future edition boundary.
--- /dev/null
+# `native_link_modifiers_verbatim`
+
+The tracking issue for this feature is: [#81490]
+
+[#81490]: https://github.com/rust-lang/rust/issues/81490
+
+------------------------
+
+The `native_link_modifiers_verbatim` feature allows you to use the `verbatim` modifier.
+
+`+verbatim` means that rustc itself won't add any target-specified library prefixes or suffixes (like `lib` or `.a`) to the library name, and will try its best to ask for the same thing from the linker.
+
+For `ld`-like linkers rustc will use the `-l:filename` syntax (note the colon) when passing the library, so the linker won't add any prefixes or suffixes as well.
+See [`-l namespec`](https://sourceware.org/binutils/docs/ld/Options.html) in ld documentation for more details.
+For linkers not supporting any verbatim modifiers (e.g. `link.exe` or `ld64`) the library name will be passed as is.
+
+The default for this modifier is `-verbatim`.
+
+This RFC changes the behavior of `raw-dylib` linking kind specified by [RFC 2627](https://github.com/rust-lang/rfcs/pull/2627). The `.dll` suffix (or other target-specified suffixes for other targets) is now added automatically.
+If your DLL doesn't have the `.dll` suffix, it can be specified with `+verbatim`.
--- /dev/null
+# `native_link_modifiers_whole_archive`
+
+The tracking issue for this feature is: [#81490]
+
+[#81490]: https://github.com/rust-lang/rust/issues/81490
+
+------------------------
+
+The `native_link_modifiers_whole_archive` feature allows you to use the `whole-archive` modifier.
+
+Only compatible with the `static` linking kind. Using any other kind will result in a compiler error.
+
+`+whole-archive` means that the static library is linked as a whole archive without throwing any object files away.
+
+This modifier translates to `--whole-archive` for `ld`-like linkers, to `/WHOLEARCHIVE` for `link.exe`, and to `-force_load` for `ld64`.
+The modifier does nothing for linkers that don't support it.
+
+The default for this modifier is `-whole-archive`.
--- /dev/null
+# `native_link_modifiers`
+
+The tracking issue for this feature is: [#81490]
+
+[#81490]: https://github.com/rust-lang/rust/issues/81490
+
+------------------------
+
+The `native_link_modifiers` feature allows you to use the `modifiers` syntax with the `#[link(..)]` attribute.
+
+Modifiers are specified as a comma-delimited string with each modifier prefixed with either a `+` or `-` to indicate that the modifier is enabled or disabled, respectively. The last boolean value specified for a given modifier wins.
--- /dev/null
+# `no_coverage`
+
+The tracking issue for this feature is: [#84605]
+
+[#84605]: https://github.com/rust-lang/rust/issues/84605
+
+---
+
+The `no_coverage` attribute can be used to selectively disable coverage
+instrumentation in an annotated function. This might be useful to:
+
+- Avoid instrumentation overhead in a performance critical function
+- Avoid generating coverage for a function that is not meant to be executed,
+ but still target 100% coverage for the rest of the program.
+
+## Example
+
+```rust
+#![feature(no_coverage)]
+
+// `foo()` will get coverage instrumentation (by default)
+fn foo() {
+ // ...
+}
+
+#[no_coverage]
+fn bar() {
+ // ...
+}
+```
| Architecture | Register class | Registers | LLVM constraint code |
| ------------ | -------------- | --------- | -------------------- |
-| x86 | `reg` | `ax`, `bx`, `cx`, `dx`, `si`, `di`, `r[8-15]` (x86-64 only) | `r` |
+| x86 | `reg` | `ax`, `bx`, `cx`, `dx`, `si`, `di`, `bp`, `r[8-15]` (x86-64 only) | `r` |
| x86 | `reg_abcd` | `ax`, `bx`, `cx`, `dx` | `Q` |
| x86-32 | `reg_byte` | `al`, `bl`, `cl`, `dl`, `ah`, `bh`, `ch`, `dh` | `q` |
-| x86-64 | `reg_byte`\* | `al`, `bl`, `cl`, `dl`, `sil`, `dil`, `r[8-15]b` | `q` |
+| x86-64 | `reg_byte`\* | `al`, `bl`, `cl`, `dl`, `sil`, `dil`, `bpl`, `r[8-15]b` | `q` |
| x86 | `xmm_reg` | `xmm[0-7]` (x86) `xmm[0-15]` (x86-64) | `x` |
| x86 | `ymm_reg` | `ymm[0-7]` (x86) `ymm[0-15]` (x86-64) | `x` |
| x86 | `zmm_reg` | `zmm[0-7]` (x86) `zmm[0-31]` (x86-64) | `v` |
| x86 | `kreg` | `k[1-7]` | `Yk` |
-| AArch64 | `reg` | `x[0-28]`, `x30` | `r` |
+| AArch64 | `reg` | `x[0-30]` | `r` |
| AArch64 | `vreg` | `v[0-31]` | `w` |
| AArch64 | `vreg_low16` | `v[0-15]` | `x` |
-| ARM | `reg` | `r[0-5]` `r7`\*, `r[8-10]`, `r11`\*, `r12`, `r14` | `r` |
+| ARM | `reg` | `r[0-12]`, `r14` | `r` |
| ARM (Thumb) | `reg_thumb` | `r[0-r7]` | `l` |
-| ARM (ARM) | `reg_thumb` | `r[0-r10]`, `r12`, `r14` | `l` |
+| ARM (ARM) | `reg_thumb` | `r[0-r12]`, `r14` | `l` |
| ARM | `sreg` | `s[0-31]` | `t` |
| ARM | `sreg_low16` | `s[0-15]` | `x` |
| ARM | `dreg` | `d[0-31]` | `w` |
>
> Note #3: NVPTX doesn't have a fixed register set, so named registers are not supported.
>
-> Note #4: On ARM the frame pointer is either `r7` or `r11` depending on the platform.
->
-> Note #5: WebAssembly doesn't have registers, so named registers are not supported.
+> Note #4: WebAssembly doesn't have registers, so named registers are not supported.
Additional register classes may be added in the future based on demand (e.g. MMX, x87, etc).
| All | `sp` | The stack pointer must be restored to its original value at the end of an asm code block. |
| All | `bp` (x86), `x29` (AArch64), `x8` (RISC-V), `fr` (Hexagon), `$fp` (MIPS) | The frame pointer cannot be used as an input or output. |
| ARM | `r7` or `r11` | On ARM the frame pointer can be either `r7` or `r11` depending on the target. The frame pointer cannot be used as an input or output. |
-| ARM | `r6` | `r6` is used internally by LLVM as a base pointer and therefore cannot be used as an input or output. |
+| All | `si` (x86-32), `bx` (x86-64), `r6` (ARM), `x19` (AArch64), `r19` (Hexagon), `x9` (RISC-V) | This is used internally by LLVM as a "base pointer" for functions with complex stack frames. |
| x86 | `k0` | This is a constant zero register which can't be modified. |
| x86 | `ip` | This is the program counter, not a real register. |
| x86 | `mm[0-7]` | MMX registers are not currently supported (but may be in the future). |
| x86 | `st([0-7])` | x87 registers are not currently supported (but may be in the future). |
| AArch64 | `xzr` | This is a constant zero register which can't be modified. |
| ARM | `pc` | This is the program counter, not a real register. |
+| ARM | `r9` | This is a reserved register on some ARM targets. |
| MIPS | `$0` or `$zero` | This is a constant zero register which can't be modified. |
| MIPS | `$1` or `$at` | Reserved for assembler. |
| MIPS | `$26`/`$k0`, `$27`/`$k1` | OS-reserved registers. |
| RISC-V | `gp`, `tp` | These registers are reserved and cannot be used as inputs or outputs. |
| Hexagon | `lr` | This is the link register which cannot be used as an input or output. |
-In some cases LLVM will allocate a "reserved register" for `reg` operands even though this register cannot be explicitly specified. Assembly code making use of reserved registers should be careful since `reg` operands may alias with those registers. Reserved registers are:
-- The frame pointer on all architectures.
-- `r6` on ARM.
+In some cases LLVM will allocate a "reserved register" for `reg` operands even though this register cannot be explicitly specified. Assembly code making use of reserved registers should be careful since `reg` operands may alias with those registers. Reserved registers are the frame pointer and base pointer
+- The frame pointer and LLVM base pointer on all architectures.
+- `r9` on ARM.
+- `x18` on AArch64.
## Template modifiers
name: None,
attrs: Default::default(),
visibility: Inherited,
- def_id: self.cx.next_def_id(item_def_id.krate),
+ def_id: FakeDefId::new_fake(item_def_id.krate),
kind: box ImplItem(Impl {
span: Span::dummy(),
unsafety: hir::Unsafety::Normal,
generics: new_generics,
- provided_trait_methods: Default::default(),
trait_: Some(trait_ref.clean(self.cx).get_trait_type().unwrap()),
for_: ty.clean(self.cx),
items: Vec::new(),
}
self.cx.generated_synthetics.insert((ty, trait_def_id));
- let provided_trait_methods = self
- .cx
- .tcx
- .provided_trait_methods(trait_def_id)
- .map(|meth| meth.ident.name)
- .collect();
impls.push(Item {
name: None,
attrs: Default::default(),
visibility: Inherited,
- def_id: self.cx.next_def_id(impl_def_id.krate),
+ def_id: FakeDefId::new_fake(item_def_id.krate),
kind: box ImplItem(Impl {
span: self.cx.tcx.def_span(impl_def_id).clean(self.cx),
unsafety: hir::Unsafety::Normal,
self.cx.tcx.explicit_predicates_of(impl_def_id),
)
.clean(self.cx),
- provided_trait_methods,
// FIXME(eddyb) compute both `trait_` and `for_` from
// the post-inference `trait_ref`, as it's more accurate.
trait_: Some(trait_ref.clean(self.cx).get_trait_type().unwrap()),
use rustc_span::symbol::{kw, sym, Symbol};
use rustc_span::Span;
-use crate::clean::{self, Attributes, AttributesExt, GetDefId, ToSource};
+use crate::clean::{self, Attributes, AttributesExt, FakeDefId, GetDefId, ToSource};
use crate::core::DocContext;
use crate::formats::item_type::ItemType;
-use super::Clean;
+use super::{Clean, Visibility};
type Attrs<'hir> = rustc_middle::ty::Attributes<'hir>;
};
let (attrs, cfg) = merge_attrs(cx, Some(parent_module), load_attrs(cx, did), attrs_clone);
- cx.inlined.insert(did);
+ cx.inlined.insert(did.into());
ret.push(clean::Item::from_def_id_and_attrs_and_parts(
did,
Some(name),
if did.is_local() {
cx.cache.exact_paths.insert(did, fqn);
} else {
- cx.cache.external_paths.insert(did, (fqn, ItemType::from(kind)));
+ cx.cache.external_paths.insert(did, (fqn, kind));
}
}
crate fn build_external_trait(cx: &mut DocContext<'_>, did: DefId) -> clean::Trait {
- let trait_items =
- cx.tcx.associated_items(did).in_definition_order().map(|item| item.clean(cx)).collect();
+ let trait_items = cx
+ .tcx
+ .associated_items(did)
+ .in_definition_order()
+ .map(|item| {
+ // When building an external trait, the cleaned trait will have all items public,
+ // which causes methods to have a `pub` prefix, which is invalid since items in traits
+ // can not have a visibility prefix. Thus we override the visibility here manually.
+ // See https://github.com/rust-lang/rust/issues/81274
+ clean::Item { visibility: Visibility::Inherited, ..item.clean(cx) }
+ })
+ .collect();
let predicates = cx.tcx.predicates_of(did);
let generics = (cx.tcx.generics_of(did), predicates).clean(cx);
attrs: Option<Attrs<'_>>,
ret: &mut Vec<clean::Item>,
) {
- if !cx.inlined.insert(did) {
+ if !cx.inlined.insert(did.into()) {
return;
}
record_extern_trait(cx, trait_did);
}
- let provided = trait_
- .def_id()
- .map(|did| tcx.provided_trait_methods(did).map(|meth| meth.ident.name).collect())
- .unwrap_or_default();
-
- debug!("build_impl: impl {:?} for {:?}", trait_.def_id(), for_.def_id());
-
let (merged_attrs, cfg) = merge_attrs(cx, parent_module.into(), load_attrs(cx, did), attrs);
debug!("merged_attrs={:?}", merged_attrs);
+ debug!("build_impl: impl {:?} for {:?}", trait_.def_id(), for_.def_id());
ret.push(clean::Item::from_def_id_and_attrs_and_parts(
did,
None,
span: clean::types::rustc_span(did, cx.tcx),
unsafety: hir::Unsafety::Normal,
generics,
- provided_trait_methods: provided,
trait_,
for_,
items: trait_items,
items.push(clean::Item {
name: None,
attrs: box clean::Attributes::default(),
- def_id: cx.next_def_id(did.krate),
+ def_id: FakeDefId::new_fake(did.krate),
visibility: clean::Public,
kind: box clean::ImportItem(clean::Import::new_simple(
item.ident.name,
use rustc_hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
use rustc_index::vec::{Idx, IndexVec};
use rustc_infer::infer::region_constraints::{Constraint, RegionConstraintData};
-use rustc_middle::bug;
use rustc_middle::middle::resolve_lifetime as rl;
use rustc_middle::ty::fold::TypeFolder;
use rustc_middle::ty::subst::{InternalSubsts, Subst};
use rustc_middle::ty::{self, AdtKind, Lift, Ty, TyCtxt};
+use rustc_middle::{bug, span_bug};
use rustc_mir::const_eval::{is_const_fn, is_unstable_const_fn};
use rustc_span::hygiene::{AstPass, MacroKind};
use rustc_span::symbol::{kw, sym, Ident, Symbol};
// determine if we should display the inner contents or
// the outer `mod` item for the source code.
let span = Span::from_rustc_span({
+ let where_outer = self.where_outer(cx.tcx);
let sm = cx.sess().source_map();
- let outer = sm.lookup_char_pos(self.where_outer.lo());
+ let outer = sm.lookup_char_pos(where_outer.lo());
let inner = sm.lookup_char_pos(self.where_inner.lo());
if outer.file.start_pos == inner.file.start_pos {
// mod foo { ... }
- self.where_outer
+ where_outer
} else {
// mod foo; (and a separate SourceFile for the contents)
self.where_inner
impl Clean<Type> for (ty::TraitRef<'_>, &[TypeBinding]) {
fn clean(&self, cx: &mut DocContext<'_>) -> Type {
let (trait_ref, bounds) = *self;
- inline::record_extern_fqn(cx, trait_ref.def_id, ItemType::Trait);
+ let kind = cx.tcx.def_kind(trait_ref.def_id).into();
+ if !matches!(kind, ItemType::Trait | ItemType::TraitAlias) {
+ span_bug!(
+ cx.tcx.def_span(trait_ref.def_id),
+ "`TraitRef` had unexpected kind {:?}",
+ kind
+ );
+ }
+ inline::record_extern_fqn(cx, trait_ref.def_id, kind);
let path = external_path(
cx,
cx.tcx.item_name(trait_ref.def_id),
match param.kind {
GenericParamDefKind::Lifetime => unreachable!(),
GenericParamDefKind::Type { did, ref bounds, .. } => {
- cx.impl_trait_bounds.insert(did.into(), bounds.clone());
+ cx.impl_trait_bounds
+ .insert(FakeDefId::new_real(did).into(), bounds.clone());
}
GenericParamDefKind::Const { .. } => unreachable!(),
}
.collect::<Vec<GenericParamDef>>();
// param index -> [(DefId of trait, associated type name, type)]
- let mut impl_trait_proj = FxHashMap::<u32, Vec<(DefId, Symbol, Ty<'tcx>)>>::default();
+ let mut impl_trait_proj = FxHashMap::<u32, Vec<(FakeDefId, Symbol, Ty<'tcx>)>>::default();
let where_predicates = preds
.predicates
if let Some(((_, trait_did, name), rhs)) =
proj.as_ref().and_then(|(lhs, rhs)| Some((lhs.projection()?, rhs)))
{
- impl_trait_proj
- .entry(param_idx)
- .or_default()
- .push((trait_did, name, rhs));
+ impl_trait_proj.entry(param_idx).or_default().push((
+ trait_did.into(),
+ name,
+ rhs,
+ ));
}
return None;
if let Some(proj) = impl_trait_proj.remove(&idx) {
for (trait_did, name, rhs) in proj {
let rhs = rhs.clean(cx);
- simplify::merge_bounds(cx, &mut bounds, trait_did, name, &rhs);
+ simplify::merge_bounds(
+ cx,
+ &mut bounds,
+ trait_did.expect_real(),
+ name,
+ &rhs,
+ );
}
}
} else {
if let Some(new_ty) = cx.ty_substs.get(&did).cloned() {
return new_ty;
}
- if let Some(bounds) = cx.impl_trait_bounds.remove(&did.into()) {
+ if let Some(bounds) = cx.impl_trait_bounds.remove(&FakeDefId::new_real(did).into())
+ {
return ImplTrait(bounds);
}
}
build_deref_target_impls(cx, &items, &mut ret);
}
- let provided: FxHashSet<Symbol> = trait_
- .def_id()
- .map(|did| tcx.provided_trait_methods(did).map(|meth| meth.ident.name).collect())
- .unwrap_or_default();
-
let for_ = impl_.self_ty.clean(cx);
let type_alias = for_.def_id().and_then(|did| match tcx.def_kind(did) {
DefKind::TyAlias => Some(tcx.type_of(did).clean(cx)),
span: types::rustc_span(tcx.hir().local_def_id(hir_id).to_def_id(), tcx),
unsafety: impl_.unsafety,
generics: impl_.generics.clean(cx),
- provided_trait_methods: provided.clone(),
trait_,
for_,
items,
vec![Item {
name: Some(name),
attrs: box attrs.clean(cx),
- def_id: crate_def_id,
+ def_id: crate_def_id.into(),
visibility: krate.vis.clean(cx),
kind: box ExternCrateItem { src: orig_name },
cfg: attrs.cfg(cx.sess()),
-use std::cell::RefCell;
+use std::cell::{Cell, RefCell};
use std::default::Default;
-use std::fmt;
use std::hash::{Hash, Hasher};
use std::iter::FromIterator;
use std::lazy::SyncOnceCell as OnceCell;
+use std::path::PathBuf;
use std::rc::Rc;
use std::sync::Arc;
use std::{slice, vec};
use rustc_data_structures::thin_vec::ThinVec;
use rustc_hir as hir;
use rustc_hir::def::{CtorKind, DefKind, Res};
-use rustc_hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX};
+use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE};
use rustc_hir::lang_items::LangItem;
use rustc_hir::{BodyId, Mutability};
use rustc_index::vec::IndexVec;
use self::SelfTy::*;
use self::Type::*;
-thread_local!(crate static MAX_DEF_IDX: RefCell<FxHashMap<CrateNum, DefIndex>> = Default::default());
+crate type FakeDefIdSet = FxHashSet<FakeDefId>;
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)]
+crate enum FakeDefId {
+ Real(DefId),
+ Fake(DefIndex, CrateNum),
+}
+
+impl FakeDefId {
+ #[cfg(parallel_compiler)]
+ crate fn new_fake(crate: CrateNum) -> Self {
+ unimplemented!("")
+ }
+
+ #[cfg(not(parallel_compiler))]
+ crate fn new_fake(krate: CrateNum) -> Self {
+ thread_local!(static FAKE_DEF_ID_COUNTER: Cell<usize> = Cell::new(0));
+ let id = FAKE_DEF_ID_COUNTER.with(|id| {
+ let tmp = id.get();
+ id.set(tmp + 1);
+ tmp
+ });
+ Self::Fake(DefIndex::from(id), krate)
+ }
+
+ crate fn new_real(id: DefId) -> Self {
+ Self::Real(id)
+ }
+
+ #[inline]
+ crate fn is_local(self) -> bool {
+ match self {
+ FakeDefId::Real(id) => id.is_local(),
+ FakeDefId::Fake(_, krate) => krate == LOCAL_CRATE,
+ }
+ }
+
+ #[inline]
+ crate fn as_local(self) -> Option<LocalDefId> {
+ match self {
+ FakeDefId::Real(id) => id.as_local(),
+ FakeDefId::Fake(idx, krate) => {
+ (krate == LOCAL_CRATE).then(|| LocalDefId { local_def_index: idx })
+ }
+ }
+ }
+
+ #[inline]
+ crate fn expect_local(self) -> LocalDefId {
+ self.as_local()
+ .unwrap_or_else(|| panic!("FakeDefId::expect_local: `{:?}` isn't local", self))
+ }
+
+ #[inline]
+ crate fn expect_real(self) -> rustc_hir::def_id::DefId {
+ self.as_real().unwrap_or_else(|| panic!("FakeDefId::expect_real: `{:?}` isn't real", self))
+ }
+
+ #[inline]
+ crate fn as_real(self) -> Option<DefId> {
+ match self {
+ FakeDefId::Real(id) => Some(id),
+ FakeDefId::Fake(_, _) => None,
+ }
+ }
+
+ #[inline]
+ crate fn krate(self) -> CrateNum {
+ match self {
+ FakeDefId::Real(id) => id.krate,
+ FakeDefId::Fake(_, krate) => krate,
+ }
+ }
+
+ #[inline]
+ crate fn index(self) -> Option<DefIndex> {
+ match self {
+ FakeDefId::Real(id) => Some(id.index),
+ FakeDefId::Fake(_, _) => None,
+ }
+ }
+}
+
+impl From<DefId> for FakeDefId {
+ fn from(id: DefId) -> Self {
+ Self::Real(id)
+ }
+}
#[derive(Clone, Debug)]
crate struct Crate {
tcx.crate_name(self.crate_num)
}
+ crate fn src_root(&self, tcx: TyCtxt<'_>) -> PathBuf {
+ match self.src(tcx) {
+ FileName::Real(ref p) => match p.local_path().parent() {
+ Some(p) => p.to_path_buf(),
+ None => PathBuf::new(),
+ },
+ _ => PathBuf::new(),
+ }
+ }
+
+ /// Attempts to find where an external crate is located, given that we're
+ /// rendering in to the specified source destination.
+ crate fn location(
+ &self,
+ extern_url: Option<&str>,
+ dst: &std::path::Path,
+ tcx: TyCtxt<'_>,
+ ) -> ExternalLocation {
+ use ExternalLocation::*;
+
+ fn to_remote(url: impl ToString) -> ExternalLocation {
+ let mut url = url.to_string();
+ if !url.ends_with('/') {
+ url.push('/');
+ }
+ Remote(url)
+ }
+
+ // See if there's documentation generated into the local directory
+ // WARNING: since rustdoc creates these directories as it generates documentation, this check is only accurate before rendering starts.
+ // Make sure to call `location()` by that time.
+ let local_location = dst.join(&*self.name(tcx).as_str());
+ if local_location.is_dir() {
+ return Local;
+ }
+
+ if let Some(url) = extern_url {
+ return to_remote(url);
+ }
+
+ // Failing that, see if there's an attribute specifying where to find this
+ // external crate
+ let did = DefId { krate: self.crate_num, index: CRATE_DEF_INDEX };
+ tcx.get_attrs(did)
+ .lists(sym::doc)
+ .filter(|a| a.has_name(sym::html_root_url))
+ .filter_map(|a| a.value_str())
+ .map(to_remote)
+ .next()
+ .unwrap_or(Unknown) // Well, at least we tried.
+ }
+
crate fn keywords(&self, tcx: TyCtxt<'_>) -> ThinVec<(DefId, Symbol)> {
let root = self.def_id();
/// Anything with a source location and set of attributes and, optionally, a
/// name. That is, anything that can be documented. This doesn't correspond
/// directly to the AST's concept of an item; it's a strict superset.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
crate struct Item {
/// The name of this item.
/// Optional because not every item has a name, e.g. impls.
/// Information about this item that is specific to what kind of item it is.
/// E.g., struct vs enum vs function.
crate kind: Box<ItemKind>,
- crate def_id: DefId,
+ crate def_id: FakeDefId,
crate cfg: Option<Arc<Cfg>>,
}
#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
rustc_data_structures::static_assert_size!(Item, 48);
-impl fmt::Debug for Item {
- fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
- let def_id: &dyn fmt::Debug = if self.is_fake() { &"**FAKE**" } else { &self.def_id };
-
- fmt.debug_struct("Item")
- .field("name", &self.name)
- .field("attrs", &self.attrs)
- .field("kind", &self.kind)
- .field("visibility", &self.visibility)
- .field("def_id", def_id)
- .field("cfg", &self.cfg)
- .finish()
- }
-}
-
crate fn rustc_span(def_id: DefId, tcx: TyCtxt<'_>) -> Span {
Span::from_rustc_span(def_id.as_local().map_or_else(
|| tcx.def_span(def_id),
impl Item {
crate fn stability<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Option<&'tcx Stability> {
- if self.is_fake() { None } else { tcx.lookup_stability(self.def_id) }
+ if self.is_fake() { None } else { tcx.lookup_stability(self.def_id.expect_real()) }
}
crate fn const_stability<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Option<&'tcx ConstStability> {
- if self.is_fake() { None } else { tcx.lookup_const_stability(self.def_id) }
+ if self.is_fake() { None } else { tcx.lookup_const_stability(self.def_id.expect_real()) }
}
crate fn deprecation(&self, tcx: TyCtxt<'_>) -> Option<Deprecation> {
- if self.is_fake() { None } else { tcx.lookup_deprecation(self.def_id) }
+ if self.is_fake() { None } else { tcx.lookup_deprecation(self.def_id.expect_real()) }
}
crate fn inner_docs(&self, tcx: TyCtxt<'_>) -> bool {
- if self.is_fake() { false } else { tcx.get_attrs(self.def_id).inner_docs() }
+ if self.is_fake() { false } else { tcx.get_attrs(self.def_id.expect_real()).inner_docs() }
}
crate fn span(&self, tcx: TyCtxt<'_>) -> Span {
} else if self.is_fake() {
Span::dummy()
} else {
- rustc_span(self.def_id, tcx)
+ rustc_span(self.def_id.expect_real(), tcx)
}
}
trace!("name={:?}, def_id={:?}", name, def_id);
Item {
- def_id,
+ def_id: def_id.into(),
kind: box kind,
name,
attrs,
.map_or(&[][..], |v| v.as_slice())
.iter()
.filter_map(|ItemLink { link: s, link_text, did, ref fragment }| {
- match *did {
+ match did {
Some(did) => {
- if let Some((mut href, ..)) = href(did, cx) {
+ if let Some((mut href, ..)) = href(did.expect_real(), cx) {
if let Some(ref fragment) = *fragment {
href.push('#');
href.push_str(fragment);
None => {
let relative_to = &cx.current;
if let Some(ref fragment) = *fragment {
- let url = match cx.cache().extern_locations.get(&self.def_id.krate) {
- Some(&(_, _, ExternalLocation::Local)) => {
+ let url = match cx.cache().extern_locations.get(&self.def_id.krate()) {
+ Some(&ExternalLocation::Local) => {
if relative_to[0] == "std" {
let depth = relative_to.len() - 1;
"../".repeat(depth)
format!("{}std/", "../".repeat(depth))
}
}
- Some(&(_, _, ExternalLocation::Remote(ref s))) => {
+ Some(ExternalLocation::Remote(ref s)) => {
format!("{}/std/", s.trim_end_matches('/'))
}
- Some(&(_, _, ExternalLocation::Unknown)) | None => format!(
- "https://doc.rust-lang.org/{}/std/",
- crate::doc_rust_lang_org_channel(),
- ),
+ Some(ExternalLocation::Unknown) | None => {
+ "https://doc.rust-lang.org/nightly/std/".to_string()
+ }
};
// This is a primitive so the url is done "by hand".
let tail = fragment.find('#').unwrap_or_else(|| fragment.len());
}
crate fn is_crate(&self) -> bool {
- self.is_mod() && self.def_id.index == CRATE_DEF_INDEX
+ self.is_mod() && self.def_id.as_real().map_or(false, |did| did.index == CRATE_DEF_INDEX)
}
crate fn is_mod(&self) -> bool {
}
}
- /// See the documentation for [`next_def_id()`].
- ///
- /// [`next_def_id()`]: DocContext::next_def_id()
crate fn is_fake(&self) -> bool {
- MAX_DEF_IDX.with(|m| {
- m.borrow().get(&self.def_id.krate).map(|&idx| idx <= self.def_id.index).unwrap_or(false)
- })
+ matches!(self.def_id, FakeDefId::Fake(_, _))
}
}
| KeywordItem(_) => [].iter(),
}
}
-
- crate fn is_type_alias(&self) -> bool {
- matches!(self, ItemKind::TypedefItem(..) | ItemKind::AssocTypeItem(..))
- }
}
#[derive(Clone, Debug)]
/// This may not be the same as `link` if there was a disambiguator
/// in an intra-doc link (e.g. \[`fn@f`\])
pub(crate) link_text: String,
- pub(crate) did: Option<DefId>,
+ pub(crate) did: Option<FakeDefId>,
/// The url fragment to append to the link
pub(crate) fragment: Option<String>,
}
}
}
- let clean_attr = |(attr, parent_module): (&ast::Attribute, _)| {
+ let clean_attr = |(attr, parent_module): (&ast::Attribute, Option<DefId>)| {
if let Some(value) = attr.doc_str() {
trace!("got doc_str={:?}", value);
let value = beautify_doc_string(value);
impl Type {
fn inner_def_id(&self, cache: Option<&Cache>) -> Option<DefId> {
let t: PrimitiveType = match *self {
- ResolvedPath { did, .. } => return Some(did),
+ ResolvedPath { did, .. } => return Some(did.into()),
Primitive(p) => return cache.and_then(|c| c.primitive_locations.get(&p).cloned()),
BorrowedRef { type_: box Generic(..), .. } => PrimitiveType::Reference,
BorrowedRef { ref type_, .. } => return type_.inner_def_id(cache),
crate span: Span,
crate unsafety: hir::Unsafety,
crate generics: Generics,
- crate provided_trait_methods: FxHashSet<Symbol>,
crate trait_: Option<Type>,
crate for_: Type,
crate items: Vec<Item>,
crate blanket_impl: Option<Type>,
}
+impl Impl {
+ crate fn provided_trait_methods(&self, tcx: TyCtxt<'_>) -> FxHashSet<Symbol> {
+ self.trait_
+ .def_id()
+ .map(|did| tcx.provided_trait_methods(did).map(|meth| meth.ident.name).collect())
+ .unwrap_or_default()
+ }
+}
+
#[derive(Clone, Debug)]
crate struct Import {
crate kind: ImportKind,
use rustc_span::symbol::{kw, sym, Symbol};
use std::mem;
+#[cfg(test)]
+mod tests;
+
crate fn krate(cx: &mut DocContext<'_>) -> Crate {
use crate::visit_lib::LibEmbargoVisitor;
// `#[doc(masked)]` to the injected `extern crate` because it's unstable.
if it.is_extern_crate()
&& (it.attrs.has_doc_flag(sym::masked)
- || cx.tcx.is_compiler_builtins(it.def_id.krate))
+ || cx.tcx.is_compiler_builtins(it.def_id.krate()))
{
- cx.cache.masked_crates.insert(it.def_id.krate);
+ cx.cache.masked_crates.insert(it.def_id.krate());
}
}
}
fn format_integer_with_underscore_sep(num: &str) -> String {
let num_chars: Vec<_> = num.chars().collect();
- let num_start_index = if num_chars.get(0) == Some(&'-') { 1 } else { 0 };
+ let mut num_start_index = if num_chars.get(0) == Some(&'-') { 1 } else { 0 };
+ let chunk_size = match num[num_start_index..].as_bytes() {
+ [b'0', b'b' | b'x', ..] => {
+ num_start_index += 2;
+ 4
+ }
+ [b'0', b'o', ..] => {
+ num_start_index += 2;
+ let remaining_chars = num_chars.len() - num_start_index;
+ if remaining_chars <= 6 {
+ // don't add underscores to Unix permissions like 0755 or 100755
+ return num.to_string();
+ }
+ 3
+ }
+ _ => 3,
+ };
num_chars[..num_start_index]
.iter()
- .chain(num_chars[num_start_index..].rchunks(3).rev().intersperse(&['_']).flatten())
+ .chain(num_chars[num_start_index..].rchunks(chunk_size).rev().intersperse(&['_']).flatten())
.collect()
}
}
/// Find the nearest parent module of a [`DefId`].
-///
-/// **Panics if the item it belongs to [is fake][Item::is_fake].**
crate fn find_nearest_parent_module(tcx: TyCtxt<'_>, def_id: DefId) -> Option<DefId> {
if def_id.is_top_level_module() {
// The crate root has no parent. Use it as the root instead.
&& attr.meta_item_list().map_or(false, |l| rustc_attr::list_contains_name(&l, flag))
})
}
-
-/// Return a channel suitable for using in a `doc.rust-lang.org/{channel}` format string.
-crate fn doc_rust_lang_org_channel() -> &'static str {
- match env!("CFG_RELEASE_CHANNEL") {
- "stable" => env!("CFG_RELEASE_NUM"),
- "beta" => "beta",
- "nightly" | "dev" => "nightly",
- // custom build of rustdoc maybe? link to the stable docs just in case
- _ => "",
- }
-}
--- /dev/null
+use super::*;
+
+#[test]
+fn int_format_decimal() {
+ assert_eq!(format_integer_with_underscore_sep("12345678"), "12_345_678");
+ assert_eq!(format_integer_with_underscore_sep("123"), "123");
+ assert_eq!(format_integer_with_underscore_sep("123459"), "123_459");
+ assert_eq!(format_integer_with_underscore_sep("-12345678"), "-12_345_678");
+ assert_eq!(format_integer_with_underscore_sep("-123"), "-123");
+ assert_eq!(format_integer_with_underscore_sep("-123459"), "-123_459");
+}
+
+#[test]
+fn int_format_hex() {
+ assert_eq!(format_integer_with_underscore_sep("0xab3"), "0xab3");
+ assert_eq!(format_integer_with_underscore_sep("0xa2345b"), "0xa2_345b");
+ assert_eq!(format_integer_with_underscore_sep("0xa2e6345b"), "0xa2e6_345b");
+ assert_eq!(format_integer_with_underscore_sep("-0xab3"), "-0xab3");
+ assert_eq!(format_integer_with_underscore_sep("-0xa2345b"), "-0xa2_345b");
+ assert_eq!(format_integer_with_underscore_sep("-0xa2e6345b"), "-0xa2e6_345b");
+}
+
+#[test]
+fn int_format_binary() {
+ assert_eq!(format_integer_with_underscore_sep("0o12345671"), "0o12_345_671");
+ assert_eq!(format_integer_with_underscore_sep("0o123"), "0o123");
+ assert_eq!(format_integer_with_underscore_sep("0o123451"), "0o123451");
+ assert_eq!(format_integer_with_underscore_sep("-0o12345671"), "-0o12_345_671");
+ assert_eq!(format_integer_with_underscore_sep("-0o123"), "-0o123");
+ assert_eq!(format_integer_with_underscore_sep("-0o123451"), "-0o123451");
+}
+
+#[test]
+fn int_format_octal() {
+ assert_eq!(format_integer_with_underscore_sep("0b101"), "0b101");
+ assert_eq!(format_integer_with_underscore_sep("0b101101011"), "0b1_0110_1011");
+ assert_eq!(format_integer_with_underscore_sep("0b01101011"), "0b0110_1011");
+ assert_eq!(format_integer_with_underscore_sep("-0b101"), "-0b101");
+ assert_eq!(format_integer_with_underscore_sep("-0b101101011"), "-0b1_0110_1011");
+ assert_eq!(format_integer_with_underscore_sep("-0b01101011"), "-0b0110_1011");
+}
/// For example, using ignore-foo to ignore running the doctest on any target that
/// contains "foo" as a substring
crate enable_per_target_ignores: bool,
+ /// Do not run doctests, compile them if should_test is active.
+ crate no_run: bool,
/// The path to a rustc-like binary to build tests with. If not set, we
/// default to loading from `$sysroot/bin/rustc`.
.field("runtool_args", &self.runtool_args)
.field("enable-per-target-ignores", &self.enable_per_target_ignores)
.field("run_check", &self.run_check)
+ .field("no_run", &self.no_run)
.finish()
}
}
test_args.iter().flat_map(|s| s.split_whitespace()).map(|s| s.to_string()).collect();
let should_test = matches.opt_present("test");
+ let no_run = matches.opt_present("no-run");
+
+ if !should_test && no_run {
+ diag.err("the `--test` flag must be passed to enable `--no-run`");
+ return Err(1);
+ }
let output =
matches.opt_str("o").map(|s| PathBuf::from(&s)).unwrap_or_else(|| PathBuf::from("doc"));
enable_per_target_ignores,
test_builder,
run_check,
+ no_run,
render_options: RenderOptions {
output,
external_html,
use rustc_errors::json::JsonEmitter;
use rustc_feature::UnstableFeatures;
use rustc_hir::def::Res;
-use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LocalDefId, LOCAL_CRATE};
+use rustc_hir::def_id::{DefId, LocalDefId, LOCAL_CRATE};
use rustc_hir::HirId;
use rustc_hir::{
intravisit::{self, NestedVisitorMap, Visitor},
use rustc_span::Span;
use std::cell::RefCell;
-use std::collections::hash_map::Entry;
use std::mem;
use std::rc::Rc;
-use crate::clean;
use crate::clean::inline::build_external_trait;
-use crate::clean::{TraitWithExtraInfo, MAX_DEF_IDX};
+use crate::clean::{self, FakeDefId, TraitWithExtraInfo};
use crate::config::{Options as RustdocOptions, OutputFormat, RenderOptions};
use crate::formats::cache::Cache;
use crate::passes::{self, Condition::*, ConditionalPass};
crate ct_substs: FxHashMap<DefId, clean::Constant>,
/// Table synthetic type parameter for `impl Trait` in argument position -> bounds
crate impl_trait_bounds: FxHashMap<ImplTraitParam, Vec<clean::GenericBound>>,
- crate fake_def_ids: FxHashMap<CrateNum, DefIndex>,
/// Auto-trait or blanket impls processed so far, as `(self_ty, trait_def_id)`.
// FIXME(eddyb) make this a `ty::TraitRef<'tcx>` set.
crate generated_synthetics: FxHashSet<(Ty<'tcx>, DefId)>,
/// This same cache is used throughout rustdoc, including in [`crate::html::render`].
crate cache: Cache,
/// Used by [`clean::inline`] to tell if an item has already been inlined.
- crate inlined: FxHashSet<DefId>,
+ crate inlined: FxHashSet<FakeDefId>,
/// Used by `calculate_doc_coverage`.
crate output_format: OutputFormat,
}
r
}
- /// Create a new "fake" [`DefId`].
- ///
- /// This is an ugly hack, but it's the simplest way to handle synthetic impls without greatly
- /// refactoring either rustdoc or [`rustc_middle`]. In particular, allowing new [`DefId`]s
- /// to be registered after the AST is constructed would require storing the [`DefId`] mapping
- /// in a [`RefCell`], decreasing the performance for normal compilation for very little gain.
- ///
- /// Instead, we construct "fake" [`DefId`]s, which start immediately after the last `DefId`.
- /// In the [`Debug`] impl for [`clean::Item`], we explicitly check for fake `DefId`s,
- /// as we'll end up with a panic if we use the `DefId` `Debug` impl for fake `DefId`s.
- ///
- /// [`RefCell`]: std::cell::RefCell
- /// [`Debug`]: std::fmt::Debug
- /// [`clean::Item`]: crate::clean::types::Item
- crate fn next_def_id(&mut self, crate_num: CrateNum) -> DefId {
- let def_index = match self.fake_def_ids.entry(crate_num) {
- Entry::Vacant(e) => {
- let num_def_idx = {
- let num_def_idx = if crate_num == LOCAL_CRATE {
- self.tcx.hir().definitions().def_path_table().num_def_ids()
- } else {
- self.resolver.borrow_mut().access(|r| r.cstore().num_def_ids(crate_num))
- };
-
- DefIndex::from_usize(num_def_idx)
- };
-
- MAX_DEF_IDX.with(|m| {
- m.borrow_mut().insert(crate_num, num_def_idx);
- });
- e.insert(num_def_idx)
- }
- Entry::Occupied(e) => e.into_mut(),
- };
- *def_index = *def_index + 1;
-
- DefId { krate: crate_num, index: *def_index }
- }
-
/// Like `hir().local_def_id_to_hir_id()`, but skips calling it on fake DefIds.
/// (This avoids a slice-index-out-of-bounds panic.)
- crate fn as_local_hir_id(tcx: TyCtxt<'_>, def_id: DefId) -> Option<HirId> {
- if MAX_DEF_IDX.with(|m| {
- m.borrow().get(&def_id.krate).map(|&idx| idx <= def_id.index).unwrap_or(false)
- }) {
- None
- } else {
- def_id.as_local().map(|def_id| tcx.hir().local_def_id_to_hir_id(def_id))
+ crate fn as_local_hir_id(tcx: TyCtxt<'_>, def_id: FakeDefId) -> Option<HirId> {
+ match def_id {
+ FakeDefId::Real(real_id) => {
+ real_id.as_local().map(|def_id| tcx.hir().local_def_id_to_hir_id(def_id))
+ }
+ FakeDefId::Fake(_, _) => None,
}
}
}
lt_substs: Default::default(),
ct_substs: Default::default(),
impl_trait_bounds: Default::default(),
- fake_def_ids: Default::default(),
generated_synthetics: Default::default(),
auto_traits: tcx
.all_traits(LOCAL_CRATE)
let mut krate = tcx.sess.time("clean_crate", || clean::krate(&mut ctxt));
if krate.module.doc_value().map(|d| d.is_empty()).unwrap_or(true) {
- let help = format!(
- "The following guide may be of use:\n\
- https://doc.rust-lang.org/{}/rustdoc/how-to-write-documentation.html",
- crate::doc_rust_lang_org_channel(),
- );
+ let help = "The following guide may be of use:\n\
+ https://doc.rust-lang.org/nightly/rustdoc/how-to-write-documentation.html";
tcx.struct_lint_node(
crate::lint::MISSING_CRATE_LEVEL_DOCS,
DocContext::as_local_hir_id(tcx, krate.module.def_id).unwrap(),
|lint| {
let mut diag =
lint.build("no documentation found for this crate's top-level module");
- diag.help(&help);
+ diag.help(help);
diag.emit();
},
);
/// for `impl Trait` in argument position.
#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
crate enum ImplTraitParam {
- DefId(DefId),
+ DefId(FakeDefId),
ParamIndex(u32),
}
-impl From<DefId> for ImplTraitParam {
- fn from(did: DefId) -> Self {
+impl From<FakeDefId> for ImplTraitParam {
+ fn from(did: FakeDefId) -> Self {
ImplTraitParam::DefId(did)
}
}
let report_unused_externs = |uext| {
unused_externs.lock().unwrap().push(uext);
};
+ let no_run = config.no_run || options.no_run;
let res = run_test(
&test,
&cratename,
line,
options,
config.should_panic,
- config.no_run,
+ no_run,
config.test_harness,
runtool,
runtool_args,
//! This module is used to store stuff from Rust's AST in a more convenient
//! manner (and with prettier names) before cleaning.
+use rustc_middle::ty::TyCtxt;
use rustc_span::{self, Span, Symbol};
use rustc_hir as hir;
crate struct Module<'hir> {
crate name: Symbol,
- crate where_outer: Span,
crate where_inner: Span,
crate mods: Vec<Module<'hir>>,
crate id: hir::HirId,
}
impl Module<'hir> {
- crate fn new(name: Symbol) -> Module<'hir> {
+ crate fn new(name: Symbol, id: hir::HirId, where_inner: Span) -> Module<'hir> {
Module {
name,
- id: hir::CRATE_HIR_ID,
- where_outer: rustc_span::DUMMY_SP,
- where_inner: rustc_span::DUMMY_SP,
+ id,
+ where_inner,
mods: Vec::new(),
items: Vec::new(),
foreigns: Vec::new(),
macros: Vec::new(),
}
}
+
+ crate fn where_outer(&self, tcx: TyCtxt<'_>) -> Span {
+ tcx.hir().span(self.id)
+ }
}
use std::collections::BTreeMap;
use std::mem;
-use std::path::{Path, PathBuf};
+use std::path::Path;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX};
use rustc_middle::middle::privacy::AccessLevels;
use rustc_middle::ty::TyCtxt;
-use rustc_span::source_map::FileName;
use rustc_span::symbol::sym;
-use rustc_span::Symbol;
-use crate::clean::{self, GetDefId};
+use crate::clean::{self, FakeDefId, GetDefId};
use crate::fold::DocFolder;
use crate::formats::item_type::ItemType;
use crate::formats::Impl;
use crate::html::markdown::short_markdown_summary;
-use crate::html::render::cache::{extern_location, get_index_search_type, ExternalLocation};
+use crate::html::render::cache::{get_index_search_type, ExternalLocation};
use crate::html::render::IndexItem;
/// This cache is used to store information about the [`clean::Crate`] being
/// When rendering traits, it's often useful to be able to list all
/// implementors of the trait, and this mapping is exactly, that: a mapping
/// of trait ids to the list of known implementors of the trait
- crate implementors: FxHashMap<DefId, Vec<Impl>>,
+ crate implementors: FxHashMap<FakeDefId, Vec<Impl>>,
/// Cache of where external crate documentation can be found.
- crate extern_locations: FxHashMap<CrateNum, (Symbol, PathBuf, ExternalLocation)>,
+ crate extern_locations: FxHashMap<CrateNum, ExternalLocation>,
/// Cache of where documentation for primitives can be found.
crate primitive_locations: FxHashMap<clean::PrimitiveType, DefId>,
/// All intra-doc links resolved so far.
///
/// Links are indexed by the DefId of the item they document.
- crate intra_doc_links: BTreeMap<DefId, Vec<clean::ItemLink>>,
+ crate intra_doc_links: BTreeMap<FakeDefId, Vec<clean::ItemLink>>,
}
/// This struct is used to wrap the `cache` and `tcx` in order to run `DocFolder`.
// Cache where all our extern crates are located
// FIXME: this part is specific to HTML so it'd be nice to remove it from the common code
for &(n, ref e) in &krate.externs {
- let src_root = match e.src(tcx) {
- FileName::Real(ref p) => match p.local_path().parent() {
- Some(p) => p.to_path_buf(),
- None => PathBuf::new(),
- },
- _ => PathBuf::new(),
- };
let name = e.name(tcx);
let extern_url = extern_html_root_urls.get(&*name.as_str()).map(|u| &**u);
let did = DefId { krate: n, index: CRATE_DEF_INDEX };
- self.extern_locations.insert(
- n,
- (name, src_root, extern_location(e, extern_url, tcx.get_attrs(did), &dst, tcx)),
- );
-
+ self.extern_locations.insert(n, e.location(extern_url, &dst, tcx));
self.external_paths.insert(did, (vec![name.to_string()], ItemType::Module));
}
// If the impl is from a masked crate or references something from a
// masked crate then remove it completely.
if let clean::ImplItem(ref i) = *item.kind {
- if self.cache.masked_crates.contains(&item.def_id.krate)
+ if self.cache.masked_crates.contains(&item.def_id.krate())
|| i.trait_.def_id().map_or(false, |d| self.cache.masked_crates.contains(&d.krate))
|| i.for_.def_id().map_or(false, |d| self.cache.masked_crates.contains(&d.krate))
{
// Propagate a trait method's documentation to all implementors of the
// trait.
if let clean::TraitItem(ref t) = *item.kind {
- self.cache.traits.entry(item.def_id).or_insert_with(|| clean::TraitWithExtraInfo {
- trait_: t.clone(),
- is_notable: item.attrs.has_doc_flag(sym::notable_trait),
+ self.cache.traits.entry(item.def_id.expect_real()).or_insert_with(|| {
+ clean::TraitWithExtraInfo {
+ trait_: t.clone(),
+ is_notable: item.attrs.has_doc_flag(sym::notable_trait),
+ }
});
}
if i.blanket_impl.is_none() {
self.cache
.implementors
- .entry(did)
+ .entry(did.into())
.or_default()
.push(Impl { impl_item: item.clone() });
}
// A crate has a module at its root, containing all items,
// which should not be indexed. The crate-item itself is
// inserted later on when serializing the search-index.
- if item.def_id.index != CRATE_DEF_INDEX {
+ if item.def_id.index().map_or(false, |idx| idx != CRATE_DEF_INDEX) {
self.cache.search_index.push(IndexItem {
ty: item.type_(),
name: s.to_string(),
desc: item
.doc_value()
.map_or_else(String::new, |x| short_markdown_summary(&x.as_str())),
- parent,
+ parent: parent.map(FakeDefId::new_real),
parent_idx: None,
search_type: get_index_search_type(&item, &self.empty_cache, self.tcx),
aliases: item.attrs.get_doc_aliases(),
| clean::EnumItem(..)
| clean::TypedefItem(..)
| clean::TraitItem(..)
+ | clean::TraitAliasItem(..)
| clean::FunctionItem(..)
| clean::ModuleItem(..)
| clean::ForeignFunctionItem(..)
| clean::ForeignTypeItem
| clean::MacroItem(..)
| clean::ProcMacroItem(..)
- | clean::VariantItem(..)
- if !self.cache.stripped_mod =>
- {
- // Re-exported items mean that the same id can show up twice
- // in the rustdoc ast that we're looking at. We know,
- // however, that a re-exported item doesn't show up in the
- // `public_items` map, so we can skip inserting into the
- // paths map if there was already an entry present and we're
- // not a public item.
- if !self.cache.paths.contains_key(&item.def_id)
- || self.cache.access_levels.is_public(item.def_id)
- {
- self.cache.paths.insert(item.def_id, (self.cache.stack.clone(), item.type_()));
+ | clean::VariantItem(..) => {
+ if !self.cache.stripped_mod {
+ // Re-exported items mean that the same id can show up twice
+ // in the rustdoc ast that we're looking at. We know,
+ // however, that a re-exported item doesn't show up in the
+ // `public_items` map, so we can skip inserting into the
+ // paths map if there was already an entry present and we're
+ // not a public item.
+ if !self.cache.paths.contains_key(&item.def_id.expect_real())
+ || self.cache.access_levels.is_public(item.def_id.expect_real())
+ {
+ self.cache.paths.insert(
+ item.def_id.expect_real(),
+ (self.cache.stack.clone(), item.type_()),
+ );
+ }
}
}
clean::PrimitiveItem(..) => {
- self.cache.paths.insert(item.def_id, (self.cache.stack.clone(), item.type_()));
+ self.cache
+ .paths
+ .insert(item.def_id.expect_real(), (self.cache.stack.clone(), item.type_()));
}
- _ => {}
+ clean::ExternCrateItem { .. }
+ | clean::ImportItem(..)
+ | clean::OpaqueTyItem(..)
+ | clean::ImplItem(..)
+ | clean::TyMethodItem(..)
+ | clean::MethodItem(..)
+ | clean::StructFieldItem(..)
+ | clean::AssocConstItem(..)
+ | clean::AssocTypeItem(..)
+ | clean::StrippedItem(..)
+ | clean::KeywordItem(..) => {
+ // FIXME: Do these need handling?
+ // The person writing this comment doesn't know.
+ // So would rather leave them to an expert,
+ // as at least the list is better than `_ => {}`.
+ }
}
// Maintain the parent stack
| clean::StructItem(..)
| clean::UnionItem(..)
| clean::VariantItem(..) => {
- self.cache.parent_stack.push(item.def_id);
+ self.cache.parent_stack.push(item.def_id.expect_real());
self.cache.parent_is_trait_impl = false;
true
}
crate mod item_type;
crate mod renderer;
-crate use renderer::{run_format, FormatRenderer};
+use rustc_hir::def_id::DefId;
-use rustc_span::def_id::DefId;
+crate use renderer::{run_format, FormatRenderer};
use crate::clean;
use crate::clean::types::GetDefId;
use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::FxHashSet;
use rustc_hir as hir;
+use rustc_hir::def_id::DefId;
use rustc_middle::ty::TyCtxt;
-use rustc_span::def_id::{DefId, CRATE_DEF_INDEX};
+use rustc_span::def_id::CRATE_DEF_INDEX;
use rustc_target::spec::abi::Abi;
-use crate::clean::{self, utils::find_nearest_parent_module, PrimitiveType};
+use crate::clean::{
+ self, utils::find_nearest_parent_module, ExternalCrate, FakeDefId, PrimitiveType,
+};
use crate::formats::item_type::ItemType;
use crate::html::escape::Escape;
use crate::html::render::cache::ExternalLocation;
fqp,
shortty,
match cache.extern_locations[&did.krate] {
- (.., ExternalLocation::Remote(ref s)) => {
+ ExternalLocation::Remote(ref s) => {
let s = s.trim_end_matches('/');
let mut s = vec![&s[..]];
s.extend(module_fqp[..].iter().map(String::as_str));
s
}
- (.., ExternalLocation::Local) => href_relative_parts(module_fqp, relative_to),
- (.., ExternalLocation::Unknown) => return None,
+ ExternalLocation::Local => href_relative_parts(module_fqp, relative_to),
+ ExternalLocation::Unknown => return None,
},
)
}
Some(&def_id) => {
let cname_str;
let loc = match m.extern_locations[&def_id.krate] {
- (ref cname, _, ExternalLocation::Remote(ref s)) => {
- cname_str = cname.as_str();
+ ExternalLocation::Remote(ref s) => {
+ cname_str =
+ ExternalCrate { crate_num: def_id.krate }.name(cx.tcx()).as_str();
Some(vec![s.trim_end_matches('/'), &cname_str[..]])
}
- (ref cname, _, ExternalLocation::Local) => {
- cname_str = cname.as_str();
+ ExternalLocation::Local => {
+ cname_str =
+ ExternalCrate { crate_num: def_id.krate }.name(cx.tcx()).as_str();
Some(if cx.current.first().map(|x| &x[..]) == Some(&cname_str[..]) {
iter::repeat("..").take(cx.current.len() - 1).collect()
} else {
iter::repeat("..").take(cx.current.len()).chain(cname).collect()
})
}
- (.., ExternalLocation::Unknown) => None,
+ ExternalLocation::Unknown => None,
};
if let Some(loc) = loc {
write!(
text: &'a str,
cx: &'cx Context<'_>,
) -> impl fmt::Display + 'a {
- let parts = href(did, cx);
+ let parts = href(did.into(), cx);
display_fn(move |f| {
if let Some((url, short_ty, fqp)) = parts {
write!(
// everything comes in as a fully resolved QPath (hard to
// look at).
box clean::ResolvedPath { did, ref param_names, .. } => {
- match href(did, cx) {
+ match href(did.into(), cx) {
Some((ref url, _, ref path)) if !f.alternate() => {
write!(
f,
impl clean::Visibility {
crate fn print_with_space<'a, 'tcx: 'a>(
self,
- item_did: DefId,
+ item_did: FakeDefId,
cx: &'a Context<'tcx>,
) -> impl fmt::Display + 'a + Captures<'tcx> {
let to_print = match self {
// FIXME(camelid): This may not work correctly if `item_did` is a module.
// However, rustdoc currently never displays a module's
// visibility, so it shouldn't matter.
- let parent_module = find_nearest_parent_module(cx.tcx(), item_did);
+ let parent_module = find_nearest_parent_module(cx.tcx(), item_did.expect_real());
if vis_did.index == CRATE_DEF_INDEX {
"pub(crate) ".to_owned()
use rustc_lexer::{LiteralKind, TokenKind};
use rustc_span::edition::Edition;
use rustc_span::symbol::Symbol;
-use rustc_span::with_default_session_globals;
use super::format::Buffer;
}
fn write_header(out: &mut Buffer, class: Option<&str>) {
- write!(out, "<div class=\"example-wrap\"><pre class=\"rust {}\">\n", class.unwrap_or_default());
+ writeln!(out, "<div class=\"example-wrap\"><pre class=\"rust {}\">", class.unwrap_or_default());
}
fn write_code(out: &mut Buffer, src: &str, edition: Edition) {
}
fn write_footer(out: &mut Buffer, playground_button: Option<&str>) {
- write!(out, "</pre>{}</div>\n", playground_button.unwrap_or_default());
+ writeln!(out, "</pre>{}</div>", playground_button.unwrap_or_default());
}
/// How a span of text is classified. Mostly corresponds to token kinds.
/// possibly giving it an HTML span with a class specifying what flavor of
/// token is used.
fn highlight(mut self, sink: &mut dyn FnMut(Highlight<'a>)) {
- with_default_session_globals(|| {
- loop {
- if self
- .tokens
- .peek()
- .map(|t| matches!(t.0, TokenKind::Colon | TokenKind::Ident))
- .unwrap_or(false)
- {
- let tokens = self.get_full_ident_path();
- for (token, start, end) in tokens {
- let text = &self.src[start..end];
- self.advance(token, text, sink);
- self.byte_pos += text.len() as u32;
- }
- }
- if let Some((token, text)) = self.next() {
+ loop {
+ if self
+ .tokens
+ .peek()
+ .map(|t| matches!(t.0, TokenKind::Colon | TokenKind::Ident))
+ .unwrap_or(false)
+ {
+ let tokens = self.get_full_ident_path();
+ for (token, start, end) in tokens {
+ let text = &self.src[start..end];
self.advance(token, text, sink);
- } else {
- break;
+ self.byte_pos += text.len() as u32;
}
}
- })
+ if let Some((token, text)) = self.next() {
+ self.advance(token, text, sink);
+ } else {
+ break;
+ }
+ }
}
/// Single step of highlighting. This will classify `token`, but maybe also
use crate::html::format::Buffer;
use expect_test::expect_file;
use rustc_span::edition::Edition;
+use rustc_span::with_default_session_globals;
const STYLE: &str = r#"
<style>
#[test]
fn test_html_highlighting() {
- let src = include_str!("fixtures/sample.rs");
- let html = {
- let mut out = Buffer::new();
- write_code(&mut out, src, Edition::Edition2018);
- format!("{}<pre><code>{}</code></pre>\n", STYLE, out.into_inner())
- };
- expect_file!["fixtures/sample.html"].assert_eq(&html);
+ with_default_session_globals(|| {
+ let src = include_str!("fixtures/sample.rs");
+ let html = {
+ let mut out = Buffer::new();
+ write_code(&mut out, src, Edition::Edition2018);
+ format!("{}<pre><code>{}</code></pre>\n", STYLE, out.into_inner())
+ };
+ expect_file!["fixtures/sample.html"].assert_eq(&html);
+ });
}
#[test]
fn test_dos_backline() {
- let src = "pub fn foo() {\r\n\
+ with_default_session_globals(|| {
+ let src = "pub fn foo() {\r\n\
println!(\"foo\");\r\n\
}\r\n";
- let mut html = Buffer::new();
- write_code(&mut html, src, Edition::Edition2018);
- expect_file!["fixtures/dos_line.html"].assert_eq(&html.into_inner());
+ let mut html = Buffer::new();
+ write_code(&mut html, src, Edition::Edition2018);
+ expect_file!["fixtures/dos_line.html"].assert_eq(&html.into_inner());
+ });
}
use std::collections::BTreeMap;
-use std::path::Path;
-use rustc_ast::ast;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_middle::ty::TyCtxt;
-use rustc_span::symbol::{sym, Symbol};
+use rustc_span::symbol::Symbol;
use serde::ser::{Serialize, SerializeStruct, Serializer};
use crate::clean;
use crate::clean::types::{
- AttributesExt, FnDecl, FnRetTy, GenericBound, Generics, GetDefId, Type, WherePredicate,
+ FakeDefId, FnDecl, FnRetTy, GenericBound, Generics, GetDefId, Type, WherePredicate,
};
use crate::formats::cache::Cache;
use crate::formats::item_type::ItemType;
Unknown,
}
-/// Attempts to find where an external crate is located, given that we're
-/// rendering in to the specified source destination.
-crate fn extern_location(
- e: &clean::ExternalCrate,
- extern_url: Option<&str>,
- ast_attrs: &[ast::Attribute],
- dst: &Path,
- tcx: TyCtxt<'_>,
-) -> ExternalLocation {
- use ExternalLocation::*;
- // See if there's documentation generated into the local directory
- let local_location = dst.join(&*e.name(tcx).as_str());
- if local_location.is_dir() {
- return Local;
- }
-
- if let Some(url) = extern_url {
- let mut url = url.to_string();
- if !url.ends_with('/') {
- url.push('/');
- }
- return Remote(url);
- }
-
- // Failing that, see if there's an attribute specifying where to find this
- // external crate
- ast_attrs
- .lists(sym::doc)
- .filter(|a| a.has_name(sym::html_root_url))
- .filter_map(|a| a.value_str())
- .map(|url| {
- let mut url = url.to_string();
- if !url.ends_with('/') {
- url.push('/')
- }
- Remote(url)
- })
- .next()
- .unwrap_or(Unknown) // Well, at least we tried.
-}
-
/// Builds the search index from the collected metadata
crate fn build_index<'tcx>(krate: &clean::Crate, cache: &mut Cache, tcx: TyCtxt<'tcx>) -> String {
let mut defid_to_pathid = FxHashMap::default();
name: item.name.unwrap().to_string(),
path: fqp[..fqp.len() - 1].join("::"),
desc: item.doc_value().map_or_else(String::new, |s| short_markdown_summary(&s)),
- parent: Some(did),
+ parent: Some(did.into()),
parent_idx: None,
search_type: get_index_search_type(&item, cache, tcx),
aliases: item.attrs.get_doc_aliases(),
defid_to_pathid.insert(defid, pathid);
lastpathid += 1;
- if let Some(&(ref fqp, short)) = paths.get(&defid) {
+ if let Some(&(ref fqp, short)) = paths.get(&defid.expect_real()) {
crate_paths.push((short, fqp.last().unwrap().clone()));
Some(pathid)
} else {
fn get_index_type(clean_type: &clean::Type, cache: &Cache) -> RenderType {
RenderType {
- ty: clean_type.def_id_full(cache),
+ ty: clean_type.def_id_full(cache).map(FakeDefId::new_real),
idx: None,
name: get_index_type_name(clean_type, true).map(|s| s.as_str().to_ascii_lowercase()),
generics: get_generics(clean_type, cache),
.filter_map(|t| {
get_index_type_name(t, false).map(|name| Generic {
name: name.as_str().to_ascii_lowercase(),
- defid: t.def_id_full(cache),
+ defid: t.def_id_full(cache).map(FakeDefId::new_real),
idx: None,
})
})
use super::{print_sidebar, settings, AllTypes, NameDoc, StylePath, BASIC_KEYWORDS};
use crate::clean;
+use crate::clean::ExternalCrate;
use crate::config::RenderOptions;
use crate::docfs::{DocFS, PathError};
use crate::error::Error;
&self.shared.style_files,
)
} else {
- if let Some(&(ref names, ty)) = self.cache.paths.get(&it.def_id) {
+ if let Some(&(ref names, ty)) = self.cache.paths.get(&it.def_id.expect_real()) {
let mut path = String::new();
for name in &names[..names.len() - 1] {
path.push_str(name);
}
} else {
let (krate, src_root) = match *self.cache.extern_locations.get(&cnum)? {
- (name, ref src, ExternalLocation::Local) => (name, src),
- (name, ref src, ExternalLocation::Remote(ref s)) => {
+ ExternalLocation::Local => {
+ let e = ExternalCrate { crate_num: cnum };
+ (e.name(self.tcx()), e.src_root(self.tcx()))
+ }
+ ExternalLocation::Remote(ref s) => {
root = s.to_string();
- (name, src)
+ let e = ExternalCrate { crate_num: cnum };
+ (e.name(self.tcx()), e.src_root(self.tcx()))
}
- (_, _, ExternalLocation::Unknown) => return None,
+ ExternalLocation::Unknown => return None,
};
sources::clean_path(&src_root, file, false, |component| {
use serde::ser::SerializeSeq;
use serde::{Serialize, Serializer};
-use crate::clean::{self, GetDefId, RenderedLink, SelfTy};
+use crate::clean::{self, FakeDefId, GetDefId, RenderedLink, SelfTy};
use crate::docfs::PathError;
use crate::error::Error;
use crate::formats::cache::Cache;
crate name: String,
crate path: String,
crate desc: String,
- crate parent: Option<DefId>,
+ crate parent: Option<FakeDefId>,
crate parent_idx: Option<usize>,
crate search_type: Option<IndexItemFunctionType>,
crate aliases: Box<[String]>,
/// A type used for the search index.
#[derive(Debug)]
crate struct RenderType {
- ty: Option<DefId>,
+ ty: Option<FakeDefId>,
idx: Option<usize>,
name: Option<String>,
generics: Option<Vec<Generic>>,
#[derive(Debug)]
crate struct Generic {
name: String,
- defid: Option<DefId>,
+ defid: Option<FakeDefId>,
idx: Option<usize>,
}
if let Some(ref name) = item.name {
info!("Documenting {}", name);
}
- document_item_info(w, cx, item, false, parent);
- document_full(w, item, cx, false);
+ document_item_info(w, cx, item, parent);
+ document_full(w, item, cx);
}
/// Render md_text as markdown.
-fn render_markdown(
- w: &mut Buffer,
- cx: &Context<'_>,
- md_text: &str,
- links: Vec<RenderedLink>,
- is_hidden: bool,
-) {
+fn render_markdown(w: &mut Buffer, cx: &Context<'_>, md_text: &str, links: Vec<RenderedLink>) {
let mut ids = cx.id_map.borrow_mut();
write!(
w,
- "<div class=\"docblock{}\">{}</div>",
- if is_hidden { " hidden" } else { "" },
+ "<div class=\"docblock\">{}</div>",
Markdown(
md_text,
&links,
item: &clean::Item,
cx: &Context<'_>,
link: AssocItemLink<'_>,
- is_hidden: bool,
parent: &clean::Item,
show_def_docs: bool,
) {
- document_item_info(w, cx, item, is_hidden, Some(parent));
+ document_item_info(w, cx, item, Some(parent));
if !show_def_docs {
return;
}
}
}
- write!(
- w,
- "<div class='docblock{}'>{}</div>",
- if is_hidden { " hidden" } else { "" },
- summary_html,
- );
+ write!(w, "<div class='docblock'>{}</div>", summary_html,);
}
}
-fn document_full(w: &mut Buffer, item: &clean::Item, cx: &Context<'_>, is_hidden: bool) {
+fn document_full(w: &mut Buffer, item: &clean::Item, cx: &Context<'_>) {
if let Some(s) = cx.shared.maybe_collapsed_doc_value(item) {
debug!("Doc block: =====\n{}\n=====", s);
- render_markdown(w, cx, &s, item.links(cx), is_hidden);
+ render_markdown(w, cx, &s, item.links(cx));
}
}
w: &mut Buffer,
cx: &Context<'_>,
item: &clean::Item,
- is_hidden: bool,
parent: Option<&clean::Item>,
) {
let item_infos = short_item_info(item, cx, parent);
if !item_infos.is_empty() {
- if is_hidden {
- w.write_str("<div class=\"item-info hidden\">");
- } else {
- w.write_str("<div class=\"item-info\">");
- }
+ w.write_str("<div class=\"item-info\">");
for info in item_infos {
w.write_str(&info);
}
.iter()
.map(|i| {
let did = i.trait_did_full(cache).unwrap();
- let assoc_link = AssocItemLink::GotoSource(did, &i.inner_impl().provided_trait_methods);
+ let provided_trait_methods = i.inner_impl().provided_trait_methods(tcx);
+ let assoc_link = AssocItemLink::GotoSource(did.into(), &provided_trait_methods);
let mut buffer = if w.is_for_html() { Buffer::html() } else { Buffer::new() };
render_impl(
&mut buffer,
AssocItemLink::Anchor(Some(ref id)) => format!("#{}", id),
AssocItemLink::Anchor(None) => anchor,
AssocItemLink::GotoSource(did, _) => {
- href(did, cx).map(|p| format!("{}{}", p.0, anchor)).unwrap_or(anchor)
+ href(did.expect_real(), cx).map(|p| format!("{}{}", p.0, anchor)).unwrap_or(anchor)
}
}
}
ItemType::TyMethod
};
- href(did, cx)
+ href(did.expect_real(), cx)
.map(|p| format!("{}#{}.{}", p.0, ty, name))
.unwrap_or_else(|| format!("#{}.{}", ty, name))
}
// a whitespace prefix and newline.
fn render_attributes_in_pre(w: &mut Buffer, it: &clean::Item, prefix: &str) {
for a in attributes(it) {
- write!(w, "{}{}\n", prefix, a);
+ writeln!(w, "{}{}", prefix, a);
}
}
#[derive(Copy, Clone)]
enum AssocItemLink<'a> {
Anchor(Option<&'a str>),
- GotoSource(DefId, &'a FxHashSet<Symbol>),
+ GotoSource(FakeDefId, &'a FxHashSet<Symbol>),
}
impl<'a> AssocItemLink<'a> {
it,
&[],
Some(&tydef.type_),
- AssocItemLink::GotoSource(t_did, &FxHashSet::default()),
+ AssocItemLink::GotoSource(t_did.into(), &FxHashSet::default()),
"",
cx,
);
let trait_ = i.trait_did_full(cache).map(|did| &traits[&did]);
let mut close_tags = String::new();
+ // For trait implementations, the `interesting` output contains all methods that have doc
+ // comments, and the `boring` output contains all methods that do not. The distinction is
+ // used to allow hiding the boring methods.
fn doc_impl_item(
- w: &mut Buffer,
+ boring: &mut Buffer,
+ interesting: &mut Buffer,
cx: &Context<'_>,
item: &clean::Item,
parent: &clean::Item,
}
};
- let (is_hidden, extra_class) =
- if (trait_.is_none() || item.doc_value().is_some() || item.kind.is_type_alias())
- && !is_default_item
- {
- (false, "")
- } else {
- (true, " hidden")
- };
let in_trait_class = if trait_.is_some() { " trait-impl" } else { "" };
+
+ let mut doc_buffer = Buffer::empty_from(boring);
+ let mut info_buffer = Buffer::empty_from(boring);
+ let mut short_documented = true;
+
+ if render_method_item {
+ if !is_default_item {
+ if let Some(t) = trait_ {
+ // The trait item may have been stripped so we might not
+ // find any documentation or stability for it.
+ if let Some(it) = t.items.iter().find(|i| i.name == item.name) {
+ // We need the stability of the item from the trait
+ // because impls can't have a stability.
+ if item.doc_value().is_some() {
+ document_item_info(&mut info_buffer, cx, it, Some(parent));
+ document_full(&mut doc_buffer, item, cx);
+ short_documented = false;
+ } else {
+ // In case the item isn't documented,
+ // provide short documentation from the trait.
+ document_short(&mut doc_buffer, it, cx, link, parent, show_def_docs);
+ }
+ }
+ } else {
+ document_item_info(&mut info_buffer, cx, item, Some(parent));
+ if show_def_docs {
+ document_full(&mut doc_buffer, item, cx);
+ short_documented = false;
+ }
+ }
+ } else {
+ document_short(&mut doc_buffer, item, cx, link, parent, show_def_docs);
+ }
+ }
+ let w = if short_documented && trait_.is_some() { interesting } else { boring };
+
+ if !doc_buffer.is_empty() {
+ w.write_str("<details class=\"rustdoc-toggle\" open><summary>");
+ }
match *item.kind {
clean::MethodItem(..) | clean::TyMethodItem(_) => {
// Only render when the method is not static or we allow static methods
})
})
.map(|item| format!("{}.{}", item.type_(), name));
- write!(
- w,
- "<h4 id=\"{}\" class=\"{}{}{}\">",
- id, item_type, extra_class, in_trait_class,
- );
+ write!(w, "<h4 id=\"{}\" class=\"{}{}\">", id, item_type, in_trait_class,);
w.write_str("<code>");
render_assoc_item(
w,
clean::TypedefItem(ref tydef, _) => {
let source_id = format!("{}.{}", ItemType::AssocType, name);
let id = cx.derive_id(source_id.clone());
- write!(
- w,
- "<h4 id=\"{}\" class=\"{}{}{}\"><code>",
- id, item_type, extra_class, in_trait_class
- );
+ write!(w, "<h4 id=\"{}\" class=\"{}{}\"><code>", id, item_type, in_trait_class);
assoc_type(
w,
item,
clean::AssocConstItem(ref ty, ref default) => {
let source_id = format!("{}.{}", item_type, name);
let id = cx.derive_id(source_id.clone());
- write!(
- w,
- "<h4 id=\"{}\" class=\"{}{}{}\"><code>",
- id, item_type, extra_class, in_trait_class
- );
+ write!(w, "<h4 id=\"{}\" class=\"{}{}\"><code>", id, item_type, in_trait_class);
assoc_const(
w,
item,
clean::AssocTypeItem(ref bounds, ref default) => {
let source_id = format!("{}.{}", item_type, name);
let id = cx.derive_id(source_id.clone());
- write!(
- w,
- "<h4 id=\"{}\" class=\"{}{}{}\"><code>",
- id, item_type, extra_class, in_trait_class
- );
+ write!(w, "<h4 id=\"{}\" class=\"{}{}\"><code>", id, item_type, in_trait_class);
assoc_type(
w,
item,
_ => panic!("can't make docs for trait item with name {:?}", item.name),
}
- if render_method_item {
- if !is_default_item {
- if let Some(t) = trait_ {
- // The trait item may have been stripped so we might not
- // find any documentation or stability for it.
- if let Some(it) = t.items.iter().find(|i| i.name == item.name) {
- // We need the stability of the item from the trait
- // because impls can't have a stability.
- if item.doc_value().is_some() {
- document_item_info(w, cx, it, is_hidden, Some(parent));
- document_full(w, item, cx, is_hidden);
- } else {
- // In case the item isn't documented,
- // provide short documentation from the trait.
- document_short(w, it, cx, link, is_hidden, parent, show_def_docs);
- }
- }
- } else {
- document_item_info(w, cx, item, is_hidden, Some(parent));
- if show_def_docs {
- document_full(w, item, cx, is_hidden);
- }
- }
- } else {
- document_short(w, item, cx, link, is_hidden, parent, show_def_docs);
- }
+ w.push_buffer(info_buffer);
+ if !doc_buffer.is_empty() {
+ w.write_str("</summary>");
+ w.push_buffer(doc_buffer);
+ w.push_str("</details>");
}
}
let mut impl_items = Buffer::empty_from(w);
+ let mut default_impl_items = Buffer::empty_from(w);
+
for trait_item in &i.inner_impl().items {
doc_impl_item(
+ &mut default_impl_items,
&mut impl_items,
cx,
trait_item,
}
fn render_default_items(
- w: &mut Buffer,
+ boring: &mut Buffer,
+ interesting: &mut Buffer,
cx: &Context<'_>,
t: &clean::Trait,
i: &clean::Impl,
continue;
}
let did = i.trait_.as_ref().unwrap().def_id_full(cx.cache()).unwrap();
- let assoc_link = AssocItemLink::GotoSource(did, &i.provided_trait_methods);
+ let provided_methods = i.provided_trait_methods(cx.tcx());
+ let assoc_link = AssocItemLink::GotoSource(did.into(), &provided_methods);
doc_impl_item(
- w,
+ boring,
+ interesting,
cx,
trait_item,
parent,
if show_default_items {
if let Some(t) = trait_ {
render_default_items(
+ &mut default_impl_items,
&mut impl_items,
cx,
&t.trait_,
);
}
}
- let details_str = if impl_items.is_empty() {
- ""
- } else {
- "<details class=\"rustdoc-toggle implementors-toggle\" open><summary>"
+ let toggled = !impl_items.is_empty() || !default_impl_items.is_empty();
+ let open_details = |close_tags: &mut String| {
+ if toggled {
+ close_tags.insert_str(0, "</details>");
+ "<details class=\"rustdoc-toggle implementors-toggle\" open><summary>"
+ } else {
+ ""
+ }
};
if render_mode == RenderMode::Normal {
let id = cx.derive_id(match i.inner_impl().trait_ {
write!(
w,
"{}<h3 id=\"{}\" class=\"impl\"{}><code class=\"in-band\">",
- details_str, id, aliases
+ open_details(&mut close_tags),
+ id,
+ aliases
);
- if !impl_items.is_empty() {
- close_tags.insert_str(0, "</details>");
- }
write!(w, "{}", i.inner_impl().print(use_absolute, cx));
if show_def_docs {
for it in &i.inner_impl().items {
write!(
w,
"{}<h3 id=\"{}\" class=\"impl\"{}><code class=\"in-band\">{}</code>",
- details_str,
+ open_details(&mut close_tags),
id,
aliases,
i.inner_impl().print(false, cx)
);
- if !impl_items.is_empty() {
- close_tags.insert_str(0, "</details>");
- }
}
write!(w, "<a href=\"#{}\" class=\"anchor\"></a>", id);
render_stability_since_raw(
outer_const_version,
);
write_srclink(cx, &i.impl_item, w);
- if impl_items.is_empty() {
+ if !toggled {
w.write_str("</h3>");
} else {
w.write_str("</h3></summary>");
);
}
}
- if !impl_items.is_empty() {
+ if toggled {
w.write_str("<div class=\"impl-items\">");
+ w.push_buffer(default_impl_items);
+ if trait_.is_some() && !impl_items.is_empty() {
+ w.write_str("<details class=\"undocumented\"><summary></summary>");
+ close_tags.insert_str(0, "</details>");
+ }
w.push_buffer(impl_items);
close_tags.insert_str(0, "</div>");
}
}
fn sidebar_assoc_items(cx: &Context<'_>, out: &mut Buffer, it: &clean::Item) {
- if let Some(v) = cx.cache.impls.get(&it.def_id) {
+ let did = it.def_id.expect_real();
+ if let Some(v) = cx.cache.impls.get(&did) {
let mut used_links = FxHashSet::default();
let cache = cx.cache();
w,
"<tr><td><code>{}extern crate {} as {};",
myitem.visibility.print_with_space(myitem.def_id, cx),
- anchor(myitem.def_id, &*src.as_str(), cx),
+ anchor(myitem.def_id.expect_real(), &*src.as_str(), cx),
myitem.name.as_ref().unwrap(),
),
None => write!(
w,
"<tr><td><code>{}extern crate {};",
myitem.visibility.print_with_space(myitem.def_id, cx),
- anchor(myitem.def_id, &*myitem.name.as_ref().unwrap().as_str(), cx),
+ anchor(
+ myitem.def_id.expect_real(),
+ &*myitem.name.as_ref().unwrap().as_str(),
+ cx
+ ),
),
}
w.write_str("</code></td></tr>");
// Just need an item with the correct def_id and attrs
let import_item = clean::Item {
- def_id: import_def_id,
+ def_id: import_def_id.into(),
attrs: import_attrs,
cfg: ast_attrs.cfg(cx.sess()),
..myitem.clone()
}
// If there are methods directly on this trait object, render them here.
- render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All);
+ render_assoc_items(w, cx, it, it.def_id.expect_real(), AssocItemRender::All);
if let Some(implementors) = cx.cache.implementors.get(&it.def_id) {
// The DefId is for the first Type found with that name. The bool is
write_small_section_header(w, "foreign-impls", "Implementations on Foreign Types", "");
for implementor in foreign {
- let assoc_link = AssocItemLink::GotoSource(
- implementor.impl_item.def_id,
- &implementor.inner_impl().provided_trait_methods,
- );
+ let provided_methods = implementor.inner_impl().provided_trait_methods(cx.tcx());
+ let assoc_link =
+ AssocItemLink::GotoSource(implementor.impl_item.def_id, &provided_methods);
render_impl(
w,
cx,
path = if it.def_id.is_local() {
cx.current.join("/")
} else {
- let (ref path, _) = cx.cache.external_paths[&it.def_id];
+ let (ref path, _) = cx.cache.external_paths[&it.def_id.expect_real()];
path[..path.len() - 1].join("/")
},
ty = it.type_(),
// won't be visible anywhere in the docs. It would be nice to also show
// associated items from the aliased type (see discussion in #32077), but
// we need #14072 to make sense of the generics.
- render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
+ render_assoc_items(w, cx, it, it.def_id.expect_real(), AssocItemRender::All)
}
fn item_opaque_ty(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::OpaqueTy) {
// won't be visible anywhere in the docs. It would be nice to also show
// associated items from the aliased type (see discussion in #32077), but
// we need #14072 to make sense of the generics.
- render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
+ render_assoc_items(w, cx, it, it.def_id.expect_real(), AssocItemRender::All)
}
fn item_typedef(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Typedef) {
// won't be visible anywhere in the docs. It would be nice to also show
// associated items from the aliased type (see discussion in #32077), but
// we need #14072 to make sense of the generics.
- render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
+ render_assoc_items(w, cx, it, it.def_id.expect_real(), AssocItemRender::All)
}
fn item_union(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::Union) {
document(w, cx, field, Some(it));
}
}
- render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
+ render_assoc_items(w, cx, it, it.def_id.expect_real(), AssocItemRender::All)
}
fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum) {
render_stability_since(w, variant, it, cx.tcx());
}
}
- render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
+ render_assoc_items(w, cx, it, it.def_id.expect_real(), AssocItemRender::All)
}
fn item_macro(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Macro) {
fn item_primitive(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item) {
document(w, cx, it, None);
- render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
+ render_assoc_items(w, cx, it, it.def_id.expect_real(), AssocItemRender::All)
}
fn item_constant(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, c: &clean::Constant) {
}
}
}
- render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
+ render_assoc_items(w, cx, it, it.def_id.expect_real(), AssocItemRender::All)
}
fn item_static(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::Static) {
document(w, cx, it, None);
- render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
+ render_assoc_items(w, cx, it, it.def_id.expect_real(), AssocItemRender::All)
}
fn item_keyword(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item) {
// Update the list of all implementors for traits
let dst = cx.dst.join("implementors");
for (&did, imps) in &cx.cache.implementors {
+ let did = did.expect_real();
+
// Private modules can leak through to this phase of rustdoc, which
// could contain implementations for otherwise private types. In some
// rare cases we could find an implementation for an item which wasn't
//
// If the implementation is from another crate then that crate
// should add it.
- if imp.impl_item.def_id.krate == did.krate || !imp.impl_item.def_id.is_local() {
+ if imp.impl_item.def_id.krate() == did.krate || !imp.impl_item.def_id.is_local() {
None
} else {
Some(Implementor {
}
buf.write_str("<pre class=\"line-numbers\">");
for i in 1..=lines {
- write!(buf, "<span id=\"{0}\">{0:1$}</span>\n", i, cols);
+ writeln!(buf, "<span id=\"{0}\">{0:1$}</span>", i, cols);
}
buf.write_str("</pre>");
highlight::render_with_highlighting(s, buf, None, None, None, edition);
var hideMethodDocs = getSettingValue("auto-hide-method-docs") === "true";
var hideImplementors = getSettingValue("auto-collapse-implementors") !== "false";
var hideLargeItemContents = getSettingValue("auto-hide-large-items") !== "false";
- var hideTraitImplementations =
- getSettingValue("auto-hide-trait-implementations") !== "false";
var impl_list = document.getElementById("trait-implementations-list");
if (impl_list !== null) {
});
}
- var func = function(e) {
- var next = e.nextElementSibling;
- if (next && hasClass(next, "item-info")) {
- next = next.nextElementSibling;
- }
- if (!next) {
- return;
- }
- if (hasClass(next, "docblock")) {
- var newToggle = toggle.cloneNode(true);
- insertAfter(newToggle, e.childNodes[e.childNodes.length - 1]);
- if (hideMethodDocs === true && hasClass(e, "method") === true) {
- collapseDocs(newToggle, "hide");
+ if (hideMethodDocs === true) {
+ onEachLazy(document.getElementsByClassName("method"), function(e) {
+ var toggle = e.parentNode;
+ if (toggle) {
+ toggle = toggle.parentNode;
}
- }
- };
-
- var funcImpl = function(e) {
- var next = e.nextElementSibling;
- if (next && hasClass(next, "item-info")) {
- next = next.nextElementSibling;
- }
- if (next && hasClass(next, "docblock")) {
- next = next.nextElementSibling;
- }
- if (!next) {
- return;
- }
- };
+ if (toggle && toggle.tagName === "DETAILS") {
+ toggle.open = false;
+ }
+ });
+ }
- onEachLazy(document.getElementsByClassName("method"), func);
- onEachLazy(document.getElementsByClassName("associatedconstant"), func);
- var impl_call = function() {};
onEachLazy(document.getElementsByTagName("details"), function (e) {
var showLargeItem = !hideLargeItemContents && hasClass(e, "type-contents-toggle");
var showImplementor = !hideImplementors && hasClass(e, "implementors-toggle");
e.open = true;
}
});
- if (hideMethodDocs === true) {
- impl_call = function(e, newToggle) {
- if (e.id.match(/^impl(?:-\d+)?$/) === null) {
- // Automatically minimize all non-inherent impls
- if (hasClass(e, "impl") === true) {
- collapseDocs(newToggle, "hide");
- }
- }
- };
- }
- var newToggle = document.createElement("a");
- newToggle.href = "javascript:void(0)";
- newToggle.className = "collapse-toggle hidden-default collapsed";
- newToggle.innerHTML = "[<span class=\"inner\">" + labelForToggleButton(true) +
- "</span>] Show hidden undocumented items";
- function toggleClicked() {
- if (hasClass(this, "collapsed")) {
- removeClass(this, "collapsed");
- onEachLazy(this.parentNode.getElementsByClassName("hidden"), function(x) {
- if (hasClass(x, "content") === false) {
- removeClass(x, "hidden");
- addClass(x, "x");
- }
- }, true);
- this.innerHTML = "[<span class=\"inner\">" + labelForToggleButton(false) +
- "</span>] Hide undocumented items";
- } else {
- addClass(this, "collapsed");
- onEachLazy(this.parentNode.getElementsByClassName("x"), function(x) {
- if (hasClass(x, "content") === false) {
- addClass(x, "hidden");
- removeClass(x, "x");
- }
- }, true);
- this.innerHTML = "[<span class=\"inner\">" + labelForToggleButton(true) +
- "</span>] Show hidden undocumented items";
- }
- }
- onEachLazy(document.getElementsByClassName("impl-items"), function(e) {
- onEachLazy(e.getElementsByClassName("associatedconstant"), func);
- // We transform the DOM iterator into a vec of DOM elements to prevent performance
- // issues on webkit browsers.
- var hiddenElems = Array.prototype.slice.call(e.getElementsByClassName("hidden"));
- var needToggle = hiddenElems.some(function(hiddenElem) {
- return hasClass(hiddenElem, "content") === false &&
- hasClass(hiddenElem, "docblock") === false;
- });
- if (needToggle === true) {
- var inner_toggle = newToggle.cloneNode(true);
- inner_toggle.onclick = toggleClicked;
- e.insertBefore(inner_toggle, e.firstChild);
- impl_call(e.previousSibling, inner_toggle);
- }
- });
var currentType = document.getElementsByClassName("type-decl")[0];
var className = null;
searchState.setup();
}());
-function copy_path(but) {
- var parent = but.parentElement;
- var path = [];
+(function () {
+ var reset_button_timeout = null;
- onEach(parent.childNodes, function(child) {
- if (child.tagName === 'A') {
- path.push(child.textContent);
- }
- });
+ window.copy_path = function(but) {
+ var parent = but.parentElement;
+ var path = [];
- var el = document.createElement('textarea');
- el.value = 'use ' + path.join('::') + ';';
- el.setAttribute('readonly', '');
- // To not make it appear on the screen.
- el.style.position = 'absolute';
- el.style.left = '-9999px';
+ onEach(parent.childNodes, function(child) {
+ if (child.tagName === 'A') {
+ path.push(child.textContent);
+ }
+ });
- document.body.appendChild(el);
- el.select();
- document.execCommand('copy');
- document.body.removeChild(el);
+ var el = document.createElement('textarea');
+ el.value = 'use ' + path.join('::') + ';';
+ el.setAttribute('readonly', '');
+ // To not make it appear on the screen.
+ el.style.position = 'absolute';
+ el.style.left = '-9999px';
- but.textContent = '✓';
-}
+ document.body.appendChild(el);
+ el.select();
+ document.execCommand('copy');
+ document.body.removeChild(el);
+
+ but.textContent = '✓';
+
+ if (reset_button_timeout !== null) {
+ window.clearTimeout(reset_button_timeout);
+ }
+
+ function reset_button() {
+ but.textContent = '⎘';
+ reset_button_timeout = null;
+ }
+
+ reset_button_timeout = window.setTimeout(reset_button, 1000);
+ };
+}());
font-size: 1.3em;
}
h1, h2, h3:not(.impl):not(.method):not(.type):not(.tymethod):not(.notable),
-h4:not(.method):not(.type):not(.tymethod):not(.associatedconstant) {
+h4:not(.method):not(.type):not(.tymethod):not(.associatedconstant):not(.associatedtype) {
font-weight: 500;
margin: 20px 0 15px 0;
padding-bottom: 6px;
}
h1.fqn {
display: flex;
- width: 100%;
border-bottom: 1px dashed;
margin-top: 0;
+
+ /* workaround to keep flex from breaking below 700 px width due to the float: right on the nav
+ above the h1 */
+ padding-left: 1px;
}
h1.fqn > .in-band > a:hover {
text-decoration: underline;
}
h2, h3:not(.impl):not(.method):not(.type):not(.tymethod),
-h4:not(.method):not(.type):not(.tymethod):not(.associatedconstant) {
+h4:not(.method):not(.type):not(.tymethod):not(.associatedconstant):not(.associatedtype) {
border-bottom: 1px solid;
}
-h3.impl, h3.method, h4.method, h3.type, h4.type, h4.associatedconstant {
+h3.impl, h3.method, h4.method, h3.type, h4.type, h4.associatedconstant, h4.associatedtype {
flex-basis: 100%;
font-weight: 600;
margin-top: 16px;
position: relative;
}
h3.impl, h3.method, h4.method.trait-impl, h3.type,
-h4.type.trait-impl, h4.associatedconstant.trait-impl {
+h4.type.trait-impl, h4.associatedconstant.trait-impl, h4.associatedtype.trait-impl {
padding-left: 15px;
}
.sidebar, a.source, .search-input, .content table td:first-child > a,
.collapse-toggle, div.item-list .out-of-band,
#source-sidebar, #sidebar-toggle,
+details.rustdoc-toggle > summary::before,
+details.undocumented > summary::before,
+.content ul.crate a.crate,
/* This selector is for the items listed in the "all items" page. */
#main > ul.docblock > li > a {
font-family: "Fira Sans", Arial, sans-serif;
.content ul.crate a.crate {
font-size: 16px/1.6;
- font-family: "Fira Sans", Arial, sans-serif;
}
ol, ul {
position: relative;
}
-#results {
- position: absolute;
- right: 0;
- left: 0;
- overflow: auto;
-}
-
#results > table {
width: 100%;
table-layout: fixed;
- margin-bottom: 40px;
}
.content pre.line-numbers {
}
.content .out-of-band {
- float: right;
+ flex-grow: 0;
+ text-align: right;
font-size: 23px;
margin: 0px;
- padding: 0px;
+ padding: 0 0 0 12px;
font-weight: normal;
}
-h1.fqn > .out-of-band {
- float: unset;
- flex: 1;
- text-align: right;
- margin-left: 8px;
-}
-
h3.impl > .out-of-band {
font-size: 21px;
}
}
.content .in-band {
+ flex-grow: 1;
margin: 0px;
padding: 0px;
}
left: -19px;
}
-.content .impl-items .method, .content .impl-items > .type, .impl-items > .associatedconstant {
+.content .impl-items .method, .content .impl-items > .type, .impl-items > .associatedconstant,
+.impl-items > .associatedtype, .content .impl-items details > summary > .type,
+.impl-items details > summary > .associatedconstant,
+.impl-items details > summary > .associatedtype {
margin-left: 20px;
}
}
.in-band:hover > .anchor, .impl:hover > .anchor, .method.trait-impl:hover > .anchor,
-.type.trait-impl:hover > .anchor, .associatedconstant.trait-impl:hover > .anchor {
+.type.trait-impl:hover > .anchor, .associatedconstant.trait-impl:hover > .anchor,
+.associatedtype.trait-impl:hover > .anchor {
display: inline-block;
position: absolute;
}
margin-left: 0;
}
- .content .impl-items .method, .content .impl-items > .type, .impl-items > .associatedconstant {
+ .content .impl-items .method, .content .impl-items > .type, .impl-items > .associatedconstant,
+ .impl-items > .associatedtype {
display: flex;
}
display: none !important;
}
- h1.fqn {
- overflow: initial;
- }
-
.theme-picker {
left: 10px;
top: 54px;
cursor: pointer;
}
-details.rustdoc-toggle > summary::-webkit-details-marker {
+details.rustdoc-toggle > summary::-webkit-details-marker,
+details.rustdoc-toggle > summary::marker,
+details.undocumented > summary::-webkit-details-marker,
+details.undocumented > summary::marker {
display: none;
}
details.rustdoc-toggle > summary:not(.hideme)::before {
position: absolute;
left: -23px;
+ top: initial;
+}
+
+.impl-items > details.rustdoc-toggle > summary:not(.hideme)::before,
+.undocumented > details.rustdoc-toggle > summary:not(.hideme)::before {
+ position: absolute;
+ top: 3px;
+ left: -2px;
}
/* When a "hideme" summary is open and the "Expand description" or "Show
position: absolute;
}
-details.rustdoc-toggle[open] {
+details.rustdoc-toggle, details.undocumented {
position: relative;
}
content: "[−]";
display: inline;
}
+
+details.undocumented > summary::before {
+ content: "[+] Show hidden undocumented items";
+ cursor: pointer;
+ font-size: 16px;
+ font-weight: 300;
+}
+
+details.undocumented[open] > summary::before {
+ content: "[-] Hide undocumented items";
+}
.collapse-toggle,
details.rustdoc-toggle > summary.hideme > span,
-details.rustdoc-toggle > summary::before {
+details.rustdoc-toggle > summary::before,
+details.undocumented > summary::before {
color: #999;
}
.collapse-toggle,
details.rustdoc-toggle > summary.hideme > span,
-details.rustdoc-toggle > summary::before {
+details.rustdoc-toggle > summary::before,
+details.undocumented > summary::before {
color: #999;
}
.collapse-toggle,
details.rustdoc-toggle > summary.hideme > span,
-details.rustdoc-toggle > summary::before {
+details.rustdoc-toggle > summary::before,
+details.undocumented > summary::before {
color: #999;
}
use rustc_ast::ast;
use rustc_hir::def::CtorKind;
use rustc_middle::ty::TyCtxt;
-use rustc_span::def_id::{DefId, CRATE_DEF_INDEX};
+use rustc_span::def_id::CRATE_DEF_INDEX;
use rustc_span::Pos;
use rustdoc_json_types::*;
use crate::clean;
use crate::clean::utils::print_const_expr;
+use crate::clean::FakeDefId;
use crate::formats::item_type::ItemType;
use crate::json::JsonRenderer;
use std::collections::HashSet;
};
Some(Item {
id: from_def_id(def_id),
- crate_id: def_id.krate.as_u32(),
+ crate_id: def_id.krate().as_u32(),
name: name.map(|sym| sym.to_string()),
span: self.convert_span(span),
visibility: self.convert_visibility(visibility),
Inherited => Visibility::Default,
Restricted(did) if did.index == CRATE_DEF_INDEX => Visibility::Crate,
Restricted(did) => Visibility::Restricted {
- parent: from_def_id(did),
+ parent: from_def_id(did.into()),
path: self.tcx.def_path(did).to_string_no_crate_verbose(),
},
}
}
}
-crate fn from_def_id(did: DefId) -> Id {
- Id(format!("{}:{}", did.krate.as_u32(), u32::from(did.index)))
+crate fn from_def_id(did: FakeDefId) -> Id {
+ match did {
+ FakeDefId::Real(did) => Id(format!("{}:{}", did.krate.as_u32(), u32::from(did.index))),
+ // We need to differentiate real and fake ids, because the indices might overlap for fake
+ // and real DefId's, which would cause two different Id's treated as they were the same.
+ FakeDefId::Fake(idx, krate) => Id(format!("F{}:{}", krate.as_u32(), u32::from(idx))),
+ }
}
fn from_clean_item(item: clean::Item, tcx: TyCtxt<'_>) -> ItemEnum {
match ty {
ResolvedPath { path, param_names, did, is_generic: _ } => Type::ResolvedPath {
name: path.whole_name(),
- id: from_def_id(did),
+ id: from_def_id(did.into()),
args: path.segments.last().map(|args| Box::new(args.clone().args.into_tcx(tcx))),
param_names: param_names
.map(|v| v.into_iter().map(|x| x.into_tcx(tcx)).collect())
impl FromWithTcx<clean::Impl> for Impl {
fn from_tcx(impl_: clean::Impl, tcx: TyCtxt<'_>) -> Self {
+ let provided_trait_methods = impl_.provided_trait_methods(tcx);
let clean::Impl {
unsafety,
generics,
- provided_trait_methods,
trait_,
for_,
items,
Simple(s) => Import {
source: import.source.path.whole_name(),
name: s.to_string(),
- id: import.source.did.map(from_def_id),
+ id: import.source.did.map(FakeDefId::from).map(from_def_id),
glob: false,
},
Glob => Import {
source: import.source.path.whole_name(),
name: import.source.path.last_name().to_string(),
- id: import.source.did.map(from_def_id),
+ id: import.source.did.map(FakeDefId::from).map(from_def_id),
glob: true,
},
}
use rustdoc_json_types as types;
use crate::clean;
+use crate::clean::{ExternalCrate, FakeDefId};
use crate::config::RenderOptions;
use crate::error::Error;
use crate::formats::cache::Cache;
self.tcx.sess
}
- fn get_trait_implementors(&mut self, id: rustc_span::def_id::DefId) -> Vec<types::Id> {
+ fn get_trait_implementors(&mut self, id: FakeDefId) -> Vec<types::Id> {
Rc::clone(&self.cache)
.implementors
.get(&id)
.unwrap_or_default()
}
- fn get_impls(&mut self, id: rustc_span::def_id::DefId) -> Vec<types::Id> {
+ fn get_impls(&mut self, id: FakeDefId) -> Vec<types::Id> {
Rc::clone(&self.cache)
.impls
- .get(&id)
+ .get(&id.expect_real())
.map(|impls| {
impls
.iter()
let trait_item = &trait_item.trait_;
trait_item.items.clone().into_iter().for_each(|i| self.item(i).unwrap());
Some((
- from_def_id(id),
+ from_def_id(id.into()),
types::Item {
- id: from_def_id(id),
+ id: from_def_id(id.into()),
crate_id: id.krate.as_u32(),
name: self
.cache
.chain(self.cache.external_paths.clone().into_iter())
.map(|(k, (path, kind))| {
(
- from_def_id(k),
+ from_def_id(k.into()),
types::ItemSummary {
crate_id: k.krate.as_u32(),
path,
.cache
.extern_locations
.iter()
- .map(|(k, v)| {
+ .map(|(crate_num, external_location)| {
+ let e = ExternalCrate { crate_num: *crate_num };
(
- k.as_u32(),
+ crate_num.as_u32(),
types::ExternalCrate {
- name: v.0.to_string(),
- html_root_url: match &v.2 {
+ name: e.name(self.tcx).to_string(),
+ html_root_url: match external_location {
ExternalLocation::Remote(s) => Some(s.clone()),
_ => None,
},
use rustc_session::getopts;
use rustc_session::{early_error, early_warn};
-use crate::clean::utils::doc_rust_lang_org_channel;
-
/// A macro to create a FxHashMap.
///
/// Example:
"[unversioned-shared-resources,toolchain-shared-resources,invocation-specific]",
)
}),
+ unstable("no-run", |o| o.optflag("", "no-run", "Compile doctests without running them")),
]
}
}
println!("{}", options.usage(&format!("{} [options] <input>", argv0)));
println!(" @path Read newline separated options from `path`\n");
- println!(
- "More information available at https://doc.rust-lang.org/{}/rustdoc/what-is-rustdoc.html",
- doc_rust_lang_org_channel()
- );
+ println!("More information available at https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html")
}
/// A result type used by several functions under `main()`.
fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
if let Some(dox) = &item.attrs.collapsed_doc_value() {
let sp = item.attr_span(self.cx.tcx);
- let extra = crate::html::markdown::ExtraInfo::new_did(self.cx.tcx, item.def_id, sp);
+ let extra = crate::html::markdown::ExtraInfo::new_did(
+ self.cx.tcx,
+ item.def_id.expect_real(),
+ sp,
+ );
for code_block in markdown::rust_code_blocks(&dox, &extra) {
self.check_rust_syntax(&item, &dox, code_block);
}
use std::mem;
use std::ops::Range;
-use crate::clean::{self, utils::find_nearest_parent_module, Crate, Item, ItemLink, PrimitiveType};
+use crate::clean::{
+ self, utils::find_nearest_parent_module, Crate, FakeDefId, Item, ItemLink, PrimitiveType,
+};
use crate::core::DocContext;
use crate::fold::DocFolder;
use crate::html::markdown::{markdown_links, MarkdownLink};
#[derive(Clone, Debug, Hash, PartialEq, Eq)]
struct ResolutionInfo {
- module_id: DefId,
+ module_id: FakeDefId,
dis: Option<Disambiguator>,
path_str: String,
extra_fragment: Option<String>,
///
/// The last module will be used if the parent scope of the current item is
/// unknown.
- mod_ids: Vec<DefId>,
+ mod_ids: Vec<FakeDefId>,
/// This is used to store the kind of associated items,
/// because `clean` and the disambiguator code expect them to be different.
/// See the code for associated items on inherent impls for details.
) -> Result<(Res, Option<String>), ErrorKind<'path>> {
let tcx = self.cx.tcx;
let no_res = || ResolutionFailure::NotResolved {
- module_id,
+ module_id: module_id.into(),
partial_res: None,
unresolved: path_str.into(),
};
// but the disambiguator logic expects the associated item.
// Store the kind in a side channel so that only the disambiguator logic looks at it.
if let Some((kind, id)) = side_channel {
- self.kind_side_channel.set(Some((kind, id)));
+ self.kind_side_channel.set(Some((kind, id.into())));
}
Ok((res, Some(fragment)))
};
let parent_node = if item.is_fake() {
None
} else {
- find_nearest_parent_module(self.cx.tcx, item.def_id)
+ find_nearest_parent_module(self.cx.tcx, item.def_id.expect_real())
};
if parent_node.is_some() {
let self_id = if item.is_fake() {
None
// Checking if the item is a field in an enum variant
- } else if (matches!(self.cx.tcx.def_kind(item.def_id), DefKind::Field)
+ } else if (matches!(self.cx.tcx.def_kind(item.def_id.expect_real()), DefKind::Field)
&& matches!(
- self.cx.tcx.def_kind(self.cx.tcx.parent(item.def_id).unwrap()),
+ self.cx.tcx.def_kind(self.cx.tcx.parent(item.def_id.expect_real()).unwrap()),
DefKind::Variant
))
{
- self.cx.tcx.parent(item.def_id).and_then(|item_id| self.cx.tcx.parent(item_id))
+ self.cx
+ .tcx
+ .parent(item.def_id.expect_real())
+ .and_then(|item_id| self.cx.tcx.parent(item_id))
} else if matches!(
- self.cx.tcx.def_kind(item.def_id),
+ self.cx.tcx.def_kind(item.def_id.expect_real()),
DefKind::AssocConst
| DefKind::AssocFn
| DefKind::AssocTy
| DefKind::Variant
| DefKind::Field
) {
- self.cx.tcx.parent(item.def_id)
+ self.cx.tcx.parent(item.def_id.expect_real())
// HACK(jynelson): `clean` marks associated types as `TypedefItem`, not as `AssocTypeItem`.
// Fixing this breaks `fn render_deref_methods`.
// As a workaround, see if the parent of the item is an `impl`; if so this must be an associated item,
// regardless of what rustdoc wants to call it.
- } else if let Some(parent) = self.cx.tcx.parent(item.def_id) {
+ } else if let Some(parent) = self.cx.tcx.parent(item.def_id.expect_real()) {
let parent_kind = self.cx.tcx.def_kind(parent);
- Some(if parent_kind == DefKind::Impl { parent } else { item.def_id })
+ Some(if parent_kind == DefKind::Impl { parent } else { item.def_id.expect_real() })
} else {
- Some(item.def_id)
+ Some(item.def_id.expect_real())
};
// FIXME(jynelson): this shouldn't go through stringification, rustdoc should just use the DefId directly
let (krate, parent_node) = if let Some(id) = parent_module {
(id.krate, Some(id))
} else {
- (item.def_id.krate, parent_node)
+ (item.def_id.krate(), parent_node)
};
// NOTE: if there are links that start in one crate and end in another, this will not resolve them.
// This is a degenerate case and it's not supported by rustdoc.
// we've already pushed this node onto the resolution stack but
// for outer comments we explicitly try and resolve against the
// parent_node first.
- let base_node =
- if item.is_mod() && inner_docs { self.mod_ids.last().copied() } else { parent_node };
+ let base_node = if item.is_mod() && inner_docs {
+ self.mod_ids.last().copied()
+ } else {
+ parent_node.map(|id| FakeDefId::new_real(id))
+ };
let mut module_id = if let Some(id) = base_node {
id
resolved_self = format!("self::{}", &path_str["crate::".len()..]);
path_str = &resolved_self;
}
- module_id = DefId { krate, index: CRATE_DEF_INDEX };
+ module_id = FakeDefId::new_real(DefId { krate, index: CRATE_DEF_INDEX });
}
let (mut res, mut fragment) = self.resolve_with_disambiguator_cached(
report_diagnostic(self.cx.tcx, BROKEN_INTRA_DOC_LINKS, &msg, &diag_info, callback);
};
- let verify = |kind: DefKind, id: DefId| {
- let (kind, id) = self.kind_side_channel.take().unwrap_or((kind, id));
+ let verify = |kind: DefKind, id: FakeDefId| {
+ let (kind, id) = self.kind_side_channel.take().unwrap_or((kind, id.expect_real()));
debug!("intra-doc link to {} resolved to {:?} (id: {:?})", path_str, res, id);
// Disallow e.g. linking to enums with `struct@`
// doesn't allow statements like `use str::trim;`, making this a (hopefully)
// valid omission. See https://github.com/rust-lang/rust/pull/80660#discussion_r551585677
// for discussion on the matter.
- verify(kind, id)?;
+ verify(kind, id.into())?;
// FIXME: it would be nice to check that the feature gate was enabled in the original crate, not just ignore it altogether.
// However I'm not sure how to check that across crates.
Some(ItemLink { link: ori_link.link, link_text, did: None, fragment })
}
Res::Def(kind, id) => {
- verify(kind, id)?;
+ verify(kind, id.into())?;
let id = clean::register_res(self.cx, rustc_hir::def::Res::Def(kind, id));
- Some(ItemLink { link: ori_link.link, link_text, did: Some(id), fragment })
+ Some(ItemLink { link: ori_link.link, link_text, did: Some(id.into()), fragment })
}
}
}
match disambiguator.map(Disambiguator::ns) {
Some(expected_ns @ (ValueNS | TypeNS)) => {
- match self.resolve(path_str, expected_ns, base_node, extra_fragment) {
+ match self.resolve(path_str, expected_ns, base_node.expect_real(), extra_fragment) {
Ok(res) => Some(res),
Err(ErrorKind::Resolve(box mut kind)) => {
// We only looked in one namespace. Try to give a better error if possible.
// FIXME: really it should be `resolution_failure` that does this, not `resolve_with_disambiguator`
// See https://github.com/rust-lang/rust/pull/76955#discussion_r493953382 for a good approach
for &new_ns in &[other_ns, MacroNS] {
- if let Some(res) =
- self.check_full_res(new_ns, path_str, base_node, extra_fragment)
- {
+ if let Some(res) = self.check_full_res(
+ new_ns,
+ path_str,
+ base_node.expect_real(),
+ extra_fragment,
+ ) {
kind = ResolutionFailure::WrongNamespace { res, expected_ns };
break;
}
// Try everything!
let mut candidates = PerNS {
macro_ns: self
- .resolve_macro(path_str, base_node)
+ .resolve_macro(path_str, base_node.expect_real())
.map(|res| (res, extra_fragment.clone())),
- type_ns: match self.resolve(path_str, TypeNS, base_node, extra_fragment) {
+ type_ns: match self.resolve(
+ path_str,
+ TypeNS,
+ base_node.expect_real(),
+ extra_fragment,
+ ) {
Ok(res) => {
debug!("got res in TypeNS: {:?}", res);
Ok(res)
}
Err(ErrorKind::Resolve(box kind)) => Err(kind),
},
- value_ns: match self.resolve(path_str, ValueNS, base_node, extra_fragment) {
+ value_ns: match self.resolve(
+ path_str,
+ ValueNS,
+ base_node.expect_real(),
+ extra_fragment,
+ ) {
Ok(res) => Ok(res),
Err(ErrorKind::AnchorFailure(msg)) => {
anchor_failure(self.cx, diag, msg);
}
if len == 1 {
- Some(candidates.into_iter().filter_map(|res| res.ok()).next().unwrap())
+ Some(candidates.into_iter().find_map(|res| res.ok()).unwrap())
} else if len == 2 && is_derive_trait_collision(&candidates) {
Some(candidates.type_ns.unwrap())
} else {
}
}
Some(MacroNS) => {
- match self.resolve_macro(path_str, base_node) {
+ match self.resolve_macro(path_str, base_node.expect_real()) {
Ok(res) => Some((res, extra_fragment.clone())),
Err(mut kind) => {
// `resolve_macro` only looks in the macro namespace. Try to give a better error if possible.
for &ns in &[TypeNS, ValueNS] {
- if let Some(res) =
- self.check_full_res(ns, path_str, base_node, extra_fragment)
- {
+ if let Some(res) = self.check_full_res(
+ ns,
+ path_str,
+ base_node.expect_real(),
+ extra_fragment,
+ ) {
kind =
ResolutionFailure::WrongNamespace { res, expected_ns: MacroNS };
break;
name = start;
for &ns in &[TypeNS, ValueNS, MacroNS] {
if let Some(res) =
- collector.check_full_res(ns, &start, module_id, &None)
+ collector.check_full_res(ns, &start, module_id.into(), &None)
{
debug!("found partial_res={:?}", res);
*partial_res = Some(res);
msg: &str,
) {
diag_info.link_range = disambiguator_range;
- report_diagnostic(cx.tcx, BROKEN_INTRA_DOC_LINKS, msg, &diag_info, |diag, _sp| {
- let msg = format!(
- "see https://doc.rust-lang.org/{}/rustdoc/linking-to-items-by-name.html#namespaces-and-disambiguators \
- for more info about disambiguators",
- crate::doc_rust_lang_org_channel(),
- );
- diag.note(&msg);
- });
+ report_diagnostic(cx.tcx, BROKEN_INTRA_DOC_LINKS, msg, &diag_info, |_diag, _sp| {});
}
/// Report an ambiguity error, where there were multiple possible resolutions.
// FIXME(eddyb) is this `doc(hidden)` check needed?
if !cx.tcx.get_attrs(def_id).lists(sym::doc).has_word(sym::hidden) {
- let impls = get_auto_trait_and_blanket_impls(cx, def_id);
+ let impls = get_auto_trait_and_blanket_impls(cx, def_id.into());
new_items.extend(impls.filter(|i| cx.inlined.insert(i.def_id)));
}
});
// Avoid infinite cycles
return;
}
- cleaner.items.insert(target_did);
- add_deref_target(map, cleaner, &target_did);
+ cleaner.items.insert(target_did.into());
+ add_deref_target(map, cleaner, &target_did.into());
}
}
}
// Since only the `DefId` portion of the `Type` instances is known to be same for both the
// `Deref` target type and the impl for type positions, this map of types is keyed by
// `DefId` and for convenience uses a special cleaner that accepts `DefId`s directly.
- if cleaner.keep_impl_with_def_id(type_did) {
+ if cleaner.keep_impl_with_def_id(&FakeDefId::new_real(*type_did)) {
add_deref_target(&type_did_to_deref_target, &mut cleaner, type_did);
}
}
fn fold_item(&mut self, i: Item) -> Option<Item> {
if i.is_struct() || i.is_enum() || i.is_union() {
// FIXME(eddyb) is this `doc(hidden)` check needed?
- if !self.cx.tcx.get_attrs(i.def_id).lists(sym::doc).has_word(sym::hidden) {
- self.impls.extend(get_auto_trait_and_blanket_impls(self.cx, i.def_id));
+ if !self.cx.tcx.get_attrs(i.def_id.expect_real()).lists(sym::doc).has_word(sym::hidden)
+ {
+ self.impls
+ .extend(get_auto_trait_and_blanket_impls(self.cx, i.def_id.expect_real()));
}
}
#[derive(Default)]
struct ItemCollector {
- items: FxHashSet<DefId>,
+ items: FxHashSet<FakeDefId>,
}
impl ItemCollector {
struct BadImplStripper {
prims: FxHashSet<PrimitiveType>,
- items: FxHashSet<DefId>,
+ items: FxHashSet<FakeDefId>,
}
impl BadImplStripper {
} else if let Some(prim) = ty.primitive_type() {
self.prims.contains(&prim)
} else if let Some(did) = ty.def_id() {
- self.keep_impl_with_def_id(&did)
+ self.keep_impl_with_def_id(&did.into())
} else {
false
}
}
- fn keep_impl_with_def_id(&self, did: &DefId) -> bool {
+ fn keep_impl_with_def_id(&self, did: &FakeDefId) -> bool {
self.items.contains(did)
}
}
}
crate fn should_have_doc_example(cx: &DocContext<'_>, item: &clean::Item) -> bool {
- if !cx.cache.access_levels.is_public(item.def_id)
+ if !cx.cache.access_levels.is_public(item.def_id.expect_real())
|| matches!(
*item.kind,
clean::StructFieldItem(_)
|lint| lint.build("missing code example in this documentation").emit(),
);
}
- } else if tests.found_tests > 0 && !cx.cache.access_levels.is_public(item.def_id) {
+ } else if tests.found_tests > 0 && !cx.cache.access_levels.is_public(item.def_id.expect_real())
+ {
cx.tcx.struct_span_lint_hir(
crate::lint::PRIVATE_DOC_TESTS,
hir_id,
-use rustc_hir::def_id::DefIdSet;
use rustc_span::symbol::sym;
use std::mem;
use crate::clean;
-use crate::clean::{Item, NestedAttributesExt};
+use crate::clean::{FakeDefIdSet, Item, NestedAttributesExt};
use crate::core::DocContext;
use crate::fold::{DocFolder, StripItem};
use crate::passes::{ImplStripper, Pass};
/// Strip items marked `#[doc(hidden)]`
crate fn strip_hidden(krate: clean::Crate, _: &mut DocContext<'_>) -> clean::Crate {
- let mut retained = DefIdSet::default();
+ let mut retained = FakeDefIdSet::default();
// strip all #[doc(hidden)] items
let krate = {
}
struct Stripper<'a> {
- retained: &'a mut DefIdSet,
+ retained: &'a mut FakeDefIdSet,
update_retained: bool,
}
-use rustc_hir::def_id::DefIdSet;
-
-use crate::clean;
+use crate::clean::{self, FakeDefIdSet};
use crate::core::DocContext;
use crate::fold::DocFolder;
use crate::passes::{ImplStripper, ImportStripper, Pass, Stripper};
/// crate, specified by the `xcrate` flag.
crate fn strip_private(mut krate: clean::Crate, cx: &mut DocContext<'_>) -> clean::Crate {
// This stripper collects all *retained* nodes.
- let mut retained = DefIdSet::default();
+ let mut retained = FakeDefIdSet::default();
// strip all private items
{
-use rustc_hir::def_id::{DefId, DefIdSet};
+use rustc_hir::def_id::DefId;
use rustc_middle::middle::privacy::AccessLevels;
use std::mem;
-use crate::clean::{self, GetDefId, Item};
+use crate::clean::{self, FakeDefIdSet, GetDefId, Item};
use crate::fold::{DocFolder, StripItem};
crate struct Stripper<'a> {
- crate retained: &'a mut DefIdSet,
+ crate retained: &'a mut FakeDefIdSet,
crate access_levels: &'a AccessLevels<DefId>,
crate update_retained: bool,
}
| clean::TraitAliasItem(..)
| clean::ForeignTypeItem => {
if i.def_id.is_local() {
- if !self.access_levels.is_exported(i.def_id) {
+ if !self.access_levels.is_exported(i.def_id.expect_real()) {
debug!("Stripper: stripping {:?} {:?}", i.type_(), i.name);
return None;
}
/// This stripper discards all impls which reference stripped items
crate struct ImplStripper<'a> {
- crate retained: &'a DefIdSet,
+ crate retained: &'a FakeDefIdSet,
}
impl<'a> DocFolder for ImplStripper<'a> {
return None;
}
if let Some(did) = imp.for_.def_id() {
- if did.is_local() && !imp.for_.is_generic() && !self.retained.contains(&did) {
+ if did.is_local() && !imp.for_.is_generic() && !self.retained.contains(&did.into())
+ {
debug!("ImplStripper: impl item for stripped type; removing");
return None;
}
}
if let Some(did) = imp.trait_.def_id() {
- if did.is_local() && !self.retained.contains(&did) {
+ if did.is_local() && !self.retained.contains(&did.into()) {
debug!("ImplStripper: impl item for stripped trait; removing");
return None;
}
if let Some(generics) = imp.trait_.as_ref().and_then(|t| t.generics()) {
for typaram in generics {
if let Some(did) = typaram.def_id() {
- if did.is_local() && !self.retained.contains(&did) {
+ if did.is_local() && !self.retained.contains(&did.into()) {
debug!(
"ImplStripper: stripped item in trait's generics; removing impl"
);
// This PartialEq implementation IS NOT COMMUTATIVE!!!
//
// The order is very important: the second object must have all first's rules.
-// However, the first doesn't require to have all second's rules.
+// However, the first is not required to have all of the second's rules.
impl PartialEq for CssPath {
fn eq(&self, other: &CssPath) -> bool {
if self.name != other.name {
use rustc_hir::Node;
use rustc_middle::middle::privacy::AccessLevel;
use rustc_middle::ty::TyCtxt;
+use rustc_span;
use rustc_span::source_map::Spanned;
use rustc_span::symbol::{kw, sym, Symbol};
-use rustc_span::{self, Span};
use std::mem;
crate fn visit(mut self, krate: &'tcx hir::Crate<'_>) -> Module<'tcx> {
let span = krate.item.inner;
let mut top_level_module = self.visit_mod_contents(
- span,
&Spanned { span, node: hir::VisibilityKind::Public },
hir::CRATE_HIR_ID,
&krate.item,
fn visit_mod_contents(
&mut self,
- span: Span,
vis: &hir::Visibility<'_>,
id: hir::HirId,
m: &'tcx hir::Mod<'tcx>,
name: Symbol,
) -> Module<'tcx> {
- let mut om = Module::new(name);
- om.where_outer = span;
- om.where_inner = m.inner;
- om.id = id;
+ let mut om = Module::new(name, id, m.inner);
// Keep track of if there were any private modules in the path.
let orig_inside_public_path = self.inside_public_path;
self.inside_public_path &= vis.node.is_pub();
} else {
// All items need to be handled here in case someone wishes to link
// to them with intra-doc links
- self.cx.cache.access_levels.map.insert(did, AccessLevel::Public);
+ self.cx.cache.access_levels.map.insert(did.into(), AccessLevel::Public);
}
}
}
None => return false,
};
- let is_private = !self.cx.cache.access_levels.is_public(res_did);
+ let is_private = !self.cx.cache.access_levels.is_public(res_did.into());
let is_hidden = inherits_doc_hidden(self.cx.tcx, res_hir_id);
// Only inline if requested or if the item would otherwise be stripped.
om.items.push((item, renamed))
}
hir::ItemKind::Mod(ref m) => {
- om.mods.push(self.visit_mod_contents(item.span, &item.vis, item.hir_id(), m, name));
+ om.mods.push(self.visit_mod_contents(&item.vis, item.hir_id(), m, name));
}
hir::ItemKind::Fn(..)
| hir::ItemKind::ExternCrate(..)
-Subproject commit 0ed6038a318e34e3d76a9e55bdebc4cfd17f902a
+Subproject commit b61c24f3521303d442fa86fe691bc8e6acc15103
+++ /dev/null
-// min-llvm-version: 11.0.1
-// revisions: x86_64 i686
-// assembly-output: emit-asm
-//[x86_64] compile-flags: --target x86_64-unknown-linux-gnu
-//[i686] compile-flags: --target i686-unknown-linux-gnu
-// compile-flags: -C llvm-args=--x86-asm-syntax=intel
-
-#![feature(no_core, lang_items)]
-#![crate_type = "lib"]
-#![no_core]
-
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for u8 {}
-
-// Check that inline-asm stack probes are generated correctly.
-// To avoid making this test fragile to slight asm changes,
-// we only check that the stack pointer is decremented by a page at a time,
-// instead of matching the whole probe sequence.
-
-// CHECK-LABEL: small_stack_probe:
-#[no_mangle]
-pub fn small_stack_probe(x: u8, f: fn([u8; 8192])) {
- // CHECK-NOT: __rust_probestack
- // x86_64: sub rsp, 4096
- // i686: sub esp, 4096
- let a = [x; 8192];
- f(a);
-}
-
-// CHECK-LABEL: big_stack_probe:
-#[no_mangle]
-pub fn big_stack_probe(x: u8, f: fn([u8; 65536])) {
- // CHECK-NOT: __rust_probestack
- // x86_64: sub rsp, 4096
- // i686: sub esp, 4096
- let a = [x; 65536];
- f(a);
-}
#[no_mangle]
pub unsafe fn pure(x: i32) {
let y: i32;
- asm!("", out("ax") y, in("bx") x, options(pure), options(nomem));
+ asm!("", out("ax") y, in("cx") x, options(pure), options(nomem));
}
pub static mut VAR: i32 = 0;
#[no_mangle]
pub unsafe fn pure(x: i32) {
let y: i32;
- asm!("", out("ax") y, in("bx") x, options(pure, nomem));
+ asm!("", out("ax") y, in("cx") x, options(pure, nomem));
}
// CHECK-LABEL: @noreturn
// Verify debuginfo for generators:
// - Each variant points to the file and line of its yield point
-// - The generator types and variants are marked artificial
-// - Captured vars from the source are not marked artificial
+// - The discriminants are marked artificial
+// - Other fields are not marked artificial
//
//
// compile-flags: -C debuginfo=2 --edition=2018
// FIXME: No way to reliably check the filename.
// CHECK-DAG: [[ASYNC_FN:!.*]] = !DINamespace(name: "async_fn_test"
-// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_union_type, name: "generator-0", scope: [[ASYNC_FN]], {{.*}}flags: DIFlagArtificial
+// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_union_type, name: "generator-0", scope: [[ASYNC_FN]]
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, scope: [[GEN]],
// For brevity, we only check the struct name and members of the last variant.
// CHECK-SAME: file: [[FILE:![0-9]*]], line: 11,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, scope: [[GEN]],
// CHECK-SAME: file: [[FILE]], line: 15,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, scope: [[GEN]],
// CHECK-SAME: file: [[FILE]], line: 15,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, scope: [[GEN]],
// CHECK-SAME: file: [[FILE]], line: 12,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, scope: [[GEN]],
// CHECK-SAME: file: [[FILE]], line: 14,
// CHECK-SAME: baseType: [[VARIANT:![0-9]*]]
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: [[S1:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Suspend1", scope: [[ASYNC_FN]],
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "RUST$ENUM$DISR", scope: [[S1]],
// CHECK-SAME: flags: DIFlagArtificial
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "s", scope: [[S1]]
// Verify debuginfo for async fn:
// - Each variant points to the file and line of its yield point
-// - The generator types and variants are marked artificial
-// - Captured vars from the source are not marked artificial
+// - The discriminants are marked artificial
+// - Other fields are not marked artificial
//
//
// compile-flags: -C debuginfo=2 --edition=2018
// FIXME: No way to reliably check the filename.
// CHECK-DAG: [[ASYNC_FN:!.*]] = !DINamespace(name: "async_fn_test"
-// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "generator-0", scope: [[ASYNC_FN]], {{.*}}flags: DIFlagArtificial
+// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "generator-0", scope: [[ASYNC_FN]]
// CHECK: [[VARIANT:!.*]] = !DICompositeType(tag: DW_TAG_variant_part, scope: [[ASYNC_FN]],
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
// CHECK-SAME: discriminator: [[DISC:![0-9]*]]
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "0", scope: [[VARIANT]],
// CHECK-SAME: file: [[FILE:![0-9]*]], line: 11,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "Unresumed", scope: [[GEN]],
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "1", scope: [[VARIANT]],
// CHECK-SAME: file: [[FILE]], line: 15,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "2", scope: [[VARIANT]],
// CHECK-SAME: file: [[FILE]], line: 15,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "3", scope: [[VARIANT]],
// CHECK-SAME: file: [[FILE]], line: 12,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "4", scope: [[VARIANT]],
// CHECK-SAME: file: [[FILE]], line: 14,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: [[S1:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Suspend1", scope: [[GEN]],
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "s", scope: [[S1]]
// CHECK-NOT: flags: DIFlagArtificial
// CHECK-SAME: )
// Verify debuginfo for generators:
// - Each variant points to the file and line of its yield point
-// - The generator types and variants are marked artificial
-// - Captured vars from the source are not marked artificial
+// - The discriminants are marked artificial
+// - Other fields are not marked artificial
//
//
// compile-flags: -C debuginfo=2
// FIXME: No way to reliably check the filename.
// CHECK-DAG: [[GEN_FN:!.*]] = !DINamespace(name: "generator_test"
-// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_union_type, name: "generator-0", scope: [[GEN_FN]], {{.*}}flags: DIFlagArtificial
+// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_union_type, name: "generator-0", scope: [[GEN_FN]]
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, scope: [[GEN]],
// For brevity, we only check the struct name and members of the last variant.
// CHECK-SAME: file: [[FILE:![0-9]*]], line: 14,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, scope: [[GEN]],
// CHECK-SAME: file: [[FILE]], line: 18,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, scope: [[GEN]],
// CHECK-SAME: file: [[FILE]], line: 18,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, scope: [[GEN]],
// CHECK-SAME: file: [[FILE]], line: 15,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, scope: [[GEN]],
// CHECK-SAME: file: [[FILE]], line: 17,
// CHECK-SAME: baseType: [[VARIANT:![0-9]*]]
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: [[S1:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Suspend1", scope: [[GEN_FN]],
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "RUST$ENUM$DISR", scope: [[S1]],
// CHECK-SAME: flags: DIFlagArtificial
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "s", scope: [[S1]]
// Verify debuginfo for generators:
// - Each variant points to the file and line of its yield point
-// - The generator types and variants are marked artificial
-// - Captured vars from the source are not marked artificial
+// - The discriminants are marked artificial
+// - Other fields are not marked artificial
//
//
// compile-flags: -C debuginfo=2 --edition=2018
// FIXME: No way to reliably check the filename.
// CHECK-DAG: [[GEN_FN:!.*]] = !DINamespace(name: "generator_test"
-// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "generator-0", scope: [[GEN_FN]], {{.*}}flags: DIFlagArtificial
+// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "generator-0", scope: [[GEN_FN]]
// CHECK: [[VARIANT:!.*]] = !DICompositeType(tag: DW_TAG_variant_part, scope: [[GEN_FN]],
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
// CHECK-SAME: discriminator: [[DISC:![0-9]*]]
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "0", scope: [[VARIANT]],
// CHECK-SAME: file: [[FILE:![0-9]*]], line: 14,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DICompositeType(tag: DW_TAG_structure_type, name: "Unresumed", scope: [[GEN]],
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "1", scope: [[VARIANT]],
// CHECK-SAME: file: [[FILE]], line: 18,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "2", scope: [[VARIANT]],
// CHECK-SAME: file: [[FILE]], line: 18,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "3", scope: [[VARIANT]],
// CHECK-SAME: file: [[FILE]], line: 15,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "4", scope: [[VARIANT]],
// CHECK-SAME: file: [[FILE]], line: 17,
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: [[S1:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Suspend1", scope: [[GEN]],
-// CHECK-SAME: flags: DIFlagArtificial
+// CHECK-NOT: flags: DIFlagArtificial
+// CHECK-SAME: )
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "s", scope: [[S1]]
// CHECK-NOT: flags: DIFlagArtificial
// CHECK-SAME: )
// ignore-emscripten
// ignore-windows
// compile-flags: -C no-prepopulate-passes
-// min-llvm-version: 11.0.1
#![crate_type = "lib"]
#[no_mangle]
pub fn foo() {
// CHECK: @foo() unnamed_addr #0
-// CHECK: attributes #0 = { {{.*}}"probe-stack"="inline-asm"{{.*}} }
}
// Require a gdb that can read DW_TAG_variant_part.
// min-gdb-version: 8.2
+// LLDB without native Rust support cannot read DW_TAG_variant_part,
+// so it prints nothing for generators. But those tests are kept to
+// ensure that LLDB won't crash at least (like #57822).
+
// compile-flags:-g
// === GDB TESTS ===================================================================================
// gdb-command:run
// gdb-command:print b
-// gdb-check:$1 = generator_objects::main::generator-0 {__0: 0x[...], <<variant>>: {__state: 0, 0: generator_objects::main::generator-0::Unresumed, 1: generator_objects::main::generator-0::Returned, 2: generator_objects::main::generator-0::Panicked, 3: generator_objects::main::generator-0::Suspend0 {[...]}, 4: generator_objects::main::generator-0::Suspend1 {[...]}}}
+// gdb-check:$1 = generator_objects::main::generator-0::Unresumed(0x[...])
// gdb-command:continue
// gdb-command:print b
-// gdb-check:$2 = generator_objects::main::generator-0 {__0: 0x[...], <<variant>>: {__state: 3, 0: generator_objects::main::generator-0::Unresumed, 1: generator_objects::main::generator-0::Returned, 2: generator_objects::main::generator-0::Panicked, 3: generator_objects::main::generator-0::Suspend0 {c: 6, d: 7}, 4: generator_objects::main::generator-0::Suspend1 {[...]}}}
+// gdb-check:$2 = generator_objects::main::generator-0::Suspend0{c: 6, d: 7, __0: 0x[...]}
// gdb-command:continue
// gdb-command:print b
-// gdb-check:$3 = generator_objects::main::generator-0 {__0: 0x[...], <<variant>>: {__state: 4, 0: generator_objects::main::generator-0::Unresumed, 1: generator_objects::main::generator-0::Returned, 2: generator_objects::main::generator-0::Panicked, 3: generator_objects::main::generator-0::Suspend0 {[...]}, 4: generator_objects::main::generator-0::Suspend1 {c: 7, d: 8}}}
+// gdb-check:$3 = generator_objects::main::generator-0::Suspend1{c: 7, d: 8, __0: 0x[...]}
// gdb-command:continue
// gdb-command:print b
-// gdb-check:$4 = generator_objects::main::generator-0 {__0: 0x[...], <<variant>>: {__state: 1, 0: generator_objects::main::generator-0::Unresumed, 1: generator_objects::main::generator-0::Returned, 2: generator_objects::main::generator-0::Panicked, 3: generator_objects::main::generator-0::Suspend0 {[...]}, 4: generator_objects::main::generator-0::Suspend1 {[...]}}}
+// gdb-check:$4 = generator_objects::main::generator-0::Returned(0x[...])
// === LLDB TESTS ==================================================================================
// lldb-command:run
// lldb-command:print b
-// lldbg-check:(generator_objects::main::generator-0) $0 = { 0 = 0x[...] }
+// lldbg-check:(generator_objects::main::generator-0) $0 =
// lldb-command:continue
// lldb-command:print b
-// lldbg-check:(generator_objects::main::generator-0) $1 = { 0 = 0x[...] }
+// lldbg-check:(generator_objects::main::generator-0) $1 =
// lldb-command:continue
// lldb-command:print b
-// lldbg-check:(generator_objects::main::generator-0) $2 = { 0 = 0x[...] }
+// lldbg-check:(generator_objects::main::generator-0) $2 =
// lldb-command:continue
// lldb-command:print b
-// lldbg-check:(generator_objects::main::generator-0) $3 = { 0 = 0x[...] }
+// lldbg-check:(generator_objects::main::generator-0) $3 =
#![feature(omit_gdb_pretty_printer_section, generators, generator_trait)]
#![omit_gdb_pretty_printer_section]
// gdb-check:$1 = issue_57822::main::closure-1 (issue_57822::main::closure-0 (1))
// gdb-command:print b
-// gdb-check:$2 = issue_57822::main::generator-3 {__0: issue_57822::main::generator-2 {__0: 2, <<variant>>: {[...]}}, <<variant>>: {[...]}}
+// gdb-check:$2 = issue_57822::main::generator-3::Unresumed(issue_57822::main::generator-2::Unresumed(2))
// === LLDB TESTS ==================================================================================
// lldbg-check:(issue_57822::main::closure-1) $0 = { 0 = { 0 = 1 } }
// lldb-command:print b
-// lldbg-check:(issue_57822::main::generator-3) $1 = { 0 = { 0 = 2 } }
+// lldbg-check:(issue_57822::main::generator-3) $1 =
#![feature(omit_gdb_pretty_printer_section, generators, generator_trait)]
#![omit_gdb_pretty_printer_section]
// == Test [gdb|lldb]-[command|check] are parsed correctly ===
// should-fail
+// needs-run-enabled
// compile-flags:-g
// === GDB TESTS ===================================================================================
// the cache while changing an untracked one doesn't.
// ignore-asmjs wasm2js does not support source maps yet
-// revisions:rpass1 rpass2 rpass3
+// revisions:rpass1 rpass2 rpass3 rpass4
// compile-flags: -Z query-dep-graph
#![feature(rustc_attrs)]
#![rustc_partition_codegened(module="commandline_args", cfg="rpass2")]
#![rustc_partition_reused(module="commandline_args", cfg="rpass3")]
+#![rustc_partition_codegened(module="commandline_args", cfg="rpass4")]
// Between revisions 1 and 2, we are changing the debuginfo-level, which should
// invalidate the cache. Between revisions 2 and 3, we are adding `--verbose`
-// which should have no effect on the cache:
+// which should have no effect on the cache. Between revisions, we are adding
+// `--remap-path-prefix` which should invalidate the cache:
//[rpass1] compile-flags: -C debuginfo=0
//[rpass2] compile-flags: -C debuginfo=2
//[rpass3] compile-flags: -C debuginfo=2 --verbose
+//[rpass4] compile-flags: -C debuginfo=2 --verbose --remap-path-prefix=/home/bors/rust=src
pub fn main() {
// empty
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,associated_item_def_ids")]
+#[rustc_clean(cfg="cfail2", except="hir_owner,associated_item_def_ids")]
#[rustc_clean(cfg="cfail3")]
impl Foo {
#[rustc_clean(cfg="cfail3")]
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")]
+#[rustc_clean(cfg="cfail2", except="hir_owner")]
#[rustc_clean(cfg="cfail3")]
impl Foo {
#[rustc_clean(cfg="cfail2", except="associated_item,hir_owner,hir_owner_nodes")]
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")]
+#[rustc_clean(cfg="cfail2", except="hir_owner")]
#[rustc_clean(cfg="cfail3")]
impl Foo {
#[rustc_dirty(cfg="cfail2", except="type_of,predicates_of,promoted_mir")]
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,associated_item_def_ids")]
+#[rustc_clean(cfg="cfail2", except="hir_owner,associated_item_def_ids")]
#[rustc_clean(cfg="cfail3")]
impl Foo {
#[rustc_clean(cfg="cfail2")]
}
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")]
+#[rustc_clean(cfg="cfail2", except="hir_owner")]
#[rustc_clean(cfg="cfail3")]
impl Bar<u64> {
#[rustc_clean(cfg="cfail2", except="fn_sig,optimized_mir,typeck")]
type ChangePrimitiveType = i32;
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")]
+#[rustc_clean(cfg="cfail2", except="hir_owner")]
#[rustc_clean(cfg="cfail3")]
type ChangePrimitiveType = i64;
type ChangeMutability = &'static i32;
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")]
+#[rustc_clean(cfg="cfail2", except="hir_owner")]
#[rustc_clean(cfg="cfail3")]
type ChangeMutability = &'static mut i32;
type ChangeTypeStruct = Struct1;
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")]
+#[rustc_clean(cfg="cfail2", except="hir_owner")]
#[rustc_clean(cfg="cfail3")]
type ChangeTypeStruct = Struct2;
type ChangeTypeTuple = (u32, u64);
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")]
+#[rustc_clean(cfg="cfail2", except="hir_owner")]
#[rustc_clean(cfg="cfail3")]
type ChangeTypeTuple = (u32, i64);
type ChangeTypeEnum = Enum1;
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")]
+#[rustc_clean(cfg="cfail2", except="hir_owner")]
#[rustc_clean(cfg="cfail3")]
type ChangeTypeEnum = Enum2;
type AddTupleField = (i32, i64);
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")]
+#[rustc_clean(cfg="cfail2", except="hir_owner")]
#[rustc_clean(cfg="cfail3")]
type AddTupleField = (i32, i64, i16);
type ChangeNestedTupleField = (i32, (i64, i16));
#[cfg(not(cfail1))]
-#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")]
+#[rustc_clean(cfg="cfail2", except="hir_owner")]
#[rustc_clean(cfg="cfail3")]
type ChangeNestedTupleField = (i32, (i64, i8));
#[cfg(cfail1)]
pub fn baz() {} // order is different...
- // FIXME: Make "hir_owner" use `rustc_clean` here. Currently "hir_owner" includes a reference to
- // the parent node, which is the statement holding this item. Changing the position of
- // `bar` in `foo` will update that reference and make `hir_owner(bar)` dirty.
- #[rustc_dirty(label = "hir_owner", cfg = "cfail2")]
+ #[rustc_clean(label = "hir_owner", cfg = "cfail2")]
#[rustc_clean(label = "hir_owner_nodes", cfg = "cfail2")]
pub fn bar() {} // but that doesn't matter.
asm!("{0}", out(reg) a);
asm!("{0}", inout(reg) b);
asm!("{0} {1}", out(reg) _, inlateout(reg) b => _);
- asm!("", out("al") _, lateout("rbx") _);
+ asm!("", out("al") _, lateout("rcx") _);
asm!("inst1\ninst2");
asm!("inst1 {0}, 42\ninst2 {1}, 24", in(reg) a, out(reg) b);
asm!("inst2 {1}, 24\ninst1 {0}, 42", in(reg) a, out(reg) b);
asm!("{0}", out(reg) a);
asm!("{name}", name = inout(reg) b);
asm!("{} {}", out(reg) _, inlateout(reg) b => _);
- asm!("", out("al") _, lateout("rbx") _);
+ asm!("", out("al") _, lateout("rcx") _);
asm!("inst1", "inst2");
asm!("inst1 {}, 42", "inst2 {}, 24", in(reg) a, out(reg) b);
asm!("inst2 {1}, 24", "inst1 {0}, 42", in(reg) a, out(reg) b);
#[cfg(FALSE)]
fn syntax() {
let _ = #[attr] box 0;
- let _ = #[attr] [#![attr] ];
- let _ = #[attr] [#![attr] 0];
- let _ = #[attr] [#![attr] 0; 0];
- let _ = #[attr] [#![attr] 0, 0, 0];
+ let _ = #[attr] [];
+ let _ = #[attr] [0];
+ let _ = #[attr] [0; 0];
+ let _ = #[attr] [0, 0, 0];
let _ = #[attr] foo();
let _ = #[attr] x.foo();
- let _ = #[attr] (#![attr] );
- let _ = #[attr] (#![attr] #[attr] 0,);
- let _ = #[attr] (#![attr] #[attr] 0, 0);
+ let _ = #[attr] ();
+ let _ = #[attr] (#[attr] 0,);
+ let _ = #[attr] (#[attr] 0, 0);
let _ = #[attr] 0 + #[attr] 0;
let _ = #[attr] 0 / #[attr] 0;
let _ = #[attr] 0 & #[attr] 0;
#![attr]
};
let _ =
- #[attr] match true {
- #![attr]
- #[attr]
- _ => false,
+ #[attr] match true
+ {
+ #[attr]
+ _ => false,
};
let _ = #[attr] || #[attr] foo;
let _ = #[attr] move || #[attr] foo;
let _ = #[attr] foo![# ! [attr]];
let _ = #[attr] foo! { };
let _ = #[attr] foo! { # ! [attr] };
- let _ = #[attr] Foo{#![attr] bar: baz,};
- let _ = #[attr] Foo{#![attr] ..foo};
- let _ = #[attr] Foo{#![attr] bar: baz, ..foo};
- let _ = #[attr] (#![attr] 0);
+ let _ = #[attr] Foo{bar: baz,};
+ let _ = #[attr] Foo{..foo};
+ let _ = #[attr] Foo{bar: baz, ..foo};
+ let _ = #[attr] (0);
{
#[attr]
fn _4() {
#[rustc_dummy]
- match () {
- #![rustc_dummy]
- _ => (),
- }
+ match () { _ => (), }
- let _ =
- #[rustc_dummy] match () {
- #![rustc_dummy]
- () => (),
- };
+ let _ = #[rustc_dummy] match () { () => (), };
}
fn _5() {
fn _6() {
#[rustc_dummy]
- [#![rustc_dummy] 1, 2, 3];
+ [1, 2, 3];
- let _ = #[rustc_dummy] [#![rustc_dummy] 1, 2, 3];
+ let _ = #[rustc_dummy] [1, 2, 3];
#[rustc_dummy]
- [#![rustc_dummy] 1; 4];
+ [1; 4];
- let _ = #[rustc_dummy] [#![rustc_dummy] 1; 4];
+ let _ = #[rustc_dummy] [1; 4];
}
struct Foo {
fn _7() {
#[rustc_dummy]
- Foo{#![rustc_dummy] data: (),};
+ Foo{data: (),};
- let _ = #[rustc_dummy] Foo{#![rustc_dummy] data: (),};
+ let _ = #[rustc_dummy] Foo{data: (),};
}
fn _8() {
#[rustc_dummy]
- (#![rustc_dummy] );
+ ();
#[rustc_dummy]
- (#![rustc_dummy] 0);
+ (0);
#[rustc_dummy]
- (#![rustc_dummy] 0,);
+ (0,);
#[rustc_dummy]
- (#![rustc_dummy] 0, 1);
+ (0, 1);
}
fn _9() {
fn _11() {
let _ = #[rustc_dummy] box 0;
- let _: [(); 0] = #[rustc_dummy] [#![rustc_dummy] ];
- let _ = #[rustc_dummy] [#![rustc_dummy] 0, 0];
- let _ = #[rustc_dummy] [#![rustc_dummy] 0; 0];
+ let _: [(); 0] = #[rustc_dummy] [];
+ let _ = #[rustc_dummy] [0, 0];
+ let _ = #[rustc_dummy] [0; 0];
let _ = #[rustc_dummy] foo();
let _ = #[rustc_dummy] 1i32.clone();
- let _ = #[rustc_dummy] (#![rustc_dummy] );
- let _ = #[rustc_dummy] (#![rustc_dummy] 0);
- let _ = #[rustc_dummy] (#![rustc_dummy] 0,);
- let _ = #[rustc_dummy] (#![rustc_dummy] 0, 0);
+ let _ = #[rustc_dummy] ();
+ let _ = #[rustc_dummy] (0);
+ let _ = #[rustc_dummy] (0,);
+ let _ = #[rustc_dummy] (0, 0);
let _ = #[rustc_dummy] 0 + #[rustc_dummy] 0;
let _ = #[rustc_dummy] !0;
let _ = #[rustc_dummy] -0i32;
#[rustc_dummy] loop {
#![rustc_dummy]
};
- let _ =
- #[rustc_dummy] match false {
- #![rustc_dummy]
- _ => (),
- };
+ let _ = #[rustc_dummy] match false { _ => (), };
let _ = #[rustc_dummy] || #[rustc_dummy] ();
let _ = #[rustc_dummy] move || #[rustc_dummy] ();
let _ =
let _ = #[rustc_dummy] expr_mac!();
let _ = #[rustc_dummy] expr_mac![];
let _ = #[rustc_dummy] expr_mac! { };
- let _ = #[rustc_dummy] Foo{#![rustc_dummy] data: (),};
- let _ = #[rustc_dummy] Foo{#![rustc_dummy] ..s};
- let _ = #[rustc_dummy] Foo{#![rustc_dummy] data: (), ..s};
- let _ = #[rustc_dummy] (#![rustc_dummy] 0);
+ let _ = #[rustc_dummy] Foo{data: (),};
+ let _ = #[rustc_dummy] Foo{..s};
+ let _ = #[rustc_dummy] Foo{data: (), ..s};
+ let _ = #[rustc_dummy] (0);
}
fn _12() {
+++ /dev/null
--include ../tools.mk
-
-all:
- $(RUSTC) fakealloc.rs
- $(RUSTC) --edition=2018 --crate-type=rlib ../../../../library/alloc/src/lib.rs --cfg feature=\"external_crate\" --extern external=$(TMPDIR)/$(shell $(RUSTC) --print file-names fakealloc.rs)
+++ /dev/null
-#![crate_type = "rlib"]
-#![no_std]
-
-#[inline]
-pub unsafe fn allocate(_size: usize, _align: usize) -> *mut u8 {
- core::ptr::null_mut()
-}
-
-#[inline]
-pub unsafe fn deallocate(_ptr: *mut u8, _old_size: usize, _align: usize) { }
-
-#[inline]
-pub unsafe fn reallocate(_ptr: *mut u8, _old_size: usize, _size: usize, _align: usize) -> *mut u8 {
- core::ptr::null_mut()
-}
-
-#[inline]
-pub unsafe fn reallocate_inplace(_ptr: *mut u8, old_size: usize, _size: usize,
- _align: usize) -> usize { old_size }
-
-#[inline]
-pub fn usable_size(size: usize, _align: usize) -> usize { size }
-
-#[inline]
-pub fn stats_print() { }
--- /dev/null
+-include ../tools.mk
+
+all:
+ $(RUSTC) --edition=2018 --crate-type=rlib ../../../../library/alloc/src/lib.rs --cfg feature=\"external_crate\" --cfg no_global_oom_handling
12| 1| if b {
13| 1| println!("non_async_func println in block");
14| 1| }
+ ^0
15| 1|}
16| |
- 17| |// FIXME(#83985): The auto-generated closure in an async function is failing to include
- 18| |// the println!() and `let` assignment lines in the coverage code region(s), as it does in the
- 19| |// non-async function above, unless the `println!()` is inside a covered block.
+ 17| |
+ 18| |
+ 19| |
20| 1|async fn async_func() {
21| 1| println!("async_func was covered");
22| 1| let b = true;
^0
26| 1|}
27| |
- 28| |// FIXME(#83985): As above, this async function only has the `println!()` macro call, which is not
- 29| |// showing coverage, so the entire async closure _appears_ uncovered; but this is not exactly true.
- 30| |// It's only certain kinds of lines and/or their context that results in missing coverage.
+ 28| |
+ 29| |
+ 30| |
31| 1|async fn async_func_just_println() {
32| 1| println!("async_func_just_println was covered");
33| 1|}
37| 0| countdown = 10;
38| 0| }
39| 0| "alt string 2".to_owned()
- 40| 1| };
+ 40| 0| };
41| 1| println!(
42| 1| "The string or alt: {}"
43| 1| ,
125| 0| countdown = 10;
126| 0| }
127| 0| "closure should be unused".to_owned()
- 128| 1| };
- 129| 1|
+ 128| 0| };
+ 129| |
130| 1| let mut countdown = 10;
131| 1| let _short_unused_closure = | _unused_arg: u8 | countdown += 1;
^0
- 132| 1|
- 133| 1| // Macros can sometimes confuse the coverage results. Compare this next assignment, with an
- 134| 1| // unused closure that invokes the `println!()` macro, with the closure assignment above, that
- 135| 1| // does not use a macro. The closure above correctly shows `0` executions.
- 136| 1| let _short_unused_closure = | _unused_arg: u8 | println!("not called");
- 137| 1| // The closure assignment above is executed, with a line count of `1`, but the `println!()`
- 138| 1| // could not have been called, and yet, there is no indication that it wasn't...
- 139| 1|
- 140| 1| // ...but adding block braces gives the expected result, showing the block was not executed.
+ 132| |
+ 133| |
+ 134| 1| let short_used_covered_closure_macro = | used_arg: u8 | println!("called");
+ 135| 1| let short_used_not_covered_closure_macro = | used_arg: u8 | println!("not called");
+ ^0
+ 136| 1| let _short_unused_closure_macro = | _unused_arg: u8 | println!("not called");
+ ^0
+ 137| |
+ 138| |
+ 139| |
+ 140| |
141| 1| let _short_unused_closure_block = | _unused_arg: u8 | { println!("not called") };
^0
- 142| 1|
+ 142| |
143| 1| let _shortish_unused_closure = | _unused_arg: u8 | {
144| 0| println!("not called")
- 145| 1| };
- 146| 1|
+ 145| 0| };
+ 146| |
147| 1| let _as_short_unused_closure = |
148| | _unused_arg: u8
- 149| 1| | { println!("not called") };
- ^0
- 150| 1|
+ 149| 0| | { println!("not called") };
+ 150| |
151| 1| let _almost_as_short_unused_closure = |
152| | _unused_arg: u8
- 153| 1| | { println!("not called") }
- ^0
- 154| 1| ;
- 155| 1|}
+ 153| 0| | { println!("not called") }
+ 154| | ;
+ 155| |
+ 156| |
+ 157| |
+ 158| |
+ 159| |
+ 160| 1| let _short_unused_closure_line_break_no_block = | _unused_arg: u8 |
+ 161| 0|println!("not called")
+ 162| | ;
+ 163| |
+ 164| 1| let _short_unused_closure_line_break_no_block2 =
+ 165| | | _unused_arg: u8 |
+ 166| 0| println!(
+ 167| 0| "not called"
+ 168| 0| )
+ 169| | ;
+ 170| |
+ 171| 1| let short_used_not_covered_closure_line_break_no_block_embedded_branch =
+ 172| 1| | _unused_arg: u8 |
+ 173| 0| println!(
+ 174| 0| "not called: {}",
+ 175| 0| if is_true { "check" } else { "me" }
+ 176| 0| )
+ 177| | ;
+ 178| |
+ 179| 1| let short_used_not_covered_closure_line_break_block_embedded_branch =
+ 180| 1| | _unused_arg: u8 |
+ 181| 0| {
+ 182| 0| println!(
+ 183| 0| "not called: {}",
+ 184| 0| if is_true { "check" } else { "me" }
+ 185| | )
+ 186| 0| }
+ 187| | ;
+ 188| |
+ 189| 1| let short_used_covered_closure_line_break_no_block_embedded_branch =
+ 190| 1| | _unused_arg: u8 |
+ 191| 1| println!(
+ 192| 1| "not called: {}",
+ 193| 1| if is_true { "check" } else { "me" }
+ ^0
+ 194| 1| )
+ 195| | ;
+ 196| |
+ 197| 1| let short_used_covered_closure_line_break_block_embedded_branch =
+ 198| 1| | _unused_arg: u8 |
+ 199| 1| {
+ 200| 1| println!(
+ 201| 1| "not called: {}",
+ 202| 1| if is_true { "check" } else { "me" }
+ ^0
+ 203| | )
+ 204| 1| }
+ 205| | ;
+ 206| |
+ 207| 1| if is_false {
+ 208| 0| short_used_not_covered_closure_macro(0);
+ 209| 0| short_used_not_covered_closure_line_break_no_block_embedded_branch(0);
+ 210| 0| short_used_not_covered_closure_line_break_block_embedded_branch(0);
+ 211| 1| }
+ 212| 1| short_used_covered_closure_macro(0);
+ 213| 1| short_used_covered_closure_line_break_no_block_embedded_branch(0);
+ 214| 1| short_used_covered_closure_line_break_block_embedded_branch(0);
+ 215| 1|}
--- /dev/null
+ 1| |// compile-flags: --edition=2018
+ 2| |#![feature(no_coverage)]
+ 3| |
+ 4| |macro_rules! bail {
+ 5| | ($msg:literal $(,)?) => {
+ 6| | if $msg.len() > 0 {
+ 7| | println!("no msg");
+ 8| | } else {
+ 9| | println!($msg);
+ 10| | }
+ 11| | return Err(String::from($msg));
+ 12| | };
+ 13| |}
+ 14| |
+ 15| |macro_rules! on_error {
+ 16| | ($value:expr, $error_message:expr) => {
+ 17| | $value.or_else(|e| { // FIXME(85000): no coverage in closure macros
+ 18| | let message = format!($error_message, e);
+ 19| | if message.len() > 0 {
+ 20| | println!("{}", message);
+ 21| | Ok(String::from("ok"))
+ 22| | } else {
+ 23| | bail!("error");
+ 24| | }
+ 25| | })
+ 26| | };
+ 27| |}
+ 28| |
+ 29| 1|fn load_configuration_files() -> Result<String, String> {
+ 30| 1| Ok(String::from("config"))
+ 31| 1|}
+ 32| |
+ 33| 1|pub fn main() -> Result<(), String> {
+ 34| 1| println!("Starting service");
+ 35| 1| let config = on_error!(load_configuration_files(), "Error loading configs: {}")?;
+ ^0
+ 36| |
+ 37| 1| let startup_delay_duration = String::from("arg");
+ 38| 1| let _ = (config, startup_delay_duration);
+ 39| 1| Ok(())
+ 40| 1|}
+
--- /dev/null
+ 1| |// compile-flags: --edition=2018
+ 2| |#![feature(no_coverage)]
+ 3| |
+ 4| |macro_rules! bail {
+ 5| | ($msg:literal $(,)?) => {
+ 6| | if $msg.len() > 0 {
+ 7| | println!("no msg");
+ 8| | } else {
+ 9| | println!($msg);
+ 10| | }
+ 11| | return Err(String::from($msg));
+ 12| | };
+ 13| |}
+ 14| |
+ 15| |macro_rules! on_error {
+ 16| | ($value:expr, $error_message:expr) => {
+ 17| | $value.or_else(|e| { // FIXME(85000): no coverage in closure macros
+ 18| | let message = format!($error_message, e);
+ 19| | if message.len() > 0 {
+ 20| | println!("{}", message);
+ 21| | Ok(String::from("ok"))
+ 22| | } else {
+ 23| | bail!("error");
+ 24| | }
+ 25| | })
+ 26| | };
+ 27| |}
+ 28| |
+ 29| 1|fn load_configuration_files() -> Result<String, String> {
+ 30| 1| Ok(String::from("config"))
+ 31| 1|}
+ 32| |
+ 33| 1|pub async fn test() -> Result<(), String> {
+ 34| 1| println!("Starting service");
+ 35| 1| let config = on_error!(load_configuration_files(), "Error loading configs: {}")?;
+ ^0
+ 36| |
+ 37| 1| let startup_delay_duration = String::from("arg");
+ 38| 1| let _ = (config, startup_delay_duration);
+ 39| 1| Ok(())
+ 40| 1|}
+ 41| |
+ 42| |#[no_coverage]
+ 43| |fn main() {
+ 44| | executor::block_on(test());
+ 45| |}
+ 46| |
+ 47| |mod executor {
+ 48| | use core::{
+ 49| | future::Future,
+ 50| | pin::Pin,
+ 51| | task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
+ 52| | };
+ 53| |
+ 54| | #[no_coverage]
+ 55| | pub fn block_on<F: Future>(mut future: F) -> F::Output {
+ 56| | let mut future = unsafe { Pin::new_unchecked(&mut future) };
+ 57| | use std::hint::unreachable_unchecked;
+ 58| | static VTABLE: RawWakerVTable = RawWakerVTable::new(
+ 59| |
+ 60| | #[no_coverage]
+ 61| | |_| unsafe { unreachable_unchecked() }, // clone
+ 62| |
+ 63| | #[no_coverage]
+ 64| | |_| unsafe { unreachable_unchecked() }, // wake
+ 65| |
+ 66| | #[no_coverage]
+ 67| | |_| unsafe { unreachable_unchecked() }, // wake_by_ref
+ 68| |
+ 69| | #[no_coverage]
+ 70| | |_| (),
+ 71| | );
+ 72| | let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) };
+ 73| | let mut context = Context::from_waker(&waker);
+ 74| |
+ 75| | loop {
+ 76| | if let Poll::Ready(val) = future.as_mut().poll(&mut context) {
+ 77| | break val;
+ 78| | }
+ 79| | }
+ 80| | }
+ 81| |}
+
5| 1| if true {
6| 1| countdown = 10;
7| 1| }
+ ^0
8| |
9| | const B: u32 = 100;
10| 1| let x = if countdown > 7 {
24| 1| if true {
25| 1| countdown = 10;
26| 1| }
+ ^0
27| |
28| 1| if countdown > 7 {
29| 1| countdown -= 4;
41| 1| if true {
42| 1| countdown = 10;
43| 1| }
+ ^0
44| |
45| 1| if countdown > 7 {
46| 1| countdown -= 4;
53| | } else {
54| 0| return;
55| | }
- 56| | } // Note: closing brace shows uncovered (vs. `0` for implicit else) because condition literal
- 57| | // `true` was const-evaluated. The compiler knows the `if` block will be executed.
+ 56| 0| }
+ 57| |
58| |
59| 1| let mut countdown = 0;
60| 1| if true {
61| 1| countdown = 1;
62| 1| }
+ ^0
63| |
64| 1| let z = if countdown > 7 {
^0
8| 1|//! assert_eq!(1, 1);
9| |//! } else {
10| |//! // this is not!
- 11| |//! assert_eq!(1, 2);
+ 11| 0|//! assert_eq!(1, 2);
12| |//! }
13| 1|//! ```
14| |//!
74| 1| if true {
75| 1| assert_eq!(1, 1);
76| | } else {
- 77| | assert_eq!(1, 2);
+ 77| 0| assert_eq!(1, 2);
78| | }
79| 1|}
80| |
19| 1| if true {
20| 1| println!("Exiting with error...");
21| 1| return Err(1);
- 22| | }
- 23| |
- 24| | let _ = Firework { strength: 1000 };
- 25| |
- 26| | Ok(())
+ 22| 0| }
+ 23| 0|
+ 24| 0| let _ = Firework { strength: 1000 };
+ 25| 0|
+ 26| 0| Ok(())
27| 1|}
28| |
29| |// Expected program output:
30| 1| if true {
31| 1| println!("Exiting with error...");
32| 1| return Err(1);
- 33| | } // The remaining lines below have no coverage because `if true` (with the constant literal
- 34| | // `true`) is guaranteed to execute the `then` block, which is also guaranteed to `return`.
- 35| | // Thankfully, in the normal case, conditions are not guaranteed ahead of time, and as shown
- 36| | // in other tests, the lines below would have coverage (which would show they had `0`
- 37| | // executions, assuming the condition still evaluated to `true`).
- 38| |
- 39| | let _ = Firework { strength: 1000 };
- 40| |
- 41| | Ok(())
+ 33| 0| }
+ 34| 0|
+ 35| 0|
+ 36| 0|
+ 37| 0|
+ 38| 0|
+ 39| 0| let _ = Firework { strength: 1000 };
+ 40| 0|
+ 41| 0| Ok(())
42| 1|}
43| |
44| |// Expected program output:
1| |#![allow(unused_assignments, unused_variables, dead_code)]
2| |
3| 1|fn main() {
- 4| | // Initialize test constants in a way that cannot be determined at compile time, to ensure
- 5| | // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
- 6| | // dependent conditions.
+ 4| 1| // Initialize test constants in a way that cannot be determined at compile time, to ensure
+ 5| 1| // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+ 6| 1| // dependent conditions.
7| 1| let is_true = std::env::args().len() == 1;
8| 1|
9| 1| let mut countdown = 0;
5| |
6| 1|fn main() {
7| 1| let bar = Foo(1);
- 8| 0| assert_eq!(bar, Foo(1));
+ 8| 1| assert_eq!(bar, Foo(1));
9| 1| let baz = Foo(0);
- 10| 0| assert_ne!(baz, Foo(1));
+ 10| 1| assert_ne!(baz, Foo(1));
11| 1| println!("{:?}", Foo(1));
12| 1| println!("{:?}", bar);
13| 1| println!("{:?}", baz);
--- /dev/null
+ 1| |// This demonstrated Issue #84561: function-like macros produce unintuitive coverage results.
+ 2| |
+ 3| |// expect-exit-status-101
+ 4| 21|#[derive(PartialEq, Eq)]
+ ------------------
+ | <issue_84561::Foo as core::cmp::PartialEq>::eq:
+ | 4| 21|#[derive(PartialEq, Eq)]
+ ------------------
+ | Unexecuted instantiation: <issue_84561::Foo as core::cmp::PartialEq>::ne
+ ------------------
+ 5| |struct Foo(u32);
+ 6| 1|fn test3() {
+ 7| 1| let is_true = std::env::args().len() == 1;
+ 8| 1| let bar = Foo(1);
+ 9| 1| assert_eq!(bar, Foo(1));
+ 10| 1| let baz = Foo(0);
+ 11| 1| assert_ne!(baz, Foo(1));
+ 12| 1| println!("{:?}", Foo(1));
+ 13| 1| println!("{:?}", bar);
+ 14| 1| println!("{:?}", baz);
+ 15| 1|
+ 16| 1| assert_eq!(Foo(1), Foo(1));
+ 17| 1| assert_ne!(Foo(0), Foo(1));
+ 18| 1| assert_eq!(Foo(2), Foo(2));
+ 19| 1| let bar = Foo(0);
+ 20| 1| assert_ne!(bar, Foo(3));
+ 21| 1| assert_ne!(Foo(0), Foo(4));
+ 22| 1| assert_eq!(Foo(3), Foo(3), "with a message");
+ ^0
+ 23| 1| println!("{:?}", bar);
+ 24| 1| println!("{:?}", Foo(1));
+ 25| 1|
+ 26| 1| assert_ne!(Foo(0), Foo(5), "{}", if is_true { "true message" } else { "false message" });
+ ^0 ^0 ^0
+ 27| 1| assert_ne!(
+ 28| | Foo(0)
+ 29| | ,
+ 30| | Foo(5)
+ 31| | ,
+ 32| 0| "{}"
+ 33| 0| ,
+ 34| 0| if
+ 35| 0| is_true
+ 36| | {
+ 37| 0| "true message"
+ 38| | } else {
+ 39| 0| "false message"
+ 40| | }
+ 41| | );
+ 42| |
+ 43| 1| let is_true = std::env::args().len() == 1;
+ 44| 1|
+ 45| 1| assert_eq!(
+ 46| 1| Foo(1),
+ 47| 1| Foo(1)
+ 48| 1| );
+ 49| 1| assert_ne!(
+ 50| 1| Foo(0),
+ 51| 1| Foo(1)
+ 52| 1| );
+ 53| 1| assert_eq!(
+ 54| 1| Foo(2),
+ 55| 1| Foo(2)
+ 56| 1| );
+ 57| 1| let bar = Foo(1);
+ 58| 1| assert_ne!(
+ 59| 1| bar,
+ 60| 1| Foo(3)
+ 61| 1| );
+ 62| 1| if is_true {
+ 63| 1| assert_ne!(
+ 64| 1| Foo(0),
+ 65| 1| Foo(4)
+ 66| 1| );
+ 67| | } else {
+ 68| 0| assert_eq!(
+ 69| 0| Foo(3),
+ 70| 0| Foo(3)
+ 71| 0| );
+ 72| | }
+ 73| 1| if is_true {
+ 74| 1| assert_ne!(
+ 75| | Foo(0),
+ 76| | Foo(4),
+ 77| 0| "with a message"
+ 78| | );
+ 79| | } else {
+ 80| 0| assert_eq!(
+ 81| | Foo(3),
+ 82| | Foo(3),
+ 83| 0| "with a message"
+ 84| | );
+ 85| | }
+ 86| 1| assert_ne!(
+ 87| 1| if is_true {
+ 88| 1| Foo(0)
+ 89| | } else {
+ 90| 0| Foo(1)
+ 91| | },
+ 92| | Foo(5)
+ 93| | );
+ 94| 1| assert_ne!(
+ 95| 1| Foo(5),
+ 96| 1| if is_true {
+ 97| 1| Foo(0)
+ 98| | } else {
+ 99| 0| Foo(1)
+ 100| | }
+ 101| | );
+ 102| 1| assert_ne!(
+ 103| 1| if is_true {
+ 104| 1| assert_eq!(
+ 105| 1| Foo(3),
+ 106| 1| Foo(3)
+ 107| 1| );
+ 108| 1| Foo(0)
+ 109| | } else {
+ 110| 0| assert_ne!(
+ 111| 0| if is_true {
+ 112| 0| Foo(0)
+ 113| | } else {
+ 114| 0| Foo(1)
+ 115| | },
+ 116| | Foo(5)
+ 117| | );
+ 118| 0| Foo(1)
+ 119| | },
+ 120| | Foo(5),
+ 121| 0| "with a message"
+ 122| | );
+ 123| 1| assert_eq!(
+ 124| | Foo(1),
+ 125| | Foo(3),
+ 126| 1| "this assert should fail"
+ 127| | );
+ 128| 0| assert_eq!(
+ 129| | Foo(3),
+ 130| | Foo(3),
+ 131| 0| "this assert should not be reached"
+ 132| | );
+ 133| 0|}
+ 134| |
+ 135| |impl std::fmt::Debug for Foo {
+ 136| | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+ 137| 7| write!(f, "try and succeed")?;
+ ^0
+ 138| 7| Ok(())
+ 139| 7| }
+ 140| |}
+ 141| |
+ 142| |static mut DEBUG_LEVEL_ENABLED: bool = false;
+ 143| |
+ 144| |macro_rules! debug {
+ 145| | ($($arg:tt)+) => (
+ 146| | if unsafe { DEBUG_LEVEL_ENABLED } {
+ 147| | println!($($arg)+);
+ 148| | }
+ 149| | );
+ 150| |}
+ 151| |
+ 152| 1|fn test1() {
+ 153| 1| debug!("debug is enabled");
+ ^0
+ 154| 1| debug!("debug is enabled");
+ ^0
+ 155| 1| let _ = 0;
+ 156| 1| debug!("debug is enabled");
+ ^0
+ 157| 1| unsafe {
+ 158| 1| DEBUG_LEVEL_ENABLED = true;
+ 159| 1| }
+ 160| 1| debug!("debug is enabled");
+ 161| 1|}
+ 162| |
+ 163| |macro_rules! call_debug {
+ 164| | ($($arg:tt)+) => (
+ 165| 1| fn call_print(s: &str) {
+ 166| 1| print!("{}", s);
+ 167| 1| }
+ 168| |
+ 169| | call_print("called from call_debug: ");
+ 170| | debug!($($arg)+);
+ 171| | );
+ 172| |}
+ 173| |
+ 174| 1|fn test2() {
+ 175| 1| call_debug!("debug is enabled");
+ 176| 1|}
+ 177| |
+ 178| 1|fn main() {
+ 179| 1| test1();
+ 180| 1| test2();
+ 181| 1| test3();
+ 182| 1|}
+
9| 1| fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
10| 1| if true {
11| 1| if false {
- 12| | while true {
- 13| | }
+ 12| 0| while true {
+ 13| 0| }
14| 1| }
- 15| 1| write!(f, "error")?;
- ^0
- 16| | } else {
- 17| | }
+ 15| 1| write!(f, "cool")?;
+ ^0
+ 16| 0| } else {
+ 17| 0| }
18| |
19| 10| for i in 0..10 {
20| 10| if true {
21| 10| if false {
- 22| | while true {}
+ 22| 0| while true {}
23| 10| }
- 24| 10| write!(f, "error")?;
- ^0
- 25| | } else {
- 26| | }
+ 24| 10| write!(f, "cool")?;
+ ^0
+ 25| 0| } else {
+ 26| 0| }
27| | }
28| 1| Ok(())
29| 1| }
34| |impl std::fmt::Display for DisplayTest {
35| 1| fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
36| 1| if false {
- 37| | } else {
+ 37| 0| } else {
38| 1| if false {
- 39| | while true {}
+ 39| 0| while true {}
40| 1| }
- 41| 1| write!(f, "error")?;
- ^0
+ 41| 1| write!(f, "cool")?;
+ ^0
42| | }
43| 10| for i in 0..10 {
44| 10| if false {
- 45| | } else {
+ 45| 0| } else {
46| 10| if false {
- 47| | while true {}
+ 47| 0| while true {}
48| 10| }
- 49| 10| write!(f, "error")?;
- ^0
+ 49| 10| write!(f, "cool")?;
+ ^0
50| | }
51| | }
52| 1| Ok(())
11| | println!("called but not covered");
12| |}
13| |
- 14| 1|fn main() {
- 15| 1| do_not_add_coverage_1();
- 16| 1| do_not_add_coverage_2();
- 17| 1|}
+ 14| |#[no_coverage]
+ 15| |fn do_not_add_coverage_not_called() {
+ 16| | println!("not called and not covered");
+ 17| |}
+ 18| |
+ 19| 1|fn add_coverage_1() {
+ 20| 1| println!("called and covered");
+ 21| 1|}
+ 22| |
+ 23| 1|fn add_coverage_2() {
+ 24| 1| println!("called and covered");
+ 25| 1|}
+ 26| |
+ 27| 0|fn add_coverage_not_called() {
+ 28| 0| println!("not called but covered");
+ 29| 0|}
+ 30| |
+ 31| 1|fn main() {
+ 32| 1| do_not_add_coverage_1();
+ 33| 1| do_not_add_coverage_2();
+ 34| 1| add_coverage_1();
+ 35| 1| add_coverage_2();
+ 36| 1|}
+++ /dev/null
- 1| |// Enables `no_coverage` on individual functions
- 2| |
- 3| |#[feature(no_coverage)]
- 4| |#[no_coverage]
- 5| |fn do_not_add_coverage_1() {
- 6| | println!("called but not covered");
- 7| |}
- 8| |
- 9| |#[no_coverage]
- 10| |#[feature(no_coverage)]
- 11| |fn do_not_add_coverage_2() {
- 12| | println!("called but not covered");
- 13| |}
- 14| |
- 15| 1|fn main() {
- 16| 1| do_not_add_coverage_1();
- 17| 1| do_not_add_coverage_2();
- 18| 1|}
-
29| |// 2. Since the `panic_unwind.rs` test is allowed to unwind, it is also allowed to execute the
30| |// normal program exit cleanup, including writing out the current values of the coverage
31| |// counters.
- 32| |// 3. The coverage results show (interestingly) that the `panic!()` call did execute, but it does
- 33| |// not show coverage of the `if countdown == 1` branch in `main()` that calls
- 34| |// `might_panic(true)` (causing the call to `panic!()`).
- 35| |// 4. The reason `main()`s `if countdown == 1` branch, calling `might_panic(true)`, appears
- 36| |// "uncovered" is, InstrumentCoverage (intentionally) treats `TerminatorKind::Call` terminators
- 37| |// as non-branching, because when a program executes normally, they always are. Errors handled
- 38| |// via the try `?` operator produce error handling branches that *are* treated as branches in
- 39| |// coverage results. By treating calls without try `?` operators as non-branching (assumed to
- 40| |// return normally and continue) the coverage graph can be simplified, producing smaller,
- 41| |// faster binaries, and cleaner coverage results.
- 42| |// 5. The reason the coverage results actually show `panic!()` was called is most likely because
- 43| |// `panic!()` is a macro, not a simple function call, and there are other `Statement`s and/or
- 44| |// `Terminator`s that execute with a coverage counter before the panic and unwind occur.
- 45| |// 6. Since the common practice is not to use `panic!()` for error handling, the coverage
- 46| |// implementation avoids incurring an additional cost (in program size and execution time) to
- 47| |// improve coverage results for an event that is generally not "supposed" to happen.
- 48| |// 7. FIXME(#78544): This issue describes a feature request for a proposed option to enable
- 49| |// more accurate coverage results for tests that intentionally panic.
1| 1|fn main() {
2| 1| if false {
- 3| | loop {}
+ 3| 0| loop {}
4| 1| }
5| 1|}
3| |use std::fmt::Debug;
4| |
5| 1|pub fn used_function() {
- 6| | // Initialize test constants in a way that cannot be determined at compile time, to ensure
- 7| | // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
- 8| | // dependent conditions.
+ 6| 1| // Initialize test constants in a way that cannot be determined at compile time, to ensure
+ 7| 1| // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+ 8| 1| // dependent conditions.
9| 1| let is_true = std::env::args().len() == 1;
10| 1| let mut countdown = 0;
11| 1| if is_true {
22| 2| println!("used_only_from_this_lib_crate_generic_function with {:?}", arg);
23| 2|}
------------------
- | used_crate::used_only_from_this_lib_crate_generic_function::<&str>:
+ | used_crate::used_only_from_this_lib_crate_generic_function::<alloc::vec::Vec<i32>>:
| 21| 1|pub fn used_only_from_this_lib_crate_generic_function<T: Debug>(arg: T) {
| 22| 1| println!("used_only_from_this_lib_crate_generic_function with {:?}", arg);
| 23| 1|}
------------------
- | used_crate::used_only_from_this_lib_crate_generic_function::<alloc::vec::Vec<i32>>:
+ | used_crate::used_only_from_this_lib_crate_generic_function::<&str>:
| 21| 1|pub fn used_only_from_this_lib_crate_generic_function<T: Debug>(arg: T) {
| 22| 1| println!("used_only_from_this_lib_crate_generic_function with {:?}", arg);
| 23| 1|}
5| |use std::fmt::Debug;
6| |
7| 1|pub fn used_function() {
- 8| | // Initialize test constants in a way that cannot be determined at compile time, to ensure
- 9| | // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
- 10| | // dependent conditions.
+ 8| 1| // Initialize test constants in a way that cannot be determined at compile time, to ensure
+ 9| 1| // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+ 10| 1| // dependent conditions.
11| 1| let is_true = std::env::args().len() == 1;
12| 1| let mut countdown = 0;
13| 1| if is_true {
18| |
19| |#[inline(always)]
20| 1|pub fn used_inline_function() {
- 21| | // Initialize test constants in a way that cannot be determined at compile time, to ensure
- 22| | // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
- 23| | // dependent conditions.
+ 21| 1| // Initialize test constants in a way that cannot be determined at compile time, to ensure
+ 22| 1| // rustc and LLVM cannot optimize out statements (or coverage counters) downstream from
+ 23| 1| // dependent conditions.
24| 1| let is_true = std::env::args().len() == 1;
25| 1| let mut countdown = 0;
26| 1| if is_true {
}
}
-// FIXME(#83985): The auto-generated closure in an async function is failing to include
-// the println!() and `let` assignment lines in the coverage code region(s), as it does in the
-// non-async function above, unless the `println!()` is inside a covered block.
+
+
+
async fn async_func() {
println!("async_func was covered");
let b = true;
}
}
-// FIXME(#83985): As above, this async function only has the `println!()` macro call, which is not
-// showing coverage, so the entire async closure _appears_ uncovered; but this is not exactly true.
-// It's only certain kinds of lines and/or their context that results in missing coverage.
+
+
+
async fn async_func_just_println() {
println!("async_func_just_println was covered");
}
let mut countdown = 10;
let _short_unused_closure = | _unused_arg: u8 | countdown += 1;
- // Macros can sometimes confuse the coverage results. Compare this next assignment, with an
- // unused closure that invokes the `println!()` macro, with the closure assignment above, that
- // does not use a macro. The closure above correctly shows `0` executions.
- let _short_unused_closure = | _unused_arg: u8 | println!("not called");
- // The closure assignment above is executed, with a line count of `1`, but the `println!()`
- // could not have been called, and yet, there is no indication that it wasn't...
-
- // ...but adding block braces gives the expected result, showing the block was not executed.
+
+ let short_used_covered_closure_macro = | used_arg: u8 | println!("called");
+ let short_used_not_covered_closure_macro = | used_arg: u8 | println!("not called");
+ let _short_unused_closure_macro = | _unused_arg: u8 | println!("not called");
+
+
+
+
let _short_unused_closure_block = | _unused_arg: u8 | { println!("not called") };
let _shortish_unused_closure = | _unused_arg: u8 | {
_unused_arg: u8
| { println!("not called") }
;
+
+
+
+
+
+ let _short_unused_closure_line_break_no_block = | _unused_arg: u8 |
+println!("not called")
+ ;
+
+ let _short_unused_closure_line_break_no_block2 =
+ | _unused_arg: u8 |
+ println!(
+ "not called"
+ )
+ ;
+
+ let short_used_not_covered_closure_line_break_no_block_embedded_branch =
+ | _unused_arg: u8 |
+ println!(
+ "not called: {}",
+ if is_true { "check" } else { "me" }
+ )
+ ;
+
+ let short_used_not_covered_closure_line_break_block_embedded_branch =
+ | _unused_arg: u8 |
+ {
+ println!(
+ "not called: {}",
+ if is_true { "check" } else { "me" }
+ )
+ }
+ ;
+
+ let short_used_covered_closure_line_break_no_block_embedded_branch =
+ | _unused_arg: u8 |
+ println!(
+ "not called: {}",
+ if is_true { "check" } else { "me" }
+ )
+ ;
+
+ let short_used_covered_closure_line_break_block_embedded_branch =
+ | _unused_arg: u8 |
+ {
+ println!(
+ "not called: {}",
+ if is_true { "check" } else { "me" }
+ )
+ }
+ ;
+
+ if is_false {
+ short_used_not_covered_closure_macro(0);
+ short_used_not_covered_closure_line_break_no_block_embedded_branch(0);
+ short_used_not_covered_closure_line_break_block_embedded_branch(0);
+ }
+ short_used_covered_closure_macro(0);
+ short_used_covered_closure_line_break_no_block_embedded_branch(0);
+ short_used_covered_closure_line_break_block_embedded_branch(0);
}
--- /dev/null
+// compile-flags: --edition=2018
+#![feature(no_coverage)]
+
+macro_rules! bail {
+ ($msg:literal $(,)?) => {
+ if $msg.len() > 0 {
+ println!("no msg");
+ } else {
+ println!($msg);
+ }
+ return Err(String::from($msg));
+ };
+}
+
+macro_rules! on_error {
+ ($value:expr, $error_message:expr) => {
+ $value.or_else(|e| { // FIXME(85000): no coverage in closure macros
+ let message = format!($error_message, e);
+ if message.len() > 0 {
+ println!("{}", message);
+ Ok(String::from("ok"))
+ } else {
+ bail!("error");
+ }
+ })
+ };
+}
+
+fn load_configuration_files() -> Result<String, String> {
+ Ok(String::from("config"))
+}
+
+pub fn main() -> Result<(), String> {
+ println!("Starting service");
+ let config = on_error!(load_configuration_files(), "Error loading configs: {}")?;
+
+ let startup_delay_duration = String::from("arg");
+ let _ = (config, startup_delay_duration);
+ Ok(())
+}
--- /dev/null
+// compile-flags: --edition=2018
+#![feature(no_coverage)]
+
+macro_rules! bail {
+ ($msg:literal $(,)?) => {
+ if $msg.len() > 0 {
+ println!("no msg");
+ } else {
+ println!($msg);
+ }
+ return Err(String::from($msg));
+ };
+}
+
+macro_rules! on_error {
+ ($value:expr, $error_message:expr) => {
+ $value.or_else(|e| { // FIXME(85000): no coverage in closure macros
+ let message = format!($error_message, e);
+ if message.len() > 0 {
+ println!("{}", message);
+ Ok(String::from("ok"))
+ } else {
+ bail!("error");
+ }
+ })
+ };
+}
+
+fn load_configuration_files() -> Result<String, String> {
+ Ok(String::from("config"))
+}
+
+pub async fn test() -> Result<(), String> {
+ println!("Starting service");
+ let config = on_error!(load_configuration_files(), "Error loading configs: {}")?;
+
+ let startup_delay_duration = String::from("arg");
+ let _ = (config, startup_delay_duration);
+ Ok(())
+}
+
+#[no_coverage]
+fn main() {
+ executor::block_on(test());
+}
+
+mod executor {
+ use core::{
+ future::Future,
+ pin::Pin,
+ task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
+ };
+
+ #[no_coverage]
+ pub fn block_on<F: Future>(mut future: F) -> F::Output {
+ let mut future = unsafe { Pin::new_unchecked(&mut future) };
+ use std::hint::unreachable_unchecked;
+ static VTABLE: RawWakerVTable = RawWakerVTable::new(
+
+ #[no_coverage]
+ |_| unsafe { unreachable_unchecked() }, // clone
+
+ #[no_coverage]
+ |_| unsafe { unreachable_unchecked() }, // wake
+
+ #[no_coverage]
+ |_| unsafe { unreachable_unchecked() }, // wake_by_ref
+
+ #[no_coverage]
+ |_| (),
+ );
+ let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) };
+ let mut context = Context::from_waker(&waker);
+
+ loop {
+ if let Poll::Ready(val) = future.as_mut().poll(&mut context) {
+ break val;
+ }
+ }
+ }
+}
} else {
return;
}
- } // Note: closing brace shows uncovered (vs. `0` for implicit else) because condition literal
- // `true` was const-evaluated. The compiler knows the `if` block will be executed.
+ }
+
let mut countdown = 0;
if true {
if true {
println!("Exiting with error...");
return Err(1);
- } // The remaining lines below have no coverage because `if true` (with the constant literal
- // `true`) is guaranteed to execute the `then` block, which is also guaranteed to `return`.
- // Thankfully, in the normal case, conditions are not guaranteed ahead of time, and as shown
- // in other tests, the lines below would have coverage (which would show they had `0`
- // executions, assuming the condition still evaluated to `true`).
+ }
+
+
+
+
let _ = Firework { strength: 1000 };
--- /dev/null
+// This demonstrated Issue #84561: function-like macros produce unintuitive coverage results.
+
+// expect-exit-status-101
+#[derive(PartialEq, Eq)]
+struct Foo(u32);
+fn test3() {
+ let is_true = std::env::args().len() == 1;
+ let bar = Foo(1);
+ assert_eq!(bar, Foo(1));
+ let baz = Foo(0);
+ assert_ne!(baz, Foo(1));
+ println!("{:?}", Foo(1));
+ println!("{:?}", bar);
+ println!("{:?}", baz);
+
+ assert_eq!(Foo(1), Foo(1));
+ assert_ne!(Foo(0), Foo(1));
+ assert_eq!(Foo(2), Foo(2));
+ let bar = Foo(0);
+ assert_ne!(bar, Foo(3));
+ assert_ne!(Foo(0), Foo(4));
+ assert_eq!(Foo(3), Foo(3), "with a message");
+ println!("{:?}", bar);
+ println!("{:?}", Foo(1));
+
+ assert_ne!(Foo(0), Foo(5), "{}", if is_true { "true message" } else { "false message" });
+ assert_ne!(
+ Foo(0)
+ ,
+ Foo(5)
+ ,
+ "{}"
+ ,
+ if
+ is_true
+ {
+ "true message"
+ } else {
+ "false message"
+ }
+ );
+
+ let is_true = std::env::args().len() == 1;
+
+ assert_eq!(
+ Foo(1),
+ Foo(1)
+ );
+ assert_ne!(
+ Foo(0),
+ Foo(1)
+ );
+ assert_eq!(
+ Foo(2),
+ Foo(2)
+ );
+ let bar = Foo(1);
+ assert_ne!(
+ bar,
+ Foo(3)
+ );
+ if is_true {
+ assert_ne!(
+ Foo(0),
+ Foo(4)
+ );
+ } else {
+ assert_eq!(
+ Foo(3),
+ Foo(3)
+ );
+ }
+ if is_true {
+ assert_ne!(
+ Foo(0),
+ Foo(4),
+ "with a message"
+ );
+ } else {
+ assert_eq!(
+ Foo(3),
+ Foo(3),
+ "with a message"
+ );
+ }
+ assert_ne!(
+ if is_true {
+ Foo(0)
+ } else {
+ Foo(1)
+ },
+ Foo(5)
+ );
+ assert_ne!(
+ Foo(5),
+ if is_true {
+ Foo(0)
+ } else {
+ Foo(1)
+ }
+ );
+ assert_ne!(
+ if is_true {
+ assert_eq!(
+ Foo(3),
+ Foo(3)
+ );
+ Foo(0)
+ } else {
+ assert_ne!(
+ if is_true {
+ Foo(0)
+ } else {
+ Foo(1)
+ },
+ Foo(5)
+ );
+ Foo(1)
+ },
+ Foo(5),
+ "with a message"
+ );
+ assert_eq!(
+ Foo(1),
+ Foo(3),
+ "this assert should fail"
+ );
+ assert_eq!(
+ Foo(3),
+ Foo(3),
+ "this assert should not be reached"
+ );
+}
+
+impl std::fmt::Debug for Foo {
+ fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+ write!(f, "try and succeed")?;
+ Ok(())
+ }
+}
+
+static mut DEBUG_LEVEL_ENABLED: bool = false;
+
+macro_rules! debug {
+ ($($arg:tt)+) => (
+ if unsafe { DEBUG_LEVEL_ENABLED } {
+ println!($($arg)+);
+ }
+ );
+}
+
+fn test1() {
+ debug!("debug is enabled");
+ debug!("debug is enabled");
+ let _ = 0;
+ debug!("debug is enabled");
+ unsafe {
+ DEBUG_LEVEL_ENABLED = true;
+ }
+ debug!("debug is enabled");
+}
+
+macro_rules! call_debug {
+ ($($arg:tt)+) => (
+ fn call_print(s: &str) {
+ print!("{}", s);
+ }
+
+ call_print("called from call_debug: ");
+ debug!($($arg)+);
+ );
+}
+
+fn test2() {
+ call_debug!("debug is enabled");
+}
+
+fn main() {
+ test1();
+ test2();
+ test3();
+}
while true {
}
}
- write!(f, "error")?;
+ write!(f, "cool")?;
} else {
}
if false {
while true {}
}
- write!(f, "error")?;
+ write!(f, "cool")?;
} else {
}
}
if false {
while true {}
}
- write!(f, "error")?;
+ write!(f, "cool")?;
}
for i in 0..10 {
if false {
if false {
while true {}
}
- write!(f, "error")?;
+ write!(f, "cool")?;
}
}
Ok(())
println!("called but not covered");
}
+#[no_coverage]
+fn do_not_add_coverage_not_called() {
+ println!("not called and not covered");
+}
+
+fn add_coverage_1() {
+ println!("called and covered");
+}
+
+fn add_coverage_2() {
+ println!("called and covered");
+}
+
+fn add_coverage_not_called() {
+ println!("not called but covered");
+}
+
fn main() {
do_not_add_coverage_1();
do_not_add_coverage_2();
+ add_coverage_1();
+ add_coverage_2();
}
+++ /dev/null
-// Enables `no_coverage` on individual functions
-
-#[feature(no_coverage)]
-#[no_coverage]
-fn do_not_add_coverage_1() {
- println!("called but not covered");
-}
-
-#[no_coverage]
-#[feature(no_coverage)]
-fn do_not_add_coverage_2() {
- println!("called but not covered");
-}
-
-fn main() {
- do_not_add_coverage_1();
- do_not_add_coverage_2();
-}
// 2. Since the `panic_unwind.rs` test is allowed to unwind, it is also allowed to execute the
// normal program exit cleanup, including writing out the current values of the coverage
// counters.
-// 3. The coverage results show (interestingly) that the `panic!()` call did execute, but it does
-// not show coverage of the `if countdown == 1` branch in `main()` that calls
-// `might_panic(true)` (causing the call to `panic!()`).
-// 4. The reason `main()`s `if countdown == 1` branch, calling `might_panic(true)`, appears
-// "uncovered" is, InstrumentCoverage (intentionally) treats `TerminatorKind::Call` terminators
-// as non-branching, because when a program executes normally, they always are. Errors handled
-// via the try `?` operator produce error handling branches that *are* treated as branches in
-// coverage results. By treating calls without try `?` operators as non-branching (assumed to
-// return normally and continue) the coverage graph can be simplified, producing smaller,
-// faster binaries, and cleaner coverage results.
-// 5. The reason the coverage results actually show `panic!()` was called is most likely because
-// `panic!()` is a macro, not a simple function call, and there are other `Statement`s and/or
-// `Terminator`s that execute with a coverage counter before the panic and unwind occur.
-// 6. Since the common practice is not to use `panic!()` for error handling, the coverage
-// implementation avoids incurring an additional cost (in program size and execution time) to
-// improve coverage results for an event that is generally not "supposed" to happen.
-// 7. FIXME(#78544): This issue describes a feature request for a proposed option to enable
-// more accurate coverage results for tests that intentionally panic.
-include ../tools.mk
# rust-lang/rust#70924: Test that if we add rust-src component in between two
-# incremetnal compiles, the compiler does not ICE on the second.
+# incremental compiles, the compiler does not ICE on the second.
# This test uses `ln -s` rather than copying to save testing time, but its
# usage doesn't work on windows. So ignore windows.
LL | #![deny(warnings)]
| ^^^^^^^^
= note: `#[deny(rustdoc::broken_intra_doc_links)]` implied by `#[deny(warnings)]`
- = note: see https://doc.rust-lang.org/nightly/rustdoc/linking-to-items-by-name.html#namespaces-and-disambiguators for more info about disambiguators
error: aborting due to previous error
LL | #![deny(warnings)]
| ^^^^^^^^
= note: `#[deny(rustdoc::broken_intra_doc_links)]` implied by `#[deny(warnings)]`
- = note: see https://doc.rust-lang.org/nightly/rustdoc/linking-to-items-by-name.html#namespaces-and-disambiguators for more info about disambiguators
error: unknown disambiguator `bar`
--> $DIR/unknown-disambiguator.rs:3:35
|
LL | //! Linking to [foo@banana] and [`bar@banana!()`].
| ^^^
- |
- = note: see https://doc.rust-lang.org/nightly/rustdoc/linking-to-items-by-name.html#namespaces-and-disambiguators for more info about disambiguators
error: unknown disambiguator `foo`
--> $DIR/unknown-disambiguator.rs:9:34
|
LL | //! And with weird backticks: [``foo@hello``] [foo`@`hello].
| ^^^
- |
- = note: see https://doc.rust-lang.org/nightly/rustdoc/linking-to-items-by-name.html#namespaces-and-disambiguators for more info about disambiguators
error: unknown disambiguator `foo`
--> $DIR/unknown-disambiguator.rs:9:48
|
LL | //! And with weird backticks: [``foo@hello``] [foo`@`hello].
| ^^^
- |
- = note: see https://doc.rust-lang.org/nightly/rustdoc/linking-to-items-by-name.html#namespaces-and-disambiguators for more info about disambiguators
error: unknown disambiguator ``
--> $DIR/unknown-disambiguator.rs:6:31
|
LL | //! And to [no disambiguator](@nectarine) and [another](@apricot!()).
| ^
- |
- = note: see https://doc.rust-lang.org/nightly/rustdoc/linking-to-items-by-name.html#namespaces-and-disambiguators for more info about disambiguators
error: unknown disambiguator ``
--> $DIR/unknown-disambiguator.rs:6:57
|
LL | //! And to [no disambiguator](@nectarine) and [another](@apricot!()).
| ^
- |
- = note: see https://doc.rust-lang.org/nightly/rustdoc/linking-to-items-by-name.html#namespaces-and-disambiguators for more info about disambiguators
error: aborting due to 6 previous errors
--- /dev/null
+// test the behavior of the --no-run flag without the --test flag
+
+// compile-flags:-Z unstable-options --no-run --test-args=--test-threads=1
+// error-pattern: the `--test` flag must be passed
+
+pub fn f() {}
--- /dev/null
+error: the `--test` flag must be passed to enable `--no-run`
+
--- /dev/null
+// test the behavior of the --no-run flag
+
+// check-pass
+// compile-flags:-Z unstable-options --test --no-run --test-args=--test-threads=1
+// normalize-stdout-test: "src/test/rustdoc-ui" -> "$$DIR"
+// normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
+
+/// ```
+/// let a = true;
+/// ```
+/// ```should_panic
+/// panic!()
+/// ```
+/// ```ignore (incomplete-code)
+/// fn foo() {
+/// ```
+/// ```no_run
+/// loop {
+/// println!("Hello, world");
+/// }
+/// ```
+/// fails to compile
+/// ```compile_fail
+/// let x = 5;
+/// x += 2; // shouldn't compile!
+/// ```
+/// Ok the test does not run
+/// ```
+/// panic!()
+/// ```
+/// Ok the test does not run
+/// ```should_panic
+/// loop {
+/// println!("Hello, world");
+/// panic!()
+/// }
+/// ```
+pub fn f() {}
--- /dev/null
+
+running 7 tests
+test $DIR/no-run-flag.rs - f (line 11) ... ok
+test $DIR/no-run-flag.rs - f (line 14) ... ignored
+test $DIR/no-run-flag.rs - f (line 17) ... ok
+test $DIR/no-run-flag.rs - f (line 23) ... ok
+test $DIR/no-run-flag.rs - f (line 28) ... ok
+test $DIR/no-run-flag.rs - f (line 32) ... ok
+test $DIR/no-run-flag.rs - f (line 8) ... ok
+
+test result: ok. 6 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out; finished in $TIME
+
/// Docs for QUX1 in impl.
const QUX1: i8 = 5;
// @has - '//*[@id="associatedconstant.QUX_DEFAULT0"]' 'const QUX_DEFAULT0: u16'
- // @has - '//*[@class="docblock hidden"]' "Docs for QUX_DEFAULT12 in trait."
+ // @!has - '//div[@class="impl-items"]/details[@open=""]//*[@class="docblock"]' "Docs for QUX_DEFAULT12 in trait."
+ // @has - '//div[@class="impl-items"]/details//*[@class="docblock"]' "Docs for QUX_DEFAULT12 in trait."
const QUX_DEFAULT0: u16 = 6;
// @has - '//*[@id="associatedconstant.QUX_DEFAULT1"]' 'const QUX_DEFAULT1: i16'
// @has - '//*[@class="docblock"]' "Docs for QUX_DEFAULT1 in impl."
/// Docs for QUX_DEFAULT1 in impl.
const QUX_DEFAULT1: i16 = 7;
// @has - '//*[@id="associatedconstant.QUX_DEFAULT2"]' 'const QUX_DEFAULT2: u32'
- // @has - '//*[@class="docblock hidden"]' "Docs for QUX_DEFAULT2 in trait."
+ // @!has - '//div[@class="impl-items"]/details[@open=""]//*[@class="docblock"]' "Docs for QUX_DEFAULT2 in trait."
+ // @has - '//div[@class="impl-items"]/details//*[@class="docblock"]' "Docs for QUX_DEFAULT2 in trait."
}
--- /dev/null
+#![feature(trait_alias)]
+
+pub trait SomeAlias = std::fmt::Debug + std::marker::Copy;
--- /dev/null
+pub trait Bar {
+ fn foo();
+}
// @has - '//*[@id="associatedconstant.ConstNoDefault"]' 'const ConstNoDefault: i16'
// @has - '//*[@class="docblock"]' 'dox for ConstNoDefault'
// @has - '//*[@id="associatedconstant.ConstWithDefault"]' 'const ConstWithDefault: u16'
-// @has - '//*[@class="docblock hidden"]' 'docs for ConstWithDefault'
+// @!has - '//details[@open=""]/details/div[@class="docblock"]' 'docs for ConstWithDefault'
+// @has - '//details/details/div[@class="docblock"]' 'docs for ConstWithDefault'
// @has - '//*[@id="associatedtype.TypeNoDefault"]' 'type TypeNoDefault = i32'
// @has - '//*[@class="docblock"]' 'dox for TypeNoDefault'
// @has - '//*[@id="associatedtype.TypeWithDefault"]' 'type TypeWithDefault = u32'
-// @has - '//*[@class="docblock hidden"]' 'docs for TypeWithDefault'
+// @!has - '//details[@open=""]/details/div[@class="docblock"]' 'docs for TypeWithDefault'
+// @has - '//details/details/div[@class="docblock"]' 'docs for TypeWithDefault'
// @has - '//*[@id="method.method_no_default"]' 'fn method_no_default()'
// @has - '//*[@class="docblock"]' 'dox for method_no_default'
// @has - '//*[@id="method.method_with_default"]' 'fn method_with_default()'
-// @has - '//*[@class="docblock hidden"]' 'docs for method_with_default'
+// @!has - '//details[@open=""]/details/div[@class="docblock"]' 'docs for method_with_default'
+// @has - '//details/details/div[@class="docblock"]' 'docs for method_with_default'
pub use assoc_items::MyStruct;
// @has foo/trait.MyTrait.html
// @has 'foo/struct.MyStruct.html'
// @has - '//*[@id="method.my_trait_method"]' 'fn my_trait_method()'
-// @has - '//*[@class="docblock hidden"]' 'docs for my_trait_method'
+// @!has - '//details[@open=""]/details/div[@class="docblock"]' 'docs for my_trait_method'
+// @has - '//details/details/div[@class="docblock"]' 'docs for my_trait_method'
pub use impl_inline_without_trait::MyStruct;
// @has - '//*[@class="docblock"]' 'Docs associated with the S1 trait implementation.'
// @has - '//*[@class="docblock"]' 'Docs associated with the S1 trait a_method implementation.'
// @!has - '//*[@class="docblock"]' 'Docs associated with the trait a_method definition.'
-// @has - '//*[@class="docblock hidden"]' 'Docs associated with the trait b_method definition.'
-// @has - '//*[@class="docblock hidden"]' 'Docs associated with the trait c_method definition.'
+// @!has - '//div[@class="impl-items"]/details[@open=""]//div[@class="docblock"]' 'Docs associated with the trait b_method definition.'
+// @has - '//div[@class="impl-items"]/details//div[@class="docblock"]' 'Docs associated with the trait b_method definition.'
+// @!has - '//div[@class="impl-items"]/details[@open=""]//div[@class="docblock"]' 'Docs associated with the trait c_method definition.'
+// @has - '//div[@class="impl-items"]/details//div[@class="docblock"]' 'Docs associated with the trait c_method definition.'
// @!has - '//*[@class="docblock"]' 'There is another line'
-// @has - '//*[@class="docblock hidden"]' 'Read more'
+// @!has - '//div[@class="impl-items"]/details[@open=""]//div[@class="docblock"]' 'Read more'
+// @has - '//div[@class="impl-items"]/details//div[@class="docblock"]' 'Read more'
pub struct S1(usize);
/// Docs associated with the S1 trait implementation.
// @has - '//*[@class="docblock"]' 'Docs associated with the S2 trait implementation.'
// @has - '//*[@class="docblock"]' 'Docs associated with the S2 trait a_method implementation.'
// @has - '//*[@class="docblock"]' 'Docs associated with the S2 trait c_method implementation.'
-// @!has - '//*[@class="docblock"]' 'Docs associated with the trait a_method definition.'
-// @!has - '//*[@class="docblock"]' 'Docs associated with the trait c_method definition.'
-// @has - '//*[@class="docblock hidden"]' 'Docs associated with the trait b_method definition.'
+// @!has - '//details[open=""]/div[@class="docblock"]' 'Docs associated with the trait a_method definition.'
+// @!has - '//details[open=""]/div[@class="docblock"]' 'Docs associated with the trait c_method definition.'
+// @!has - '//div[@class="impl-items"]/details[@open=""]//div[@class="docblock"]' 'Docs associated with the trait b_method definition.'
+// @has - '//div[@class="impl-items"]/details//div[@class="docblock"]' 'Docs associated with the trait b_method definition.'
pub struct S2(usize);
/// Docs associated with the S2 trait implementation.
}
// @has manual_impl/struct.S3.html '//*[@class="trait"]' 'T'
-// @has - '//*[@class="docblock"]' 'Docs associated with the S3 trait implementation.'
-// @has - '//*[@class="docblock"]' 'Docs associated with the S3 trait b_method implementation.'
-// @has - '//*[@class="docblock hidden"]' 'Docs associated with the trait a_method definition.'
+// @has - '//details[@open=""]/div[@class="docblock"]' 'Docs associated with the S3 trait implementation.'
+// @has - '//details[@open=""]/div[@class="docblock"]' 'Docs associated with the S3 trait b_method implementation.'
+// @!has - '//div[@class="impl-items"]/details[@open=""]//div[@class="docblock"]' 'Docs associated with the trait a_method definition.'
+// @has - '//div[@class="impl-items"]/details//div[@class="docblock"]' 'Docs associated with the trait a_method definition.'
pub struct S3(usize);
/// Docs associated with the S3 trait implementation.
--- /dev/null
+// aux-build:trait-alias-mention.rs
+// build-aux-docs
+
+#![crate_name = "foo"]
+
+extern crate trait_alias_mention;
+
+// @has foo/fn.mention_alias_in_bounds.html '//a[@href="../trait_alias_mention/traitalias.SomeAlias.html"]' 'SomeAlias'
+pub fn mention_alias_in_bounds<T: trait_alias_mention::SomeAlias>() {
+}
pub struct Struct;
impl Trait for Struct {
- // @has trait_impl/struct.Struct.html '//*[@id="method.a"]/../div/p' 'Some long docs'
- // @!has - '//*[@id="method.a"]/../div/p' 'link will be added'
- // @has - '//*[@id="method.a"]/../div/p/a' 'Read more'
- // @has - '//*[@id="method.a"]/../div/p/a/@href' 'trait.Trait.html'
+ // @has trait_impl/struct.Struct.html '//*[@id="method.a"]/../../div[@class="docblock"]/p' 'Some long docs'
+ // @!has - '//*[@id="method.a"]/../../div[@class="docblock"]/p' 'link will be added'
+ // @has - '//*[@id="method.a"]/../../div[@class="docblock"]/p/a' 'Read more'
+ // @has - '//*[@id="method.a"]/../../div[@class="docblock"]/p/a/@href' 'trait.Trait.html#tymethod.a'
fn a() {}
- // @has trait_impl/struct.Struct.html '//*[@id="method.b"]/../div/p' 'These docs contain'
- // @has - '//*[@id="method.b"]/../div/p/a' 'reference link'
- // @has - '//*[@id="method.b"]/../div/p/a/@href' 'https://example.com'
- // @has - '//*[@id="method.b"]/../div/p/a' 'Read more'
- // @has - '//*[@id="method.b"]/../div/p/a/@href' 'trait.Trait.html'
+ // @has - '//*[@id="method.b"]/../../div[@class="docblock"]/p' 'These docs contain'
+ // @has - '//*[@id="method.b"]/../../div[@class="docblock"]/p/a' 'reference link'
+ // @has - '//*[@id="method.b"]/../../div[@class="docblock"]/p/a/@href' 'https://example.com'
+ // @has - '//*[@id="method.b"]/../../div[@class="docblock"]/p/a' 'Read more'
+ // @has - '//*[@id="method.b"]/../../div[@class="docblock"]/p/a/@href' 'trait.Trait.html#tymethod.b'
fn b() {}
- // @!has trait_impl/struct.Struct.html '//*[@id="method.c"]/../div/p' 'code block'
- // @has - '//*[@id="method.c"]/../div/p/a' 'Read more'
- // @has - '//*[@id="method.c"]/../div/p/a/@href' 'trait.Trait.html'
+ // @!has - '//*[@id="method.c"]/../../div[@class="docblock"]/p' 'code block'
+ // @has - '//*[@id="method.c"]/../../div[@class="docblock"]/a' 'Read more'
+ // @has - '//*[@id="method.c"]/../../div[@class="docblock"]/a/@href' 'trait.Trait.html#tymethod.c'
fn c() {}
- // @has trait_impl/struct.Struct.html '//*[@id="method.d"]/../div/p' \
- // 'Escaped formatting a*b*c* works'
- // @!has trait_impl/struct.Struct.html '//*[@id="method.d"]/../div/p/em'
+ // @has - '//*[@id="method.d"]/../../div[@class="docblock"]/p' 'Escaped formatting a*b*c* works'
+ // @!has - '//*[@id="method.d"]/../../div[@class="docblock"]/p/em'
fn d() {}
+
+ // @has - '//*[@id="impl-Trait"]/code/a/@href' 'trait.Trait.html'
}
--- /dev/null
+// aux-build:trait-visibility.rs
+
+#![crate_name = "foo"]
+
+extern crate trait_visibility;
+
+// @has foo/trait.Bar.html '//a[@href="#tymethod.foo"]/..' "fn foo()"
+pub use trait_visibility::Bar;
pub trait Alias2 = Copy + Debug;
// @has foo/traitalias.Foo.html '//section[@id="main"]/pre' 'trait Foo<T> = Into<T> + Debug;'
pub trait Foo<T> = Into<T> + Debug;
+// @has foo/fn.bar.html '//a[@href="traitalias.Alias2.html"]' 'Alias2'
+pub fn bar<T>() where T: Alias2 {}
// run-pass
-#![feature(const_fn)]
-
#[derive(PartialEq, Debug, Clone)]
struct N(u8);
// min-llvm-version: 10.0.1
-// FIXME(#84025): codegen-units=1 leads to linkage errors
-// compile-flags: -C codegen-units=2
// only-x86_64
// only-linux
// run-pass
// #29924
-#![feature(const_fn, associated_consts)]
+#![feature(associated_consts)]
trait Trait {
const N: usize;
--> $DIR/async-borrowck-escaping-block-error.rs:11:11
|
LL | async { *x }
- | ^^^-^^
- | | |
- | | `x` is borrowed here
+ | ^^--^^
+ | | |
+ | | `x` is borrowed here
| may outlive borrowed value `x`
|
note: async block is returned here
async fn main() -> Result<i32, ()> {
//~^ ERROR `main` function is not allowed to be `async`
-//~^^ ERROR `main` has invalid return type `impl Future`
Ok(1)
}
-error[E0277]: `main` has invalid return type `impl Future`
- --> $DIR/issue-68523.rs:3:20
- |
-LL | async fn main() -> Result<i32, ()> {
- | ^^^^^^^^^^^^^^^ `main` can only return types that implement `Termination`
- |
- = help: consider using `()`, or a `Result`
-
error[E0752]: `main` function is not allowed to be `async`
--> $DIR/issue-68523.rs:3:1
|
LL | async fn main() -> Result<i32, ()> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `main` function is not allowed to be `async`
-error: aborting due to 2 previous errors
+error: aborting due to previous error
-Some errors have detailed explanations: E0277, E0752.
-For more information about an error, try `rustc --explain E0277`.
+For more information about this error, try `rustc --explain E0752`.
--> $DIR/borrowck-closures-mut-and-imm.rs:57:5
|
LL | let c1 = || get(&*x);
- | -- - borrow occurs due to use in closure
+ | -- -- borrow occurs due to use in closure
| |
| borrow of `*x` occurs here
LL | *x = 5;
--> $DIR/borrowck-closures-mut-and-imm.rs:69:5
|
LL | let c1 = || get(&*x.f);
- | -- - borrow occurs due to use in closure
+ | -- ---- borrow occurs due to use in closure
| |
| borrow of `*x.f` occurs here
LL | *x.f = 5;
--> $DIR/borrowck-closures-mut-and-imm.rs:81:14
|
LL | let c1 = || get(&*x.f);
- | -- - first borrow occurs due to use of `x` in closure
+ | -- ---- first borrow occurs due to use of `x` in closure
| |
| immutable borrow occurs here
LL | let c2 = || *x.f = 5;
- | ^^ - second borrow occurs due to use of `x` in closure
+ | ^^ ---- second borrow occurs due to use of `x` in closure
| |
| mutable borrow occurs here
LL |
--> $DIR/borrowck-closures-mut-of-imm.rs:11:18
|
LL | let mut c1 = || set(&mut *x);
- | -- - first borrow occurs due to use of `x` in closure
+ | -- -- first borrow occurs due to use of `x` in closure
| |
| first closure is constructed here
LL |
LL | let mut c2 = || set(&mut *x);
- | ^^ - second borrow occurs due to use of `x` in closure
+ | ^^ -- second borrow occurs due to use of `x` in closure
| |
| second closure is constructed here
...
--> $DIR/borrowck-closures-mut-of-mut.rs:14:18
|
LL | let mut c1 = || set(&mut *x);
- | -- - first borrow occurs due to use of `x` in closure
+ | -- -- first borrow occurs due to use of `x` in closure
| |
| first closure is constructed here
LL | let mut c2 = || set(&mut *x);
- | ^^ - second borrow occurs due to use of `x` in closure
+ | ^^ -- second borrow occurs due to use of `x` in closure
| |
| second closure is constructed here
LL |
LL | let f = || {
| -- immutable borrow occurs here
LL | let [ref y, ref z @ ..] = *x;
- | - first borrow occurs due to use of `x` in closure
+ | -- first borrow occurs due to use of `x` in closure
LL | };
LL | let r = &mut *x;
| ^^^^^^^ mutable borrow occurs here
LL | let mut f = || {
| -- closure construction occurs here
LL | let [ref mut y, ref mut z @ ..] = *x;
- | - first borrow occurs due to use of `x` in closure
+ | -- first borrow occurs due to use of `x` in closure
LL | };
LL | let r = &x;
| ^^ second borrow occurs here
LL | let f = || {
| -- immutable borrow occurs here
LL | if let [ref y, ref z @ ..] = *x {}
- | - first borrow occurs due to use of `x` in closure
+ | -- first borrow occurs due to use of `x` in closure
LL | };
LL | let r = &mut *x;
| ^^^^^^^ mutable borrow occurs here
LL | let mut f = || {
| -- closure construction occurs here
LL | if let [ref mut y, ref mut z @ ..] = *x {}
- | - first borrow occurs due to use of `x` in closure
+ | -- first borrow occurs due to use of `x` in closure
LL | };
LL | let r = &x;
| ^^ second borrow occurs here
--> $DIR/borrowck-closures-two-mut-fail.rs:53:24
|
LL | let c1 = to_fn_mut(|| set(&mut *x.f));
- | -- - first borrow occurs due to use of `x` in closure
+ | -- ---- first borrow occurs due to use of `x` in closure
| |
| first mutable borrow occurs here
LL | let c2 = to_fn_mut(|| set(&mut *x.f));
- | ^^ - second borrow occurs due to use of `x` in closure
+ | ^^ ---- second borrow occurs due to use of `x` in closure
| |
| second mutable borrow occurs here
LL |
--> $DIR/borrowck-closures-two-mut.rs:49:24
|
LL | let c1 = to_fn_mut(|| set(&mut *x.f));
- | -- - first borrow occurs due to use of `x` in closure
+ | -- ---- first borrow occurs due to use of `x` in closure
| |
| first mutable borrow occurs here
LL | let c2 = to_fn_mut(|| set(&mut *x.f));
- | ^^ - second borrow occurs due to use of `x` in closure
+ | ^^ ---- second borrow occurs due to use of `x` in closure
| |
| second mutable borrow occurs here
LL |
| |
| borrow occurs here
LL | let c2 = || { get(x); set(x); };
- | ^^ - second borrow occurs due to use of `x` in closure
+ | ^^ - second borrow occurs due to use of `x` in closure
| |
| closure construction occurs here
LL | c1;
LL | let mut test = |foo: &Foo| {
| ----------- mutable borrow occurs here
LL | ptr = box Foo { x: ptr.x + 1 };
- | --- first borrow occurs due to use of `ptr` in closure
+ | --- first borrow occurs due to use of `ptr` in closure
LL | };
LL | test(&*ptr);
| ---- ^^^^^ immutable borrow occurs here
LL | | |a| {
| | --- closure construction occurs here
LL | | f.n.insert(*a);
- | | - first borrow occurs due to use of `f` in closure
+ | | --- first borrow occurs due to use of `f` in closure
LL | | })
| |__________^ second borrow occurs here
LL | |a| {
| ^^^ closure construction occurs here
LL | f.n.insert(*a);
- | - second borrow occurs due to use of `f` in closure
+ | --- second borrow occurs due to use of `f` in closure
error: aborting due to 2 previous errors
| ^^^^^^ move out of `v` occurs here
LL |
LL | println!("v={}", *v);
- | - move occurs due to use in closure
+ | -- move occurs due to use in closure
LL | });
LL | w.use_ref();
| - borrow later used here
| ^^^^^^ move out of `v` occurs here
LL |
LL | println!("v={}", *v);
- | - move occurs due to use in closure
+ | -- move occurs due to use in closure
LL | });
LL | w.use_ref();
| - borrow later used here
| | immutable borrow later used by call
| immutable borrow occurs here
LL | p.x = 10;
- | - second borrow occurs due to use of `p` in closure
+ | --- second borrow occurs due to use of `p` in closure
error[E0502]: cannot borrow `p` as immutable because it is also borrowed as mutable
--> $DIR/borrowck-loan-rcvr.rs:34:5
| --- captured outer variable
LL | let _g = to_fn_mut(|| {
LL | let _h = to_fn_once(move || -> isize { *bar });
- | ^^^^^^^^^^^^^^^^ ---
- | | |
- | | move occurs because `bar` has type `Box<isize>`, which does not implement the `Copy` trait
- | | move occurs due to use in closure
+ | ^^^^^^^^^^^^^^^^ ----
+ | | |
+ | | move occurs because `bar` has type `Box<isize>`, which does not implement the `Copy` trait
+ | | move occurs due to use in closure
| move out of `bar` occurs here
error: aborting due to previous error
| - move occurs because `t` has type `Box<isize>`, which does not implement the `Copy` trait
LL |
LL | call_f(move|| { *t + 1 });
- | ------ - variable moved due to use in closure
+ | ------ -- variable moved due to use in closure
| |
| value moved into closure here
LL | call_f(move|| { *t + 1 });
- | ^^^^^^ - use occurs due to use in closure
+ | ^^^^^^ -- use occurs due to use in closure
| |
| value used here after move
| - value is immutable in match guard
...
LL | (|| { *x = None; drop(force_fn_once); })();
- | ^^ - borrow occurs due to use of `x` in closure
+ | ^^ -- borrow occurs due to use of `x` in closure
| |
| cannot mutably borrow
--> $DIR/issue-27282-reborrow-ref-mut-in-guard.rs:12:25
|
LL | ref mut r if { (|| { let bar = &mut *r; **bar = false; })();
- | ^^ - mutable borrow occurs due to use of `r` in closure
+ | ^^ -- mutable borrow occurs due to use of `r` in closure
| |
| cannot borrow as mutable
|
-// run-pass
+// build-pass
// pretty-expanded FIXME #23616
-// ignore-wasm32-bare no target_family
+// ignore-wasm32-bare no bare family
// ignore-sgx
#[cfg(windows)]
// build-pass
// compile-flags: -C panic=unwind
+// needs-unwind
// ignore-emscripten no panic_unwind implementation
// ignore-wasm32 no panic_unwind implementation
// ignore-wasm64 no panic_unwind implementation
-// run-pass
-// ignore-wasm32-bare no target_family
+// build-pass
// ignore-sgx
// pretty-expanded FIXME #23616
#[cfg(target_family = "unix")]
pub fn main() {
}
+
+#[cfg(target_family="wasm")]
+pub fn main() {
+}
--- /dev/null
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+
+#[derive(Debug)]
+struct Point {
+ x: i32,
+ y: i32,
+}
+fn main() {
+ let mut p = Point {x: 1, y: 2 };
+
+ let y = &mut p.y;
+ let mut c = || {
+ //~^ ERROR cannot borrow `p` as mutable more than once at a time
+ let x = &mut p.x;
+ println!("{:?}", p);
+ };
+ c();
+ *y+=1;
+}
--- /dev/null
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+ --> $DIR/borrowck-1.rs:1:12
+ |
+LL | #![feature(capture_disjoint_fields)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: `#[warn(incomplete_features)]` on by default
+ = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error[E0499]: cannot borrow `p` as mutable more than once at a time
+ --> $DIR/borrowck-1.rs:13:17
+ |
+LL | let y = &mut p.y;
+ | -------- first mutable borrow occurs here
+LL | let mut c = || {
+ | ^^ second mutable borrow occurs here
+LL |
+LL | let x = &mut p.x;
+ | --- capture is mutable because of use here
+LL | println!("{:?}", p);
+ | - second borrow occurs due to use of `p` in closure
+...
+LL | *y+=1;
+ | ----- first borrow later used here
+
+error: aborting due to previous error; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0499`.
--- /dev/null
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+
+#[derive(Debug)]
+struct Point {
+ x: i32,
+ y: i32,
+}
+fn main() {
+ let mut p = Point {x: 1, y: 2 };
+
+ let y = &p.y;
+ let mut c = || {
+ //~^ ERROR cannot borrow `p` as mutable because it is also borrowed as immutable
+ println!("{:?}", p);
+ let x = &mut p.x;
+ };
+ c();
+ println!("{}", y);
+}
--- /dev/null
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+ --> $DIR/borrowck-2.rs:1:12
+ |
+LL | #![feature(capture_disjoint_fields)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: `#[warn(incomplete_features)]` on by default
+ = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error[E0502]: cannot borrow `p` as mutable because it is also borrowed as immutable
+ --> $DIR/borrowck-2.rs:13:17
+ |
+LL | let y = &p.y;
+ | ---- immutable borrow occurs here
+LL | let mut c = || {
+ | ^^ mutable borrow occurs here
+LL |
+LL | println!("{:?}", p);
+ | - second borrow occurs due to use of `p` in closure
+LL | let x = &mut p.x;
+ | --- capture is mutable because of use here
+...
+LL | println!("{}", y);
+ | - immutable borrow later used here
+
+error: aborting due to previous error; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0502`.
--- /dev/null
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+
+#[derive(Debug)]
+struct Point {
+ x: String,
+ y: String,
+}
+fn main() {
+ let mut c = {
+ let mut p = Point {x: "1".to_string(), y: "2".to_string() };
+ || {
+ let x = &mut p.x;
+ println!("{:?}", p);
+ //~^ ERROR `p` does not live long enough
+ }
+ };
+ c();
+}
--- /dev/null
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+ --> $DIR/borrowck-3.rs:1:12
+ |
+LL | #![feature(capture_disjoint_fields)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: `#[warn(incomplete_features)]` on by default
+ = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error[E0597]: `p` does not live long enough
+ --> $DIR/borrowck-3.rs:14:29
+ |
+LL | let mut c = {
+ | ----- borrow later stored here
+LL | let mut p = Point {x: "1".to_string(), y: "2".to_string() };
+LL | || {
+ | -- value captured here
+LL | let x = &mut p.x;
+LL | println!("{:?}", p);
+ | ^ borrowed value does not live long enough
+...
+LL | };
+ | - `p` dropped here while still borrowed
+
+error: aborting due to previous error; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0597`.
--- /dev/null
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+
+#[derive(Debug)]
+struct Point {
+ x: i32,
+ y: i32,
+}
+fn foo () -> impl FnMut()->() {
+ let mut p = Point {x: 1, y: 2 };
+ let mut c = || {
+ //~^ ERROR closure may outlive the current function, but it borrows `p`
+ p.x+=5;
+ println!("{:?}", p);
+ };
+ c
+}
+fn main() {
+ let c = foo();
+ c();
+}
--- /dev/null
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+ --> $DIR/borrowck-4.rs:1:12
+ |
+LL | #![feature(capture_disjoint_fields)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: `#[warn(incomplete_features)]` on by default
+ = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error[E0373]: closure may outlive the current function, but it borrows `p`, which is owned by the current function
+ --> $DIR/borrowck-4.rs:11:17
+ |
+LL | let mut c = || {
+ | ^^ may outlive borrowed value `p`
+...
+LL | println!("{:?}", p);
+ | - `p` is borrowed here
+ |
+note: closure is returned here
+ --> $DIR/borrowck-4.rs:9:14
+ |
+LL | fn foo () -> impl FnMut()->() {
+ | ^^^^^^^^^^^^^^^^
+help: to force the closure to take ownership of `p` (and any other referenced variables), use the `move` keyword
+ |
+LL | let mut c = move || {
+ | ^^^^^^^
+
+error: aborting due to previous error; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0373`.
--- /dev/null
+// Tests that two closures cannot simultaneously have mutable
+// and immutable access to the variable. Issue #6801.
+
+#![feature(capture_disjoint_fields)]
+//~^ WARNING: the feature `capture_disjoint_fields` is incomplete
+#![feature(box_syntax)]
+
+#[derive(Debug)]
+struct Point {
+ x: i32,
+ y: i32,
+}
+
+fn a() {
+ let mut p = Point {x: 3, y:4};
+ let c2 = || p.y * 5;
+ let c1 = || {
+ //~^ ERROR cannot borrow `p` as mutable because it is also borrowed as immutable
+ dbg!(&p);
+ p.x = 4;
+ };
+ drop(c2);
+}
+
+fn main() {
+}
--- /dev/null
+warning: the feature `capture_disjoint_fields` is incomplete and may not be safe to use and/or cause compiler crashes
+ --> $DIR/borrowck-closures-mut-and-imm.rs:4:12
+ |
+LL | #![feature(capture_disjoint_fields)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: `#[warn(incomplete_features)]` on by default
+ = note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
+
+error[E0502]: cannot borrow `p` as mutable because it is also borrowed as immutable
+ --> $DIR/borrowck-closures-mut-and-imm.rs:17:14
+ |
+LL | let c2 = || p.y * 5;
+ | -- --- first borrow occurs due to use of `p.y` in closure
+ | |
+ | immutable borrow occurs here
+LL | let c1 = || {
+ | ^^ mutable borrow occurs here
+LL |
+LL | dbg!(&p);
+ | - second borrow occurs due to use of `p` in closure
+LL | p.x = 4;
+ | --- capture is mutable because of use here
+LL | };
+LL | drop(c2);
+ | -- immutable borrow later used here
+
+error: aborting due to previous error; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0502`.
LL | let mut c = || {
| -- borrow of `e.0.0.m.x` occurs here
LL | e.0.0.m.x = format!("not-x");
- | - borrow occurs due to use in closure
+ | --------- borrow occurs due to use in closure
...
LL | e.0.0.m.x = format!("not-x");
| ^^^^^^^^^ assignment to borrowed `e.0.0.m.x` occurs here
LL | let mut c = || {
| -- mutable borrow occurs here
LL | e.0.0.m.x = format!("not-x");
- | - first borrow occurs due to use of `e.0.0.m.x` in closure
+ | --------- first borrow occurs due to use of `e.0.0.m.x` in closure
...
LL | println!("{}", e.0.0.m.x);
| ^^^^^^^^^ immutable borrow occurs here
LL | let c = || {
| -- borrow of `e.0.0.m.x` occurs here
LL | println!("{}", e.0.0.m.x);
- | - borrow occurs due to use in closure
+ | --------- borrow occurs due to use in closure
...
LL | e.0.0.m.x = format!("not-x");
| ^^^^^^^^^ assignment to borrowed `e.0.0.m.x` occurs here
| ^^ cannot borrow as mutable
LL |
LL | z.0.0.0 = format!("X1");
- | - mutable borrow occurs due to use of `z.0.0.0` in closure
+ | ------- mutable borrow occurs due to use of `z.0.0.0` in closure
error: aborting due to previous error; 1 warning emitted
let mut c = || {
z.0.0.0 = 20;
- //~^ ERROR: cannot assign to `z`, as it is not declared as mutable
+ //~^ ERROR: cannot assign to `z.0.0.0`, as it is not declared as mutable
};
c();
let mut c = || {
bx.0 = 20;
- //~^ ERROR: cannot assign to `bx`, as it is not declared as mutable
+ //~^ ERROR: cannot assign to `*bx.0`, as it is not declared as mutable
};
c();
= note: `#[warn(incomplete_features)]` on by default
= note: see issue #53488 <https://github.com/rust-lang/rust/issues/53488> for more information
-error[E0594]: cannot assign to `z`, as it is not declared as mutable
+error[E0594]: cannot assign to `z.0.0.0`, as it is not declared as mutable
--> $DIR/cant-mutate-imm.rs:13:9
|
LL | let z = (y, 10);
LL | z.0.0.0 = 20;
| ^^^^^^^^^^^^ cannot assign
-error[E0594]: cannot assign to `bx`, as it is not declared as mutable
+error[E0594]: cannot assign to `*bx.0`, as it is not declared as mutable
--> $DIR/cant-mutate-imm.rs:25:9
|
LL | let bx = Box::new(x);
LL | let mut c = || {
| -- first mutable borrow occurs here
LL | w.p.x += 20;
- | - first borrow occurs due to use of `w.p.x` in closure
+ | ----- first borrow occurs due to use of `w.p.x` in closure
...
LL | let py = &mut w.p.x;
| ^^^^^^^^^^ second mutable borrow occurs here
| ^^ `ref_mref_x` is a `&` reference, so the data it refers to cannot be borrowed as mutable
LL |
LL | **ref_mref_x = y;
- | ---------- mutable borrow occurs due to use of `**ref_mref_x` in closure
+ | ------------ mutable borrow occurs due to use of `**ref_mref_x` in closure
error[E0596]: cannot borrow `**mref_ref_x` as mutable, as it is behind a `&` reference
--> $DIR/mut_ref.rs:27:13
| ^^ cannot borrow as mutable
LL |
LL | **mref_ref_x = y;
- | ---------- mutable borrow occurs due to use of `**mref_ref_x` in closure
+ | ------------ mutable borrow occurs due to use of `**mref_ref_x` in closure
error: aborting due to 2 previous errors; 1 warning emitted
LL | let mut c = || {
| -- mutable borrow occurs here
LL | p.x += 10;
- | - first borrow occurs due to use of `p` in closure
+ | --- capture is mutable because of use here
+LL | println!("{:?}", p);
+ | - first borrow occurs due to use of `p` in closure
...
LL | println!("{:?}", p);
| ^ immutable borrow occurs here
| ^ unused parameter
|
= help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `T` to be a const parameter, use `const T: usize` instead
error: aborting due to 2 previous errors
| ^ unused parameter
|
= help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `T` to be a const parameter, use `const T: usize` instead
error: aborting due to 2 previous errors
| ^ unused parameter
|
= help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `T` to be a const parameter, use `const T: usize` instead
error: aborting due to previous error; 1 warning emitted
| ^ unused parameter
|
= help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `T` to be a const parameter, use `const T: usize` instead
error: aborting due to 2 previous errors
| ^ unused parameter
|
= help: consider removing `S`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `S` to be a const parameter, use `const S: usize` instead
error: aborting due to 2 previous errors
| ^ unused parameter
|
= help: consider removing `S`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `S` to be a const parameter, use `const S: usize` instead
error: aborting due to 3 previous errors
| ^ unused parameter
|
= help: consider removing `S`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `S` to be a const parameter, use `const S: usize` instead
error: aborting due to 2 previous errors
| ^ unused parameter
|
= help: consider removing `S`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `S` to be a const parameter, use `const S: usize` instead
error: aborting due to 3 previous errors
--- /dev/null
+// regression test for #83466- tests that generic arg mismatch errors between
+// consts and types are not supressed when there are explicit late bound lifetimes
+
+struct S;
+impl S {
+ fn func<'a, U>(self) -> U {
+ todo!()
+ }
+}
+fn dont_crash<'a, U>() {
+ S.func::<'a, 10_u32>()
+ //~^ WARNING cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
+ //~^^ WARNING this was previously accepted by
+ //~^^^ ERROR constant provided when a type was expected [E0747]
+}
+
+fn main() {}
--- /dev/null
+warning: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
+ --> $DIR/issue-83466.rs:11:14
+ |
+LL | fn func<'a, U>(self) -> U {
+ | -- the late bound lifetime parameter is introduced here
+...
+LL | S.func::<'a, 10_u32>()
+ | ^^
+ |
+ = note: `#[warn(late_bound_lifetime_arguments)]` on by default
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #42868 <https://github.com/rust-lang/rust/issues/42868>
+
+error[E0747]: constant provided when a type was expected
+ --> $DIR/issue-83466.rs:11:18
+ |
+LL | S.func::<'a, 10_u32>()
+ | ^^^^^^
+
+error: aborting due to previous error; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0747`.
//~| ERROR expected trait, found constant `BAR`
//~| ERROR type provided when a constant was expected
//~| WARN trait objects without an explicit `dyn` are deprecated
+ //~| WARN this was previously accepted by the compiler
}
fn c() {
foo::<3 + 3>(); //~ ERROR expressions must be enclosed in braces
| ^ ^
error: expressions must be enclosed in braces to be used as const generic arguments
- --> $DIR/const-expression-suggest-missing-braces.rs:18:11
+ --> $DIR/const-expression-suggest-missing-braces.rs:19:11
|
LL | foo::<3 + 3>();
| ^^^^^
| ^ ^
error: expected one of `,` or `>`, found `-`
- --> $DIR/const-expression-suggest-missing-braces.rs:21:15
+ --> $DIR/const-expression-suggest-missing-braces.rs:22:15
|
LL | foo::<BAR - 3>();
| ^ expected one of `,` or `>`
| ^ ^
error: expected one of `,` or `>`, found `-`
- --> $DIR/const-expression-suggest-missing-braces.rs:24:15
+ --> $DIR/const-expression-suggest-missing-braces.rs:25:15
|
LL | foo::<BAR - BAR>();
| ^ expected one of `,` or `>`
| ^ ^
error: expressions must be enclosed in braces to be used as const generic arguments
- --> $DIR/const-expression-suggest-missing-braces.rs:27:11
+ --> $DIR/const-expression-suggest-missing-braces.rs:28:11
|
LL | foo::<100 - BAR>();
| ^^^^^^^^^
| ^ ^
error: expected one of `,` or `>`, found `(`
- --> $DIR/const-expression-suggest-missing-braces.rs:30:19
+ --> $DIR/const-expression-suggest-missing-braces.rs:31:19
|
LL | foo::<bar<i32>()>();
| ^ expected one of `,` or `>`
| ^ ^
error: expected one of `,` or `>`, found `(`
- --> $DIR/const-expression-suggest-missing-braces.rs:33:21
+ --> $DIR/const-expression-suggest-missing-braces.rs:34:21
|
LL | foo::<bar::<i32>()>();
| ^ expected one of `,` or `>`
| ^ ^
error: expected one of `,` or `>`, found `(`
- --> $DIR/const-expression-suggest-missing-braces.rs:36:21
+ --> $DIR/const-expression-suggest-missing-braces.rs:37:21
|
LL | foo::<bar::<i32>() + BAR>();
| ^ expected one of `,` or `>`
| ^ ^
error: expected one of `,` or `>`, found `(`
- --> $DIR/const-expression-suggest-missing-braces.rs:39:21
+ --> $DIR/const-expression-suggest-missing-braces.rs:40:21
|
LL | foo::<bar::<i32>() - BAR>();
| ^ expected one of `,` or `>`
| ^ ^
error: expected one of `,` or `>`, found `-`
- --> $DIR/const-expression-suggest-missing-braces.rs:42:15
+ --> $DIR/const-expression-suggest-missing-braces.rs:43:15
|
LL | foo::<BAR - bar::<i32>()>();
| ^ expected one of `,` or `>`
| ^ ^
error: expected one of `,` or `>`, found `-`
- --> $DIR/const-expression-suggest-missing-braces.rs:45:15
+ --> $DIR/const-expression-suggest-missing-braces.rs:46:15
|
LL | foo::<BAR - bar::<i32>()>();
| ^ expected one of `,` or `>`
| ^^^^^^^^^ help: use `dyn`: `dyn BAR + BAR`
|
= note: `#[warn(bare_trait_objects)]` on by default
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error[E0747]: type provided when a constant was expected
--> $DIR/const-expression-suggest-missing-braces.rs:11:11
--- /dev/null
+#![crate_type="lib"]
+
+struct Example<N>;
+//~^ ERROR parameter
--- /dev/null
+error[E0392]: parameter `N` is never used
+ --> $DIR/unused-type-param-suggestion.rs:3:16
+ |
+LL | struct Example<N>;
+ | ^ unused parameter
+ |
+ = help: consider removing `N`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `N` to be a const parameter, use `const N: usize` instead
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0392`.
#![crate_type="rlib"]
#![stable(feature = "rust1", since = "1.0.0")]
-#![feature(const_fn)]
#![feature(staged_api)]
#[stable(feature = "rust1", since = "1.0.0")]
// run-pass
// compile-flags: -Zunleash-the-miri-inside-of-you
-#![feature(const_fn)]
fn double(x: usize) -> usize { x * 2 }
const fn double_const(x: usize) -> usize { x * 2 }
warning: skipping const checks
|
help: skipping check that does not even have a feature gate
- --> $DIR/const_fn_ptr.rs:12:5
+ --> $DIR/const_fn_ptr.rs:11:5
|
LL | X(x)
| ^^^^
help: skipping check that does not even have a feature gate
- --> $DIR/const_fn_ptr.rs:16:5
+ --> $DIR/const_fn_ptr.rs:15:5
|
LL | X_CONST(x)
| ^^^^^^^^^^
help: skipping check for `const_fn_fn_ptr_basics` feature
- --> $DIR/const_fn_ptr.rs:19:14
+ --> $DIR/const_fn_ptr.rs:18:14
|
LL | const fn foo(x: fn(usize) -> usize, y: usize) -> usize {
| ^
help: skipping check for `const_fn_fn_ptr_basics` feature
- --> $DIR/const_fn_ptr.rs:20:5
+ --> $DIR/const_fn_ptr.rs:19:5
|
LL | x(y)
| ^
help: skipping check that does not even have a feature gate
- --> $DIR/const_fn_ptr.rs:20:5
+ --> $DIR/const_fn_ptr.rs:19:5
|
LL | x(y)
| ^^^^
// run-pass
// compile-flags: -Zunleash-the-miri-inside-of-you
-#![feature(const_fn)]
#![allow(unused)]
fn double(x: usize) -> usize { x * 2 }
warning: skipping const checks
|
help: skipping check that does not even have a feature gate
- --> $DIR/const_fn_ptr_fail.rs:10:5
+ --> $DIR/const_fn_ptr_fail.rs:9:5
|
LL | X(x) // FIXME: this should error someday
| ^^^^
// build-fail
// compile-flags: -Zunleash-the-miri-inside-of-you
-#![feature(const_fn)]
#![allow(const_err)]
fn double(x: usize) -> usize {
error[E0080]: evaluation of constant value failed
- --> $DIR/const_fn_ptr_fail2.rs:20:16
+ --> $DIR/const_fn_ptr_fail2.rs:19:16
|
LL | assert_eq!(Y, 4);
| ^ referenced constant has errors
error[E0080]: evaluation of constant value failed
- --> $DIR/const_fn_ptr_fail2.rs:22:16
+ --> $DIR/const_fn_ptr_fail2.rs:21:16
|
LL | assert_eq!(Z, 4);
| ^ referenced constant has errors
warning: skipping const checks
|
help: skipping check for `const_fn_fn_ptr_basics` feature
- --> $DIR/const_fn_ptr_fail2.rs:12:14
+ --> $DIR/const_fn_ptr_fail2.rs:11:14
|
LL | const fn bar(x: fn(usize) -> usize, y: usize) -> usize {
| ^
help: skipping check for `const_fn_fn_ptr_basics` feature
- --> $DIR/const_fn_ptr_fail2.rs:13:5
+ --> $DIR/const_fn_ptr_fail2.rs:12:5
|
LL | x(y)
| ^
help: skipping check that does not even have a feature gate
- --> $DIR/const_fn_ptr_fail2.rs:13:5
+ --> $DIR/const_fn_ptr_fail2.rs:12:5
|
LL | x(y)
| ^^^^
we're apparently really bad at it",
issue = "none")]
-#![feature(const_fn)]
#![feature(staged_api)]
#[stable(feature = "rust1", since = "1.0.0")]
error: `foo` is not yet stable as a const fn
- --> $DIR/dont_promote_unstable_const_fn.rs:15:25
+ --> $DIR/dont_promote_unstable_const_fn.rs:14:25
|
LL | const fn bar() -> u32 { foo() }
| ^^^^^
= help: add `#![feature(foo)]` to the crate attributes to enable
error[E0716]: temporary value dropped while borrowed
- --> $DIR/dont_promote_unstable_const_fn.rs:18:28
+ --> $DIR/dont_promote_unstable_const_fn.rs:17:28
|
LL | let _: &'static u32 = &foo();
| ------------ ^^^^^ creates a temporary which is freed while still in use
| - temporary value is freed at the end of this statement
error[E0716]: temporary value dropped while borrowed
- --> $DIR/dont_promote_unstable_const_fn.rs:22:28
+ --> $DIR/dont_promote_unstable_const_fn.rs:21:28
|
LL | let _: &'static u32 = &meh();
| ------------ ^^^^^ creates a temporary which is freed while still in use
| - temporary value is freed at the end of this statement
error[E0716]: temporary value dropped while borrowed
- --> $DIR/dont_promote_unstable_const_fn.rs:23:26
+ --> $DIR/dont_promote_unstable_const_fn.rs:22:26
|
LL | let x: &'static _ = &std::time::Duration::from_millis(42).subsec_millis();
| ---------- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ creates a temporary which is freed while still in use
// check-pass
-#![feature(const_fn, rustc_attrs)]
+#![feature(rustc_attrs)]
#[rustc_args_required_const(0)]
pub const fn a(value: u8) -> u8 {
-#![feature(const_fn)]
-
fn main() {}
#[repr(C)]
error[E0658]: unions in const fn are unstable
- --> $DIR/feature-gate-const_fn_union.rs:12:5
+ --> $DIR/feature-gate-const_fn_union.rs:10:5
|
LL | Foo { u }.i
| ^^^^^^^^^^^
-#![feature(const_fn, const_fn_union)]
+#![feature(const_fn_union)]
#![allow(const_err)]
-#![feature(const_fn, const_fn_union)]
+#![feature(const_fn_union)]
#![deny(const_err)]
// run-pass
-#![feature(const_fn)]
#![feature(repr_simd)]
#![feature(platform_intrinsics)]
#![feature(staged_api)]
|
LL | / const OUT_OF_BOUNDS_PTR: NonNull<u8> = { unsafe {
LL | | let ptr: &[u8; 256] = mem::transmute(&0u8); // &0 gets promoted so it does not dangle
-LL | | // Use address-of-element for pointer arithmetic. This could wrap around to NULL!
+LL | | // Use address-of-element for pointer arithmetic. This could wrap around to null!
LL | | let out_of_bounds_ptr = &ptr[255];
| | ^^^^^^^^ memory access failed: pointer must be in-bounds at offset 256, but is outside bounds of alloc10 which has size 1
LL | |
|
LL | / const OUT_OF_BOUNDS_PTR: NonNull<u8> = { unsafe {
LL | | let ptr: &[u8; 256] = mem::transmute(&0u8); // &0 gets promoted so it does not dangle
-LL | | // Use address-of-element for pointer arithmetic. This could wrap around to NULL!
+LL | | // Use address-of-element for pointer arithmetic. This could wrap around to null!
LL | | let out_of_bounds_ptr = &ptr[255];
| | ^^^^^^^^ memory access failed: pointer must be in-bounds at offset 256, but is outside bounds of alloc10 which has size 1
LL | |
#[deny(const_err)] // this triggers a `const_err` so validation does not even happen
const OUT_OF_BOUNDS_PTR: NonNull<u8> = { unsafe {
let ptr: &[u8; 256] = mem::transmute(&0u8); // &0 gets promoted so it does not dangle
- // Use address-of-element for pointer arithmetic. This could wrap around to NULL!
+ // Use address-of-element for pointer arithmetic. This could wrap around to null!
let out_of_bounds_ptr = &ptr[255]; //~ ERROR any use of this value will cause an error
//~| WARN this was previously accepted by the compiler but is being phased out
mem::transmute(out_of_bounds_ptr)
--> $DIR/ub-ref-ptr.rs:21:1
|
LL | const NULL: &u16 = unsafe { mem::transmute(0usize) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a NULL reference
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a null reference
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
= note: the raw bytes of the constant (size: 4, align: 4) {
--> $DIR/ub-ref-ptr.rs:24:1
|
LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a NULL box
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a null box
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
= note: the raw bytes of the constant (size: 4, align: 4) {
--> $DIR/ub-ref-ptr.rs:21:1
|
LL | const NULL: &u16 = unsafe { mem::transmute(0usize) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a NULL reference
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a null reference
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
= note: the raw bytes of the constant (size: 8, align: 8) {
--> $DIR/ub-ref-ptr.rs:24:1
|
LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a NULL box
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a null box
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
= note: the raw bytes of the constant (size: 8, align: 8) {
LL | | let another_var = 13;
LL | | move || { let _ = bad_ref; let _ = another_var; }
LL | | };
- | |__^ type validation failed: encountered a NULL reference at .<deref>.<dyn-downcast>.<captured-var(bad_ref)>
+ | |__^ type validation failed: encountered a null reference at .<deref>.<dyn-downcast>.<captured-var(bad_ref)>
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
= note: the raw bytes of the constant (size: 8, align: 4) {
LL | | let another_var = 13;
LL | | move || { let _ = bad_ref; let _ = another_var; }
LL | | };
- | |__^ type validation failed: encountered a NULL reference at .<deref>.<dyn-downcast>.<captured-var(bad_ref)>
+ | |__^ type validation failed: encountered a null reference at .<deref>.<dyn-downcast>.<captured-var(bad_ref)>
|
= note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
= note: the raw bytes of the constant (size: 16, align: 8) {
--> $DIR/ub-wide-ptr.rs:135:5
|
LL | mem::transmute::<_, &dyn Trait>((&92u8, 0usize))
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ inbounds test failed: 0x0 is not a valid pointer
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ null pointer is not allowed for this operation
error[E0080]: could not evaluate static initializer
--> $DIR/ub-wide-ptr.rs:139:5
--> $DIR/ub-wide-ptr.rs:135:5
|
LL | mem::transmute::<_, &dyn Trait>((&92u8, 0usize))
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ inbounds test failed: 0x0 is not a valid pointer
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ null pointer is not allowed for this operation
error[E0080]: could not evaluate static initializer
--> $DIR/ub-wide-ptr.rs:139:5
// only-x86_64
-#![feature(const_fn)]
type Field1 = i32;
type Field2 = f32;
error[E0080]: it is undefined behavior to use this value
- --> $DIR/union-const-eval-field.rs:29:5
+ --> $DIR/union-const-eval-field.rs:28:5
|
LL | const FIELD3: Field3 = unsafe { UNION.field3 };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes
// only-x86_64
-#![feature(const_fn)]
type Field1 = i32;
type Field3 = i64;
error[E0080]: it is undefined behavior to use this value
- --> $DIR/union-ice.rs:15:1
+ --> $DIR/union-ice.rs:14:1
|
LL | const FIELD3: Field3 = unsafe { UNION.field3 };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes
}
error[E0080]: it is undefined behavior to use this value
- --> $DIR/union-ice.rs:17:1
+ --> $DIR/union-ice.rs:16:1
|
LL | / const FIELD_PATH: Struct = Struct {
LL | | a: 42,
}
error[E0080]: it is undefined behavior to use this value
- --> $DIR/union-ice.rs:27:1
+ --> $DIR/union-ice.rs:26:1
|
LL | / const FIELD_PATH2: Struct2 = Struct2 {
LL | | b: [
warning: any use of this value will cause an error
- --> $DIR/validate_uninhabited_zsts.rs:6:14
+ --> $DIR/validate_uninhabited_zsts.rs:5:14
|
LL | unsafe { std::mem::transmute(()) }
| ^^^^^^^^^^^^^^^^^^^^^^^
| |
| transmuting to uninhabited type
- | inside `foo` at $DIR/validate_uninhabited_zsts.rs:6:14
- | inside `FOO` at $DIR/validate_uninhabited_zsts.rs:16:26
+ | inside `foo` at $DIR/validate_uninhabited_zsts.rs:5:14
+ | inside `FOO` at $DIR/validate_uninhabited_zsts.rs:15:26
...
LL | const FOO: [Empty; 3] = [foo(); 3];
| -----------------------------------
|
note: the lint level is defined here
- --> $DIR/validate_uninhabited_zsts.rs:15:8
+ --> $DIR/validate_uninhabited_zsts.rs:14:8
|
LL | #[warn(const_err)]
| ^^^^^^^^^
= note: for more information, see issue #71800 <https://github.com/rust-lang/rust/issues/71800>
error[E0080]: it is undefined behavior to use this value
- --> $DIR/validate_uninhabited_zsts.rs:19:1
+ --> $DIR/validate_uninhabited_zsts.rs:18:1
|
LL | const BAR: [Empty; 3] = [unsafe { std::mem::transmute(()) }; 3];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of uninhabited type Empty at [0]
= note: the raw bytes of the constant (size: 0, align: 1) {}
warning: the type `!` does not permit zero-initialization
- --> $DIR/validate_uninhabited_zsts.rs:6:14
+ --> $DIR/validate_uninhabited_zsts.rs:5:14
|
LL | unsafe { std::mem::transmute(()) }
| ^^^^^^^^^^^^^^^^^^^^^^^
= note: the `!` type has no valid value
warning: the type `Empty` does not permit zero-initialization
- --> $DIR/validate_uninhabited_zsts.rs:19:35
+ --> $DIR/validate_uninhabited_zsts.rs:18:35
|
LL | const BAR: [Empty; 3] = [unsafe { std::mem::transmute(()) }; 3];
| ^^^^^^^^^^^^^^^^^^^^^^^
warning: any use of this value will cause an error
- --> $DIR/validate_uninhabited_zsts.rs:6:14
+ --> $DIR/validate_uninhabited_zsts.rs:5:14
|
LL | unsafe { std::mem::transmute(()) }
| ^^^^^^^^^^^^^^^^^^^^^^^
| |
| transmuting to uninhabited type
- | inside `foo` at $DIR/validate_uninhabited_zsts.rs:6:14
- | inside `FOO` at $DIR/validate_uninhabited_zsts.rs:16:26
+ | inside `foo` at $DIR/validate_uninhabited_zsts.rs:5:14
+ | inside `FOO` at $DIR/validate_uninhabited_zsts.rs:15:26
...
LL | const FOO: [Empty; 3] = [foo(); 3];
| -----------------------------------
|
note: the lint level is defined here
- --> $DIR/validate_uninhabited_zsts.rs:15:8
+ --> $DIR/validate_uninhabited_zsts.rs:14:8
|
LL | #[warn(const_err)]
| ^^^^^^^^^
= note: for more information, see issue #71800 <https://github.com/rust-lang/rust/issues/71800>
error[E0080]: it is undefined behavior to use this value
- --> $DIR/validate_uninhabited_zsts.rs:19:1
+ --> $DIR/validate_uninhabited_zsts.rs:18:1
|
LL | const BAR: [Empty; 3] = [unsafe { std::mem::transmute(()) }; 3];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of uninhabited type Empty at [0]
= note: the raw bytes of the constant (size: 0, align: 1) {}
warning: the type `!` does not permit zero-initialization
- --> $DIR/validate_uninhabited_zsts.rs:6:14
+ --> $DIR/validate_uninhabited_zsts.rs:5:14
|
LL | unsafe { std::mem::transmute(()) }
| ^^^^^^^^^^^^^^^^^^^^^^^
= note: the `!` type has no valid value
warning: the type `Empty` does not permit zero-initialization
- --> $DIR/validate_uninhabited_zsts.rs:19:35
+ --> $DIR/validate_uninhabited_zsts.rs:18:35
|
LL | const BAR: [Empty; 3] = [unsafe { std::mem::transmute(()) }; 3];
| ^^^^^^^^^^^^^^^^^^^^^^^
// stderr-per-bitwidth
-#![feature(const_fn)]
#![feature(const_fn_transmute)]
const fn foo() -> ! {
-#![feature(const_fn)]
-
const X : usize = 2;
const fn f(x: usize) -> usize {
error[E0744]: `for` is not allowed in a `const fn`
- --> $DIR/const-fn-error.rs:7:5
+ --> $DIR/const-fn-error.rs:5:5
|
LL | / for i in 0..x {
LL | |
| |_____^
error[E0015]: calls in constant functions are limited to constant functions, tuple structs and tuple variants
- --> $DIR/const-fn-error.rs:7:14
+ --> $DIR/const-fn-error.rs:5:14
|
LL | for i in 0..x {
| ^^^^
error[E0658]: mutable references are not allowed in constant functions
- --> $DIR/const-fn-error.rs:7:14
+ --> $DIR/const-fn-error.rs:5:14
|
LL | for i in 0..x {
| ^^^^
= help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
error[E0015]: calls in constant functions are limited to constant functions, tuple structs and tuple variants
- --> $DIR/const-fn-error.rs:7:14
+ --> $DIR/const-fn-error.rs:5:14
|
LL | for i in 0..x {
| ^^^^
error[E0080]: evaluation of constant value failed
- --> $DIR/const-fn-error.rs:7:14
+ --> $DIR/const-fn-error.rs:5:14
|
LL | for i in 0..x {
| ^^^^
| |
| calling non-const function `<std::ops::Range<usize> as IntoIterator>::into_iter`
- | inside `f` at $DIR/const-fn-error.rs:7:14
+ | inside `f` at $DIR/const-fn-error.rs:5:14
...
LL | let a : [i32; f(X)];
- | ---- inside `main::{constant#0}` at $DIR/const-fn-error.rs:20:19
+ | ---- inside `main::{constant#0}` at $DIR/const-fn-error.rs:18:19
error: aborting due to 5 previous errors
// it if the trait fn is const (but right now no trait fns can be
// const).
-#![feature(const_fn)]
-
trait Foo {
fn f() -> u32;
}
error[E0379]: functions in traits cannot be declared const
- --> $DIR/const-fn-mismatch.rs:13:5
+ --> $DIR/const-fn-mismatch.rs:11:5
|
LL | const fn f() -> u32 {
| ^^^^^ functions in traits cannot be const
// Test that const fn is illegal in a trait declaration, whether or
// not a default is provided, and even with the feature gate.
-#![feature(const_fn)]
-
trait Foo {
const fn f() -> u32;
//~^ ERROR functions in traits cannot be declared const
error[E0379]: functions in traits cannot be declared const
- --> $DIR/const-fn-not-in-trait.rs:7:5
+ --> $DIR/const-fn-not-in-trait.rs:5:5
|
LL | const fn f() -> u32;
| ^^^^^ functions in traits cannot be const
error[E0379]: functions in traits cannot be declared const
- --> $DIR/const-fn-not-in-trait.rs:9:5
+ --> $DIR/const-fn-not-in-trait.rs:7:5
|
LL | const fn g() -> u32 {
| ^^^^^ functions in traits cannot be const
// Test that we can't call random fns in a const fn or do other bad things.
-#![feature(const_fn, const_fn_transmute)]
+#![feature(const_fn_transmute)]
use std::mem::transmute;
// run-pass
-#![feature(const_fn)]
#![feature(const_type_name)]
#![allow(dead_code)]
// run-pass
#![feature(core_intrinsics)]
-#![feature(const_fn)]
#![feature(const_type_name)]
#![allow(dead_code)]
// check-pass
#![feature(const_mut_refs)]
-#![feature(const_fn)]
#![feature(raw_ref_op)]
struct Foo {
#![feature(const_mut_refs)]
-#![feature(const_fn)]
#![feature(raw_ref_op)]
#![feature(const_raw_ptr_deref)]
error[E0764]: mutable references are not allowed in the final value of constants
- --> $DIR/mut_ref_in_final.rs:12:21
+ --> $DIR/mut_ref_in_final.rs:11:21
|
LL | const B: *mut i32 = &mut 4;
| ^^^^^^
error[E0716]: temporary value dropped while borrowed
- --> $DIR/mut_ref_in_final.rs:18:40
+ --> $DIR/mut_ref_in_final.rs:17:40
|
LL | const B3: Option<&mut i32> = Some(&mut 42);
| ----------^^-
| using this value as a constant requires that borrow lasts for `'static`
error[E0716]: temporary value dropped while borrowed
- --> $DIR/mut_ref_in_final.rs:21:42
+ --> $DIR/mut_ref_in_final.rs:20:42
|
LL | const B4: Option<&mut i32> = helper(&mut 42);
| ------------^^-
| using this value as a constant requires that borrow lasts for `'static`
error[E0716]: temporary value dropped while borrowed
- --> $DIR/mut_ref_in_final.rs:36:65
+ --> $DIR/mut_ref_in_final.rs:35:65
|
LL | const FOO: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
| -------------------------------^^--
| using this value as a constant requires that borrow lasts for `'static`
error[E0716]: temporary value dropped while borrowed
- --> $DIR/mut_ref_in_final.rs:39:67
+ --> $DIR/mut_ref_in_final.rs:38:67
|
LL | static FOO2: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
| -------------------------------^^--
| using this value as a static requires that borrow lasts for `'static`
error[E0716]: temporary value dropped while borrowed
- --> $DIR/mut_ref_in_final.rs:42:71
+ --> $DIR/mut_ref_in_final.rs:41:71
|
LL | static mut FOO3: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
| -------------------------------^^--
#![feature(const_mut_refs)]
-#![feature(const_fn)]
#![feature(raw_ref_op)]
#![feature(const_raw_ptr_deref)]
error: any use of this value will cause an error
- --> $DIR/mut_ref_in_final_dynamic_check.rs:15:10
+ --> $DIR/mut_ref_in_final_dynamic_check.rs:14:10
|
LL | Some(&mut *(42 as *mut i32))
| ^^^^^^^^^^^^^^^^^^^^^^
| |
| unable to turn bytes into a pointer
- | inside `helper` at $DIR/mut_ref_in_final_dynamic_check.rs:15:10
- | inside `A` at $DIR/mut_ref_in_final_dynamic_check.rs:20:29
+ | inside `helper` at $DIR/mut_ref_in_final_dynamic_check.rs:14:10
+ | inside `A` at $DIR/mut_ref_in_final_dynamic_check.rs:19:29
...
LL | const A: Option<&mut i32> = helper();
| -------------------------------------
= note: for more information, see issue #71800 <https://github.com/rust-lang/rust/issues/71800>
error: encountered dangling pointer in final constant
- --> $DIR/mut_ref_in_final_dynamic_check.rs:27:1
+ --> $DIR/mut_ref_in_final_dynamic_check.rs:26:1
|
LL | const B: Option<&mut i32> = helper2();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-// Test that constructors are considered to be const fns with the required feature.
+// Test that constructors are considered to be const fns
// run-pass
-// revisions: min_const_fn const_fn
-
-#![cfg_attr(const_fn, feature(const_fn))]
-
// Ctor(..) is transformed to Ctor { 0: ... } in THIR lowering, so directly
// calling constructors doesn't require them to be const.
-// revisions: min_const_fn const_fn
// run-pass
-#![cfg_attr(const_fn, feature(const_fn))]
-
trait ConstDefault {
const DEFAULT: Self;
}
-#![feature(const_fn)]
-
struct S {
state: u32,
}
error[E0658]: mutable references are not allowed in constant functions
- --> $DIR/const_let_assign3.rs:8:18
+ --> $DIR/const_let_assign3.rs:6:18
|
LL | const fn foo(&mut self, x: u32) {
| ^^^^^^^^^
= help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
error[E0658]: mutable references are not allowed in constants
- --> $DIR/const_let_assign3.rs:16:5
+ --> $DIR/const_let_assign3.rs:14:5
|
LL | s.foo(3);
| ^
= help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
error[E0658]: mutable references are not allowed in constants
- --> $DIR/const_let_assign3.rs:22:13
+ --> $DIR/const_let_assign3.rs:20:13
|
LL | let y = &mut x;
| ^^^^^^
// run-pass
-#![feature(const_fn)]
#![feature(const_unreachable_unchecked)]
const unsafe fn foo(x: bool) -> bool {
// build-fail
-#![feature(const_fn)]
#![feature(const_unreachable_unchecked)]
const unsafe fn foo(x: bool) -> bool {
| |
| entering unreachable code
| inside `unreachable_unchecked` at $SRC_DIR/core/src/hint.rs:LL:COL
- | inside `foo` at $DIR/const_unsafe_unreachable_ub.rs:9:18
- | inside `BAR` at $DIR/const_unsafe_unreachable_ub.rs:14:28
+ | inside `foo` at $DIR/const_unsafe_unreachable_ub.rs:8:18
+ | inside `BAR` at $DIR/const_unsafe_unreachable_ub.rs:13:28
|
- ::: $DIR/const_unsafe_unreachable_ub.rs:14:1
+ ::: $DIR/const_unsafe_unreachable_ub.rs:13:1
|
LL | const BAR: bool = unsafe { foo(false) };
| ----------------------------------------
|
note: the lint level is defined here
- --> $DIR/const_unsafe_unreachable_ub.rs:13:8
+ --> $DIR/const_unsafe_unreachable_ub.rs:12:8
|
LL | #[warn(const_err)]
| ^^^^^^^^^
= note: for more information, see issue #71800 <https://github.com/rust-lang/rust/issues/71800>
error[E0080]: evaluation of constant value failed
- --> $DIR/const_unsafe_unreachable_ub.rs:17:14
+ --> $DIR/const_unsafe_unreachable_ub.rs:16:14
|
LL | assert_eq!(BAR, true);
| ^^^ referenced constant has errors
error: erroneous constant used
- --> $DIR/const_unsafe_unreachable_ub.rs:17:3
+ --> $DIR/const_unsafe_unreachable_ub.rs:16:3
|
LL | assert_eq!(BAR, true);
| ^^^^^^^^^^^^^^^^^^^^^^ referenced constant has errors
// run-pass
#![feature(const_panic)]
-#![feature(const_fn)]
const X: u32 = 4;
const Y: u32 = 5;
we're apparently really bad at it",
issue = "none")]
-#![feature(const_fn, const_fn_floating_point_arithmetic, foo, foo2)]
+#![feature(const_fn_floating_point_arithmetic, foo, foo2)]
#![feature(staged_api)]
#[stable(feature = "rust1", since = "1.0.0")]
we're apparently really bad at it",
issue = "none")]
-#![feature(const_fn, const_fn_floating_point_arithmetic, foo, foo2)]
+#![feature(const_fn_floating_point_arithmetic, foo, foo2)]
#![feature(staged_api)]
#[stable(feature = "rust1", since = "1.0.0")]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_stable(feature = "rust1", since = "1.0.0")]
-// conformity is required, even with `const_fn` feature gate
+// conformity is required
const unsafe fn bar3() -> u32 { (5f32 + 6f32) as u32 }
//~^ ERROR const-stable function cannot use `#[feature(const_fn_floating_point_arithmetic)]`
we're apparently really bad at it",
issue = "none")]
-#![feature(const_fn, foo, foo2)]
+#![feature(foo, foo2)]
#![feature(staged_api)]
#[stable(feature = "rust1", since = "1.0.0")]
LL | unsafe { intrinsics::ptr_offset_from(self, origin) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
- | inbounds test failed: 0x0 is not a valid pointer
+ | null pointer is not allowed for this operation
| inside `ptr::const_ptr::<impl *const u8>::offset_from` at $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
| inside `OFFSET_FROM_NULL` at $DIR/offset_from_ub.rs:36:14
|
LL | unsafe { intrinsics::offset(self, count) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
- | inbounds test failed: pointer must be in-bounds at offset 2, but is outside bounds of allocN which has size 1
+ | pointer arithmetic failed: pointer must be in-bounds at offset 2, but is outside bounds of allocN which has size 1
| inside `ptr::const_ptr::<impl *const u8>::offset` at $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
| inside `AFTER_END` at $DIR/offset_ub.rs:7:43
|
LL | unsafe { intrinsics::offset(self, count) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
- | inbounds test failed: pointer must be in-bounds at offset 101, but is outside bounds of allocN which has size 100
+ | pointer arithmetic failed: pointer must be in-bounds at offset 101, but is outside bounds of allocN which has size 100
| inside `ptr::const_ptr::<impl *const u8>::offset` at $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
| inside `AFTER_ARRAY` at $DIR/offset_ub.rs:8:45
|
LL | unsafe { intrinsics::offset(self, count) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
- | inbounds test failed: pointer must be in-bounds at offset 1, but is outside bounds of allocN which has size 0
+ | pointer arithmetic failed: pointer must be in-bounds at offset 1, but is outside bounds of allocN which has size 0
| inside `ptr::const_ptr::<impl *const u8>::offset` at $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
| inside `ZERO_SIZED_ALLOC` at $DIR/offset_ub.rs:15:50
|
LL | unsafe { intrinsics::offset(self, count) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
- | inbounds test failed: 0x0 is not a valid pointer
+ | pointer arithmetic failed: 0x0 is not a valid pointer
| inside `ptr::const_ptr::<impl *const u8>::offset` at $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
| inside `NULL_OFFSET_ZERO` at $DIR/offset_ub.rs:19:50
|
// ignore-tidy-linelength
// Test various things that we do not want to promote.
#![allow(unconditional_panic, const_err)]
-#![feature(const_fn, const_fn_union)]
+#![feature(const_fn_union)]
use std::cell::Cell;
LL | unsafe { intrinsics::offset(self, count) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
- | inbounds test failed: pointer must be in-bounds at offset $TWO_WORDS, but is outside bounds of alloc2 which has size $WORD
+ | pointer arithmetic failed: pointer must be in-bounds at offset $TWO_WORDS, but is outside bounds of alloc2 which has size $WORD
| inside `ptr::const_ptr::<impl *const usize>::offset` at $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
| inside `_` at $DIR/ptr_comparisons.rs:61:34
|
-#![feature(rustc_attrs, const_fn)]
+#![feature(rustc_attrs)]
#[rustc_args_required_const(0)]
fn foo(_a: i32) {
#![stable(feature = "core", since = "1.6.0")]
#![feature(staged_api)]
-#![feature(const_precise_live_drops, const_fn)]
+#![feature(const_precise_live_drops)]
enum Either<T, S> {
Left(T),
--- /dev/null
+// edition:2018
+#[deny(bare_trait_objects)]
+
+fn function(x: &SomeTrait, y: Box<SomeTrait>) {
+ //~^ ERROR trait objects without an explicit `dyn` are deprecated
+ //~| WARN this was previously accepted
+ //~| ERROR trait objects without an explicit `dyn` are deprecated
+ //~| WARN this was previously accepted
+ let _x: &SomeTrait = todo!();
+ //~^ ERROR trait objects without an explicit `dyn` are deprecated
+ //~| WARN this was previously accepted
+}
+
+trait SomeTrait {}
+
+fn main() {}
--- /dev/null
+error: trait objects without an explicit `dyn` are deprecated
+ --> $DIR/dyn-2018-edition-lint.rs:4:17
+ |
+LL | fn function(x: &SomeTrait, y: Box<SomeTrait>) {
+ | ^^^^^^^^^ help: use `dyn`: `dyn SomeTrait`
+ |
+note: the lint level is defined here
+ --> $DIR/dyn-2018-edition-lint.rs:2:8
+ |
+LL | #[deny(bare_trait_objects)]
+ | ^^^^^^^^^^^^^^^^^^
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
+
+error: trait objects without an explicit `dyn` are deprecated
+ --> $DIR/dyn-2018-edition-lint.rs:4:35
+ |
+LL | fn function(x: &SomeTrait, y: Box<SomeTrait>) {
+ | ^^^^^^^^^ help: use `dyn`: `dyn SomeTrait`
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
+
+error: trait objects without an explicit `dyn` are deprecated
+ --> $DIR/dyn-2018-edition-lint.rs:9:14
+ |
+LL | let _x: &SomeTrait = todo!();
+ | ^^^^^^^^^ help: use `dyn`: `dyn SomeTrait`
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
+
+error: aborting due to 3 previous errors
+
--- /dev/null
+// edition:2021
+
+fn function(x: &SomeTrait, y: Box<SomeTrait>) {
+ //~^ ERROR trait objects must include the `dyn` keyword
+ //~| ERROR trait objects must include the `dyn` keyword
+ let _x: &SomeTrait = todo!();
+ //~^ ERROR trait objects must include the `dyn` keyword
+}
+
+trait SomeTrait {}
+
+fn main() {}
--- /dev/null
+error[E0782]: trait objects must include the `dyn` keyword
+ --> $DIR/dyn-2021-edition-error.rs:6:14
+ |
+LL | let _x: &SomeTrait = todo!();
+ | ^^^^^^^^^
+ |
+help: add `dyn` keyword before this trait
+ |
+LL | let _x: &dyn SomeTrait = todo!();
+ | ^^^
+
+error[E0782]: trait objects must include the `dyn` keyword
+ --> $DIR/dyn-2021-edition-error.rs:3:17
+ |
+LL | fn function(x: &SomeTrait, y: Box<SomeTrait>) {
+ | ^^^^^^^^^
+ |
+help: add `dyn` keyword before this trait
+ |
+LL | fn function(x: &dyn SomeTrait, y: Box<SomeTrait>) {
+ | ^^^
+
+error[E0782]: trait objects must include the `dyn` keyword
+ --> $DIR/dyn-2021-edition-error.rs:3:35
+ |
+LL | fn function(x: &SomeTrait, y: Box<SomeTrait>) {
+ | ^^^^^^^^^
+ |
+help: add `dyn` keyword before this trait
+ |
+LL | fn function(x: &SomeTrait, y: Box<dyn SomeTrait>) {
+ | ^^^
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0782`.
error[E0532]: expected tuple struct or tuple variant, found unit struct `Empty2`
--> $DIR/empty-struct-unit-pat.rs:21:9
|
+LL | struct Empty2;
+ | -------------- `Empty2` defined here
+...
LL | Empty2() => ()
- | ^^^^^^ help: a tuple struct with a similar name exists: `XEmpty6`
+ | ^^^^^^^^
|
::: $DIR/auxiliary/empty-struct.rs:3:1
|
LL | pub struct XEmpty6();
| --------------------- similarly named tuple struct `XEmpty6` defined here
+ |
+help: use this syntax instead
+ |
+LL | Empty2 => ()
+ | ^^^^^^
+help: a tuple struct with a similar name exists
+ |
+LL | XEmpty6() => ()
+ | ^^^^^^^
error[E0532]: expected tuple struct or tuple variant, found unit struct `XEmpty2`
--> $DIR/empty-struct-unit-pat.rs:24:9
|
LL | XEmpty2() => ()
- | ^^^^^^^ help: a tuple struct with a similar name exists: `XEmpty6`
+ | ^^^^^^^^^
|
- ::: $DIR/auxiliary/empty-struct.rs:3:1
+ ::: $DIR/auxiliary/empty-struct.rs:2:1
|
+LL | pub struct XEmpty2;
+ | ------------------- `XEmpty2` defined here
LL | pub struct XEmpty6();
| --------------------- similarly named tuple struct `XEmpty6` defined here
+ |
+help: use this syntax instead
+ |
+LL | XEmpty2 => ()
+ | ^^^^^^^
+help: a tuple struct with a similar name exists
+ |
+LL | XEmpty6() => ()
+ | ^^^^^^^
error[E0532]: expected tuple struct or tuple variant, found unit struct `Empty2`
--> $DIR/empty-struct-unit-pat.rs:28:9
|
+LL | struct Empty2;
+ | -------------- `Empty2` defined here
+...
LL | Empty2(..) => ()
- | ^^^^^^ help: a tuple struct with a similar name exists: `XEmpty6`
+ | ^^^^^^^^^^
|
::: $DIR/auxiliary/empty-struct.rs:3:1
|
LL | pub struct XEmpty6();
| --------------------- similarly named tuple struct `XEmpty6` defined here
+ |
+help: use this syntax instead
+ |
+LL | Empty2 => ()
+ | ^^^^^^
+help: a tuple struct with a similar name exists
+ |
+LL | XEmpty6(..) => ()
+ | ^^^^^^^
error[E0532]: expected tuple struct or tuple variant, found unit struct `XEmpty2`
--> $DIR/empty-struct-unit-pat.rs:32:9
|
LL | XEmpty2(..) => ()
- | ^^^^^^^ help: a tuple struct with a similar name exists: `XEmpty6`
+ | ^^^^^^^^^^^
|
- ::: $DIR/auxiliary/empty-struct.rs:3:1
+ ::: $DIR/auxiliary/empty-struct.rs:2:1
|
+LL | pub struct XEmpty2;
+ | ------------------- `XEmpty2` defined here
LL | pub struct XEmpty6();
| --------------------- similarly named tuple struct `XEmpty6` defined here
+ |
+help: use this syntax instead
+ |
+LL | XEmpty2 => ()
+ | ^^^^^^^
+help: a tuple struct with a similar name exists
+ |
+LL | XEmpty6(..) => ()
+ | ^^^^^^^
error[E0532]: expected tuple struct or tuple variant, found unit variant `E::Empty4`
--> $DIR/empty-struct-unit-pat.rs:37:9
|
+LL | Empty4
+ | ------ `E::Empty4` defined here
+...
LL | E::Empty4() => ()
- | ^^^^^^^^^ not a tuple struct or tuple variant
+ | ^^^^^^^^^^^ help: use this syntax instead: `E::Empty4`
error[E0532]: expected tuple struct or tuple variant, found unit variant `XE::XEmpty4`
--> $DIR/empty-struct-unit-pat.rs:41:9
|
LL | XE::XEmpty4() => (),
- | ^^^^-------
- | |
- | help: a tuple variant with a similar name exists: `XEmpty5`
+ | ^^^^^^^^^^^^^
|
- ::: $DIR/auxiliary/empty-struct.rs:8:5
+ ::: $DIR/auxiliary/empty-struct.rs:7:5
|
+LL | XEmpty4,
+ | ------- `XE::XEmpty4` defined here
LL | XEmpty5(),
| --------- similarly named tuple variant `XEmpty5` defined here
+ |
+help: use this syntax instead
+ |
+LL | XE::XEmpty4 => (),
+ | ^^^^^^^^^^^
+help: a tuple variant with a similar name exists
+ |
+LL | XE::XEmpty5() => (),
+ | ^^^^^^^
error[E0532]: expected tuple struct or tuple variant, found unit variant `E::Empty4`
--> $DIR/empty-struct-unit-pat.rs:46:9
|
+LL | Empty4
+ | ------ `E::Empty4` defined here
+...
LL | E::Empty4(..) => ()
- | ^^^^^^^^^ not a tuple struct or tuple variant
+ | ^^^^^^^^^^^^^ help: use this syntax instead: `E::Empty4`
error[E0532]: expected tuple struct or tuple variant, found unit variant `XE::XEmpty4`
--> $DIR/empty-struct-unit-pat.rs:50:9
|
LL | XE::XEmpty4(..) => (),
- | ^^^^-------
- | |
- | help: a tuple variant with a similar name exists: `XEmpty5`
+ | ^^^^^^^^^^^^^^^
|
- ::: $DIR/auxiliary/empty-struct.rs:8:5
+ ::: $DIR/auxiliary/empty-struct.rs:7:5
|
+LL | XEmpty4,
+ | ------- `XE::XEmpty4` defined here
LL | XEmpty5(),
| --------- similarly named tuple variant `XEmpty5` defined here
+ |
+help: use this syntax instead
+ |
+LL | XE::XEmpty4 => (),
+ | ^^^^^^^^^^^
+help: a tuple variant with a similar name exists
+ |
+LL | XE::XEmpty5(..) => (),
+ | ^^^^^^^
error: aborting due to 8 previous errors
--- /dev/null
+pub fn boilerplate() {}
--- /dev/null
+#![feature(imported_main)]
+//~^ ERROR `main` is ambiguous (glob import vs glob import in the same module)
+mod m1 { pub(crate) fn main() {} }
+mod m2 { pub(crate) fn main() {} }
+
+use m1::*;
+use m2::*;
--- /dev/null
+error[E0659]: `main` is ambiguous (glob import vs glob import in the same module)
+ |
+note: `main` could refer to the function imported here
+ --> $DIR/imported_main_conflict.rs:6:5
+ |
+LL | use m1::*;
+ | ^^^^^
+ = help: consider adding an explicit import of `main` to disambiguate
+note: `main` could also refer to the function imported here
+ --> $DIR/imported_main_conflict.rs:7:5
+ |
+LL | use m2::*;
+ | ^^^^^
+ = help: consider adding an explicit import of `main` to disambiguate
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0659`.
--- /dev/null
+#![feature(imported_main)]
+#![feature(min_type_alias_impl_trait, impl_trait_in_bindings)]
+#![allow(incomplete_features)]
+//~^^^ ERROR `main` function not found in crate
+pub mod foo {
+ type MainFn = impl Fn();
+
+ fn bar() {}
+ pub const BAR: MainFn = bar;
+}
+
+use foo::BAR as main;
--- /dev/null
+error[E0601]: `main` function not found in crate `imported_main_const_fn_item_type_forbidden`
+ --> $DIR/imported_main_const_fn_item_type_forbidden.rs:1:1
+ |
+LL | / #![feature(imported_main)]
+LL | | #![feature(min_type_alias_impl_trait, impl_trait_in_bindings)]
+LL | | #![allow(incomplete_features)]
+LL | |
+... |
+LL | |
+LL | | use foo::BAR as main;
+ | |_____----------------^ consider adding a `main` function to `$DIR/imported_main_const_fn_item_type_forbidden.rs`
+ | |
+ | non-function item at `crate::main` is found
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0601`.
--- /dev/null
+#![feature(imported_main)]
+//~^ ERROR `main` function not found in crate
+pub mod foo {
+ pub const BAR: usize = 42;
+}
+
+use foo::BAR as main;
--- /dev/null
+error[E0601]: `main` function not found in crate `imported_main_const_forbidden`
+ --> $DIR/imported_main_const_forbidden.rs:1:1
+ |
+LL | / #![feature(imported_main)]
+LL | |
+LL | | pub mod foo {
+LL | | pub const BAR: usize = 42;
+LL | | }
+LL | |
+LL | | use foo::BAR as main;
+ | |_____----------------^ consider adding a `main` function to `$DIR/imported_main_const_forbidden.rs`
+ | |
+ | non-function item at `crate::main` is found
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0601`.
--- /dev/null
+// build-fail
+// aux-build:main_functions.rs
+
+#![feature(imported_main)]
+
+extern crate main_functions;
+pub use main_functions::boilerplate as main; //~ ERROR entry symbol `main` from foreign crate
+
+// FIXME: Should be run-pass
--- /dev/null
+error: entry symbol `main` from foreign crate is not yet supported.
+ --> $DIR/imported_main_from_extern_crate.rs:7:9
+ |
+LL | pub use main_functions::boilerplate as main;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: see issue #28937 <https://github.com/rust-lang/rust/issues/28937> for more information
+
+error: aborting due to previous error
+
--- /dev/null
+// run-pass
+#![feature(imported_main)]
+
+pub mod foo {
+ pub fn bar() {
+ println!("Hello world!");
+ }
+}
+use foo::bar as main;
--- /dev/null
+// check-pass
+#![feature(rustc_attrs)]
+
+#[rustc_main]
+fn actual_main() {}
+
+mod foo {
+ pub(crate) fn something() {}
+}
+
+use foo::something as main;
| ^ unused parameter
|
= help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `T` to be a const parameter, use `const T: usize` instead
error: aborting due to 2 previous errors
| ^ unused parameter
|
= help: consider removing `S`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `S` to be a const parameter, use `const S: usize` instead
error: aborting due to 2 previous errors
| ^ unused parameter
|
= help: consider removing `S`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `S` to be a const parameter, use `const S: usize` instead
error: aborting due to 2 previous errors
| ^ unused parameter
|
= help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `T` to be a const parameter, use `const T: usize` instead
error: aborting due to previous error
LL | let x = move || {
| ^^^^^^^ move out of `fancy_num` occurs here
LL | println!("child function: {}", fancy_num.num);
- | --------- move occurs due to use in closure
+ | ------------- move occurs due to use in closure
...
LL | println!("main function: {}", fancy_ref.num);
| ------------- borrow later used here
LL | mod module_that_doesnt_exist;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = help: to create the module `module_that_doesnt_exist`, create file "$DIR/module_that_doesnt_exist.rs"
+ = help: to create the module `module_that_doesnt_exist`, create file "$DIR/module_that_doesnt_exist.rs" or "$DIR/module_that_doesnt_exist/mod.rs"
error: aborting due to previous error
--- /dev/null
+pub mod foo {
+ pub fn bar() {
+ println!("Hello world!");
+ }
+}
+use foo::bar as main; //~ ERROR using an imported function as entry point
--- /dev/null
+error[E0658]: using an imported function as entry point `main` is experimental
+ --> $DIR/feature-gate-imported_main.rs:6:5
+ |
+LL | use foo::bar as main;
+ | ^^^^^^^^^^^^^^^^
+ |
+ = note: see issue #28937 <https://github.com/rust-lang/rust/issues/28937> for more information
+ = help: add `#![feature(imported_main)]` to the crate attributes to enable
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0658`.
--- /dev/null
+#[link(name = "foo", modifiers = "")]
+//~^ ERROR: native link modifiers are experimental
+extern "C" {}
+
+fn main() {}
--- /dev/null
+error[E0658]: native link modifiers are experimental
+ --> $DIR/feature-gate-native_link_modifiers.rs:1:22
+ |
+LL | #[link(name = "foo", modifiers = "")]
+ | ^^^^^^^^^^^^^^
+ |
+ = note: see issue #81490 <https://github.com/rust-lang/rust/issues/81490> for more information
+ = help: add `#![feature(native_link_modifiers)]` to the crate attributes to enable
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0658`.
--- /dev/null
+#![allow(incomplete_features)]
+#![feature(native_link_modifiers)]
+
+#[link(name = "foo", modifiers = "+as-needed")]
+//~^ ERROR: `#[link(modifiers="as-needed")]` is unstable
+extern "C" {}
+
+fn main() {}
--- /dev/null
+error[E0658]: `#[link(modifiers="as-needed")]` is unstable
+ --> $DIR/feature-gate-native_link_modifiers_as_needed.rs:4:34
+ |
+LL | #[link(name = "foo", modifiers = "+as-needed")]
+ | ^^^^^^^^^^^^
+ |
+ = note: see issue #81490 <https://github.com/rust-lang/rust/issues/81490> for more information
+ = help: add `#![feature(native_link_modifiers_as_needed)]` to the crate attributes to enable
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0658`.
--- /dev/null
+#![allow(incomplete_features)]
+#![feature(native_link_modifiers)]
+
+#[link(name = "foo", modifiers = "+bundle")]
+//~^ ERROR: `#[link(modifiers="bundle")]` is unstable
+extern "C" {}
+
+fn main() {}
--- /dev/null
+error[E0658]: `#[link(modifiers="bundle")]` is unstable
+ --> $DIR/feature-gate-native_link_modifiers_bundle.rs:4:34
+ |
+LL | #[link(name = "foo", modifiers = "+bundle")]
+ | ^^^^^^^^^
+ |
+ = note: see issue #81490 <https://github.com/rust-lang/rust/issues/81490> for more information
+ = help: add `#![feature(native_link_modifiers_bundle)]` to the crate attributes to enable
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0658`.
--- /dev/null
+#![allow(incomplete_features)]
+#![feature(native_link_modifiers)]
+
+#[link(name = "foo", modifiers = "+verbatim")]
+//~^ ERROR: `#[link(modifiers="verbatim")]` is unstable
+extern "C" {}
+
+fn main() {}
--- /dev/null
+error[E0658]: `#[link(modifiers="verbatim")]` is unstable
+ --> $DIR/feature-gate-native_link_modifiers_verbatim.rs:4:34
+ |
+LL | #[link(name = "foo", modifiers = "+verbatim")]
+ | ^^^^^^^^^^^
+ |
+ = note: see issue #81490 <https://github.com/rust-lang/rust/issues/81490> for more information
+ = help: add `#![feature(native_link_modifiers_verbatim)]` to the crate attributes to enable
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0658`.
--- /dev/null
+#![allow(incomplete_features)]
+#![feature(native_link_modifiers)]
+
+#[link(name = "foo", modifiers = "+whole-archive")]
+//~^ ERROR: `#[link(modifiers="whole-archive")]` is unstable
+extern "C" {}
+
+fn main() {}
--- /dev/null
+error[E0658]: `#[link(modifiers="whole-archive")]` is unstable
+ --> $DIR/feature-gate-native_link_modifiers_whole_archive.rs:4:34
+ |
+LL | #[link(name = "foo", modifiers = "+whole-archive")]
+ | ^^^^^^^^^^^^^^^^
+ |
+ = note: see issue #81490 <https://github.com/rust-lang/rust/issues/81490> for more information
+ = help: add `#![feature(native_link_modifiers_whole_archive)]` to the crate attributes to enable
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0658`.
#![crate_type = "lib"]
-#[no_coverage]
-#[feature(no_coverage)] // does not have to be enabled before `#[no_coverage]`
-fn no_coverage_is_enabled_on_this_function() {}
+#[derive(PartialEq, Eq)] // ensure deriving `Eq` does not enable `feature(no_coverage)`
+struct Foo {
+ a: u8,
+ b: u32,
+}
#[no_coverage] //~ ERROR the `#[no_coverage]` attribute is an experimental feature
-fn requires_feature_no_coverage() {}
+fn requires_feature_no_coverage() -> bool {
+ let bar = Foo { a: 0, b: 0 };
+ bar == Foo { a: 0, b: 0 }
+}
error[E0658]: the `#[no_coverage]` attribute is an experimental feature
- --> $DIR/feature-gate-no_coverage.rs:7:1
+ --> $DIR/feature-gate-no_coverage.rs:9:1
|
LL | #[no_coverage]
| ^^^^^^^^^^^^^^
|
= note: see issue #84605 <https://github.com/rust-lang/rust/issues/84605> for more information
= help: add `#![feature(no_coverage)]` to the crate attributes to enable
- = help: or, alternatively, add `#[feature(no_coverage)]` to the function
error: aborting due to previous error
+warning: library kind `static-nobundle` has been superseded by specifying `-bundle` on library kind `static`. Try `static:-bundle`
+
error[E0658]: kind="static-nobundle" is unstable
|
= note: see issue #37403 <https://github.com/rust-lang/rust/issues/37403> for more information
#[link(name = "foo", kind = "static-nobundle")]
-//~^ ERROR: kind="static-nobundle" is unstable
+//~^ WARNING: library kind `static-nobundle` has been superseded by specifying modifier `-bundle` with library kind `static`
+//~^^ ERROR: kind="static-nobundle" is unstable
extern "C" {}
fn main() {}
+warning: library kind `static-nobundle` has been superseded by specifying modifier `-bundle` with library kind `static`
+ --> $DIR/feature-gate-static-nobundle.rs:1:22
+ |
+LL | #[link(name = "foo", kind = "static-nobundle")]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+
error[E0658]: kind="static-nobundle" is unstable
--> $DIR/feature-gate-static-nobundle.rs:1:1
|
= note: see issue #37403 <https://github.com/rust-lang/rust/issues/37403> for more information
= help: add `#![feature(static_nobundle)]` to the crate attributes to enable
-error: aborting due to previous error
+error: aborting due to previous error; 1 warning emitted
For more information about this error, try `rustc --explain E0658`.
LL | *(1 as *mut u32) = 42;
| ^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
|
- = note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
+ = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: aborting due to previous error
LL | let mut b = || {
| -- generator construction occurs here
LL | let a = &mut *x;
- | - first borrow occurs due to use of `x` in generator
+ | -- first borrow occurs due to use of `x` in generator
...
LL | println!("{}", x);
| ^ second borrow occurs here
//~^ ERROR: lifetime in trait object type must be followed by `+`
//~| ERROR: parenthesized generic arguments cannot be used
//~| WARNING: trait objects without an explicit `dyn` are deprecated
+ //~| WARNING: this was previously accepted by the compiler
fn main() {}
| ^^ help: use `dyn`: `dyn 'a`
|
= note: `#[warn(bare_trait_objects)]` on by default
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error[E0107]: this associated type takes 1 lifetime argument but 0 lifetime arguments were supplied
--> $DIR/gat-trait-path-parenthesised-args.rs:5:8
| ^ unused parameter
|
= help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `T` to be a const parameter, use `const T: usize` instead
error: aborting due to 2 previous errors
target_os = "dragonfly",
target_os = "emscripten",
target_os = "freebsd",
+ target_os = "fuchsia",
target_os = "linux",
target_os = "macos",
target_os = "netbsd",
LL | pub mod baz;
| ^^^^^^^^^^^^
|
- = help: to create the module `baz`, create file "$DIR/auxiliary/foo/bar/baz.rs"
+ = help: to create the module `baz`, create file "$DIR/auxiliary/foo/bar/baz.rs" or "$DIR/auxiliary/foo/bar/baz/mod.rs"
error: aborting due to previous error
| ----------- mutable borrow occurs here
LL | println!("access {}", foo.x);
LL | ptr = box Foo { x: ptr.x + 1 };
- | --- first borrow occurs due to use of `ptr` in closure
+ | --- first borrow occurs due to use of `ptr` in closure
...
LL | test(&*ptr);
| ---- ^^^^^ immutable borrow occurs here
| ^ unused parameter
|
= help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `T` to be a const parameter, use `const T: usize` instead
error: aborting due to previous error
| ^ unused parameter
|
= help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `T` to be a const parameter, use `const T: usize` instead
error[E0275]: overflow evaluating the requirement `NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<NoData<T>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>: Foo`
--> $DIR/issue-20413.rs:8:36
| - value is immutable in match guard
...
LL | (|| { *x = None; drop(force_fn_once); })();
- | ^^ - borrow occurs due to use of `x` in closure
+ | ^^ -- borrow occurs due to use of `x` in closure
| |
| cannot mutably borrow
| --- value is immutable in match guard
...
LL | (|| { *x = &None; drop(force_fn_once); })();
- | ^^ - borrow occurs due to use of `x` in closure
+ | ^^ -- borrow occurs due to use of `x` in closure
| |
| cannot mutably borrow
error[E0532]: expected tuple struct or tuple variant, found unit struct `S`
--> $DIR/issue-32004.rs:16:9
|
+LL | struct S;
+ | --------- `S` defined here
+...
LL | S(()) => {}
- | ^ not a tuple struct or tuple variant
+ | ^^^^^ help: use this syntax instead: `S`
error: aborting due to 2 previous errors
| ^ unused parameter
|
= help: consider removing `A`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `A` to be a const parameter, use `const A: usize` instead
error: aborting due to 2 previous errors
| ^^^^ unused parameter
|
= help: consider removing `Self`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `Self` to be a const parameter, use `const Self: usize` instead
error: aborting due to 3 previous errors
| ^ unused parameter
|
= help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `T` to be a const parameter, use `const T: usize` instead
error: aborting due to 2 previous errors; 1 warning emitted
LL | match *ptr {}
| ^^^^ dereference of raw pointer
|
- = note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
+ = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: aborting due to 2 previous errors
--> $DIR/issue-61623.rs:6:19
|
LL | f2(|| x.0, f1(x.1))
- | -- -- - ^^^ mutable borrow occurs here
+ | -- -- --- ^^^ mutable borrow occurs here
| | | |
| | | first borrow occurs due to use of `x` in closure
| | immutable borrow occurs here
--> $DIR/issue-6801.rs:19:13
|
LL | let sq = || { *x * *x };
- | -- - borrow occurs due to use in closure
+ | -- -- borrow occurs due to use in closure
| |
| borrow of `x` occurs here
LL |
// run-pass
// compile-flags: -Zlink-native-libraries=no -Cdefault-linker-libraries=yes
// ignore-windows - this will probably only work on unixish systems
+// ignore-fuchsia - missing __libc_start_main for some reason (#84733)
#[link(name = "some-random-non-existent-library", kind = "static")]
extern "C" {}
error[E0532]: expected tuple struct or tuple variant, found unit variant `E::A`
--> $DIR/issue-pr29383.rs:9:14
|
+LL | A,
+ | - `E::A` defined here
+...
LL | Some(E::A(..)) => {}
- | ^^^^ not a tuple struct or tuple variant
+ | ^^^^^^^^ help: use this syntax instead: `E::A`
error[E0532]: expected tuple struct or tuple variant, found unit variant `E::B`
--> $DIR/issue-pr29383.rs:11:14
|
+LL | B,
+ | - `E::B` defined here
+...
LL | Some(E::B(..)) => {}
- | ^^^^ not a tuple struct or tuple variant
+ | ^^^^^^^^ help: use this syntax instead: `E::B`
error: aborting due to 2 previous errors
--- /dev/null
+// build-pass
+// compile-flags: --edition 2018
+// compile-flags: --crate-type rlib
+
+use std::future::Future;
+
+async fn handle<F>(slf: &F)
+where
+ F: Fn(&()) -> Box<dyn for<'a> Future<Output = ()> + Unpin>,
+{
+ (slf)(&()).await;
+}
+
+fn main() {}
--- /dev/null
+// check-pass
+
+pub trait Deserialize<'de>: Sized {}
+pub trait DeserializeOwned: for<'de> Deserialize<'de> {}
+
+pub trait Extensible {
+ type Config;
+}
+
+// The `C` here generates a `C: Sized` candidate
+pub trait Installer<C> {
+ fn init<B: Extensible<Config = C>>(&mut self) -> ()
+ where
+ // This clause generates a `for<'de> C: Sized` candidate
+ B::Config: DeserializeOwned,
+ {
+ }
+}
+
+fn main() {}
--- /dev/null
+// run-pass
+// compile-flags: -Zsymbol-mangling-version=v0
+
+pub fn f<T: ?Sized>() {}
+pub trait Frob<T: ?Sized> {}
+fn main() {
+ f::<dyn Frob<str>>();
+ f::<dyn for<'a> Frob<str>>();
+}
impl Assoc for dyn Dyn {}
fn main() {
- Dyn::func(); //~ WARN trait objects without an explicit `dyn` are deprecated
- ::Dyn::func(); //~ WARN trait objects without an explicit `dyn` are deprecated
- Dyn::CONST; //~ WARN trait objects without an explicit `dyn` are deprecated
+ Dyn::func();
+ //~^ WARN trait objects without an explicit `dyn` are deprecated
+ //~| WARN this was previously accepted by the compiler
+ ::Dyn::func();
+ //~^ WARN trait objects without an explicit `dyn` are deprecated
+ //~| WARN this was previously accepted by the compiler
+ Dyn::CONST;
+ //~^ WARN trait objects without an explicit `dyn` are deprecated
+ //~| WARN this was previously accepted by the compiler
let _: Dyn::Ty; //~ ERROR ambiguous associated type
}
error[E0223]: ambiguous associated type
- --> $DIR/bare-trait-objects-path.rs:17:12
+ --> $DIR/bare-trait-objects-path.rs:23:12
|
LL | let _: Dyn::Ty;
| ^^^^^^^ help: use fully-qualified syntax: `<dyn Dyn as Trait>::Ty`
| ^^^ help: use `dyn`: `<dyn Dyn>`
|
= note: `#[warn(bare_trait_objects)]` on by default
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
warning: trait objects without an explicit `dyn` are deprecated
- --> $DIR/bare-trait-objects-path.rs:15:5
+ --> $DIR/bare-trait-objects-path.rs:17:5
|
LL | ::Dyn::func();
| ^^^^^ help: use `dyn`: `<dyn (::Dyn)>`
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
warning: trait objects without an explicit `dyn` are deprecated
- --> $DIR/bare-trait-objects-path.rs:16:5
+ --> $DIR/bare-trait-objects-path.rs:20:5
|
LL | Dyn::CONST;
| ^^^ help: use `dyn`: `<dyn Dyn>`
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: aborting due to previous error; 3 warnings emitted
// Test that attributes on parens get concatenated
// in the expected order in the hir folder.
- #[deny(non_snake_case)] (
- #![allow(non_snake_case)]
+ #[deny(non_snake_case)] #[allow(non_snake_case)] (
{
let X = 0;
let _ = X;
}
);
- #[allow(non_snake_case)] (
- #![deny(non_snake_case)]
+ #[allow(non_snake_case)] #[deny(non_snake_case)] (
{
let X = 0; //~ ERROR snake case name
let _ = X;
error: variable `X` should have a snake case name
- --> $DIR/expr_attr_paren_order.rs:19:17
+ --> $DIR/expr_attr_paren_order.rs:17:17
|
LL | let X = 0;
| ^ help: convert the identifier to snake case (notice the capitalization): `x`
|
note: the lint level is defined here
- --> $DIR/expr_attr_paren_order.rs:17:17
+ --> $DIR/expr_attr_paren_order.rs:15:37
|
-LL | #![deny(non_snake_case)]
- | ^^^^^^^^^^^^^^
+LL | #[allow(non_snake_case)] #[deny(non_snake_case)] (
+ | ^^^^^^^^^^^^^^
error: aborting due to previous error
match despondency {
1..=2 => {}
//~^ WARN `...` range patterns are deprecated
+ //~| WARN this was previously accepted by the compiler
_ => {}
}
match &despondency {
&(1..=2) => {}
//~^ WARN `...` range patterns are deprecated
+ //~| WARN this was previously accepted by the compiler
_ => {}
}
}
match despondency {
1...2 => {}
//~^ WARN `...` range patterns are deprecated
+ //~| WARN this was previously accepted by the compiler
_ => {}
}
match &despondency {
&1...2 => {}
//~^ WARN `...` range patterns are deprecated
+ //~| WARN this was previously accepted by the compiler
_ => {}
}
}
|
LL | #![warn(ellipsis_inclusive_range_patterns)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
warning: `...` range patterns are deprecated
- --> $DIR/inclusive-range-pattern-syntax.rs:15:9
+ --> $DIR/inclusive-range-pattern-syntax.rs:16:9
|
LL | &1...2 => {}
| ^^^^^^ help: use `..=` for an inclusive range: `&(1..=2)`
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
warning: 2 warnings emitted
error[E0532]: expected tuple struct or tuple variant, found unit variant `Color::NoColor`
--> $DIR/match-pattern-field-mismatch-2.rs:12:11
|
+LL | NoColor,
+ | ------- `Color::NoColor` defined here
+...
LL | Color::NoColor(_) => { }
- | ^^^^^^^^^^^^^^ not a tuple struct or tuple variant
+ | ^^^^^^^^^^^^^^^^^ help: use this syntax instead: `Color::NoColor`
error: aborting due to previous error
// run-fail
// revisions: foo bar
// should-fail
+// needs-run-enabled
//[foo] error-pattern:bar
//[bar] error-pattern:foo
LL | mod missing;
| ^^^^^^^^^^^^
|
- = help: to create the module `missing`, create file "$DIR/foo/missing.rs"
+ = help: to create the module `missing`, create file "$DIR/foo/missing.rs" or "$DIR/foo/missing/mod.rs"
error: aborting due to previous error
LL | mod missing;
| ^^^^^^^^^^^^
|
- = help: to create the module `missing`, create file "$DIR/foo_inline/inline/missing.rs"
+ = help: to create the module `missing`, create file "$DIR/foo_inline/inline/missing.rs" or "$DIR/foo_inline/inline/missing/mod.rs"
error: aborting due to previous error
-error[E0761]: file for module `mod_file_disambig_aux` found at both mod_file_disambig_aux.rs and mod_file_disambig_aux/mod.rs
+error[E0761]: file for module `mod_file_disambig_aux` found at both "$DIR/mod_file_disambig_aux.rs" and "$DIR/mod_file_disambig_aux/mod.rs"
--> $DIR/mod_file_disambig.rs:1:1
|
LL | mod mod_file_disambig_aux;
--- /dev/null
+// Unspecified kind should fail with an error
+
+// compile-flags: -l =mylib
+// error-pattern: unknown library kind ``, expected one of dylib, framework, or static
+
+fn main() {}
--- /dev/null
+error: unknown library kind ``, expected one of dylib, framework, or static
+
--- /dev/null
+// Unspecified kind should fail with an error
+
+// compile-flags: -l :+bundle=mylib
+// error-pattern: unknown library kind ``, expected one of dylib, framework, or static
+
+fn main() {}
--- /dev/null
+error: unknown library kind ``, expected one of dylib, framework, or static
+
LL | let r = &mut x;
| ------ borrow occurs here
LL | || *x = 2;
- | ^^ - second borrow occurs due to use of `x` in closure
+ | ^^ -- second borrow occurs due to use of `x` in closure
| |
| closure construction occurs here
LL | r.use_mut();
LL | let r = x;
| - value moved here
LL | || *x = String::new();
- | ^^ - borrow occurs due to use in closure
+ | ^^ -- borrow occurs due to use in closure
| |
| value borrowed here after move
--> $DIR/closure-borrow-spans.rs:65:13
|
LL | let f = || *x = 0;
- | -- - borrow occurs due to use in closure
+ | -- -- borrow occurs due to use in closure
| |
| borrow of `x` occurs here
LL | let y = x;
--> $DIR/closure-borrow-spans.rs:71:13
|
LL | let f = || *x = 0;
- | -- - first borrow occurs due to use of `x` in closure
+ | -- -- first borrow occurs due to use of `x` in closure
| |
| closure construction occurs here
LL | let y = &x;
--> $DIR/closure-borrow-spans.rs:77:13
|
LL | let f = || *x = 0;
- | -- - first borrow occurs due to use of `x` in closure
+ | -- -- first borrow occurs due to use of `x` in closure
| |
| closure construction occurs here
LL | let y = &mut x;
| - first borrow later used here
error[E0597]: `x` does not live long enough
- --> $DIR/closure-borrow-spans.rs:86:17
+ --> $DIR/closure-borrow-spans.rs:86:16
|
LL | f = || *x = 0;
- | -- ^ borrowed value does not live long enough
+ | -- ^^ borrowed value does not live long enough
| |
| value captured here
LL | }
--> $DIR/closure-borrow-spans.rs:93:5
|
LL | let f = || *x = 0;
- | -- - borrow occurs due to use in closure
+ | -- -- borrow occurs due to use in closure
| |
| borrow of `*x` occurs here
LL | *x = 1;
LL | | ||
| | ^^ cannot borrow as mutable
LL | | *x = 1;});
- | |__________-_____- in this closure
- | |
- | mutable borrow occurs due to use of `x` in closure
+ | |_________--_____- in this closure
+ | |
+ | mutable borrow occurs due to use of `x` in closure
error[E0596]: cannot borrow `x` as mutable, as it is a captured variable in a `Fn` closure
--> $DIR/closure-captures.rs:51:9
LL | | ||
| | ^^ cannot borrow as mutable
LL | | *x = 1;});
- | |__________-_____- in this closure
- | |
- | mutable borrow occurs due to use of `x` in closure
+ | |_________--_____- in this closure
+ | |
+ | mutable borrow occurs due to use of `x` in closure
error: aborting due to 12 previous errors
LL | x = 0;
| ^^^^^ assignment to borrowed `x` occurs here
LL | || *y;
- | - borrow later captured here by closure
+ | -- borrow later captured here by closure
error[E0506]: cannot assign to `x` because it is borrowed
--> $DIR/closure-use-spans.rs:11:5
LL | x = 0;
| ^^^^^ assignment to borrowed `x` occurs here
LL | || *y = 1;
- | - borrow later captured here by closure
+ | -- borrow later captured here by closure
error[E0506]: cannot assign to `x` because it is borrowed
--> $DIR/closure-use-spans.rs:17:5
--> $DIR/closures-in-loops.rs:20:16
|
LL | v.push(|| *x = String::new());
- | ^^ - borrows occur due to use of `x` in closure
+ | ^^ -- borrows occur due to use of `x` in closure
| |
| closures are constructed here in different iterations of loop
| |
LL | |
LL | | &self.number;
- | | ---- first borrow occurs due to use of `self` in closure
+ | | ----------- first borrow occurs due to use of `self` in closure
LL | | });
| |__________^ mutable borrow occurs here
// run-pass
// edition:2021
-// ignore-test
-// FIXME(mark-i-m): enable this test again when 2021 machinery is available
use Foo::*;
+#[allow(dead_code)]
#[derive(Eq, PartialEq, Debug)]
enum Foo {
A(u64),
// Tests that :pat in macros in edition 2021 allows top-level or-patterns.
// run-pass
-// ignore-test
// edition:2021
-// FIXME(mark-i-m): unignore when 2021 machinery is in place.
macro_rules! accept_pat {
($p:pat) => {};
// aux-build:weak-lang-items.rs
// error-pattern: `#[panic_handler]` function required, but not found
// error-pattern: language item required, but not found: `eh_personality`
+// needs-unwind since it affects the error output
// ignore-emscripten compiled with panic=abort, personality not required
#![no_std]
error[E0259]: the name `core` is defined multiple times
- --> $DIR/weak-lang-item.rs:8:1
+ --> $DIR/weak-lang-item.rs:9:1
|
LL | extern crate core;
| ^^^^^^^^^^^^^^^^^^ `core` reimported here
// build-fail
// compile-flags:-C panic=abort -C prefer-dynamic
+// needs-unwind
// ignore-musl - no dylibs here
// ignore-emscripten
// ignore-sgx no dynamic lib support
#![allow(unused_variables)]
// compile-flags:-C lto -C panic=unwind
+// needs-unwind
// no-prefer-dynamic
// ignore-emscripten no processes
// ignore-sgx no processes
// build-fail
+// needs-unwind
// aux-build:panic-runtime-unwind.rs
// aux-build:panic-runtime-abort.rs
// aux-build:wants-panic-runtime-unwind.rs
// build-fail
+// needs-unwind
// error-pattern:is incompatible with this crate's strategy of `unwind`
// aux-build:panic-runtime-abort.rs
// aux-build:panic-runtime-lang-items.rs
// build-fail
+// needs-unwind
// error-pattern:is incompatible with this crate's strategy of `unwind`
// aux-build:panic-runtime-abort.rs
// aux-build:wants-panic-runtime-abort.rs
//~^ ERROR `?` may only modify trait bounds, not lifetime bounds
//~| ERROR at least one trait is required for an object type
//~| WARN trait objects without an explicit `dyn` are deprecated
+//~| WARN this was previously accepted by the compiler
| ^^^^^^^ help: use `dyn`: `dyn (?'a) +`
|
= note: `#[warn(bare_trait_objects)]` on by default
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error[E0224]: at least one trait is required for an object type
--> $DIR/issue-68890-2.rs:3:14
fn y<'a>(y: &mut 'a + Send) {
//~^ ERROR expected a path on the left-hand side of `+`, not `&mut 'a`
//~| WARNING trait objects without an explicit `dyn` are deprecated
+ //~| WARN this was previously accepted by the compiler
//~| ERROR at least one trait is required for an object type
let z = y as &mut 'a + Send;
//~^ ERROR expected value, found trait `Send`
//~| WARNING trait objects without an explicit `dyn` are deprecated
+ //~| WARN this was previously accepted by the compiler
}
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0423]: expected value, found trait `Send`
- --> $DIR/issue-73568-lifetime-after-mut.rs:18:28
+ --> $DIR/issue-73568-lifetime-after-mut.rs:19:28
|
LL | let z = y as &mut 'a + Send;
| ^^^^ not a value
| ^^ help: use `dyn`: `dyn 'a`
|
= note: `#[warn(bare_trait_objects)]` on by default
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
warning: trait objects without an explicit `dyn` are deprecated
- --> $DIR/issue-73568-lifetime-after-mut.rs:18:23
+ --> $DIR/issue-73568-lifetime-after-mut.rs:19:23
|
LL | let z = y as &mut 'a + Send;
| ^^ help: use `dyn`: `dyn 'a`
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error[E0224]: at least one trait is required for an object type
--> $DIR/issue-73568-lifetime-after-mut.rs:14:18
//~^ ERROR lifetime in trait object type must be followed by `+`
//~| ERROR at least one trait is required for an object type
//~| WARN trait objects without an explicit `dyn` are deprecated
+ //~| WARN this was previously accepted by the compiler
}
| ^^^^^^^ help: use `dyn`: `dyn 'static`
|
= note: `#[warn(bare_trait_objects)]` on by default
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error[E0224]: at least one trait is required for an object type
--> $DIR/trait-object-macro-matcher.rs:11:8
LL | mod not_a_real_file;
| ^^^^^^^^^^^^^^^^^^^^
|
- = help: to create the module `not_a_real_file`, create file "$DIR/not_a_real_file.rs"
+ = help: to create the module `not_a_real_file`, create file "$DIR/not_a_real_file.rs" or "$DIR/not_a_real_file/mod.rs"
error[E0433]: failed to resolve: use of undeclared crate or module `mod_file_aux`
--> $DIR/mod_file_not_exist.rs:7:16
LL | mod not_a_real_file;
| ^^^^^^^^^^^^^^^^^^^^
|
- = help: to create the module `not_a_real_file`, create file "$DIR/not_a_real_file.rs"
+ = help: to create the module `not_a_real_file`, create file "$DIR/not_a_real_file.rs" or "$DIR/not_a_real_file/mod.rs"
error[E0433]: failed to resolve: use of undeclared crate or module `mod_file_aux`
--> $DIR/mod_file_not_exist_windows.rs:7:16
}
fn inclusive2_from_to() {
- if let 0...3 = 0 {} //~ ERROR `...` range patterns are deprecated
- if let 0...Y = 0 {} //~ ERROR `...` range patterns are deprecated
- if let X...3 = 0 {} //~ ERROR `...` range patterns are deprecated
- if let X...Y = 0 {} //~ ERROR `...` range patterns are deprecated
+ if let 0...3 = 0 {}
+ //~^ ERROR `...` range patterns are deprecated
+ //~| WARN this was previously accepted by the compiler
+ if let 0...Y = 0 {}
+ //~^ ERROR `...` range patterns are deprecated
+ //~| WARN this was previously accepted by the compiler
+ if let X...3 = 0 {}
+ //~^ ERROR `...` range patterns are deprecated
+ //~| WARN this was previously accepted by the compiler
+ if let X...Y = 0 {}
+ //~^ ERROR `...` range patterns are deprecated
+ //~| WARN this was previously accepted by the compiler
if let true...Y = 0 {} //~ ERROR only `char` and numeric types
//~^ ERROR `...` range patterns are deprecated
+ //~| WARN this was previously accepted by the compiler
if let X...true = 0 {} //~ ERROR only `char` and numeric types
//~^ ERROR `...` range patterns are deprecated
+ //~| WARN this was previously accepted by the compiler
if let .0...Y = 0 {} //~ ERROR mismatched types
//~^ ERROR float literals must have an integer part
+ //~| WARN this was previously accepted by the compiler
//~| ERROR `...` range patterns are deprecated
if let X... .0 = 0 {} //~ ERROR mismatched types
//~^ ERROR float literals must have an integer part
//~| ERROR `...` range patterns are deprecated
+ //~| WARN this was previously accepted by the compiler
}
fn exclusive_from() {
let $e1..$e2;
let $e1...$e2;
//~^ ERROR `...` range patterns are deprecated
+ //~| WARN this was previously accepted by the compiler
let $e1..=$e2;
}
}
| ^^ help: must have an integer part: `0.0`
error: float literals must have an integer part
- --> $DIR/recover-range-pats.rs:50:12
+ --> $DIR/recover-range-pats.rs:60:12
|
LL | if let .0...Y = 0 {}
| ^^ help: must have an integer part: `0.0`
error: float literals must have an integer part
- --> $DIR/recover-range-pats.rs:53:17
+ --> $DIR/recover-range-pats.rs:64:17
|
LL | if let X... .0 = 0 {}
| ^^ help: must have an integer part: `0.0`
error: float literals must have an integer part
- --> $DIR/recover-range-pats.rs:63:12
+ --> $DIR/recover-range-pats.rs:75:12
|
LL | if let .0.. = 0 {}
| ^^ help: must have an integer part: `0.0`
error[E0586]: inclusive range with no end
- --> $DIR/recover-range-pats.rs:69:13
+ --> $DIR/recover-range-pats.rs:81:13
|
LL | if let 0..= = 0 {}
| ^^^ help: use `..` instead
= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
error[E0586]: inclusive range with no end
- --> $DIR/recover-range-pats.rs:70:13
+ --> $DIR/recover-range-pats.rs:82:13
|
LL | if let X..= = 0 {}
| ^^^ help: use `..` instead
= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
error[E0586]: inclusive range with no end
- --> $DIR/recover-range-pats.rs:71:16
+ --> $DIR/recover-range-pats.rs:83:16
|
LL | if let true..= = 0 {}
| ^^^ help: use `..` instead
= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
error: float literals must have an integer part
- --> $DIR/recover-range-pats.rs:73:12
+ --> $DIR/recover-range-pats.rs:85:12
|
LL | if let .0..= = 0 {}
| ^^ help: must have an integer part: `0.0`
error[E0586]: inclusive range with no end
- --> $DIR/recover-range-pats.rs:73:14
+ --> $DIR/recover-range-pats.rs:85:14
|
LL | if let .0..= = 0 {}
| ^^^ help: use `..` instead
= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
error[E0586]: inclusive range with no end
- --> $DIR/recover-range-pats.rs:79:13
+ --> $DIR/recover-range-pats.rs:91:13
|
LL | if let 0... = 0 {}
| ^^^ help: use `..` instead
= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
error[E0586]: inclusive range with no end
- --> $DIR/recover-range-pats.rs:80:13
+ --> $DIR/recover-range-pats.rs:92:13
|
LL | if let X... = 0 {}
| ^^^ help: use `..` instead
= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
error[E0586]: inclusive range with no end
- --> $DIR/recover-range-pats.rs:81:16
+ --> $DIR/recover-range-pats.rs:93:16
|
LL | if let true... = 0 {}
| ^^^ help: use `..` instead
= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
error: float literals must have an integer part
- --> $DIR/recover-range-pats.rs:83:12
+ --> $DIR/recover-range-pats.rs:95:12
|
LL | if let .0... = 0 {}
| ^^ help: must have an integer part: `0.0`
error[E0586]: inclusive range with no end
- --> $DIR/recover-range-pats.rs:83:14
+ --> $DIR/recover-range-pats.rs:95:14
|
LL | if let .0... = 0 {}
| ^^^ help: use `..` instead
= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
error: float literals must have an integer part
- --> $DIR/recover-range-pats.rs:93:15
+ --> $DIR/recover-range-pats.rs:105:15
|
LL | if let .. .0 = 0 {}
| ^^ help: must have an integer part: `0.0`
error: float literals must have an integer part
- --> $DIR/recover-range-pats.rs:103:15
+ --> $DIR/recover-range-pats.rs:115:15
|
LL | if let ..=.0 = 0 {}
| ^^ help: must have an integer part: `0.0`
error: range-to patterns with `...` are not allowed
- --> $DIR/recover-range-pats.rs:109:12
+ --> $DIR/recover-range-pats.rs:121:12
|
LL | if let ...3 = 0 {}
| ^^^ help: use `..=` instead
error: range-to patterns with `...` are not allowed
- --> $DIR/recover-range-pats.rs:111:12
+ --> $DIR/recover-range-pats.rs:123:12
|
LL | if let ...Y = 0 {}
| ^^^ help: use `..=` instead
error: range-to patterns with `...` are not allowed
- --> $DIR/recover-range-pats.rs:113:12
+ --> $DIR/recover-range-pats.rs:125:12
|
LL | if let ...true = 0 {}
| ^^^ help: use `..=` instead
error: float literals must have an integer part
- --> $DIR/recover-range-pats.rs:116:15
+ --> $DIR/recover-range-pats.rs:128:15
|
LL | if let ....3 = 0 {}
| ^^ help: must have an integer part: `0.3`
error: range-to patterns with `...` are not allowed
- --> $DIR/recover-range-pats.rs:116:12
+ --> $DIR/recover-range-pats.rs:128:12
|
LL | if let ....3 = 0 {}
| ^^^ help: use `..=` instead
error: range-to patterns with `...` are not allowed
- --> $DIR/recover-range-pats.rs:137:17
+ --> $DIR/recover-range-pats.rs:150:17
|
LL | let ...$e;
| ^^^ help: use `..=` instead
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0586]: inclusive range with no end
- --> $DIR/recover-range-pats.rs:141:19
+ --> $DIR/recover-range-pats.rs:154:19
|
LL | let $e...;
| ^^^ help: use `..` instead
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0586]: inclusive range with no end
- --> $DIR/recover-range-pats.rs:142:19
+ --> $DIR/recover-range-pats.rs:155:19
|
LL | let $e..=;
| ^^^ help: use `..` instead
|
LL | #![deny(ellipsis_inclusive_range_patterns)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: `...` range patterns are deprecated
- --> $DIR/recover-range-pats.rs:43:13
+ --> $DIR/recover-range-pats.rs:45:13
|
LL | if let 0...Y = 0 {}
| ^^^ help: use `..=` for an inclusive range
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: `...` range patterns are deprecated
- --> $DIR/recover-range-pats.rs:44:13
+ --> $DIR/recover-range-pats.rs:48:13
|
LL | if let X...3 = 0 {}
| ^^^ help: use `..=` for an inclusive range
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: `...` range patterns are deprecated
- --> $DIR/recover-range-pats.rs:45:13
+ --> $DIR/recover-range-pats.rs:51:13
|
LL | if let X...Y = 0 {}
| ^^^ help: use `..=` for an inclusive range
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: `...` range patterns are deprecated
- --> $DIR/recover-range-pats.rs:46:16
+ --> $DIR/recover-range-pats.rs:54:16
|
LL | if let true...Y = 0 {}
| ^^^ help: use `..=` for an inclusive range
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: `...` range patterns are deprecated
- --> $DIR/recover-range-pats.rs:48:13
+ --> $DIR/recover-range-pats.rs:57:13
|
LL | if let X...true = 0 {}
| ^^^ help: use `..=` for an inclusive range
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: `...` range patterns are deprecated
- --> $DIR/recover-range-pats.rs:50:14
+ --> $DIR/recover-range-pats.rs:60:14
|
LL | if let .0...Y = 0 {}
| ^^^ help: use `..=` for an inclusive range
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: `...` range patterns are deprecated
- --> $DIR/recover-range-pats.rs:53:13
+ --> $DIR/recover-range-pats.rs:64:13
|
LL | if let X... .0 = 0 {}
| ^^^ help: use `..=` for an inclusive range
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: `...` range patterns are deprecated
- --> $DIR/recover-range-pats.rs:126:20
+ --> $DIR/recover-range-pats.rs:138:20
|
LL | let $e1...$e2;
| ^^^ help: use `..=` for an inclusive range
LL | mac2!(0, 1);
| ------------ in this macro invocation
|
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0029]: only `char` and numeric types are allowed in range patterns
| this is of type `u8`
error[E0029]: only `char` and numeric types are allowed in range patterns
- --> $DIR/recover-range-pats.rs:46:12
+ --> $DIR/recover-range-pats.rs:54:12
|
LL | if let true...Y = 0 {}
| ^^^^ - this is of type `u8`
| this is of type `bool` but it should be `char` or numeric
error[E0029]: only `char` and numeric types are allowed in range patterns
- --> $DIR/recover-range-pats.rs:48:16
+ --> $DIR/recover-range-pats.rs:57:16
|
LL | if let X...true = 0 {}
| - ^^^^ this is of type `bool` but it should be `char` or numeric
| this is of type `u8`
error[E0308]: mismatched types
- --> $DIR/recover-range-pats.rs:50:12
+ --> $DIR/recover-range-pats.rs:60:12
|
LL | if let .0...Y = 0 {}
| ^^ - this is of type `u8`
| expected integer, found floating-point number
error[E0308]: mismatched types
- --> $DIR/recover-range-pats.rs:53:17
+ --> $DIR/recover-range-pats.rs:64:17
|
LL | if let X... .0 = 0 {}
| - ^^ - this expression has type `u8`
| this is of type `u8`
error[E0029]: only `char` and numeric types are allowed in range patterns
- --> $DIR/recover-range-pats.rs:61:12
+ --> $DIR/recover-range-pats.rs:73:12
|
LL | if let true.. = 0 {}
| ^^^^ this is of type `bool` but it should be `char` or numeric
error[E0308]: mismatched types
- --> $DIR/recover-range-pats.rs:63:12
+ --> $DIR/recover-range-pats.rs:75:12
|
LL | if let .0.. = 0 {}
| ^^ expected integer, found floating-point number
error[E0029]: only `char` and numeric types are allowed in range patterns
- --> $DIR/recover-range-pats.rs:71:12
+ --> $DIR/recover-range-pats.rs:83:12
|
LL | if let true..= = 0 {}
| ^^^^ this is of type `bool` but it should be `char` or numeric
error[E0308]: mismatched types
- --> $DIR/recover-range-pats.rs:73:12
+ --> $DIR/recover-range-pats.rs:85:12
|
LL | if let .0..= = 0 {}
| ^^ expected integer, found floating-point number
error[E0029]: only `char` and numeric types are allowed in range patterns
- --> $DIR/recover-range-pats.rs:81:12
+ --> $DIR/recover-range-pats.rs:93:12
|
LL | if let true... = 0 {}
| ^^^^ this is of type `bool` but it should be `char` or numeric
error[E0308]: mismatched types
- --> $DIR/recover-range-pats.rs:83:12
+ --> $DIR/recover-range-pats.rs:95:12
|
LL | if let .0... = 0 {}
| ^^ expected integer, found floating-point number
error[E0029]: only `char` and numeric types are allowed in range patterns
- --> $DIR/recover-range-pats.rs:91:14
+ --> $DIR/recover-range-pats.rs:103:14
|
LL | if let ..true = 0 {}
| ^^^^ this is of type `bool` but it should be `char` or numeric
error[E0308]: mismatched types
- --> $DIR/recover-range-pats.rs:93:15
+ --> $DIR/recover-range-pats.rs:105:15
|
LL | if let .. .0 = 0 {}
| ^^ expected integer, found floating-point number
error[E0029]: only `char` and numeric types are allowed in range patterns
- --> $DIR/recover-range-pats.rs:101:15
+ --> $DIR/recover-range-pats.rs:113:15
|
LL | if let ..=true = 0 {}
| ^^^^ this is of type `bool` but it should be `char` or numeric
error[E0308]: mismatched types
- --> $DIR/recover-range-pats.rs:103:15
+ --> $DIR/recover-range-pats.rs:115:15
|
LL | if let ..=.0 = 0 {}
| ^^ expected integer, found floating-point number
error[E0029]: only `char` and numeric types are allowed in range patterns
- --> $DIR/recover-range-pats.rs:113:15
+ --> $DIR/recover-range-pats.rs:125:15
|
LL | if let ...true = 0 {}
| ^^^^ this is of type `bool` but it should be `char` or numeric
error[E0308]: mismatched types
- --> $DIR/recover-range-pats.rs:116:15
+ --> $DIR/recover-range-pats.rs:128:15
|
LL | if let ....3 = 0 {}
| ^^ expected integer, found floating-point number
//~^ ERROR an inner attribute is not permitted in this context
let b = (#![allow(warnings)] 1, 2);
+ //~^ ERROR an inner attribute is not permitted in this context
let c = {
#![allow(warnings)]
(#![allow(warnings)] 1, 2)
+ //~^ ERROR an inner attribute is not permitted in this context
};
let d = {
#![allow(warnings)]
let e = (#![allow(warnings)] 1, 2);
+ //~^ ERROR an inner attribute is not permitted in this context
e
};
+
+ let e = [#![allow(warnings)] 1, 2];
+ //~^ ERROR an inner attribute is not permitted in this context
+
+ let f = [#![allow(warnings)] 1; 0];
+ //~^ ERROR an inner attribute is not permitted in this context
+
+ let g = match true { #![allow(warnings)] _ => {} };
+ //~^ ERROR an inner attribute is not permitted in this context
+
+ struct MyStruct { field: u8 }
+ let h = MyStruct { #![allow(warnings)] field: 0 };
+ //~^ ERROR an inner attribute is not permitted in this context
}
|
= note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files. Outer attributes, like `#[test]`, annotate the item following them.
-error: aborting due to previous error
+error: an inner attribute is not permitted in this context
+ --> $DIR/stmt_expr_attrs_placement.rs:10:14
+ |
+LL | let b = (#![allow(warnings)] 1, 2);
+ | ^^^^^^^^^^^^^^^^^^^
+ |
+ = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files. Outer attributes, like `#[test]`, annotate the item following them.
+
+error: an inner attribute is not permitted in this context
+ --> $DIR/stmt_expr_attrs_placement.rs:15:10
+ |
+LL | (#![allow(warnings)] 1, 2)
+ | ^^^^^^^^^^^^^^^^^^^
+ |
+ = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files. Outer attributes, like `#[test]`, annotate the item following them.
+
+error: an inner attribute is not permitted in this context
+ --> $DIR/stmt_expr_attrs_placement.rs:21:18
+ |
+LL | let e = (#![allow(warnings)] 1, 2);
+ | ^^^^^^^^^^^^^^^^^^^
+ |
+ = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files. Outer attributes, like `#[test]`, annotate the item following them.
+
+error: an inner attribute is not permitted in this context
+ --> $DIR/stmt_expr_attrs_placement.rs:26:14
+ |
+LL | let e = [#![allow(warnings)] 1, 2];
+ | ^^^^^^^^^^^^^^^^^^^
+ |
+ = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files. Outer attributes, like `#[test]`, annotate the item following them.
+
+error: an inner attribute is not permitted in this context
+ --> $DIR/stmt_expr_attrs_placement.rs:29:14
+ |
+LL | let f = [#![allow(warnings)] 1; 0];
+ | ^^^^^^^^^^^^^^^^^^^
+ |
+ = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files. Outer attributes, like `#[test]`, annotate the item following them.
+
+error: an inner attribute is not permitted in this context
+ --> $DIR/stmt_expr_attrs_placement.rs:32:26
+ |
+LL | let g = match true { #![allow(warnings)] _ => {} };
+ | ^^^^^^^^^^^^^^^^^^^
+ |
+ = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files. Outer attributes, like `#[test]`, annotate the item following them.
+
+error: an inner attribute is not permitted in this context
+ --> $DIR/stmt_expr_attrs_placement.rs:36:24
+ |
+LL | let h = MyStruct { #![allow(warnings)] field: 0 };
+ | ^^^^^^^^^^^^^^^^^^^
+ |
+ = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files. Outer attributes, like `#[test]`, annotate the item following them.
+
+error: aborting due to 8 previous errors
--- /dev/null
+// edition:2018
+
+fn foo1(_: &dyn Drop + AsRef<str>) {} //~ ERROR ambiguous `+` in a type
+//~^ ERROR only auto traits can be used as additional traits in a trait object
+
+fn foo2(_: &dyn (Drop + AsRef<str>)) {} //~ ERROR incorrect braces around trait bounds
+
+fn foo3(_: &dyn {Drop + AsRef<str>}) {} //~ ERROR expected parameter name, found `{`
+//~^ ERROR expected one of `!`, `(`, `)`, `,`, `?`, `for`, lifetime, or path, found `{`
+//~| ERROR at least one trait is required for an object type
+
+fn foo4(_: &dyn <Drop + AsRef<str>>) {} //~ ERROR expected identifier, found `<`
+
+fn foo5(_: &(dyn Drop + dyn AsRef<str>)) {} //~ ERROR invalid `dyn` keyword
+//~^ ERROR only auto traits can be used as additional traits in a trait object
+
+fn main() {}
--- /dev/null
+error: ambiguous `+` in a type
+ --> $DIR/trait-object-delimiters.rs:3:13
+ |
+LL | fn foo1(_: &dyn Drop + AsRef<str>) {}
+ | ^^^^^^^^^^^^^^^^^^^^^ help: use parentheses to disambiguate: `(dyn Drop + AsRef<str>)`
+
+error: incorrect braces around trait bounds
+ --> $DIR/trait-object-delimiters.rs:6:17
+ |
+LL | fn foo2(_: &dyn (Drop + AsRef<str>)) {}
+ | ^ ^
+ |
+help: remove the parentheses
+ |
+LL | fn foo2(_: &dyn Drop + AsRef<str>) {}
+ | -- --
+
+error: expected parameter name, found `{`
+ --> $DIR/trait-object-delimiters.rs:8:17
+ |
+LL | fn foo3(_: &dyn {Drop + AsRef<str>}) {}
+ | ^ expected parameter name
+
+error: expected one of `!`, `(`, `)`, `,`, `?`, `for`, lifetime, or path, found `{`
+ --> $DIR/trait-object-delimiters.rs:8:17
+ |
+LL | fn foo3(_: &dyn {Drop + AsRef<str>}) {}
+ | -^ expected one of 8 possible tokens
+ | |
+ | help: missing `,`
+
+error: expected identifier, found `<`
+ --> $DIR/trait-object-delimiters.rs:12:17
+ |
+LL | fn foo4(_: &dyn <Drop + AsRef<str>>) {}
+ | ^ expected identifier
+
+error: invalid `dyn` keyword
+ --> $DIR/trait-object-delimiters.rs:14:25
+ |
+LL | fn foo5(_: &(dyn Drop + dyn AsRef<str>)) {}
+ | ^^^ help: remove this keyword
+ |
+ = help: `dyn` is only needed at the start of a trait `+`-separated list
+
+error[E0225]: only auto traits can be used as additional traits in a trait object
+ --> $DIR/trait-object-delimiters.rs:3:24
+ |
+LL | fn foo1(_: &dyn Drop + AsRef<str>) {}
+ | ---- ^^^^^^^^^^ additional non-auto trait
+ | |
+ | first non-auto trait
+ |
+ = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Drop + AsRef<str> {}`
+ = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
+
+error[E0224]: at least one trait is required for an object type
+ --> $DIR/trait-object-delimiters.rs:8:13
+ |
+LL | fn foo3(_: &dyn {Drop + AsRef<str>}) {}
+ | ^^^
+
+error[E0225]: only auto traits can be used as additional traits in a trait object
+ --> $DIR/trait-object-delimiters.rs:14:29
+ |
+LL | fn foo5(_: &(dyn Drop + dyn AsRef<str>)) {}
+ | ---- ^^^^^^^^^^ additional non-auto trait
+ | |
+ | first non-auto trait
+ |
+ = help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: Drop + AsRef<str> {}`
+ = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
+
+error: aborting due to 9 previous errors
+
+Some errors have detailed explanations: E0224, E0225.
+For more information about an error, try `rustc --explain E0224`.
//~^ ERROR `?Trait` is not permitted in trait object types
//~| ERROR only auto traits can be used as additional traits
//~| WARN trait objects without an explicit `dyn` are deprecated
- let _: Box<(?Sized) + (for<'a> Trait<'a>) + (Obj)>;
+ //~| WARN this was previously accepted by the compiler
+ let _: Box<?Sized + (for<'a> Trait<'a>) + (Obj)>;
//~^ ERROR `?Trait` is not permitted in trait object types
//~| ERROR only auto traits can be used as additional traits
//~| WARN trait objects without an explicit `dyn` are deprecated
- let _: Box<(for<'a> Trait<'a>) + (Obj) + (?Sized)>;
+ //~| WARN this was previously accepted by the compiler
+ let _: Box<for<'a> Trait<'a> + (Obj) + (?Sized)>;
//~^ ERROR `?Trait` is not permitted in trait object types
//~| ERROR only auto traits can be used as additional traits
//~| WARN trait objects without an explicit `dyn` are deprecated
+ //~| WARN this was previously accepted by the compiler
}
| ^^^^^^^^
error: `?Trait` is not permitted in trait object types
- --> $DIR/trait-object-trait-parens.rs:12:17
+ --> $DIR/trait-object-trait-parens.rs:13:16
|
-LL | let _: Box<(?Sized) + (for<'a> Trait<'a>) + (Obj)>;
- | ^^^^^^
+LL | let _: Box<?Sized + (for<'a> Trait<'a>) + (Obj)>;
+ | ^^^^^^
error: `?Trait` is not permitted in trait object types
- --> $DIR/trait-object-trait-parens.rs:16:46
+ --> $DIR/trait-object-trait-parens.rs:18:44
|
-LL | let _: Box<(for<'a> Trait<'a>) + (Obj) + (?Sized)>;
- | ^^^^^^^^
+LL | let _: Box<for<'a> Trait<'a> + (Obj) + (?Sized)>;
+ | ^^^^^^^^
warning: trait objects without an explicit `dyn` are deprecated
--> $DIR/trait-object-trait-parens.rs:8:16
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `dyn`: `dyn (Obj) + (?Sized) + (for<'a> Trait<'a>)`
|
= note: `#[warn(bare_trait_objects)]` on by default
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
warning: trait objects without an explicit `dyn` are deprecated
- --> $DIR/trait-object-trait-parens.rs:12:16
+ --> $DIR/trait-object-trait-parens.rs:13:16
|
-LL | let _: Box<(?Sized) + (for<'a> Trait<'a>) + (Obj)>;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `dyn`: `dyn (?Sized) + (for<'a> Trait<'a>) + (Obj)`
+LL | let _: Box<?Sized + (for<'a> Trait<'a>) + (Obj)>;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `dyn`: `dyn ?Sized + (for<'a> Trait<'a>) + (Obj)`
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
warning: trait objects without an explicit `dyn` are deprecated
- --> $DIR/trait-object-trait-parens.rs:16:16
+ --> $DIR/trait-object-trait-parens.rs:18:16
+ |
+LL | let _: Box<for<'a> Trait<'a> + (Obj) + (?Sized)>;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `dyn`: `dyn for<'a> Trait<'a> + (Obj) + (?Sized)`
|
-LL | let _: Box<(for<'a> Trait<'a>) + (Obj) + (?Sized)>;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `dyn`: `dyn (for<'a> Trait<'a>) + (Obj) + (?Sized)`
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/trait-object-trait-parens.rs:8:35
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
- --> $DIR/trait-object-trait-parens.rs:12:49
+ --> $DIR/trait-object-trait-parens.rs:13:47
|
-LL | let _: Box<(?Sized) + (for<'a> Trait<'a>) + (Obj)>;
- | ------------------- ^^^^^ additional non-auto trait
- | |
- | first non-auto trait
+LL | let _: Box<?Sized + (for<'a> Trait<'a>) + (Obj)>;
+ | ------------------- ^^^^^ additional non-auto trait
+ | |
+ | first non-auto trait
|
= help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: for<'a> Trait<'a> + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
- --> $DIR/trait-object-trait-parens.rs:16:38
+ --> $DIR/trait-object-trait-parens.rs:18:36
|
-LL | let _: Box<(for<'a> Trait<'a>) + (Obj) + (?Sized)>;
- | ----------------- ^^^^^ additional non-auto trait
- | |
- | first non-auto trait
+LL | let _: Box<for<'a> Trait<'a> + (Obj) + (?Sized)>;
+ | ----------------- ^^^^^ additional non-auto trait
+ | |
+ | first non-auto trait
|
= help: consider creating a new trait with all of these as super-traits and using that trait here instead: `trait NewTrait: for<'a> Trait<'a> + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
LL | unsafe mod n;
| ^^^^^^^^^^^^^
|
- = help: to create the module `n`, create file "$DIR/n.rs"
+ = help: to create the module `n`, create file "$DIR/n.rs" or "$DIR/n/mod.rs"
error: module cannot be declared unsafe
--> $DIR/unsafe-mod.rs:1:1
|
LL | B(isize, isize),
| --------------- similarly named tuple variant `B` defined here
+LL | C(isize, isize, isize),
+LL | D
+ | - `A::D` defined here
...
LL | A::D(_) => (),
- | ^^^-
- | |
- | help: a tuple variant with a similar name exists: `B`
+ | ^^^^^^^
+ |
+help: use this syntax instead
+ |
+LL | A::D => (),
+ | ^^^^
+help: a tuple variant with a similar name exists
+ |
+LL | A::B(_) => (),
+ | ^
error[E0023]: this pattern has 3 fields, but the corresponding tuple variant has 2 fields
--> $DIR/pattern-error-continue.rs:17:9
// compile-flags: -Z span-debug --error-format human
// aux-build:test-macros.rs
// edition:2018
+
#![feature(custom_inner_attributes)]
#![feature(proc_macro_hygiene)]
#![feature(stmt_expr_attributes)]
struct MyDerivePrint {
field: [u8; {
match true {
- #![cfg_attr(not(FALSE), rustc_dummy(first))]
- #![cfg_attr(not(FALSE), rustc_dummy(second))]
_ => {
#![cfg_attr(not(FALSE), rustc_dummy(third))]
true
}
fn bar() {
- (#![print_target_and_args(fifth)] 1, 2);
- //~^ ERROR expected non-macro inner attribute, found attribute macro
-
#[print_target_and_args(tuple_attrs)] (
- #![cfg_attr(FALSE, rustc_dummy)]
3, 4, {
#![cfg_attr(not(FALSE), rustc_dummy(innermost))]
5
}
);
- #[print_target_and_args(array_attrs)] [
- #![rustc_dummy(inner)]
- true; 0
- ];
-
#[print_target_and_args(tuple_attrs)] (
- #![cfg_attr(FALSE, rustc_dummy)]
3, 4, {
#![cfg_attr(not(FALSE), rustc_dummy(innermost))]
5
}
);
- #[print_target_and_args(array_attrs)] [
- #![rustc_dummy(inner)]
- true; 0
- ];
-
- [#![print_target_and_args(sixth)] 1 , 2];
- //~^ ERROR expected non-macro inner attribute, found attribute macro
- [#![print_target_and_args(seventh)] true ; 5];
- //~^ ERROR expected non-macro inner attribute, found attribute macro
-
- match 0 {
- #![print_target_and_args(eighth)]
- //~^ ERROR expected non-macro inner attribute, found attribute macro
- _ => {}
- }
-
- MyStruct { #![print_target_and_args(ninth)] field: true };
- //~^ ERROR expected non-macro inner attribute, found attribute macro
-
for _ in &[true] {
#![print_attr] //~ ERROR expected non-macro inner attribute
}
-error: expected non-macro inner attribute, found attribute macro `print_target_and_args`
- --> $DIR/inner-attrs.rs:49:9
- |
-LL | (#![print_target_and_args(fifth)] 1, 2);
- | ^^^^^^^^^^^^^^^^^^^^^ not a non-macro inner attribute
-
-error: expected non-macro inner attribute, found attribute macro `print_target_and_args`
- --> $DIR/inner-attrs.rs:78:9
- |
-LL | [#![print_target_and_args(sixth)] 1 , 2];
- | ^^^^^^^^^^^^^^^^^^^^^ not a non-macro inner attribute
-
-error: expected non-macro inner attribute, found attribute macro `print_target_and_args`
- --> $DIR/inner-attrs.rs:80:9
- |
-LL | [#![print_target_and_args(seventh)] true ; 5];
- | ^^^^^^^^^^^^^^^^^^^^^ not a non-macro inner attribute
-
-error: expected non-macro inner attribute, found attribute macro `print_target_and_args`
- --> $DIR/inner-attrs.rs:84:12
- |
-LL | #![print_target_and_args(eighth)]
- | ^^^^^^^^^^^^^^^^^^^^^ not a non-macro inner attribute
-
-error: expected non-macro inner attribute, found attribute macro `print_target_and_args`
- --> $DIR/inner-attrs.rs:89:19
- |
-LL | MyStruct { #![print_target_and_args(ninth)] field: true };
- | ^^^^^^^^^^^^^^^^^^^^^ not a non-macro inner attribute
-
error: expected non-macro inner attribute, found attribute macro `print_attr`
- --> $DIR/inner-attrs.rs:93:12
+ --> $DIR/inner-attrs.rs:63:12
|
LL | #![print_attr]
| ^^^^^^^^^^ not a non-macro inner attribute
error: expected non-macro inner attribute, found attribute macro `print_attr`
- --> $DIR/inner-attrs.rs:97:12
+ --> $DIR/inner-attrs.rs:67:12
|
LL | #![print_attr]
| ^^^^^^^^^^ not a non-macro inner attribute
error: expected non-macro inner attribute, found attribute macro `print_attr`
- --> $DIR/inner-attrs.rs:101:12
+ --> $DIR/inner-attrs.rs:71:12
|
LL | #![print_attr]
| ^^^^^^^^^^ not a non-macro inner attribute
error: expected non-macro inner attribute, found attribute macro `print_attr`
- --> $DIR/inner-attrs.rs:105:12
+ --> $DIR/inner-attrs.rs:75:12
|
LL | #![print_attr]
| ^^^^^^^^^^ not a non-macro inner attribute
-error: aborting due to 9 previous errors
+error: aborting due to 4 previous errors
PRINT-ATTR_ARGS INPUT (DEBUG): TokenStream [
Ident {
ident: "first",
- span: $DIR/inner-attrs.rs:15:25: 15:30 (#0),
+ span: $DIR/inner-attrs.rs:16:25: 16:30 (#0),
},
]
PRINT-ATTR INPUT (DISPLAY): #[print_target_and_args(second)] fn foo()
Punct {
ch: '#',
spacing: Alone,
- span: $DIR/inner-attrs.rs:16:1: 16:2 (#0),
+ span: $DIR/inner-attrs.rs:17:1: 17:2 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "print_target_and_args",
- span: $DIR/inner-attrs.rs:16:3: 16:24 (#0),
+ span: $DIR/inner-attrs.rs:17:3: 17:24 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "second",
- span: $DIR/inner-attrs.rs:16:25: 16:31 (#0),
+ span: $DIR/inner-attrs.rs:17:25: 17:31 (#0),
},
],
- span: $DIR/inner-attrs.rs:16:24: 16:32 (#0),
+ span: $DIR/inner-attrs.rs:17:24: 17:32 (#0),
},
],
- span: $DIR/inner-attrs.rs:16:2: 16:33 (#0),
+ span: $DIR/inner-attrs.rs:17:2: 17:33 (#0),
},
Ident {
ident: "fn",
- span: $DIR/inner-attrs.rs:17:1: 17:3 (#0),
+ span: $DIR/inner-attrs.rs:18:1: 18:3 (#0),
},
Ident {
ident: "foo",
- span: $DIR/inner-attrs.rs:17:4: 17:7 (#0),
+ span: $DIR/inner-attrs.rs:18:4: 18:7 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [],
- span: $DIR/inner-attrs.rs:17:7: 17:9 (#0),
+ span: $DIR/inner-attrs.rs:18:7: 18:9 (#0),
},
Group {
delimiter: Brace,
Punct {
ch: '#',
spacing: Joint,
- span: $DIR/inner-attrs.rs:18:5: 18:6 (#0),
+ span: $DIR/inner-attrs.rs:19:5: 19:6 (#0),
},
Punct {
ch: '!',
spacing: Alone,
- span: $DIR/inner-attrs.rs:18:6: 18:7 (#0),
+ span: $DIR/inner-attrs.rs:19:6: 19:7 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "print_target_and_args",
- span: $DIR/inner-attrs.rs:18:8: 18:29 (#0),
+ span: $DIR/inner-attrs.rs:19:8: 19:29 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "third",
- span: $DIR/inner-attrs.rs:18:30: 18:35 (#0),
+ span: $DIR/inner-attrs.rs:19:30: 19:35 (#0),
},
],
- span: $DIR/inner-attrs.rs:18:29: 18:36 (#0),
+ span: $DIR/inner-attrs.rs:19:29: 19:36 (#0),
},
],
- span: $DIR/inner-attrs.rs:18:7: 18:37 (#0),
+ span: $DIR/inner-attrs.rs:19:7: 19:37 (#0),
},
Punct {
ch: '#',
spacing: Joint,
- span: $DIR/inner-attrs.rs:19:5: 19:6 (#0),
+ span: $DIR/inner-attrs.rs:20:5: 20:6 (#0),
},
Punct {
ch: '!',
spacing: Alone,
- span: $DIR/inner-attrs.rs:19:6: 19:7 (#0),
+ span: $DIR/inner-attrs.rs:20:6: 20:7 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "print_target_and_args",
- span: $DIR/inner-attrs.rs:19:8: 19:29 (#0),
+ span: $DIR/inner-attrs.rs:20:8: 20:29 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "fourth",
- span: $DIR/inner-attrs.rs:19:30: 19:36 (#0),
+ span: $DIR/inner-attrs.rs:20:30: 20:36 (#0),
},
],
- span: $DIR/inner-attrs.rs:19:29: 19:37 (#0),
+ span: $DIR/inner-attrs.rs:20:29: 20:37 (#0),
},
],
- span: $DIR/inner-attrs.rs:19:7: 19:38 (#0),
+ span: $DIR/inner-attrs.rs:20:7: 20:38 (#0),
},
],
- span: $DIR/inner-attrs.rs:17:10: 20:2 (#0),
+ span: $DIR/inner-attrs.rs:18:10: 21:2 (#0),
},
]
PRINT-ATTR_ARGS INPUT (DISPLAY): second
PRINT-ATTR_ARGS INPUT (DEBUG): TokenStream [
Ident {
ident: "second",
- span: $DIR/inner-attrs.rs:16:25: 16:31 (#0),
+ span: $DIR/inner-attrs.rs:17:25: 17:31 (#0),
},
]
PRINT-ATTR INPUT (DISPLAY): fn foo()
PRINT-ATTR INPUT (DEBUG): TokenStream [
Ident {
ident: "fn",
- span: $DIR/inner-attrs.rs:17:1: 17:3 (#0),
+ span: $DIR/inner-attrs.rs:18:1: 18:3 (#0),
},
Ident {
ident: "foo",
- span: $DIR/inner-attrs.rs:17:4: 17:7 (#0),
+ span: $DIR/inner-attrs.rs:18:4: 18:7 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [],
- span: $DIR/inner-attrs.rs:17:7: 17:9 (#0),
+ span: $DIR/inner-attrs.rs:18:7: 18:9 (#0),
},
Group {
delimiter: Brace,
Punct {
ch: '#',
spacing: Joint,
- span: $DIR/inner-attrs.rs:18:5: 18:6 (#0),
+ span: $DIR/inner-attrs.rs:19:5: 19:6 (#0),
},
Punct {
ch: '!',
spacing: Alone,
- span: $DIR/inner-attrs.rs:18:6: 18:7 (#0),
+ span: $DIR/inner-attrs.rs:19:6: 19:7 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "print_target_and_args",
- span: $DIR/inner-attrs.rs:18:8: 18:29 (#0),
+ span: $DIR/inner-attrs.rs:19:8: 19:29 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "third",
- span: $DIR/inner-attrs.rs:18:30: 18:35 (#0),
+ span: $DIR/inner-attrs.rs:19:30: 19:35 (#0),
},
],
- span: $DIR/inner-attrs.rs:18:29: 18:36 (#0),
+ span: $DIR/inner-attrs.rs:19:29: 19:36 (#0),
},
],
- span: $DIR/inner-attrs.rs:18:7: 18:37 (#0),
+ span: $DIR/inner-attrs.rs:19:7: 19:37 (#0),
},
Punct {
ch: '#',
spacing: Joint,
- span: $DIR/inner-attrs.rs:19:5: 19:6 (#0),
+ span: $DIR/inner-attrs.rs:20:5: 20:6 (#0),
},
Punct {
ch: '!',
spacing: Alone,
- span: $DIR/inner-attrs.rs:19:6: 19:7 (#0),
+ span: $DIR/inner-attrs.rs:20:6: 20:7 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "print_target_and_args",
- span: $DIR/inner-attrs.rs:19:8: 19:29 (#0),
+ span: $DIR/inner-attrs.rs:20:8: 20:29 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "fourth",
- span: $DIR/inner-attrs.rs:19:30: 19:36 (#0),
+ span: $DIR/inner-attrs.rs:20:30: 20:36 (#0),
},
],
- span: $DIR/inner-attrs.rs:19:29: 19:37 (#0),
+ span: $DIR/inner-attrs.rs:20:29: 20:37 (#0),
},
],
- span: $DIR/inner-attrs.rs:19:7: 19:38 (#0),
+ span: $DIR/inner-attrs.rs:20:7: 20:38 (#0),
},
],
- span: $DIR/inner-attrs.rs:17:10: 20:2 (#0),
+ span: $DIR/inner-attrs.rs:18:10: 21:2 (#0),
},
]
PRINT-ATTR_ARGS INPUT (DISPLAY): third
PRINT-ATTR_ARGS INPUT (DEBUG): TokenStream [
Ident {
ident: "third",
- span: $DIR/inner-attrs.rs:18:30: 18:35 (#0),
+ span: $DIR/inner-attrs.rs:19:30: 19:35 (#0),
},
]
PRINT-ATTR INPUT (DISPLAY): fn foo() { # ! [print_target_and_args(fourth)] }
PRINT-ATTR INPUT (DEBUG): TokenStream [
Ident {
ident: "fn",
- span: $DIR/inner-attrs.rs:17:1: 17:3 (#0),
+ span: $DIR/inner-attrs.rs:18:1: 18:3 (#0),
},
Ident {
ident: "foo",
- span: $DIR/inner-attrs.rs:17:4: 17:7 (#0),
+ span: $DIR/inner-attrs.rs:18:4: 18:7 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [],
- span: $DIR/inner-attrs.rs:17:7: 17:9 (#0),
+ span: $DIR/inner-attrs.rs:18:7: 18:9 (#0),
},
Group {
delimiter: Brace,
Punct {
ch: '#',
spacing: Joint,
- span: $DIR/inner-attrs.rs:19:5: 19:6 (#0),
+ span: $DIR/inner-attrs.rs:20:5: 20:6 (#0),
},
Punct {
ch: '!',
spacing: Alone,
- span: $DIR/inner-attrs.rs:19:6: 19:7 (#0),
+ span: $DIR/inner-attrs.rs:20:6: 20:7 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "print_target_and_args",
- span: $DIR/inner-attrs.rs:19:8: 19:29 (#0),
+ span: $DIR/inner-attrs.rs:20:8: 20:29 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "fourth",
- span: $DIR/inner-attrs.rs:19:30: 19:36 (#0),
+ span: $DIR/inner-attrs.rs:20:30: 20:36 (#0),
},
],
- span: $DIR/inner-attrs.rs:19:29: 19:37 (#0),
+ span: $DIR/inner-attrs.rs:20:29: 20:37 (#0),
},
],
- span: $DIR/inner-attrs.rs:19:7: 19:38 (#0),
+ span: $DIR/inner-attrs.rs:20:7: 20:38 (#0),
},
],
- span: $DIR/inner-attrs.rs:17:10: 20:2 (#0),
+ span: $DIR/inner-attrs.rs:18:10: 21:2 (#0),
},
]
PRINT-ATTR_ARGS INPUT (DISPLAY): fourth
PRINT-ATTR_ARGS INPUT (DEBUG): TokenStream [
Ident {
ident: "fourth",
- span: $DIR/inner-attrs.rs:19:30: 19:36 (#0),
+ span: $DIR/inner-attrs.rs:20:30: 20:36 (#0),
},
]
PRINT-ATTR INPUT (DISPLAY): fn foo() { }
PRINT-ATTR INPUT (DEBUG): TokenStream [
Ident {
ident: "fn",
- span: $DIR/inner-attrs.rs:17:1: 17:3 (#0),
+ span: $DIR/inner-attrs.rs:18:1: 18:3 (#0),
},
Ident {
ident: "foo",
- span: $DIR/inner-attrs.rs:17:4: 17:7 (#0),
+ span: $DIR/inner-attrs.rs:18:4: 18:7 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [],
- span: $DIR/inner-attrs.rs:17:7: 17:9 (#0),
+ span: $DIR/inner-attrs.rs:18:7: 18:9 (#0),
},
Group {
delimiter: Brace,
stream: TokenStream [],
- span: $DIR/inner-attrs.rs:17:10: 20:2 (#0),
+ span: $DIR/inner-attrs.rs:18:10: 21:2 (#0),
},
]
PRINT-ATTR_ARGS INPUT (DISPLAY): mod_first
PRINT-ATTR_ARGS INPUT (DEBUG): TokenStream [
Ident {
ident: "mod_first",
- span: $DIR/inner-attrs.rs:22:25: 22:34 (#0),
+ span: $DIR/inner-attrs.rs:23:25: 23:34 (#0),
},
]
PRINT-ATTR INPUT (DISPLAY): #[print_target_and_args(mod_second)] mod inline_mod
Punct {
ch: '#',
spacing: Alone,
- span: $DIR/inner-attrs.rs:23:1: 23:2 (#0),
+ span: $DIR/inner-attrs.rs:24:1: 24:2 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "print_target_and_args",
- span: $DIR/inner-attrs.rs:23:3: 23:24 (#0),
+ span: $DIR/inner-attrs.rs:24:3: 24:24 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "mod_second",
- span: $DIR/inner-attrs.rs:23:25: 23:35 (#0),
+ span: $DIR/inner-attrs.rs:24:25: 24:35 (#0),
},
],
- span: $DIR/inner-attrs.rs:23:24: 23:36 (#0),
+ span: $DIR/inner-attrs.rs:24:24: 24:36 (#0),
},
],
- span: $DIR/inner-attrs.rs:23:2: 23:37 (#0),
+ span: $DIR/inner-attrs.rs:24:2: 24:37 (#0),
},
Ident {
ident: "mod",
- span: $DIR/inner-attrs.rs:24:1: 24:4 (#0),
+ span: $DIR/inner-attrs.rs:25:1: 25:4 (#0),
},
Ident {
ident: "inline_mod",
- span: $DIR/inner-attrs.rs:24:5: 24:15 (#0),
+ span: $DIR/inner-attrs.rs:25:5: 25:15 (#0),
},
Group {
delimiter: Brace,
Punct {
ch: '#',
spacing: Joint,
- span: $DIR/inner-attrs.rs:25:5: 25:6 (#0),
+ span: $DIR/inner-attrs.rs:26:5: 26:6 (#0),
},
Punct {
ch: '!',
spacing: Alone,
- span: $DIR/inner-attrs.rs:25:6: 25:7 (#0),
+ span: $DIR/inner-attrs.rs:26:6: 26:7 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "print_target_and_args",
- span: $DIR/inner-attrs.rs:25:8: 25:29 (#0),
+ span: $DIR/inner-attrs.rs:26:8: 26:29 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "mod_third",
- span: $DIR/inner-attrs.rs:25:30: 25:39 (#0),
+ span: $DIR/inner-attrs.rs:26:30: 26:39 (#0),
},
],
- span: $DIR/inner-attrs.rs:25:29: 25:40 (#0),
+ span: $DIR/inner-attrs.rs:26:29: 26:40 (#0),
},
],
- span: $DIR/inner-attrs.rs:25:7: 25:41 (#0),
+ span: $DIR/inner-attrs.rs:26:7: 26:41 (#0),
},
Punct {
ch: '#',
spacing: Joint,
- span: $DIR/inner-attrs.rs:26:5: 26:6 (#0),
+ span: $DIR/inner-attrs.rs:27:5: 27:6 (#0),
},
Punct {
ch: '!',
spacing: Alone,
- span: $DIR/inner-attrs.rs:26:6: 26:7 (#0),
+ span: $DIR/inner-attrs.rs:27:6: 27:7 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "print_target_and_args",
- span: $DIR/inner-attrs.rs:26:8: 26:29 (#0),
+ span: $DIR/inner-attrs.rs:27:8: 27:29 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "mod_fourth",
- span: $DIR/inner-attrs.rs:26:30: 26:40 (#0),
+ span: $DIR/inner-attrs.rs:27:30: 27:40 (#0),
},
],
- span: $DIR/inner-attrs.rs:26:29: 26:41 (#0),
+ span: $DIR/inner-attrs.rs:27:29: 27:41 (#0),
},
],
- span: $DIR/inner-attrs.rs:26:7: 26:42 (#0),
+ span: $DIR/inner-attrs.rs:27:7: 27:42 (#0),
},
],
- span: $DIR/inner-attrs.rs:24:16: 27:2 (#0),
+ span: $DIR/inner-attrs.rs:25:16: 28:2 (#0),
},
]
PRINT-ATTR_ARGS INPUT (DISPLAY): mod_second
PRINT-ATTR_ARGS INPUT (DEBUG): TokenStream [
Ident {
ident: "mod_second",
- span: $DIR/inner-attrs.rs:23:25: 23:35 (#0),
+ span: $DIR/inner-attrs.rs:24:25: 24:35 (#0),
},
]
PRINT-ATTR INPUT (DISPLAY): mod inline_mod
PRINT-ATTR INPUT (DEBUG): TokenStream [
Ident {
ident: "mod",
- span: $DIR/inner-attrs.rs:24:1: 24:4 (#0),
+ span: $DIR/inner-attrs.rs:25:1: 25:4 (#0),
},
Ident {
ident: "inline_mod",
- span: $DIR/inner-attrs.rs:24:5: 24:15 (#0),
+ span: $DIR/inner-attrs.rs:25:5: 25:15 (#0),
},
Group {
delimiter: Brace,
Punct {
ch: '#',
spacing: Joint,
- span: $DIR/inner-attrs.rs:25:5: 25:6 (#0),
+ span: $DIR/inner-attrs.rs:26:5: 26:6 (#0),
},
Punct {
ch: '!',
spacing: Alone,
- span: $DIR/inner-attrs.rs:25:6: 25:7 (#0),
+ span: $DIR/inner-attrs.rs:26:6: 26:7 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "print_target_and_args",
- span: $DIR/inner-attrs.rs:25:8: 25:29 (#0),
+ span: $DIR/inner-attrs.rs:26:8: 26:29 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "mod_third",
- span: $DIR/inner-attrs.rs:25:30: 25:39 (#0),
+ span: $DIR/inner-attrs.rs:26:30: 26:39 (#0),
},
],
- span: $DIR/inner-attrs.rs:25:29: 25:40 (#0),
+ span: $DIR/inner-attrs.rs:26:29: 26:40 (#0),
},
],
- span: $DIR/inner-attrs.rs:25:7: 25:41 (#0),
+ span: $DIR/inner-attrs.rs:26:7: 26:41 (#0),
},
Punct {
ch: '#',
spacing: Joint,
- span: $DIR/inner-attrs.rs:26:5: 26:6 (#0),
+ span: $DIR/inner-attrs.rs:27:5: 27:6 (#0),
},
Punct {
ch: '!',
spacing: Alone,
- span: $DIR/inner-attrs.rs:26:6: 26:7 (#0),
+ span: $DIR/inner-attrs.rs:27:6: 27:7 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "print_target_and_args",
- span: $DIR/inner-attrs.rs:26:8: 26:29 (#0),
+ span: $DIR/inner-attrs.rs:27:8: 27:29 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "mod_fourth",
- span: $DIR/inner-attrs.rs:26:30: 26:40 (#0),
+ span: $DIR/inner-attrs.rs:27:30: 27:40 (#0),
},
],
- span: $DIR/inner-attrs.rs:26:29: 26:41 (#0),
+ span: $DIR/inner-attrs.rs:27:29: 27:41 (#0),
},
],
- span: $DIR/inner-attrs.rs:26:7: 26:42 (#0),
+ span: $DIR/inner-attrs.rs:27:7: 27:42 (#0),
},
],
- span: $DIR/inner-attrs.rs:24:16: 27:2 (#0),
+ span: $DIR/inner-attrs.rs:25:16: 28:2 (#0),
},
]
PRINT-ATTR_ARGS INPUT (DISPLAY): mod_third
PRINT-ATTR_ARGS INPUT (DEBUG): TokenStream [
Ident {
ident: "mod_third",
- span: $DIR/inner-attrs.rs:25:30: 25:39 (#0),
+ span: $DIR/inner-attrs.rs:26:30: 26:39 (#0),
},
]
PRINT-ATTR INPUT (DISPLAY): mod inline_mod { # ! [print_target_and_args(mod_fourth)] }
PRINT-ATTR INPUT (DEBUG): TokenStream [
Ident {
ident: "mod",
- span: $DIR/inner-attrs.rs:24:1: 24:4 (#0),
+ span: $DIR/inner-attrs.rs:25:1: 25:4 (#0),
},
Ident {
ident: "inline_mod",
- span: $DIR/inner-attrs.rs:24:5: 24:15 (#0),
+ span: $DIR/inner-attrs.rs:25:5: 25:15 (#0),
},
Group {
delimiter: Brace,
Punct {
ch: '#',
spacing: Joint,
- span: $DIR/inner-attrs.rs:26:5: 26:6 (#0),
+ span: $DIR/inner-attrs.rs:27:5: 27:6 (#0),
},
Punct {
ch: '!',
spacing: Alone,
- span: $DIR/inner-attrs.rs:26:6: 26:7 (#0),
+ span: $DIR/inner-attrs.rs:27:6: 27:7 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "print_target_and_args",
- span: $DIR/inner-attrs.rs:26:8: 26:29 (#0),
+ span: $DIR/inner-attrs.rs:27:8: 27:29 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "mod_fourth",
- span: $DIR/inner-attrs.rs:26:30: 26:40 (#0),
+ span: $DIR/inner-attrs.rs:27:30: 27:40 (#0),
},
],
- span: $DIR/inner-attrs.rs:26:29: 26:41 (#0),
+ span: $DIR/inner-attrs.rs:27:29: 27:41 (#0),
},
],
- span: $DIR/inner-attrs.rs:26:7: 26:42 (#0),
+ span: $DIR/inner-attrs.rs:27:7: 27:42 (#0),
},
],
- span: $DIR/inner-attrs.rs:24:16: 27:2 (#0),
+ span: $DIR/inner-attrs.rs:25:16: 28:2 (#0),
},
]
PRINT-ATTR_ARGS INPUT (DISPLAY): mod_fourth
PRINT-ATTR_ARGS INPUT (DEBUG): TokenStream [
Ident {
ident: "mod_fourth",
- span: $DIR/inner-attrs.rs:26:30: 26:40 (#0),
+ span: $DIR/inner-attrs.rs:27:30: 27:40 (#0),
},
]
PRINT-ATTR INPUT (DISPLAY): mod inline_mod { }
PRINT-ATTR INPUT (DEBUG): TokenStream [
Ident {
ident: "mod",
- span: $DIR/inner-attrs.rs:24:1: 24:4 (#0),
+ span: $DIR/inner-attrs.rs:25:1: 25:4 (#0),
},
Ident {
ident: "inline_mod",
- span: $DIR/inner-attrs.rs:24:5: 24:15 (#0),
+ span: $DIR/inner-attrs.rs:25:5: 25:15 (#0),
},
Group {
delimiter: Brace,
stream: TokenStream [],
- span: $DIR/inner-attrs.rs:24:16: 27:2 (#0),
+ span: $DIR/inner-attrs.rs:25:16: 28:2 (#0),
},
]
PRINT-DERIVE INPUT (DISPLAY): struct MyDerivePrint
{
field :
- [u8 ;
- {
- match true
- {
- # ! [rustc_dummy(first)] # ! [rustc_dummy(second)] _ =>
- { # ! [rustc_dummy(third)] true }
- } ; 0
- }]
+ [u8 ; { match true { _ => { # ! [rustc_dummy(third)] true } } ; 0 }]
}
PRINT-DERIVE INPUT (DEBUG): TokenStream [
Ident {
ident: "struct",
- span: $DIR/inner-attrs.rs:34:1: 34:7 (#0),
+ span: $DIR/inner-attrs.rs:35:1: 35:7 (#0),
},
Ident {
ident: "MyDerivePrint",
- span: $DIR/inner-attrs.rs:34:8: 34:21 (#0),
+ span: $DIR/inner-attrs.rs:35:8: 35:21 (#0),
},
Group {
delimiter: Brace,
stream: TokenStream [
Ident {
ident: "field",
- span: $DIR/inner-attrs.rs:35:5: 35:10 (#0),
+ span: $DIR/inner-attrs.rs:36:5: 36:10 (#0),
},
Punct {
ch: ':',
spacing: Alone,
- span: $DIR/inner-attrs.rs:35:10: 35:11 (#0),
+ span: $DIR/inner-attrs.rs:36:10: 36:11 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "u8",
- span: $DIR/inner-attrs.rs:35:13: 35:15 (#0),
+ span: $DIR/inner-attrs.rs:36:13: 36:15 (#0),
},
Punct {
ch: ';',
spacing: Alone,
- span: $DIR/inner-attrs.rs:35:15: 35:16 (#0),
+ span: $DIR/inner-attrs.rs:36:15: 36:16 (#0),
},
Group {
delimiter: Brace,
stream: TokenStream [
Ident {
ident: "match",
- span: $DIR/inner-attrs.rs:36:9: 36:14 (#0),
+ span: $DIR/inner-attrs.rs:37:9: 37:14 (#0),
},
Ident {
ident: "true",
- span: $DIR/inner-attrs.rs:36:15: 36:19 (#0),
+ span: $DIR/inner-attrs.rs:37:15: 37:19 (#0),
},
Group {
delimiter: Brace,
stream: TokenStream [
- Punct {
- ch: '#',
- spacing: Alone,
- span: $DIR/inner-attrs.rs:37:13: 37:14 (#0),
- },
- Punct {
- ch: '!',
- spacing: Alone,
- span: $DIR/inner-attrs.rs:37:14: 37:15 (#0),
- },
- Group {
- delimiter: Bracket,
- stream: TokenStream [
- Ident {
- ident: "rustc_dummy",
- span: $DIR/inner-attrs.rs:37:37: 37:48 (#0),
- },
- Group {
- delimiter: Parenthesis,
- stream: TokenStream [
- Ident {
- ident: "first",
- span: $DIR/inner-attrs.rs:37:49: 37:54 (#0),
- },
- ],
- span: $DIR/inner-attrs.rs:37:48: 37:55 (#0),
- },
- ],
- span: $DIR/inner-attrs.rs:37:13: 37:14 (#0),
- },
- Punct {
- ch: '#',
- spacing: Alone,
- span: $DIR/inner-attrs.rs:38:13: 38:14 (#0),
- },
- Punct {
- ch: '!',
- spacing: Alone,
- span: $DIR/inner-attrs.rs:38:14: 38:15 (#0),
- },
- Group {
- delimiter: Bracket,
- stream: TokenStream [
- Ident {
- ident: "rustc_dummy",
- span: $DIR/inner-attrs.rs:38:37: 38:48 (#0),
- },
- Group {
- delimiter: Parenthesis,
- stream: TokenStream [
- Ident {
- ident: "second",
- span: $DIR/inner-attrs.rs:38:49: 38:55 (#0),
- },
- ],
- span: $DIR/inner-attrs.rs:38:48: 38:56 (#0),
- },
- ],
- span: $DIR/inner-attrs.rs:38:13: 38:14 (#0),
- },
Ident {
ident: "_",
- span: $DIR/inner-attrs.rs:39:13: 39:14 (#0),
+ span: $DIR/inner-attrs.rs:38:13: 38:14 (#0),
},
Punct {
ch: '=',
spacing: Joint,
- span: $DIR/inner-attrs.rs:39:15: 39:17 (#0),
+ span: $DIR/inner-attrs.rs:38:15: 38:17 (#0),
},
Punct {
ch: '>',
spacing: Alone,
- span: $DIR/inner-attrs.rs:39:15: 39:17 (#0),
+ span: $DIR/inner-attrs.rs:38:15: 38:17 (#0),
},
Group {
delimiter: Brace,
Punct {
ch: '#',
spacing: Alone,
- span: $DIR/inner-attrs.rs:40:17: 40:18 (#0),
+ span: $DIR/inner-attrs.rs:39:17: 39:18 (#0),
},
Punct {
ch: '!',
spacing: Alone,
- span: $DIR/inner-attrs.rs:40:18: 40:19 (#0),
+ span: $DIR/inner-attrs.rs:39:18: 39:19 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "rustc_dummy",
- span: $DIR/inner-attrs.rs:40:41: 40:52 (#0),
+ span: $DIR/inner-attrs.rs:39:41: 39:52 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "third",
- span: $DIR/inner-attrs.rs:40:53: 40:58 (#0),
+ span: $DIR/inner-attrs.rs:39:53: 39:58 (#0),
},
],
- span: $DIR/inner-attrs.rs:40:52: 40:59 (#0),
+ span: $DIR/inner-attrs.rs:39:52: 39:59 (#0),
},
],
- span: $DIR/inner-attrs.rs:40:17: 40:18 (#0),
+ span: $DIR/inner-attrs.rs:39:17: 39:18 (#0),
},
Ident {
ident: "true",
- span: $DIR/inner-attrs.rs:41:17: 41:21 (#0),
+ span: $DIR/inner-attrs.rs:40:17: 40:21 (#0),
},
],
- span: $DIR/inner-attrs.rs:39:18: 42:14 (#0),
+ span: $DIR/inner-attrs.rs:38:18: 41:14 (#0),
},
],
- span: $DIR/inner-attrs.rs:36:20: 43:10 (#0),
+ span: $DIR/inner-attrs.rs:37:20: 42:10 (#0),
},
Punct {
ch: ';',
spacing: Alone,
- span: $DIR/inner-attrs.rs:43:10: 43:11 (#0),
+ span: $DIR/inner-attrs.rs:42:10: 42:11 (#0),
},
Literal {
kind: Integer,
symbol: "0",
suffix: None,
- span: $DIR/inner-attrs.rs:44:9: 44:10 (#0),
+ span: $DIR/inner-attrs.rs:43:9: 43:10 (#0),
},
],
- span: $DIR/inner-attrs.rs:35:17: 45:6 (#0),
+ span: $DIR/inner-attrs.rs:36:17: 44:6 (#0),
},
],
- span: $DIR/inner-attrs.rs:35:12: 45:7 (#0),
+ span: $DIR/inner-attrs.rs:36:12: 44:7 (#0),
},
],
- span: $DIR/inner-attrs.rs:34:22: 46:2 (#0),
+ span: $DIR/inner-attrs.rs:35:22: 45:2 (#0),
},
]
PRINT-ATTR_ARGS INPUT (DISPLAY): tuple_attrs
PRINT-ATTR_ARGS INPUT (DEBUG): TokenStream [
Ident {
ident: "tuple_attrs",
- span: $DIR/inner-attrs.rs:52:29: 52:40 (#0),
+ span: $DIR/inner-attrs.rs:48:29: 48:40 (#0),
},
]
PRINT-ATTR INPUT (DISPLAY): (3, 4, { # ! [cfg_attr(not(FALSE), rustc_dummy(innermost))] 5 }) ;
kind: Integer,
symbol: "3",
suffix: None,
- span: $DIR/inner-attrs.rs:54:9: 54:10 (#0),
+ span: $DIR/inner-attrs.rs:49:9: 49:10 (#0),
},
Punct {
ch: ',',
spacing: Alone,
- span: $DIR/inner-attrs.rs:54:10: 54:11 (#0),
+ span: $DIR/inner-attrs.rs:49:10: 49:11 (#0),
},
Literal {
kind: Integer,
symbol: "4",
suffix: None,
- span: $DIR/inner-attrs.rs:54:12: 54:13 (#0),
+ span: $DIR/inner-attrs.rs:49:12: 49:13 (#0),
},
Punct {
ch: ',',
spacing: Alone,
- span: $DIR/inner-attrs.rs:54:13: 54:14 (#0),
+ span: $DIR/inner-attrs.rs:49:13: 49:14 (#0),
},
Group {
delimiter: Brace,
Punct {
ch: '#',
spacing: Joint,
- span: $DIR/inner-attrs.rs:55:13: 55:14 (#0),
+ span: $DIR/inner-attrs.rs:50:13: 50:14 (#0),
},
Punct {
ch: '!',
spacing: Alone,
- span: $DIR/inner-attrs.rs:55:14: 55:15 (#0),
+ span: $DIR/inner-attrs.rs:50:14: 50:15 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "cfg_attr",
- span: $DIR/inner-attrs.rs:55:16: 55:24 (#0),
+ span: $DIR/inner-attrs.rs:50:16: 50:24 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "not",
- span: $DIR/inner-attrs.rs:55:25: 55:28 (#0),
+ span: $DIR/inner-attrs.rs:50:25: 50:28 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "FALSE",
- span: $DIR/inner-attrs.rs:55:29: 55:34 (#0),
+ span: $DIR/inner-attrs.rs:50:29: 50:34 (#0),
},
],
- span: $DIR/inner-attrs.rs:55:28: 55:35 (#0),
+ span: $DIR/inner-attrs.rs:50:28: 50:35 (#0),
},
Punct {
ch: ',',
spacing: Alone,
- span: $DIR/inner-attrs.rs:55:35: 55:36 (#0),
+ span: $DIR/inner-attrs.rs:50:35: 50:36 (#0),
},
Ident {
ident: "rustc_dummy",
- span: $DIR/inner-attrs.rs:55:37: 55:48 (#0),
+ span: $DIR/inner-attrs.rs:50:37: 50:48 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "innermost",
- span: $DIR/inner-attrs.rs:55:49: 55:58 (#0),
+ span: $DIR/inner-attrs.rs:50:49: 50:58 (#0),
},
],
- span: $DIR/inner-attrs.rs:55:48: 55:59 (#0),
+ span: $DIR/inner-attrs.rs:50:48: 50:59 (#0),
},
],
- span: $DIR/inner-attrs.rs:55:24: 55:60 (#0),
+ span: $DIR/inner-attrs.rs:50:24: 50:60 (#0),
},
],
- span: $DIR/inner-attrs.rs:55:15: 55:61 (#0),
+ span: $DIR/inner-attrs.rs:50:15: 50:61 (#0),
},
Literal {
kind: Integer,
symbol: "5",
suffix: None,
- span: $DIR/inner-attrs.rs:56:13: 56:14 (#0),
+ span: $DIR/inner-attrs.rs:51:13: 51:14 (#0),
},
],
- span: $DIR/inner-attrs.rs:54:15: 57:10 (#0),
+ span: $DIR/inner-attrs.rs:49:15: 52:10 (#0),
},
],
- span: $DIR/inner-attrs.rs:52:43: 58:6 (#0),
+ span: $DIR/inner-attrs.rs:48:43: 53:6 (#0),
},
Punct {
ch: ';',
spacing: Alone,
- span: $DIR/inner-attrs.rs:58:6: 58:7 (#0),
- },
-]
-PRINT-ATTR_ARGS INPUT (DISPLAY): array_attrs
-PRINT-ATTR_ARGS INPUT (DEBUG): TokenStream [
- Ident {
- ident: "array_attrs",
- span: $DIR/inner-attrs.rs:60:29: 60:40 (#0),
- },
-]
-PRINT-ATTR INPUT (DISPLAY): [# ! [rustc_dummy(inner)] true ; 0] ;
-PRINT-ATTR INPUT (DEBUG): TokenStream [
- Group {
- delimiter: Bracket,
- stream: TokenStream [
- Punct {
- ch: '#',
- spacing: Joint,
- span: $DIR/inner-attrs.rs:61:9: 61:10 (#0),
- },
- Punct {
- ch: '!',
- spacing: Alone,
- span: $DIR/inner-attrs.rs:61:10: 61:11 (#0),
- },
- Group {
- delimiter: Bracket,
- stream: TokenStream [
- Ident {
- ident: "rustc_dummy",
- span: $DIR/inner-attrs.rs:61:12: 61:23 (#0),
- },
- Group {
- delimiter: Parenthesis,
- stream: TokenStream [
- Ident {
- ident: "inner",
- span: $DIR/inner-attrs.rs:61:24: 61:29 (#0),
- },
- ],
- span: $DIR/inner-attrs.rs:61:23: 61:30 (#0),
- },
- ],
- span: $DIR/inner-attrs.rs:61:11: 61:31 (#0),
- },
- Ident {
- ident: "true",
- span: $DIR/inner-attrs.rs:62:9: 62:13 (#0),
- },
- Punct {
- ch: ';',
- spacing: Alone,
- span: $DIR/inner-attrs.rs:62:13: 62:14 (#0),
- },
- Literal {
- kind: Integer,
- symbol: "0",
- suffix: None,
- span: $DIR/inner-attrs.rs:62:15: 62:16 (#0),
- },
- ],
- span: $DIR/inner-attrs.rs:60:43: 63:6 (#0),
- },
- Punct {
- ch: ';',
- spacing: Alone,
- span: $DIR/inner-attrs.rs:63:6: 63:7 (#0),
+ span: $DIR/inner-attrs.rs:53:6: 53:7 (#0),
},
]
PRINT-ATTR_ARGS INPUT (DISPLAY): tuple_attrs
PRINT-ATTR_ARGS INPUT (DEBUG): TokenStream [
Ident {
ident: "tuple_attrs",
- span: $DIR/inner-attrs.rs:65:29: 65:40 (#0),
+ span: $DIR/inner-attrs.rs:55:29: 55:40 (#0),
},
]
PRINT-ATTR INPUT (DISPLAY): (3, 4, { # ! [cfg_attr(not(FALSE), rustc_dummy(innermost))] 5 }) ;
kind: Integer,
symbol: "3",
suffix: None,
- span: $DIR/inner-attrs.rs:67:9: 67:10 (#0),
+ span: $DIR/inner-attrs.rs:56:9: 56:10 (#0),
},
Punct {
ch: ',',
spacing: Alone,
- span: $DIR/inner-attrs.rs:67:10: 67:11 (#0),
+ span: $DIR/inner-attrs.rs:56:10: 56:11 (#0),
},
Literal {
kind: Integer,
symbol: "4",
suffix: None,
- span: $DIR/inner-attrs.rs:67:12: 67:13 (#0),
+ span: $DIR/inner-attrs.rs:56:12: 56:13 (#0),
},
Punct {
ch: ',',
spacing: Alone,
- span: $DIR/inner-attrs.rs:67:13: 67:14 (#0),
+ span: $DIR/inner-attrs.rs:56:13: 56:14 (#0),
},
Group {
delimiter: Brace,
Punct {
ch: '#',
spacing: Joint,
- span: $DIR/inner-attrs.rs:68:13: 68:14 (#0),
+ span: $DIR/inner-attrs.rs:57:13: 57:14 (#0),
},
Punct {
ch: '!',
spacing: Alone,
- span: $DIR/inner-attrs.rs:68:14: 68:15 (#0),
+ span: $DIR/inner-attrs.rs:57:14: 57:15 (#0),
},
Group {
delimiter: Bracket,
stream: TokenStream [
Ident {
ident: "cfg_attr",
- span: $DIR/inner-attrs.rs:68:16: 68:24 (#0),
+ span: $DIR/inner-attrs.rs:57:16: 57:24 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "not",
- span: $DIR/inner-attrs.rs:68:25: 68:28 (#0),
+ span: $DIR/inner-attrs.rs:57:25: 57:28 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "FALSE",
- span: $DIR/inner-attrs.rs:68:29: 68:34 (#0),
+ span: $DIR/inner-attrs.rs:57:29: 57:34 (#0),
},
],
- span: $DIR/inner-attrs.rs:68:28: 68:35 (#0),
+ span: $DIR/inner-attrs.rs:57:28: 57:35 (#0),
},
Punct {
ch: ',',
spacing: Alone,
- span: $DIR/inner-attrs.rs:68:35: 68:36 (#0),
+ span: $DIR/inner-attrs.rs:57:35: 57:36 (#0),
},
Ident {
ident: "rustc_dummy",
- span: $DIR/inner-attrs.rs:68:37: 68:48 (#0),
+ span: $DIR/inner-attrs.rs:57:37: 57:48 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [
Ident {
ident: "innermost",
- span: $DIR/inner-attrs.rs:68:49: 68:58 (#0),
+ span: $DIR/inner-attrs.rs:57:49: 57:58 (#0),
},
],
- span: $DIR/inner-attrs.rs:68:48: 68:59 (#0),
+ span: $DIR/inner-attrs.rs:57:48: 57:59 (#0),
},
],
- span: $DIR/inner-attrs.rs:68:24: 68:60 (#0),
+ span: $DIR/inner-attrs.rs:57:24: 57:60 (#0),
},
],
- span: $DIR/inner-attrs.rs:68:15: 68:61 (#0),
+ span: $DIR/inner-attrs.rs:57:15: 57:61 (#0),
},
Literal {
kind: Integer,
symbol: "5",
suffix: None,
- span: $DIR/inner-attrs.rs:69:13: 69:14 (#0),
- },
- ],
- span: $DIR/inner-attrs.rs:67:15: 70:10 (#0),
- },
- ],
- span: $DIR/inner-attrs.rs:65:43: 71:6 (#0),
- },
- Punct {
- ch: ';',
- spacing: Alone,
- span: $DIR/inner-attrs.rs:71:6: 71:7 (#0),
- },
-]
-PRINT-ATTR_ARGS INPUT (DISPLAY): array_attrs
-PRINT-ATTR_ARGS INPUT (DEBUG): TokenStream [
- Ident {
- ident: "array_attrs",
- span: $DIR/inner-attrs.rs:73:29: 73:40 (#0),
- },
-]
-PRINT-ATTR INPUT (DISPLAY): [# ! [rustc_dummy(inner)] true ; 0] ;
-PRINT-ATTR INPUT (DEBUG): TokenStream [
- Group {
- delimiter: Bracket,
- stream: TokenStream [
- Punct {
- ch: '#',
- spacing: Joint,
- span: $DIR/inner-attrs.rs:74:9: 74:10 (#0),
- },
- Punct {
- ch: '!',
- spacing: Alone,
- span: $DIR/inner-attrs.rs:74:10: 74:11 (#0),
- },
- Group {
- delimiter: Bracket,
- stream: TokenStream [
- Ident {
- ident: "rustc_dummy",
- span: $DIR/inner-attrs.rs:74:12: 74:23 (#0),
- },
- Group {
- delimiter: Parenthesis,
- stream: TokenStream [
- Ident {
- ident: "inner",
- span: $DIR/inner-attrs.rs:74:24: 74:29 (#0),
- },
- ],
- span: $DIR/inner-attrs.rs:74:23: 74:30 (#0),
+ span: $DIR/inner-attrs.rs:58:13: 58:14 (#0),
},
],
- span: $DIR/inner-attrs.rs:74:11: 74:31 (#0),
- },
- Ident {
- ident: "true",
- span: $DIR/inner-attrs.rs:75:9: 75:13 (#0),
- },
- Punct {
- ch: ';',
- spacing: Alone,
- span: $DIR/inner-attrs.rs:75:13: 75:14 (#0),
- },
- Literal {
- kind: Integer,
- symbol: "0",
- suffix: None,
- span: $DIR/inner-attrs.rs:75:15: 75:16 (#0),
+ span: $DIR/inner-attrs.rs:56:15: 59:10 (#0),
},
],
- span: $DIR/inner-attrs.rs:73:43: 76:6 (#0),
+ span: $DIR/inner-attrs.rs:55:43: 60:6 (#0),
},
Punct {
ch: ';',
spacing: Alone,
- span: $DIR/inner-attrs.rs:76:6: 76:7 (#0),
+ span: $DIR/inner-attrs.rs:60:6: 60:7 (#0),
},
]
PRINT-ATTR_ARGS INPUT (DISPLAY): tenth
PRINT-ATTR_ARGS INPUT (DEBUG): TokenStream [
Ident {
ident: "tenth",
- span: $DIR/inner-attrs.rs:112:42: 112:47 (#0),
+ span: $DIR/inner-attrs.rs:82:42: 82:47 (#0),
},
]
PRINT-ATTR INPUT (DISPLAY): fn weird_extern() { }
PRINT-ATTR INPUT (DEBUG): TokenStream [
Ident {
ident: "fn",
- span: $DIR/inner-attrs.rs:111:5: 111:7 (#0),
+ span: $DIR/inner-attrs.rs:81:5: 81:7 (#0),
},
Ident {
ident: "weird_extern",
- span: $DIR/inner-attrs.rs:111:8: 111:20 (#0),
+ span: $DIR/inner-attrs.rs:81:8: 81:20 (#0),
},
Group {
delimiter: Parenthesis,
stream: TokenStream [],
- span: $DIR/inner-attrs.rs:111:20: 111:22 (#0),
+ span: $DIR/inner-attrs.rs:81:20: 81:22 (#0),
},
Group {
delimiter: Brace,
stream: TokenStream [],
- span: $DIR/inner-attrs.rs:111:23: 113:6 (#0),
+ span: $DIR/inner-attrs.rs:81:23: 83:6 (#0),
},
]
// Test that using a macro to replace the entire crate tree with a non-'mod' item errors out nicely.
// `issue_59191::no_main` replaces whatever's passed in with `fn main() {}`.
#![feature(custom_inner_attributes)]
-//~^ ERROR `main` function not found in crate `issue_59191_replace_root_with_fn` [E0601]
#![issue_59191::no_main]
//~^ ERROR expected crate top-level item to be a module after macro expansion, found a function
error: expected crate top-level item to be a module after macro expansion, found a function
- --> $DIR/issue-59191-replace-root-with-fn.rs:7:1
+ --> $DIR/issue-59191-replace-root-with-fn.rs:6:1
|
LL | #![issue_59191::no_main]
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: this error originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
-error[E0601]: `main` function not found in crate `issue_59191_replace_root_with_fn`
- --> $DIR/issue-59191-replace-root-with-fn.rs:5:1
- |
-LL | / #![feature(custom_inner_attributes)]
-LL | |
-LL | | #![issue_59191::no_main]
- | |________________________^ consider adding a `main` function to `$DIR/issue-59191-replace-root-with-fn.rs`
-
-error: aborting due to 2 previous errors
+error: aborting due to previous error
-For more information about this error, try `rustc --explain E0601`.
+++ /dev/null
-// check-pass
-// compile-flags: -Z span-debug --error-format human
-// aux-build:test-macros.rs
-// edition:2018
-
-#![feature(proc_macro_hygiene)]
-
-#![no_std] // Don't load unnecessary hygiene information from std
-extern crate std;
-
-#[macro_use]
-extern crate test_macros;
-
-fn main() {
- #[print_target_and_args(my_arg)] (
- #![cfg_attr(not(FALSE), allow(unused))]
- 1, 2, 3
- );
-}
+++ /dev/null
-PRINT-ATTR_ARGS INPUT (DISPLAY): my_arg
-PRINT-ATTR_ARGS INPUT (DEBUG): TokenStream [
- Ident {
- ident: "my_arg",
- span: $DIR/simple-tuple.rs:15:29: 15:35 (#0),
- },
-]
-PRINT-ATTR INPUT (DISPLAY): (# ! [allow(unused)] 1, 2, 3) ;
-PRINT-ATTR INPUT (DEBUG): TokenStream [
- Group {
- delimiter: Parenthesis,
- stream: TokenStream [
- Punct {
- ch: '#',
- spacing: Alone,
- span: $DIR/simple-tuple.rs:16:9: 16:10 (#0),
- },
- Punct {
- ch: '!',
- spacing: Alone,
- span: $DIR/simple-tuple.rs:16:10: 16:11 (#0),
- },
- Group {
- delimiter: Bracket,
- stream: TokenStream [
- Ident {
- ident: "allow",
- span: $DIR/simple-tuple.rs:16:33: 16:38 (#0),
- },
- Group {
- delimiter: Parenthesis,
- stream: TokenStream [
- Ident {
- ident: "unused",
- span: $DIR/simple-tuple.rs:16:39: 16:45 (#0),
- },
- ],
- span: $DIR/simple-tuple.rs:16:38: 16:46 (#0),
- },
- ],
- span: $DIR/simple-tuple.rs:16:9: 16:10 (#0),
- },
- Literal {
- kind: Integer,
- symbol: "1",
- suffix: None,
- span: $DIR/simple-tuple.rs:17:9: 17:10 (#0),
- },
- Punct {
- ch: ',',
- spacing: Alone,
- span: $DIR/simple-tuple.rs:17:10: 17:11 (#0),
- },
- Literal {
- kind: Integer,
- symbol: "2",
- suffix: None,
- span: $DIR/simple-tuple.rs:17:12: 17:13 (#0),
- },
- Punct {
- ch: ',',
- spacing: Alone,
- span: $DIR/simple-tuple.rs:17:13: 17:14 (#0),
- },
- Literal {
- kind: Integer,
- symbol: "3",
- suffix: None,
- span: $DIR/simple-tuple.rs:17:15: 17:16 (#0),
- },
- ],
- span: $DIR/simple-tuple.rs:15:38: 18:6 (#0),
- },
- Punct {
- ch: ';',
- spacing: Alone,
- span: $DIR/simple-tuple.rs:18:6: 18:7 (#0),
- },
-]
--- /dev/null
+// edition:2021
+
+fn main() {
+ let n = 2;
+ match n {
+ 0...3 => {}
+ //~^ ERROR `...` range patterns are deprecated
+ 4...10 => {}
+ //~^ ERROR `...` range patterns are deprecated
+ (11...100) => {}
+ //~^ ERROR `...` range patterns are deprecated
+ _ => {}
+ }
+}
--- /dev/null
+error[E0783]: `...` range patterns are deprecated
+ --> $DIR/exclusive-range-patterns-2021.rs:6:9
+ |
+LL | 0...3 => {}
+ | ^---^
+ | |
+ | help: use `..=` for an inclusive range
+
+error[E0783]: `...` range patterns are deprecated
+ --> $DIR/exclusive-range-patterns-2021.rs:8:9
+ |
+LL | 4...10 => {}
+ | ^---^^
+ | |
+ | help: use `..=` for an inclusive range
+
+error[E0783]: `...` range patterns are deprecated
+ --> $DIR/exclusive-range-patterns-2021.rs:10:10
+ |
+LL | (11...100) => {}
+ | ^^---^^^
+ | |
+ | help: use `..=` for an inclusive range
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0783`.
match &12 {
&(0..=9) => {}
//~^ WARN `...` range patterns are deprecated
+ //~| WARN this was previously accepted by the compiler
//~| HELP use `..=` for an inclusive range
&(10 ..=15) => {}
//~^ ERROR the range pattern here has ambiguous interpretation
- //~^^ HELP add parentheses to clarify the precedence
+ //~| HELP add parentheses to clarify the precedence
&(16..=20) => {}
_ => {}
}
match &12 {
&0...9 => {}
//~^ WARN `...` range patterns are deprecated
+ //~| WARN this was previously accepted by the compiler
//~| HELP use `..=` for an inclusive range
&10..=15 => {}
//~^ ERROR the range pattern here has ambiguous interpretation
- //~^^ HELP add parentheses to clarify the precedence
+ //~| HELP add parentheses to clarify the precedence
&(16..=20) => {}
_ => {}
}
error: the range pattern here has ambiguous interpretation
- --> $DIR/range-inclusive-pattern-precedence.rs:14:10
+ --> $DIR/range-inclusive-pattern-precedence.rs:15:10
|
LL | &10..=15 => {}
| ^^^^^^^ help: add parentheses to clarify the precedence: `(10 ..=15)`
|
LL | #![warn(ellipsis_inclusive_range_patterns)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: aborting due to previous error; 1 warning emitted
// FIXME: can we add suggestions like `&(0..=9)`?
box 0...9 => {}
//~^ WARN `...` range patterns are deprecated
+ //~| WARN this was previously accepted by the compiler
//~| HELP use `..=` for an inclusive range
box 10..=15 => {}
//~^ ERROR the range pattern here has ambiguous interpretation
error: the range pattern here has ambiguous interpretation
- --> $DIR/range-inclusive-pattern-precedence2.rs:13:13
+ --> $DIR/range-inclusive-pattern-precedence2.rs:14:13
|
LL | box 10..=15 => {}
| ^^^^^^^ help: add parentheses to clarify the precedence: `(10 ..=15)`
|
LL | #![warn(ellipsis_inclusive_range_patterns)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: aborting due to previous error; 1 warning emitted
LL | let _f = || {
| -- value captured here
LL | let p: &'static mut usize = &mut self.food;
- | ------------------ ^^^^ borrowed value does not live long enough
+ | ------------------ ^^^^^^^^^ borrowed value does not live long enough
| |
| type annotation requires that `self` is borrowed for `'static`
...
LL | mod řųśť;
| ^^^^^^^^^
|
- = help: to create the module `řųśť`, create file "$DIR/řųśť.rs"
+ = help: to create the module `řųśť`, create file "$DIR/řųśť.rs" or "$DIR/řųśť/mod.rs"
error[E0754]: trying to load file for module `řųśť` with non-ascii identifier name
--> $DIR/mod_file_nonascii_forbidden.rs:1:5
#![allow(incomplete_features)]
#![feature(const_trait_impl)]
-#![feature(const_fn)]
struct NonConstAdd(i32);
#![allow(incomplete_features)]
#![feature(const_trait_impl)]
-#![feature(const_fn)]
pub trait Plus {
fn plus(self, rhs: Self) -> Self;
error[E0015]: calls in constant functions are limited to constant functions, tuple structs and tuple variants
- --> $DIR/call-const-trait-method-fail.rs:26:5
+ --> $DIR/call-const-trait-method-fail.rs:25:5
|
LL | a.plus(b)
| ^^^^^^^^^
#![allow(incomplete_features)]
#![feature(const_trait_impl)]
-#![feature(const_fn)]
struct Int(i32);
-#![feature(const_fn)]
+#![feature(const_fn_trait_bound)]
#![feature(const_trait_impl)]
#![feature(const_trait_bound_opt_out)]
#![allow(incomplete_features)]
// check-pass
-#![feature(const_fn)]
+#![feature(const_fn_trait_bound)]
#![feature(const_trait_impl)]
#![feature(const_trait_bound_opt_out)]
#![allow(incomplete_features)]
// FIXME(jschievink): this is not rejected correctly (only when the non-const impl is actually used)
// ignore-test
-#![feature(const_fn)]
#![feature(const_trait_impl)]
#![allow(incomplete_features)]
#![cfg_attr(gated, feature(const_trait_bound_opt_out))]
#![allow(incomplete_features)]
#![feature(rustc_attrs)]
-#![feature(const_fn)]
+#![feature(const_fn_trait_bound)]
trait T {
const CONST: i32;
// Regression test for #69615.
-#![feature(const_trait_impl, const_fn)]
+#![feature(const_trait_impl)]
#![allow(incomplete_features)]
pub trait MyTrait {
mod test {
use crate::foo::foo;
- #[foo] //~ WARN: absolute paths must start with
- //~| WARN: previously accepted
- //~| WARN: absolute paths
- //~| WARN: previously accepted
- fn main() {
- }
+ #[foo]
+ fn main() {}
}
fn main() {
mod test {
use crate::foo::foo;
- #[foo] //~ WARN: absolute paths must start with
- //~| WARN: previously accepted
- //~| WARN: absolute paths
- //~| WARN: previously accepted
- fn main() {
- }
+ #[foo]
+ fn main() {}
}
fn main() {
+++ /dev/null
-warning: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition
- --> $DIR/suggestions-not-always-applicable.rs:17:5
- |
-LL | #[foo]
- | ^^^^^^
- |
-note: the lint level is defined here
- --> $DIR/suggestions-not-always-applicable.rs:8:9
- |
-LL | #![warn(rust_2018_compatibility)]
- | ^^^^^^^^^^^^^^^^^^^^^^^
- = note: `#[warn(absolute_paths_not_starting_with_crate)]` implied by `#[warn(rust_2018_compatibility)]`
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2018 edition!
- = note: for more information, see issue #53130 <https://github.com/rust-lang/rust/issues/53130>
- = note: this warning originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-warning: absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition
- --> $DIR/suggestions-not-always-applicable.rs:17:5
- |
-LL | #[foo]
- | ^^^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2018 edition!
- = note: for more information, see issue #53130 <https://github.com/rust-lang/rust/issues/53130>
- = note: this warning originates in an attribute macro (in Nightly builds, run with -Z macro-backtrace for more info)
-
-warning: 2 warnings emitted
-
target_os = "dragonfly",
target_os = "emscripten",
target_os = "freebsd",
+ target_os = "fuchsia",
target_os = "linux",
target_os = "macos",
target_os = "netbsd",
h.finish() //~ ERROR no method named `finish` found for struct `DefaultHasher`
}
-fn main() {}
+trait Bar {}
+impl Bar for String {}
+
+fn main() {
+ let s = String::from("hey");
+ let x: &dyn Bar = &s;
+ x.as_ref(); //~ ERROR the method `as_ref` exists for reference `&dyn Bar`, but its trait bounds
+}
LL | use std::hash::Hasher;
|
-error: aborting due to previous error
+error[E0599]: the method `as_ref` exists for reference `&dyn Bar`, but its trait bounds were not satisfied
+ --> $DIR/import-trait-for-method-call.rs:15:7
+ |
+LL | trait Bar {}
+ | --------- doesn't satisfy `dyn Bar: AsRef<_>`
+...
+LL | x.as_ref();
+ | ^^^^^^ method cannot be called on `&dyn Bar` due to unsatisfied trait bounds
+ |
+ = note: the following trait bounds were not satisfied:
+ `dyn Bar: AsRef<_>`
+ which is required by `&dyn Bar: AsRef<_>`
+ = help: items from traits can only be used if the trait is implemented and in scope
+ = note: the following trait defines an item `as_ref`, perhaps you need to implement it:
+ candidate #1: `AsRef`
+
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0599`.
// generate code which would trigger the lint.
pub struct Baz;
-pub trait Bar { }
+pub trait Bar {}
pub struct Qux<T>(T);
#[dom_struct]
pub struct Foo {
//~^ ERROR trait objects without an explicit `dyn` are deprecated [bare_trait_objects]
+ //~| WARN this was previously accepted by the compiler
qux: Qux<Qux<Baz>>,
bar: Box<Bar>,
//~^ ERROR trait objects without an explicit `dyn` are deprecated [bare_trait_objects]
+ //~| WARN this was previously accepted by the compiler
}
fn main() {}
error: trait objects without an explicit `dyn` are deprecated
- --> $DIR/issue-61963.rs:21:14
+ --> $DIR/issue-61963.rs:22:14
|
LL | bar: Box<Bar>,
| ^^^ help: use `dyn`: `dyn Bar`
|
LL | #![deny(bare_trait_objects)]
| ^^^^^^^^^^^^^^^^^^
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: trait objects without an explicit `dyn` are deprecated
--> $DIR/issue-61963.rs:18:1
|
LL | pub struct Foo {
| ^^^ help: use `dyn`: `dyn pub`
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: aborting due to 2 previous errors
--- /dev/null
+// test for suggestion on fieldless enum variant
+
+#[derive(PartialEq, Debug)]
+enum FarmAnimal {
+ Worm,
+ Cow,
+ Bull,
+ Chicken { num_eggs: usize },
+ Dog (String),
+}
+
+fn what_does_the_animal_say(animal: &FarmAnimal) {
+
+ let noise = match animal {
+ FarmAnimal::Cow(_) => "moo".to_string(),
+ //~^ ERROR expected tuple struct or tuple variant, found unit variant `FarmAnimal::Cow`
+ FarmAnimal::Chicken(_) => "cluck, cluck!".to_string(),
+ //~^ ERROR expected tuple struct or tuple variant, found struct variant `FarmAnimal::Chicken`
+ FarmAnimal::Dog{..} => "woof!".to_string(),
+ _ => todo!()
+ };
+
+ println!("{:?} says: {:?}", animal, noise);
+}
+
+fn main() {}
--- /dev/null
+error[E0532]: expected tuple struct or tuple variant, found unit variant `FarmAnimal::Cow`
+ --> $DIR/issue-84700.rs:15:9
+ |
+LL | Cow,
+ | --- `FarmAnimal::Cow` defined here
+...
+LL | FarmAnimal::Cow(_) => "moo".to_string(),
+ | ^^^^^^^^^^^^^^^^^^ help: use this syntax instead: `FarmAnimal::Cow`
+
+error[E0532]: expected tuple struct or tuple variant, found struct variant `FarmAnimal::Chicken`
+ --> $DIR/issue-84700.rs:17:9
+ |
+LL | Chicken { num_eggs: usize },
+ | --------------------------- `FarmAnimal::Chicken` defined here
+...
+LL | FarmAnimal::Chicken(_) => "cluck, cluck!".to_string(),
+ | ^^^^^^^^^^^^^^^^^^^^^^ help: use struct pattern syntax instead: `FarmAnimal::Chicken { num_eggs }`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0532`.
--- /dev/null
+// run-rustfix
+
+#![allow(dead_code, unused_variables)]
+
+fn foo1(bar: &str) {}
+//~^ ERROR the size for values of type `str` cannot be known at compilation time
+//~| HELP the trait `Sized` is not implemented for `str`
+//~| HELP unsized fn params are gated as an unstable feature
+//~| HELP function arguments must have a statically known size, borrowed types always have a known size
+
+fn foo2(_bar: &str) {}
+//~^ ERROR the size for values of type `str` cannot be known at compilation time
+//~| HELP the trait `Sized` is not implemented for `str`
+//~| HELP unsized fn params are gated as an unstable feature
+//~| HELP function arguments must have a statically known size, borrowed types always have a known size
+
+fn foo3(_: &str) {}
+//~^ ERROR the size for values of type `str` cannot be known at compilation time
+//~| HELP the trait `Sized` is not implemented for `str`
+//~| HELP unsized fn params are gated as an unstable feature
+//~| HELP function arguments must have a statically known size, borrowed types always have a known size
+
+fn main() {}
--- /dev/null
+// run-rustfix
+
+#![allow(dead_code, unused_variables)]
+
+fn foo1(bar: str) {}
+//~^ ERROR the size for values of type `str` cannot be known at compilation time
+//~| HELP the trait `Sized` is not implemented for `str`
+//~| HELP unsized fn params are gated as an unstable feature
+//~| HELP function arguments must have a statically known size, borrowed types always have a known size
+
+fn foo2(_bar: str) {}
+//~^ ERROR the size for values of type `str` cannot be known at compilation time
+//~| HELP the trait `Sized` is not implemented for `str`
+//~| HELP unsized fn params are gated as an unstable feature
+//~| HELP function arguments must have a statically known size, borrowed types always have a known size
+
+fn foo3(_: str) {}
+//~^ ERROR the size for values of type `str` cannot be known at compilation time
+//~| HELP the trait `Sized` is not implemented for `str`
+//~| HELP unsized fn params are gated as an unstable feature
+//~| HELP function arguments must have a statically known size, borrowed types always have a known size
+
+fn main() {}
--- /dev/null
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+ --> $DIR/unsized-function-parameter.rs:5:9
+ |
+LL | fn foo1(bar: str) {}
+ | ^^^ doesn't have a size known at compile-time
+ |
+ = help: the trait `Sized` is not implemented for `str`
+ = help: unsized fn params are gated as an unstable feature
+help: function arguments must have a statically known size, borrowed types always have a known size
+ |
+LL | fn foo1(bar: &str) {}
+ | ^
+
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+ --> $DIR/unsized-function-parameter.rs:11:9
+ |
+LL | fn foo2(_bar: str) {}
+ | ^^^^ doesn't have a size known at compile-time
+ |
+ = help: the trait `Sized` is not implemented for `str`
+ = help: unsized fn params are gated as an unstable feature
+help: function arguments must have a statically known size, borrowed types always have a known size
+ |
+LL | fn foo2(_bar: &str) {}
+ | ^
+
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+ --> $DIR/unsized-function-parameter.rs:17:9
+ |
+LL | fn foo3(_: str) {}
+ | ^ doesn't have a size known at compile-time
+ |
+ = help: the trait `Sized` is not implemented for `str`
+ = help: unsized fn params are gated as an unstable feature
+help: function arguments must have a statically known size, borrowed types always have a known size
+ |
+LL | fn foo3(_: &str) {}
+ | ^
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
// error-pattern:building tests with panic=abort is not supported
// no-prefer-dynamic
-// compile-flags: --test -Cpanic=abort
+// compile-flags: --test -Cpanic=abort -Zpanic-abort-tests=no
// run-flags: --test-threads=1
// ignore-wasm no panic or subprocess support
trait Foo {
- fn dummy(&self) { }
+ fn dummy(&self) {}
}
// This should emit the less confusing error, not the more confusing one.
fn foo(_x: Foo + Send) {
//~^ ERROR the size for values of type
//~| WARN trait objects without an explicit `dyn` are deprecated
+ //~| WARN this was previously accepted by the compiler
}
-fn main() { }
+fn main() {}
| ^^^^^^^^^^ help: use `dyn`: `dyn Foo + Send`
|
= note: `#[warn(bare_trait_objects)]` on by default
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error[E0277]: the size for values of type `(dyn Foo + Send + 'static)` cannot be known at compilation time
--> $DIR/not-on-bare-trait.rs:7:8
--- /dev/null
+// compile-flags: --crate-type lib
+// check-pass
+//
+// Regression test for issue #84399
+// Tests that we keep the full `ParamEnv` when
+// caching predicates with freshened types in the global cache
+
+use std::marker::PhantomData;
+pub trait Allocator<R> {
+ type Buffer;
+}
+pub struct DefaultAllocator;
+impl <R> Allocator<R> for DefaultAllocator {
+ type Buffer = ();
+}
+pub type Owned<R> = <DefaultAllocator as Allocator<R>>::Buffer;
+pub type MatrixMN<R> = Matrix<R, Owned<R>>;
+pub type Matrix4<N> = Matrix<N, ()>;
+pub struct Matrix<R, S> {
+ pub data: S,
+ _phantoms: PhantomData<R>,
+}
+pub fn set_object_transform(matrix: &Matrix4<()>) {
+ matrix.js_buffer_view();
+}
+pub trait Storable {
+ type Cell;
+ fn slice_to_items(_buffer: &()) -> &[Self::Cell] {
+ unimplemented!()
+ }
+}
+pub type Cell<T> = <T as Storable>::Cell;
+impl<R> Storable for MatrixMN<R>
+where
+ DefaultAllocator: Allocator<R>,
+{
+ type Cell = ();
+}
+pub trait JsBufferView {
+ fn js_buffer_view(&self) -> usize {
+ unimplemented!()
+ }
+}
+impl<R> JsBufferView for [MatrixMN<R>]
+where
+ DefaultAllocator: Allocator<R>,
+ MatrixMN<R>: Storable,
+ [Cell<MatrixMN<R>>]: JsBufferView,
+{
+ fn js_buffer_view(&self) -> usize {
+ <MatrixMN<R> as Storable>::slice_to_items(&()).js_buffer_view()
+ }
+}
+impl JsBufferView for [()] {}
+impl<R> JsBufferView for MatrixMN<R> where DefaultAllocator: Allocator<R> {}
LL | *self += 1;
| ^^^^^^^^^^ dereference of raw pointer
|
- = note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
+ = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: aborting due to previous error
--- /dev/null
+fn f() {
+ std::<0>; //~ ERROR expected value
+}
+fn j() {
+ std::<_ as _>; //~ ERROR expected value
+ //~^ ERROR expected one of `,` or `>`, found keyword `as`
+}
+
+fn main () {}
--- /dev/null
+error: expected one of `,` or `>`, found keyword `as`
+ --> $DIR/issue-84831.rs:5:13
+ |
+LL | std::<_ as _>;
+ | ^^ expected one of `,` or `>`
+ |
+help: expressions must be enclosed in braces to be used as const generic arguments
+ |
+LL | std::<{ _ as _ }>;
+ | ^ ^
+
+error[E0423]: expected value, found crate `std`
+ --> $DIR/issue-84831.rs:2:5
+ |
+LL | std::<0>;
+ | ^^^^^^^^ not a value
+
+error[E0423]: expected value, found crate `std`
+ --> $DIR/issue-84831.rs:5:5
+ |
+LL | std::<_ as _>;
+ | ^^^^^^^^^^^^^ not a value
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0423`.
LL | *(1 as *mut u32) = 42;
| ^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
|
- = note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
+ = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: aborting due to previous error
LL | *PTR;
| ^^^^ dereference of raw pointer
|
- = note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
+ = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: use of mutable static is unsafe and requires unsafe block (error E0133)
--> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:13:5
LL | *PTR;
| ^^^^ dereference of raw pointer
|
- = note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
+ = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: use of mutable static is unsafe and requires unsafe block (error E0133)
--> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:28:5
LL | *p = 0;
| ^^^^^^ dereference of raw pointer
|
- = note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
+ = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: aborting due to previous error
LL | return *p;
| ^^ dereference of raw pointer
|
- = note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
+ = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: aborting due to previous error
LL | *a == b
| ^^ dereference of raw pointer
|
- = note: raw pointers may be NULL, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
+ = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
error: aborting due to previous error
// run-pass
+// needs-unwind
// ignore-windows target requires uwtable
// ignore-wasm32-bare no proper panic=unwind support
// compile-flags: -C panic=unwind -C force-unwind-tables=n
| ^ unused parameter
|
= help: consider removing `A`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `A` to be a const parameter, use `const A: usize` instead
error[E0392]: parameter `A` is never used
--> $DIR/variance-unused-type-param.rs:9:15
| ^ unused parameter
|
= help: consider removing `A`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `A` to be a const parameter, use `const A: usize` instead
error[E0392]: parameter `T` is never used
--> $DIR/variance-unused-type-param.rs:13:15
| ^ unused parameter
|
= help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+ = help: if you intended `T` to be a const parameter, use `const T: usize` instead
error: aborting due to 3 previous errors
target_os = "dragonfly",
target_os = "emscripten",
target_os = "freebsd",
+ target_os = "fuchsia",
target_os = "linux",
target_os = "macos",
target_os = "netbsd",
-Subproject commit 4369396ce7d270972955d876eaa4954bea56bcd9
+Subproject commit f3e13226d6d17a2bc5f325303494b43a45f53b7f
let cargo = &Path::new(cargo);
for test in TEST_REPOS.iter().rev() {
- test_repo(cargo, out_dir, test);
+ if args[3..].is_empty() || args[3..].iter().any(|s| s.contains(test.name)) {
+ test_repo(cargo, out_dir, test);
+ }
}
}
create_test(&lint).context("Unable to create a test for the new lint")
}
-fn create_lint(lint: &LintData) -> io::Result<()> {
+fn create_lint(lint: &LintData<'_>) -> io::Result<()> {
let (pass_type, pass_lifetimes, pass_import, context_import) = match lint.pass {
"early" => ("EarlyLintPass", "", "use rustc_ast::ast::*;", "EarlyContext"),
"late" => ("LateLintPass", "<'_>", "use rustc_hir::*;", "LateContext"),
write_file(lint.project_root.join(&lint_path), lint_contents.as_bytes())
}
-fn create_test(lint: &LintData) -> io::Result<()> {
+fn create_test(lint: &LintData<'_>) -> io::Result<()> {
fn create_project_layout<P: Into<PathBuf>>(lint_name: &str, location: P, case: &str, hint: &str) -> io::Result<()> {
let mut path = location.into().join(case);
fs::create_dir(&path)?;
pub fn is_entrypoint_fn(cx: &LateContext<'_>, def_id: DefId) -> bool {
cx.tcx
.entry_fn(LOCAL_CRATE)
- .map_or(false, |(entry_fn_def_id, _)| def_id == entry_fn_def_id.to_def_id())
+ .map_or(false, |(entry_fn_def_id, _)| def_id == entry_fn_def_id)
}
/// Returns `true` if the expression is in the program's `#[panic_handler]`.
pub const PATH_BUF_AS_PATH: [&str; 4] = ["std", "path", "PathBuf", "as_path"];
pub const PATH_TO_PATH_BUF: [&str; 4] = ["std", "path", "Path", "to_path_buf"];
pub const PERMISSIONS: [&str; 3] = ["std", "fs", "Permissions"];
-pub const PERMISSIONS_FROM_MODE: [&str; 7] = ["std", "sys", "unix", "ext", "fs", "PermissionsExt", "from_mode"];
+pub const PERMISSIONS_FROM_MODE: [&str; 7] = ["std", "os", "imp", "unix", "fs", "PermissionsExt", "from_mode"];
pub const POLL: [&str; 4] = ["core", "task", "poll", "Poll"];
pub const POLL_PENDING: [&str; 5] = ["core", "task", "poll", "Poll", "Pending"];
pub const POLL_READY: [&str; 5] = ["core", "task", "poll", "Poll", "Ready"];
third_party_crates(),
));
- config.build_base = if cargo::is_rustc_test_suite() {
- // This make the stderr files go to clippy OUT_DIR on rustc repo build dir
- let mut path = PathBuf::from(env!("OUT_DIR"));
- path.push("test_build_base");
- path
- } else {
- host_lib().join("test_build_base")
- };
+ config.build_base = host_lib().join("test_build_base");
config.rustc_path = clippy_driver_path();
config
}
| ^^^^^^ help: use `dyn`: `dyn A + 'a`
|
= note: `-D bare-trait-objects` implied by `-D warnings`
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: trait objects without an explicit `dyn` are deprecated
--> $DIR/ice-3969.rs:27:16
|
LL | let x: Dst<A> = *(Box::new(Dst { x: 1 }) as Box<Dst<A>>);
| ^ help: use `dyn`: `dyn A`
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: trait objects without an explicit `dyn` are deprecated
--> $DIR/ice-3969.rs:27:57
|
LL | let x: Dst<A> = *(Box::new(Dst { x: 1 }) as Box<Dst<A>>);
| ^ help: use `dyn`: `dyn A`
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2021 edition!
+ = note: for more information, see issue #80165 <https://github.com/rust-lang/rust/issues/80165>
error: aborting due to 3 previous errors
let error_kind = ErrorKind::NotFound;
match error_kind {
ErrorKind::NotFound => {},
- ErrorKind::PermissionDenied | ErrorKind::ConnectionRefused | ErrorKind::ConnectionReset | ErrorKind::ConnectionAborted | ErrorKind::NotConnected | ErrorKind::AddrInUse | ErrorKind::AddrNotAvailable | ErrorKind::BrokenPipe | ErrorKind::AlreadyExists | ErrorKind::WouldBlock | ErrorKind::InvalidInput | ErrorKind::InvalidData | ErrorKind::TimedOut | ErrorKind::WriteZero | ErrorKind::Interrupted | ErrorKind::Other | ErrorKind::UnexpectedEof | ErrorKind::Unsupported | _ => {},
+ ErrorKind::PermissionDenied | ErrorKind::ConnectionRefused | ErrorKind::ConnectionReset | ErrorKind::ConnectionAborted | ErrorKind::NotConnected | ErrorKind::AddrInUse | ErrorKind::AddrNotAvailable | ErrorKind::BrokenPipe | ErrorKind::AlreadyExists | ErrorKind::WouldBlock | ErrorKind::InvalidInput | ErrorKind::InvalidData | ErrorKind::TimedOut | ErrorKind::WriteZero | ErrorKind::Interrupted | ErrorKind::Other | ErrorKind::UnexpectedEof | ErrorKind::Unsupported | ErrorKind::OutOfMemory | _ => {},
}
match error_kind {
ErrorKind::NotFound => {},
ErrorKind::Other => {},
ErrorKind::UnexpectedEof => {},
ErrorKind::Unsupported => {},
+ ErrorKind::OutOfMemory => {},
_ => {},
}
}
ErrorKind::Other => {},
ErrorKind::UnexpectedEof => {},
ErrorKind::Unsupported => {},
+ ErrorKind::OutOfMemory => {},
_ => {},
}
}
--> $DIR/wildcard_enum_match_arm.rs:80:9
|
LL | _ => {},
- | ^ help: try this: `ErrorKind::PermissionDenied | ErrorKind::ConnectionRefused | ErrorKind::ConnectionReset | ErrorKind::ConnectionAborted | ErrorKind::NotConnected | ErrorKind::AddrInUse | ErrorKind::AddrNotAvailable | ErrorKind::BrokenPipe | ErrorKind::AlreadyExists | ErrorKind::WouldBlock | ErrorKind::InvalidInput | ErrorKind::InvalidData | ErrorKind::TimedOut | ErrorKind::WriteZero | ErrorKind::Interrupted | ErrorKind::Other | ErrorKind::UnexpectedEof | ErrorKind::Unsupported | _`
+ | ^ help: try this: `ErrorKind::PermissionDenied | ErrorKind::ConnectionRefused | ErrorKind::ConnectionReset | ErrorKind::ConnectionAborted | ErrorKind::NotConnected | ErrorKind::AddrInUse | ErrorKind::AddrNotAvailable | ErrorKind::BrokenPipe | ErrorKind::AlreadyExists | ErrorKind::WouldBlock | ErrorKind::InvalidInput | ErrorKind::InvalidData | ErrorKind::TimedOut | ErrorKind::WriteZero | ErrorKind::Interrupted | ErrorKind::Other | ErrorKind::UnexpectedEof | ErrorKind::Unsupported | ErrorKind::OutOfMemory | _`
error: aborting due to 5 previous errors
}
}
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum PanicStrategy {
+ Unwind,
+ Abort,
+}
+
/// Configuration for compiletest
#[derive(Debug, Clone)]
pub struct Config {
/// Force the pass mode of a check/build/run-pass test to this mode.
pub force_pass_mode: Option<PassMode>,
+ /// Explicitly enable or disable running.
+ pub run: Option<bool>,
+
/// Write out a parseable log of tests that were run
pub logfile: Option<PathBuf>,
/// Flags to pass to the compiler when building for the target
pub target_rustcflags: Option<String>,
+ /// What panic strategy the target is built with. Unwind supports Abort, but
+ /// not vice versa.
+ pub target_panic: PanicStrategy,
+
/// Target system to be tested
pub target: String,
pub npm: Option<String>,
}
+impl Config {
+ pub fn run_enabled(&self) -> bool {
+ self.run.unwrap_or_else(|| {
+ // Auto-detect whether to run based on the platform.
+ !self.target.ends_with("-fuchsia")
+ })
+ }
+}
+
#[derive(Debug, Clone)]
pub struct TestPaths {
pub file: PathBuf, // e.g., compile-test/foo/bar/baz.rs
use tracing::*;
-use crate::common::{CompareMode, Config, Debugger, FailMode, Mode, PassMode};
+use crate::common::{CompareMode, Config, Debugger, FailMode, Mode, PanicStrategy, PassMode};
use crate::util;
use crate::{extract_cdb_version, extract_gdb_version};
props.ignore = true;
}
+ if !config.run_enabled() && config.parse_name_directive(ln, "needs-run-enabled") {
+ props.ignore = true;
+ }
+
if !rustc_has_sanitizer_support
&& config.parse_name_directive(ln, "needs-sanitizer-support")
{
props.ignore = true;
}
+ if config.target_panic == PanicStrategy::Abort
+ && config.parse_name_directive(ln, "needs-unwind")
+ {
+ props.ignore = true;
+ }
+
if config.target == "wasm32-unknown-unknown" && config.parse_check_run_results(ln) {
props.ignore = true;
}
extern crate test;
-use crate::common::{expected_output_path, output_base_dir, output_relative_path, UI_EXTENSIONS};
+use crate::common::{
+ expected_output_path, output_base_dir, output_relative_path, PanicStrategy, UI_EXTENSIONS,
+};
use crate::common::{CompareMode, Config, Debugger, Mode, PassMode, Pretty, TestPaths};
use crate::util::logv;
use getopts::Options;
"force {check,build,run}-pass tests to this mode.",
"check | build | run",
)
+ .optopt("", "run", "whether to execute run-* tests", "auto | always | never")
.optflag("", "ignored", "run tests marked as ignored")
.optflag("", "exact", "filters match exactly")
.optopt(
(eg. emulator, valgrind)",
"PROGRAM",
)
- .optopt("", "host-rustcflags", "flags to pass to rustc for host", "FLAGS")
- .optopt("", "target-rustcflags", "flags to pass to rustc for target", "FLAGS")
+ .optmulti("", "host-rustcflags", "flags to pass to rustc for host", "FLAGS")
+ .optmulti("", "target-rustcflags", "flags to pass to rustc for target", "FLAGS")
+ .optopt("", "target-panic", "what panic strategy the target supports", "unwind | abort")
.optflag("", "verbose", "run tests verbosely, showing all output")
.optflag(
"",
mode.parse::<PassMode>()
.unwrap_or_else(|_| panic!("unknown `--pass` option `{}` given", mode))
}),
+ run: matches.opt_str("run").and_then(|mode| match mode.as_str() {
+ "auto" => None,
+ "always" => Some(true),
+ "never" => Some(false),
+ _ => panic!("unknown `--run` option `{}` given", mode),
+ }),
logfile: matches.opt_str("logfile").map(|s| PathBuf::from(&s)),
runtool: matches.opt_str("runtool"),
- host_rustcflags: matches.opt_str("host-rustcflags"),
- target_rustcflags: matches.opt_str("target-rustcflags"),
+ host_rustcflags: Some(matches.opt_strs("host-rustcflags").join(" ")),
+ target_rustcflags: Some(matches.opt_strs("target-rustcflags").join(" ")),
+ target_panic: match matches.opt_str("target-panic").as_deref() {
+ Some("unwind") | None => PanicStrategy::Unwind,
+ Some("abort") => PanicStrategy::Abort,
+ _ => panic!("unknown `--target-panic` option `{}` given", mode),
+ },
target,
host: opt_str2(matches.opt_str("host")),
cdb,
pub fn compute_stamp_hash(config: &Config) -> String {
let mut hash = DefaultHasher::new();
config.stage_id.hash(&mut hash);
+ config.run.hash(&mut hash);
match config.debugger {
Some(Debugger::Cdb) => {
enum WillExecute {
Yes,
No,
+ Disabled,
}
/// Should `--emit metadata` be used?
}
fn should_run(&self, pm: Option<PassMode>) -> WillExecute {
- match self.config.mode {
- Ui if pm == Some(PassMode::Run) || self.props.fail_mode == Some(FailMode::Run) => {
- WillExecute::Yes
- }
- MirOpt if pm == Some(PassMode::Run) => WillExecute::Yes,
- Ui | MirOpt => WillExecute::No,
+ let test_should_run = match self.config.mode {
+ Ui if pm == Some(PassMode::Run) || self.props.fail_mode == Some(FailMode::Run) => true,
+ MirOpt if pm == Some(PassMode::Run) => true,
+ Ui | MirOpt => false,
mode => panic!("unimplemented for mode {:?}", mode),
- }
+ };
+ if test_should_run { self.run_if_enabled() } else { WillExecute::No }
+ }
+
+ fn run_if_enabled(&self) -> WillExecute {
+ if self.config.run_enabled() { WillExecute::Yes } else { WillExecute::Disabled }
}
fn should_run_successfully(&self, pm: Option<PassMode>) -> bool {
fn run_rfail_test(&self) {
let pm = self.pass_mode();
- let proc_res = self.compile_test(WillExecute::Yes, self.should_emit_metadata(pm));
+ let should_run = self.run_if_enabled();
+ let proc_res = self.compile_test(should_run, self.should_emit_metadata(pm));
if !proc_res.status.success() {
self.fatal_proc_rec("compilation failed!", &proc_res);
}
+ if let WillExecute::Disabled = should_run {
+ return;
+ }
+
let proc_res = self.exec_compiled_test();
// The value our Makefile configures valgrind to return on failure
fn run_rpass_test(&self) {
let emit_metadata = self.should_emit_metadata(self.pass_mode());
- let proc_res = self.compile_test(WillExecute::Yes, emit_metadata);
+ let should_run = self.run_if_enabled();
+ let proc_res = self.compile_test(should_run, emit_metadata);
if !proc_res.status.success() {
self.fatal_proc_rec("compilation failed!", &proc_res);
}
+ if let WillExecute::Disabled = should_run {
+ return;
+ }
+
// FIXME(#41968): Move this check to tidy?
let expected_errors = errors::load_errors(&self.testpaths.file, self.revision);
assert!(
return self.run_rpass_test();
}
- let mut proc_res = self.compile_test(WillExecute::Yes, EmitMetadata::No);
+ let should_run = self.run_if_enabled();
+ let mut proc_res = self.compile_test(should_run, EmitMetadata::No);
if !proc_res.status.success() {
self.fatal_proc_rec("compilation failed!", &proc_res);
}
+ if let WillExecute::Disabled = should_run {
+ return;
+ }
+
let mut new_config = self.config.clone();
new_config.runtool = new_config.valgrind_path.clone();
let new_cx = TestCx { config: &new_config, ..*self };
fn run_debuginfo_cdb_test_no_opt(&self) {
// compile test file (it should have 'compile-flags:-g' in the header)
- let compile_result = self.compile_test(WillExecute::Yes, EmitMetadata::No);
+ let should_run = self.run_if_enabled();
+ let compile_result = self.compile_test(should_run, EmitMetadata::No);
if !compile_result.status.success() {
self.fatal_proc_rec("compilation failed!", &compile_result);
}
+ if let WillExecute::Disabled = should_run {
+ return;
+ }
let exe_file = self.make_exe_name();
let mut cmds = commands.join("\n");
// compile test file (it should have 'compile-flags:-g' in the header)
- let compiler_run_result = self.compile_test(WillExecute::Yes, EmitMetadata::No);
+ let should_run = self.run_if_enabled();
+ let compiler_run_result = self.compile_test(should_run, EmitMetadata::No);
if !compiler_run_result.status.success() {
self.fatal_proc_rec("compilation failed!", &compiler_run_result);
}
+ if let WillExecute::Disabled = should_run {
+ return;
+ }
let exe_file = self.make_exe_name();
fn run_debuginfo_lldb_test_no_opt(&self) {
// compile test file (it should have 'compile-flags:-g' in the header)
- let compile_result = self.compile_test(WillExecute::Yes, EmitMetadata::No);
+ let should_run = self.run_if_enabled();
+ let compile_result = self.compile_test(should_run, EmitMetadata::No);
if !compile_result.status.success() {
self.fatal_proc_rec("compilation failed!", &compile_result);
}
+ if let WillExecute::Disabled = should_run {
+ return;
+ }
let exe_file = self.make_exe_name();
// Only use `make_exe_name` when the test ends up being executed.
let output_file = match will_execute {
WillExecute::Yes => TargetLocation::ThisFile(self.make_exe_name()),
- WillExecute::No => TargetLocation::ThisDirectory(self.output_base_dir()),
+ WillExecute::No | WillExecute::Disabled => {
+ TargetLocation::ThisDirectory(self.output_base_dir())
+ }
};
let allow_unused = match self.config.mode {
("nonstandard-style", "Violation of standard naming conventions"),
("future-incompatible", "Lints that detect code that has future-compatibility problems"),
("rust-2018-compatibility", "Lints used to transition code from the 2015 edition to 2018"),
+ ("rust-2021-compatibility", "Lints used to transition code from the 2018 edition to 2021"),
];
type LintGroups = BTreeMap<String, BTreeSet<String>>;
-Subproject commit 5faf5a5ca059f6eb067fc86e47480f5668ac6e8c
+Subproject commit 67c04afc251ad7d80ea22e2056c93349e7e9df58
-Subproject commit 74d1800c25498689c5b5120a1e8495fce0cd0d0d
+Subproject commit 359513ce678efba186972e4f280dbc7046cac15f
-Subproject commit 617535393bb5ccc7adf0bac8a3b9a9c306454e79
+Subproject commit eb741e895f1a73420a401f2495c711afe37d9d19
-Subproject commit 0bd2b1927c2b02a6fe7447d58e897cf1f1a1d41f
+Subproject commit 2a3635d5d1218c726ff58af4bc35418836143f69
("fortanix-sgx-abi", "MPL-2.0"), // libstd but only for `sgx` target
];
+const EXCEPTIONS_CRANELIFT: &[(&str, &str)] = &[
+ ("cranelift-bforest", "Apache-2.0 WITH LLVM-exception"),
+ ("cranelift-codegen", "Apache-2.0 WITH LLVM-exception"),
+ ("cranelift-codegen-meta", "Apache-2.0 WITH LLVM-exception"),
+ ("cranelift-codegen-shared", "Apache-2.0 WITH LLVM-exception"),
+ ("cranelift-entity", "Apache-2.0 WITH LLVM-exception"),
+ ("cranelift-frontend", "Apache-2.0 WITH LLVM-exception"),
+ ("cranelift-jit", "Apache-2.0 WITH LLVM-exception"),
+ ("cranelift-module", "Apache-2.0 WITH LLVM-exception"),
+ ("cranelift-native", "Apache-2.0 WITH LLVM-exception"),
+ ("cranelift-object", "Apache-2.0 WITH LLVM-exception"),
+ ("libloading", "ISC"),
+ ("mach", "BSD-2-Clause"),
+ ("regalloc", "Apache-2.0 WITH LLVM-exception"),
+ ("target-lexicon", "Apache-2.0 WITH LLVM-exception"),
+];
+
/// These are the root crates that are part of the runtime. The licenses for
/// these and all their dependencies *must not* be in the exception list.
const RUNTIME_CRATES: &[&str] = &["std", "core", "alloc", "test", "panic_abort", "panic_unwind"];
/// Crates whose dependencies must be explicitly permitted.
-const RESTRICTED_DEPENDENCY_CRATES: &[&str] = &["rustc_middle", "rustc_codegen_llvm"];
+const RESTRICTED_DEPENDENCY_CRATES: &[&str] = &["rustc_driver", "rustc_codegen_llvm"];
/// Crates rustc is allowed to depend on. Avoid adding to the list if possible.
///
"cc",
"cfg-if",
"chalk-derive",
+ "chalk-engine",
"chalk-ir",
+ "chalk-solve",
+ "chrono",
"cmake",
"compiler_builtins",
"cpuid-bool",
"expect-test",
"fake-simd",
"filetime",
+ "fixedbitset",
"flate2",
"fortanix-sgx-abi",
"fuchsia-zircon",
"indexmap",
"instant",
"itertools",
+ "itoa",
"jobserver",
"kernel32-sys",
"lazy_static",
"libz-sys",
"lock_api",
"log",
+ "matchers",
"maybe-uninit",
"md-5",
"measureme",
"memoffset",
"miniz_oxide",
"num_cpus",
+ "num-integer",
+ "num-traits",
"object",
"once_cell",
"opaque-debug",
"parking_lot_core",
"pathdiff",
"perf-event-open-sys",
+ "petgraph",
"pin-project-lite",
"pkg-config",
"polonius-engine",
"rand_xorshift",
"redox_syscall",
"regex",
+ "regex-automata",
"regex-syntax",
"remove_dir_all",
+ "rls-data",
+ "rls-span",
"rustc-demangle",
"rustc-hash",
"rustc-rayon",
"rustc-rayon-core",
"rustc_version",
+ "ryu",
"scoped-tls",
"scopeguard",
"semver",
"semver-parser",
"serde",
"serde_derive",
+ "serde_json",
"sha-1",
"sha2",
"smallvec",
+ "sharded-slab",
"snap",
"stable_deref_trait",
"stacker",
"termcolor",
"termize",
"thread_local",
+ "time",
+ "tinyvec",
"tracing",
"tracing-attributes",
"tracing-core",
+ "tracing-log",
+ "tracing-serde",
+ "tracing-subscriber",
+ "tracing-tree",
"typenum",
"unicode-normalization",
"unicode-script",
"winapi-i686-pc-windows-gnu",
"winapi-util",
"winapi-x86_64-pc-windows-gnu",
+ // this is a false-positive: it's only used by rustfmt, but because it's enabled through a feature, tidy thinks it's used by rustc as well.
+ "yansi-term",
+];
+
+const PERMITTED_CRANELIFT_DEPENDENCIES: &[&str] = &[
+ "anyhow",
+ "ar",
+ "autocfg",
+ "bitflags",
+ "byteorder",
+ "cfg-if",
+ "cranelift-bforest",
+ "cranelift-codegen",
+ "cranelift-codegen-meta",
+ "cranelift-codegen-shared",
+ "cranelift-entity",
+ "cranelift-frontend",
+ "cranelift-jit",
+ "cranelift-module",
+ "cranelift-native",
+ "cranelift-object",
+ "crc32fast",
+ "errno",
+ "errno-dragonfly",
+ "gcc",
+ "gimli",
+ "hashbrown",
+ "indexmap",
+ "libc",
+ "libloading",
+ "log",
+ "mach",
+ "object",
+ "proc-macro2",
+ "quote",
+ "regalloc",
+ "region",
+ "rustc-hash",
+ "smallvec",
+ "syn",
+ "target-lexicon",
+ "thiserror",
+ "thiserror-impl",
+ "unicode-xid",
+ "winapi",
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+];
+
+const FORBIDDEN_TO_HAVE_DUPLICATES: &[&str] = &[
+ // These two crates take quite a long time to build, so don't allow two versions of them
+ // to accidentally sneak into our dependency graph, in order to ensure we keep our CI times
+ // under control.
+ "cargo",
+ "rustc-ap-rustc_ast",
];
/// Dependency checks.
.manifest_path(root.join("Cargo.toml"))
.features(cargo_metadata::CargoOpt::AllFeatures);
let metadata = t!(cmd.exec());
- check_exceptions(&metadata, bad);
- check_dependencies(&metadata, bad);
- check_crate_duplicate(&metadata, bad);
+ let runtime_ids = compute_runtime_crates(&metadata);
+ check_exceptions(&metadata, EXCEPTIONS, runtime_ids, bad);
+ check_dependencies(&metadata, PERMITTED_DEPENDENCIES, RESTRICTED_DEPENDENCY_CRATES, bad);
+ check_crate_duplicate(&metadata, FORBIDDEN_TO_HAVE_DUPLICATES, bad);
+
+ // Check rustc_codegen_cranelift independently as it has it's own workspace.
+ let mut cmd = cargo_metadata::MetadataCommand::new();
+ cmd.cargo_path(cargo)
+ .manifest_path(root.join("compiler/rustc_codegen_cranelift/Cargo.toml"))
+ .features(cargo_metadata::CargoOpt::AllFeatures);
+ let metadata = t!(cmd.exec());
+ let runtime_ids = HashSet::new();
+ check_exceptions(&metadata, EXCEPTIONS_CRANELIFT, runtime_ids, bad);
+ check_dependencies(
+ &metadata,
+ PERMITTED_CRANELIFT_DEPENDENCIES,
+ &["rustc_codegen_cranelift"],
+ bad,
+ );
+ check_crate_duplicate(&metadata, &[], bad);
}
/// Check that all licenses are in the valid list in `LICENSES`.
///
/// Packages listed in `EXCEPTIONS` are allowed for tools.
-fn check_exceptions(metadata: &Metadata, bad: &mut bool) {
+fn check_exceptions(
+ metadata: &Metadata,
+ exceptions: &[(&str, &str)],
+ runtime_ids: HashSet<&PackageId>,
+ bad: &mut bool,
+) {
// Validate the EXCEPTIONS list hasn't changed.
- for (name, license) in EXCEPTIONS {
+ for (name, license) in exceptions {
// Check that the package actually exists.
if !metadata.packages.iter().any(|p| p.name == *name) {
tidy_error!(
}
// Check that the license hasn't changed.
for pkg in metadata.packages.iter().filter(|p| p.name == *name) {
- if pkg.name == "fuchsia-cprng" {
- // This package doesn't declare a license expression. Manual
- // inspection of the license file is necessary, which appears
- // to be BSD-3-Clause.
- assert!(pkg.license.is_none());
- continue;
- }
match &pkg.license {
None => {
tidy_error!(
}
Some(pkg_license) => {
if pkg_license.as_str() != *license {
- if *name == "crossbeam-queue"
- && *license == "MIT/Apache-2.0 AND BSD-2-Clause"
- {
- // We have two versions of crossbeam-queue and both
- // are fine.
- continue;
- }
-
println!("dependency exception `{}` license has changed", name);
println!(" previously `{}` now `{}`", license, pkg_license);
println!(" update EXCEPTIONS for the new license");
}
}
- let exception_names: Vec<_> = EXCEPTIONS.iter().map(|(name, _license)| *name).collect();
- let runtime_ids = compute_runtime_crates(metadata);
+ let exception_names: Vec<_> = exceptions.iter().map(|(name, _license)| *name).collect();
// Check if any package does not have a valid license.
for pkg in &metadata.packages {
/// `true` if a check failed.
///
/// Specifically, this checks that the dependencies are on the `PERMITTED_DEPENDENCIES`.
-fn check_dependencies(metadata: &Metadata, bad: &mut bool) {
+fn check_dependencies(
+ metadata: &Metadata,
+ permitted_dependencies: &[&'static str],
+ restricted_dependency_crates: &[&'static str],
+ bad: &mut bool,
+) {
// Check that the PERMITTED_DEPENDENCIES does not have unused entries.
- for name in PERMITTED_DEPENDENCIES {
+ for name in permitted_dependencies {
if !metadata.packages.iter().any(|p| p.name == *name) {
tidy_error!(
bad,
}
}
// Get the list in a convenient form.
- let permitted_dependencies: HashSet<_> = PERMITTED_DEPENDENCIES.iter().cloned().collect();
+ let permitted_dependencies: HashSet<_> = permitted_dependencies.iter().cloned().collect();
// Check dependencies.
let mut visited = BTreeSet::new();
let mut unapproved = BTreeSet::new();
- for &krate in RESTRICTED_DEPENDENCY_CRATES.iter() {
+ for &krate in restricted_dependency_crates.iter() {
let pkg = pkg_from_name(metadata, krate);
let mut bad =
check_crate_dependencies(&permitted_dependencies, metadata, &mut visited, pkg);
}
/// Prevents multiple versions of some expensive crates.
-fn check_crate_duplicate(metadata: &Metadata, bad: &mut bool) {
- const FORBIDDEN_TO_HAVE_DUPLICATES: &[&str] = &[
- // These two crates take quite a long time to build, so don't allow two versions of them
- // to accidentally sneak into our dependency graph, in order to ensure we keep our CI times
- // under control.
- "cargo",
- "rustc-ap-rustc_ast",
- ];
-
- for &name in FORBIDDEN_TO_HAVE_DUPLICATES {
+fn check_crate_duplicate(
+ metadata: &Metadata,
+ forbidden_to_have_duplicates: &[&str],
+ bad: &mut bool,
+) {
+ for &name in forbidden_to_have_duplicates {
let matches: Vec<_> = metadata.packages.iter().filter(|pkg| pkg.name == name).collect();
match matches.len() {
0 => {
.iter()
.find(|n| &n.id == pkg_id)
.unwrap_or_else(|| panic!("could not find `{}` in resolve", pkg_id));
- // Don't care about dev-dependencies.
- // Build dependencies *shouldn't* matter unless they do some kind of
- // codegen. For now we'll assume they don't.
- let deps = node.deps.iter().filter(|node_dep| {
- node_dep
- .dep_kinds
- .iter()
- .any(|kind_info| kind_info.kind == cargo_metadata::DependencyKind::Normal)
- });
- for dep in deps {
+ for dep in &node.deps {
normal_deps_of_r(resolve, &dep.pkg, result);
}
}
projects / rust.git / commitdiff