Rollup merge of #74162 - lcnr:ToPredicate-no-ref, r=varkor
take self by value in ToPredicate
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6ffc8a7..a38761d1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -363,35 +363,6 @@
env:
DEPLOY_TOOLSTATES_JSON: toolstates-linux.json
os: ubuntu-latest-xl
- - name: dist-x86_64-apple
- env:
- SCRIPT: "./x.py dist"
- RUST_CONFIGURE_ARGS: "--target=aarch64-apple-ios,x86_64-apple-ios --enable-full-tools --enable-sanitizers --enable-profiler --set rust.jemalloc"
- RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
- MACOSX_DEPLOYMENT_TARGET: 10.7
- NO_LLVM_ASSERTIONS: 1
- NO_DEBUG_ASSERTIONS: 1
- DIST_REQUIRE_ALL_TOOLS: 1
- os: macos-latest
- - name: dist-x86_64-apple-alt
- env:
- SCRIPT: "./x.py dist"
- RUST_CONFIGURE_ARGS: "--enable-extended --enable-profiler --set rust.jemalloc"
- RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
- MACOSX_DEPLOYMENT_TARGET: 10.7
- NO_LLVM_ASSERTIONS: 1
- NO_DEBUG_ASSERTIONS: 1
- os: macos-latest
- - name: x86_64-apple
- env:
- SCRIPT: "./x.py test"
- RUST_CONFIGURE_ARGS: "--build=x86_64-apple-darwin --enable-sanitizers --enable-profiler --set rust.jemalloc"
- RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
- MACOSX_DEPLOYMENT_TARGET: 10.8
- MACOSX_STD_DEPLOYMENT_TARGET: 10.7
- NO_LLVM_ASSERTIONS: 1
- NO_DEBUG_ASSERTIONS: 1
- os: macos-latest
- name: x86_64-msvc-1
env:
RUST_CONFIGURE_ARGS: "--build=x86_64-pc-windows-msvc --enable-profiler"
@@ -571,6 +542,132 @@
AWS_ACCESS_KEY_ID: "${{ env.ARTIFACTS_AWS_ACCESS_KEY_ID }}"
AWS_SECRET_ACCESS_KEY: "${{ secrets[format('AWS_SECRET_ACCESS_KEY_{0}', env.ARTIFACTS_AWS_ACCESS_KEY_ID)] }}"
if: "success() && !env.SKIP_JOB && (github.event_name == 'push' || env.DEPLOY == '1' || env.DEPLOY_ALT == '1')"
+ auto-fallible:
+ name: auto-fallible
+ env:
+ CI_JOB_NAME: "${{ matrix.name }}"
+ SCCACHE_BUCKET: rust-lang-gha-caches
+ DEPLOY_BUCKET: rust-lang-gha
+ TOOLSTATE_REPO: "https://github.com/pietroalbini/rust-toolstate"
+ TOOLSTATE_ISSUES_API_URL: "https://api.github.com/repos/pietroalbini/rust-toolstate/issues"
+ TOOLSTATE_PUBLISH: 1
+ CACHES_AWS_ACCESS_KEY_ID: AKIA46X5W6CZOMUQATD5
+ ARTIFACTS_AWS_ACCESS_KEY_ID: AKIA46X5W6CZH5AYXDVF
+ CACHE_DOMAIN: ci-caches-gha.rust-lang.org
+ if: "github.event_name == 'push' && github.ref == 'refs/heads/auto' && github.repository == 'rust-lang-ci/rust'"
+ strategy:
+ matrix:
+ include:
+ - name: dist-x86_64-apple
+ env:
+ SCRIPT: "./x.py dist"
+ RUST_CONFIGURE_ARGS: "--target=aarch64-apple-ios,x86_64-apple-ios --enable-full-tools --enable-sanitizers --enable-profiler --set rust.jemalloc"
+ RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
+ MACOSX_DEPLOYMENT_TARGET: 10.7
+ NO_LLVM_ASSERTIONS: 1
+ NO_DEBUG_ASSERTIONS: 1
+ DIST_REQUIRE_ALL_TOOLS: 1
+ os: macos-latest
+ - name: dist-x86_64-apple-alt
+ env:
+ SCRIPT: "./x.py dist"
+ RUST_CONFIGURE_ARGS: "--enable-extended --enable-profiler --set rust.jemalloc"
+ RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
+ MACOSX_DEPLOYMENT_TARGET: 10.7
+ NO_LLVM_ASSERTIONS: 1
+ NO_DEBUG_ASSERTIONS: 1
+ os: macos-latest
+ - name: x86_64-apple
+ env:
+ SCRIPT: "./x.py test"
+ RUST_CONFIGURE_ARGS: "--build=x86_64-apple-darwin --enable-sanitizers --enable-profiler --set rust.jemalloc"
+ RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
+ MACOSX_DEPLOYMENT_TARGET: 10.8
+ MACOSX_STD_DEPLOYMENT_TARGET: 10.7
+ NO_LLVM_ASSERTIONS: 1
+ NO_DEBUG_ASSERTIONS: 1
+ os: macos-latest
+ timeout-minutes: 600
+ runs-on: "${{ matrix.os }}"
+ steps:
+ - name: disable git crlf conversion
+ run: git config --global core.autocrlf false
+ shell: bash
+ - name: checkout the source code
+ uses: actions/checkout@v1
+ with:
+ fetch-depth: 2
+ - name: configure GitHub Actions to kill the build when outdated
+ uses: rust-lang/simpleinfra/github-actions/cancel-outdated-builds@master
+ with:
+ github_token: "${{ secrets.github_token }}"
+ if: "success() && !env.SKIP_JOB && github.ref != 'refs/heads/try'"
+ - name: add extra environment variables
+ run: src/ci/scripts/setup-environment.sh
+ env:
+ EXTRA_VARIABLES: "${{ toJson(matrix.env) }}"
+ if: success() && !env.SKIP_JOB
+ - name: decide whether to skip this job
+ run: src/ci/scripts/should-skip-this.sh
+ if: success() && !env.SKIP_JOB
+ - name: collect CPU statistics
+ run: src/ci/scripts/collect-cpu-stats.sh
+ if: success() && !env.SKIP_JOB
+ - name: show the current environment
+ run: src/ci/scripts/dump-environment.sh
+ if: success() && !env.SKIP_JOB
+ - name: install awscli
+ run: src/ci/scripts/install-awscli.sh
+ if: success() && !env.SKIP_JOB
+ - name: install sccache
+ run: src/ci/scripts/install-sccache.sh
+ if: success() && !env.SKIP_JOB
+ - name: install clang
+ run: src/ci/scripts/install-clang.sh
+ if: success() && !env.SKIP_JOB
+ - name: install WIX
+ run: src/ci/scripts/install-wix.sh
+ if: success() && !env.SKIP_JOB
+ - name: ensure the build happens on a partition with enough space
+ run: src/ci/scripts/symlink-build-dir.sh
+ if: success() && !env.SKIP_JOB
+ - name: disable git crlf conversion
+ run: src/ci/scripts/disable-git-crlf-conversion.sh
+ if: success() && !env.SKIP_JOB
+ - name: install MSYS2
+ run: src/ci/scripts/install-msys2.sh
+ if: success() && !env.SKIP_JOB
+ - name: install MinGW
+ run: src/ci/scripts/install-mingw.sh
+ if: success() && !env.SKIP_JOB
+ - name: install ninja
+ run: src/ci/scripts/install-ninja.sh
+ if: success() && !env.SKIP_JOB
+ - name: enable ipv6 on Docker
+ run: src/ci/scripts/enable-docker-ipv6.sh
+ if: success() && !env.SKIP_JOB
+ - name: disable git crlf conversion
+ run: src/ci/scripts/disable-git-crlf-conversion.sh
+ if: success() && !env.SKIP_JOB
+ - name: checkout submodules
+ run: src/ci/scripts/checkout-submodules.sh
+ if: success() && !env.SKIP_JOB
+ - name: ensure line endings are correct
+ run: src/ci/scripts/verify-line-endings.sh
+ if: success() && !env.SKIP_JOB
+ - name: run the build
+ run: src/ci/scripts/run-build-from-ci.sh
+ env:
+ AWS_ACCESS_KEY_ID: "${{ env.CACHES_AWS_ACCESS_KEY_ID }}"
+ AWS_SECRET_ACCESS_KEY: "${{ secrets[format('AWS_SECRET_ACCESS_KEY_{0}', env.CACHES_AWS_ACCESS_KEY_ID)] }}"
+ TOOLSTATE_REPO_ACCESS_TOKEN: "${{ secrets.TOOLSTATE_REPO_ACCESS_TOKEN }}"
+ if: success() && !env.SKIP_JOB
+ - name: upload artifacts to S3
+ run: src/ci/scripts/upload-artifacts.sh
+ env:
+ AWS_ACCESS_KEY_ID: "${{ env.ARTIFACTS_AWS_ACCESS_KEY_ID }}"
+ AWS_SECRET_ACCESS_KEY: "${{ secrets[format('AWS_SECRET_ACCESS_KEY_{0}', env.ARTIFACTS_AWS_ACCESS_KEY_ID)] }}"
+ if: "success() && !env.SKIP_JOB && (github.event_name == 'push' || env.DEPLOY == '1' || env.DEPLOY_ALT == '1')"
master:
name: master
runs-on: ubuntu-latest
diff --git a/Cargo.lock b/Cargo.lock
index cedf44b..2096a3d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1366,8 +1366,8 @@
name = "installer"
version = "0.0.0"
dependencies = [
+ "anyhow",
"clap",
- "failure",
"flate2",
"lazy_static",
"num_cpus",
diff --git a/config.toml.example b/config.toml.example
index 2fa6137..79e4e46 100644
--- a/config.toml.example
+++ b/config.toml.example
@@ -318,7 +318,9 @@
#codegen-units-std = 1
# Whether or not debug assertions are enabled for the compiler and standard
-# library.
+# library. Debug assertions control the maximum log level used by rustc. When
+# enabled calls to `trace!` and `debug!` macros are preserved in the compiled
+# binary, otherwise they are omitted.
#
# Defaults to rust.debug value
#debug-assertions = false
@@ -331,7 +333,9 @@
# Debuginfo level for most of Rust code, corresponds to the `-C debuginfo=N` option of `rustc`.
# `0` - no debug info
-# `1` - line tables only
+# `1` - line tables only - sufficient to generate backtraces that include line
+# information and inlined functions, set breakpoints at source code
+# locations, and step through execution in a debugger.
# `2` - full debug info with variable and type information
# Can be overridden for specific subsets of Rust code (rustc, std or tools).
# Debuginfo for tests run with compiletest is not controlled by this option
diff --git a/src/bootstrap/compile.rs b/src/bootstrap/compile.rs
index 84545dc..9b4926f 100644
--- a/src/bootstrap/compile.rs
+++ b/src/bootstrap/compile.rs
@@ -963,10 +963,11 @@
.collect::<Vec<_>>();
for (prefix, extension, expected_len) in toplevel {
let candidates = contents.iter().filter(|&&(_, ref filename, ref meta)| {
- filename.starts_with(&prefix[..])
- && filename[prefix.len()..].starts_with('-')
- && filename.ends_with(&extension[..])
- && meta.len() == expected_len
+ meta.len() == expected_len
+ && filename
+ .strip_prefix(&prefix[..])
+ .map(|s| s.starts_with('-') && s.ends_with(&extension[..]))
+ .unwrap_or(false)
});
let max = candidates
.max_by_key(|&&(_, _, ref metadata)| FileTime::from_last_modification_time(metadata));
diff --git a/src/bootstrap/doc.rs b/src/bootstrap/doc.rs
index ed35135..582bc9d 100644
--- a/src/bootstrap/doc.rs
+++ b/src/bootstrap/doc.rs
@@ -156,7 +156,7 @@
let index = out.join("index.html");
let rustbook = builder.tool_exe(Tool::Rustbook);
let mut rustbook_cmd = builder.tool_cmd(Tool::Rustbook);
- if up_to_date(&src, &index) && up_to_date(&rustbook, &index) {
+ if builder.config.dry_run || up_to_date(&src, &index) && up_to_date(&rustbook, &index) {
return;
}
builder.info(&format!("Rustbook ({}) - {}", target, name));
@@ -439,8 +439,6 @@
builder.cargo(compiler, Mode::Std, SourceType::InTree, target, "rustdoc");
compile::std_cargo(builder, target, compiler.stage, &mut cargo);
- // Keep a whitelist so we do not build internal stdlib crates, these will be
- // build by the rustc step later if enabled.
cargo.arg("-p").arg(package);
// Create all crate output directories first to make sure rustdoc uses
// relative links.
@@ -460,6 +458,10 @@
builder.run(&mut cargo.into());
};
+ // Only build the following crates. While we could just iterate over the
+ // folder structure, that would also build internal crates that we do
+ // not want to show in documentation. These crates will later be visited
+ // by the rustc step, so internal documentation will show them.
let krates = ["alloc", "core", "std", "proc_macro", "test"];
for krate in &krates {
run_cargo_rustdoc_for(krate);
diff --git a/src/bootstrap/lib.rs b/src/bootstrap/lib.rs
index b973889..783a64c 100644
--- a/src/bootstrap/lib.rs
+++ b/src/bootstrap/lib.rs
@@ -436,10 +436,9 @@
output(Command::new(&build.initial_rustc).arg("--version").arg("--verbose"));
let local_release = local_version_verbose
.lines()
- .filter(|x| x.starts_with("release:"))
+ .filter_map(|x| x.strip_prefix("release:"))
.next()
.unwrap()
- .trim_start_matches("release:")
.trim();
let my_version = channel::CFG_RELEASE_NUM;
if local_release.split('.').take(2).eq(my_version.split('.').take(2)) {
@@ -1089,10 +1088,10 @@
let toml_file_name = self.src.join(&format!("src/tools/{}/Cargo.toml", package));
let toml = t!(fs::read_to_string(&toml_file_name));
for line in toml.lines() {
- let prefix = "version = \"";
- let suffix = "\"";
- if line.starts_with(prefix) && line.ends_with(suffix) {
- return line[prefix.len()..line.len() - suffix.len()].to_string();
+ if let Some(stripped) =
+ line.strip_prefix("version = \"").and_then(|s| s.strip_suffix("\""))
+ {
+ return stripped.to_owned();
}
}
diff --git a/src/bootstrap/test.rs b/src/bootstrap/test.rs
index 3125325..1916d96 100644
--- a/src/bootstrap/test.rs
+++ b/src/bootstrap/test.rs
@@ -1562,7 +1562,7 @@
let compiler = builder.compiler(builder.top_stage, run.host);
for krate in builder.in_tree_crates("rustc-main") {
- if run.path.ends_with(&krate.path) {
+ if krate.path.ends_with(&run.path) {
let test_kind = builder.kind.into();
builder.ensure(CrateLibrustc {
@@ -1669,7 +1669,7 @@
};
for krate in builder.in_tree_crates("test") {
- if run.path.ends_with(&krate.local_path(&builder)) {
+ if krate.path.ends_with(&run.path) {
make(Mode::Std, krate);
}
}
diff --git a/src/ci/docker/host-x86_64/disabled/riscv64gc-linux/Dockerfile b/src/ci/docker/host-x86_64/disabled/riscv64gc-linux/Dockerfile
index 40c02ba..a938899 100644
--- a/src/ci/docker/host-x86_64/disabled/riscv64gc-linux/Dockerfile
+++ b/src/ci/docker/host-x86_64/disabled/riscv64gc-linux/Dockerfile
@@ -40,9 +40,9 @@
cp linux.config linux-5.6.16/.config && \
cd /build/linux-5.6.16 && \
make olddefconfig && \
- make -j$(nproc) vmlinux
-RUN cp linux-5.6.16/vmlinux /tmp
-RUN rm -rf linux-5.6.16
+ make -j$(nproc) vmlinux && \
+ cp vmlinux /tmp && \
+ rm -rf linux-5.6.16
# Compile an instance of busybox as this provides a lightweight system and init
# binary which we will boot into. Only trick here is configuring busybox to
diff --git a/src/ci/docker/run.sh b/src/ci/docker/run.sh
index 9bc61b5..c2ff62e 100755
--- a/src/ci/docker/run.sh
+++ b/src/ci/docker/run.sh
@@ -119,11 +119,11 @@
exit 1
fi
# Transform changes the context of disabled Dockerfiles to match the enabled ones
- tar --transform 's#^./disabled/#./#' -C $docker_dir -c . | docker \
+ tar --transform 's#disabled/#./#' -C $script_dir -c . | docker \
build \
--rm \
-t rust-ci \
- -f "$image/Dockerfile" \
+ -f "host-$(uname -m)/$image/Dockerfile" \
-
else
echo Invalid image: $image
diff --git a/src/ci/github-actions/ci.yml b/src/ci/github-actions/ci.yml
index 0614d5e..502949d 100644
--- a/src/ci/github-actions/ci.yml
+++ b/src/ci/github-actions/ci.yml
@@ -410,42 +410,6 @@
DEPLOY_TOOLSTATES_JSON: toolstates-linux.json
<<: *job-linux-xl
- ####################
- # macOS Builders #
- ####################
-
- - name: dist-x86_64-apple
- env:
- SCRIPT: ./x.py dist
- RUST_CONFIGURE_ARGS: --target=aarch64-apple-ios,x86_64-apple-ios --enable-full-tools --enable-sanitizers --enable-profiler --set rust.jemalloc
- RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
- MACOSX_DEPLOYMENT_TARGET: 10.7
- NO_LLVM_ASSERTIONS: 1
- NO_DEBUG_ASSERTIONS: 1
- DIST_REQUIRE_ALL_TOOLS: 1
- <<: *job-macos-xl
-
- - name: dist-x86_64-apple-alt
- env:
- SCRIPT: ./x.py dist
- RUST_CONFIGURE_ARGS: --enable-extended --enable-profiler --set rust.jemalloc
- RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
- MACOSX_DEPLOYMENT_TARGET: 10.7
- NO_LLVM_ASSERTIONS: 1
- NO_DEBUG_ASSERTIONS: 1
- <<: *job-macos-xl
-
- - name: x86_64-apple
- env:
- SCRIPT: ./x.py test
- RUST_CONFIGURE_ARGS: --build=x86_64-apple-darwin --enable-sanitizers --enable-profiler --set rust.jemalloc
- RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
- MACOSX_DEPLOYMENT_TARGET: 10.8
- MACOSX_STD_DEPLOYMENT_TARGET: 10.7
- NO_LLVM_ASSERTIONS: 1
- NO_DEBUG_ASSERTIONS: 1
- <<: *job-macos-xl
-
######################
# Windows Builders #
######################
@@ -591,6 +555,51 @@
SCRIPT: python x.py dist
<<: *job-windows-xl
+ auto-fallible:
+ <<: *base-ci-job
+ name: auto-fallible
+ env:
+ <<: [*shared-ci-variables, *prod-variables]
+ if: github.event_name == 'push' && github.ref == 'refs/heads/auto' && github.repository == 'rust-lang-ci/rust'
+ strategy:
+ matrix:
+ include:
+ ####################
+ # macOS Builders #
+ ####################
+
+ - name: dist-x86_64-apple
+ env:
+ SCRIPT: ./x.py dist
+ RUST_CONFIGURE_ARGS: --target=aarch64-apple-ios,x86_64-apple-ios --enable-full-tools --enable-sanitizers --enable-profiler --set rust.jemalloc
+ RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
+ MACOSX_DEPLOYMENT_TARGET: 10.7
+ NO_LLVM_ASSERTIONS: 1
+ NO_DEBUG_ASSERTIONS: 1
+ DIST_REQUIRE_ALL_TOOLS: 1
+ <<: *job-macos-xl
+
+ - name: dist-x86_64-apple-alt
+ env:
+ SCRIPT: ./x.py dist
+ RUST_CONFIGURE_ARGS: --enable-extended --enable-profiler --set rust.jemalloc
+ RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
+ MACOSX_DEPLOYMENT_TARGET: 10.7
+ NO_LLVM_ASSERTIONS: 1
+ NO_DEBUG_ASSERTIONS: 1
+ <<: *job-macos-xl
+
+ - name: x86_64-apple
+ env:
+ SCRIPT: ./x.py test
+ RUST_CONFIGURE_ARGS: --build=x86_64-apple-darwin --enable-sanitizers --enable-profiler --set rust.jemalloc
+ RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
+ MACOSX_DEPLOYMENT_TARGET: 10.8
+ MACOSX_STD_DEPLOYMENT_TARGET: 10.7
+ NO_LLVM_ASSERTIONS: 1
+ NO_DEBUG_ASSERTIONS: 1
+ <<: *job-macos-xl
+
master:
name: master
runs-on: ubuntu-latest
diff --git a/src/doc/book b/src/doc/book
index 4e7c00b..84a3139 160000
--- a/src/doc/book
+++ b/src/doc/book
@@ -1 +1 @@
-Subproject commit 4e7c00bece1544d409312ec93467beb62b5bd0cb
+Subproject commit 84a31397b34f9d405df44f2899ff17a4828dba18
diff --git a/src/doc/embedded-book b/src/doc/embedded-book
index 616962a..94d9ea8 160000
--- a/src/doc/embedded-book
+++ b/src/doc/embedded-book
@@ -1 +1 @@
-Subproject commit 616962ad0dd80f34d8b802da038d0aed9dd691bb
+Subproject commit 94d9ea8460bcbbbfef1877b47cb930260b5849a7
diff --git a/src/doc/reference b/src/doc/reference
index 04d5d5d..0ea7bc4 160000
--- a/src/doc/reference
+++ b/src/doc/reference
@@ -1 +1 @@
-Subproject commit 04d5d5d7ba624b6f5016298451f3a63d557f3260
+Subproject commit 0ea7bc494f1289234d8800bb9185021e0ad946f0
diff --git a/src/doc/rust-by-example b/src/doc/rust-by-example
index 6f94ccb..229c694 160000
--- a/src/doc/rust-by-example
+++ b/src/doc/rust-by-example
@@ -1 +1 @@
-Subproject commit 6f94ccb48da6fa4ed0031290f21411cf789f7d5e
+Subproject commit 229c6945a26a53a751ffa4f9cb418388c00029d3
diff --git a/src/doc/rustdoc/src/unstable-features.md b/src/doc/rustdoc/src/unstable-features.md
index 84e1ebe..eea674f 100644
--- a/src/doc/rustdoc/src/unstable-features.md
+++ b/src/doc/rustdoc/src/unstable-features.md
@@ -38,50 +38,62 @@
Attempting to use these error numbers on stable will result in the code sample being interpreted as
plain text.
-### Linking to items by type
+### Linking to items by name
-As designed in [RFC 1946], Rustdoc can parse paths to items when you use them as links. To resolve
-these type names, it uses the items currently in-scope, either by declaration or by `use` statement.
-For modules, the "active scope" depends on whether the documentation is written outside the module
-(as `///` comments on the `mod` statement) or inside the module (at `//!` comments inside the file
-or block). For all other items, it uses the enclosing module's scope.
+Rustdoc is capable of directly linking to other rustdoc pages in Markdown documentation using the path of item as a link.
-[RFC 1946]: https://github.com/rust-lang/rfcs/pull/1946
-
-For example, in the following code:
+For example, in the following code all of the links will link to the rustdoc page for `Bar`:
```rust
-/// Does the thing.
-pub fn do_the_thing(_: SomeType) {
- println!("Let's do the thing!");
-}
+/// This struct is not [Bar]
+pub struct Foo1;
-/// Token you use to [`do_the_thing`].
-pub struct SomeType;
-```
+/// This struct is also not [bar](Bar)
+pub struct Foo2;
-The link to ``[`do_the_thing`]`` in `SomeType`'s docs will properly link to the page for `fn
-do_the_thing`. Note that here, rustdoc will insert the link target for you, but manually writing the
-target out also works:
-
-```rust
-pub mod some_module {
- /// Token you use to do the thing.
- pub struct SomeStruct;
-}
-
-/// Does the thing. Requires one [`SomeStruct`] for the thing to work.
+/// This struct is also not [bar][b]
///
-/// [`SomeStruct`]: some_module::SomeStruct
-pub fn do_the_thing(_: some_module::SomeStruct) {
- println!("Let's do the thing!");
+/// [b]: Bar
+pub struct Foo3;
+
+/// This struct is also not [`Bar`]
+pub struct Foo4;
+
+pub struct Bar;
+```
+
+You can refer to anything in scope, and use paths, including `Self`. You may also use `foo()` and `foo!()` to refer to methods/functions and macros respectively.
+
+```rust,edition2018
+use std::sync::mpsc::Receiver;
+
+/// This is an version of [`Receiver`], with support for [`std::future`].
+///
+/// You can obtain a [`std::future::Future`] by calling [`Self::recv()`].
+pub struct AsyncReceiver<T> {
+ sender: Receiver<T>
+}
+
+impl<T> AsyncReceiver<T> {
+ pub async fn recv() -> T {
+ unimplemented!()
+ }
}
```
-For more details, check out [the RFC][RFC 1946], and see [the tracking issue][43466] for more
-information about what parts of the feature are available.
+Paths in Rust have three namespaces: type, value, and macro. Items from these namespaces are allowed to overlap. In case of ambiguity, rustdoc will warn about the ambiguity and ask you to disambiguate, which can be done by using a prefix like `struct@`, `enum@`, `type@`, `trait@`, `union@`, `const@`, `static@`, `value@`, `function@`, `mod@`, `fn@`, `module@`, `method@` , `macro@`, or `derive@`:
-[43466]: https://github.com/rust-lang/rust/issues/43466
+```rust
+/// See also: [`Foo`](struct@Foo)
+struct Bar;
+
+/// This is different from [`Foo`](fn@Foo)
+struct Foo {}
+
+fn Foo() {}
+```
+
+Note: Because of how `macro_rules` macros are scoped in Rust, the intra-doc links of a `macro_rules` macro will be resolved relative to the crate root, as opposed to the module it is defined in.
## Extensions to the `#[doc]` attribute
@@ -321,7 +333,7 @@
### `--index-page`: provide a top-level landing page for docs
This feature allows you to generate an index-page with a given markdown file. A good example of it
-is the [rust documentation index](https://doc.rust-lang.org/index.html).
+is the [rust documentation index](https://doc.rust-lang.org/nightly/index.html).
With this, you'll have a page which you can custom as much as you want at the top of your crates.
diff --git a/src/etc/test-float-parse/runtests.py b/src/etc/test-float-parse/runtests.py
index fe6fd45..7106078 100644
--- a/src/etc/test-float-parse/runtests.py
+++ b/src/etc/test-float-parse/runtests.py
@@ -195,9 +195,9 @@
global MAILBOX
tests = [os.path.splitext(f)[0] for f in glob('*.rs')
if not f.startswith('_')]
- whitelist = sys.argv[1:]
- if whitelist:
- tests = [test for test in tests if test in whitelist]
+ listed = sys.argv[1:]
+ if listed:
+ tests = [test for test in tests if test in listed]
if not tests:
print("Error: No tests to run")
sys.exit(1)
@@ -210,8 +210,6 @@
mailman.daemon = True
mailman.start()
for test in tests:
- if whitelist and test not in whitelist:
- continue
run(test)
MAILBOX.put(None)
mailman.join()
diff --git a/src/liballoc/collections/vec_deque.rs b/src/liballoc/collections/vec_deque.rs
index 15f3a94..2efb94e 100644
--- a/src/liballoc/collections/vec_deque.rs
+++ b/src/liballoc/collections/vec_deque.rs
@@ -1084,6 +1084,108 @@
self.tail == self.head
}
+ fn range_start_end<R>(&self, range: R) -> (usize, usize)
+ where
+ R: RangeBounds<usize>,
+ {
+ let len = self.len();
+ let start = match range.start_bound() {
+ Included(&n) => n,
+ Excluded(&n) => n + 1,
+ Unbounded => 0,
+ };
+ let end = match range.end_bound() {
+ Included(&n) => n + 1,
+ Excluded(&n) => n,
+ Unbounded => len,
+ };
+ assert!(start <= end, "lower bound was too large");
+ assert!(end <= len, "upper bound was too large");
+ (start, end)
+ }
+
+ /// Creates an iterator that covers the specified range in the `VecDeque`.
+ ///
+ /// # Panics
+ ///
+ /// Panics if the starting point is greater than the end point or if
+ /// the end point is greater than the length of the vector.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(deque_range)]
+ ///
+ /// use std::collections::VecDeque;
+ ///
+ /// let v: VecDeque<_> = vec![1, 2, 3].into_iter().collect();
+ /// let range = v.range(2..).copied().collect::<VecDeque<_>>();
+ /// assert_eq!(range, [3]);
+ ///
+ /// // A full range covers all contents
+ /// let all = v.range(..);
+ /// assert_eq!(all.len(), 3);
+ /// ```
+ #[inline]
+ #[unstable(feature = "deque_range", issue = "74217")]
+ pub fn range<R>(&self, range: R) -> Iter<'_, T>
+ where
+ R: RangeBounds<usize>,
+ {
+ let (start, end) = self.range_start_end(range);
+ let tail = self.wrap_add(self.tail, start);
+ let head = self.wrap_add(self.tail, end);
+ Iter {
+ tail,
+ head,
+ // The shared reference we have in &self is maintained in the '_ of Iter.
+ ring: unsafe { self.buffer_as_slice() },
+ }
+ }
+
+ /// Creates an iterator that covers the specified mutable range in the `VecDeque`.
+ ///
+ /// # Panics
+ ///
+ /// Panics if the starting point is greater than the end point or if
+ /// the end point is greater than the length of the vector.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(deque_range)]
+ ///
+ /// use std::collections::VecDeque;
+ ///
+ /// let mut v: VecDeque<_> = vec![1, 2, 3].into_iter().collect();
+ /// for v in v.range_mut(2..) {
+ /// *v *= 2;
+ /// }
+ /// assert_eq!(v, vec![1, 2, 6]);
+ ///
+ /// // A full range covers all contents
+ /// for v in v.range_mut(..) {
+ /// *v *= 2;
+ /// }
+ /// assert_eq!(v, vec![2, 4, 12]);
+ /// ```
+ #[inline]
+ #[unstable(feature = "deque_range", issue = "74217")]
+ pub fn range_mut<R>(&mut self, range: R) -> IterMut<'_, T>
+ where
+ R: RangeBounds<usize>,
+ {
+ let (start, end) = self.range_start_end(range);
+ let tail = self.wrap_add(self.tail, start);
+ let head = self.wrap_add(self.tail, end);
+ IterMut {
+ tail,
+ head,
+ // The shared reference we have in &mut self is maintained in the '_ of IterMut.
+ ring: unsafe { self.buffer_as_mut_slice() },
+ }
+ }
+
/// Creates a draining iterator that removes the specified range in the
/// `VecDeque` and yields the removed items.
///
@@ -1129,19 +1231,7 @@
// When finished, the remaining data will be copied back to cover the hole,
// and the head/tail values will be restored correctly.
//
- let len = self.len();
- let start = match range.start_bound() {
- Included(&n) => n,
- Excluded(&n) => n + 1,
- Unbounded => 0,
- };
- let end = match range.end_bound() {
- Included(&n) => n + 1,
- Excluded(&n) => n,
- Unbounded => len,
- };
- assert!(start <= end, "drain lower bound was too large");
- assert!(end <= len, "drain upper bound was too large");
+ let (start, end) = self.range_start_end(range);
// The deque's elements are parted into three segments:
// * self.tail -> drain_tail
diff --git a/src/liballoc/collections/vec_deque/tests.rs b/src/liballoc/collections/vec_deque/tests.rs
index 960af4b..e5edfe0 100644
--- a/src/liballoc/collections/vec_deque/tests.rs
+++ b/src/liballoc/collections/vec_deque/tests.rs
@@ -247,6 +247,65 @@
}
#[test]
+fn test_range() {
+ let mut tester: VecDeque<usize> = VecDeque::with_capacity(7);
+
+ let cap = tester.capacity();
+ for len in 0..=cap {
+ for tail in 0..=cap {
+ for start in 0..=len {
+ for end in start..=len {
+ tester.tail = tail;
+ tester.head = tail;
+ for i in 0..len {
+ tester.push_back(i);
+ }
+
+ // Check that we iterate over the correct values
+ let range: VecDeque<_> = tester.range(start..end).copied().collect();
+ let expected: VecDeque<_> = (start..end).collect();
+ assert_eq!(range, expected);
+ }
+ }
+ }
+ }
+}
+
+#[test]
+fn test_range_mut() {
+ let mut tester: VecDeque<usize> = VecDeque::with_capacity(7);
+
+ let cap = tester.capacity();
+ for len in 0..=cap {
+ for tail in 0..=cap {
+ for start in 0..=len {
+ for end in start..=len {
+ tester.tail = tail;
+ tester.head = tail;
+ for i in 0..len {
+ tester.push_back(i);
+ }
+
+ let head_was = tester.head;
+ let tail_was = tester.tail;
+
+ // Check that we iterate over the correct values
+ let range: VecDeque<_> = tester.range_mut(start..end).map(|v| *v).collect();
+ let expected: VecDeque<_> = (start..end).collect();
+ assert_eq!(range, expected);
+
+ // We shouldn't have changed the capacity or made the
+ // head or tail out of bounds
+ assert_eq!(tester.capacity(), cap);
+ assert_eq!(tester.tail, tail_was);
+ assert_eq!(tester.head, head_was);
+ }
+ }
+ }
+ }
+}
+
+#[test]
fn test_drain() {
let mut tester: VecDeque<usize> = VecDeque::with_capacity(7);
diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs
index 79bfd57..2ec777a 100644
--- a/src/liballoc/lib.rs
+++ b/src/liballoc/lib.rs
@@ -89,6 +89,7 @@
#![feature(const_in_array_repeat_expressions)]
#![cfg_attr(bootstrap, feature(const_if_match))]
#![feature(cow_is_borrowed)]
+#![feature(deque_range)]
#![feature(dispatch_from_dyn)]
#![feature(core_intrinsics)]
#![feature(container_error_extra)]
diff --git a/src/liballoc/slice.rs b/src/liballoc/slice.rs
index d7dc217..3d51115 100644
--- a/src/liballoc/slice.rs
+++ b/src/liballoc/slice.rs
@@ -136,8 +136,6 @@
// `test_permutations` test
mod hack {
use crate::boxed::Box;
- #[cfg(test)]
- use crate::string::ToString;
use crate::vec::Vec;
// We shouldn't add inline attribute to this since this is used in
@@ -156,9 +154,9 @@
where
T: Clone,
{
- let mut vector = Vec::with_capacity(s.len());
- vector.extend_from_slice(s);
- vector
+ let mut vec = Vec::with_capacity(s.len());
+ vec.extend_from_slice(s);
+ vec
}
}
diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index 9856efc..7908574 100644
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -35,7 +35,7 @@
///
/// This trait allows for partial equality, for types that do not have a full
/// equivalence relation. For example, in floating point numbers `NaN != NaN`,
-/// so floating point types implement `PartialEq` but not [`Eq`].
+/// so floating point types implement `PartialEq` but not [`Eq`](Eq).
///
/// Formally, the equality must be (for all `a`, `b` and `c`):
///
@@ -191,7 +191,6 @@
/// assert_eq!(x.eq(&y), false);
/// ```
///
-/// [`Eq`]: Eq
/// [`eq`]: PartialEq::eq
/// [`ne`]: PartialEq::ne
#[lang = "eq"]
diff --git a/src/libcore/ffi.rs b/src/libcore/ffi.rs
index ee3192e..e9689af 100644
--- a/src/libcore/ffi.rs
+++ b/src/libcore/ffi.rs
@@ -280,7 +280,7 @@
// within a private module. Once RFC 2145 has been implemented look into
// improving this.
mod sealed_trait {
- /// Trait which whitelists the allowed types to be used with [VaList::arg]
+ /// Trait which permits the allowed types to be used with [VaList::arg].
///
/// [VaList::arg]: ../struct.VaList.html#method.arg
#[unstable(
diff --git a/src/libcore/future/mod.rs b/src/libcore/future/mod.rs
index 2555d91..6d1ad9d 100644
--- a/src/libcore/future/mod.rs
+++ b/src/libcore/future/mod.rs
@@ -12,6 +12,7 @@
mod future;
mod into_future;
mod pending;
+mod poll_fn;
mod ready;
#[stable(feature = "futures_api", since = "1.36.0")]
@@ -25,6 +26,9 @@
#[unstable(feature = "future_readiness_fns", issue = "70921")]
pub use ready::{ready, Ready};
+#[unstable(feature = "future_poll_fn", issue = "72302")]
+pub use poll_fn::{poll_fn, PollFn};
+
/// This type is needed because:
///
/// a) Generators cannot implement `for<'a, 'b> Generator<&'a mut Context<'b>>`, so we need to pass
diff --git a/src/libcore/future/poll_fn.rs b/src/libcore/future/poll_fn.rs
new file mode 100644
index 0000000..9ab3bfc
--- /dev/null
+++ b/src/libcore/future/poll_fn.rs
@@ -0,0 +1,66 @@
+use crate::fmt;
+use crate::future::Future;
+use crate::pin::Pin;
+use crate::task::{Context, Poll};
+
+/// Creates a future that wraps a function returning `Poll`.
+///
+/// Polling the future delegates to the wrapped function.
+///
+/// # Examples
+///
+/// ```
+/// #![feature(future_poll_fn)]
+/// # async fn run() {
+/// use core::future::poll_fn;
+/// use core::task::{Context, Poll};
+///
+/// fn read_line(_cx: &mut Context<'_>) -> Poll<String> {
+/// Poll::Ready("Hello, World!".into())
+/// }
+///
+/// let read_future = poll_fn(read_line);
+/// assert_eq!(read_future.await, "Hello, World!".to_owned());
+/// # };
+/// ```
+#[unstable(feature = "future_poll_fn", issue = "72302")]
+pub fn poll_fn<T, F>(f: F) -> PollFn<F>
+where
+ F: FnMut(&mut Context<'_>) -> Poll<T>,
+{
+ PollFn { f }
+}
+
+/// A Future that wraps a function returning `Poll`.
+///
+/// This `struct` is created by the [`poll_fn`] function. See its
+/// documentation for more.
+///
+/// [`poll_fn`]: fn.poll_fn.html
+#[must_use = "futures do nothing unless you `.await` or poll them"]
+#[unstable(feature = "future_poll_fn", issue = "72302")]
+pub struct PollFn<F> {
+ f: F,
+}
+
+#[unstable(feature = "future_poll_fn", issue = "72302")]
+impl<F> Unpin for PollFn<F> {}
+
+#[unstable(feature = "future_poll_fn", issue = "72302")]
+impl<F> fmt::Debug for PollFn<F> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("PollFn").finish()
+ }
+}
+
+#[unstable(feature = "future_poll_fn", issue = "72302")]
+impl<T, F> Future for PollFn<F>
+where
+ F: FnMut(&mut Context<'_>) -> Poll<T>,
+{
+ type Output = T;
+
+ fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
+ (&mut self.f)(cx)
+ }
+}
diff --git a/src/libcore/mem/mod.rs b/src/libcore/mem/mod.rs
index 0a976a4..98d2027 100644
--- a/src/libcore/mem/mod.rs
+++ b/src/libcore/mem/mod.rs
@@ -142,7 +142,7 @@
/// [ub]: ../../reference/behavior-considered-undefined.html
/// [`ManuallyDrop`]: struct.ManuallyDrop.html
#[inline]
-#[rustc_const_unstable(feature = "const_forget", issue = "69616")]
+#[rustc_const_stable(feature = "const_forget", since = "1.46.0")]
#[stable(feature = "rust1", since = "1.0.0")]
pub const fn forget<T>(t: T) {
ManuallyDrop::new(t);
diff --git a/src/libcore/tests/lib.rs b/src/libcore/tests/lib.rs
index 68a5e20..090ce47 100644
--- a/src/libcore/tests/lib.rs
+++ b/src/libcore/tests/lib.rs
@@ -40,7 +40,6 @@
#![feature(const_raw_ptr_deref)]
#![feature(never_type)]
#![feature(unwrap_infallible)]
-#![feature(const_forget)]
#![feature(option_unwrap_none)]
#![feature(peekable_next_if)]
#![feature(partition_point)]
diff --git a/src/librustc_ast/attr/mod.rs b/src/librustc_ast/attr/mod.rs
index 7613920..9d4b6db 100644
--- a/src/librustc_ast/attr/mod.rs
+++ b/src/librustc_ast/attr/mod.rs
@@ -21,55 +21,61 @@
use std::iter;
use std::ops::DerefMut;
-pub struct Globals {
+// Per-session global variables: this struct is stored in thread-local storage
+// in such a way that it is accessible without any kind of handle to all
+// threads within the compilation session, but is not accessible outside the
+// session.
+pub struct SessionGlobals {
used_attrs: Lock<GrowableBitSet<AttrId>>,
known_attrs: Lock<GrowableBitSet<AttrId>>,
- rustc_span_globals: rustc_span::Globals,
+ span_session_globals: rustc_span::SessionGlobals,
}
-impl Globals {
- fn new(edition: Edition) -> Globals {
- Globals {
+impl SessionGlobals {
+ fn new(edition: Edition) -> SessionGlobals {
+ SessionGlobals {
// We have no idea how many attributes there will be, so just
// initiate the vectors with 0 bits. We'll grow them as necessary.
used_attrs: Lock::new(GrowableBitSet::new_empty()),
known_attrs: Lock::new(GrowableBitSet::new_empty()),
- rustc_span_globals: rustc_span::Globals::new(edition),
+ span_session_globals: rustc_span::SessionGlobals::new(edition),
}
}
}
-pub fn with_globals<R>(edition: Edition, f: impl FnOnce() -> R) -> R {
- let globals = Globals::new(edition);
- GLOBALS.set(&globals, || rustc_span::GLOBALS.set(&globals.rustc_span_globals, f))
+pub fn with_session_globals<R>(edition: Edition, f: impl FnOnce() -> R) -> R {
+ let ast_session_globals = SessionGlobals::new(edition);
+ SESSION_GLOBALS.set(&ast_session_globals, || {
+ rustc_span::SESSION_GLOBALS.set(&ast_session_globals.span_session_globals, f)
+ })
}
-pub fn with_default_globals<R>(f: impl FnOnce() -> R) -> R {
- with_globals(DEFAULT_EDITION, f)
+pub fn with_default_session_globals<R>(f: impl FnOnce() -> R) -> R {
+ with_session_globals(DEFAULT_EDITION, f)
}
-scoped_tls::scoped_thread_local!(pub static GLOBALS: Globals);
+scoped_tls::scoped_thread_local!(pub static SESSION_GLOBALS: SessionGlobals);
pub fn mark_used(attr: &Attribute) {
debug!("marking {:?} as used", attr);
- GLOBALS.with(|globals| {
- globals.used_attrs.lock().insert(attr.id);
+ SESSION_GLOBALS.with(|session_globals| {
+ session_globals.used_attrs.lock().insert(attr.id);
});
}
pub fn is_used(attr: &Attribute) -> bool {
- GLOBALS.with(|globals| globals.used_attrs.lock().contains(attr.id))
+ SESSION_GLOBALS.with(|session_globals| session_globals.used_attrs.lock().contains(attr.id))
}
pub fn mark_known(attr: &Attribute) {
debug!("marking {:?} as known", attr);
- GLOBALS.with(|globals| {
- globals.known_attrs.lock().insert(attr.id);
+ SESSION_GLOBALS.with(|session_globals| {
+ session_globals.known_attrs.lock().insert(attr.id);
});
}
pub fn is_known(attr: &Attribute) -> bool {
- GLOBALS.with(|globals| globals.known_attrs.lock().contains(attr.id))
+ SESSION_GLOBALS.with(|session_globals| session_globals.known_attrs.lock().contains(attr.id))
}
pub fn is_known_lint_tool(m_item: Ident) -> bool {
diff --git a/src/librustc_ast/lib.rs b/src/librustc_ast/lib.rs
index 5c1c9d6..ffd2aa6 100644
--- a/src/librustc_ast/lib.rs
+++ b/src/librustc_ast/lib.rs
@@ -43,7 +43,7 @@
pub mod ast;
pub mod attr;
-pub use attr::{with_default_globals, with_globals, GLOBALS};
+pub use attr::{with_default_session_globals, with_session_globals, SESSION_GLOBALS};
pub mod crate_disambiguator;
pub mod entry;
pub mod expand;
diff --git a/src/librustc_ast/util/lev_distance/tests.rs b/src/librustc_ast/util/lev_distance/tests.rs
index 2226616..e9b6c97 100644
--- a/src/librustc_ast/util/lev_distance/tests.rs
+++ b/src/librustc_ast/util/lev_distance/tests.rs
@@ -21,8 +21,8 @@
#[test]
fn test_find_best_match_for_name() {
- use crate::with_default_globals;
- with_default_globals(|| {
+ use crate::with_default_session_globals;
+ with_default_session_globals(|| {
let input = vec![Symbol::intern("aaab"), Symbol::intern("aaabc")];
assert_eq!(
find_best_match_for_name(input.iter(), "aaaa", None),
diff --git a/src/librustc_ast_pretty/pprust/tests.rs b/src/librustc_ast_pretty/pprust/tests.rs
index f92e40e..96377a4 100644
--- a/src/librustc_ast_pretty/pprust/tests.rs
+++ b/src/librustc_ast_pretty/pprust/tests.rs
@@ -1,7 +1,7 @@
use super::*;
use rustc_ast::ast;
-use rustc_ast::with_default_globals;
+use rustc_ast::with_default_session_globals;
use rustc_span::source_map::respan;
use rustc_span::symbol::Ident;
@@ -25,7 +25,7 @@
#[test]
fn test_fun_to_string() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let abba_ident = Ident::from_str("abba");
let decl =
@@ -40,7 +40,7 @@
#[test]
fn test_variant_to_string() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let ident = Ident::from_str("principal_skinner");
let var = ast::Variant {
diff --git a/src/librustc_codegen_llvm/attributes.rs b/src/librustc_codegen_llvm/attributes.rs
index 6234ade..89b548a 100644
--- a/src/librustc_codegen_llvm/attributes.rs
+++ b/src/librustc_codegen_llvm/attributes.rs
@@ -263,7 +263,7 @@
// Windows we end up still needing the `uwtable` attribute even if the `-C
// panic=abort` flag is passed.
//
- // You can also find more info on why Windows is whitelisted here in:
+ // You can also find more info on why Windows always requires uwtables here:
// https://bugzilla.mozilla.org/show_bug.cgi?id=1302078
if cx.sess().must_emit_unwind_tables() {
attributes::emit_uwtable(llfn, true);
@@ -342,15 +342,15 @@
}
}
-pub fn provide(providers: &mut Providers<'_>) {
- providers.target_features_whitelist = |tcx, cnum| {
+pub fn provide(providers: &mut Providers) {
+ providers.supported_target_features = |tcx, cnum| {
assert_eq!(cnum, LOCAL_CRATE);
if tcx.sess.opts.actually_rustdoc {
// rustdoc needs to be able to document functions that use all the features, so
- // whitelist them all
+ // provide them all.
llvm_util::all_known_features().map(|(a, b)| (a.to_string(), b)).collect()
} else {
- llvm_util::target_feature_whitelist(tcx.sess)
+ llvm_util::supported_target_features(tcx.sess)
.iter()
.map(|&(a, b)| (a.to_string(), b))
.collect()
@@ -360,7 +360,7 @@
provide_extern(providers);
}
-pub fn provide_extern(providers: &mut Providers<'_>) {
+pub fn provide_extern(providers: &mut Providers) {
providers.wasm_import_module_map = |tcx, cnum| {
// Build up a map from DefId to a `NativeLib` structure, where
// `NativeLib` internally contains information about
diff --git a/src/librustc_codegen_llvm/back/lto.rs b/src/librustc_codegen_llvm/back/lto.rs
index 9764c9a..6b02b5e 100644
--- a/src/librustc_codegen_llvm/back/lto.rs
+++ b/src/librustc_codegen_llvm/back/lto.rs
@@ -62,11 +62,11 @@
}
};
let exported_symbols = cgcx.exported_symbols.as_ref().expect("needs exported symbols for LTO");
- let mut symbol_white_list = {
- let _timer = cgcx.prof.generic_activity("LLVM_lto_generate_symbol_white_list");
+ let mut symbols_below_threshold = {
+ let _timer = cgcx.prof.generic_activity("LLVM_lto_generate_symbols_below_threshold");
exported_symbols[&LOCAL_CRATE].iter().filter_map(symbol_filter).collect::<Vec<CString>>()
};
- info!("{} symbols to preserve in this crate", symbol_white_list.len());
+ info!("{} symbols to preserve in this crate", symbols_below_threshold.len());
// If we're performing LTO for the entire crate graph, then for each of our
// upstream dependencies, find the corresponding rlib and load the bitcode
@@ -102,8 +102,10 @@
let exported_symbols =
cgcx.exported_symbols.as_ref().expect("needs exported symbols for LTO");
{
- let _timer = cgcx.prof.generic_activity("LLVM_lto_generate_symbol_white_list");
- symbol_white_list.extend(exported_symbols[&cnum].iter().filter_map(symbol_filter));
+ let _timer =
+ cgcx.prof.generic_activity("LLVM_lto_generate_symbols_below_threshold");
+ symbols_below_threshold
+ .extend(exported_symbols[&cnum].iter().filter_map(symbol_filter));
}
let archive = ArchiveRO::open(&path).expect("wanted an rlib");
@@ -124,7 +126,7 @@
}
}
- Ok((symbol_white_list, upstream_modules))
+ Ok((symbols_below_threshold, upstream_modules))
}
fn get_bitcode_slice_from_object_data(obj: &[u8]) -> Result<&[u8], String> {
@@ -155,9 +157,17 @@
cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
) -> Result<LtoModuleCodegen<LlvmCodegenBackend>, FatalError> {
let diag_handler = cgcx.create_diag_handler();
- let (symbol_white_list, upstream_modules) = prepare_lto(cgcx, &diag_handler)?;
- let symbol_white_list = symbol_white_list.iter().map(|c| c.as_ptr()).collect::<Vec<_>>();
- fat_lto(cgcx, &diag_handler, modules, cached_modules, upstream_modules, &symbol_white_list)
+ let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, &diag_handler)?;
+ let symbols_below_threshold =
+ symbols_below_threshold.iter().map(|c| c.as_ptr()).collect::<Vec<_>>();
+ fat_lto(
+ cgcx,
+ &diag_handler,
+ modules,
+ cached_modules,
+ upstream_modules,
+ &symbols_below_threshold,
+ )
}
/// Performs thin LTO by performing necessary global analysis and returning two
@@ -169,15 +179,23 @@
cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
) -> Result<(Vec<LtoModuleCodegen<LlvmCodegenBackend>>, Vec<WorkProduct>), FatalError> {
let diag_handler = cgcx.create_diag_handler();
- let (symbol_white_list, upstream_modules) = prepare_lto(cgcx, &diag_handler)?;
- let symbol_white_list = symbol_white_list.iter().map(|c| c.as_ptr()).collect::<Vec<_>>();
+ let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, &diag_handler)?;
+ let symbols_below_threshold =
+ symbols_below_threshold.iter().map(|c| c.as_ptr()).collect::<Vec<_>>();
if cgcx.opts.cg.linker_plugin_lto.enabled() {
unreachable!(
"We should never reach this case if the LTO step \
is deferred to the linker"
);
}
- thin_lto(cgcx, &diag_handler, modules, upstream_modules, cached_modules, &symbol_white_list)
+ thin_lto(
+ cgcx,
+ &diag_handler,
+ modules,
+ upstream_modules,
+ cached_modules,
+ &symbols_below_threshold,
+ )
}
pub(crate) fn prepare_thin(module: ModuleCodegen<ModuleLlvm>) -> (String, ThinBuffer) {
@@ -192,7 +210,7 @@
modules: Vec<FatLTOInput<LlvmCodegenBackend>>,
cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
mut serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,
- symbol_white_list: &[*const libc::c_char],
+ symbols_below_threshold: &[*const libc::c_char],
) -> Result<LtoModuleCodegen<LlvmCodegenBackend>, FatalError> {
let _timer = cgcx.prof.generic_activity("LLVM_fat_lto_build_monolithic_module");
info!("going for a fat lto");
@@ -306,14 +324,13 @@
drop(linker);
save_temp_bitcode(&cgcx, &module, "lto.input");
- // Internalize everything that *isn't* in our whitelist to help strip out
- // more modules and such
+ // Internalize everything below threshold to help strip out more modules and such.
unsafe {
- let ptr = symbol_white_list.as_ptr();
+ let ptr = symbols_below_threshold.as_ptr();
llvm::LLVMRustRunRestrictionPass(
llmod,
ptr as *const *const libc::c_char,
- symbol_white_list.len() as libc::size_t,
+ symbols_below_threshold.len() as libc::size_t,
);
save_temp_bitcode(&cgcx, &module, "lto.after-restriction");
}
@@ -395,7 +412,7 @@
modules: Vec<(String, ThinBuffer)>,
serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,
cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
- symbol_white_list: &[*const libc::c_char],
+ symbols_below_threshold: &[*const libc::c_char],
) -> Result<(Vec<LtoModuleCodegen<LlvmCodegenBackend>>, Vec<WorkProduct>), FatalError> {
let _timer = cgcx.prof.generic_activity("LLVM_thin_lto_global_analysis");
unsafe {
@@ -463,8 +480,8 @@
let data = llvm::LLVMRustCreateThinLTOData(
thin_modules.as_ptr(),
thin_modules.len() as u32,
- symbol_white_list.as_ptr(),
- symbol_white_list.len() as u32,
+ symbols_below_threshold.as_ptr(),
+ symbols_below_threshold.len() as u32,
)
.ok_or_else(|| write::llvm_err(&diag_handler, "failed to prepare thin LTO context"))?;
diff --git a/src/librustc_codegen_llvm/context.rs b/src/librustc_codegen_llvm/context.rs
index d484e15e..21ba97d 100644
--- a/src/librustc_codegen_llvm/context.rs
+++ b/src/librustc_codegen_llvm/context.rs
@@ -188,14 +188,19 @@
llvm::LLVMRustAddModuleFlag(llmod, avoid_plt, 1);
}
- // Set module flags to enable Windows Control Flow Guard (/guard:cf) metadata
- // only (`cfguard=1`) or metadata and checks (`cfguard=2`).
- match sess.opts.debugging_opts.control_flow_guard {
- CFGuard::Disabled => {}
- CFGuard::NoChecks => {
- llvm::LLVMRustAddModuleFlag(llmod, "cfguard\0".as_ptr() as *const _, 1)
+ // Control Flow Guard is currently only supported by the MSVC linker on Windows.
+ if sess.target.target.options.is_like_msvc {
+ match sess.opts.debugging_opts.control_flow_guard {
+ CFGuard::Disabled => {}
+ CFGuard::NoChecks => {
+ // Set `cfguard=1` module flag to emit metadata only.
+ llvm::LLVMRustAddModuleFlag(llmod, "cfguard\0".as_ptr() as *const _, 1)
+ }
+ CFGuard::Checks => {
+ // Set `cfguard=2` module flag to emit metadata and checks.
+ llvm::LLVMRustAddModuleFlag(llmod, "cfguard\0".as_ptr() as *const _, 2)
+ }
}
- CFGuard::Checks => llvm::LLVMRustAddModuleFlag(llmod, "cfguard\0".as_ptr() as *const _, 2),
}
llmod
diff --git a/src/librustc_codegen_llvm/lib.rs b/src/librustc_codegen_llvm/lib.rs
index 565968f..67d4b26 100644
--- a/src/librustc_codegen_llvm/lib.rs
+++ b/src/librustc_codegen_llvm/lib.rs
@@ -241,11 +241,11 @@
Box::new(metadata::LlvmMetadataLoader)
}
- fn provide(&self, providers: &mut ty::query::Providers<'_>) {
+ fn provide(&self, providers: &mut ty::query::Providers) {
attributes::provide(providers);
}
- fn provide_extern(&self, providers: &mut ty::query::Providers<'_>) {
+ fn provide_extern(&self, providers: &mut ty::query::Providers) {
attributes::provide_extern(providers);
}
diff --git a/src/librustc_codegen_llvm/llvm_util.rs b/src/librustc_codegen_llvm/llvm_util.rs
index 2e2ce15..b631c10 100644
--- a/src/librustc_codegen_llvm/llvm_util.rs
+++ b/src/librustc_codegen_llvm/llvm_util.rs
@@ -139,7 +139,7 @@
// to LLVM or the feature detection code will walk past the end of the feature
// array, leading to crashes.
-const ARM_WHITELIST: &[(&str, Option<Symbol>)] = &[
+const ARM_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
("aclass", Some(sym::arm_target_feature)),
("mclass", Some(sym::arm_target_feature)),
("rclass", Some(sym::arm_target_feature)),
@@ -162,7 +162,7 @@
("thumb-mode", Some(sym::arm_target_feature)),
];
-const AARCH64_WHITELIST: &[(&str, Option<Symbol>)] = &[
+const AARCH64_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
("fp", Some(sym::aarch64_target_feature)),
("neon", Some(sym::aarch64_target_feature)),
("sve", Some(sym::aarch64_target_feature)),
@@ -180,7 +180,7 @@
("v8.3a", Some(sym::aarch64_target_feature)),
];
-const X86_WHITELIST: &[(&str, Option<Symbol>)] = &[
+const X86_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
("adx", Some(sym::adx_target_feature)),
("aes", None),
("avx", None),
@@ -224,12 +224,12 @@
("xsaves", None),
];
-const HEXAGON_WHITELIST: &[(&str, Option<Symbol>)] = &[
+const HEXAGON_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
("hvx", Some(sym::hexagon_target_feature)),
("hvx-length128b", Some(sym::hexagon_target_feature)),
];
-const POWERPC_WHITELIST: &[(&str, Option<Symbol>)] = &[
+const POWERPC_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
("altivec", Some(sym::powerpc_target_feature)),
("power8-altivec", Some(sym::powerpc_target_feature)),
("power9-altivec", Some(sym::powerpc_target_feature)),
@@ -238,10 +238,10 @@
("vsx", Some(sym::powerpc_target_feature)),
];
-const MIPS_WHITELIST: &[(&str, Option<Symbol>)] =
+const MIPS_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] =
&[("fp64", Some(sym::mips_target_feature)), ("msa", Some(sym::mips_target_feature))];
-const RISCV_WHITELIST: &[(&str, Option<Symbol>)] = &[
+const RISCV_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
("m", Some(sym::riscv_target_feature)),
("a", Some(sym::riscv_target_feature)),
("c", Some(sym::riscv_target_feature)),
@@ -250,7 +250,7 @@
("e", Some(sym::riscv_target_feature)),
];
-const WASM_WHITELIST: &[(&str, Option<Symbol>)] = &[
+const WASM_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
("simd128", Some(sym::wasm_target_feature)),
("atomics", Some(sym::wasm_target_feature)),
("nontrapping-fptoint", Some(sym::wasm_target_feature)),
@@ -259,19 +259,18 @@
/// When rustdoc is running, provide a list of all known features so that all their respective
/// primitives may be documented.
///
-/// IMPORTANT: If you're adding another whitelist to the above lists, make sure to add it to this
-/// iterator!
+/// IMPORTANT: If you're adding another feature list above, make sure to add it to this iterator!
pub fn all_known_features() -> impl Iterator<Item = (&'static str, Option<Symbol>)> {
- ARM_WHITELIST
- .iter()
+ std::iter::empty()
+ .chain(ARM_ALLOWED_FEATURES.iter())
+ .chain(AARCH64_ALLOWED_FEATURES.iter())
+ .chain(X86_ALLOWED_FEATURES.iter())
+ .chain(HEXAGON_ALLOWED_FEATURES.iter())
+ .chain(POWERPC_ALLOWED_FEATURES.iter())
+ .chain(MIPS_ALLOWED_FEATURES.iter())
+ .chain(RISCV_ALLOWED_FEATURES.iter())
+ .chain(WASM_ALLOWED_FEATURES.iter())
.cloned()
- .chain(AARCH64_WHITELIST.iter().cloned())
- .chain(X86_WHITELIST.iter().cloned())
- .chain(HEXAGON_WHITELIST.iter().cloned())
- .chain(POWERPC_WHITELIST.iter().cloned())
- .chain(MIPS_WHITELIST.iter().cloned())
- .chain(RISCV_WHITELIST.iter().cloned())
- .chain(WASM_WHITELIST.iter().cloned())
}
pub fn to_llvm_feature<'a>(sess: &Session, s: &'a str) -> &'a str {
@@ -289,7 +288,7 @@
pub fn target_features(sess: &Session) -> Vec<Symbol> {
let target_machine = create_informational_target_machine(sess);
- target_feature_whitelist(sess)
+ supported_target_features(sess)
.iter()
.filter_map(|&(feature, gate)| {
if UnstableFeatures::from_environment().is_nightly_build() || gate.is_none() {
@@ -307,16 +306,16 @@
.collect()
}
-pub fn target_feature_whitelist(sess: &Session) -> &'static [(&'static str, Option<Symbol>)] {
+pub fn supported_target_features(sess: &Session) -> &'static [(&'static str, Option<Symbol>)] {
match &*sess.target.target.arch {
- "arm" => ARM_WHITELIST,
- "aarch64" => AARCH64_WHITELIST,
- "x86" | "x86_64" => X86_WHITELIST,
- "hexagon" => HEXAGON_WHITELIST,
- "mips" | "mips64" => MIPS_WHITELIST,
- "powerpc" | "powerpc64" => POWERPC_WHITELIST,
- "riscv32" | "riscv64" => RISCV_WHITELIST,
- "wasm32" => WASM_WHITELIST,
+ "arm" => ARM_ALLOWED_FEATURES,
+ "aarch64" => AARCH64_ALLOWED_FEATURES,
+ "x86" | "x86_64" => X86_ALLOWED_FEATURES,
+ "hexagon" => HEXAGON_ALLOWED_FEATURES,
+ "mips" | "mips64" => MIPS_ALLOWED_FEATURES,
+ "powerpc" | "powerpc64" => POWERPC_ALLOWED_FEATURES,
+ "riscv32" | "riscv64" => RISCV_ALLOWED_FEATURES,
+ "wasm32" => WASM_ALLOWED_FEATURES,
_ => &[],
}
}
diff --git a/src/librustc_codegen_ssa/back/linker.rs b/src/librustc_codegen_ssa/back/linker.rs
index 54f55c8..7a07da0 100644
--- a/src/librustc_codegen_ssa/back/linker.rs
+++ b/src/librustc_codegen_ssa/back/linker.rs
@@ -475,9 +475,7 @@
self.cmd.arg("__llvm_profile_runtime");
}
- fn control_flow_guard(&mut self) {
- self.sess.warn("Windows Control Flow Guard is not supported by this linker.");
- }
+ fn control_flow_guard(&mut self) {}
fn debuginfo(&mut self, strip: Strip) {
match strip {
@@ -959,9 +957,7 @@
// noop, but maybe we need something like the gnu linker?
}
- fn control_flow_guard(&mut self) {
- self.sess.warn("Windows Control Flow Guard is not supported by this linker.");
- }
+ fn control_flow_guard(&mut self) {}
fn debuginfo(&mut self, _strip: Strip) {
// Preserve names or generate source maps depending on debug info
@@ -1163,9 +1159,7 @@
}
}
- fn control_flow_guard(&mut self) {
- self.sess.warn("Windows Control Flow Guard is not supported by this linker.");
- }
+ fn control_flow_guard(&mut self) {}
fn no_crt_objects(&mut self) {}
@@ -1176,10 +1170,10 @@
self.cmd.arg("--export").arg(&sym);
}
- // LLD will hide these otherwise-internal symbols since our `--export`
- // list above is a whitelist of what to export. Various bits and pieces
- // of tooling use this, so be sure these symbols make their way out of
- // the linker as well.
+ // LLD will hide these otherwise-internal symbols since it only exports
+ // symbols explicity passed via the `--export` flags above and hides all
+ // others. Various bits and pieces of tooling use this, so be sure these
+ // symbols make their way out of the linker as well.
self.cmd.arg("--export=__heap_base");
self.cmd.arg("--export=__data_end");
}
@@ -1330,9 +1324,7 @@
fn no_default_libraries(&mut self) {}
- fn control_flow_guard(&mut self) {
- self.sess.warn("Windows Control Flow Guard is not supported by this linker.");
- }
+ fn control_flow_guard(&mut self) {}
fn export_symbols(&mut self, _tmpdir: &Path, _crate_type: CrateType) {}
diff --git a/src/librustc_codegen_ssa/back/symbol_export.rs b/src/librustc_codegen_ssa/back/symbol_export.rs
index 217ad57..2efbfcb 100644
--- a/src/librustc_codegen_ssa/back/symbol_export.rs
+++ b/src/librustc_codegen_ssa/back/symbol_export.rs
@@ -161,9 +161,9 @@
}
fn exported_symbols_provider_local(
- tcx: TyCtxt<'_>,
+ tcx: TyCtxt<'tcx>,
cnum: CrateNum,
-) -> &'tcx [(ExportedSymbol<'_>, SymbolExportLevel)] {
+) -> &'tcx [(ExportedSymbol<'tcx>, SymbolExportLevel)] {
assert_eq!(cnum, LOCAL_CRATE);
if !tcx.sess.opts.output_types.should_codegen() {
@@ -366,7 +366,7 @@
}
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
providers.reachable_non_generics = reachable_non_generics_provider;
providers.is_reachable_non_generic = is_reachable_non_generic_provider_local;
providers.exported_symbols = exported_symbols_provider_local;
@@ -375,7 +375,7 @@
providers.upstream_drop_glue_for = upstream_drop_glue_for_provider;
}
-pub fn provide_extern(providers: &mut Providers<'_>) {
+pub fn provide_extern(providers: &mut Providers) {
providers.is_reachable_non_generic = is_reachable_non_generic_provider_extern;
providers.upstream_monomorphizations_for = upstream_monomorphizations_for_provider;
}
diff --git a/src/librustc_codegen_ssa/base.rs b/src/librustc_codegen_ssa/base.rs
index 5b14258..b28cb07 100644
--- a/src/librustc_codegen_ssa/base.rs
+++ b/src/librustc_codegen_ssa/base.rs
@@ -842,10 +842,9 @@
}
}
- // No need to look for lang items that are whitelisted and don't
- // actually need to exist.
+ // No need to look for lang items that don't actually need to exist.
let missing =
- missing.iter().cloned().filter(|&l| !lang_items::whitelisted(tcx, l)).collect();
+ missing.iter().cloned().filter(|&l| lang_items::required(tcx, l)).collect();
info.missing_lang_items.insert(cnum, missing);
}
@@ -853,7 +852,7 @@
}
}
-pub fn provide_both(providers: &mut Providers<'_>) {
+pub fn provide_both(providers: &mut Providers) {
providers.backend_optimization_level = |tcx, cratenum| {
let for_speed = match tcx.sess.opts.optimize {
// If globally no optimisation is done, #[optimize] has no effect.
diff --git a/src/librustc_codegen_ssa/lib.rs b/src/librustc_codegen_ssa/lib.rs
index 618df15..bdd73c0 100644
--- a/src/librustc_codegen_ssa/lib.rs
+++ b/src/librustc_codegen_ssa/lib.rs
@@ -138,12 +138,12 @@
pub crate_info: CrateInfo,
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
crate::back::symbol_export::provide(providers);
crate::base::provide_both(providers);
}
-pub fn provide_extern(providers: &mut Providers<'_>) {
+pub fn provide_extern(providers: &mut Providers) {
crate::back::symbol_export::provide_extern(providers);
crate::base::provide_both(providers);
}
diff --git a/src/librustc_codegen_ssa/traits/backend.rs b/src/librustc_codegen_ssa/traits/backend.rs
index 6cbb47e..3522ea0 100644
--- a/src/librustc_codegen_ssa/traits/backend.rs
+++ b/src/librustc_codegen_ssa/traits/backend.rs
@@ -55,8 +55,8 @@
fn print_version(&self) {}
fn metadata_loader(&self) -> Box<MetadataLoaderDyn>;
- fn provide(&self, _providers: &mut Providers<'_>);
- fn provide_extern(&self, _providers: &mut Providers<'_>);
+ fn provide(&self, _providers: &mut Providers);
+ fn provide_extern(&self, _providers: &mut Providers);
fn codegen_crate<'tcx>(
&self,
tcx: TyCtxt<'tcx>,
diff --git a/src/librustc_error_codes/error_codes/E0570.md b/src/librustc_error_codes/error_codes/E0570.md
index bf9615f..355e71f 100644
--- a/src/librustc_error_codes/error_codes/E0570.md
+++ b/src/librustc_error_codes/error_codes/E0570.md
@@ -1,6 +1,6 @@
The requested ABI is unsupported by the current target.
-The rust compiler maintains for each target a blacklist of ABIs unsupported on
+The rust compiler maintains for each target a list of unsupported ABIs on
that target. If an ABI is present in such a list this usually means that the
target / ABI combination is currently unsupported by llvm.
diff --git a/src/librustc_errors/json/tests.rs b/src/librustc_errors/json/tests.rs
index 3591290..dcfcdbc 100644
--- a/src/librustc_errors/json/tests.rs
+++ b/src/librustc_errors/json/tests.rs
@@ -39,16 +39,16 @@
}
}
-fn with_default_globals(f: impl FnOnce()) {
- let globals = rustc_span::Globals::new(rustc_span::edition::DEFAULT_EDITION);
- rustc_span::GLOBALS.set(&globals, || rustc_span::GLOBALS.set(&globals, f))
+fn with_default_session_globals(f: impl FnOnce()) {
+ let session_globals = rustc_span::SessionGlobals::new(rustc_span::edition::DEFAULT_EDITION);
+ rustc_span::SESSION_GLOBALS.set(&session_globals, f);
}
/// Test the span yields correct positions in JSON.
fn test_positions(code: &str, span: (u32, u32), expected_output: SpanTestData) {
let expected_output = TestData { spans: vec![expected_output] };
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
sm.new_source_file(Path::new("test.rs").to_owned().into(), code.to_owned());
@@ -59,6 +59,7 @@
sm,
true,
HumanReadableErrorType::Short(ColorConfig::Never),
+ None,
false,
);
diff --git a/src/librustc_expand/base.rs b/src/librustc_expand/base.rs
index db9293b..3e48224 100644
--- a/src/librustc_expand/base.rs
+++ b/src/librustc_expand/base.rs
@@ -735,7 +735,7 @@
pub kind: SyntaxExtensionKind,
/// Span of the macro definition.
pub span: Span,
- /// Whitelist of unstable features that are treated as stable inside this macro.
+ /// List of unstable features that are treated as stable inside this macro.
pub allow_internal_unstable: Option<Lrc<[Symbol]>>,
/// Suppresses the `unsafe_code` lint for code produced by this macro.
pub allow_internal_unsafe: bool,
diff --git a/src/librustc_expand/mut_visit/tests.rs b/src/librustc_expand/mut_visit/tests.rs
index 48da1a3..c22d2a1 100644
--- a/src/librustc_expand/mut_visit/tests.rs
+++ b/src/librustc_expand/mut_visit/tests.rs
@@ -2,7 +2,7 @@
use rustc_ast::ast;
use rustc_ast::mut_visit::{self, MutVisitor};
-use rustc_ast::with_default_globals;
+use rustc_ast::with_default_session_globals;
use rustc_ast_pretty::pprust;
use rustc_span::symbol::Ident;
@@ -38,7 +38,7 @@
// Make sure idents get transformed everywhere.
#[test]
fn ident_transformation() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let mut zz_visitor = ToZzIdentMutVisitor;
let mut krate =
string_to_crate("#[a] mod b {fn c (d : e, f : g) {h!(i,j,k);l;m}}".to_string());
@@ -55,7 +55,7 @@
// Make sure idents get transformed even inside macro defs.
#[test]
fn ident_transformation_in_defs() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let mut zz_visitor = ToZzIdentMutVisitor;
let mut krate = string_to_crate(
"macro_rules! a {(b $c:expr $(d $e:token)f+ => \
diff --git a/src/librustc_expand/parse/lexer/tests.rs b/src/librustc_expand/parse/lexer/tests.rs
index 2932475..b3775c7 100644
--- a/src/librustc_expand/parse/lexer/tests.rs
+++ b/src/librustc_expand/parse/lexer/tests.rs
@@ -1,6 +1,6 @@
use rustc_ast::token::{self, Token, TokenKind};
use rustc_ast::util::comments::is_doc_comment;
-use rustc_ast::with_default_globals;
+use rustc_ast::with_default_session_globals;
use rustc_data_structures::sync::Lrc;
use rustc_errors::{emitter::EmitterWriter, Handler};
use rustc_parse::lexer::StringReader;
@@ -33,7 +33,7 @@
#[test]
fn t1() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
let mut string_reader = setup(
@@ -79,7 +79,7 @@
#[test]
fn doublecolon_parsing() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
check_tokenization(
@@ -91,7 +91,7 @@
#[test]
fn doublecolon_parsing_2() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
check_tokenization(
@@ -103,7 +103,7 @@
#[test]
fn doublecolon_parsing_3() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
check_tokenization(
@@ -115,7 +115,7 @@
#[test]
fn doublecolon_parsing_4() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
check_tokenization(
@@ -127,7 +127,7 @@
#[test]
fn character_a() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
assert_eq!(setup(&sm, &sh, "'a'".to_string()).next_token(), mk_lit(token::Char, "a", None),);
@@ -136,7 +136,7 @@
#[test]
fn character_space() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
assert_eq!(setup(&sm, &sh, "' '".to_string()).next_token(), mk_lit(token::Char, " ", None),);
@@ -145,7 +145,7 @@
#[test]
fn character_escaped() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
assert_eq!(
@@ -157,7 +157,7 @@
#[test]
fn lifetime_name() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
assert_eq!(
@@ -169,7 +169,7 @@
#[test]
fn raw_string() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
assert_eq!(
@@ -181,7 +181,7 @@
#[test]
fn literal_suffixes() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
macro_rules! test {
@@ -232,7 +232,7 @@
#[test]
fn nested_block_comments() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
let mut lexer = setup(&sm, &sh, "/* /* */ */'a'".to_string());
@@ -243,7 +243,7 @@
#[test]
fn crlf_comments() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
let mut lexer = setup(&sm, &sh, "// test\r\n/// test\r\n".to_string());
diff --git a/src/librustc_expand/parse/tests.rs b/src/librustc_expand/parse/tests.rs
index 437f6e6..fc9b9f2 100644
--- a/src/librustc_expand/parse/tests.rs
+++ b/src/librustc_expand/parse/tests.rs
@@ -5,7 +5,7 @@
use rustc_ast::token::{self, Token};
use rustc_ast::tokenstream::{DelimSpan, TokenStream, TokenTree};
use rustc_ast::visit;
-use rustc_ast::with_default_globals;
+use rustc_ast::with_default_session_globals;
use rustc_ast_pretty::pprust::item_to_string;
use rustc_errors::PResult;
use rustc_parse::new_parser_from_source_str;
@@ -50,7 +50,7 @@
#[should_panic]
#[test]
fn bad_path_expr_1() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
string_to_expr("::abc::def::return".to_string());
})
}
@@ -58,7 +58,7 @@
// Checks the token-tree-ization of macros.
#[test]
fn string_to_tts_macro() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let tts: Vec<_> =
string_to_stream("macro_rules! zip (($a)=>($a))".to_string()).trees().collect();
let tts: &[TokenTree] = &tts[..];
@@ -95,7 +95,7 @@
#[test]
fn string_to_tts_1() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let tts = string_to_stream("fn a (b : i32) { b; }".to_string());
let expected = TokenStream::new(vec![
@@ -130,7 +130,7 @@
#[test]
fn parse_use() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let use_s = "use foo::bar::baz;";
let vitem = string_to_item(use_s.to_string()).unwrap();
let vitem_s = item_to_string(&vitem);
@@ -145,7 +145,7 @@
#[test]
fn parse_extern_crate() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let ex_s = "extern crate foo;";
let vitem = string_to_item(ex_s.to_string()).unwrap();
let vitem_s = item_to_string(&vitem);
@@ -183,7 +183,7 @@
#[test]
fn span_of_self_arg_pat_idents_are_correct() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let srcs = [
"impl z { fn a (&self, &myarg: i32) {} }",
"impl z { fn a (&mut self, &myarg: i32) {} }",
@@ -207,7 +207,7 @@
#[test]
fn parse_exprs() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
// just make sure that they parse....
string_to_expr("3 + 4".to_string());
string_to_expr("a::z.froob(b,&(987+3))".to_string());
@@ -216,7 +216,7 @@
#[test]
fn attrs_fix_bug() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
string_to_item(
"pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
-> Result<Box<Writer>, String> {
@@ -237,7 +237,7 @@
#[test]
fn crlf_doc_comments() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sess = sess();
let name_1 = FileName::Custom("crlf_source_1".to_string());
@@ -271,7 +271,7 @@
new_parser_from_source_str(sess, name, source).parse_expr()
}
- with_default_globals(|| {
+ with_default_session_globals(|| {
let sess = sess();
let expr = parse_expr_from_source_str(
PathBuf::from("foo").into(),
@@ -299,7 +299,7 @@
// See `recurse_into_file_modules` in the parser.
#[test]
fn out_of_line_mod() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let item = parse_item_from_source_str(
PathBuf::from("foo").into(),
"mod foo { struct S; mod this_does_not_exist; }".to_owned(),
diff --git a/src/librustc_expand/tests.rs b/src/librustc_expand/tests.rs
index fbc49dd..283ea0f 100644
--- a/src/librustc_expand/tests.rs
+++ b/src/librustc_expand/tests.rs
@@ -1,6 +1,6 @@
use rustc_ast::ast;
use rustc_ast::tokenstream::TokenStream;
-use rustc_ast::with_default_globals;
+use rustc_ast::with_default_session_globals;
use rustc_parse::{new_parser_from_source_str, parser::Parser, source_file_to_stream};
use rustc_session::parse::ParseSess;
use rustc_span::source_map::{FilePathMapping, SourceMap};
@@ -124,7 +124,7 @@
}
fn test_harness(file_text: &str, span_labels: Vec<SpanLabel>, expected_output: &str) {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let output = Arc::new(Mutex::new(Vec::new()));
let source_map = Lrc::new(SourceMap::new(FilePathMapping::empty()));
diff --git a/src/librustc_expand/tokenstream/tests.rs b/src/librustc_expand/tokenstream/tests.rs
index caaa08d..bc171be 100644
--- a/src/librustc_expand/tokenstream/tests.rs
+++ b/src/librustc_expand/tokenstream/tests.rs
@@ -2,7 +2,7 @@
use rustc_ast::token;
use rustc_ast::tokenstream::{TokenStream, TokenStreamBuilder, TokenTree};
-use rustc_ast::with_default_globals;
+use rustc_ast::with_default_session_globals;
use rustc_span::{BytePos, Span, Symbol};
use smallvec::smallvec;
@@ -16,7 +16,7 @@
#[test]
fn test_concat() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let test_res = string_to_ts("foo::bar::baz");
let test_fst = string_to_ts("foo::bar");
let test_snd = string_to_ts("::baz");
@@ -29,7 +29,7 @@
#[test]
fn test_to_from_bijection() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let test_start = string_to_ts("foo::bar(baz)");
let test_end = test_start.trees().collect();
assert_eq!(test_start, test_end)
@@ -38,7 +38,7 @@
#[test]
fn test_eq_0() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let test_res = string_to_ts("foo");
let test_eqs = string_to_ts("foo");
assert_eq!(test_res, test_eqs)
@@ -47,7 +47,7 @@
#[test]
fn test_eq_1() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let test_res = string_to_ts("::bar::baz");
let test_eqs = string_to_ts("::bar::baz");
assert_eq!(test_res, test_eqs)
@@ -56,7 +56,7 @@
#[test]
fn test_eq_3() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let test_res = string_to_ts("");
let test_eqs = string_to_ts("");
assert_eq!(test_res, test_eqs)
@@ -65,7 +65,7 @@
#[test]
fn test_diseq_0() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let test_res = string_to_ts("::bar::baz");
let test_eqs = string_to_ts("bar::baz");
assert_eq!(test_res == test_eqs, false)
@@ -74,7 +74,7 @@
#[test]
fn test_diseq_1() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let test_res = string_to_ts("(bar,baz)");
let test_eqs = string_to_ts("bar,baz");
assert_eq!(test_res == test_eqs, false)
@@ -83,7 +83,7 @@
#[test]
fn test_is_empty() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let test0: TokenStream = Vec::<TokenTree>::new().into_iter().collect();
let test1: TokenStream =
TokenTree::token(token::Ident(Symbol::intern("a"), false), sp(0, 1)).into();
@@ -97,7 +97,7 @@
#[test]
fn test_dotdotdot() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let mut builder = TokenStreamBuilder::new();
builder.push(TokenTree::token(token::Dot, sp(0, 1)).joint());
builder.push(TokenTree::token(token::Dot, sp(1, 2)).joint());
diff --git a/src/librustc_feature/builtin_attrs.rs b/src/librustc_feature/builtin_attrs.rs
index c9a34f0..4e2aea3 100644
--- a/src/librustc_feature/builtin_attrs.rs
+++ b/src/librustc_feature/builtin_attrs.rs
@@ -47,7 +47,7 @@
/// Builtin attribute that may not be consumed by the compiler
/// before the unused_attribute check. These attributes
/// will be ignored by the unused_attribute lint
- Whitelisted,
+ AssumedUsed,
/// Builtin attribute that is only allowed at the crate level
CrateLevel,
@@ -202,7 +202,7 @@
ungated!(allow, Normal, template!(List: r#"lint1, lint2, ..., /*opt*/ reason = "...""#)),
ungated!(forbid, Normal, template!(List: r#"lint1, lint2, ..., /*opt*/ reason = "...""#)),
ungated!(deny, Normal, template!(List: r#"lint1, lint2, ..., /*opt*/ reason = "...""#)),
- ungated!(must_use, Whitelisted, template!(Word, NameValueStr: "reason")),
+ ungated!(must_use, AssumedUsed, template!(Word, NameValueStr: "reason")),
// FIXME(#14407)
ungated!(
deprecated, Normal,
@@ -220,16 +220,16 @@
// ABI, linking, symbols, and FFI
ungated!(
- link, Whitelisted,
+ link, AssumedUsed,
template!(List: r#"name = "...", /*opt*/ kind = "dylib|static|...", /*opt*/ wasm_import_module = "...""#),
),
- ungated!(link_name, Whitelisted, template!(NameValueStr: "name")),
+ ungated!(link_name, AssumedUsed, template!(NameValueStr: "name")),
ungated!(no_link, Normal, template!(Word)),
ungated!(repr, Normal, template!(List: "C")),
- ungated!(export_name, Whitelisted, template!(NameValueStr: "name")),
- ungated!(link_section, Whitelisted, template!(NameValueStr: "name")),
- ungated!(no_mangle, Whitelisted, template!(Word)),
- ungated!(used, Whitelisted, template!(Word)),
+ ungated!(export_name, AssumedUsed, template!(NameValueStr: "name")),
+ ungated!(link_section, AssumedUsed, template!(NameValueStr: "name")),
+ ungated!(no_mangle, AssumedUsed, template!(Word)),
+ ungated!(used, AssumedUsed, template!(Word)),
// Limits:
ungated!(recursion_limit, CrateLevel, template!(NameValueStr: "N")),
@@ -249,40 +249,40 @@
ungated!(path, Normal, template!(NameValueStr: "file")),
ungated!(no_std, CrateLevel, template!(Word)),
ungated!(no_implicit_prelude, Normal, template!(Word)),
- ungated!(non_exhaustive, Whitelisted, template!(Word)),
+ ungated!(non_exhaustive, AssumedUsed, template!(Word)),
// Runtime
- ungated!(windows_subsystem, Whitelisted, template!(NameValueStr: "windows|console")),
+ ungated!(windows_subsystem, AssumedUsed, template!(NameValueStr: "windows|console")),
ungated!(panic_handler, Normal, template!(Word)), // RFC 2070
// Code generation:
- ungated!(inline, Whitelisted, template!(Word, List: "always|never")),
- ungated!(cold, Whitelisted, template!(Word)),
- ungated!(no_builtins, Whitelisted, template!(Word)),
- ungated!(target_feature, Whitelisted, template!(List: r#"enable = "name""#)),
- ungated!(track_caller, Whitelisted, template!(Word)),
+ ungated!(inline, AssumedUsed, template!(Word, List: "always|never")),
+ ungated!(cold, AssumedUsed, template!(Word)),
+ ungated!(no_builtins, AssumedUsed, template!(Word)),
+ ungated!(target_feature, AssumedUsed, template!(List: r#"enable = "name""#)),
+ ungated!(track_caller, AssumedUsed, template!(Word)),
gated!(
- no_sanitize, Whitelisted,
+ no_sanitize, AssumedUsed,
template!(List: "address, memory, thread"),
experimental!(no_sanitize)
),
- // FIXME: #14408 whitelist docs since rustdoc looks at them
- ungated!(doc, Whitelisted, template!(List: "hidden|inline|...", NameValueStr: "string")),
+ // FIXME: #14408 assume docs are used since rustdoc looks at them.
+ ungated!(doc, AssumedUsed, template!(List: "hidden|inline|...", NameValueStr: "string")),
// ==========================================================================
// Unstable attributes:
// ==========================================================================
// Linking:
- gated!(naked, Whitelisted, template!(Word), naked_functions, experimental!(naked)),
+ gated!(naked, AssumedUsed, template!(Word), naked_functions, experimental!(naked)),
gated!(
link_args, Normal, template!(NameValueStr: "args"),
"the `link_args` attribute is experimental and not portable across platforms, \
it is recommended to use `#[link(name = \"foo\")] instead",
),
gated!(
- link_ordinal, Whitelisted, template!(List: "ordinal"), raw_dylib,
+ link_ordinal, AssumedUsed, template!(List: "ordinal"), raw_dylib,
experimental!(link_ordinal)
),
@@ -321,19 +321,19 @@
// RFC #1268
gated!(marker, Normal, template!(Word), marker_trait_attr, experimental!(marker)),
gated!(
- thread_local, Whitelisted, template!(Word),
+ thread_local, AssumedUsed, template!(Word),
"`#[thread_local]` is an experimental feature, and does not currently handle destructors",
),
gated!(no_core, CrateLevel, template!(Word), experimental!(no_core)),
// RFC 2412
gated!(
- optimize, Whitelisted, template!(List: "size|speed"), optimize_attribute,
+ optimize, AssumedUsed, template!(List: "size|speed"), optimize_attribute,
experimental!(optimize),
),
- gated!(ffi_returns_twice, Whitelisted, template!(Word), experimental!(ffi_returns_twice)),
- gated!(ffi_pure, Whitelisted, template!(Word), experimental!(ffi_pure)),
- gated!(ffi_const, Whitelisted, template!(Word), experimental!(ffi_const)),
+ gated!(ffi_returns_twice, AssumedUsed, template!(Word), experimental!(ffi_returns_twice)),
+ gated!(ffi_pure, AssumedUsed, template!(Word), experimental!(ffi_pure)),
+ gated!(ffi_const, AssumedUsed, template!(Word), experimental!(ffi_const)),
gated!(
register_attr, CrateLevel, template!(List: "attr1, attr2, ..."),
experimental!(register_attr),
@@ -351,22 +351,22 @@
// FIXME(#14407) -- only looked at on-demand so we can't
// guarantee they'll have already been checked.
ungated!(
- rustc_deprecated, Whitelisted,
+ rustc_deprecated, AssumedUsed,
template!(List: r#"since = "version", reason = "...""#)
),
// FIXME(#14407)
- ungated!(stable, Whitelisted, template!(List: r#"feature = "name", since = "version""#)),
+ ungated!(stable, AssumedUsed, template!(List: r#"feature = "name", since = "version""#)),
// FIXME(#14407)
ungated!(
- unstable, Whitelisted,
+ unstable, AssumedUsed,
template!(List: r#"feature = "name", reason = "...", issue = "N""#),
),
// FIXME(#14407)
- ungated!(rustc_const_unstable, Whitelisted, template!(List: r#"feature = "name""#)),
+ ungated!(rustc_const_unstable, AssumedUsed, template!(List: r#"feature = "name""#)),
// FIXME(#14407)
- ungated!(rustc_const_stable, Whitelisted, template!(List: r#"feature = "name""#)),
+ ungated!(rustc_const_stable, AssumedUsed, template!(List: r#"feature = "name""#)),
gated!(
- allow_internal_unstable, Whitelisted, template!(Word, List: "feat1, feat2, ..."),
+ allow_internal_unstable, AssumedUsed, template!(Word, List: "feat1, feat2, ..."),
"allow_internal_unstable side-steps feature gating and stability checks",
),
gated!(
@@ -378,7 +378,7 @@
// Internal attributes: Type system related:
// ==========================================================================
- gated!(fundamental, Whitelisted, template!(Word), experimental!(fundamental)),
+ gated!(fundamental, AssumedUsed, template!(Word), experimental!(fundamental)),
gated!(
may_dangle, Normal, template!(Word), dropck_eyepatch,
"`may_dangle` has unstable semantics and may be removed in the future",
@@ -388,30 +388,30 @@
// Internal attributes: Runtime related:
// ==========================================================================
- rustc_attr!(rustc_allocator, Whitelisted, template!(Word), IMPL_DETAIL),
- rustc_attr!(rustc_allocator_nounwind, Whitelisted, template!(Word), IMPL_DETAIL),
+ rustc_attr!(rustc_allocator, AssumedUsed, template!(Word), IMPL_DETAIL),
+ rustc_attr!(rustc_allocator_nounwind, AssumedUsed, template!(Word), IMPL_DETAIL),
gated!(alloc_error_handler, Normal, template!(Word), experimental!(alloc_error_handler)),
gated!(
- default_lib_allocator, Whitelisted, template!(Word), allocator_internals,
+ default_lib_allocator, AssumedUsed, template!(Word), allocator_internals,
experimental!(default_lib_allocator),
),
gated!(
needs_allocator, Normal, template!(Word), allocator_internals,
experimental!(needs_allocator),
),
- gated!(panic_runtime, Whitelisted, template!(Word), experimental!(panic_runtime)),
- gated!(needs_panic_runtime, Whitelisted, template!(Word), experimental!(needs_panic_runtime)),
+ gated!(panic_runtime, AssumedUsed, template!(Word), experimental!(panic_runtime)),
+ gated!(needs_panic_runtime, AssumedUsed, template!(Word), experimental!(needs_panic_runtime)),
gated!(
- unwind, Whitelisted, template!(List: "allowed|aborts"), unwind_attributes,
+ unwind, AssumedUsed, template!(List: "allowed|aborts"), unwind_attributes,
experimental!(unwind),
),
gated!(
- compiler_builtins, Whitelisted, template!(Word),
+ compiler_builtins, AssumedUsed, template!(Word),
"the `#[compiler_builtins]` attribute is used to identify the `compiler_builtins` crate \
which contains compiler-rt intrinsics and will never be stable",
),
gated!(
- profiler_runtime, Whitelisted, template!(Word),
+ profiler_runtime, AssumedUsed, template!(Word),
"the `#[profiler_runtime]` attribute is used to identify the `profiler_builtins` crate \
which contains the profiler runtime and will never be stable",
),
@@ -421,19 +421,19 @@
// ==========================================================================
gated!(
- linkage, Whitelisted, template!(NameValueStr: "external|internal|..."),
+ linkage, AssumedUsed, template!(NameValueStr: "external|internal|..."),
"the `linkage` attribute is experimental and not portable across platforms",
),
- rustc_attr!(rustc_std_internal_symbol, Whitelisted, template!(Word), INTERNAL_UNSTABLE),
+ rustc_attr!(rustc_std_internal_symbol, AssumedUsed, template!(Word), INTERNAL_UNSTABLE),
// ==========================================================================
// Internal attributes, Macro related:
// ==========================================================================
- rustc_attr!(rustc_builtin_macro, Whitelisted, template!(Word), IMPL_DETAIL),
+ rustc_attr!(rustc_builtin_macro, AssumedUsed, template!(Word), IMPL_DETAIL),
rustc_attr!(rustc_proc_macro_decls, Normal, template!(Word), INTERNAL_UNSTABLE),
rustc_attr!(
- rustc_macro_transparency, Whitelisted,
+ rustc_macro_transparency, AssumedUsed,
template!(NameValueStr: "transparent|semitransparent|opaque"),
"used internally for testing macro hygiene",
),
@@ -443,40 +443,40 @@
// ==========================================================================
rustc_attr!(
- rustc_on_unimplemented, Whitelisted,
+ rustc_on_unimplemented, AssumedUsed,
template!(
List: r#"/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...""#,
NameValueStr: "message"
),
INTERNAL_UNSTABLE
),
- // Whitelists "identity-like" conversion methods to suggest on type mismatch.
- rustc_attr!(rustc_conversion_suggestion, Whitelisted, template!(Word), INTERNAL_UNSTABLE),
+ // Enumerates "identity-like" conversion methods to suggest on type mismatch.
+ rustc_attr!(rustc_conversion_suggestion, AssumedUsed, template!(Word), INTERNAL_UNSTABLE),
// ==========================================================================
// Internal attributes, Const related:
// ==========================================================================
- rustc_attr!(rustc_promotable, Whitelisted, template!(Word), IMPL_DETAIL),
- rustc_attr!(rustc_allow_const_fn_ptr, Whitelisted, template!(Word), IMPL_DETAIL),
- rustc_attr!(rustc_args_required_const, Whitelisted, template!(List: "N"), INTERNAL_UNSTABLE),
+ rustc_attr!(rustc_promotable, AssumedUsed, template!(Word), IMPL_DETAIL),
+ rustc_attr!(rustc_allow_const_fn_ptr, AssumedUsed, template!(Word), IMPL_DETAIL),
+ rustc_attr!(rustc_args_required_const, AssumedUsed, template!(List: "N"), INTERNAL_UNSTABLE),
// ==========================================================================
// Internal attributes, Layout related:
// ==========================================================================
rustc_attr!(
- rustc_layout_scalar_valid_range_start, Whitelisted, template!(List: "value"),
+ rustc_layout_scalar_valid_range_start, AssumedUsed, template!(List: "value"),
"the `#[rustc_layout_scalar_valid_range_start]` attribute is just used to enable \
niche optimizations in libcore and will never be stable",
),
rustc_attr!(
- rustc_layout_scalar_valid_range_end, Whitelisted, template!(List: "value"),
+ rustc_layout_scalar_valid_range_end, AssumedUsed, template!(List: "value"),
"the `#[rustc_layout_scalar_valid_range_end]` attribute is just used to enable \
niche optimizations in libcore and will never be stable",
),
rustc_attr!(
- rustc_nonnull_optimization_guaranteed, Whitelisted, template!(Word),
+ rustc_nonnull_optimization_guaranteed, AssumedUsed, template!(Word),
"the `#[rustc_nonnull_optimization_guaranteed]` attribute is just used to enable \
niche optimizations in libcore and will never be stable",
),
@@ -501,7 +501,7 @@
),
gated!(
// Used in resolve:
- prelude_import, Whitelisted, template!(Word),
+ prelude_import, AssumedUsed, template!(Word),
"`#[prelude_import]` is for use by rustc only",
),
gated!(
@@ -509,7 +509,7 @@
"unboxed_closures are still evolving",
),
rustc_attr!(
- rustc_inherit_overflow_checks, Whitelisted, template!(Word),
+ rustc_inherit_overflow_checks, AssumedUsed, template!(Word),
"the `#[rustc_inherit_overflow_checks]` attribute is just used to control \
overflow checking behavior of several libcore functions that are inlined \
across crates and will never be stable",
@@ -540,42 +540,42 @@
rustc_attr!(TEST, rustc_layout, Normal, template!(List: "field1, field2, ...")),
rustc_attr!(TEST, rustc_regions, Normal, template!(Word)),
rustc_attr!(
- TEST, rustc_error, Whitelisted,
+ TEST, rustc_error, AssumedUsed,
template!(Word, List: "delay_span_bug_from_inside_query")
),
- rustc_attr!(TEST, rustc_dump_user_substs, Whitelisted, template!(Word)),
- rustc_attr!(TEST, rustc_if_this_changed, Whitelisted, template!(Word, List: "DepNode")),
- rustc_attr!(TEST, rustc_then_this_would_need, Whitelisted, template!(List: "DepNode")),
+ rustc_attr!(TEST, rustc_dump_user_substs, AssumedUsed, template!(Word)),
+ rustc_attr!(TEST, rustc_if_this_changed, AssumedUsed, template!(Word, List: "DepNode")),
+ rustc_attr!(TEST, rustc_then_this_would_need, AssumedUsed, template!(List: "DepNode")),
rustc_attr!(
- TEST, rustc_dirty, Whitelisted,
+ TEST, rustc_dirty, AssumedUsed,
template!(List: r#"cfg = "...", /*opt*/ label = "...", /*opt*/ except = "...""#),
),
rustc_attr!(
- TEST, rustc_clean, Whitelisted,
+ TEST, rustc_clean, AssumedUsed,
template!(List: r#"cfg = "...", /*opt*/ label = "...", /*opt*/ except = "...""#),
),
rustc_attr!(
- TEST, rustc_partition_reused, Whitelisted,
+ TEST, rustc_partition_reused, AssumedUsed,
template!(List: r#"cfg = "...", module = "...""#),
),
rustc_attr!(
- TEST, rustc_partition_codegened, Whitelisted,
+ TEST, rustc_partition_codegened, AssumedUsed,
template!(List: r#"cfg = "...", module = "...""#),
),
rustc_attr!(
- TEST, rustc_expected_cgu_reuse, Whitelisted,
+ TEST, rustc_expected_cgu_reuse, AssumedUsed,
template!(List: r#"cfg = "...", module = "...", kind = "...""#),
),
- rustc_attr!(TEST, rustc_synthetic, Whitelisted, template!(Word)),
- rustc_attr!(TEST, rustc_symbol_name, Whitelisted, template!(Word)),
- rustc_attr!(TEST, rustc_def_path, Whitelisted, template!(Word)),
- rustc_attr!(TEST, rustc_mir, Whitelisted, template!(List: "arg1, arg2, ...")),
- rustc_attr!(TEST, rustc_dump_program_clauses, Whitelisted, template!(Word)),
- rustc_attr!(TEST, rustc_dump_env_program_clauses, Whitelisted, template!(Word)),
- rustc_attr!(TEST, rustc_object_lifetime_default, Whitelisted, template!(Word)),
+ rustc_attr!(TEST, rustc_synthetic, AssumedUsed, template!(Word)),
+ rustc_attr!(TEST, rustc_symbol_name, AssumedUsed, template!(Word)),
+ rustc_attr!(TEST, rustc_def_path, AssumedUsed, template!(Word)),
+ rustc_attr!(TEST, rustc_mir, AssumedUsed, template!(List: "arg1, arg2, ...")),
+ rustc_attr!(TEST, rustc_dump_program_clauses, AssumedUsed, template!(Word)),
+ rustc_attr!(TEST, rustc_dump_env_program_clauses, AssumedUsed, template!(Word)),
+ rustc_attr!(TEST, rustc_object_lifetime_default, AssumedUsed, template!(Word)),
rustc_attr!(TEST, rustc_dummy, Normal, template!(Word /* doesn't matter*/)),
gated!(
- omit_gdb_pretty_printer_section, Whitelisted, template!(Word),
+ omit_gdb_pretty_printer_section, AssumedUsed, template!(Word),
"the `#[omit_gdb_pretty_printer_section]` attribute is just used for the Rust test suite",
),
];
diff --git a/src/librustc_incremental/persist/dirty_clean.rs b/src/librustc_incremental/persist/dirty_clean.rs
index 2ee9517..043aff9 100644
--- a/src/librustc_incremental/persist/dirty_clean.rs
+++ b/src/librustc_incremental/persist/dirty_clean.rs
@@ -168,7 +168,7 @@
// Note that we cannot use the existing "unused attribute"-infrastructure
// here, since that is running before codegen. This is also the reason why
- // all codegen-specific attributes are `Whitelisted` in rustc_ast::feature_gate.
+ // all codegen-specific attributes are `AssumedUsed` in rustc_ast::feature_gate.
all_attrs.report_unchecked_attrs(&dirty_clean_visitor.checked_attrs);
})
}
diff --git a/src/librustc_interface/interface.rs b/src/librustc_interface/interface.rs
index 920cc60..e50622a 100644
--- a/src/librustc_interface/interface.rs
+++ b/src/librustc_interface/interface.rs
@@ -38,7 +38,7 @@
pub(crate) crate_name: Option<String>,
pub(crate) register_lints: Option<Box<dyn Fn(&Session, &mut LintStore) + Send + Sync>>,
pub(crate) override_queries:
- Option<fn(&Session, &mut ty::query::Providers<'_>, &mut ty::query::Providers<'_>)>,
+ Option<fn(&Session, &mut ty::query::Providers, &mut ty::query::Providers)>,
}
impl Compiler {
@@ -74,7 +74,7 @@
/// Converts strings provided as `--cfg [cfgspec]` into a `crate_cfg`.
pub fn parse_cfgspecs(cfgspecs: Vec<String>) -> FxHashSet<(String, Option<String>)> {
- rustc_ast::with_default_globals(move || {
+ rustc_ast::with_default_session_globals(move || {
let cfg = cfgspecs
.into_iter()
.map(|s| {
@@ -153,16 +153,13 @@
///
/// The second parameter is local providers and the third parameter is external providers.
pub override_queries:
- Option<fn(&Session, &mut ty::query::Providers<'_>, &mut ty::query::Providers<'_>)>,
+ Option<fn(&Session, &mut ty::query::Providers, &mut ty::query::Providers)>,
/// Registry of diagnostics codes.
pub registry: Registry,
}
-pub fn run_compiler_in_existing_thread_pool<R>(
- config: Config,
- f: impl FnOnce(&Compiler) -> R,
-) -> R {
+pub fn create_compiler_and_run<R>(config: Config, f: impl FnOnce(&Compiler) -> R) -> R {
let registry = &config.registry;
let (sess, codegen_backend) = util::create_session(
config.opts,
@@ -204,17 +201,20 @@
pub fn run_compiler<R: Send>(mut config: Config, f: impl FnOnce(&Compiler) -> R + Send) -> R {
log::trace!("run_compiler");
let stderr = config.stderr.take();
- util::spawn_thread_pool(
+ util::setup_callbacks_and_run_in_thread_pool_with_globals(
config.opts.edition,
config.opts.debugging_opts.threads,
&stderr,
- || run_compiler_in_existing_thread_pool(config, f),
+ || create_compiler_and_run(config, f),
)
}
-pub fn default_thread_pool<R: Send>(edition: edition::Edition, f: impl FnOnce() -> R + Send) -> R {
+pub fn setup_callbacks_and_run_in_default_thread_pool_with_globals<R: Send>(
+ edition: edition::Edition,
+ f: impl FnOnce() -> R + Send,
+) -> R {
// the 1 here is duplicating code in config.opts.debugging_opts.threads
// which also defaults to 1; it ultimately doesn't matter as the default
// isn't threaded, and just ignores this parameter
- util::spawn_thread_pool(edition, 1, &None, f)
+ util::setup_callbacks_and_run_in_thread_pool_with_globals(edition, 1, &None, f)
}
diff --git a/src/librustc_interface/passes.rs b/src/librustc_interface/passes.rs
index ed5e715..6d85c2f 100644
--- a/src/librustc_interface/passes.rs
+++ b/src/librustc_interface/passes.rs
@@ -719,7 +719,7 @@
Ok(outputs)
}
-pub fn default_provide(providers: &mut ty::query::Providers<'_>) {
+pub fn default_provide(providers: &mut ty::query::Providers) {
providers.analysis = analysis;
proc_macro_decls::provide(providers);
plugin::build::provide(providers);
@@ -740,7 +740,7 @@
rustc_codegen_ssa::provide(providers);
}
-pub fn default_provide_extern(providers: &mut ty::query::Providers<'_>) {
+pub fn default_provide_extern(providers: &mut ty::query::Providers) {
rustc_metadata::provide_extern(providers);
rustc_codegen_ssa::provide_extern(providers);
}
diff --git a/src/librustc_interface/proc_macro_decls.rs b/src/librustc_interface/proc_macro_decls.rs
index c74cba8..e91003b 100644
--- a/src/librustc_interface/proc_macro_decls.rs
+++ b/src/librustc_interface/proc_macro_decls.rs
@@ -35,6 +35,6 @@
fn visit_impl_item(&mut self, _impl_item: &hir::ImplItem<'_>) {}
}
-pub(crate) fn provide(providers: &mut Providers<'_>) {
+pub(crate) fn provide(providers: &mut Providers) {
*providers = Providers { proc_macro_decls_static, ..*providers };
}
diff --git a/src/librustc_interface/tests.rs b/src/librustc_interface/tests.rs
index e35dbbc..651a779 100644
--- a/src/librustc_interface/tests.rs
+++ b/src/librustc_interface/tests.rs
@@ -73,7 +73,7 @@
// When the user supplies --test we should implicitly supply --cfg test
#[test]
fn test_switch_implies_cfg_test() {
- rustc_ast::with_default_globals(|| {
+ rustc_ast::with_default_session_globals(|| {
let matches = optgroups().parse(&["--test".to_string()]).unwrap();
let (sess, cfg) = mk_session(matches);
let cfg = build_configuration(&sess, to_crate_config(cfg));
@@ -84,7 +84,7 @@
// When the user supplies --test and --cfg test, don't implicitly add another --cfg test
#[test]
fn test_switch_implies_cfg_test_unless_cfg_test() {
- rustc_ast::with_default_globals(|| {
+ rustc_ast::with_default_session_globals(|| {
let matches = optgroups().parse(&["--test".to_string(), "--cfg=test".to_string()]).unwrap();
let (sess, cfg) = mk_session(matches);
let cfg = build_configuration(&sess, to_crate_config(cfg));
@@ -96,20 +96,20 @@
#[test]
fn test_can_print_warnings() {
- rustc_ast::with_default_globals(|| {
+ rustc_ast::with_default_session_globals(|| {
let matches = optgroups().parse(&["-Awarnings".to_string()]).unwrap();
let (sess, _) = mk_session(matches);
assert!(!sess.diagnostic().can_emit_warnings());
});
- rustc_ast::with_default_globals(|| {
+ rustc_ast::with_default_session_globals(|| {
let matches =
optgroups().parse(&["-Awarnings".to_string(), "-Dwarnings".to_string()]).unwrap();
let (sess, _) = mk_session(matches);
assert!(sess.diagnostic().can_emit_warnings());
});
- rustc_ast::with_default_globals(|| {
+ rustc_ast::with_default_session_globals(|| {
let matches = optgroups().parse(&["-Adead_code".to_string()]).unwrap();
let (sess, _) = mk_session(matches);
assert!(sess.diagnostic().can_emit_warnings());
diff --git a/src/librustc_interface/util.rs b/src/librustc_interface/util.rs
index 924908e..0c8c713 100644
--- a/src/librustc_interface/util.rs
+++ b/src/librustc_interface/util.rs
@@ -38,8 +38,8 @@
/// Adds `target_feature = "..."` cfgs for a variety of platform
/// specific features (SSE, NEON etc.).
///
-/// This is performed by checking whether a whitelisted set of
-/// features is available on the target machine, by querying LLVM.
+/// This is performed by checking whether a set of permitted features
+/// is available on the target machine, by querying LLVM.
pub fn add_configuration(
cfg: &mut CrateConfig,
sess: &mut Session,
@@ -102,6 +102,8 @@
}
}
+/// Like a `thread::Builder::spawn` followed by a `join()`, but avoids the need
+/// for `'static` bounds.
#[cfg(not(parallel_compiler))]
pub fn scoped_thread<F: FnOnce() -> R + Send, R: Send>(cfg: thread::Builder, f: F) -> R {
struct Ptr(*mut ());
@@ -126,7 +128,7 @@
}
#[cfg(not(parallel_compiler))]
-pub fn spawn_thread_pool<F: FnOnce() -> R + Send, R: Send>(
+pub fn setup_callbacks_and_run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
edition: Edition,
_threads: usize,
stderr: &Option<Arc<Mutex<Vec<u8>>>>,
@@ -140,8 +142,8 @@
crate::callbacks::setup_callbacks();
- scoped_thread(cfg, || {
- rustc_ast::with_globals(edition, || {
+ let main_handler = move || {
+ rustc_ast::with_session_globals(edition, || {
ty::tls::GCX_PTR.set(&Lock::new(0), || {
if let Some(stderr) = stderr {
io::set_panic(Some(box Sink(stderr.clone())));
@@ -149,22 +151,21 @@
f()
})
})
- })
+ };
+
+ scoped_thread(cfg, main_handler)
}
#[cfg(parallel_compiler)]
-pub fn spawn_thread_pool<F: FnOnce() -> R + Send, R: Send>(
+pub fn setup_callbacks_and_run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
edition: Edition,
threads: usize,
stderr: &Option<Arc<Mutex<Vec<u8>>>>,
f: F,
) -> R {
- use rayon::{ThreadBuilder, ThreadPool, ThreadPoolBuilder};
-
- let gcx_ptr = &Lock::new(0);
crate::callbacks::setup_callbacks();
- let mut config = ThreadPoolBuilder::new()
+ let mut config = rayon::ThreadPoolBuilder::new()
.thread_name(|_| "rustc".to_string())
.acquire_thread_handler(jobserver::acquire_thread)
.release_thread_handler(jobserver::release_thread)
@@ -175,22 +176,25 @@
config = config.stack_size(size);
}
- let with_pool = move |pool: &ThreadPool| pool.install(move || f());
+ let with_pool = move |pool: &rayon::ThreadPool| pool.install(move || f());
- rustc_ast::with_globals(edition, || {
- rustc_ast::GLOBALS.with(|syntax_globals| {
- rustc_span::GLOBALS.with(|rustc_span_globals| {
- // The main handler runs for each Rayon worker thread and sets up
- // the thread local rustc uses. syntax_globals and rustc_span_globals are
- // captured and set on the new threads. ty::tls::with_thread_locals sets up
- // thread local callbacks from librustc_ast
- let main_handler = move |thread: ThreadBuilder| {
- rustc_ast::GLOBALS.set(syntax_globals, || {
- rustc_span::GLOBALS.set(rustc_span_globals, || {
- if let Some(stderr) = stderr {
- io::set_panic(Some(box Sink(stderr.clone())));
- }
- ty::tls::GCX_PTR.set(gcx_ptr, || thread.run())
+ rustc_ast::with_session_globals(edition, || {
+ rustc_ast::SESSION_GLOBALS.with(|ast_session_globals| {
+ rustc_span::SESSION_GLOBALS.with(|span_session_globals| {
+ // The main handler runs for each Rayon worker thread and sets
+ // up the thread local rustc uses. ast_session_globals and
+ // span_session_globals are captured and set on the new
+ // threads. ty::tls::with_thread_locals sets up thread local
+ // callbacks from librustc_ast.
+ let main_handler = move |thread: rayon::ThreadBuilder| {
+ rustc_ast::SESSION_GLOBALS.set(ast_session_globals, || {
+ rustc_span::SESSION_GLOBALS.set(span_session_globals, || {
+ ty::tls::GCX_PTR.set(&Lock::new(0), || {
+ if let Some(stderr) = stderr {
+ io::set_panic(Some(box Sink(stderr.clone())));
+ }
+ thread.run()
+ })
})
})
};
diff --git a/src/librustc_lint/levels.rs b/src/librustc_lint/levels.rs
index f875e27..2e9cd96 100644
--- a/src/librustc_lint/levels.rs
+++ b/src/librustc_lint/levels.rs
@@ -571,6 +571,6 @@
}
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
providers.lint_levels = lint_levels;
}
diff --git a/src/librustc_lint/lib.rs b/src/librustc_lint/lib.rs
index 45a86cf..6b5353e 100644
--- a/src/librustc_lint/lib.rs
+++ b/src/librustc_lint/lib.rs
@@ -63,7 +63,7 @@
use rustc_middle::ty::TyCtxt;
use rustc_session::lint::builtin::{
BARE_TRAIT_OBJECTS, ELIDED_LIFETIMES_IN_PATHS, EXPLICIT_OUTLIVES_REQUIREMENTS,
- INTRA_DOC_LINK_RESOLUTION_FAILURE, INVALID_CODEBLOCK_ATTRIBUTE, MISSING_DOC_CODE_EXAMPLES,
+ INTRA_DOC_LINK_RESOLUTION_FAILURE, INVALID_CODEBLOCK_ATTRIBUTES, MISSING_DOC_CODE_EXAMPLES,
PRIVATE_DOC_TESTS,
};
use rustc_span::symbol::{Ident, Symbol};
@@ -88,7 +88,7 @@
pub use rustc_session::lint::{BufferedEarlyLint, FutureIncompatibleInfo, Lint, LintId};
pub use rustc_session::lint::{LintArray, LintPass};
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
levels::provide(providers);
*providers = Providers { lint_mod, ..*providers };
}
@@ -305,7 +305,7 @@
add_lint_group!(
"rustdoc",
INTRA_DOC_LINK_RESOLUTION_FAILURE,
- INVALID_CODEBLOCK_ATTRIBUTE,
+ INVALID_CODEBLOCK_ATTRIBUTES,
MISSING_DOC_CODE_EXAMPLES,
PRIVATE_DOC_TESTS
);
diff --git a/src/librustc_lint/unused.rs b/src/librustc_lint/unused.rs
index c407f60..2431f7b 100644
--- a/src/librustc_lint/unused.rs
+++ b/src/librustc_lint/unused.rs
@@ -287,8 +287,8 @@
let attr_info = attr.ident().and_then(|ident| self.builtin_attributes.get(&ident.name));
if let Some(&&(name, ty, ..)) = attr_info {
- if let AttributeType::Whitelisted = ty {
- debug!("{:?} is Whitelisted", name);
+ if let AttributeType::AssumedUsed = ty {
+ debug!("{:?} is AssumedUsed", name);
return;
}
}
diff --git a/src/librustc_metadata/rmeta/decoder.rs b/src/librustc_metadata/rmeta/decoder.rs
index 1ac16e0..4746e53 100644
--- a/src/librustc_metadata/rmeta/decoder.rs
+++ b/src/librustc_metadata/rmeta/decoder.rs
@@ -1386,9 +1386,6 @@
let constness = match self.kind(id) {
EntryKind::AssocFn(data) => data.decode(self).fn_data.constness,
EntryKind::Fn(data) => data.decode(self).constness,
- // Some intrinsics can be const fn. While we could recompute this (at least until we
- // stop having hardcoded whitelists and move to stability attributes), it seems cleaner
- // to treat all const fns equally.
EntryKind::ForeignFn(data) => data.decode(self).constness,
EntryKind::Variant(..) | EntryKind::Struct(..) => hir::Constness::Const,
_ => hir::Constness::NotConst,
diff --git a/src/librustc_metadata/rmeta/decoder/cstore_impl.rs b/src/librustc_metadata/rmeta/decoder/cstore_impl.rs
index abbe45f..201a32d 100644
--- a/src/librustc_metadata/rmeta/decoder/cstore_impl.rs
+++ b/src/librustc_metadata/rmeta/decoder/cstore_impl.rs
@@ -17,7 +17,6 @@
use rustc_middle::middle::exported_symbols::ExportedSymbol;
use rustc_middle::middle::stability::DeprecationEntry;
use rustc_middle::ty::query::Providers;
-use rustc_middle::ty::query::QueryConfig;
use rustc_middle::ty::{self, TyCtxt};
use rustc_session::utils::NativeLibKind;
use rustc_session::{CrateDisambiguator, Session};
@@ -31,13 +30,11 @@
macro_rules! provide {
(<$lt:tt> $tcx:ident, $def_id:ident, $other:ident, $cdata:ident,
$($name:ident => $compute:block)*) => {
- pub fn provide_extern<$lt>(providers: &mut Providers<$lt>) {
- // HACK(eddyb) `$lt: $lt` forces `$lt` to be early-bound, which
- // allows the associated type in the return type to be normalized.
- $(fn $name<$lt: $lt, T: IntoArgs>(
+ pub fn provide_extern(providers: &mut Providers) {
+ $(fn $name<$lt>(
$tcx: TyCtxt<$lt>,
- def_id_arg: T,
- ) -> <ty::queries::$name<$lt> as QueryConfig<TyCtxt<$lt>>>::Value {
+ def_id_arg: ty::query::query_keys::$name<$lt>,
+ ) -> ty::query::query_values::$name<$lt> {
let _prof_timer =
$tcx.prof.generic_activity("metadata_decode_entry");
@@ -243,7 +240,7 @@
crate_extern_paths => { cdata.source().paths().cloned().collect() }
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
// FIXME(#44234) - almost all of these queries have no sub-queries and
// therefore no actual inputs, they're just reading tables calculated in
// resolve! Does this work? Unsure! That's what the issue is about
diff --git a/src/librustc_middle/hir/map/mod.rs b/src/librustc_middle/hir/map/mod.rs
index 75c10de..250f4d5 100644
--- a/src/librustc_middle/hir/map/mod.rs
+++ b/src/librustc_middle/hir/map/mod.rs
@@ -1067,6 +1067,6 @@
}
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
providers.def_kind = |tcx, def_id| tcx.hir().def_kind(def_id.expect_local());
}
diff --git a/src/librustc_middle/hir/mod.rs b/src/librustc_middle/hir/mod.rs
index e152d11..485f9b7 100644
--- a/src/librustc_middle/hir/mod.rs
+++ b/src/librustc_middle/hir/mod.rs
@@ -62,7 +62,7 @@
}
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
providers.parent_module_from_def_id = |tcx, id| {
let hir = tcx.hir();
hir.local_def_id(hir.get_module_parent_node(hir.as_local_hir_id(id)))
diff --git a/src/librustc_middle/lint.rs b/src/librustc_middle/lint.rs
index bb62c1b..3f09392 100644
--- a/src/librustc_middle/lint.rs
+++ b/src/librustc_middle/lint.rs
@@ -230,8 +230,9 @@
err.allow_suggestions(false);
// If this is a future incompatible lint it'll become a hard error, so
- // we have to emit *something*. Also allow lints to whitelist themselves
- // on a case-by-case basis for emission in a foreign macro.
+ // 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 {
err.cancel();
// Don't continue further, since we don't want to have
diff --git a/src/librustc_middle/middle/lang_items.rs b/src/librustc_middle/middle/lang_items.rs
index 0f98c33..70c9019 100644
--- a/src/librustc_middle/middle/lang_items.rs
+++ b/src/librustc_middle/middle/lang_items.rs
@@ -42,19 +42,18 @@
}
}
-/// Returns `true` if the specified `lang_item` doesn't actually need to be
-/// present for this compilation.
+/// Returns `true` if the specified `lang_item` must be present for this
+/// compilation.
///
/// Not all lang items are always required for each compilation, particularly in
/// the case of panic=abort. In these situations some lang items are injected by
/// crates and don't actually need to be defined in libstd.
-pub fn whitelisted(tcx: TyCtxt<'_>, lang_item: LangItem) -> bool {
+pub fn required(tcx: TyCtxt<'_>, lang_item: LangItem) -> bool {
// If we're not compiling with unwinding, we won't actually need these
// symbols. Other panic runtimes ensure that the relevant symbols are
// available to link things together, but they're never exercised.
- if tcx.sess.panic_strategy() != PanicStrategy::Unwind {
- return lang_item == LangItem::EhPersonalityLangItem;
+ match tcx.sess.panic_strategy() {
+ PanicStrategy::Abort => lang_item != LangItem::EhPersonalityLangItem,
+ PanicStrategy::Unwind => true,
}
-
- false
}
diff --git a/src/librustc_middle/query/mod.rs b/src/librustc_middle/query/mod.rs
index 3285be5..0faf389 100644
--- a/src/librustc_middle/query/mod.rs
+++ b/src/librustc_middle/query/mod.rs
@@ -1413,10 +1413,10 @@
}
Other {
- query target_features_whitelist(_: CrateNum) -> FxHashMap<String, Option<Symbol>> {
+ query supported_target_features(_: CrateNum) -> FxHashMap<String, Option<Symbol>> {
storage(ArenaCacheSelector<'tcx>)
eval_always
- desc { "looking up the whitelist of target features" }
+ desc { "looking up supported target features" }
}
// Get an estimate of the size of an InstanceDef based on its MIR for CGU partitioning.
diff --git a/src/librustc_middle/ty/context.rs b/src/librustc_middle/ty/context.rs
index 698bef4..c4a5bc3 100644
--- a/src/librustc_middle/ty/context.rs
+++ b/src/librustc_middle/ty/context.rs
@@ -1060,8 +1060,8 @@
pub fn create_global_ctxt(
s: &'tcx Session,
lint_store: Lrc<dyn Any + sync::Send + sync::Sync>,
- local_providers: ty::query::Providers<'tcx>,
- extern_providers: ty::query::Providers<'tcx>,
+ local_providers: ty::query::Providers,
+ extern_providers: ty::query::Providers,
arena: &'tcx WorkerLocal<Arena<'tcx>>,
resolutions: ty::ResolverOutputs,
krate: &'tcx hir::Crate<'tcx>,
@@ -2699,7 +2699,7 @@
t as *const () == u as *const ()
}
-pub fn provide(providers: &mut ty::query::Providers<'_>) {
+pub fn provide(providers: &mut ty::query::Providers) {
providers.in_scope_traits_map = |tcx, id| tcx.gcx.trait_map.get(&id);
providers.module_exports = |tcx, id| tcx.gcx.export_map.get(&id).map(|v| &v[..]);
providers.crate_name = |tcx, id| {
diff --git a/src/librustc_middle/ty/erase_regions.rs b/src/librustc_middle/ty/erase_regions.rs
index ba16592..48d0fc1 100644
--- a/src/librustc_middle/ty/erase_regions.rs
+++ b/src/librustc_middle/ty/erase_regions.rs
@@ -1,7 +1,7 @@
use crate::ty::fold::{TypeFoldable, TypeFolder};
use crate::ty::{self, Ty, TyCtxt, TypeFlags};
-pub(super) fn provide(providers: &mut ty::query::Providers<'_>) {
+pub(super) fn provide(providers: &mut ty::query::Providers) {
*providers = ty::query::Providers { erase_regions_ty, ..*providers };
}
diff --git a/src/librustc_middle/ty/layout.rs b/src/librustc_middle/ty/layout.rs
index 010370c..66ad923 100644
--- a/src/librustc_middle/ty/layout.rs
+++ b/src/librustc_middle/ty/layout.rs
@@ -210,7 +210,7 @@
})
}
-pub fn provide(providers: &mut ty::query::Providers<'_>) {
+pub fn provide(providers: &mut ty::query::Providers) {
*providers = ty::query::Providers { layout_raw, ..*providers };
}
@@ -527,7 +527,7 @@
size: Size::ZERO,
}),
- // Potentially-fat pointers.
+ // Potentially-wide pointers.
ty::Ref(_, pointee, _) | ty::RawPtr(ty::TypeAndMut { ty: pointee, .. }) => {
let mut data_ptr = scalar_unit(Pointer);
if !ty.is_unsafe_ptr() {
diff --git a/src/librustc_middle/ty/mod.rs b/src/librustc_middle/ty/mod.rs
index 5ed3994..bec1200 100644
--- a/src/librustc_middle/ty/mod.rs
+++ b/src/librustc_middle/ty/mod.rs
@@ -2966,7 +2966,7 @@
None
}
-pub fn provide(providers: &mut ty::query::Providers<'_>) {
+pub fn provide(providers: &mut ty::query::Providers) {
context::provide(providers);
erase_regions::provide(providers);
layout::provide(providers);
diff --git a/src/librustc_middle/ty/query/job.rs b/src/librustc_middle/ty/query/job.rs
index 5f7a9e8..60b93b3 100644
--- a/src/librustc_middle/ty/query/job.rs
+++ b/src/librustc_middle/ty/query/job.rs
@@ -13,16 +13,15 @@
let gcx_ptr = tls::GCX_PTR.with(|gcx_ptr| gcx_ptr as *const _);
let gcx_ptr = &*gcx_ptr;
- let rustc_span_globals =
- rustc_span::GLOBALS.with(|rustc_span_globals| rustc_span_globals as *const _);
- let rustc_span_globals = &*rustc_span_globals;
- let syntax_globals = rustc_ast::attr::GLOBALS.with(|syntax_globals| syntax_globals as *const _);
- let syntax_globals = &*syntax_globals;
+ let span_session_globals = rustc_span::SESSION_GLOBALS.with(|ssg| ssg as *const _);
+ let span_session_globals = &*span_session_globals;
+ let ast_session_globals = rustc_ast::attr::SESSION_GLOBALS.with(|asg| asg as *const _);
+ let ast_session_globals = &*ast_session_globals;
thread::spawn(move || {
tls::GCX_PTR.set(gcx_ptr, || {
- rustc_ast::attr::GLOBALS.set(syntax_globals, || {
- rustc_span::GLOBALS
- .set(rustc_span_globals, || tls::with_global(|tcx| deadlock(tcx, ®istry)))
+ rustc_ast::attr::SESSION_GLOBALS.set(ast_session_globals, || {
+ rustc_span::SESSION_GLOBALS
+ .set(span_session_globals, || tls::with_global(|tcx| deadlock(tcx, ®istry)))
});
})
});
diff --git a/src/librustc_middle/ty/query/plumbing.rs b/src/librustc_middle/ty/query/plumbing.rs
index c711de9..f3fa363 100644
--- a/src/librustc_middle/ty/query/plumbing.rs
+++ b/src/librustc_middle/ty/query/plumbing.rs
@@ -318,15 +318,34 @@
}
}
+ #[allow(nonstandard_style)]
pub mod queries {
use std::marker::PhantomData;
- $(#[allow(nonstandard_style)]
- pub struct $name<$tcx> {
+ $(pub struct $name<$tcx> {
data: PhantomData<&$tcx ()>
})*
}
+ // HACK(eddyb) this is like the `impl QueryConfig for queries::$name`
+ // below, but using type aliases instead of associated types, to bypass
+ // the limitations around normalizing under HRTB - for example, this:
+ // `for<'tcx> fn(...) -> <queries::$name<'tcx> as QueryConfig<TyCtxt<'tcx>>>::Value`
+ // doesn't currently normalize to `for<'tcx> fn(...) -> query_values::$name<'tcx>`.
+ // This is primarily used by the `provide!` macro in `rustc_metadata`.
+ #[allow(nonstandard_style, unused_lifetimes)]
+ pub mod query_keys {
+ use super::*;
+
+ $(pub type $name<$tcx> = $($K)*;)*
+ }
+ #[allow(nonstandard_style, unused_lifetimes)]
+ pub mod query_values {
+ use super::*;
+
+ $(pub type $name<$tcx> = $V;)*
+ }
+
$(impl<$tcx> QueryConfig<TyCtxt<$tcx>> for queries::$name<$tcx> {
type Key = $($K)*;
type Value = $V;
@@ -478,13 +497,16 @@
input: ($(([$($modifiers)*] [$name] [$($K)*] [$V]))*)
}
- impl<$tcx> Copy for Providers<$tcx> {}
- impl<$tcx> Clone for Providers<$tcx> {
+ impl Copy for Providers {}
+ impl Clone for Providers {
fn clone(&self) -> Self { *self }
}
}
}
+// FIXME(eddyb) this macro (and others?) use `$tcx` and `'tcx` interchangeably.
+// We should either not take `$tcx` at all and use `'tcx` everywhere, or use
+// `$tcx` everywhere (even if that isn't necessary due to lack of hygiene).
macro_rules! define_queries_struct {
(tcx: $tcx:tt,
input: ($(([$($modifiers:tt)*] [$($attr:tt)*] [$name:ident]))*)) => {
@@ -494,8 +516,8 @@
/// `DepGraph::try_mark_green()` and the query infrastructure.
pub(crate) on_disk_cache: OnDiskCache<'tcx>,
- providers: IndexVec<CrateNum, Providers<$tcx>>,
- fallback_extern_providers: Box<Providers<$tcx>>,
+ providers: IndexVec<CrateNum, Providers>,
+ fallback_extern_providers: Box<Providers>,
$($(#[$attr])* $name: QueryState<
TyCtxt<$tcx>,
@@ -505,8 +527,8 @@
impl<$tcx> Queries<$tcx> {
pub(crate) fn new(
- providers: IndexVec<CrateNum, Providers<$tcx>>,
- fallback_extern_providers: Providers<$tcx>,
+ providers: IndexVec<CrateNum, Providers>,
+ fallback_extern_providers: Providers,
on_disk_cache: OnDiskCache<'tcx>,
) -> Self {
Queries {
@@ -539,11 +561,11 @@
macro_rules! define_provider_struct {
(tcx: $tcx:tt,
input: ($(([$($modifiers:tt)*] [$name:ident] [$K:ty] [$R:ty]))*)) => {
- pub struct Providers<$tcx> {
- $(pub $name: fn(TyCtxt<$tcx>, $K) -> $R,)*
+ pub struct Providers {
+ $(pub $name: for<$tcx> fn(TyCtxt<$tcx>, $K) -> $R,)*
}
- impl<$tcx> Default for Providers<$tcx> {
+ impl Default for Providers {
fn default() -> Self {
$(fn $name<$tcx>(_: TyCtxt<$tcx>, key: $K) -> $R {
bug!("`tcx.{}({:?})` unsupported by its crate",
diff --git a/src/librustc_middle/util/bug.rs b/src/librustc_middle/util/bug.rs
index 9c3a97d..0903ef5 100644
--- a/src/librustc_middle/util/bug.rs
+++ b/src/librustc_middle/util/bug.rs
@@ -47,6 +47,6 @@
);
}
-pub fn provide(providers: &mut crate::ty::query::Providers<'_>) {
+pub fn provide(providers: &mut crate::ty::query::Providers) {
*providers = crate::ty::query::Providers { trigger_delay_span_bug, ..*providers };
}
diff --git a/src/librustc_mir/borrow_check/mod.rs b/src/librustc_mir/borrow_check/mod.rs
index 83691d4..beb5f1f 100644
--- a/src/librustc_mir/borrow_check/mod.rs
+++ b/src/librustc_mir/borrow_check/mod.rs
@@ -86,7 +86,7 @@
const DEREF_PROJECTION: &[PlaceElem<'_>; 1] = &[ProjectionElem::Deref];
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
*providers = Providers { mir_borrowck, ..*providers };
}
diff --git a/src/librustc_mir/const_eval/fn_queries.rs b/src/librustc_mir/const_eval/fn_queries.rs
index 74f8a1c..70ddd79 100644
--- a/src/librustc_mir/const_eval/fn_queries.rs
+++ b/src/librustc_mir/const_eval/fn_queries.rs
@@ -88,7 +88,7 @@
}
/// Checks whether the function has a `const` modifier or, in case it is an intrinsic, whether
-/// said intrinsic is on the whitelist for being const callable.
+/// said intrinsic has a `rustc_const_{un,}stable` attribute.
fn is_const_fn_raw(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local());
@@ -156,7 +156,7 @@
&& tcx.lookup_const_stability(def_id).map(|stab| stab.allow_const_fn_ptr).unwrap_or(false)
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
*providers = Providers {
is_const_fn_raw,
is_const_impl_raw: |tcx, def_id| is_const_impl_raw(tcx, def_id.expect_local()),
diff --git a/src/librustc_mir/interpret/validity.rs b/src/librustc_mir/interpret/validity.rs
index ab83659..f95ac30 100644
--- a/src/librustc_mir/interpret/validity.rs
+++ b/src/librustc_mir/interpret/validity.rs
@@ -45,7 +45,7 @@
/// If $e throws an error matching the pattern, throw a validation failure.
/// Other errors are passed back to the caller, unchanged -- and if they reach the root of
/// the visitor, we make sure only validation errors and `InvalidProgram` errors are left.
-/// This lets you use the patterns as a kind of validation whitelist, asserting which errors
+/// This lets you use the patterns as a kind of validation list, asserting which errors
/// can possibly happen:
///
/// ```
diff --git a/src/librustc_mir/lib.rs b/src/librustc_mir/lib.rs
index cb68931..eff1dc1 100644
--- a/src/librustc_mir/lib.rs
+++ b/src/librustc_mir/lib.rs
@@ -47,7 +47,7 @@
use rustc_middle::ty::query::Providers;
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
borrow_check::provide(providers);
const_eval::provide(providers);
shim::provide(providers);
diff --git a/src/librustc_mir/monomorphize/partitioning.rs b/src/librustc_mir/monomorphize/partitioning.rs
index a945c1d..ebea65c 100644
--- a/src/librustc_mir/monomorphize/partitioning.rs
+++ b/src/librustc_mir/monomorphize/partitioning.rs
@@ -880,9 +880,9 @@
}
fn collect_and_partition_mono_items(
- tcx: TyCtxt<'_>,
+ tcx: TyCtxt<'tcx>,
cnum: CrateNum,
-) -> (&'tcx DefIdSet, &'tcx [CodegenUnit<'_>]) {
+) -> (&'tcx DefIdSet, &'tcx [CodegenUnit<'tcx>]) {
assert_eq!(cnum, LOCAL_CRATE);
let collection_mode = match tcx.sess.opts.debugging_opts.print_mono_items {
@@ -994,7 +994,7 @@
(tcx.arena.alloc(mono_items), codegen_units)
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
providers.collect_and_partition_mono_items = collect_and_partition_mono_items;
providers.is_codegened_item = |tcx, def_id| {
diff --git a/src/librustc_mir/shim.rs b/src/librustc_mir/shim.rs
index 5671b5b..98286cd 100644
--- a/src/librustc_mir/shim.rs
+++ b/src/librustc_mir/shim.rs
@@ -23,7 +23,7 @@
use crate::util::expand_aggregate;
use crate::util::patch::MirPatch;
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
providers.mir_shims = make_shim;
}
diff --git a/src/librustc_mir/transform/check_unsafety.rs b/src/librustc_mir/transform/check_unsafety.rs
index b8f725e..f218dd3 100644
--- a/src/librustc_mir/transform/check_unsafety.rs
+++ b/src/librustc_mir/transform/check_unsafety.rs
@@ -488,7 +488,7 @@
}
}
-pub(crate) fn provide(providers: &mut Providers<'_>) {
+pub(crate) fn provide(providers: &mut Providers) {
*providers = Providers { unsafety_check_result, unsafe_derive_on_repr_packed, ..*providers };
}
diff --git a/src/librustc_mir/transform/instrument_coverage.rs b/src/librustc_mir/transform/instrument_coverage.rs
index 25e154f..76904b7 100644
--- a/src/librustc_mir/transform/instrument_coverage.rs
+++ b/src/librustc_mir/transform/instrument_coverage.rs
@@ -25,7 +25,7 @@
/// The `query` provider for `CoverageInfo`, requested by `codegen_intrinsic_call()` when
/// constructing the arguments for `llvm.instrprof.increment`.
-pub(crate) fn provide(providers: &mut Providers<'_>) {
+pub(crate) fn provide(providers: &mut Providers) {
providers.coverageinfo = |tcx, def_id| coverageinfo_from_mir(tcx, def_id);
}
diff --git a/src/librustc_mir/transform/mod.rs b/src/librustc_mir/transform/mod.rs
index 14c3093..816cf08 100644
--- a/src/librustc_mir/transform/mod.rs
+++ b/src/librustc_mir/transform/mod.rs
@@ -43,7 +43,7 @@
pub mod unreachable_prop;
pub mod validate;
-pub(crate) fn provide(providers: &mut Providers<'_>) {
+pub(crate) fn provide(providers: &mut Providers) {
self::check_unsafety::provide(providers);
*providers = Providers {
mir_keys,
diff --git a/src/librustc_mir/transform/qualify_min_const_fn.rs b/src/librustc_mir/transform/qualify_min_const_fn.rs
index 2f52570..7041e2d 100644
--- a/src/librustc_mir/transform/qualify_min_const_fn.rs
+++ b/src/librustc_mir/transform/qualify_min_const_fn.rs
@@ -191,8 +191,17 @@
_,
_,
) => Err((span, "function pointer casts are not allowed in const fn".into())),
- Rvalue::Cast(CastKind::Pointer(PointerCast::Unsize), _, _) => {
- Err((span, "unsizing casts are not allowed in const fn".into()))
+ Rvalue::Cast(CastKind::Pointer(PointerCast::Unsize), op, cast_ty) => {
+ let pointee_ty = cast_ty.builtin_deref(true).unwrap().ty;
+ let unsized_ty = tcx.struct_tail_erasing_lifetimes(pointee_ty, tcx.param_env(def_id));
+ if let ty::Slice(_) | ty::Str = unsized_ty.kind {
+ check_operand(tcx, op, span, def_id, body)?;
+ // Casting/coercing things to slices is fine.
+ Ok(())
+ } else {
+ // We just can't allow trait objects until we have figured out trait method calls.
+ Err((span, "unsizing casts are not allowed in const fn".into()))
+ }
}
// binops are fine on integers
Rvalue::BinaryOp(_, lhs, rhs) | Rvalue::CheckedBinaryOp(_, lhs, rhs) => {
diff --git a/src/librustc_mir_build/lib.rs b/src/librustc_mir_build/lib.rs
index b44d8ee..be495e4 100644
--- a/src/librustc_mir_build/lib.rs
+++ b/src/librustc_mir_build/lib.rs
@@ -23,7 +23,7 @@
use rustc_middle::ty::query::Providers;
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
providers.check_match = hair::pattern::check_match;
providers.lit_to_const = hair::constant::lit_to_const;
providers.mir_built = build::mir_built;
diff --git a/src/librustc_parse/parser/diagnostics.rs b/src/librustc_parse/parser/diagnostics.rs
index 7822c09..3244b35 100644
--- a/src/librustc_parse/parser/diagnostics.rs
+++ b/src/librustc_parse/parser/diagnostics.rs
@@ -346,13 +346,16 @@
if allow_unstable {
// Give extra information about type ascription only if it's a nightly compiler.
err.note(
- "`#![feature(type_ascription)]` lets you annotate an expression with a \
- type: `<expr>: <type>`",
+ "`#![feature(type_ascription)]` lets you annotate an expression with a type: \
+ `<expr>: <type>`",
);
- err.note(
- "see issue #23416 <https://github.com/rust-lang/rust/issues/23416> \
- for more information",
- );
+ if !likely_path {
+ // Avoid giving too much info when it was likely an unrelated typo.
+ err.note(
+ "see issue #23416 <https://github.com/rust-lang/rust/issues/23416> \
+ for more information",
+ );
+ }
}
}
}
@@ -1161,8 +1164,10 @@
} &&
!self.token.is_reserved_ident() && // v `foo:bar(baz)`
self.look_ahead(1, |t| t == &token::OpenDelim(token::Paren))
- || self.look_ahead(1, |t| t == &token::Lt) && // `foo:bar<baz`
- self.look_ahead(2, |t| t.is_ident())
+ || self.look_ahead(1, |t| t == &token::OpenDelim(token::Brace)) // `foo:bar {`
+ || self.look_ahead(1, |t| t == &token::Colon) && // `foo:bar::<baz`
+ self.look_ahead(2, |t| t == &token::Lt) &&
+ self.look_ahead(3, |t| t.is_ident())
|| self.look_ahead(1, |t| t == &token::Colon) && // `foo:bar:baz`
self.look_ahead(2, |t| t.is_ident())
|| self.look_ahead(1, |t| t == &token::ModSep)
diff --git a/src/librustc_parse/parser/expr.rs b/src/librustc_parse/parser/expr.rs
index abb4449..3926122 100644
--- a/src/librustc_parse/parser/expr.rs
+++ b/src/librustc_parse/parser/expr.rs
@@ -770,10 +770,10 @@
match self.token.uninterpolate().kind {
token::Ident(..) => self.parse_dot_suffix(base, lo),
token::Literal(token::Lit { kind: token::Integer, symbol, suffix }) => {
- Ok(self.parse_tuple_field_access_expr(lo, base, symbol, suffix))
+ Ok(self.parse_tuple_field_access_expr(lo, base, symbol, suffix, None))
}
- token::Literal(token::Lit { kind: token::Float, symbol, .. }) => {
- self.recover_field_access_by_float_lit(lo, base, symbol)
+ token::Literal(token::Lit { kind: token::Float, symbol, suffix }) => {
+ Ok(self.parse_tuple_field_access_expr_float(lo, base, symbol, suffix))
}
_ => {
self.error_unexpected_after_dot();
@@ -788,45 +788,84 @@
self.struct_span_err(self.token.span, &format!("unexpected token: `{}`", actual)).emit();
}
- fn recover_field_access_by_float_lit(
+ // We need and identifier or integer, but the next token is a float.
+ // Break the float into components to extract the identifier or integer.
+ // FIXME: With current `TokenCursor` it's hard to break tokens into more than 2
+ // parts unless those parts are processed immediately. `TokenCursor` should either
+ // support pushing "future tokens" (would be also helpful to `break_and_eat`), or
+ // we should break everything including floats into more basic proc-macro style
+ // tokens in the lexer (probably preferable).
+ fn parse_tuple_field_access_expr_float(
&mut self,
lo: Span,
base: P<Expr>,
- sym: Symbol,
- ) -> PResult<'a, P<Expr>> {
- self.bump();
-
- let fstr = sym.as_str();
- let msg = format!("unexpected token: `{}`", sym);
-
- let mut err = self.struct_span_err(self.prev_token.span, &msg);
- err.span_label(self.prev_token.span, "unexpected token");
-
- if fstr.chars().all(|x| "0123456789.".contains(x)) {
- let float = match fstr.parse::<f64>() {
- Ok(f) => f,
- Err(_) => {
- err.emit();
- return Ok(base);
- }
- };
- let sugg = pprust::to_string(|s| {
- s.popen();
- s.print_expr(&base);
- s.s.word(".");
- s.print_usize(float.trunc() as usize);
- s.pclose();
- s.s.word(".");
- s.s.word(fstr.splitn(2, '.').last().unwrap().to_string())
- });
- err.span_suggestion(
- lo.to(self.prev_token.span),
- "try parenthesizing the first index",
- sugg,
- Applicability::MachineApplicable,
- );
+ float: Symbol,
+ suffix: Option<Symbol>,
+ ) -> P<Expr> {
+ #[derive(Debug)]
+ enum FloatComponent {
+ IdentLike(String),
+ Punct(char),
}
- Err(err)
+ use FloatComponent::*;
+
+ let mut components = Vec::new();
+ let mut ident_like = String::new();
+ for c in float.as_str().chars() {
+ if c == '_' || c.is_ascii_alphanumeric() {
+ ident_like.push(c);
+ } else if matches!(c, '.' | '+' | '-') {
+ if !ident_like.is_empty() {
+ components.push(IdentLike(mem::take(&mut ident_like)));
+ }
+ components.push(Punct(c));
+ } else {
+ panic!("unexpected character in a float token: {:?}", c)
+ }
+ }
+ if !ident_like.is_empty() {
+ components.push(IdentLike(ident_like));
+ }
+
+ // FIXME: Make the span more precise.
+ let span = self.token.span;
+ match &*components {
+ // 1e2
+ [IdentLike(i)] => {
+ self.parse_tuple_field_access_expr(lo, base, Symbol::intern(&i), suffix, None)
+ }
+ // 1.
+ [IdentLike(i), Punct('.')] => {
+ assert!(suffix.is_none());
+ let symbol = Symbol::intern(&i);
+ self.token = Token::new(token::Ident(symbol, false), span);
+ let next_token = Token::new(token::Dot, span);
+ self.parse_tuple_field_access_expr(lo, base, symbol, None, Some(next_token))
+ }
+ // 1.2 | 1.2e3
+ [IdentLike(i1), Punct('.'), IdentLike(i2)] => {
+ let symbol1 = Symbol::intern(&i1);
+ self.token = Token::new(token::Ident(symbol1, false), span);
+ let next_token1 = Token::new(token::Dot, span);
+ let base1 =
+ self.parse_tuple_field_access_expr(lo, base, symbol1, None, Some(next_token1));
+ let symbol2 = Symbol::intern(&i2);
+ let next_token2 = Token::new(token::Ident(symbol2, false), span);
+ self.bump_with(next_token2); // `.`
+ self.parse_tuple_field_access_expr(lo, base1, symbol2, suffix, None)
+ }
+ // 1e+ | 1e- (recovered)
+ [IdentLike(_), Punct('+' | '-')] |
+ // 1e+2 | 1e-2
+ [IdentLike(_), Punct('+' | '-'), IdentLike(_)] |
+ // 1.2e+3 | 1.2e-3
+ [IdentLike(_), Punct('.'), IdentLike(_), Punct('+' | '-'), IdentLike(_)] => {
+ // See the FIXME about `TokenCursor` above.
+ self.error_unexpected_after_dot();
+ base
+ }
+ _ => panic!("unexpected components in a float token: {:?}", components),
+ }
}
fn parse_tuple_field_access_expr(
@@ -835,8 +874,12 @@
base: P<Expr>,
field: Symbol,
suffix: Option<Symbol>,
+ next_token: Option<Token>,
) -> P<Expr> {
- self.bump();
+ match next_token {
+ Some(next_token) => self.bump_with(next_token),
+ None => self.bump(),
+ }
let span = self.prev_token.span;
let field = ExprKind::Field(base, Ident::new(field, span));
self.expect_no_suffix(span, "a tuple index", suffix);
@@ -1790,7 +1833,7 @@
let require_comma = classify::expr_requires_semi_to_be_stmt(&expr)
&& self.token != token::CloseDelim(token::Brace);
- let hi = self.token.span;
+ let hi = self.prev_token.span;
if require_comma {
let sm = self.sess.source_map();
diff --git a/src/librustc_parse_format/tests.rs b/src/librustc_parse_format/tests.rs
index 9932c1d..9fd0497 100644
--- a/src/librustc_parse_format/tests.rs
+++ b/src/librustc_parse_format/tests.rs
@@ -144,8 +144,8 @@
}
#[test]
fn format_counts() {
- use rustc_span::{edition, Globals, GLOBALS};
- GLOBALS.set(&Globals::new(edition::DEFAULT_EDITION), || {
+ use rustc_span::{edition, SessionGlobals, SESSION_GLOBALS};
+ SESSION_GLOBALS.set(&SessionGlobals::new(edition::DEFAULT_EDITION), || {
same(
"{:10x}",
&[NextArgument(Argument {
diff --git a/src/librustc_passes/check_attr.rs b/src/librustc_passes/check_attr.rs
index ef84f25..46aa5a4 100644
--- a/src/librustc_passes/check_attr.rs
+++ b/src/librustc_passes/check_attr.rs
@@ -292,6 +292,8 @@
| sym::u32
| sym::i64
| sym::u64
+ | sym::i128
+ | sym::u128
| sym::isize
| sym::usize => {
int_reprs += 1;
@@ -469,6 +471,6 @@
.visit_item_likes_in_module(module_def_id, &mut CheckAttrVisitor { tcx }.as_deep_visitor());
}
-pub(crate) fn provide(providers: &mut Providers<'_>) {
+pub(crate) fn provide(providers: &mut Providers) {
*providers = Providers { check_mod_attrs, ..*providers };
}
diff --git a/src/librustc_passes/check_const.rs b/src/librustc_passes/check_const.rs
index 7387545..b1ebab3 100644
--- a/src/librustc_passes/check_const.rs
+++ b/src/librustc_passes/check_const.rs
@@ -62,7 +62,7 @@
tcx.hir().visit_item_likes_in_module(module_def_id, &mut vis.as_deep_visitor());
}
-pub(crate) fn provide(providers: &mut Providers<'_>) {
+pub(crate) fn provide(providers: &mut Providers) {
*providers = Providers { check_mod_const_bodies, ..*providers };
}
diff --git a/src/librustc_passes/diagnostic_items.rs b/src/librustc_passes/diagnostic_items.rs
index d91f495..3cce4b8 100644
--- a/src/librustc_passes/diagnostic_items.rs
+++ b/src/librustc_passes/diagnostic_items.rs
@@ -118,7 +118,7 @@
collector
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
providers.diagnostic_items = |tcx, id| {
assert_eq!(id, LOCAL_CRATE);
collect(tcx)
diff --git a/src/librustc_passes/entry.rs b/src/librustc_passes/entry.rs
index e0ad0ac..1161210 100644
--- a/src/librustc_passes/entry.rs
+++ b/src/librustc_passes/entry.rs
@@ -217,6 +217,6 @@
tcx.entry_fn(LOCAL_CRATE)
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
*providers = Providers { entry_fn, ..*providers };
}
diff --git a/src/librustc_passes/intrinsicck.rs b/src/librustc_passes/intrinsicck.rs
index e4f4885..25edfad 100644
--- a/src/librustc_passes/intrinsicck.rs
+++ b/src/librustc_passes/intrinsicck.rs
@@ -18,7 +18,7 @@
tcx.hir().visit_item_likes_in_module(module_def_id, &mut ItemVisitor { tcx }.as_deep_visitor());
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
*providers = Providers { check_mod_intrinsics, ..*providers };
}
diff --git a/src/librustc_passes/lang_items.rs b/src/librustc_passes/lang_items.rs
index 0326591..8096971 100644
--- a/src/librustc_passes/lang_items.rs
+++ b/src/librustc_passes/lang_items.rs
@@ -205,7 +205,7 @@
items
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
providers.get_lang_items = |tcx, id| {
assert_eq!(id, LOCAL_CRATE);
collect(tcx)
diff --git a/src/librustc_passes/lib.rs b/src/librustc_passes/lib.rs
index 5109d8d..3f10c418 100644
--- a/src/librustc_passes/lib.rs
+++ b/src/librustc_passes/lib.rs
@@ -37,7 +37,7 @@
mod upvars;
mod weak_lang_items;
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
check_attr::provide(providers);
check_const::provide(providers);
diagnostic_items::provide(providers);
diff --git a/src/librustc_passes/lib_features.rs b/src/librustc_passes/lib_features.rs
index 31c7ba2..922a475 100644
--- a/src/librustc_passes/lib_features.rs
+++ b/src/librustc_passes/lib_features.rs
@@ -135,7 +135,7 @@
collector.lib_features
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
providers.get_lib_features = |tcx, id| {
assert_eq!(id, LOCAL_CRATE);
collect(tcx)
diff --git a/src/librustc_passes/liveness.rs b/src/librustc_passes/liveness.rs
index b288a41..3675a98 100644
--- a/src/librustc_passes/liveness.rs
+++ b/src/librustc_passes/liveness.rs
@@ -179,7 +179,7 @@
);
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
*providers = Providers { check_mod_liveness, ..*providers };
}
diff --git a/src/librustc_passes/loops.rs b/src/librustc_passes/loops.rs
index d7012d4..9b4da71 100644
--- a/src/librustc_passes/loops.rs
+++ b/src/librustc_passes/loops.rs
@@ -36,7 +36,7 @@
);
}
-pub(crate) fn provide(providers: &mut Providers<'_>) {
+pub(crate) fn provide(providers: &mut Providers) {
*providers = Providers { check_mod_loops, ..*providers };
}
diff --git a/src/librustc_passes/reachable.rs b/src/librustc_passes/reachable.rs
index 50fcefa..c46f485 100644
--- a/src/librustc_passes/reachable.rs
+++ b/src/librustc_passes/reachable.rs
@@ -425,6 +425,6 @@
tcx.arena.alloc(reachable_context.reachable_symbols)
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
*providers = Providers { reachable_set, ..*providers };
}
diff --git a/src/librustc_passes/region.rs b/src/librustc_passes/region.rs
index a6fa677..b2a8965 100644
--- a/src/librustc_passes/region.rs
+++ b/src/librustc_passes/region.rs
@@ -842,6 +842,6 @@
tcx.arena.alloc(scope_tree)
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
*providers = Providers { region_scope_tree, ..*providers };
}
diff --git a/src/librustc_passes/stability.rs b/src/librustc_passes/stability.rs
index 2e1775c..5bacab6 100644
--- a/src/librustc_passes/stability.rs
+++ b/src/librustc_passes/stability.rs
@@ -476,7 +476,7 @@
tcx.hir().visit_item_likes_in_module(module_def_id, &mut Checker { tcx }.as_deep_visitor());
}
-pub(crate) fn provide(providers: &mut Providers<'_>) {
+pub(crate) fn provide(providers: &mut Providers) {
*providers = Providers { check_mod_unstable_api_usage, ..*providers };
providers.stability_index = |tcx, cnum| {
assert_eq!(cnum, LOCAL_CRATE);
diff --git a/src/librustc_passes/upvars.rs b/src/librustc_passes/upvars.rs
index 99b4ef9..3aed494 100644
--- a/src/librustc_passes/upvars.rs
+++ b/src/librustc_passes/upvars.rs
@@ -9,7 +9,7 @@
use rustc_middle::ty::TyCtxt;
use rustc_span::Span;
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
providers.upvars_mentioned = |tcx, def_id| {
if !tcx.is_closure(def_id) {
return None;
diff --git a/src/librustc_passes/weak_lang_items.rs b/src/librustc_passes/weak_lang_items.rs
index f2f07b5..12925af 100644
--- a/src/librustc_passes/weak_lang_items.rs
+++ b/src/librustc_passes/weak_lang_items.rs
@@ -7,7 +7,7 @@
use rustc_hir::lang_items;
use rustc_hir::lang_items::ITEM_REFS;
use rustc_hir::weak_lang_items::WEAK_ITEMS_REFS;
-use rustc_middle::middle::lang_items::whitelisted;
+use rustc_middle::middle::lang_items::required;
use rustc_middle::ty::TyCtxt;
use rustc_session::config::CrateType;
use rustc_span::symbol::sym;
@@ -59,7 +59,7 @@
}
for (name, &item) in WEAK_ITEMS_REFS.iter() {
- if missing.contains(&item) && !whitelisted(tcx, item) && items.require(item).is_err() {
+ if missing.contains(&item) && required(tcx, item) && items.require(item).is_err() {
if item == lang_items::PanicImplLangItem {
tcx.sess.err("`#[panic_handler]` function required, but not found");
} else if item == lang_items::OomLangItem {
diff --git a/src/librustc_plugin_impl/build.rs b/src/librustc_plugin_impl/build.rs
index 34522cf..db23633 100644
--- a/src/librustc_plugin_impl/build.rs
+++ b/src/librustc_plugin_impl/build.rs
@@ -57,6 +57,6 @@
}
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
*providers = Providers { plugin_registrar_fn, ..*providers };
}
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
index de21365..2c5cbed 100644
--- a/src/librustc_privacy/lib.rs
+++ b/src/librustc_privacy/lib.rs
@@ -2029,7 +2029,7 @@
}
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
*providers = Providers {
privacy_access_levels,
check_private_in_public,
diff --git a/src/librustc_resolve/diagnostics.rs b/src/librustc_resolve/diagnostics.rs
index c64c617..5618907 100644
--- a/src/librustc_resolve/diagnostics.rs
+++ b/src/librustc_resolve/diagnostics.rs
@@ -898,44 +898,42 @@
suggestion: Option<TypoSuggestion>,
span: Span,
) -> bool {
- if let Some(suggestion) = suggestion {
+ let suggestion = match suggestion {
+ None => return false,
// We shouldn't suggest underscore.
- if suggestion.candidate == kw::Underscore {
- return false;
- }
-
- let msg = format!(
- "{} {} with a similar name exists",
- suggestion.res.article(),
- suggestion.res.descr()
- );
- err.span_suggestion(
- span,
- &msg,
- suggestion.candidate.to_string(),
- Applicability::MaybeIncorrect,
- );
- let def_span = suggestion.res.opt_def_id().and_then(|def_id| match def_id.krate {
- LOCAL_CRATE => self.opt_span(def_id),
- _ => Some(
- self.session
- .source_map()
- .guess_head_span(self.cstore().get_span_untracked(def_id, self.session)),
+ Some(suggestion) if suggestion.candidate == kw::Underscore => return false,
+ Some(suggestion) => suggestion,
+ };
+ let msg = format!(
+ "{} {} with a similar name exists",
+ suggestion.res.article(),
+ suggestion.res.descr()
+ );
+ err.span_suggestion(
+ span,
+ &msg,
+ suggestion.candidate.to_string(),
+ Applicability::MaybeIncorrect,
+ );
+ let def_span = suggestion.res.opt_def_id().and_then(|def_id| match def_id.krate {
+ LOCAL_CRATE => self.opt_span(def_id),
+ _ => Some(
+ self.session
+ .source_map()
+ .guess_head_span(self.cstore().get_span_untracked(def_id, self.session)),
+ ),
+ });
+ if let Some(span) = def_span {
+ err.span_label(
+ self.session.source_map().guess_head_span(span),
+ &format!(
+ "similarly named {} `{}` defined here",
+ suggestion.res.descr(),
+ suggestion.candidate.as_str(),
),
- });
- if let Some(span) = def_span {
- err.span_label(
- self.session.source_map().guess_head_span(span),
- &format!(
- "similarly named {} `{}` defined here",
- suggestion.res.descr(),
- suggestion.candidate.as_str(),
- ),
- );
- }
- return true;
+ );
}
- false
+ true
}
fn binding_description(&self, b: &NameBinding<'_>, ident: Ident, from_prelude: bool) -> String {
diff --git a/src/librustc_resolve/imports.rs b/src/librustc_resolve/imports.rs
index ded0ee8..4595a96 100644
--- a/src/librustc_resolve/imports.rs
+++ b/src/librustc_resolve/imports.rs
@@ -262,8 +262,8 @@
}
let check_usable = |this: &mut Self, binding: &'a NameBinding<'a>| {
- if let Some(blacklisted_binding) = this.blacklisted_binding {
- if ptr::eq(binding, blacklisted_binding) {
+ if let Some(unusable_binding) = this.unusable_binding {
+ if ptr::eq(binding, unusable_binding) {
return Err((Determined, Weak::No));
}
}
@@ -278,12 +278,12 @@
return resolution
.binding
.and_then(|binding| {
- // If the primary binding is blacklisted, search further and return the shadowed
- // glob binding if it exists. What we really want here is having two separate
- // scopes in a module - one for non-globs and one for globs, but until that's done
- // use this hack to avoid inconsistent resolution ICEs during import validation.
- if let Some(blacklisted_binding) = self.blacklisted_binding {
- if ptr::eq(binding, blacklisted_binding) {
+ // If the primary binding is unusable, search further and return the shadowed glob
+ // binding if it exists. What we really want here is having two separate scopes in
+ // a module - one for non-globs and one for globs, but until that's done use this
+ // hack to avoid inconsistent resolution ICEs during import validation.
+ if let Some(unusable_binding) = self.unusable_binding {
+ if ptr::eq(binding, unusable_binding) {
return resolution.shadowed_glob;
}
}
@@ -875,9 +875,9 @@
/// consolidate multiple unresolved import errors into a single diagnostic.
fn finalize_import(&mut self, import: &'b Import<'b>) -> Option<UnresolvedImportError> {
let orig_vis = import.vis.replace(ty::Visibility::Invisible);
- let orig_blacklisted_binding = match &import.kind {
+ let orig_unusable_binding = match &import.kind {
ImportKind::Single { target_bindings, .. } => {
- Some(mem::replace(&mut self.r.blacklisted_binding, target_bindings[TypeNS].get()))
+ Some(mem::replace(&mut self.r.unusable_binding, target_bindings[TypeNS].get()))
}
_ => None,
};
@@ -891,8 +891,8 @@
import.crate_lint(),
);
let no_ambiguity = self.r.ambiguity_errors.len() == prev_ambiguity_errors_len;
- if let Some(orig_blacklisted_binding) = orig_blacklisted_binding {
- self.r.blacklisted_binding = orig_blacklisted_binding;
+ if let Some(orig_unusable_binding) = orig_unusable_binding {
+ self.r.unusable_binding = orig_unusable_binding;
}
import.vis.set(orig_vis);
if let PathResult::Failed { .. } | PathResult::NonModule(..) = path_res {
@@ -1013,8 +1013,8 @@
self.r.per_ns(|this, ns| {
if !type_ns_only || ns == TypeNS {
let orig_vis = import.vis.replace(ty::Visibility::Invisible);
- let orig_blacklisted_binding =
- mem::replace(&mut this.blacklisted_binding, target_bindings[ns].get());
+ let orig_unusable_binding =
+ mem::replace(&mut this.unusable_binding, target_bindings[ns].get());
let orig_last_import_segment = mem::replace(&mut this.last_import_segment, true);
let binding = this.resolve_ident_in_module(
module,
@@ -1025,7 +1025,7 @@
import.span,
);
this.last_import_segment = orig_last_import_segment;
- this.blacklisted_binding = orig_blacklisted_binding;
+ this.unusable_binding = orig_unusable_binding;
import.vis.set(orig_vis);
match binding {
@@ -1291,8 +1291,8 @@
return;
}
- let orig_blacklisted_binding =
- mem::replace(&mut this.blacklisted_binding, target_bindings[ns].get());
+ let orig_unusable_binding =
+ mem::replace(&mut this.unusable_binding, target_bindings[ns].get());
match this.early_resolve_ident_in_lexical_scope(
target,
@@ -1311,7 +1311,7 @@
Err(_) => is_redundant[ns] = Some(false),
}
- this.blacklisted_binding = orig_blacklisted_binding;
+ this.unusable_binding = orig_unusable_binding;
}
});
diff --git a/src/librustc_resolve/late.rs b/src/librustc_resolve/late.rs
index 4451791..679f563 100644
--- a/src/librustc_resolve/late.rs
+++ b/src/librustc_resolve/late.rs
@@ -842,14 +842,14 @@
report_error(self, ns);
}
Some(LexicalScopeBinding::Item(binding)) => {
- let orig_blacklisted_binding =
- replace(&mut self.r.blacklisted_binding, Some(binding));
+ let orig_unusable_binding =
+ replace(&mut self.r.unusable_binding, Some(binding));
if let Some(LexicalScopeBinding::Res(..)) = self
.resolve_ident_in_lexical_scope(ident, ns, None, use_tree.prefix.span)
{
report_error(self, ns);
}
- self.r.blacklisted_binding = orig_blacklisted_binding;
+ self.r.unusable_binding = orig_unusable_binding;
}
None => {}
}
diff --git a/src/librustc_resolve/late/lifetimes.rs b/src/librustc_resolve/late/lifetimes.rs
index 903eee6..1467bf5 100644
--- a/src/librustc_resolve/late/lifetimes.rs
+++ b/src/librustc_resolve/late/lifetimes.rs
@@ -278,7 +278,7 @@
const ROOT_SCOPE: ScopeRef<'static> = &Scope::Root;
-pub fn provide(providers: &mut ty::query::Providers<'_>) {
+pub fn provide(providers: &mut ty::query::Providers) {
*providers = ty::query::Providers {
resolve_lifetimes,
@@ -2122,7 +2122,7 @@
self.impl_self
{
match path.res {
- // Whitelist the types that unambiguously always
+ // Permit the types that unambiguously always
// result in the same type constructor being used
// (it can't differ between `Self` and `self`).
Res::Def(DefKind::Struct | DefKind::Union | DefKind::Enum, _)
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index f3a1934..0f16180 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -867,7 +867,7 @@
last_import_segment: bool,
/// This binding should be ignored during in-module resolution, so that we don't get
/// "self-confirming" import resolutions during import validation.
- blacklisted_binding: Option<&'a NameBinding<'a>>,
+ unusable_binding: Option<&'a NameBinding<'a>>,
/// The idents for the primitive types.
primitive_type_table: PrimitiveTypeTable,
@@ -1266,7 +1266,7 @@
indeterminate_imports: Vec::new(),
last_import_segment: false,
- blacklisted_binding: None,
+ unusable_binding: None,
primitive_type_table: PrimitiveTypeTable::new(),
@@ -3102,6 +3102,6 @@
}
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
late::lifetimes::provide(providers);
}
diff --git a/src/librustc_session/lint/builtin.rs b/src/librustc_session/lint/builtin.rs
index 5deee6e..aa2a133 100644
--- a/src/librustc_session/lint/builtin.rs
+++ b/src/librustc_session/lint/builtin.rs
@@ -404,7 +404,7 @@
}
declare_lint! {
- pub INVALID_CODEBLOCK_ATTRIBUTE,
+ pub INVALID_CODEBLOCK_ATTRIBUTES,
Warn,
"codeblock attribute looks a lot like a known one"
}
@@ -602,7 +602,7 @@
UNSTABLE_NAME_COLLISIONS,
IRREFUTABLE_LET_PATTERNS,
INTRA_DOC_LINK_RESOLUTION_FAILURE,
- INVALID_CODEBLOCK_ATTRIBUTE,
+ INVALID_CODEBLOCK_ATTRIBUTES,
MISSING_CRATE_LEVEL_DOCS,
MISSING_DOC_CODE_EXAMPLES,
PRIVATE_DOC_TESTS,
diff --git a/src/librustc_span/hygiene.rs b/src/librustc_span/hygiene.rs
index fef1e34..7249894 100644
--- a/src/librustc_span/hygiene.rs
+++ b/src/librustc_span/hygiene.rs
@@ -27,7 +27,7 @@
use crate::def_id::{DefId, CRATE_DEF_INDEX};
use crate::edition::Edition;
use crate::symbol::{kw, sym, Symbol};
-use crate::GLOBALS;
+use crate::SESSION_GLOBALS;
use crate::{Span, DUMMY_SP};
use rustc_data_structures::fx::FxHashMap;
@@ -174,7 +174,7 @@
}
fn with<T, F: FnOnce(&mut HygieneData) -> T>(f: F) -> T {
- GLOBALS.with(|globals| f(&mut *globals.hygiene_data.borrow_mut()))
+ SESSION_GLOBALS.with(|session_globals| f(&mut *session_globals.hygiene_data.borrow_mut()))
}
fn fresh_expn(&mut self, expn_data: Option<ExpnData>) -> ExpnId {
diff --git a/src/librustc_span/lib.rs b/src/librustc_span/lib.rs
index 0465540..699871f 100644
--- a/src/librustc_span/lib.rs
+++ b/src/librustc_span/lib.rs
@@ -65,16 +65,20 @@
#[cfg(test)]
mod tests;
-pub struct Globals {
+// Per-session global variables: this struct is stored in thread-local storage
+// in such a way that it is accessible without any kind of handle to all
+// threads within the compilation session, but is not accessible outside the
+// session.
+pub struct SessionGlobals {
symbol_interner: Lock<symbol::Interner>,
span_interner: Lock<span_encoding::SpanInterner>,
hygiene_data: Lock<hygiene::HygieneData>,
source_map: Lock<Option<Lrc<SourceMap>>>,
}
-impl Globals {
- pub fn new(edition: Edition) -> Globals {
- Globals {
+impl SessionGlobals {
+ pub fn new(edition: Edition) -> SessionGlobals {
+ SessionGlobals {
symbol_interner: Lock::new(symbol::Interner::fresh()),
span_interner: Lock::new(span_encoding::SpanInterner::default()),
hygiene_data: Lock::new(hygiene::HygieneData::new(edition)),
@@ -83,7 +87,7 @@
}
}
-scoped_tls::scoped_thread_local!(pub static GLOBALS: Globals);
+scoped_tls::scoped_thread_local!(pub static SESSION_GLOBALS: SessionGlobals);
// FIXME: Perhaps this should not implement Rustc{Decodable, Encodable}
//
@@ -713,14 +717,14 @@
/// the `SourceMap` provided to this function. If that is not available,
/// we fall back to printing the raw `Span` field values
pub fn with_source_map<T, F: FnOnce() -> T>(source_map: Lrc<SourceMap>, f: F) -> T {
- GLOBALS.with(|globals| {
- *globals.source_map.borrow_mut() = Some(source_map);
+ SESSION_GLOBALS.with(|session_globals| {
+ *session_globals.source_map.borrow_mut() = Some(source_map);
});
struct ClearSourceMap;
impl Drop for ClearSourceMap {
fn drop(&mut self) {
- GLOBALS.with(|globals| {
- globals.source_map.borrow_mut().take();
+ SESSION_GLOBALS.with(|session_globals| {
+ session_globals.source_map.borrow_mut().take();
});
}
}
@@ -738,8 +742,8 @@
}
pub fn default_span_debug(span: Span, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- GLOBALS.with(|globals| {
- if let Some(source_map) = &*globals.source_map.borrow() {
+ SESSION_GLOBALS.with(|session_globals| {
+ if let Some(source_map) = &*session_globals.source_map.borrow() {
debug_with_source_map(span, f, source_map)
} else {
f.debug_struct("Span")
diff --git a/src/librustc_span/span_encoding.rs b/src/librustc_span/span_encoding.rs
index d769cf8..6b672d3 100644
--- a/src/librustc_span/span_encoding.rs
+++ b/src/librustc_span/span_encoding.rs
@@ -5,7 +5,7 @@
// See https://internals.rust-lang.org/t/rfc-compiler-refactoring-spans/1357/28
use crate::hygiene::SyntaxContext;
-use crate::GLOBALS;
+use crate::SESSION_GLOBALS;
use crate::{BytePos, SpanData};
use rustc_data_structures::fx::FxHashMap;
@@ -136,5 +136,5 @@
// If an interner exists, return it. Otherwise, prepare a fresh one.
#[inline]
fn with_span_interner<T, F: FnOnce(&mut SpanInterner) -> T>(f: F) -> T {
- GLOBALS.with(|globals| f(&mut *globals.span_interner.lock()))
+ SESSION_GLOBALS.with(|session_globals| f(&mut *session_globals.span_interner.lock()))
}
diff --git a/src/librustc_span/symbol.rs b/src/librustc_span/symbol.rs
index 92afb7d..37fb754 100644
--- a/src/librustc_span/symbol.rs
+++ b/src/librustc_span/symbol.rs
@@ -14,7 +14,7 @@
use std::hash::{Hash, Hasher};
use std::str;
-use crate::{Span, DUMMY_SP, GLOBALS};
+use crate::{Span, DUMMY_SP, SESSION_GLOBALS};
#[cfg(test)]
mod tests;
@@ -1387,7 +1387,7 @@
#[inline]
fn with_interner<T, F: FnOnce(&mut Interner) -> T>(f: F) -> T {
- GLOBALS.with(|globals| f(&mut *globals.symbol_interner.lock()))
+ SESSION_GLOBALS.with(|session_globals| f(&mut *session_globals.symbol_interner.lock()))
}
/// An alternative to `Symbol`, useful when the chars within the symbol need to
diff --git a/src/librustc_span/symbol/tests.rs b/src/librustc_span/symbol/tests.rs
index f74b9a0..47da034 100644
--- a/src/librustc_span/symbol/tests.rs
+++ b/src/librustc_span/symbol/tests.rs
@@ -1,6 +1,6 @@
use super::*;
-use crate::{edition, Globals};
+use crate::{edition, SessionGlobals};
#[test]
fn interner_tests() {
@@ -18,7 +18,7 @@
#[test]
fn without_first_quote_test() {
- GLOBALS.set(&Globals::new(edition::DEFAULT_EDITION), || {
+ SESSION_GLOBALS.set(&SessionGlobals::new(edition::DEFAULT_EDITION), || {
let i = Ident::from_str("'break");
assert_eq!(i.without_first_quote().name, kw::Break);
});
diff --git a/src/librustc_symbol_mangling/lib.rs b/src/librustc_symbol_mangling/lib.rs
index 5a1c649..0123210 100644
--- a/src/librustc_symbol_mangling/lib.rs
+++ b/src/librustc_symbol_mangling/lib.rs
@@ -126,7 +126,7 @@
compute_symbol_name(tcx, instance, || instantiating_crate)
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
*providers = Providers { symbol_name: symbol_name_provider, ..*providers };
}
diff --git a/src/librustc_target/spec/aarch64_apple_ios.rs b/src/librustc_target/spec/aarch64_apple_ios.rs
index 1447716..21dcec8 100644
--- a/src/librustc_target/spec/aarch64_apple_ios.rs
+++ b/src/librustc_target/spec/aarch64_apple_ios.rs
@@ -18,7 +18,7 @@
features: "+neon,+fp-armv8,+apple-a7".to_string(),
eliminate_frame_pointer: false,
max_atomic_width: Some(128),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
forces_embed_bitcode: true,
// Taken from a clang build on Xcode 11.4.1.
// These arguments are not actually invoked - they just have
diff --git a/src/librustc_target/spec/aarch64_apple_tvos.rs b/src/librustc_target/spec/aarch64_apple_tvos.rs
index 21f660a..2b0cd6c 100644
--- a/src/librustc_target/spec/aarch64_apple_tvos.rs
+++ b/src/librustc_target/spec/aarch64_apple_tvos.rs
@@ -18,7 +18,7 @@
features: "+neon,+fp-armv8,+apple-a7".to_string(),
eliminate_frame_pointer: false,
max_atomic_width: Some(128),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
forces_embed_bitcode: true,
..base
},
diff --git a/src/librustc_target/spec/aarch64_fuchsia.rs b/src/librustc_target/spec/aarch64_fuchsia.rs
index c0d5d57..aabfe45 100644
--- a/src/librustc_target/spec/aarch64_fuchsia.rs
+++ b/src/librustc_target/spec/aarch64_fuchsia.rs
@@ -15,6 +15,6 @@
target_env: String::new(),
target_vendor: String::new(),
linker_flavor: LinkerFlavor::Lld(LldFlavor::Ld),
- options: TargetOptions { abi_blacklist: super::arm_base::abi_blacklist(), ..base },
+ options: TargetOptions { unsupported_abis: super::arm_base::unsupported_abis(), ..base },
})
}
diff --git a/src/librustc_target/spec/aarch64_linux_android.rs b/src/librustc_target/spec/aarch64_linux_android.rs
index 03fd059..e4ecc7a 100644
--- a/src/librustc_target/spec/aarch64_linux_android.rs
+++ b/src/librustc_target/spec/aarch64_linux_android.rs
@@ -20,6 +20,6 @@
target_env: String::new(),
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
- options: TargetOptions { abi_blacklist: super::arm_base::abi_blacklist(), ..base },
+ options: TargetOptions { unsupported_abis: super::arm_base::unsupported_abis(), ..base },
})
}
diff --git a/src/librustc_target/spec/aarch64_unknown_cloudabi.rs b/src/librustc_target/spec/aarch64_unknown_cloudabi.rs
index 7141954..1278b89 100644
--- a/src/librustc_target/spec/aarch64_unknown_cloudabi.rs
+++ b/src/librustc_target/spec/aarch64_unknown_cloudabi.rs
@@ -3,7 +3,7 @@
pub fn target() -> TargetResult {
let mut base = super::cloudabi_base::opts();
base.max_atomic_width = Some(128);
- base.abi_blacklist = super::arm_base::abi_blacklist();
+ base.unsupported_abis = super::arm_base::unsupported_abis();
base.linker = Some("aarch64-unknown-cloudabi-cc".to_string());
Ok(Target {
diff --git a/src/librustc_target/spec/aarch64_unknown_freebsd.rs b/src/librustc_target/spec/aarch64_unknown_freebsd.rs
index 2177b7a..5ae592c 100644
--- a/src/librustc_target/spec/aarch64_unknown_freebsd.rs
+++ b/src/librustc_target/spec/aarch64_unknown_freebsd.rs
@@ -15,6 +15,6 @@
target_env: String::new(),
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
- options: TargetOptions { abi_blacklist: super::arm_base::abi_blacklist(), ..base },
+ options: TargetOptions { unsupported_abis: super::arm_base::unsupported_abis(), ..base },
})
}
diff --git a/src/librustc_target/spec/aarch64_unknown_hermit.rs b/src/librustc_target/spec/aarch64_unknown_hermit.rs
index 7b02060..5f978c0 100644
--- a/src/librustc_target/spec/aarch64_unknown_hermit.rs
+++ b/src/librustc_target/spec/aarch64_unknown_hermit.rs
@@ -3,7 +3,7 @@
pub fn target() -> TargetResult {
let mut base = super::hermit_base::opts();
base.max_atomic_width = Some(128);
- base.abi_blacklist = super::arm_base::abi_blacklist();
+ base.unsupported_abis = super::arm_base::unsupported_abis();
base.linker = Some("aarch64-hermit-gcc".to_string());
Ok(Target {
diff --git a/src/librustc_target/spec/aarch64_unknown_linux_gnu.rs b/src/librustc_target/spec/aarch64_unknown_linux_gnu.rs
index 81f5fc8..0361622 100644
--- a/src/librustc_target/spec/aarch64_unknown_linux_gnu.rs
+++ b/src/librustc_target/spec/aarch64_unknown_linux_gnu.rs
@@ -16,7 +16,7 @@
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions {
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}_mcount".to_string(),
..base
},
diff --git a/src/librustc_target/spec/aarch64_unknown_linux_musl.rs b/src/librustc_target/spec/aarch64_unknown_linux_musl.rs
index 608b9d2..dc613f3 100644
--- a/src/librustc_target/spec/aarch64_unknown_linux_musl.rs
+++ b/src/librustc_target/spec/aarch64_unknown_linux_musl.rs
@@ -16,7 +16,7 @@
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions {
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}_mcount".to_string(),
..base
},
diff --git a/src/librustc_target/spec/aarch64_unknown_netbsd.rs b/src/librustc_target/spec/aarch64_unknown_netbsd.rs
index b06a2a9..8c2f6fc 100644
--- a/src/librustc_target/spec/aarch64_unknown_netbsd.rs
+++ b/src/librustc_target/spec/aarch64_unknown_netbsd.rs
@@ -3,7 +3,7 @@
pub fn target() -> TargetResult {
let mut base = super::netbsd_base::opts();
base.max_atomic_width = Some(128);
- base.abi_blacklist = super::arm_base::abi_blacklist();
+ base.unsupported_abis = super::arm_base::unsupported_abis();
Ok(Target {
llvm_target: "aarch64-unknown-netbsd".to_string(),
diff --git a/src/librustc_target/spec/aarch64_unknown_none.rs b/src/librustc_target/spec/aarch64_unknown_none.rs
index 7177c4e..e012dce 100644
--- a/src/librustc_target/spec/aarch64_unknown_none.rs
+++ b/src/librustc_target/spec/aarch64_unknown_none.rs
@@ -18,7 +18,7 @@
linker_is_gnu: true,
max_atomic_width: Some(128),
panic_strategy: PanicStrategy::Abort,
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
..Default::default()
};
Ok(Target {
diff --git a/src/librustc_target/spec/aarch64_unknown_none_softfloat.rs b/src/librustc_target/spec/aarch64_unknown_none_softfloat.rs
index 986300c..e2aa6e3 100644
--- a/src/librustc_target/spec/aarch64_unknown_none_softfloat.rs
+++ b/src/librustc_target/spec/aarch64_unknown_none_softfloat.rs
@@ -18,7 +18,7 @@
linker_is_gnu: true,
max_atomic_width: Some(128),
panic_strategy: PanicStrategy::Abort,
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
..Default::default()
};
Ok(Target {
diff --git a/src/librustc_target/spec/aarch64_unknown_openbsd.rs b/src/librustc_target/spec/aarch64_unknown_openbsd.rs
index c9cd64c..fd726c7 100644
--- a/src/librustc_target/spec/aarch64_unknown_openbsd.rs
+++ b/src/librustc_target/spec/aarch64_unknown_openbsd.rs
@@ -3,7 +3,7 @@
pub fn target() -> TargetResult {
let mut base = super::openbsd_base::opts();
base.max_atomic_width = Some(128);
- base.abi_blacklist = super::arm_base::abi_blacklist();
+ base.unsupported_abis = super::arm_base::unsupported_abis();
Ok(Target {
llvm_target: "aarch64-unknown-openbsd".to_string(),
diff --git a/src/librustc_target/spec/aarch64_wrs_vxworks.rs b/src/librustc_target/spec/aarch64_wrs_vxworks.rs
index 47b003b..05f5d7d 100644
--- a/src/librustc_target/spec/aarch64_wrs_vxworks.rs
+++ b/src/librustc_target/spec/aarch64_wrs_vxworks.rs
@@ -15,6 +15,6 @@
target_env: "gnu".to_string(),
target_vendor: "wrs".to_string(),
linker_flavor: LinkerFlavor::Gcc,
- options: TargetOptions { abi_blacklist: super::arm_base::abi_blacklist(), ..base },
+ options: TargetOptions { unsupported_abis: super::arm_base::unsupported_abis(), ..base },
})
}
diff --git a/src/librustc_target/spec/arm_base.rs b/src/librustc_target/spec/arm_base.rs
index 77e7bfa..b74d80d 100644
--- a/src/librustc_target/spec/arm_base.rs
+++ b/src/librustc_target/spec/arm_base.rs
@@ -1,6 +1,6 @@
use crate::spec::abi::Abi;
// All the calling conventions trigger an assertion(Unsupported calling convention) in llvm on arm
-pub fn abi_blacklist() -> Vec<Abi> {
+pub fn unsupported_abis() -> Vec<Abi> {
vec![Abi::Stdcall, Abi::Fastcall, Abi::Vectorcall, Abi::Thiscall, Abi::Win64, Abi::SysV64]
}
diff --git a/src/librustc_target/spec/arm_linux_androideabi.rs b/src/librustc_target/spec/arm_linux_androideabi.rs
index 5dc6eac..7109d04 100644
--- a/src/librustc_target/spec/arm_linux_androideabi.rs
+++ b/src/librustc_target/spec/arm_linux_androideabi.rs
@@ -17,6 +17,6 @@
target_env: String::new(),
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
- options: TargetOptions { abi_blacklist: super::arm_base::abi_blacklist(), ..base },
+ options: TargetOptions { unsupported_abis: super::arm_base::unsupported_abis(), ..base },
})
}
diff --git a/src/librustc_target/spec/arm_unknown_linux_gnueabi.rs b/src/librustc_target/spec/arm_unknown_linux_gnueabi.rs
index ead483d..2e3bad8 100644
--- a/src/librustc_target/spec/arm_unknown_linux_gnueabi.rs
+++ b/src/librustc_target/spec/arm_unknown_linux_gnueabi.rs
@@ -17,7 +17,7 @@
options: TargetOptions {
features: "+strict-align,+v6".to_string(),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
diff --git a/src/librustc_target/spec/arm_unknown_linux_gnueabihf.rs b/src/librustc_target/spec/arm_unknown_linux_gnueabihf.rs
index 53d2e9a..f8e357c 100644
--- a/src/librustc_target/spec/arm_unknown_linux_gnueabihf.rs
+++ b/src/librustc_target/spec/arm_unknown_linux_gnueabihf.rs
@@ -17,7 +17,7 @@
options: TargetOptions {
features: "+strict-align,+v6,+vfp2,-d32".to_string(),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
diff --git a/src/librustc_target/spec/arm_unknown_linux_musleabi.rs b/src/librustc_target/spec/arm_unknown_linux_musleabi.rs
index 03d1919..75753af 100644
--- a/src/librustc_target/spec/arm_unknown_linux_musleabi.rs
+++ b/src/librustc_target/spec/arm_unknown_linux_musleabi.rs
@@ -22,7 +22,7 @@
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions {
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}mcount".to_string(),
..base
},
diff --git a/src/librustc_target/spec/arm_unknown_linux_musleabihf.rs b/src/librustc_target/spec/arm_unknown_linux_musleabihf.rs
index bd92f0f..c74c88e 100644
--- a/src/librustc_target/spec/arm_unknown_linux_musleabihf.rs
+++ b/src/librustc_target/spec/arm_unknown_linux_musleabihf.rs
@@ -22,7 +22,7 @@
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions {
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}mcount".to_string(),
..base
},
diff --git a/src/librustc_target/spec/armebv7r_none_eabi.rs b/src/librustc_target/spec/armebv7r_none_eabi.rs
index a1f68f6..e0d1f26 100644
--- a/src/librustc_target/spec/armebv7r_none_eabi.rs
+++ b/src/librustc_target/spec/armebv7r_none_eabi.rs
@@ -22,7 +22,7 @@
relocation_model: RelocModel::Static,
panic_strategy: PanicStrategy::Abort,
max_atomic_width: Some(32),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
emit_debug_gdb_scripts: false,
..Default::default()
},
diff --git a/src/librustc_target/spec/armebv7r_none_eabihf.rs b/src/librustc_target/spec/armebv7r_none_eabihf.rs
index 4d81c21..e2d37d4 100644
--- a/src/librustc_target/spec/armebv7r_none_eabihf.rs
+++ b/src/librustc_target/spec/armebv7r_none_eabihf.rs
@@ -23,7 +23,7 @@
panic_strategy: PanicStrategy::Abort,
features: "+vfp3,-d32,-fp16".to_string(),
max_atomic_width: Some(32),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
emit_debug_gdb_scripts: false,
..Default::default()
},
diff --git a/src/librustc_target/spec/armv4t_unknown_linux_gnueabi.rs b/src/librustc_target/spec/armv4t_unknown_linux_gnueabi.rs
index 60f822a..2580e8b 100644
--- a/src/librustc_target/spec/armv4t_unknown_linux_gnueabi.rs
+++ b/src/librustc_target/spec/armv4t_unknown_linux_gnueabi.rs
@@ -18,7 +18,7 @@
features: "+soft-float,+strict-align".to_string(),
// Atomic operations provided by compiler-builtins
max_atomic_width: Some(32),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
diff --git a/src/librustc_target/spec/armv5te_unknown_linux_gnueabi.rs b/src/librustc_target/spec/armv5te_unknown_linux_gnueabi.rs
index 9fa0f60..f28421d 100644
--- a/src/librustc_target/spec/armv5te_unknown_linux_gnueabi.rs
+++ b/src/librustc_target/spec/armv5te_unknown_linux_gnueabi.rs
@@ -18,7 +18,7 @@
features: "+soft-float,+strict-align".to_string(),
// Atomic operations provided by compiler-builtins
max_atomic_width: Some(32),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
diff --git a/src/librustc_target/spec/armv5te_unknown_linux_musleabi.rs b/src/librustc_target/spec/armv5te_unknown_linux_musleabi.rs
index bb19eb4..fe1fa88 100644
--- a/src/librustc_target/spec/armv5te_unknown_linux_musleabi.rs
+++ b/src/librustc_target/spec/armv5te_unknown_linux_musleabi.rs
@@ -21,7 +21,7 @@
features: "+soft-float,+strict-align".to_string(),
// Atomic operations provided by compiler-builtins
max_atomic_width: Some(32),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}mcount".to_string(),
..base
},
diff --git a/src/librustc_target/spec/armv6_unknown_freebsd.rs b/src/librustc_target/spec/armv6_unknown_freebsd.rs
index bbab1c6..1e06f83 100644
--- a/src/librustc_target/spec/armv6_unknown_freebsd.rs
+++ b/src/librustc_target/spec/armv6_unknown_freebsd.rs
@@ -17,7 +17,7 @@
options: TargetOptions {
features: "+v6,+vfp2,-d32".to_string(),
max_atomic_width: Some(64),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
diff --git a/src/librustc_target/spec/armv6_unknown_netbsd_eabihf.rs b/src/librustc_target/spec/armv6_unknown_netbsd_eabihf.rs
index 4332d14..ef40085 100644
--- a/src/librustc_target/spec/armv6_unknown_netbsd_eabihf.rs
+++ b/src/librustc_target/spec/armv6_unknown_netbsd_eabihf.rs
@@ -17,7 +17,7 @@
options: TargetOptions {
features: "+v6,+vfp2,-d32".to_string(),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "__mcount".to_string(),
..base
},
diff --git a/src/librustc_target/spec/armv7_apple_ios.rs b/src/librustc_target/spec/armv7_apple_ios.rs
index c0c2ae9..3938435 100644
--- a/src/librustc_target/spec/armv7_apple_ios.rs
+++ b/src/librustc_target/spec/armv7_apple_ios.rs
@@ -17,7 +17,7 @@
options: TargetOptions {
features: "+v7,+vfp3,+neon".to_string(),
max_atomic_width: Some(64),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
..base
},
})
diff --git a/src/librustc_target/spec/armv7_linux_androideabi.rs b/src/librustc_target/spec/armv7_linux_androideabi.rs
index 38d8541..38c6c31 100644
--- a/src/librustc_target/spec/armv7_linux_androideabi.rs
+++ b/src/librustc_target/spec/armv7_linux_androideabi.rs
@@ -25,6 +25,6 @@
target_env: String::new(),
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
- options: TargetOptions { abi_blacklist: super::arm_base::abi_blacklist(), ..base },
+ options: TargetOptions { unsupported_abis: super::arm_base::unsupported_abis(), ..base },
})
}
diff --git a/src/librustc_target/spec/armv7_unknown_cloudabi_eabihf.rs b/src/librustc_target/spec/armv7_unknown_cloudabi_eabihf.rs
index 7d34f5c..e3f4fe0 100644
--- a/src/librustc_target/spec/armv7_unknown_cloudabi_eabihf.rs
+++ b/src/librustc_target/spec/armv7_unknown_cloudabi_eabihf.rs
@@ -5,7 +5,7 @@
base.cpu = "cortex-a8".to_string();
base.max_atomic_width = Some(64);
base.features = "+v7,+vfp3,+neon".to_string();
- base.abi_blacklist = super::arm_base::abi_blacklist();
+ base.unsupported_abis = super::arm_base::unsupported_abis();
base.linker = Some("armv7-unknown-cloudabi-eabihf-cc".to_string());
Ok(Target {
diff --git a/src/librustc_target/spec/armv7_unknown_freebsd.rs b/src/librustc_target/spec/armv7_unknown_freebsd.rs
index e747ddc..80a9e6d 100644
--- a/src/librustc_target/spec/armv7_unknown_freebsd.rs
+++ b/src/librustc_target/spec/armv7_unknown_freebsd.rs
@@ -17,7 +17,7 @@
options: TargetOptions {
features: "+v7,+vfp3,-d32,+thumb2,-neon".to_string(),
max_atomic_width: Some(64),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
diff --git a/src/librustc_target/spec/armv7_unknown_linux_gnueabi.rs b/src/librustc_target/spec/armv7_unknown_linux_gnueabi.rs
index c887bdf..0f175e9 100644
--- a/src/librustc_target/spec/armv7_unknown_linux_gnueabi.rs
+++ b/src/librustc_target/spec/armv7_unknown_linux_gnueabi.rs
@@ -21,7 +21,7 @@
features: "+v7,+thumb2,+soft-float,-neon".to_string(),
cpu: "generic".to_string(),
max_atomic_width: Some(64),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
diff --git a/src/librustc_target/spec/armv7_unknown_linux_gnueabihf.rs b/src/librustc_target/spec/armv7_unknown_linux_gnueabihf.rs
index 4ebc341..2792345 100644
--- a/src/librustc_target/spec/armv7_unknown_linux_gnueabihf.rs
+++ b/src/librustc_target/spec/armv7_unknown_linux_gnueabihf.rs
@@ -22,7 +22,7 @@
features: "+v7,+vfp3,-d32,+thumb2,-neon".to_string(),
cpu: "generic".to_string(),
max_atomic_width: Some(64),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}__gnu_mcount_nc".to_string(),
..base
},
diff --git a/src/librustc_target/spec/armv7_unknown_linux_musleabi.rs b/src/librustc_target/spec/armv7_unknown_linux_musleabi.rs
index bee3e26..3d1bf05 100644
--- a/src/librustc_target/spec/armv7_unknown_linux_musleabi.rs
+++ b/src/librustc_target/spec/armv7_unknown_linux_musleabi.rs
@@ -26,7 +26,7 @@
features: "+v7,+thumb2,+soft-float,-neon".to_string(),
cpu: "generic".to_string(),
max_atomic_width: Some(64),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}mcount".to_string(),
..base
},
diff --git a/src/librustc_target/spec/armv7_unknown_linux_musleabihf.rs b/src/librustc_target/spec/armv7_unknown_linux_musleabihf.rs
index c3cfeca..03d7d88 100644
--- a/src/librustc_target/spec/armv7_unknown_linux_musleabihf.rs
+++ b/src/librustc_target/spec/armv7_unknown_linux_musleabihf.rs
@@ -25,7 +25,7 @@
features: "+v7,+vfp3,-d32,+thumb2,-neon".to_string(),
cpu: "generic".to_string(),
max_atomic_width: Some(64),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}mcount".to_string(),
..base
},
diff --git a/src/librustc_target/spec/armv7_unknown_netbsd_eabihf.rs b/src/librustc_target/spec/armv7_unknown_netbsd_eabihf.rs
index 9d382fe..18fc9ed 100644
--- a/src/librustc_target/spec/armv7_unknown_netbsd_eabihf.rs
+++ b/src/librustc_target/spec/armv7_unknown_netbsd_eabihf.rs
@@ -18,7 +18,7 @@
features: "+v7,+vfp3,-d32,+thumb2,-neon".to_string(),
cpu: "generic".to_string(),
max_atomic_width: Some(64),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "__mcount".to_string(),
..base
},
diff --git a/src/librustc_target/spec/armv7_wrs_vxworks_eabihf.rs b/src/librustc_target/spec/armv7_wrs_vxworks_eabihf.rs
index 34eb04e..04d8702 100644
--- a/src/librustc_target/spec/armv7_wrs_vxworks_eabihf.rs
+++ b/src/librustc_target/spec/armv7_wrs_vxworks_eabihf.rs
@@ -18,7 +18,7 @@
features: "+v7,+vfp3,-d32,+thumb2,-neon".to_string(),
cpu: "generic".to_string(),
max_atomic_width: Some(64),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
..base
},
})
diff --git a/src/librustc_target/spec/armv7a_none_eabi.rs b/src/librustc_target/spec/armv7a_none_eabi.rs
index 09f1494..1db279d 100644
--- a/src/librustc_target/spec/armv7a_none_eabi.rs
+++ b/src/librustc_target/spec/armv7a_none_eabi.rs
@@ -28,7 +28,7 @@
disable_redzone: true,
max_atomic_width: Some(64),
panic_strategy: PanicStrategy::Abort,
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
emit_debug_gdb_scripts: false,
..Default::default()
};
diff --git a/src/librustc_target/spec/armv7a_none_eabihf.rs b/src/librustc_target/spec/armv7a_none_eabihf.rs
index 653ca76..22c2b30 100644
--- a/src/librustc_target/spec/armv7a_none_eabihf.rs
+++ b/src/librustc_target/spec/armv7a_none_eabihf.rs
@@ -16,7 +16,7 @@
disable_redzone: true,
max_atomic_width: Some(64),
panic_strategy: PanicStrategy::Abort,
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
emit_debug_gdb_scripts: false,
..Default::default()
};
diff --git a/src/librustc_target/spec/armv7r_none_eabi.rs b/src/librustc_target/spec/armv7r_none_eabi.rs
index 29dfa17..fed8399 100644
--- a/src/librustc_target/spec/armv7r_none_eabi.rs
+++ b/src/librustc_target/spec/armv7r_none_eabi.rs
@@ -22,7 +22,7 @@
relocation_model: RelocModel::Static,
panic_strategy: PanicStrategy::Abort,
max_atomic_width: Some(32),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
emit_debug_gdb_scripts: false,
..Default::default()
},
diff --git a/src/librustc_target/spec/armv7r_none_eabihf.rs b/src/librustc_target/spec/armv7r_none_eabihf.rs
index e6b0187..769ac13 100644
--- a/src/librustc_target/spec/armv7r_none_eabihf.rs
+++ b/src/librustc_target/spec/armv7r_none_eabihf.rs
@@ -23,7 +23,7 @@
panic_strategy: PanicStrategy::Abort,
features: "+vfp3,-d32,-fp16".to_string(),
max_atomic_width: Some(32),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
emit_debug_gdb_scripts: false,
..Default::default()
},
diff --git a/src/librustc_target/spec/armv7s_apple_ios.rs b/src/librustc_target/spec/armv7s_apple_ios.rs
index 6a5654f..998a7b2 100644
--- a/src/librustc_target/spec/armv7s_apple_ios.rs
+++ b/src/librustc_target/spec/armv7s_apple_ios.rs
@@ -17,7 +17,7 @@
options: TargetOptions {
features: "+v7,+vfp4,+neon".to_string(),
max_atomic_width: Some(64),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
..base
},
})
diff --git a/src/librustc_target/spec/mod.rs b/src/librustc_target/spec/mod.rs
index 29250f2..4a2dd89 100644
--- a/src/librustc_target/spec/mod.rs
+++ b/src/librustc_target/spec/mod.rs
@@ -902,9 +902,10 @@
/// Panic strategy: "unwind" or "abort"
pub panic_strategy: PanicStrategy,
- /// A blacklist of ABIs unsupported by the current target. Note that generic
- /// ABIs are considered to be supported on all platforms and cannot be blacklisted.
- pub abi_blacklist: Vec<Abi>,
+ /// A list of ABIs unsupported by the current target. Note that generic ABIs
+ /// are considered to be supported on all platforms and cannot be marked
+ /// unsupported.
+ pub unsupported_abis: Vec<Abi>,
/// Whether or not linking dylibs to a static CRT is allowed.
pub crt_static_allows_dylibs: bool,
@@ -1056,7 +1057,7 @@
max_atomic_width: None,
atomic_cas: true,
panic_strategy: PanicStrategy::Unwind,
- abi_blacklist: vec![],
+ unsupported_abis: vec![],
crt_static_allows_dylibs: false,
crt_static_default: false,
crt_static_respected: false,
@@ -1125,7 +1126,7 @@
}
pub fn is_abi_supported(&self, abi: Abi) -> bool {
- abi.generic() || !self.options.abi_blacklist.contains(&abi)
+ abi.generic() || !self.options.unsupported_abis.contains(&abi)
}
/// Loads a target descriptor from a JSON object.
@@ -1474,22 +1475,29 @@
key!(llvm_args, list);
key!(use_ctors_section, bool);
- if let Some(array) = obj.find("abi-blacklist").and_then(Json::as_array) {
- for name in array.iter().filter_map(|abi| abi.as_string()) {
- match lookup_abi(name) {
- Some(abi) => {
- if abi.generic() {
+ // NB: The old name is deprecated, but support for it is retained for
+ // compatibility.
+ for name in ["abi-blacklist", "unsupported-abis"].iter() {
+ if let Some(array) = obj.find(name).and_then(Json::as_array) {
+ for name in array.iter().filter_map(|abi| abi.as_string()) {
+ match lookup_abi(name) {
+ Some(abi) => {
+ if abi.generic() {
+ return Err(format!(
+ "The ABI \"{}\" is considered to be supported on all \
+ targets and cannot be marked unsupported",
+ abi
+ ));
+ }
+
+ base.options.unsupported_abis.push(abi)
+ }
+ None => {
return Err(format!(
- "The ABI \"{}\" is considered to be supported on \
- all targets and cannot be blacklisted",
- abi
+ "Unknown ABI \"{}\" in target specification",
+ name
));
}
-
- base.options.abi_blacklist.push(abi)
- }
- None => {
- return Err(format!("Unknown ABI \"{}\" in target specification", name));
}
}
}
@@ -1705,11 +1713,11 @@
target_option_val!(llvm_args);
target_option_val!(use_ctors_section);
- if default.abi_blacklist != self.options.abi_blacklist {
+ if default.unsupported_abis != self.options.unsupported_abis {
d.insert(
- "abi-blacklist".to_string(),
+ "unsupported-abis".to_string(),
self.options
- .abi_blacklist
+ .unsupported_abis
.iter()
.map(|&name| Abi::name(name).to_json())
.collect::<Vec<_>>()
diff --git a/src/librustc_target/spec/nvptx64_nvidia_cuda.rs b/src/librustc_target/spec/nvptx64_nvidia_cuda.rs
index e0a4025..0c8f2a3 100644
--- a/src/librustc_target/spec/nvptx64_nvidia_cuda.rs
+++ b/src/librustc_target/spec/nvptx64_nvidia_cuda.rs
@@ -55,7 +55,7 @@
// FIXME: enable compilation tests for the target and
// create the tests for this.
- abi_blacklist: vec![
+ unsupported_abis: vec![
Abi::Cdecl,
Abi::Stdcall,
Abi::Fastcall,
diff --git a/src/librustc_target/spec/riscv32i_unknown_none_elf.rs b/src/librustc_target/spec/riscv32i_unknown_none_elf.rs
index d7b3e7e..977aa89 100644
--- a/src/librustc_target/spec/riscv32i_unknown_none_elf.rs
+++ b/src/librustc_target/spec/riscv32i_unknown_none_elf.rs
@@ -24,7 +24,7 @@
panic_strategy: PanicStrategy::Abort,
relocation_model: RelocModel::Static,
emit_debug_gdb_scripts: false,
- abi_blacklist: super::riscv_base::abi_blacklist(),
+ unsupported_abis: super::riscv_base::unsupported_abis(),
..Default::default()
},
})
diff --git a/src/librustc_target/spec/riscv32imac_unknown_none_elf.rs b/src/librustc_target/spec/riscv32imac_unknown_none_elf.rs
index b93b6fc..1a85cdf 100644
--- a/src/librustc_target/spec/riscv32imac_unknown_none_elf.rs
+++ b/src/librustc_target/spec/riscv32imac_unknown_none_elf.rs
@@ -24,7 +24,7 @@
panic_strategy: PanicStrategy::Abort,
relocation_model: RelocModel::Static,
emit_debug_gdb_scripts: false,
- abi_blacklist: super::riscv_base::abi_blacklist(),
+ unsupported_abis: super::riscv_base::unsupported_abis(),
..Default::default()
},
})
diff --git a/src/librustc_target/spec/riscv32imc_unknown_none_elf.rs b/src/librustc_target/spec/riscv32imc_unknown_none_elf.rs
index a16e7e3..e3c1c69 100644
--- a/src/librustc_target/spec/riscv32imc_unknown_none_elf.rs
+++ b/src/librustc_target/spec/riscv32imc_unknown_none_elf.rs
@@ -24,7 +24,7 @@
panic_strategy: PanicStrategy::Abort,
relocation_model: RelocModel::Static,
emit_debug_gdb_scripts: false,
- abi_blacklist: super::riscv_base::abi_blacklist(),
+ unsupported_abis: super::riscv_base::unsupported_abis(),
..Default::default()
},
})
diff --git a/src/librustc_target/spec/riscv64gc_unknown_linux_gnu.rs b/src/librustc_target/spec/riscv64gc_unknown_linux_gnu.rs
index 715449d..f7a93c9 100644
--- a/src/librustc_target/spec/riscv64gc_unknown_linux_gnu.rs
+++ b/src/librustc_target/spec/riscv64gc_unknown_linux_gnu.rs
@@ -13,7 +13,7 @@
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
options: TargetOptions {
- abi_blacklist: super::riscv_base::abi_blacklist(),
+ unsupported_abis: super::riscv_base::unsupported_abis(),
code_model: Some(CodeModel::Medium),
cpu: "generic-rv64".to_string(),
features: "+m,+a,+f,+d,+c".to_string(),
diff --git a/src/librustc_target/spec/riscv64gc_unknown_none_elf.rs b/src/librustc_target/spec/riscv64gc_unknown_none_elf.rs
index e5147a1..857af4c 100644
--- a/src/librustc_target/spec/riscv64gc_unknown_none_elf.rs
+++ b/src/librustc_target/spec/riscv64gc_unknown_none_elf.rs
@@ -25,7 +25,7 @@
relocation_model: RelocModel::Static,
code_model: Some(CodeModel::Medium),
emit_debug_gdb_scripts: false,
- abi_blacklist: super::riscv_base::abi_blacklist(),
+ unsupported_abis: super::riscv_base::unsupported_abis(),
..Default::default()
},
})
diff --git a/src/librustc_target/spec/riscv64imac_unknown_none_elf.rs b/src/librustc_target/spec/riscv64imac_unknown_none_elf.rs
index dc056b5..36fe773 100644
--- a/src/librustc_target/spec/riscv64imac_unknown_none_elf.rs
+++ b/src/librustc_target/spec/riscv64imac_unknown_none_elf.rs
@@ -25,7 +25,7 @@
relocation_model: RelocModel::Static,
code_model: Some(CodeModel::Medium),
emit_debug_gdb_scripts: false,
- abi_blacklist: super::riscv_base::abi_blacklist(),
+ unsupported_abis: super::riscv_base::unsupported_abis(),
..Default::default()
},
})
diff --git a/src/librustc_target/spec/riscv_base.rs b/src/librustc_target/spec/riscv_base.rs
index ec1dc9b..64cf890 100644
--- a/src/librustc_target/spec/riscv_base.rs
+++ b/src/librustc_target/spec/riscv_base.rs
@@ -2,7 +2,7 @@
// All the calling conventions trigger an assertion(Unsupported calling
// convention) in llvm on RISCV
-pub fn abi_blacklist() -> Vec<Abi> {
+pub fn unsupported_abis() -> Vec<Abi> {
vec![
Abi::Cdecl,
Abi::Stdcall,
diff --git a/src/librustc_target/spec/tests/tests_impl.rs b/src/librustc_target/spec/tests/tests_impl.rs
index b2ad62e..b2c2b82 100644
--- a/src/librustc_target/spec/tests/tests_impl.rs
+++ b/src/librustc_target/spec/tests/tests_impl.rs
@@ -16,8 +16,8 @@
impl Target {
fn check_consistency(&self) {
// Check that LLD with the given flavor is treated identically to the linker it emulates.
- // If you target really needs to deviate from the rules below, whitelist it
- // and document the reasons.
+ // If your target really needs to deviate from the rules below, except it and document the
+ // reasons.
assert_eq!(
self.linker_flavor == LinkerFlavor::Msvc
|| self.linker_flavor == LinkerFlavor::Lld(LldFlavor::Link),
diff --git a/src/librustc_target/spec/thumb_base.rs b/src/librustc_target/spec/thumb_base.rs
index 646a149..2f7d15d 100644
--- a/src/librustc_target/spec/thumb_base.rs
+++ b/src/librustc_target/spec/thumb_base.rs
@@ -41,7 +41,7 @@
// Similarly, one almost always never wants to use relocatable code because of the extra
// costs it involves.
relocation_model: RelocModel::Static,
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
// When this section is added a volatile load to its start address is also generated. This
// volatile load is a footgun as it can end up loading an invalid memory address, depending
// on how the user set up their linker scripts. This section adds pretty printer for stuff
diff --git a/src/librustc_target/spec/thumbv7a_pc_windows_msvc.rs b/src/librustc_target/spec/thumbv7a_pc_windows_msvc.rs
index 21d62d2..3782802 100644
--- a/src/librustc_target/spec/thumbv7a_pc_windows_msvc.rs
+++ b/src/librustc_target/spec/thumbv7a_pc_windows_msvc.rs
@@ -37,7 +37,7 @@
features: "+vfp3,+neon".to_string(),
cpu: "generic".to_string(),
max_atomic_width: Some(64),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
..base
},
})
diff --git a/src/librustc_target/spec/thumbv7a_uwp_windows_msvc.rs b/src/librustc_target/spec/thumbv7a_uwp_windows_msvc.rs
index ff2e892..29a4a98 100644
--- a/src/librustc_target/spec/thumbv7a_uwp_windows_msvc.rs
+++ b/src/librustc_target/spec/thumbv7a_uwp_windows_msvc.rs
@@ -23,7 +23,7 @@
options: TargetOptions {
features: "+vfp3,+neon".to_string(),
cpu: "generic".to_string(),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
..base
},
})
diff --git a/src/librustc_target/spec/thumbv7neon_linux_androideabi.rs b/src/librustc_target/spec/thumbv7neon_linux_androideabi.rs
index 02ad9ab..c52f077 100644
--- a/src/librustc_target/spec/thumbv7neon_linux_androideabi.rs
+++ b/src/librustc_target/spec/thumbv7neon_linux_androideabi.rs
@@ -25,6 +25,6 @@
target_env: "".to_string(),
target_vendor: "unknown".to_string(),
linker_flavor: LinkerFlavor::Gcc,
- options: TargetOptions { abi_blacklist: super::arm_base::abi_blacklist(), ..base },
+ options: TargetOptions { unsupported_abis: super::arm_base::unsupported_abis(), ..base },
})
}
diff --git a/src/librustc_target/spec/thumbv7neon_unknown_linux_gnueabihf.rs b/src/librustc_target/spec/thumbv7neon_unknown_linux_gnueabihf.rs
index 04e0514..7893694 100644
--- a/src/librustc_target/spec/thumbv7neon_unknown_linux_gnueabihf.rs
+++ b/src/librustc_target/spec/thumbv7neon_unknown_linux_gnueabihf.rs
@@ -25,7 +25,7 @@
features: "+v7,+thumb-mode,+thumb2,+vfp3,+neon".to_string(),
cpu: "generic".to_string(),
max_atomic_width: Some(64),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
..base
},
})
diff --git a/src/librustc_target/spec/thumbv7neon_unknown_linux_musleabihf.rs b/src/librustc_target/spec/thumbv7neon_unknown_linux_musleabihf.rs
index 3d39a40..f759c3e 100644
--- a/src/librustc_target/spec/thumbv7neon_unknown_linux_musleabihf.rs
+++ b/src/librustc_target/spec/thumbv7neon_unknown_linux_musleabihf.rs
@@ -29,7 +29,7 @@
features: "+v7,+thumb-mode,+thumb2,+vfp3,+neon".to_string(),
cpu: "generic".to_string(),
max_atomic_width: Some(64),
- abi_blacklist: super::arm_base::abi_blacklist(),
+ unsupported_abis: super::arm_base::unsupported_abis(),
target_mcount: "\u{1}mcount".to_string(),
..base
},
diff --git a/src/librustc_target/spec/wasm32_base.rs b/src/librustc_target/spec/wasm32_base.rs
index d4a65aa..8423573 100644
--- a/src/librustc_target/spec/wasm32_base.rs
+++ b/src/librustc_target/spec/wasm32_base.rs
@@ -40,14 +40,14 @@
// corrupting static data.
arg("--stack-first");
- // FIXME we probably shouldn't pass this but instead pass an explicit
- // whitelist of symbols we'll allow to be undefined. We don't currently have
- // a mechanism of knowing, however, which symbols are intended to be
- // imported from the environment and which are intended to be imported from
- // other objects linked elsewhere. This is a coarse approximation but is
- // sure to hide some bugs and frustrate someone at some point, so we should
- // ideally work towards a world where we can explicitly list symbols that
- // are supposed to be imported and have all other symbols generate errors if
+ // FIXME we probably shouldn't pass this but instead pass an explicit list
+ // of symbols we'll allow to be undefined. We don't currently have a
+ // mechanism of knowing, however, which symbols are intended to be imported
+ // from the environment and which are intended to be imported from other
+ // objects linked elsewhere. This is a coarse approximation but is sure to
+ // hide some bugs and frustrate someone at some point, so we should ideally
+ // work towards a world where we can explicitly list symbols that are
+ // supposed to be imported and have all other symbols generate errors if
// they remain undefined.
arg("--allow-undefined");
diff --git a/src/librustc_trait_selection/traits/error_reporting/suggestions.rs b/src/librustc_trait_selection/traits/error_reporting/suggestions.rs
index cdfe5f9..d677d84 100644
--- a/src/librustc_trait_selection/traits/error_reporting/suggestions.rs
+++ b/src/librustc_trait_selection/traits/error_reporting/suggestions.rs
@@ -2139,7 +2139,7 @@
impl NextTypeParamName for &[hir::GenericParam<'_>] {
fn next_type_param_name(&self, name: Option<&str>) -> String {
- // This is the whitelist of possible parameter names that we might suggest.
+ // This is the list of possible parameter names that we might suggest.
let name = name.and_then(|n| n.chars().next()).map(|c| c.to_string().to_uppercase());
let name = name.as_deref();
let possible_names = [name.unwrap_or("T"), "T", "U", "V", "X", "Y", "Z", "A", "B", "C"];
diff --git a/src/librustc_trait_selection/traits/mod.rs b/src/librustc_trait_selection/traits/mod.rs
index 78c50a1..e800612 100644
--- a/src/librustc_trait_selection/traits/mod.rs
+++ b/src/librustc_trait_selection/traits/mod.rs
@@ -550,7 +550,7 @@
tcx.infer_ctxt().enter(|infcx| infcx.predicate_must_hold_modulo_regions(&obligation))
}
-pub fn provide(providers: &mut ty::query::Providers<'_>) {
+pub fn provide(providers: &mut ty::query::Providers) {
object_safety::provide(providers);
structural_match::provide(providers);
*providers = ty::query::Providers {
diff --git a/src/librustc_trait_selection/traits/object_safety.rs b/src/librustc_trait_selection/traits/object_safety.rs
index 63714c2..f00d668 100644
--- a/src/librustc_trait_selection/traits/object_safety.rs
+++ b/src/librustc_trait_selection/traits/object_safety.rs
@@ -792,6 +792,6 @@
})
}
-pub fn provide(providers: &mut ty::query::Providers<'_>) {
+pub fn provide(providers: &mut ty::query::Providers) {
*providers = ty::query::Providers { object_safety_violations, ..*providers };
}
diff --git a/src/librustc_trait_selection/traits/structural_match.rs b/src/librustc_trait_selection/traits/structural_match.rs
index 201edf2..377d163 100644
--- a/src/librustc_trait_selection/traits/structural_match.rs
+++ b/src/librustc_trait_selection/traits/structural_match.rs
@@ -271,7 +271,7 @@
}
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
providers.has_structural_eq_impls = |tcx, ty| {
tcx.infer_ctxt().enter(|infcx| {
let cause = ObligationCause::dummy();
diff --git a/src/librustc_traits/chalk/mod.rs b/src/librustc_traits/chalk/mod.rs
index 52ec0f2..0c5d575 100644
--- a/src/librustc_traits/chalk/mod.rs
+++ b/src/librustc_traits/chalk/mod.rs
@@ -29,7 +29,7 @@
use chalk_solve::Solution;
-crate fn provide(p: &mut Providers<'_>) {
+crate fn provide(p: &mut Providers) {
*p = Providers { evaluate_goal, ..*p };
}
diff --git a/src/librustc_traits/dropck_outlives.rs b/src/librustc_traits/dropck_outlives.rs
index 6339f82..ce00060 100644
--- a/src/librustc_traits/dropck_outlives.rs
+++ b/src/librustc_traits/dropck_outlives.rs
@@ -17,7 +17,7 @@
Normalized, ObligationCause, TraitEngine, TraitEngineExt as _,
};
-crate fn provide(p: &mut Providers<'_>) {
+crate fn provide(p: &mut Providers) {
*p = Providers { dropck_outlives, adt_dtorck_constraint, ..*p };
}
diff --git a/src/librustc_traits/evaluate_obligation.rs b/src/librustc_traits/evaluate_obligation.rs
index e6afc15..2404b7f 100644
--- a/src/librustc_traits/evaluate_obligation.rs
+++ b/src/librustc_traits/evaluate_obligation.rs
@@ -7,7 +7,7 @@
EvaluationResult, Obligation, ObligationCause, OverflowError, SelectionContext, TraitQueryMode,
};
-crate fn provide(p: &mut Providers<'_>) {
+crate fn provide(p: &mut Providers) {
*p = Providers { evaluate_obligation, ..*p };
}
diff --git a/src/librustc_traits/implied_outlives_bounds.rs b/src/librustc_traits/implied_outlives_bounds.rs
index 651596d..bda3da1 100644
--- a/src/librustc_traits/implied_outlives_bounds.rs
+++ b/src/librustc_traits/implied_outlives_bounds.rs
@@ -18,7 +18,7 @@
use rustc_trait_selection::traits::TraitEngine;
use smallvec::{smallvec, SmallVec};
-crate fn provide(p: &mut Providers<'_>) {
+crate fn provide(p: &mut Providers) {
*p = Providers { implied_outlives_bounds, ..*p };
}
diff --git a/src/librustc_traits/lib.rs b/src/librustc_traits/lib.rs
index f3dfdff..b8e2376 100644
--- a/src/librustc_traits/lib.rs
+++ b/src/librustc_traits/lib.rs
@@ -22,7 +22,7 @@
use rustc_middle::ty::query::Providers;
-pub fn provide(p: &mut Providers<'_>) {
+pub fn provide(p: &mut Providers) {
dropck_outlives::provide(p);
evaluate_obligation::provide(p);
implied_outlives_bounds::provide(p);
diff --git a/src/librustc_traits/normalize_erasing_regions.rs b/src/librustc_traits/normalize_erasing_regions.rs
index fcb7514..7092515 100644
--- a/src/librustc_traits/normalize_erasing_regions.rs
+++ b/src/librustc_traits/normalize_erasing_regions.rs
@@ -7,7 +7,7 @@
use rustc_trait_selection::traits::{Normalized, ObligationCause};
use std::sync::atomic::Ordering;
-crate fn provide(p: &mut Providers<'_>) {
+crate fn provide(p: &mut Providers) {
*p = Providers { normalize_generic_arg_after_erasing_regions, ..*p };
}
diff --git a/src/librustc_traits/normalize_projection_ty.rs b/src/librustc_traits/normalize_projection_ty.rs
index d6d3e86..a8e3768 100644
--- a/src/librustc_traits/normalize_projection_ty.rs
+++ b/src/librustc_traits/normalize_projection_ty.rs
@@ -10,7 +10,7 @@
use rustc_trait_selection::traits::{self, ObligationCause, SelectionContext};
use std::sync::atomic::Ordering;
-crate fn provide(p: &mut Providers<'_>) {
+crate fn provide(p: &mut Providers) {
*p = Providers { normalize_projection_ty, ..*p };
}
diff --git a/src/librustc_traits/type_op.rs b/src/librustc_traits/type_op.rs
index 374ef3f..9cc9a35 100644
--- a/src/librustc_traits/type_op.rs
+++ b/src/librustc_traits/type_op.rs
@@ -21,7 +21,7 @@
use rustc_trait_selection::traits::{Normalized, Obligation, ObligationCause, TraitEngine};
use std::fmt;
-crate fn provide(p: &mut Providers<'_>) {
+crate fn provide(p: &mut Providers) {
*p = Providers {
type_op_ascribe_user_type,
type_op_eq,
diff --git a/src/librustc_ty/common_traits.rs b/src/librustc_ty/common_traits.rs
index 265b811..8d153e7 100644
--- a/src/librustc_ty/common_traits.rs
+++ b/src/librustc_ty/common_traits.rs
@@ -36,6 +36,6 @@
})
}
-pub(crate) fn provide(providers: &mut ty::query::Providers<'_>) {
+pub(crate) fn provide(providers: &mut ty::query::Providers) {
*providers = ty::query::Providers { is_copy_raw, is_sized_raw, is_freeze_raw, ..*providers };
}
diff --git a/src/librustc_ty/instance.rs b/src/librustc_ty/instance.rs
index de4cdbb..9f5ab7f 100644
--- a/src/librustc_ty/instance.rs
+++ b/src/librustc_ty/instance.rs
@@ -243,6 +243,6 @@
})
}
-pub fn provide(providers: &mut ty::query::Providers<'_>) {
+pub fn provide(providers: &mut ty::query::Providers) {
*providers = ty::query::Providers { resolve_instance, ..*providers };
}
diff --git a/src/librustc_ty/lib.rs b/src/librustc_ty/lib.rs
index 75e62e7..8f3b20c 100644
--- a/src/librustc_ty/lib.rs
+++ b/src/librustc_ty/lib.rs
@@ -21,7 +21,7 @@
mod needs_drop;
mod ty;
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
common_traits::provide(providers);
needs_drop::provide(providers);
ty::provide(providers);
diff --git a/src/librustc_ty/needs_drop.rs b/src/librustc_ty/needs_drop.rs
index 7880c09..c4af952 100644
--- a/src/librustc_ty/needs_drop.rs
+++ b/src/librustc_ty/needs_drop.rs
@@ -183,6 +183,6 @@
res.map(|components| tcx.intern_type_list(&components))
}
-pub(crate) fn provide(providers: &mut ty::query::Providers<'_>) {
+pub(crate) fn provide(providers: &mut ty::query::Providers) {
*providers = ty::query::Providers { needs_drop_raw, adt_drop_tys, ..*providers };
}
diff --git a/src/librustc_ty/ty.rs b/src/librustc_ty/ty.rs
index 595992d..c99bc8a 100644
--- a/src/librustc_ty/ty.rs
+++ b/src/librustc_ty/ty.rs
@@ -494,7 +494,7 @@
}
}
-pub fn provide(providers: &mut ty::query::Providers<'_>) {
+pub fn provide(providers: &mut ty::query::Providers) {
*providers = ty::query::Providers {
asyncness,
associated_item,
diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs
index 85c073c..9a9630f 100644
--- a/src/librustc_typeck/check/demand.rs
+++ b/src/librustc_typeck/check/demand.rs
@@ -236,7 +236,7 @@
.tcx
.get_attrs(m.def_id)
.iter()
- // This special internal attribute is used to whitelist
+ // This special internal attribute is used to permit
// "identity-like" conversion methods to be suggested here.
//
// FIXME (#46459 and #46460): ideally
diff --git a/src/librustc_typeck/check/expr.rs b/src/librustc_typeck/check/expr.rs
index 1eaa5a6..e6b51f4 100644
--- a/src/librustc_typeck/check/expr.rs
+++ b/src/librustc_typeck/check/expr.rs
@@ -913,7 +913,7 @@
if let ty::Adt(..) = rcvr_t.kind {
// Try alternative arbitrary self types that could fulfill this call.
// FIXME: probe for all types that *could* be arbitrary self-types, not
- // just this whitelist.
+ // just this list.
try_alt_rcvr(&mut err, self.tcx.mk_lang_item(rcvr_t, lang_items::OwnedBoxLangItem));
try_alt_rcvr(&mut err, self.tcx.mk_lang_item(rcvr_t, lang_items::PinTypeLangItem));
try_alt_rcvr(&mut err, self.tcx.mk_diagnostic_item(rcvr_t, sym::Arc));
@@ -1806,7 +1806,7 @@
// If this is an input value, we require its type to be fully resolved
// at this point. This allows us to provide helpful coercions which help
- // pass the type whitelist in a later pass.
+ // pass the type candidate list in a later pass.
//
// We don't require output types to be resolved at this point, which
// allows them to be inferred based on how they are used later in the
diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs
index 7bdf137..b1799c6 100644
--- a/src/librustc_typeck/check/method/mod.rs
+++ b/src/librustc_typeck/check/method/mod.rs
@@ -28,7 +28,7 @@
use self::probe::{IsSuggestion, ProbeScope};
-pub fn provide(providers: &mut ty::query::Providers<'_>) {
+pub fn provide(providers: &mut ty::query::Providers) {
suggest::provide(providers);
probe::provide(providers);
}
diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs
index 78bf973..ba952df 100644
--- a/src/librustc_typeck/check/method/probe.rs
+++ b/src/librustc_typeck/check/method/probe.rs
@@ -440,7 +440,7 @@
}
}
-pub fn provide(providers: &mut ty::query::Providers<'_>) {
+pub fn provide(providers: &mut ty::query::Providers) {
providers.method_autoderef_steps = method_autoderef_steps;
}
diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs
index fbf81e9..44ffabc 100644
--- a/src/librustc_typeck/check/method/suggest.rs
+++ b/src/librustc_typeck/check/method/suggest.rs
@@ -1292,7 +1292,7 @@
traits
}
-pub fn provide(providers: &mut ty::query::Providers<'_>) {
+pub fn provide(providers: &mut ty::query::Providers) {
providers.all_traits = |tcx, cnum| {
assert_eq!(cnum, LOCAL_CRATE);
&tcx.arena.alloc(compute_all_traits(tcx))[..]
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index f828ca4..fa7360c 100644
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -760,7 +760,7 @@
wfcheck::check_impl_item(tcx, def_id);
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
method::provide(providers);
*providers = Providers {
typeck_item_bodies,
diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs
index 3b203dd..1483244 100644
--- a/src/librustc_typeck/coherence/mod.rs
+++ b/src/librustc_typeck/coherence/mod.rs
@@ -151,7 +151,7 @@
struct_span_err!(tcx.sess, span, E0715, "impls for marker traits cannot contain items").emit();
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
use self::builtin::coerce_unsized_info;
use self::inherent_impls::{crate_inherent_impls, inherent_impls};
use self::inherent_impls_overlap::crate_inherent_impls_overlap_check;
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
index cc491c5..1548166 100644
--- a/src/librustc_typeck/collect.rs
+++ b/src/librustc_typeck/collect.rs
@@ -62,7 +62,7 @@
);
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
*providers = Providers {
type_of: type_of::type_of,
generics_of,
@@ -2150,7 +2150,7 @@
tcx: TyCtxt<'_>,
id: DefId,
attr: &ast::Attribute,
- whitelist: &FxHashMap<String, Option<Symbol>>,
+ supported_target_features: &FxHashMap<String, Option<Symbol>>,
target_features: &mut Vec<Symbol>,
) {
let list = match attr.meta_item_list() {
@@ -2184,8 +2184,7 @@
// We allow comma separation to enable multiple features.
target_features.extend(value.as_str().split(',').filter_map(|feature| {
- // Only allow whitelisted features per platform.
- let feature_gate = match whitelist.get(feature) {
+ let feature_gate = match supported_target_features.get(feature) {
Some(g) => g,
None => {
let msg =
@@ -2196,7 +2195,7 @@
format!("`{}` is not valid for this target", feature),
);
if feature.starts_with('+') {
- let valid = whitelist.contains_key(&feature[1..]);
+ let valid = supported_target_features.contains_key(&feature[1..]);
if valid {
err.help("consider removing the leading `+` in the feature name");
}
@@ -2246,9 +2245,9 @@
// Use the names from src/llvm/docs/LangRef.rst here. Most types are only
// applicable to variable declarations and may not really make sense for
- // Rust code in the first place but whitelist them anyway and trust that
- // the user knows what s/he's doing. Who knows, unanticipated use cases
- // may pop up in the future.
+ // Rust code in the first place but allow them anyway and trust that the
+ // user knows what s/he's doing. Who knows, unanticipated use cases may pop
+ // up in the future.
//
// ghost, dllimport, dllexport and linkonce_odr_autohide are not supported
// and don't have to be, LLVM treats them as no-ops.
@@ -2283,7 +2282,7 @@
codegen_fn_attrs.flags |= CodegenFnAttrFlags::TRACK_CALLER;
}
- let whitelist = tcx.target_features_whitelist(LOCAL_CRATE);
+ let supported_target_features = tcx.supported_target_features(LOCAL_CRATE);
let mut inline_span = None;
let mut link_ordinal_span = None;
@@ -2386,7 +2385,13 @@
check_target_feature_trait_unsafe(tcx, local_id, attr.span);
}
}
- from_target_feature(tcx, id, attr, &whitelist, &mut codegen_fn_attrs.target_features);
+ from_target_feature(
+ tcx,
+ id,
+ attr,
+ &supported_target_features,
+ &mut codegen_fn_attrs.target_features,
+ );
} else if attr.check_name(sym::linkage) {
if let Some(val) = attr.value_str() {
codegen_fn_attrs.linkage = Some(linkage_by_name(tcx, id, &val.as_str()));
diff --git a/src/librustc_typeck/impl_wf_check.rs b/src/librustc_typeck/impl_wf_check.rs
index 77cd1b3..891e482 100644
--- a/src/librustc_typeck/impl_wf_check.rs
+++ b/src/librustc_typeck/impl_wf_check.rs
@@ -69,7 +69,7 @@
.visit_item_likes_in_module(module_def_id, &mut ImplWfCheck { tcx, min_specialization });
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
*providers = Providers { check_mod_impl_wf, ..*providers };
}
diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs
index 8d8a1b4..9ba2545 100644
--- a/src/librustc_typeck/lib.rs
+++ b/src/librustc_typeck/lib.rs
@@ -309,7 +309,7 @@
}
}
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
collect::provide(providers);
coherence::provide(providers);
check::provide(providers);
diff --git a/src/librustc_typeck/outlives/mod.rs b/src/librustc_typeck/outlives/mod.rs
index 1b2b08a..cc58583 100644
--- a/src/librustc_typeck/outlives/mod.rs
+++ b/src/librustc_typeck/outlives/mod.rs
@@ -13,7 +13,7 @@
pub mod test;
mod utils;
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
*providers = Providers { inferred_outlives_of, inferred_outlives_crate, ..*providers };
}
diff --git a/src/librustc_typeck/variance/mod.rs b/src/librustc_typeck/variance/mod.rs
index 23f4e1f..b307363 100644
--- a/src/librustc_typeck/variance/mod.rs
+++ b/src/librustc_typeck/variance/mod.rs
@@ -26,7 +26,7 @@
/// Code for transforming variances.
mod xform;
-pub fn provide(providers: &mut Providers<'_>) {
+pub fn provide(providers: &mut Providers) {
*providers = Providers { variances_of, crate_variances, ..*providers };
}
diff --git a/src/librustdoc/clean/cfg/tests.rs b/src/librustdoc/clean/cfg/tests.rs
index 7162633..8d1193e 100644
--- a/src/librustdoc/clean/cfg/tests.rs
+++ b/src/librustdoc/clean/cfg/tests.rs
@@ -2,7 +2,7 @@
use rustc_ast::ast::*;
use rustc_ast::attr;
-use rustc_ast::with_default_globals;
+use rustc_ast::with_default_session_globals;
use rustc_span::symbol::{Ident, Symbol};
use rustc_span::DUMMY_SP;
@@ -52,7 +52,7 @@
#[test]
fn test_cfg_not() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
assert_eq!(!Cfg::False, Cfg::True);
assert_eq!(!Cfg::True, Cfg::False);
assert_eq!(!word_cfg("test"), Cfg::Not(Box::new(word_cfg("test"))));
@@ -70,7 +70,7 @@
#[test]
fn test_cfg_and() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let mut x = Cfg::False;
x &= Cfg::True;
assert_eq!(x, Cfg::False);
@@ -154,7 +154,7 @@
#[test]
fn test_cfg_or() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let mut x = Cfg::True;
x |= Cfg::False;
assert_eq!(x, Cfg::True);
@@ -238,7 +238,7 @@
#[test]
fn test_parse_ok() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let mi = dummy_meta_item_word("all");
assert_eq!(Cfg::parse(&mi), Ok(word_cfg("all")));
@@ -271,7 +271,7 @@
#[test]
fn test_parse_err() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
let mi = attr::mk_name_value_item(Ident::from_str("foo"), LitKind::Bool(false), DUMMY_SP);
assert!(Cfg::parse(&mi).is_err());
@@ -303,7 +303,7 @@
#[test]
fn test_render_short_html() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
assert_eq!(word_cfg("unix").render_short_html(), "Unix");
assert_eq!(name_value_cfg("target_os", "macos").render_short_html(), "macOS");
assert_eq!(name_value_cfg("target_pointer_width", "16").render_short_html(), "16-bit");
@@ -358,7 +358,7 @@
#[test]
fn test_render_long_html() {
- with_default_globals(|| {
+ with_default_session_globals(|| {
assert_eq!(
word_cfg("unix").render_long_html(),
"This is supported on <strong>Unix</strong> only."
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 6dec016..34f91bf 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -628,6 +628,7 @@
/// Cache must be populated before call
pub fn links(&self, krate: &CrateNum) -> Vec<(String, String)> {
use crate::html::format::href;
+ use crate::html::render::CURRENT_DEPTH;
self.links
.iter()
@@ -648,12 +649,13 @@
if let Some(ref fragment) = *fragment {
let cache = cache();
let url = match cache.extern_locations.get(krate) {
- Some(&(_, ref src, ExternalLocation::Local)) => {
- src.to_str().expect("invalid file path")
+ Some(&(_, _, ExternalLocation::Local)) => {
+ let depth = CURRENT_DEPTH.with(|l| l.get());
+ "../".repeat(depth)
}
- Some(&(_, _, ExternalLocation::Remote(ref s))) => s,
+ Some(&(_, _, ExternalLocation::Remote(ref s))) => s.to_string(),
Some(&(_, _, ExternalLocation::Unknown)) | None => {
- "https://doc.rust-lang.org/nightly"
+ String::from("https://doc.rust-lang.org/nightly")
}
};
// This is a primitive so the url is done "by hand".
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index 38f202e..a222920 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -214,7 +214,7 @@
/// This function is used to setup the lint initialization. By default, in rustdoc, everything
/// is "allowed". Depending if we run in test mode or not, we want some of them to be at their
-/// default level. For example, the "INVALID_CODEBLOCK_ATTRIBUTE" lint is activated in both
+/// default level. For example, the "INVALID_CODEBLOCK_ATTRIBUTES" lint is activated in both
/// modes.
///
/// A little detail easy to forget is that there is a way to set the lint level for all lints
@@ -225,7 +225,7 @@
/// * Vector of tuples of lints' name and their associated "max" level
/// * HashMap of lint id with their associated "max" level
pub fn init_lints<F>(
- mut whitelisted_lints: Vec<String>,
+ mut allowed_lints: Vec<String>,
lint_opts: Vec<(String, lint::Level)>,
filter_call: F,
) -> (Vec<(String, lint::Level)>, FxHashMap<lint::LintId, lint::Level>)
@@ -234,8 +234,8 @@
{
let warnings_lint_name = lint::builtin::WARNINGS.name;
- whitelisted_lints.push(warnings_lint_name.to_owned());
- whitelisted_lints.extend(lint_opts.iter().map(|(lint, _)| lint).cloned());
+ allowed_lints.push(warnings_lint_name.to_owned());
+ allowed_lints.extend(lint_opts.iter().map(|(lint, _)| lint).cloned());
let lints = || {
lint::builtin::HardwiredLints::get_lints()
@@ -245,7 +245,7 @@
let lint_opts = lints()
.filter_map(|lint| {
- // Whitelist feature-gated lints to avoid feature errors when trying to
+ // Permit feature-gated lints to avoid feature errors when trying to
// allow all lints.
if lint.name == warnings_lint_name || lint.feature_gate.is_some() {
None
@@ -258,9 +258,9 @@
let lint_caps = lints()
.filter_map(|lint| {
- // We don't want to whitelist *all* lints so let's
- // ignore those ones.
- if whitelisted_lints.iter().any(|l| lint.name == l) {
+ // We don't want to allow *all* lints so let's ignore
+ // those ones.
+ if allowed_lints.iter().any(|l| lint.name == l) {
None
} else {
Some((lint::LintId::of(lint), lint::Allow))
@@ -315,11 +315,11 @@
let missing_doc_example = rustc_lint::builtin::MISSING_DOC_CODE_EXAMPLES.name;
let private_doc_tests = rustc_lint::builtin::PRIVATE_DOC_TESTS.name;
let no_crate_level_docs = rustc_lint::builtin::MISSING_CRATE_LEVEL_DOCS.name;
- let invalid_codeblock_attribute_name = rustc_lint::builtin::INVALID_CODEBLOCK_ATTRIBUTE.name;
+ let invalid_codeblock_attribute_name = rustc_lint::builtin::INVALID_CODEBLOCK_ATTRIBUTES.name;
- // In addition to those specific lints, we also need to whitelist those given through
+ // In addition to those specific lints, we also need to allow those given through
// command line, otherwise they'll get ignored and we don't want that.
- let whitelisted_lints = vec![
+ let allowed_lints = vec![
intra_link_resolution_failure_name.to_owned(),
missing_docs.to_owned(),
missing_doc_example.to_owned(),
@@ -328,7 +328,7 @@
invalid_codeblock_attribute_name.to_owned(),
];
- let (lint_opts, lint_caps) = init_lints(whitelisted_lints, lint_opts, |lint| {
+ let (lint_opts, lint_caps) = init_lints(allowed_lints, lint_opts, |lint| {
if lint.name == intra_link_resolution_failure_name
|| lint.name == invalid_codeblock_attribute_name
{
@@ -376,7 +376,7 @@
registry: rustc_driver::diagnostics_registry(),
};
- interface::run_compiler_in_existing_thread_pool(config, |compiler| {
+ interface::create_compiler_and_run(config, |compiler| {
compiler.enter(|queries| {
let sess = compiler.session();
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index 7a66267..a0f8eb0 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -665,7 +665,7 @@
(None, None) => return,
};
self.tcx.struct_span_lint_hir(
- lint::builtin::INVALID_CODEBLOCK_ATTRIBUTE,
+ lint::builtin::INVALID_CODEBLOCK_ATTRIBUTES,
hir_id,
self.sp,
|lint| {
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index 69e3540..8bba21a 100644
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -3151,7 +3151,7 @@
render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
}
-const ATTRIBUTE_WHITELIST: &[Symbol] = &[
+const ALLOWED_ATTRIBUTES: &[Symbol] = &[
sym::export_name,
sym::lang,
sym::link_section,
@@ -3173,7 +3173,7 @@
let mut attrs = String::new();
for attr in &it.attrs.other_attrs {
- if !ATTRIBUTE_WHITELIST.contains(&attr.name_or_empty()) {
+ if !ALLOWED_ATTRIBUTES.contains(&attr.name_or_empty()) {
continue;
}
@@ -4054,6 +4054,10 @@
_ => None,
})
{
+ let deref_mut = v
+ .iter()
+ .filter(|i| i.inner_impl().trait_.is_some())
+ .any(|i| i.inner_impl().trait_.def_id() == c.deref_mut_trait_did);
let inner_impl = target
.def_id()
.or(target
@@ -4074,7 +4078,9 @@
let mut ret = impls
.iter()
.filter(|i| i.inner_impl().trait_.is_none())
- .flat_map(|i| get_methods(i.inner_impl(), true, &mut used_links, true))
+ .flat_map(|i| {
+ get_methods(i.inner_impl(), true, &mut used_links, deref_mut)
+ })
.collect::<Vec<_>>();
// We want links' order to be reproducible so we don't use unstable sort.
ret.sort();
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 8e2dd77..57151e2b 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -437,7 +437,10 @@
Ok(opts) => opts,
Err(code) => return code,
};
- rustc_interface::interface::default_thread_pool(options.edition, move || main_options(options))
+ rustc_interface::interface::setup_callbacks_and_run_in_default_thread_pool_with_globals(
+ options.edition,
+ move || main_options(options),
+ )
}
fn wrap_return(diag: &rustc_errors::Handler, res: Result<(), String>) -> i32 {
@@ -471,7 +474,29 @@
// but we can't crates the Handler ahead of time because it's not Send
let diag_opts = (options.error_format, options.edition, options.debugging_options.clone());
let show_coverage = options.show_coverage;
- rust_input(options, move |out| {
+
+ // First, parse the crate and extract all relevant information.
+ info!("starting to run rustc");
+
+ // Interpret the input file as a rust source file, passing it through the
+ // compiler all the way through the analysis passes. The rustdoc output is
+ // then generated from the cleaned AST of the crate. This runs all the
+ // plug/cleaning passes.
+ let result = rustc_driver::catch_fatal_errors(move || {
+ let crate_name = options.crate_name.clone();
+ let crate_version = options.crate_version.clone();
+ let (mut krate, renderinfo, renderopts) = core::run_core(options);
+
+ info!("finished with rustc");
+
+ if let Some(name) = crate_name {
+ krate.name = name
+ }
+
+ krate.version = crate_version;
+
+ let out = Output { krate, renderinfo, renderopts };
+
if show_coverage {
// if we ran coverage, bail early, we don't need to also generate docs at this point
// (also we didn't load in any of the useful passes)
@@ -491,36 +516,6 @@
rustc_driver::EXIT_FAILURE
}
}
- })
-}
-
-/// Interprets the input file as a rust source file, passing it through the
-/// compiler all the way through the analysis passes. The rustdoc output is then
-/// generated from the cleaned AST of the crate.
-///
-/// This form of input will run all of the plug/cleaning passes
-fn rust_input<R, F>(options: config::Options, f: F) -> R
-where
- R: 'static + Send,
- F: 'static + Send + FnOnce(Output) -> R,
-{
- // First, parse the crate and extract all relevant information.
- info!("starting to run rustc");
-
- let result = rustc_driver::catch_fatal_errors(move || {
- let crate_name = options.crate_name.clone();
- let crate_version = options.crate_version.clone();
- let (mut krate, renderinfo, renderopts) = core::run_core(options);
-
- info!("finished with rustc");
-
- if let Some(name) = crate_name {
- krate.name = name
- }
-
- krate.version = crate_version;
-
- f(Output { krate, renderinfo, renderopts })
});
match result {
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index f1d1bf4..4fcf6ce 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -602,6 +602,9 @@
kind = Some(ValueNS);
disambiguator = Some(&prefix[..prefix.len() - 1]);
link.trim_start_matches(prefix)
+ } else if link.ends_with("!()") {
+ kind = Some(MacroNS);
+ link.trim_end_matches("!()")
} else if link.ends_with("()") {
kind = Some(ValueNS);
disambiguator = Some("fn");
diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs
index e9504aa..c2d644b 100644
--- a/src/librustdoc/test.rs
+++ b/src/librustdoc/test.rs
@@ -1,5 +1,4 @@
use rustc_ast::ast;
-use rustc_ast::with_globals;
use rustc_data_structures::sync::Lrc;
use rustc_errors::ErrorReported;
use rustc_feature::UnstableFeatures;
@@ -46,13 +45,13 @@
pub fn run(options: Options) -> Result<(), String> {
let input = config::Input::File(options.input.clone());
- let invalid_codeblock_attribute_name = rustc_lint::builtin::INVALID_CODEBLOCK_ATTRIBUTE.name;
+ let invalid_codeblock_attribute_name = rustc_lint::builtin::INVALID_CODEBLOCK_ATTRIBUTES.name;
- // In addition to those specific lints, we also need to whitelist those given through
+ // In addition to those specific lints, we also need to allow those given through
// command line, otherwise they'll get ignored and we don't want that.
- let whitelisted_lints = vec![invalid_codeblock_attribute_name.to_owned()];
+ let allowed_lints = vec![invalid_codeblock_attribute_name.to_owned()];
- let (lint_opts, lint_caps) = init_lints(whitelisted_lints, options.lint_opts.clone(), |lint| {
+ let (lint_opts, lint_caps) = init_lints(allowed_lints, options.lint_opts.clone(), |lint| {
if lint.name == invalid_codeblock_attribute_name {
None
} else {
@@ -399,7 +398,7 @@
// Uses librustc_ast to parse the doctest and find if there's a main fn and the extern
// crate already is included.
let result = rustc_driver::catch_fatal_errors(|| {
- with_globals(edition, || {
+ rustc_ast::with_session_globals(edition, || {
use rustc_errors::emitter::EmitterWriter;
use rustc_errors::Handler;
use rustc_parse::maybe_new_parser_from_source_str;
diff --git a/src/libstd/sys/wasi/ext/fs.rs b/src/libstd/sys/wasi/ext/fs.rs
index 6696efa..f41c662 100644
--- a/src/libstd/sys/wasi/ext/fs.rs
+++ b/src/libstd/sys/wasi/ext/fs.rs
@@ -21,11 +21,102 @@
///
/// 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`]: ../../../../std/fs/struct.File.html#method.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.
///
/// [`File::read`]: ../../../../std/fs/struct.File.html#method.read_vectored
- fn read_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize>;
+ 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::read_exact`]: ../../../../std/io/trait.Read.html#method.read_exact
+ /// [`read_at`]: #tymethod.read_at
+ ///
+ /// # Errors
+ ///
+ /// If this function encounters an error of the kind
+ /// [`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 [`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.
+ ///
+ /// [`ErrorKind::Interrupted`]: ../../../../std/io/enum.ErrorKind.html#variant.Interrupted
+ /// [`ErrorKind::UnexpectedEof`]: ../../../../std/io/enum.ErrorKind.html#variant.UnexpectedEof
+ #[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(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`]: ../../../../std/fs/struct.File.html#write.v
+ 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.
///
@@ -43,7 +134,49 @@
/// short write.
///
/// [`File::write`]: ../../../../std/fs/struct.File.html#method.write_vectored
- fn write_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize>;
+ 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-[`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 [`ErrorKind::Interrupted`] kind generated from this method will be
+ /// returned.
+ ///
+ /// # Errors
+ ///
+ /// This function will return the first error of
+ /// non-[`ErrorKind::Interrupted`] kind that [`write_at`] returns.
+ ///
+ /// [`ErrorKind::Interrupted`]: ../../../../std/io/enum.ErrorKind.html#variant.Interrupted
+ /// [`write_at`]: #tymethod.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(
+ 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.
///
@@ -105,11 +238,11 @@
// FIXME: bind random_get maybe? - on crates.io for unix
impl FileExt for fs::File {
- fn read_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
+ fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
self.as_inner().fd().pread(bufs, offset)
}
- fn write_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
+ fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
self.as_inner().fd().pwrite(bufs, offset)
}
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index 84fa35e..9f4fa89 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -241,7 +241,7 @@
// returned instead of what the OS says if the OS goes backwards.
//
// To hopefully mitigate the impact of this, a few platforms are
- // whitelisted as "these at least haven't gone backwards yet".
+ // excluded as "these at least haven't gone backwards yet".
if time::Instant::actually_monotonic() {
return Instant(os_now);
}
diff --git a/src/test/codegen/cfguard_checks.rs b/src/test/codegen/cfguard-checks.rs
similarity index 93%
rename from src/test/codegen/cfguard_checks.rs
rename to src/test/codegen/cfguard-checks.rs
index 96f9158..96a0a32 100644
--- a/src/test/codegen/cfguard_checks.rs
+++ b/src/test/codegen/cfguard-checks.rs
@@ -1,4 +1,5 @@
// compile-flags: -Z control-flow-guard=checks
+// only-msvc
#![crate_type = "lib"]
diff --git a/src/test/codegen/cfguard_disabled.rs b/src/test/codegen/cfguard-disabled.rs
similarity index 93%
rename from src/test/codegen/cfguard_disabled.rs
rename to src/test/codegen/cfguard-disabled.rs
index 1325ffc0..925e4e8 100644
--- a/src/test/codegen/cfguard_disabled.rs
+++ b/src/test/codegen/cfguard-disabled.rs
@@ -1,4 +1,5 @@
// compile-flags: -Z control-flow-guard=no
+// only-msvc
#![crate_type = "lib"]
diff --git a/src/test/codegen/cfguard_nochecks.rs b/src/test/codegen/cfguard-nochecks.rs
similarity index 93%
rename from src/test/codegen/cfguard_nochecks.rs
rename to src/test/codegen/cfguard-nochecks.rs
index ae1de4c..d7dc3d7 100644
--- a/src/test/codegen/cfguard_nochecks.rs
+++ b/src/test/codegen/cfguard-nochecks.rs
@@ -1,4 +1,5 @@
// compile-flags: -Z control-flow-guard=nochecks
+// only-msvc
#![crate_type = "lib"]
diff --git a/src/test/codegen/cfguard-non-msvc.rs b/src/test/codegen/cfguard-non-msvc.rs
new file mode 100644
index 0000000..4008f01
--- /dev/null
+++ b/src/test/codegen/cfguard-non-msvc.rs
@@ -0,0 +1,11 @@
+// compile-flags: -Z control-flow-guard
+// ignore-msvc
+
+#![crate_type = "lib"]
+
+// A basic test function.
+pub fn test() {
+}
+
+// Ensure the cfguard module flag is not added for non-MSVC targets.
+// CHECK-NOT: !"cfguard"
diff --git a/src/test/mir-opt/exponential-or/rustc.match_tuple.SimplifyCfg-initial.after.mir b/src/test/mir-opt/exponential-or/rustc.match_tuple.SimplifyCfg-initial.after.mir
index b84ca5d..00942cd 100644
--- a/src/test/mir-opt/exponential-or/rustc.match_tuple.SimplifyCfg-initial.after.mir
+++ b/src/test/mir-opt/exponential-or/rustc.match_tuple.SimplifyCfg-initial.after.mir
@@ -102,8 +102,8 @@
_0 = BitXor(move _9, move _10); // scope 1 at $DIR/exponential-or.rs:8:83: 8:88
StorageDead(_10); // scope 1 at $DIR/exponential-or.rs:8:87: 8:88
StorageDead(_9); // scope 1 at $DIR/exponential-or.rs:8:87: 8:88
- StorageDead(_8); // scope 0 at $DIR/exponential-or.rs:8:88: 8:89
- StorageDead(_7); // scope 0 at $DIR/exponential-or.rs:8:88: 8:89
+ StorageDead(_8); // scope 0 at $DIR/exponential-or.rs:8:87: 8:88
+ StorageDead(_7); // scope 0 at $DIR/exponential-or.rs:8:87: 8:88
goto -> bb10; // scope 0 at $DIR/exponential-or.rs:7:5: 10:6
}
diff --git a/src/test/mir-opt/issue-73223/32bit/rustc.main.SimplifyArmIdentity.diff b/src/test/mir-opt/issue-73223/32bit/rustc.main.SimplifyArmIdentity.diff
index e5b4a03..1020fc9 100644
--- a/src/test/mir-opt/issue-73223/32bit/rustc.main.SimplifyArmIdentity.diff
+++ b/src/test/mir-opt/issue-73223/32bit/rustc.main.SimplifyArmIdentity.diff
@@ -137,7 +137,7 @@
StorageLive(_4); // scope 0 at $DIR/issue-73223.rs:3:14: 3:15
_4 = ((_2 as Some).0: i32); // scope 0 at $DIR/issue-73223.rs:3:14: 3:15
_1 = _4; // scope 2 at $DIR/issue-73223.rs:3:20: 3:21
- StorageDead(_4); // scope 0 at $DIR/issue-73223.rs:3:21: 3:22
+ StorageDead(_4); // scope 0 at $DIR/issue-73223.rs:3:20: 3:21
StorageDead(_2); // scope 0 at $DIR/issue-73223.rs:5:6: 5:7
StorageLive(_6); // scope 1 at $DIR/issue-73223.rs:7:9: 7:14
StorageLive(_7); // scope 1 at $DIR/issue-73223.rs:7:22: 7:27
diff --git a/src/test/mir-opt/issue-73223/64bit/rustc.main.SimplifyArmIdentity.diff b/src/test/mir-opt/issue-73223/64bit/rustc.main.SimplifyArmIdentity.diff
index 0c2651d..aa606ed 100644
--- a/src/test/mir-opt/issue-73223/64bit/rustc.main.SimplifyArmIdentity.diff
+++ b/src/test/mir-opt/issue-73223/64bit/rustc.main.SimplifyArmIdentity.diff
@@ -137,7 +137,7 @@
StorageLive(_4); // scope 0 at $DIR/issue-73223.rs:3:14: 3:15
_4 = ((_2 as Some).0: i32); // scope 0 at $DIR/issue-73223.rs:3:14: 3:15
_1 = _4; // scope 2 at $DIR/issue-73223.rs:3:20: 3:21
- StorageDead(_4); // scope 0 at $DIR/issue-73223.rs:3:21: 3:22
+ StorageDead(_4); // scope 0 at $DIR/issue-73223.rs:3:20: 3:21
StorageDead(_2); // scope 0 at $DIR/issue-73223.rs:5:6: 5:7
StorageLive(_6); // scope 1 at $DIR/issue-73223.rs:7:9: 7:14
StorageLive(_7); // scope 1 at $DIR/issue-73223.rs:7:22: 7:27
diff --git a/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.ElaborateDrops.after.mir b/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.ElaborateDrops.after.mir
index c6832f2..df6a247 100644
--- a/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.ElaborateDrops.after.mir
+++ b/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.ElaborateDrops.after.mir
@@ -61,7 +61,7 @@
// mir::Constant
// + span: $DIR/match-arm-scopes.rs:16:77: 16:78
// + literal: Const { ty: i32, val: Value(Scalar(0x00000001)) }
- drop(_7) -> [return: bb19, unwind: bb10]; // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ drop(_7) -> [return: bb19, unwind: bb10]; // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
}
bb6: {
@@ -90,9 +90,9 @@
// + span: $DIR/match-arm-scopes.rs:16:59: 16:60
// + literal: Const { ty: i32, val: Value(Scalar(0x00000003)) }
StorageDead(_10); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73
- StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
goto -> bb11; // scope 0 at $DIR/match-arm-scopes.rs:16:52: 16:60
}
@@ -109,7 +109,7 @@
}
bb12: {
- StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
StorageLive(_5); // scope 0 at $DIR/match-arm-scopes.rs:16:17: 16:18
_5 = (_2.1: bool); // scope 0 at $DIR/match-arm-scopes.rs:16:17: 16:18
StorageLive(_7); // scope 0 at $DIR/match-arm-scopes.rs:16:20: 16:21
@@ -118,9 +118,9 @@
}
bb13: {
- StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
goto -> bb2; // scope 0 at $DIR/match-arm-scopes.rs:16:42: 16:73
}
@@ -150,14 +150,14 @@
// + span: $DIR/match-arm-scopes.rs:16:59: 16:60
// + literal: Const { ty: i32, val: Value(Scalar(0x00000003)) }
StorageDead(_13); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73
- StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
goto -> bb11; // scope 0 at $DIR/match-arm-scopes.rs:16:52: 16:60
}
bb17: {
- StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
StorageLive(_5); // scope 0 at $DIR/match-arm-scopes.rs:16:26: 16:27
_5 = (_2.0: bool); // scope 0 at $DIR/match-arm-scopes.rs:16:26: 16:27
StorageLive(_7); // scope 0 at $DIR/match-arm-scopes.rs:16:36: 16:37
@@ -166,17 +166,17 @@
}
bb18: {
- StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
goto -> bb3; // scope 0 at $DIR/match-arm-scopes.rs:16:42: 16:73
}
bb19: {
- StorageDead(_7); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_5); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ StorageDead(_7); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_5); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
goto -> bb23; // scope 0 at $DIR/match-arm-scopes.rs:15:5: 18:6
}
@@ -188,7 +188,7 @@
// mir::Constant
// + span: $DIR/match-arm-scopes.rs:17:41: 17:42
// + literal: Const { ty: i32, val: Value(Scalar(0x00000002)) }
- drop(_16) -> [return: bb22, unwind: bb10]; // scope 0 at $DIR/match-arm-scopes.rs:17:42: 17:43
+ drop(_16) -> [return: bb22, unwind: bb10]; // scope 0 at $DIR/match-arm-scopes.rs:17:41: 17:42
}
bb21: {
@@ -200,8 +200,8 @@
}
bb22: {
- StorageDead(_16); // scope 0 at $DIR/match-arm-scopes.rs:17:42: 17:43
- StorageDead(_15); // scope 0 at $DIR/match-arm-scopes.rs:17:42: 17:43
+ StorageDead(_16); // scope 0 at $DIR/match-arm-scopes.rs:17:41: 17:42
+ StorageDead(_15); // scope 0 at $DIR/match-arm-scopes.rs:17:41: 17:42
goto -> bb23; // scope 0 at $DIR/match-arm-scopes.rs:15:5: 18:6
}
diff --git a/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.SimplifyCfg-initial.after.mir b/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.SimplifyCfg-initial.after.mir
index 45f7e91..dadbc36 100644
--- a/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.SimplifyCfg-initial.after.mir
+++ b/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.SimplifyCfg-initial.after.mir
@@ -74,7 +74,7 @@
// mir::Constant
// + span: $DIR/match-arm-scopes.rs:16:77: 16:78
// + literal: Const { ty: i32, val: Value(Scalar(0x00000001)) }
- drop(_7) -> [return: bb24, unwind: bb14]; // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ drop(_7) -> [return: bb24, unwind: bb14]; // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
}
bb9: {
@@ -110,9 +110,9 @@
// + span: $DIR/match-arm-scopes.rs:16:59: 16:60
// + literal: Const { ty: i32, val: Value(Scalar(0x00000003)) }
StorageDead(_10); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73
- StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
goto -> bb15; // scope 0 at $DIR/match-arm-scopes.rs:16:52: 16:60
}
@@ -129,7 +129,7 @@
}
bb16: {
- StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
FakeRead(ForMatchGuard, _3); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73
FakeRead(ForMatchGuard, _4); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73
FakeRead(ForGuardBinding, _6); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73
@@ -142,9 +142,9 @@
}
bb17: {
- StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
falseEdge -> [real: bb3, imaginary: bb4]; // scope 0 at $DIR/match-arm-scopes.rs:16:42: 16:73
}
@@ -181,14 +181,14 @@
// + span: $DIR/match-arm-scopes.rs:16:59: 16:60
// + literal: Const { ty: i32, val: Value(Scalar(0x00000003)) }
StorageDead(_13); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73
- StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
goto -> bb15; // scope 0 at $DIR/match-arm-scopes.rs:16:52: 16:60
}
bb22: {
- StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
FakeRead(ForMatchGuard, _3); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73
FakeRead(ForMatchGuard, _4); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73
FakeRead(ForGuardBinding, _6); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73
@@ -201,17 +201,17 @@
}
bb23: {
- StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
falseEdge -> [real: bb5, imaginary: bb6]; // scope 0 at $DIR/match-arm-scopes.rs:16:42: 16:73
}
bb24: {
- StorageDead(_7); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_5); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
- StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79
+ StorageDead(_7); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_5); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
+ StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78
goto -> bb28; // scope 0 at $DIR/match-arm-scopes.rs:15:5: 18:6
}
@@ -223,7 +223,7 @@
// mir::Constant
// + span: $DIR/match-arm-scopes.rs:17:41: 17:42
// + literal: Const { ty: i32, val: Value(Scalar(0x00000002)) }
- drop(_16) -> [return: bb27, unwind: bb14]; // scope 0 at $DIR/match-arm-scopes.rs:17:42: 17:43
+ drop(_16) -> [return: bb27, unwind: bb14]; // scope 0 at $DIR/match-arm-scopes.rs:17:41: 17:42
}
bb26: {
@@ -235,8 +235,8 @@
}
bb27: {
- StorageDead(_16); // scope 0 at $DIR/match-arm-scopes.rs:17:42: 17:43
- StorageDead(_15); // scope 0 at $DIR/match-arm-scopes.rs:17:42: 17:43
+ StorageDead(_16); // scope 0 at $DIR/match-arm-scopes.rs:17:41: 17:42
+ StorageDead(_15); // scope 0 at $DIR/match-arm-scopes.rs:17:41: 17:42
goto -> bb28; // scope 0 at $DIR/match-arm-scopes.rs:15:5: 18:6
}
diff --git a/src/test/mir-opt/match_false_edges/rustc.full_tested_match.PromoteTemps.after.mir b/src/test/mir-opt/match_false_edges/rustc.full_tested_match.PromoteTemps.after.mir
index d4a2afe..5ff4150 100644
--- a/src/test/mir-opt/match_false_edges/rustc.full_tested_match.PromoteTemps.after.mir
+++ b/src/test/mir-opt/match_false_edges/rustc.full_tested_match.PromoteTemps.after.mir
@@ -97,7 +97,7 @@
}
bb8: {
- StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:16:37: 16:38
+ StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:16:36: 16:37
FakeRead(ForMatchGuard, _4); // scope 0 at $DIR/match_false_edges.rs:16:26: 16:27
FakeRead(ForGuardBinding, _6); // scope 0 at $DIR/match_false_edges.rs:16:26: 16:27
StorageLive(_5); // scope 0 at $DIR/match_false_edges.rs:16:14: 16:15
@@ -112,14 +112,14 @@
// + span: $DIR/match_false_edges.rs:16:32: 16:33
// + literal: Const { ty: i32, val: Value(Scalar(0x00000001)) }
StorageDead(_8); // scope 2 at $DIR/match_false_edges.rs:16:36: 16:37
- StorageDead(_5); // scope 0 at $DIR/match_false_edges.rs:16:37: 16:38
- StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:16:37: 16:38
+ StorageDead(_5); // scope 0 at $DIR/match_false_edges.rs:16:36: 16:37
+ StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:16:36: 16:37
goto -> bb11; // scope 0 at $DIR/match_false_edges.rs:15:13: 19:6
}
bb9: {
- StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:16:37: 16:38
- StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:16:37: 16:38
+ StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:16:36: 16:37
+ StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:16:36: 16:37
goto -> bb4; // scope 0 at $DIR/match_false_edges.rs:16:20: 16:27
}
@@ -136,7 +136,7 @@
// + span: $DIR/match_false_edges.rs:17:21: 17:22
// + literal: Const { ty: i32, val: Value(Scalar(0x00000002)) }
StorageDead(_10); // scope 3 at $DIR/match_false_edges.rs:17:25: 17:26
- StorageDead(_9); // scope 0 at $DIR/match_false_edges.rs:17:26: 17:27
+ StorageDead(_9); // scope 0 at $DIR/match_false_edges.rs:17:25: 17:26
goto -> bb11; // scope 0 at $DIR/match_false_edges.rs:15:13: 19:6
}
diff --git a/src/test/mir-opt/match_false_edges/rustc.full_tested_match2.PromoteTemps.before.mir b/src/test/mir-opt/match_false_edges/rustc.full_tested_match2.PromoteTemps.before.mir
index f1744a9..b79416f 100644
--- a/src/test/mir-opt/match_false_edges/rustc.full_tested_match2.PromoteTemps.before.mir
+++ b/src/test/mir-opt/match_false_edges/rustc.full_tested_match2.PromoteTemps.before.mir
@@ -62,7 +62,7 @@
// + span: $DIR/match_false_edges.rs:29:21: 29:22
// + literal: Const { ty: i32, val: Value(Scalar(0x00000002)) }
StorageDead(_10); // scope 3 at $DIR/match_false_edges.rs:29:25: 29:26
- StorageDead(_9); // scope 0 at $DIR/match_false_edges.rs:29:26: 29:27
+ StorageDead(_9); // scope 0 at $DIR/match_false_edges.rs:29:25: 29:26
goto -> bb11; // scope 0 at $DIR/match_false_edges.rs:26:13: 30:6
}
@@ -89,7 +89,7 @@
}
bb8: {
- StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:27:37: 27:38
+ StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:27:36: 27:37
FakeRead(ForMatchGuard, _4); // scope 0 at $DIR/match_false_edges.rs:27:26: 27:27
FakeRead(ForGuardBinding, _6); // scope 0 at $DIR/match_false_edges.rs:27:26: 27:27
StorageLive(_5); // scope 0 at $DIR/match_false_edges.rs:27:14: 27:15
@@ -104,14 +104,14 @@
// + span: $DIR/match_false_edges.rs:27:32: 27:33
// + literal: Const { ty: i32, val: Value(Scalar(0x00000001)) }
StorageDead(_8); // scope 2 at $DIR/match_false_edges.rs:27:36: 27:37
- StorageDead(_5); // scope 0 at $DIR/match_false_edges.rs:27:37: 27:38
- StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:27:37: 27:38
+ StorageDead(_5); // scope 0 at $DIR/match_false_edges.rs:27:36: 27:37
+ StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:27:36: 27:37
goto -> bb11; // scope 0 at $DIR/match_false_edges.rs:26:13: 30:6
}
bb9: {
- StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:27:37: 27:38
- StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:27:37: 27:38
+ StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:27:36: 27:37
+ StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:27:36: 27:37
falseEdge -> [real: bb4, imaginary: bb2]; // scope 0 at $DIR/match_false_edges.rs:27:20: 27:27
}
diff --git a/src/test/mir-opt/match_false_edges/rustc.main.PromoteTemps.before.mir b/src/test/mir-opt/match_false_edges/rustc.main.PromoteTemps.before.mir
index 4ab4c4d..5b449da 100644
--- a/src/test/mir-opt/match_false_edges/rustc.main.PromoteTemps.before.mir
+++ b/src/test/mir-opt/match_false_edges/rustc.main.PromoteTemps.before.mir
@@ -70,7 +70,7 @@
// mir::Constant
// + span: $DIR/match_false_edges.rs:39:15: 39:16
// + literal: Const { ty: i32, val: Value(Scalar(0x00000004)) }
- StorageDead(_14); // scope 0 at $DIR/match_false_edges.rs:39:16: 39:17
+ StorageDead(_14); // scope 0 at $DIR/match_false_edges.rs:39:15: 39:16
goto -> bb15; // scope 0 at $DIR/match_false_edges.rs:35:13: 40:6
}
@@ -97,7 +97,7 @@
}
bb8: {
- StorageDead(_8); // scope 0 at $DIR/match_false_edges.rs:36:33: 36:34
+ StorageDead(_8); // scope 0 at $DIR/match_false_edges.rs:36:32: 36:33
FakeRead(ForMatchGuard, _5); // scope 0 at $DIR/match_false_edges.rs:36:27: 36:28
FakeRead(ForGuardBinding, _7); // scope 0 at $DIR/match_false_edges.rs:36:27: 36:28
StorageLive(_6); // scope 0 at $DIR/match_false_edges.rs:36:14: 36:16
@@ -109,14 +109,14 @@
// mir::Constant
// + span: $DIR/match_false_edges.rs:36:32: 36:33
// + literal: Const { ty: i32, val: Value(Scalar(0x00000001)) }
- StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:36:33: 36:34
- StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:36:33: 36:34
+ StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:36:32: 36:33
+ StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:36:32: 36:33
goto -> bb15; // scope 0 at $DIR/match_false_edges.rs:35:13: 40:6
}
bb9: {
- StorageDead(_8); // scope 0 at $DIR/match_false_edges.rs:36:33: 36:34
- StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:36:33: 36:34
+ StorageDead(_8); // scope 0 at $DIR/match_false_edges.rs:36:32: 36:33
+ StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:36:32: 36:33
falseEdge -> [real: bb2, imaginary: bb2]; // scope 0 at $DIR/match_false_edges.rs:36:21: 36:28
}
@@ -130,7 +130,7 @@
// mir::Constant
// + span: $DIR/match_false_edges.rs:37:15: 37:16
// + literal: Const { ty: i32, val: Value(Scalar(0x00000002)) }
- StorageDead(_9); // scope 0 at $DIR/match_false_edges.rs:37:16: 37:17
+ StorageDead(_9); // scope 0 at $DIR/match_false_edges.rs:37:15: 37:16
goto -> bb15; // scope 0 at $DIR/match_false_edges.rs:35:13: 40:6
}
@@ -156,7 +156,7 @@
}
bb13: {
- StorageDead(_12); // scope 0 at $DIR/match_false_edges.rs:38:34: 38:35
+ StorageDead(_12); // scope 0 at $DIR/match_false_edges.rs:38:33: 38:34
FakeRead(ForMatchGuard, _5); // scope 0 at $DIR/match_false_edges.rs:38:28: 38:29
FakeRead(ForGuardBinding, _11); // scope 0 at $DIR/match_false_edges.rs:38:28: 38:29
StorageLive(_10); // scope 0 at $DIR/match_false_edges.rs:38:14: 38:15
@@ -168,14 +168,14 @@
// mir::Constant
// + span: $DIR/match_false_edges.rs:38:33: 38:34
// + literal: Const { ty: i32, val: Value(Scalar(0x00000003)) }
- StorageDead(_10); // scope 0 at $DIR/match_false_edges.rs:38:34: 38:35
- StorageDead(_11); // scope 0 at $DIR/match_false_edges.rs:38:34: 38:35
+ StorageDead(_10); // scope 0 at $DIR/match_false_edges.rs:38:33: 38:34
+ StorageDead(_11); // scope 0 at $DIR/match_false_edges.rs:38:33: 38:34
goto -> bb15; // scope 0 at $DIR/match_false_edges.rs:35:13: 40:6
}
bb14: {
- StorageDead(_12); // scope 0 at $DIR/match_false_edges.rs:38:34: 38:35
- StorageDead(_11); // scope 0 at $DIR/match_false_edges.rs:38:34: 38:35
+ StorageDead(_12); // scope 0 at $DIR/match_false_edges.rs:38:33: 38:34
+ StorageDead(_11); // scope 0 at $DIR/match_false_edges.rs:38:33: 38:34
falseEdge -> [real: bb4, imaginary: bb4]; // scope 0 at $DIR/match_false_edges.rs:38:20: 38:29
}
diff --git a/src/test/mir-opt/match_test/rustc.main.SimplifyCfg-initial.after.mir b/src/test/mir-opt/match_test/rustc.main.SimplifyCfg-initial.after.mir
index ef6c88d..1689594 100644
--- a/src/test/mir-opt/match_test/rustc.main.SimplifyCfg-initial.after.mir
+++ b/src/test/mir-opt/match_test/rustc.main.SimplifyCfg-initial.after.mir
@@ -117,7 +117,7 @@
}
bb10: {
- StorageDead(_9); // scope 2 at $DIR/match_test.rs:13:24: 13:25
+ StorageDead(_9); // scope 2 at $DIR/match_test.rs:13:23: 13:24
FakeRead(ForMatchGuard, _8); // scope 2 at $DIR/match_test.rs:13:18: 13:19
_3 = const 0_i32; // scope 2 at $DIR/match_test.rs:13:23: 13:24
// ty::Const
@@ -130,7 +130,7 @@
}
bb11: {
- StorageDead(_9); // scope 2 at $DIR/match_test.rs:13:24: 13:25
+ StorageDead(_9); // scope 2 at $DIR/match_test.rs:13:23: 13:24
falseEdge -> [real: bb3, imaginary: bb6]; // scope 2 at $DIR/match_test.rs:13:18: 13:19
}
diff --git a/src/test/mir-opt/no-drop-for-inactive-variant/rustc.unwrap.SimplifyCfg-elaborate-drops.after.mir b/src/test/mir-opt/no-drop-for-inactive-variant/rustc.unwrap.SimplifyCfg-elaborate-drops.after.mir
index 2e8cfae..f3f2b68 100644
--- a/src/test/mir-opt/no-drop-for-inactive-variant/rustc.unwrap.SimplifyCfg-elaborate-drops.after.mir
+++ b/src/test/mir-opt/no-drop-for-inactive-variant/rustc.unwrap.SimplifyCfg-elaborate-drops.after.mir
@@ -43,7 +43,7 @@
StorageLive(_3); // scope 0 at $DIR/no-drop-for-inactive-variant.rs:9:14: 9:15
_3 = move ((_1 as Some).0: T); // scope 0 at $DIR/no-drop-for-inactive-variant.rs:9:14: 9:15
_0 = move _3; // scope 1 at $DIR/no-drop-for-inactive-variant.rs:9:20: 9:21
- StorageDead(_3); // scope 0 at $DIR/no-drop-for-inactive-variant.rs:9:21: 9:22
+ StorageDead(_3); // scope 0 at $DIR/no-drop-for-inactive-variant.rs:9:20: 9:21
_6 = discriminant(_1); // scope 0 at $DIR/no-drop-for-inactive-variant.rs:12:1: 12:2
return; // scope 0 at $DIR/no-drop-for-inactive-variant.rs:12:2: 12:2
}
diff --git a/src/test/mir-opt/remove_fake_borrows/rustc.match_guard.CleanupNonCodegenStatements.diff b/src/test/mir-opt/remove_fake_borrows/rustc.match_guard.CleanupNonCodegenStatements.diff
index 7fc2097..0822d8c 100644
--- a/src/test/mir-opt/remove_fake_borrows/rustc.match_guard.CleanupNonCodegenStatements.diff
+++ b/src/test/mir-opt/remove_fake_borrows/rustc.match_guard.CleanupNonCodegenStatements.diff
@@ -53,7 +53,7 @@
}
bb5: {
- StorageDead(_8); // scope 0 at $DIR/remove_fake_borrows.rs:8:26: 8:27
+ StorageDead(_8); // scope 0 at $DIR/remove_fake_borrows.rs:8:25: 8:26
- FakeRead(ForMatchGuard, _4); // scope 0 at $DIR/remove_fake_borrows.rs:8:20: 8:21
- FakeRead(ForMatchGuard, _5); // scope 0 at $DIR/remove_fake_borrows.rs:8:20: 8:21
- FakeRead(ForMatchGuard, _6); // scope 0 at $DIR/remove_fake_borrows.rs:8:20: 8:21
@@ -73,7 +73,7 @@
}
bb6: {
- StorageDead(_8); // scope 0 at $DIR/remove_fake_borrows.rs:8:26: 8:27
+ StorageDead(_8); // scope 0 at $DIR/remove_fake_borrows.rs:8:25: 8:26
goto -> bb1; // scope 0 at $DIR/remove_fake_borrows.rs:8:20: 8:21
}
diff --git a/src/test/mir-opt/simplify-arm-identity/32bit/rustc.main.SimplifyArmIdentity.diff b/src/test/mir-opt/simplify-arm-identity/32bit/rustc.main.SimplifyArmIdentity.diff
index 33a3403..0de80f7 100644
--- a/src/test/mir-opt/simplify-arm-identity/32bit/rustc.main.SimplifyArmIdentity.diff
+++ b/src/test/mir-opt/simplify-arm-identity/32bit/rustc.main.SimplifyArmIdentity.diff
@@ -61,7 +61,7 @@
((_2 as Foo).0: u8) = move _5; // scope 3 at $DIR/simplify-arm-identity.rs:20:24: 20:35
discriminant(_2) = 0; // scope 3 at $DIR/simplify-arm-identity.rs:20:24: 20:35
StorageDead(_5); // scope 3 at $DIR/simplify-arm-identity.rs:20:34: 20:35
- StorageDead(_4); // scope 1 at $DIR/simplify-arm-identity.rs:20:35: 20:36
+ StorageDead(_4); // scope 1 at $DIR/simplify-arm-identity.rs:20:34: 20:35
goto -> bb4; // scope 1 at $DIR/simplify-arm-identity.rs:19:18: 22:6
}
diff --git a/src/test/mir-opt/simplify-arm-identity/64bit/rustc.main.SimplifyArmIdentity.diff b/src/test/mir-opt/simplify-arm-identity/64bit/rustc.main.SimplifyArmIdentity.diff
index 7e4fe1c..4fa0aff 100644
--- a/src/test/mir-opt/simplify-arm-identity/64bit/rustc.main.SimplifyArmIdentity.diff
+++ b/src/test/mir-opt/simplify-arm-identity/64bit/rustc.main.SimplifyArmIdentity.diff
@@ -61,7 +61,7 @@
((_2 as Foo).0: u8) = move _5; // scope 3 at $DIR/simplify-arm-identity.rs:20:24: 20:35
discriminant(_2) = 0; // scope 3 at $DIR/simplify-arm-identity.rs:20:24: 20:35
StorageDead(_5); // scope 3 at $DIR/simplify-arm-identity.rs:20:34: 20:35
- StorageDead(_4); // scope 1 at $DIR/simplify-arm-identity.rs:20:35: 20:36
+ StorageDead(_4); // scope 1 at $DIR/simplify-arm-identity.rs:20:34: 20:35
goto -> bb4; // scope 1 at $DIR/simplify-arm-identity.rs:19:18: 22:6
}
diff --git a/src/test/mir-opt/simplify-arm/rustc.id.SimplifyArmIdentity.diff b/src/test/mir-opt/simplify-arm/rustc.id.SimplifyArmIdentity.diff
index daae94e..0cddcb0 100644
--- a/src/test/mir-opt/simplify-arm/rustc.id.SimplifyArmIdentity.diff
+++ b/src/test/mir-opt/simplify-arm/rustc.id.SimplifyArmIdentity.diff
@@ -33,7 +33,7 @@
((_0 as Some).0: u8) = move _4; // scope 1 at $DIR/simplify-arm.rs:11:20: 11:27
discriminant(_0) = 1; // scope 1 at $DIR/simplify-arm.rs:11:20: 11:27
StorageDead(_4); // scope 1 at $DIR/simplify-arm.rs:11:26: 11:27
- StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:11:27: 11:28
+ StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:11:26: 11:27
goto -> bb4; // scope 0 at $DIR/simplify-arm.rs:10:5: 13:6
}
diff --git a/src/test/mir-opt/simplify-arm/rustc.id.SimplifyBranchSame.diff b/src/test/mir-opt/simplify-arm/rustc.id.SimplifyBranchSame.diff
index 15bd5e7..cd5962c 100644
--- a/src/test/mir-opt/simplify-arm/rustc.id.SimplifyBranchSame.diff
+++ b/src/test/mir-opt/simplify-arm/rustc.id.SimplifyBranchSame.diff
@@ -33,7 +33,7 @@
((_0 as Some).0: u8) = move _4; // scope 1 at $DIR/simplify-arm.rs:11:20: 11:27
discriminant(_0) = 1; // scope 1 at $DIR/simplify-arm.rs:11:20: 11:27
StorageDead(_4); // scope 1 at $DIR/simplify-arm.rs:11:26: 11:27
- StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:11:27: 11:28
+ StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:11:26: 11:27
goto -> bb4; // scope 0 at $DIR/simplify-arm.rs:10:5: 13:6
}
diff --git a/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyArmIdentity.diff b/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyArmIdentity.diff
index 37273d1..642ccc1 100644
--- a/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyArmIdentity.diff
+++ b/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyArmIdentity.diff
@@ -29,7 +29,7 @@
((_0 as Err).0: i32) = move _6; // scope 2 at $DIR/simplify-arm.rs:19:19: 19:25
discriminant(_0) = 1; // scope 2 at $DIR/simplify-arm.rs:19:19: 19:25
StorageDead(_6); // scope 2 at $DIR/simplify-arm.rs:19:24: 19:25
- StorageDead(_5); // scope 0 at $DIR/simplify-arm.rs:19:25: 19:26
+ StorageDead(_5); // scope 0 at $DIR/simplify-arm.rs:19:24: 19:25
goto -> bb4; // scope 0 at $DIR/simplify-arm.rs:17:5: 20:6
}
@@ -45,7 +45,7 @@
((_0 as Ok).0: u8) = move _4; // scope 1 at $DIR/simplify-arm.rs:18:18: 18:23
discriminant(_0) = 0; // scope 1 at $DIR/simplify-arm.rs:18:18: 18:23
StorageDead(_4); // scope 1 at $DIR/simplify-arm.rs:18:22: 18:23
- StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:18:23: 18:24
+ StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:18:22: 18:23
goto -> bb4; // scope 0 at $DIR/simplify-arm.rs:17:5: 20:6
}
diff --git a/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyBranchSame.diff b/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyBranchSame.diff
index f138d63..95ce09a 100644
--- a/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyBranchSame.diff
+++ b/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyBranchSame.diff
@@ -29,7 +29,7 @@
((_0 as Err).0: i32) = move _6; // scope 2 at $DIR/simplify-arm.rs:19:19: 19:25
discriminant(_0) = 1; // scope 2 at $DIR/simplify-arm.rs:19:19: 19:25
StorageDead(_6); // scope 2 at $DIR/simplify-arm.rs:19:24: 19:25
- StorageDead(_5); // scope 0 at $DIR/simplify-arm.rs:19:25: 19:26
+ StorageDead(_5); // scope 0 at $DIR/simplify-arm.rs:19:24: 19:25
goto -> bb4; // scope 0 at $DIR/simplify-arm.rs:17:5: 20:6
}
@@ -45,7 +45,7 @@
((_0 as Ok).0: u8) = move _4; // scope 1 at $DIR/simplify-arm.rs:18:18: 18:23
discriminant(_0) = 0; // scope 1 at $DIR/simplify-arm.rs:18:18: 18:23
StorageDead(_4); // scope 1 at $DIR/simplify-arm.rs:18:22: 18:23
- StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:18:23: 18:24
+ StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:18:22: 18:23
goto -> bb4; // scope 0 at $DIR/simplify-arm.rs:17:5: 20:6
}
diff --git "a/src/test/mir-opt/simplify_try_if_let/rustc.\173\173impl\175\175-append.SimplifyArmIdentity.diff" "b/src/test/mir-opt/simplify_try_if_let/rustc.\173\173impl\175\175-append.SimplifyArmIdentity.diff"
index aa41604..4471f4d 100644
--- "a/src/test/mir-opt/simplify_try_if_let/rustc.\173\173impl\175\175-append.SimplifyArmIdentity.diff"
+++ "b/src/test/mir-opt/simplify_try_if_let/rustc.\173\173impl\175\175-append.SimplifyArmIdentity.diff"
@@ -115,7 +115,7 @@
bb8: {
StorageDead(_5); // scope 1 at $DIR/simplify_try_if_let.rs:31:13: 31:14
- StorageDead(_4); // scope 0 at $DIR/simplify_try_if_let.rs:32:9: 32:10
+ StorageDead(_4); // scope 0 at $DIR/simplify_try_if_let.rs:31:13: 31:14
goto -> bb9; // scope 0 at $DIR/simplify_try_if_let.rs:21:9: 32:10
}
diff --git a/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs b/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs
index efc6236..dd49ca6 100644
--- a/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs
+++ b/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs
@@ -52,7 +52,7 @@
fn provide(&self, providers: &mut Providers) {
rustc_symbol_mangling::provide(providers);
- providers.target_features_whitelist = |tcx, _cnum| {
+ providers.supported_target_features = |tcx, _cnum| {
Default::default() // Just a dummy
};
providers.is_reachable_non_generic = |_tcx, _defid| true;
diff --git a/src/test/run-make-fulldeps/sysroot-crates-are-unstable/test.py b/src/test/run-make-fulldeps/sysroot-crates-are-unstable/test.py
index 927edff..f479bda 100644
--- a/src/test/run-make-fulldeps/sysroot-crates-are-unstable/test.py
+++ b/src/test/run-make-fulldeps/sysroot-crates-are-unstable/test.py
@@ -5,7 +5,7 @@
from subprocess import PIPE, Popen
-# This is a whitelist of files which are stable crates or simply are not crates,
+# This is n list of files which are stable crates or simply are not crates,
# we don't check for the instability of these crates as they're all stable!
STABLE_CRATES = ['std', 'alloc', 'core', 'proc_macro',
'rsbegin.o', 'rsend.o', 'dllcrt2.o', 'crt2.o', 'clang_rt']
diff --git a/src/test/rustdoc-ui/check-attr-test.rs b/src/test/rustdoc-ui/check-attr-test.rs
index c4140bb..665f330 100644
--- a/src/test/rustdoc-ui/check-attr-test.rs
+++ b/src/test/rustdoc-ui/check-attr-test.rs
@@ -1,6 +1,6 @@
// compile-flags:--test
-#![deny(invalid_codeblock_attribute)]
+#![deny(invalid_codeblock_attributes)]
/// foo
///
diff --git a/src/test/rustdoc-ui/check-attr-test.stderr b/src/test/rustdoc-ui/check-attr-test.stderr
index 45a2d6e..1e067a5d 100644
--- a/src/test/rustdoc-ui/check-attr-test.stderr
+++ b/src/test/rustdoc-ui/check-attr-test.stderr
@@ -11,8 +11,8 @@
note: the lint level is defined here
--> $DIR/check-attr-test.rs:3:9
|
-3 | #![deny(invalid_codeblock_attribute)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+3 | #![deny(invalid_codeblock_attributes)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= help: the code block will either not be tested if not marked as a rust one or won't fail if it compiles successfully
error: unknown attribute `compilefail`. Did you mean `compile_fail`?
diff --git a/src/test/rustdoc-ui/check-attr.rs b/src/test/rustdoc-ui/check-attr.rs
index a93ec29..9e02eab 100644
--- a/src/test/rustdoc-ui/check-attr.rs
+++ b/src/test/rustdoc-ui/check-attr.rs
@@ -1,4 +1,4 @@
-#![deny(invalid_codeblock_attribute)]
+#![deny(invalid_codeblock_attributes)]
/// foo
//~^ ERROR
diff --git a/src/test/rustdoc-ui/check-attr.stderr b/src/test/rustdoc-ui/check-attr.stderr
index 5d6939b..919eb04 100644
--- a/src/test/rustdoc-ui/check-attr.stderr
+++ b/src/test/rustdoc-ui/check-attr.stderr
@@ -13,8 +13,8 @@
note: the lint level is defined here
--> $DIR/check-attr.rs:1:9
|
-LL | #![deny(invalid_codeblock_attribute)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![deny(invalid_codeblock_attributes)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= help: the code block will either not be tested if not marked as a rust one or won't fail if it compiles successfully
error: unknown attribute `compilefail`. Did you mean `compile_fail`?
diff --git a/src/test/rustdoc/auxiliary/my-core.rs b/src/test/rustdoc/auxiliary/my-core.rs
new file mode 100644
index 0000000..54e986b
--- /dev/null
+++ b/src/test/rustdoc/auxiliary/my-core.rs
@@ -0,0 +1,19 @@
+#![feature(no_core, lang_items)]
+#![no_core]
+#![crate_type="rlib"]
+
+#[lang = "char"]
+impl char {
+ pub fn len_utf8(self) -> usize {
+ 42
+ }
+}
+
+#[lang = "sized"]
+pub trait Sized {}
+
+#[lang = "clone"]
+pub trait Clone: Sized {}
+
+#[lang = "copy"]
+pub trait Copy: Clone {}
diff --git a/src/test/rustdoc/intra-link-prim-methods-external-core.rs b/src/test/rustdoc/intra-link-prim-methods-external-core.rs
new file mode 100644
index 0000000..e09d365
--- /dev/null
+++ b/src/test/rustdoc/intra-link-prim-methods-external-core.rs
@@ -0,0 +1,18 @@
+// aux-build:my-core.rs
+// build-aux-docs
+// ignore-cross-compile
+// ignore-windows
+// ignore-tidy-linelength
+
+#![deny(intra_doc_link_resolution_failure)]
+#![feature(no_core, lang_items)]
+#![no_core]
+#![crate_type = "rlib"]
+
+// @has intra_link_prim_methods_external_core/index.html
+// @has - '//*[@id="main"]//a[@href="https://doc.rust-lang.org/nightly/std/primitive.char.html"]' 'char'
+// @has - '//*[@id="main"]//a[@href="https://doc.rust-lang.org/nightly/std/primitive.char.html#method.len_utf8"]' 'char::len_utf8'
+
+//! A [`char`] and its [`char::len_utf8`].
+
+extern crate my_core;
diff --git a/src/test/rustdoc/intra-link-prim-methods-local.rs b/src/test/rustdoc/intra-link-prim-methods-local.rs
new file mode 100644
index 0000000..d24cd2c
--- /dev/null
+++ b/src/test/rustdoc/intra-link-prim-methods-local.rs
@@ -0,0 +1,28 @@
+#![deny(intra_doc_link_resolution_failure)]
+#![feature(no_core, lang_items)]
+#![no_core]
+#![crate_type = "rlib"]
+
+// ignore-tidy-linelength
+
+// @has intra_link_prim_methods_local/index.html
+// @has - '//*[@id="main"]//a[@href="https://doc.rust-lang.org/nightly/std/primitive.char.html"]' 'char'
+// @has - '//*[@id="main"]//a[@href="https://doc.rust-lang.org/nightly/std/primitive.char.html#method.len_utf8"]' 'char::len_utf8'
+
+//! A [`char`] and its [`char::len_utf8`].
+
+#[lang = "char"]
+impl char {
+ pub fn len_utf8(self) -> usize {
+ 42
+ }
+}
+
+#[lang = "sized"]
+pub trait Sized {}
+
+#[lang = "clone"]
+pub trait Clone: Sized {}
+
+#[lang = "copy"]
+pub trait Copy: Clone {}
diff --git a/src/test/rustdoc/intra-link-prim-methods.rs b/src/test/rustdoc/intra-link-prim-methods.rs
index af0426b..76636b8 100644
--- a/src/test/rustdoc/intra-link-prim-methods.rs
+++ b/src/test/rustdoc/intra-link-prim-methods.rs
@@ -1,3 +1,9 @@
#![deny(intra_doc_link_resolution_failure)]
+// ignore-tidy-linelength
+
+// @has intra_link_prim_methods/index.html
+// @has - '//*[@id="main"]//a[@href="https://doc.rust-lang.org/nightly/std/primitive.char.html"]' 'char'
+// @has - '//*[@id="main"]//a[@href="https://doc.rust-lang.org/nightly/std/primitive.char.html#method.len_utf8"]' 'char::len_utf8'
+
//! A [`char`] and its [`char::len_utf8`].
diff --git a/src/test/rustdoc/intra-links.rs b/src/test/rustdoc/intra-links.rs
index c6725f5..751c109 100644
--- a/src/test/rustdoc/intra-links.rs
+++ b/src/test/rustdoc/intra-links.rs
@@ -46,6 +46,8 @@
() => {};
}
+// @has intra_links/struct.ThisType.html '//a/@href' '../intra_links/macro.this_macro.html'
+/// another link to [`this_macro!()`]
pub struct ThisType;
impl ThisType {
@@ -70,7 +72,7 @@
pub fn SoAmbiguous() {}
-// @has - '//a/@href' '../intra_links/struct.ThisType.html'
+// @has intra_links/struct.SomeOtherType.html '//a/@href' '../intra_links/struct.ThisType.html'
// @has - '//a/@href' '../intra_links/struct.ThisType.html#method.this_method'
// @has - '//a/@href' '../intra_links/enum.ThisEnum.html'
// @has - '//a/@href' '../intra_links/enum.ThisEnum.html#variant.ThisVariant'
diff --git a/src/test/rustdoc/issue-74083.rs b/src/test/rustdoc/issue-74083.rs
new file mode 100644
index 0000000..28585da
--- /dev/null
+++ b/src/test/rustdoc/issue-74083.rs
@@ -0,0 +1,21 @@
+use std::ops::Deref;
+
+pub struct Foo;
+
+impl Foo {
+ pub fn foo(&mut self) {}
+}
+
+// @has issue_74083/struct.Bar.html
+// !@has - '//div[@class="sidebar-links"]/a[@href="#method.foo"]' 'foo'
+pub struct Bar {
+ foo: Foo,
+}
+
+impl Deref for Bar {
+ type Target = Foo;
+
+ fn deref(&self) -> &Foo {
+ &self.foo
+ }
+}
diff --git a/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs b/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs
index 9ba2675..4e9d4d3 100644
--- a/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs
+++ b/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs
@@ -21,19 +21,19 @@
#[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) {
- reg.lint_store.register_lints(&[&MISSING_WHITELISTED_ATTR]);
- reg.lint_store.register_late_pass(|| box MissingWhitelistedAttrPass);
+ reg.lint_store.register_lints(&[&MISSING_ALLOWED_ATTR]);
+ reg.lint_store.register_late_pass(|| box MissingAllowedAttrPass);
}
declare_lint! {
- MISSING_WHITELISTED_ATTR,
+ MISSING_ALLOWED_ATTR,
Deny,
- "Checks for missing `whitelisted_attr` attribute"
+ "Checks for missing `allowed_attr` attribute"
}
-declare_lint_pass!(MissingWhitelistedAttrPass => [MISSING_WHITELISTED_ATTR]);
+declare_lint_pass!(MissingAllowedAttrPass => [MISSING_ALLOWED_ATTR]);
-impl<'tcx> LateLintPass<'tcx> for MissingWhitelistedAttrPass {
+impl<'tcx> LateLintPass<'tcx> for MissingAllowedAttrPass {
fn check_fn(
&mut self,
cx: &LateContext<'tcx>,
@@ -48,10 +48,10 @@
_ => cx.tcx.hir().expect_item(cx.tcx.hir().get_parent_item(id)),
};
- let whitelisted = |attr| pprust::attribute_to_string(attr).contains("whitelisted_attr");
- if !item.attrs.iter().any(whitelisted) {
- cx.lint(MISSING_WHITELISTED_ATTR, |lint| {
- lint.build("Missing 'whitelisted_attr' attribute").set_span(span).emit()
+ let allowed = |attr| pprust::attribute_to_string(attr).contains("allowed_attr");
+ if !item.attrs.iter().any(allowed) {
+ cx.lint(MISSING_ALLOWED_ATTR, |lint| {
+ lint.build("Missing 'allowed_attr' attribute").set_span(span).emit()
});
}
}
diff --git a/src/test/ui-fulldeps/issue-40001.rs b/src/test/ui-fulldeps/issue-40001.rs
index c3f9819..e14338f 100644
--- a/src/test/ui-fulldeps/issue-40001.rs
+++ b/src/test/ui-fulldeps/issue-40001.rs
@@ -6,5 +6,5 @@
#![plugin(issue_40001_plugin)] //~ WARNING compiler plugins are deprecated
#![register_tool(plugin)]
-#[plugin::whitelisted_attr]
+#[plugin::allowed_attr]
fn main() {}
diff --git a/src/test/ui-fulldeps/mod_dir_path_canonicalized.rs b/src/test/ui-fulldeps/mod_dir_path_canonicalized.rs
index ff7bbaf..836cb07 100644
--- a/src/test/ui-fulldeps/mod_dir_path_canonicalized.rs
+++ b/src/test/ui-fulldeps/mod_dir_path_canonicalized.rs
@@ -19,7 +19,7 @@
mod gravy;
pub fn main() {
- rustc_ast::with_default_globals(|| parse());
+ rustc_ast::with_default_session_globals(|| parse());
assert_eq!(gravy::foo(), 10);
}
diff --git a/src/test/ui-fulldeps/pprust-expr-roundtrip.rs b/src/test/ui-fulldeps/pprust-expr-roundtrip.rs
index 6da26e6..8286b7fd 100644
--- a/src/test/ui-fulldeps/pprust-expr-roundtrip.rs
+++ b/src/test/ui-fulldeps/pprust-expr-roundtrip.rs
@@ -208,7 +208,7 @@
}
fn main() {
- rustc_ast::with_default_globals(|| run());
+ rustc_ast::with_default_session_globals(|| run());
}
fn run() {
diff --git a/src/test/ui/asm/type-check-3.rs b/src/test/ui/asm/type-check-3.rs
index 5de15fe..0f803ef 100644
--- a/src/test/ui/asm/type-check-3.rs
+++ b/src/test/ui/asm/type-check-3.rs
@@ -7,7 +7,7 @@
fn main() {
unsafe {
- // Types must be in the whitelist for the register class
+ // Types must be listed in the register class.
asm!("{}", in(reg) 0i128);
//~^ ERROR type `i128` cannot be used with this register class
diff --git a/src/test/ui/cfguard-run.rs b/src/test/ui/cfguard-run.rs
new file mode 100644
index 0000000..21368fa
--- /dev/null
+++ b/src/test/ui/cfguard-run.rs
@@ -0,0 +1,6 @@
+// run-pass
+// compile-flags: -Z control-flow-guard
+
+pub fn main() {
+ println!("hello, world");
+}
diff --git a/src/test/ui/consts/array-to-slice-cast.rs b/src/test/ui/consts/array-to-slice-cast.rs
new file mode 100644
index 0000000..796f9d1
--- /dev/null
+++ b/src/test/ui/consts/array-to-slice-cast.rs
@@ -0,0 +1,13 @@
+// check-pass
+
+fn main() {}
+
+const fn foo() {
+ let x = [1, 2, 3, 4, 5];
+ let y: &[_] = &x;
+
+ struct Foo<T: ?Sized>(bool, T);
+
+ let x: Foo<[u8; 3]> = Foo(true, [1, 2, 3]);
+ let y: &Foo<[u8]> = &x;
+}
diff --git a/src/test/ui/consts/const-eval/ub-enum.rs b/src/test/ui/consts/const-eval/ub-enum.rs
index c49997c..136b332 100644
--- a/src/test/ui/consts/const-eval/ub-enum.rs
+++ b/src/test/ui/consts/const-eval/ub-enum.rs
@@ -88,9 +88,10 @@
//~^ ERROR is undefined behavior
// All variants are uninhabited but also have data.
-const BAD_UNINHABITED_WITH_DATA1: Result<(i32, Never), (i32, !)> = unsafe { mem::transmute(1u64) };
+// Use `0` as constant to make behavior endianess-independent.
+const BAD_UNINHABITED_WITH_DATA1: Result<(i32, Never), (i32, !)> = unsafe { mem::transmute(0u64) };
//~^ ERROR is undefined behavior
-const BAD_UNINHABITED_WITH_DATA2: Result<(i32, !), (i32, Never)> = unsafe { mem::transmute(1u64) };
+const BAD_UNINHABITED_WITH_DATA2: Result<(i32, !), (i32, Never)> = unsafe { mem::transmute(0u64) };
//~^ ERROR is undefined behavior
fn main() {
diff --git a/src/test/ui/consts/const-eval/ub-enum.stderr b/src/test/ui/consts/const-eval/ub-enum.stderr
index 217bfb6..7b3ee53 100644
--- a/src/test/ui/consts/const-eval/ub-enum.stderr
+++ b/src/test/ui/consts/const-eval/ub-enum.stderr
@@ -87,18 +87,18 @@
= 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.
error[E0080]: it is undefined behavior to use this value
- --> $DIR/ub-enum.rs:91:1
+ --> $DIR/ub-enum.rs:92:1
|
-LL | const BAD_UNINHABITED_WITH_DATA1: Result<(i32, Never), (i32, !)> = unsafe { mem::transmute(1u64) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of the never type `!` at .<enum-variant(Err)>.0.1
+LL | const BAD_UNINHABITED_WITH_DATA1: Result<(i32, Never), (i32, !)> = unsafe { mem::transmute(0u64) };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of uninhabited type Never at .<enum-variant(Ok)>.0.1
|
= 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.
error[E0080]: it is undefined behavior to use this value
- --> $DIR/ub-enum.rs:93:1
+ --> $DIR/ub-enum.rs:94:1
|
-LL | const BAD_UNINHABITED_WITH_DATA2: Result<(i32, !), (i32, Never)> = unsafe { mem::transmute(1u64) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of uninhabited type Never at .<enum-variant(Err)>.0.1
+LL | const BAD_UNINHABITED_WITH_DATA2: Result<(i32, !), (i32, Never)> = unsafe { mem::transmute(0u64) };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of the never type `!` at .<enum-variant(Ok)>.0.1
|
= 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.
diff --git a/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.rs b/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.rs
index 5619811..2854c08 100644
--- a/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.rs
+++ b/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.rs
@@ -1,7 +1,6 @@
#![feature(const_extern_fn)]
const extern fn unsize(x: &[u8; 3]) -> &[u8] { x }
-//~^ ERROR unsizing casts are not allowed in const fn
const unsafe extern "C" fn closure() -> fn() { || {} }
//~^ ERROR function pointers in const fn are unstable
const unsafe extern fn use_float() { 1.0 + 1.0; }
diff --git a/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr b/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr
index f520bd3..146d119 100644
--- a/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr
+++ b/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr
@@ -1,14 +1,5 @@
-error[E0723]: unsizing casts are not allowed in const fn
- --> $DIR/const-extern-fn-min-const-fn.rs:3:48
- |
-LL | const extern fn unsize(x: &[u8; 3]) -> &[u8] { x }
- | ^
- |
- = note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
- = help: add `#![feature(const_fn)]` to the crate attributes to enable
-
error[E0723]: function pointers in const fn are unstable
- --> $DIR/const-extern-fn-min-const-fn.rs:5:41
+ --> $DIR/const-extern-fn-min-const-fn.rs:4:41
|
LL | const unsafe extern "C" fn closure() -> fn() { || {} }
| ^^^^
@@ -17,7 +8,7 @@
= help: add `#![feature(const_fn)]` to the crate attributes to enable
error[E0723]: only int, `bool` and `char` operations are stable in const fn
- --> $DIR/const-extern-fn-min-const-fn.rs:7:38
+ --> $DIR/const-extern-fn-min-const-fn.rs:6:38
|
LL | const unsafe extern fn use_float() { 1.0 + 1.0; }
| ^^^^^^^^^
@@ -26,7 +17,7 @@
= help: add `#![feature(const_fn)]` to the crate attributes to enable
error[E0723]: casting pointers to ints is unstable in const fn
- --> $DIR/const-extern-fn-min-const-fn.rs:9:48
+ --> $DIR/const-extern-fn-min-const-fn.rs:8:48
|
LL | const extern "C" fn ptr_cast(val: *const u8) { val as usize; }
| ^^^^^^^^^^^^
@@ -34,6 +25,6 @@
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0723`.
diff --git a/src/test/ui/consts/const_forget.rs b/src/test/ui/consts/const_forget.rs
index 2dcb72a..ec7dde8 100644
--- a/src/test/ui/consts/const_forget.rs
+++ b/src/test/ui/consts/const_forget.rs
@@ -1,7 +1,5 @@
// check-pass
-#![feature(const_forget)]
-
use std::mem::forget;
const _: () = forget(0i32);
diff --git a/src/test/ui/consts/min_const_fn/cast_errors.rs b/src/test/ui/consts/min_const_fn/cast_errors.rs
index 8648cd3..8d730df 100644
--- a/src/test/ui/consts/min_const_fn/cast_errors.rs
+++ b/src/test/ui/consts/min_const_fn/cast_errors.rs
@@ -1,7 +1,6 @@
fn main() {}
const fn unsize(x: &[u8; 3]) -> &[u8] { x }
-//~^ ERROR unsizing casts are not allowed in const fn
const fn closure() -> fn() { || {} }
//~^ ERROR function pointers in const fn are unstable
const fn closure2() {
diff --git a/src/test/ui/consts/min_const_fn/cast_errors.stderr b/src/test/ui/consts/min_const_fn/cast_errors.stderr
index a6a05b5..583cb4e 100644
--- a/src/test/ui/consts/min_const_fn/cast_errors.stderr
+++ b/src/test/ui/consts/min_const_fn/cast_errors.stderr
@@ -1,14 +1,5 @@
-error[E0723]: unsizing casts are not allowed in const fn
- --> $DIR/cast_errors.rs:3:41
- |
-LL | const fn unsize(x: &[u8; 3]) -> &[u8] { x }
- | ^
- |
- = note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
- = help: add `#![feature(const_fn)]` to the crate attributes to enable
-
error[E0723]: function pointers in const fn are unstable
- --> $DIR/cast_errors.rs:5:23
+ --> $DIR/cast_errors.rs:4:23
|
LL | const fn closure() -> fn() { || {} }
| ^^^^
@@ -17,7 +8,7 @@
= help: add `#![feature(const_fn)]` to the crate attributes to enable
error[E0723]: function pointers in const fn are unstable
- --> $DIR/cast_errors.rs:8:5
+ --> $DIR/cast_errors.rs:7:5
|
LL | (|| {}) as fn();
| ^^^^^^^^^^^^^^^
@@ -26,7 +17,7 @@
= help: add `#![feature(const_fn)]` to the crate attributes to enable
error[E0723]: function pointers in const fn are unstable
- --> $DIR/cast_errors.rs:11:28
+ --> $DIR/cast_errors.rs:10:28
|
LL | const fn reify(f: fn()) -> unsafe fn() { f }
| ^^^^^^^^^^^
@@ -35,7 +26,7 @@
= help: add `#![feature(const_fn)]` to the crate attributes to enable
error[E0723]: function pointers in const fn are unstable
- --> $DIR/cast_errors.rs:13:21
+ --> $DIR/cast_errors.rs:12:21
|
LL | const fn reify2() { main as unsafe fn(); }
| ^^^^^^^^^^^^^^^^^^^
@@ -43,6 +34,6 @@
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0723`.
diff --git a/src/test/ui/issues/issue-29540.rs b/src/test/ui/issues/issue-29540.rs
index 2a4d50f..c0de208 100644
--- a/src/test/ui/issues/issue-29540.rs
+++ b/src/test/ui/issues/issue-29540.rs
@@ -283,7 +283,7 @@
pub mds_beacon_interval: String,
pub mds_beacon_grace: String,
pub mds_enforce_unique_name: String,
- pub mds_blacklist_interval: String,
+ pub mds_interval: String,
pub mds_session_timeout: String,
pub mds_freeze_tree_timeout: String,
pub mds_session_autoclose: String,
diff --git a/src/test/ui/issues/issue-74082.rs b/src/test/ui/issues/issue-74082.rs
new file mode 100644
index 0000000..982f8ef
--- /dev/null
+++ b/src/test/ui/issues/issue-74082.rs
@@ -0,0 +1,9 @@
+#![allow(dead_code)]
+
+#[repr(i128)] //~ ERROR: attribute should be applied to enum
+struct Foo;
+
+#[repr(u128)] //~ ERROR: attribute should be applied to enum
+struct Bar;
+
+fn main() {}
diff --git a/src/test/ui/issues/issue-74082.stderr b/src/test/ui/issues/issue-74082.stderr
new file mode 100644
index 0000000..08fe415
--- /dev/null
+++ b/src/test/ui/issues/issue-74082.stderr
@@ -0,0 +1,19 @@
+error[E0517]: attribute should be applied to enum
+ --> $DIR/issue-74082.rs:3:8
+ |
+LL | #[repr(i128)]
+ | ^^^^
+LL | struct Foo;
+ | ----------- not an enum
+
+error[E0517]: attribute should be applied to enum
+ --> $DIR/issue-74082.rs:6:8
+ |
+LL | #[repr(u128)]
+ | ^^^^
+LL | struct Bar;
+ | ----------- not an enum
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0517`.
diff --git a/src/test/ui/lifetime_starts_expressions.stderr b/src/test/ui/lifetime_starts_expressions.stderr
index 0d7980d..7275841 100644
--- a/src/test/ui/lifetime_starts_expressions.stderr
+++ b/src/test/ui/lifetime_starts_expressions.stderr
@@ -15,10 +15,9 @@
LL | loop { break 'label: loop { break 'label 42; }; }
| - ^^^^ expected type
| |
- | tried to parse a type due to this type ascription
+ | help: maybe write a path separator here: `::`
|
= note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
- = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
error: aborting due to 2 previous errors
diff --git a/src/test/ui/match/issue-74050-end-span.rs b/src/test/ui/match/issue-74050-end-span.rs
new file mode 100644
index 0000000..cc81214
--- /dev/null
+++ b/src/test/ui/match/issue-74050-end-span.rs
@@ -0,0 +1,13 @@
+fn main() {
+ let mut args = std::env::args_os();
+ let _arg = match args.next() {
+ Some(arg) => {
+ match arg.to_str() {
+ //~^ ERROR `arg` does not live long enough
+ Some(s) => s,
+ None => return,
+ }
+ }
+ None => return,
+ };
+}
diff --git a/src/test/ui/match/issue-74050-end-span.stderr b/src/test/ui/match/issue-74050-end-span.stderr
new file mode 100644
index 0000000..d636a11
--- /dev/null
+++ b/src/test/ui/match/issue-74050-end-span.stderr
@@ -0,0 +1,15 @@
+error[E0597]: `arg` does not live long enough
+ --> $DIR/issue-74050-end-span.rs:5:19
+ |
+LL | let _arg = match args.next() {
+ | ---- borrow later stored here
+LL | Some(arg) => {
+LL | match arg.to_str() {
+ | ^^^ borrowed value does not live long enough
+...
+LL | }
+ | - `arg` dropped here while still borrowed
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0597`.
diff --git a/src/test/ui/parser/float-field-interpolated.rs b/src/test/ui/parser/float-field-interpolated.rs
new file mode 100644
index 0000000..a305320
--- /dev/null
+++ b/src/test/ui/parser/float-field-interpolated.rs
@@ -0,0 +1,17 @@
+struct S(u8, (u8, u8));
+
+macro_rules! generate_field_accesses {
+ ($a:tt, $b:literal, $c:expr) => {
+ let s = S(0, (0, 0));
+
+ s.$a; // OK
+ { s.$b; } //~ ERROR unexpected token: `1.1`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1`
+ { s.$c; } //~ ERROR unexpected token: `1.1`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1`
+ };
+}
+
+fn main() {
+ generate_field_accesses!(1.1, 1.1, 1.1);
+}
diff --git a/src/test/ui/parser/float-field-interpolated.stderr b/src/test/ui/parser/float-field-interpolated.stderr
new file mode 100644
index 0000000..fb974f0
--- /dev/null
+++ b/src/test/ui/parser/float-field-interpolated.stderr
@@ -0,0 +1,46 @@
+error: unexpected token: `1.1`
+ --> $DIR/float-field-interpolated.rs:8:13
+ |
+LL | { s.$b; }
+ | ^^
+...
+LL | generate_field_accesses!(1.1, 1.1, 1.1);
+ | ---------------------------------------- in this macro invocation
+ |
+ = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1`
+ --> $DIR/float-field-interpolated.rs:8:13
+ |
+LL | { s.$b; }
+ | ^^ expected one of `.`, `;`, `?`, `}`, or an operator
+...
+LL | generate_field_accesses!(1.1, 1.1, 1.1);
+ | ---------------------------------------- in this macro invocation
+ |
+ = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: unexpected token: `1.1`
+ --> $DIR/float-field-interpolated.rs:10:13
+ |
+LL | { s.$c; }
+ | ^^
+...
+LL | generate_field_accesses!(1.1, 1.1, 1.1);
+ | ---------------------------------------- in this macro invocation
+ |
+ = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1`
+ --> $DIR/float-field-interpolated.rs:10:13
+ |
+LL | { s.$c; }
+ | ^^ expected one of `.`, `;`, `?`, `}`, or an operator
+...
+LL | generate_field_accesses!(1.1, 1.1, 1.1);
+ | ---------------------------------------- in this macro invocation
+ |
+ = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 4 previous errors
+
diff --git a/src/test/ui/parser/float-field.rs b/src/test/ui/parser/float-field.rs
new file mode 100644
index 0000000..eaa7465
--- /dev/null
+++ b/src/test/ui/parser/float-field.rs
@@ -0,0 +1,62 @@
+struct S(u8, (u8, u8));
+
+fn main() {
+ let s = S(0, (0, 0));
+
+ s.1e1; //~ ERROR no field `1e1` on type `S`
+ s.1.; //~ ERROR unexpected token: `;`
+ s.1.1;
+ s.1.1e1; //~ ERROR no field `1e1` on type `(u8, u8)`
+ { s.1e+; } //~ ERROR unexpected token: `1e+`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+`
+ //~| ERROR expected at least one digit in exponent
+ { s.1e-; } //~ ERROR unexpected token: `1e-`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-`
+ //~| ERROR expected at least one digit in exponent
+ { s.1e+1; } //~ ERROR unexpected token: `1e+1`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+1`
+ { s.1e-1; } //~ ERROR unexpected token: `1e-1`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-1`
+ { s.1.1e+1; } //~ ERROR unexpected token: `1.1e+1`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e+1`
+ { s.1.1e-1; } //~ ERROR unexpected token: `1.1e-1`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e-1`
+ s.0x1e1; //~ ERROR no field `0x1e1` on type `S`
+ s.0x1.; //~ ERROR no field `0x1` on type `S`
+ //~| ERROR hexadecimal float literal is not supported
+ //~| ERROR unexpected token: `;`
+ s.0x1.1; //~ ERROR no field `0x1` on type `S`
+ //~| ERROR hexadecimal float literal is not supported
+ s.0x1.1e1; //~ ERROR no field `0x1` on type `S`
+ //~| ERROR hexadecimal float literal is not supported
+ { s.0x1e+; } //~ ERROR expected expression, found `;`
+ { s.0x1e-; } //~ ERROR expected expression, found `;`
+ s.0x1e+1; //~ ERROR no field `0x1e` on type `S`
+ s.0x1e-1; //~ ERROR no field `0x1e` on type `S`
+ { s.0x1.1e+1; } //~ ERROR unexpected token: `0x1.1e+1`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `0x1.1e+1`
+ //~| ERROR hexadecimal float literal is not supported
+ { s.0x1.1e-1; } //~ ERROR unexpected token: `0x1.1e-1`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `0x1.1e-1`
+ //~| ERROR hexadecimal float literal is not supported
+ s.1e1f32; //~ ERROR no field `1e1` on type `S`
+ //~| ERROR suffixes on a tuple index are invalid
+ s.1.f32; //~ ERROR no field `f32` on type `(u8, u8)`
+ s.1.1f32; //~ ERROR suffixes on a tuple index are invalid
+ s.1.1e1f32; //~ ERROR no field `1e1` on type `(u8, u8)`
+ //~| ERROR suffixes on a tuple index are invalid
+ { s.1e+f32; } //~ ERROR unexpected token: `1e+f32`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+f32`
+ //~| ERROR expected at least one digit in exponent
+ { s.1e-f32; } //~ ERROR unexpected token: `1e-f32`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-f32`
+ //~| ERROR expected at least one digit in exponent
+ { s.1e+1f32; } //~ ERROR unexpected token: `1e+1f32`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+1f32`
+ { s.1e-1f32; } //~ ERROR unexpected token: `1e-1f32`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-1f32`
+ { s.1.1e+1f32; } //~ ERROR unexpected token: `1.1e+1f32`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e+1f32`
+ { s.1.1e-1f32; } //~ ERROR unexpected token: `1.1e-1f32`
+ //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e-1f32`
+}
diff --git a/src/test/ui/parser/float-field.stderr b/src/test/ui/parser/float-field.stderr
new file mode 100644
index 0000000..62202b9
--- /dev/null
+++ b/src/test/ui/parser/float-field.stderr
@@ -0,0 +1,349 @@
+error: expected at least one digit in exponent
+ --> $DIR/float-field.rs:10:9
+ |
+LL | { s.1e+; }
+ | ^^^
+
+error: expected at least one digit in exponent
+ --> $DIR/float-field.rs:13:9
+ |
+LL | { s.1e-; }
+ | ^^^
+
+error: hexadecimal float literal is not supported
+ --> $DIR/float-field.rs:25:7
+ |
+LL | s.0x1.;
+ | ^^^^
+
+error: hexadecimal float literal is not supported
+ --> $DIR/float-field.rs:28:7
+ |
+LL | s.0x1.1;
+ | ^^^^^
+
+error: hexadecimal float literal is not supported
+ --> $DIR/float-field.rs:30:7
+ |
+LL | s.0x1.1e1;
+ | ^^^^^^^
+
+error: hexadecimal float literal is not supported
+ --> $DIR/float-field.rs:36:9
+ |
+LL | { s.0x1.1e+1; }
+ | ^^^^^^^^
+
+error: hexadecimal float literal is not supported
+ --> $DIR/float-field.rs:39:9
+ |
+LL | { s.0x1.1e-1; }
+ | ^^^^^^^^
+
+error: expected at least one digit in exponent
+ --> $DIR/float-field.rs:48:9
+ |
+LL | { s.1e+f32; }
+ | ^^^^^^
+
+error: expected at least one digit in exponent
+ --> $DIR/float-field.rs:51:9
+ |
+LL | { s.1e-f32; }
+ | ^^^^^^
+
+error: unexpected token: `;`
+ --> $DIR/float-field.rs:7:9
+ |
+LL | s.1.;
+ | ^
+
+error: unexpected token: `1e+`
+ --> $DIR/float-field.rs:10:9
+ |
+LL | { s.1e+; }
+ | ^^^
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+`
+ --> $DIR/float-field.rs:10:9
+ |
+LL | { s.1e+; }
+ | ^^^ expected one of `.`, `;`, `?`, `}`, or an operator
+
+error: unexpected token: `1e-`
+ --> $DIR/float-field.rs:13:9
+ |
+LL | { s.1e-; }
+ | ^^^
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-`
+ --> $DIR/float-field.rs:13:9
+ |
+LL | { s.1e-; }
+ | ^^^ expected one of `.`, `;`, `?`, `}`, or an operator
+
+error: unexpected token: `1e+1`
+ --> $DIR/float-field.rs:16:9
+ |
+LL | { s.1e+1; }
+ | ^^^^
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+1`
+ --> $DIR/float-field.rs:16:9
+ |
+LL | { s.1e+1; }
+ | ^^^^ expected one of `.`, `;`, `?`, `}`, or an operator
+
+error: unexpected token: `1e-1`
+ --> $DIR/float-field.rs:18:9
+ |
+LL | { s.1e-1; }
+ | ^^^^
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-1`
+ --> $DIR/float-field.rs:18:9
+ |
+LL | { s.1e-1; }
+ | ^^^^ expected one of `.`, `;`, `?`, `}`, or an operator
+
+error: unexpected token: `1.1e+1`
+ --> $DIR/float-field.rs:20:9
+ |
+LL | { s.1.1e+1; }
+ | ^^^^^^
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e+1`
+ --> $DIR/float-field.rs:20:9
+ |
+LL | { s.1.1e+1; }
+ | ^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator
+
+error: unexpected token: `1.1e-1`
+ --> $DIR/float-field.rs:22:9
+ |
+LL | { s.1.1e-1; }
+ | ^^^^^^
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e-1`
+ --> $DIR/float-field.rs:22:9
+ |
+LL | { s.1.1e-1; }
+ | ^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator
+
+error: unexpected token: `;`
+ --> $DIR/float-field.rs:25:11
+ |
+LL | s.0x1.;
+ | ^
+
+error: expected expression, found `;`
+ --> $DIR/float-field.rs:32:14
+ |
+LL | { s.0x1e+; }
+ | ^ expected expression
+
+error: expected expression, found `;`
+ --> $DIR/float-field.rs:33:14
+ |
+LL | { s.0x1e-; }
+ | ^ expected expression
+
+error: unexpected token: `0x1.1e+1`
+ --> $DIR/float-field.rs:36:9
+ |
+LL | { s.0x1.1e+1; }
+ | ^^^^^^^^
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `0x1.1e+1`
+ --> $DIR/float-field.rs:36:9
+ |
+LL | { s.0x1.1e+1; }
+ | ^^^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator
+
+error: unexpected token: `0x1.1e-1`
+ --> $DIR/float-field.rs:39:9
+ |
+LL | { s.0x1.1e-1; }
+ | ^^^^^^^^
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `0x1.1e-1`
+ --> $DIR/float-field.rs:39:9
+ |
+LL | { s.0x1.1e-1; }
+ | ^^^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator
+
+error: suffixes on a tuple index are invalid
+ --> $DIR/float-field.rs:42:7
+ |
+LL | s.1e1f32;
+ | ^^^^^^ invalid suffix `f32`
+
+error: suffixes on a tuple index are invalid
+ --> $DIR/float-field.rs:45:7
+ |
+LL | s.1.1f32;
+ | ^^^^^^ invalid suffix `f32`
+
+error: suffixes on a tuple index are invalid
+ --> $DIR/float-field.rs:46:7
+ |
+LL | s.1.1e1f32;
+ | ^^^^^^^^ invalid suffix `f32`
+
+error: unexpected token: `1e+f32`
+ --> $DIR/float-field.rs:48:9
+ |
+LL | { s.1e+f32; }
+ | ^^^^^^
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+f32`
+ --> $DIR/float-field.rs:48:9
+ |
+LL | { s.1e+f32; }
+ | ^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator
+
+error: unexpected token: `1e-f32`
+ --> $DIR/float-field.rs:51:9
+ |
+LL | { s.1e-f32; }
+ | ^^^^^^
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-f32`
+ --> $DIR/float-field.rs:51:9
+ |
+LL | { s.1e-f32; }
+ | ^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator
+
+error: unexpected token: `1e+1f32`
+ --> $DIR/float-field.rs:54:9
+ |
+LL | { s.1e+1f32; }
+ | ^^^^^^^
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+1f32`
+ --> $DIR/float-field.rs:54:9
+ |
+LL | { s.1e+1f32; }
+ | ^^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator
+
+error: unexpected token: `1e-1f32`
+ --> $DIR/float-field.rs:56:9
+ |
+LL | { s.1e-1f32; }
+ | ^^^^^^^
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-1f32`
+ --> $DIR/float-field.rs:56:9
+ |
+LL | { s.1e-1f32; }
+ | ^^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator
+
+error: unexpected token: `1.1e+1f32`
+ --> $DIR/float-field.rs:58:9
+ |
+LL | { s.1.1e+1f32; }
+ | ^^^^^^^^^
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e+1f32`
+ --> $DIR/float-field.rs:58:9
+ |
+LL | { s.1.1e+1f32; }
+ | ^^^^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator
+
+error: unexpected token: `1.1e-1f32`
+ --> $DIR/float-field.rs:60:9
+ |
+LL | { s.1.1e-1f32; }
+ | ^^^^^^^^^
+
+error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e-1f32`
+ --> $DIR/float-field.rs:60:9
+ |
+LL | { s.1.1e-1f32; }
+ | ^^^^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator
+
+error[E0609]: no field `1e1` on type `S`
+ --> $DIR/float-field.rs:6:7
+ |
+LL | s.1e1;
+ | ^^^ unknown field
+ |
+ = note: available fields are: `0`, `1`
+
+error[E0609]: no field `1e1` on type `(u8, u8)`
+ --> $DIR/float-field.rs:9:7
+ |
+LL | s.1.1e1;
+ | ^^^^^
+
+error[E0609]: no field `0x1e1` on type `S`
+ --> $DIR/float-field.rs:24:7
+ |
+LL | s.0x1e1;
+ | ^^^^^ unknown field
+ |
+ = note: available fields are: `0`, `1`
+
+error[E0609]: no field `0x1` on type `S`
+ --> $DIR/float-field.rs:25:7
+ |
+LL | s.0x1.;
+ | ^^^^ unknown field
+ |
+ = note: available fields are: `0`, `1`
+
+error[E0609]: no field `0x1` on type `S`
+ --> $DIR/float-field.rs:28:7
+ |
+LL | s.0x1.1;
+ | ^^^^^ unknown field
+ |
+ = note: available fields are: `0`, `1`
+
+error[E0609]: no field `0x1` on type `S`
+ --> $DIR/float-field.rs:30:7
+ |
+LL | s.0x1.1e1;
+ | ^^^^^^^ unknown field
+ |
+ = note: available fields are: `0`, `1`
+
+error[E0609]: no field `0x1e` on type `S`
+ --> $DIR/float-field.rs:34:7
+ |
+LL | s.0x1e+1;
+ | ^^^^ unknown field
+ |
+ = note: available fields are: `0`, `1`
+
+error[E0609]: no field `0x1e` on type `S`
+ --> $DIR/float-field.rs:35:7
+ |
+LL | s.0x1e-1;
+ | ^^^^ unknown field
+ |
+ = note: available fields are: `0`, `1`
+
+error[E0609]: no field `1e1` on type `S`
+ --> $DIR/float-field.rs:42:7
+ |
+LL | s.1e1f32;
+ | ^^^^^^ unknown field
+ |
+ = note: available fields are: `0`, `1`
+
+error[E0609]: no field `f32` on type `(u8, u8)`
+ --> $DIR/float-field.rs:44:9
+ |
+LL | s.1.f32;
+ | ^^^
+
+error[E0609]: no field `1e1` on type `(u8, u8)`
+ --> $DIR/float-field.rs:46:7
+ |
+LL | s.1.1e1f32;
+ | ^^^^^^^^
+
+error: aborting due to 55 previous errors
+
+For more information about this error, try `rustc --explain E0609`.
diff --git a/src/test/ui/parser/issue-35813-postfix-after-cast.stderr b/src/test/ui/parser/issue-35813-postfix-after-cast.stderr
index 255e9f4..9ccf17a 100644
--- a/src/test/ui/parser/issue-35813-postfix-after-cast.stderr
+++ b/src/test/ui/parser/issue-35813-postfix-after-cast.stderr
@@ -280,12 +280,12 @@
--> $DIR/issue-35813-postfix-after-cast.rs:121:5
|
LL | Err(0u64): Result<u64,u64>?;
- | ^^^^^^^^^-^^^^^^^^^^^^^^^^
- | |
- | help: maybe write a path separator here: `::`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
- = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
+help: try surrounding the expression in parentheses
+ |
+LL | (Err(0u64): Result<u64,u64>)?;
+ | ^ ^
error: casts cannot be followed by a function call
--> $DIR/issue-35813-postfix-after-cast.rs:145:5
@@ -324,12 +324,12 @@
--> $DIR/issue-35813-postfix-after-cast.rs:155:5
|
LL | Box::pin(noop()): Pin<Box<_>>.await;
- | ^^^^^^^^^^^^^^^^-^^^^^^^^^^^^
- | |
- | help: maybe write a path separator here: `::`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
- = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
+help: try surrounding the expression in parentheses
+ |
+LL | (Box::pin(noop()): Pin<Box<_>>).await;
+ | ^ ^
error: casts cannot be followed by a field access
--> $DIR/issue-35813-postfix-after-cast.rs:167:5
diff --git a/src/test/ui/rfc-2126-extern-absolute-paths/meta.rs b/src/test/ui/rfc-2126-extern-absolute-paths/meta.rs
index b3b9aeb..1fb5878 100644
--- a/src/test/ui/rfc-2126-extern-absolute-paths/meta.rs
+++ b/src/test/ui/rfc-2126-extern-absolute-paths/meta.rs
@@ -1,7 +1,7 @@
// edition:2018
-// Tests that `meta` is whitelisted, even if the crate doesn't exist
-// yet (i.e., it causes a different error than `not-whitelisted.rs`).
+// Tests that `meta` is allowed, even if the crate doesn't exist
+// yet (i.e., it causes a different error than `not-allowed.rs`).
use meta; //~ ERROR can't find crate for `meta`
fn main() {}
diff --git a/src/test/ui/rfc-2126-extern-absolute-paths/not-whitelisted.rs b/src/test/ui/rfc-2126-extern-absolute-paths/not-allowed.rs
similarity index 100%
rename from src/test/ui/rfc-2126-extern-absolute-paths/not-whitelisted.rs
rename to src/test/ui/rfc-2126-extern-absolute-paths/not-allowed.rs
diff --git a/src/test/ui/rfc-2126-extern-absolute-paths/not-whitelisted.stderr b/src/test/ui/rfc-2126-extern-absolute-paths/not-allowed.stderr
similarity index 85%
rename from src/test/ui/rfc-2126-extern-absolute-paths/not-whitelisted.stderr
rename to src/test/ui/rfc-2126-extern-absolute-paths/not-allowed.stderr
index f324378..6d2b450 100644
--- a/src/test/ui/rfc-2126-extern-absolute-paths/not-whitelisted.stderr
+++ b/src/test/ui/rfc-2126-extern-absolute-paths/not-allowed.stderr
@@ -1,5 +1,5 @@
error[E0432]: unresolved import `alloc`
- --> $DIR/not-whitelisted.rs:5:5
+ --> $DIR/not-allowed.rs:5:5
|
LL | use alloc;
| ^^^^^ no `alloc` external crate
diff --git a/src/test/ui/sse2.rs b/src/test/ui/sse2.rs
index 74f1124..7726972 100644
--- a/src/test/ui/sse2.rs
+++ b/src/test/ui/sse2.rs
@@ -20,7 +20,7 @@
assert!(cfg!(target_feature = "sse2"),
"SSE2 was not detected as available on an x86 platform");
}
- // check a negative case too -- whitelisted on x86, but not enabled by default
+ // check a negative case too -- allowed on x86, but not enabled by default
assert!(cfg!(not(target_feature = "avx2")),
"AVX2 shouldn't be detected as available by default on any platform");
}
diff --git a/src/test/ui/suggestions/type-ascription-instead-of-method.stderr b/src/test/ui/suggestions/type-ascription-instead-of-method.stderr
index 998129e..c111b4a 100644
--- a/src/test/ui/suggestions/type-ascription-instead-of-method.stderr
+++ b/src/test/ui/suggestions/type-ascription-instead-of-method.stderr
@@ -7,7 +7,6 @@
| help: maybe write a path separator here: `::`
|
= note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
- = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
error: aborting due to previous error
diff --git a/src/test/ui/suggestions/type-ascription-instead-of-path-2.stderr b/src/test/ui/suggestions/type-ascription-instead-of-path-2.stderr
index 0dd1494..1d1999d 100644
--- a/src/test/ui/suggestions/type-ascription-instead-of-path-2.stderr
+++ b/src/test/ui/suggestions/type-ascription-instead-of-path-2.stderr
@@ -7,7 +7,6 @@
| help: maybe write a path separator here: `::`
|
= note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
- = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
error: aborting due to previous error
diff --git a/src/test/ui/suggestions/type-ascription-instead-of-variant.stderr b/src/test/ui/suggestions/type-ascription-instead-of-variant.stderr
index 5b40e16..f38020d 100644
--- a/src/test/ui/suggestions/type-ascription-instead-of-variant.stderr
+++ b/src/test/ui/suggestions/type-ascription-instead-of-variant.stderr
@@ -7,7 +7,6 @@
| help: maybe write a path separator here: `::`
|
= note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
- = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
error: aborting due to previous error
diff --git a/src/test/ui/tuple/index-float.rs b/src/test/ui/tuple/index-float.rs
new file mode 100644
index 0000000..eda2bf4
--- /dev/null
+++ b/src/test/ui/tuple/index-float.rs
@@ -0,0 +1,10 @@
+// check-pass
+
+fn main() {
+ let tuple = (((),),);
+
+ let _ = tuple. 0.0; // OK, whitespace
+ let _ = tuple.0. 0; // OK, whitespace
+
+ let _ = tuple./*special cases*/0.0; // OK, comment
+}
diff --git a/src/test/ui/tuple/index-invalid.rs b/src/test/ui/tuple/index-invalid.rs
new file mode 100644
index 0000000..d36f6cf
--- /dev/null
+++ b/src/test/ui/tuple/index-invalid.rs
@@ -0,0 +1,7 @@
+fn main() {
+ let _ = (((),),).1.0; //~ ERROR no field `1` on type `(((),),)`
+
+ let _ = (((),),).0.1; //~ ERROR no field `1` on type `((),)`
+
+ let _ = (((),),).000.000; //~ ERROR no field `000` on type `(((),),)`
+}
diff --git a/src/test/ui/tuple/index-invalid.stderr b/src/test/ui/tuple/index-invalid.stderr
new file mode 100644
index 0000000..800b5a3
--- /dev/null
+++ b/src/test/ui/tuple/index-invalid.stderr
@@ -0,0 +1,21 @@
+error[E0609]: no field `1` on type `(((),),)`
+ --> $DIR/index-invalid.rs:2:22
+ |
+LL | let _ = (((),),).1.0;
+ | ^^^
+
+error[E0609]: no field `1` on type `((),)`
+ --> $DIR/index-invalid.rs:4:22
+ |
+LL | let _ = (((),),).0.1;
+ | ^^^
+
+error[E0609]: no field `000` on type `(((),),)`
+ --> $DIR/index-invalid.rs:6:22
+ |
+LL | let _ = (((),),).000.000;
+ | ^^^^^^^
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0609`.
diff --git a/src/test/ui/tuple/indexing-in-macro.rs b/src/test/ui/tuple/indexing-in-macro.rs
new file mode 100644
index 0000000..bef4a69
--- /dev/null
+++ b/src/test/ui/tuple/indexing-in-macro.rs
@@ -0,0 +1,9 @@
+// check-pass
+
+macro_rules! m {
+ (.$l:literal) => {};
+}
+
+m!(.0.0); // OK, `0.0` after a dot is still a float token.
+
+fn main() {}
diff --git a/src/test/ui/tuple/nested-index.rs b/src/test/ui/tuple/nested-index.rs
new file mode 100644
index 0000000..a3232d6
--- /dev/null
+++ b/src/test/ui/tuple/nested-index.rs
@@ -0,0 +1,12 @@
+// run-pass
+
+fn main () {
+ let n = (1, (2, 3)).1.1;
+ assert_eq!(n, 3);
+
+ let n = (1, (2, (3, 4))).1.1.1;
+ assert_eq!(n, 4);
+
+ // This is a range expression, not nested indexing.
+ let _ = 0.0..1.1;
+}
diff --git a/src/test/ui/tuple/tuple-float-index.fixed b/src/test/ui/tuple/tuple-float-index.fixed
deleted file mode 100644
index cd1a85a..0000000
--- a/src/test/ui/tuple/tuple-float-index.fixed
+++ /dev/null
@@ -1,5 +0,0 @@
-// run-rustfix
-
-fn main () {
- ((1, (2, 3)).1).1; //~ ERROR unexpected token: `1.1`
-}
diff --git a/src/test/ui/tuple/tuple-float-index.rs b/src/test/ui/tuple/tuple-float-index.rs
deleted file mode 100644
index 1faabac..0000000
--- a/src/test/ui/tuple/tuple-float-index.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-// run-rustfix
-
-fn main () {
- (1, (2, 3)).1.1; //~ ERROR unexpected token: `1.1`
-}
diff --git a/src/test/ui/tuple/tuple-float-index.stderr b/src/test/ui/tuple/tuple-float-index.stderr
deleted file mode 100644
index a0ea0e0..0000000
--- a/src/test/ui/tuple/tuple-float-index.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error: unexpected token: `1.1`
- --> $DIR/tuple-float-index.rs:4:17
- |
-LL | (1, (2, 3)).1.1;
- | ------------^^^
- | | |
- | | unexpected token
- | help: try parenthesizing the first index: `((1, (2, 3)).1).1`
-
-error: aborting due to previous error
-
diff --git a/src/test/ui/type/ascription/issue-47666.stderr b/src/test/ui/type/ascription/issue-47666.stderr
index 3cd3be7..72c7c14 100644
--- a/src/test/ui/type/ascription/issue-47666.stderr
+++ b/src/test/ui/type/ascription/issue-47666.stderr
@@ -10,7 +10,6 @@
| help: maybe write a path separator here: `::`
|
= note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
- = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0423]: expected value, found enum `Option`
diff --git a/src/test/ui/type/ascription/issue-54516.stderr b/src/test/ui/type/ascription/issue-54516.stderr
index fdf3570..ec08cf2 100644
--- a/src/test/ui/type/ascription/issue-54516.stderr
+++ b/src/test/ui/type/ascription/issue-54516.stderr
@@ -7,7 +7,6 @@
| help: maybe write a path separator here: `::`
|
= note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
- = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
error[E0423]: expected value, found module `std::mem`
--> $DIR/issue-54516.rs:4:20
diff --git a/src/test/ui/type/ascription/issue-60933.stderr b/src/test/ui/type/ascription/issue-60933.stderr
index cd9ae8f..2006362 100644
--- a/src/test/ui/type/ascription/issue-60933.stderr
+++ b/src/test/ui/type/ascription/issue-60933.stderr
@@ -7,7 +7,6 @@
| help: maybe write a path separator here: `::`
|
= note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
- = note: see issue #23416 <https://github.com/rust-lang/rust/issues/23416> for more information
error[E0423]: expected value, found module `std::mem`
--> $DIR/issue-60933.rs:2:20
diff --git a/src/tools/cargo b/src/tools/cargo
index fede83c..4f74d9b 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit fede83ccf973457de319ba6fa0e36ead454d2e20
+Subproject commit 4f74d9b2a771c58b7ef4906b2668afd075bc8081
diff --git a/src/tools/clippy/clippy_lints/src/attrs.rs b/src/tools/clippy/clippy_lints/src/attrs.rs
index 2505ff3..3f7d6ba 100644
--- a/src/tools/clippy/clippy_lints/src/attrs.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs.rs
@@ -72,7 +72,7 @@
/// **What it does:** Checks for `extern crate` and `use` items annotated with
/// lint attributes.
///
- /// This lint whitelists `#[allow(unused_imports)]`, `#[allow(deprecated)]` and
+ /// This lint permits `#[allow(unused_imports)]`, `#[allow(deprecated)]` and
/// `#[allow(unreachable_pub)]` on `use` items and `#[allow(unused_imports)]` on
/// `extern crate` items with a `#[macro_use]` attribute.
///
@@ -294,7 +294,7 @@
if let Some(ident) = attr.ident() {
match &*ident.as_str() {
"allow" | "warn" | "deny" | "forbid" => {
- // whitelist `unused_imports`, `deprecated` and `unreachable_pub` for `use` items
+ // permit `unused_imports`, `deprecated` and `unreachable_pub` for `use` items
// and `unused_imports` for `extern crate` items with `macro_use`
for lint in lint_list {
match item.kind {
diff --git a/src/tools/clippy/clippy_lints/src/eq_op.rs b/src/tools/clippy/clippy_lints/src/eq_op.rs
index ca921dc..cbc93d7 100644
--- a/src/tools/clippy/clippy_lints/src/eq_op.rs
+++ b/src/tools/clippy/clippy_lints/src/eq_op.rs
@@ -16,7 +16,7 @@
/// **Known problems:** False negatives: We had some false positives regarding
/// calls (notably [racer](https://github.com/phildawes/racer) had one instance
/// of `x.pop() && x.pop()`), so we removed matching any function or method
- /// calls. We may introduce a whitelist of known pure functions in the future.
+ /// calls. We may introduce a list of known pure functions in the future.
///
/// **Example:**
/// ```rust
diff --git a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
index 5d47f94..29e5d4d 100644
--- a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
@@ -100,7 +100,7 @@
// Allow `Borrow` or functions to be taken by value
let borrow_trait = need!(get_trait_def_id(cx, &paths::BORROW_TRAIT));
- let whitelisted_traits = [
+ let allowed_traits = [
need!(cx.tcx.lang_items().fn_trait()),
need!(cx.tcx.lang_items().fn_once_trait()),
need!(cx.tcx.lang_items().fn_mut_trait()),
@@ -184,7 +184,7 @@
if !is_self(arg);
if !ty.is_mutable_ptr();
if !is_copy(cx, ty);
- if !whitelisted_traits.iter().any(|&t| implements_trait(cx, ty, t, &[]));
+ if !allowed_traits.iter().any(|&t| implements_trait(cx, ty, t, &[]));
if !implements_borrow_trait;
if !all_borrowable_trait;
diff --git a/src/tools/clippy/clippy_lints/src/non_expressive_names.rs b/src/tools/clippy/clippy_lints/src/non_expressive_names.rs
index 5f14fe9..7128fee 100644
--- a/src/tools/clippy/clippy_lints/src/non_expressive_names.rs
+++ b/src/tools/clippy/clippy_lints/src/non_expressive_names.rs
@@ -78,7 +78,7 @@
interned: SymbolStr,
span: Span,
len: usize,
- whitelist: &'static [&'static str],
+ exemptions: &'static [&'static str],
}
struct SimilarNamesLocalVisitor<'a, 'tcx> {
@@ -117,7 +117,7 @@
// this list contains lists of names that are allowed to be similar
// the assumption is that no name is ever contained in multiple lists.
#[rustfmt::skip]
-const WHITELIST: &[&[&str]] = &[
+const ALLOWED_TO_BE_SIMILAR: &[&[&str]] = &[
&["parsed", "parser"],
&["lhs", "rhs"],
&["tx", "rx"],
@@ -156,17 +156,17 @@
}
#[must_use]
-fn get_whitelist(interned_name: &str) -> Option<&'static [&'static str]> {
- for &allow in WHITELIST {
- if whitelisted(interned_name, allow) {
- return Some(allow);
+fn get_exemptions(interned_name: &str) -> Option<&'static [&'static str]> {
+ for &list in ALLOWED_TO_BE_SIMILAR {
+ if allowed_to_be_similar(interned_name, list) {
+ return Some(list);
}
}
None
}
#[must_use]
-fn whitelisted(interned_name: &str, list: &[&str]) -> bool {
+fn allowed_to_be_similar(interned_name: &str, list: &[&str]) -> bool {
list.iter()
.any(|&name| interned_name.starts_with(name) || interned_name.ends_with(name))
}
@@ -212,7 +212,7 @@
return;
}
for existing_name in &self.0.names {
- if whitelisted(&interned_name, existing_name.whitelist) {
+ if allowed_to_be_similar(&interned_name, existing_name.exemptions) {
continue;
}
let mut split_at = None;
@@ -301,7 +301,7 @@
return;
}
self.0.names.push(ExistingName {
- whitelist: get_whitelist(&interned_name).unwrap_or(&[]),
+ exemptions: get_exemptions(&interned_name).unwrap_or(&[]),
interned: interned_name,
span: ident.span,
len: count,
diff --git a/src/tools/clippy/clippy_lints/src/precedence.rs b/src/tools/clippy/clippy_lints/src/precedence.rs
index 7dce23d..2379367 100644
--- a/src/tools/clippy/clippy_lints/src/precedence.rs
+++ b/src/tools/clippy/clippy_lints/src/precedence.rs
@@ -5,7 +5,7 @@
use rustc_session::{declare_lint_pass, declare_tool_lint};
use rustc_span::source_map::Spanned;
-const ODD_FUNCTIONS_WHITELIST: [&str; 14] = [
+const ALLOWED_ODD_FUNCTIONS: [&str; 14] = [
"asin",
"asinh",
"atan",
@@ -109,7 +109,7 @@
if let ExprKind::Lit(ref lit) = slf.kind {
match lit.kind {
LitKind::Int(..) | LitKind::Float(..) => {
- if ODD_FUNCTIONS_WHITELIST
+ if ALLOWED_ODD_FUNCTIONS
.iter()
.any(|odd_function| **odd_function == *path_segment_str)
{
diff --git a/src/tools/clippy/clippy_lints/src/types.rs b/src/tools/clippy/clippy_lints/src/types.rs
index b1345f0..68f51f0 100644
--- a/src/tools/clippy/clippy_lints/src/types.rs
+++ b/src/tools/clippy/clippy_lints/src/types.rs
@@ -1256,7 +1256,7 @@
// don't lint for the result of methods that always return non-negative values
if let ExprKind::MethodCall(ref path, _, _, _) = op.kind {
let mut method_name = path.ident.name.as_str();
- let whitelisted_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"];
+ let allowed_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"];
if_chain! {
if method_name == "unwrap";
@@ -1267,7 +1267,7 @@
}
}
- if whitelisted_methods.iter().any(|&name| method_name == name) {
+ if allowed_methods.iter().any(|&name| method_name == name) {
return;
}
}
diff --git a/src/tools/clippy/tests/ui/crashes/whitelist/clippy.toml b/src/tools/clippy/tests/ui/crashes/third-party/clippy.toml
similarity index 100%
rename from src/tools/clippy/tests/ui/crashes/whitelist/clippy.toml
rename to src/tools/clippy/tests/ui/crashes/third-party/clippy.toml
diff --git a/src/tools/clippy/tests/ui/crashes/whitelist/conf_whitelisted.rs b/src/tools/clippy/tests/ui/crashes/third-party/conf_allowlisted.rs
similarity index 100%
rename from src/tools/clippy/tests/ui/crashes/whitelist/conf_whitelisted.rs
rename to src/tools/clippy/tests/ui/crashes/third-party/conf_allowlisted.rs
diff --git a/src/tools/clippy/tests/ui/needless_pass_by_value.rs b/src/tools/clippy/tests/ui/needless_pass_by_value.rs
index e93a7fe..7a9ba55 100644
--- a/src/tools/clippy/tests/ui/needless_pass_by_value.rs
+++ b/src/tools/clippy/tests/ui/needless_pass_by_value.rs
@@ -116,7 +116,7 @@
unsafe { x.assume_init() }
}
-// whitelist RangeArgument
+// exempt RangeArgument
fn range<T: ::std::ops::RangeBounds<usize>>(range: T) {
let _ = range.start_bound();
}
diff --git a/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs b/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs
index ca70e3b..0b47119 100644
--- a/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs
+++ b/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs
@@ -57,6 +57,6 @@
// The macro always negates the result of the given comparison in its
// internal check which automatically triggered the lint. As it's an
// external macro there was no chance to do anything about it which led
- // to a whitelisting of all external macros.
+ // to an exempting of all external macros.
assert!(a_value < another_value);
}
diff --git a/src/tools/compiletest/src/main.rs b/src/tools/compiletest/src/main.rs
index 2aea4d2..97272f1 100644
--- a/src/tools/compiletest/src/main.rs
+++ b/src/tools/compiletest/src/main.rs
@@ -401,7 +401,7 @@
}
if let Some(lldb_version) = config.lldb_version.as_ref() {
- if is_blacklisted_lldb_version(&lldb_version) {
+ if lldb_version == "350" {
println!(
"WARNING: The used version of LLDB ({}) has a \
known issue that breaks debuginfo tests. See \
@@ -979,7 +979,3 @@
}
(None, false)
}
-
-fn is_blacklisted_lldb_version(version: &str) -> bool {
- version == "350"
-}
diff --git a/src/tools/error_index_generator/main.rs b/src/tools/error_index_generator/main.rs
index 097fb1f..9aea859 100644
--- a/src/tools/error_index_generator/main.rs
+++ b/src/tools/error_index_generator/main.rs
@@ -284,7 +284,7 @@
fn main() {
env_logger::init();
let (format, dst) = parse_args();
- let result = rustc_ast::with_default_globals(move || main_with_result(format, &dst));
+ let result = rustc_ast::with_default_session_globals(move || main_with_result(format, &dst));
if let Err(e) = result {
panic!("{}", e.to_string());
}
diff --git a/src/tools/linkchecker/main.rs b/src/tools/linkchecker/main.rs
index 9e4e2c4..74601f9 100644
--- a/src/tools/linkchecker/main.rs
+++ b/src/tools/linkchecker/main.rs
@@ -11,8 +11,8 @@
//! These values are then translated to file URLs if possible and then the
//! destination is asserted to exist.
//!
-//! A few whitelisted exceptions are allowed as there's known bugs in rustdoc,
-//! but this should catch the majority of "broken link" cases.
+//! A few exceptions are allowed as there's known bugs in rustdoc, but this
+//! should catch the majority of "broken link" cases.
use std::collections::hash_map::Entry;
use std::collections::{HashMap, HashSet};
@@ -118,7 +118,7 @@
}
// Unfortunately we're not 100% full of valid links today to we need a few
- // whitelists to get this past `make check` today.
+ // exceptions to get this past `make check` today.
// FIXME(#32129)
if file.ends_with("std/io/struct.IoSlice.html")
|| file.ends_with("std/string/struct.String.html")
diff --git a/src/tools/miri b/src/tools/miri
index fd81012..eb5ff17 160000
--- a/src/tools/miri
+++ b/src/tools/miri
@@ -1 +1 @@
-Subproject commit fd8101247749c5be6850d5cb5096f01a1867e5ba
+Subproject commit eb5ff1791be706d173b4f4c29e9c0529b4235c0e
diff --git a/src/tools/rust-analyzer b/src/tools/rust-analyzer
index f5a4a4b..8b0983e 160000
--- a/src/tools/rust-analyzer
+++ b/src/tools/rust-analyzer
@@ -1 +1 @@
-Subproject commit f5a4a4b46e706697abe4bd136503ecc09aa23b61
+Subproject commit 8b0983e89ad9a28b142eccf3755a8c9aaeb37852
diff --git a/src/tools/rust-installer b/src/tools/rust-installer
index 9f66c14..d66f476 160000
--- a/src/tools/rust-installer
+++ b/src/tools/rust-installer
@@ -1 +1 @@
-Subproject commit 9f66c14c3f91a48a118c7817f434167b311c3515
+Subproject commit d66f476b4d5e7fdf1ec215c9ac16c923dc292324
diff --git a/src/tools/tidy/src/cargo.rs b/src/tools/tidy/src/cargo.rs
index 7c45efb..7bdd78a 100644
--- a/src/tools/tidy/src/cargo.rs
+++ b/src/tools/tidy/src/cargo.rs
@@ -73,8 +73,8 @@
// This is intentional -- this dependency just makes the crate available
// for others later on.
- let whitelisted = krate.starts_with("panic");
- if toml.contains("name = \"std\"") && whitelisted {
+ let allowed = krate.starts_with("panic");
+ if toml.contains("name = \"std\"") && allowed {
continue;
}
diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 4622e15..b7d3d42 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -49,14 +49,14 @@
/// these and all their dependencies *must not* be in the exception list.
const RUNTIME_CRATES: &[&str] = &["std", "core", "alloc", "test", "panic_abort", "panic_unwind"];
-/// Which crates to check against the whitelist?
-const WHITELIST_CRATES: &[&str] = &["rustc_middle", "rustc_codegen_llvm"];
+/// Crates whose dependencies must be explicitly permitted.
+const RESTRICTED_DEPENDENCY_CRATES: &[&str] = &["rustc_middle", "rustc_codegen_llvm"];
-/// Whitelist of crates rustc is allowed to depend on. Avoid adding to the list if possible.
+/// Crates rustc is allowed to depend on. Avoid adding to the list if possible.
///
/// This list is here to provide a speed-bump to adding a new dependency to
/// rustc. Please check with the compiler team before adding an entry.
-const WHITELIST: &[&str] = &[
+const PERMITTED_DEPENDENCIES: &[&str] = &[
"adler32",
"aho-corasick",
"annotate-snippets",
@@ -190,7 +190,7 @@
.features(cargo_metadata::CargoOpt::AllFeatures);
let metadata = t!(cmd.exec());
check_exceptions(&metadata, bad);
- check_whitelist(&metadata, bad);
+ check_dependencies(&metadata, bad);
check_crate_duplicate(&metadata, bad);
}
@@ -272,36 +272,37 @@
}
}
-/// Checks the dependency of `WHITELIST_CRATES` at the given path. Changes `bad` to `true` if a
-/// check failed.
+/// Checks the dependency of `RESTRICTED_DEPENDENCY_CRATES` at the given path. Changes `bad` to
+/// `true` if a check failed.
///
-/// Specifically, this checks that the dependencies are on the `WHITELIST`.
-fn check_whitelist(metadata: &Metadata, bad: &mut bool) {
- // Check that the WHITELIST does not have unused entries.
- for name in WHITELIST {
+/// Specifically, this checks that the dependencies are on the `PERMITTED_DEPENDENCIES`.
+fn check_dependencies(metadata: &Metadata, bad: &mut bool) {
+ // Check that the PERMITTED_DEPENDENCIES does not have unused entries.
+ for name in PERMITTED_DEPENDENCIES {
if !metadata.packages.iter().any(|p| p.name == *name) {
println!(
- "could not find whitelisted package `{}`\n\
- Remove from WHITELIST list if it is no longer used.",
+ "could not find allowed package `{}`\n\
+ Remove from PERMITTED_DEPENDENCIES list if it is no longer used.",
name
);
*bad = true;
}
}
- // Get the whitelist in a convenient form.
- let whitelist: HashSet<_> = WHITELIST.iter().cloned().collect();
+ // Get the list in a convenient form.
+ let permitted_dependencies: HashSet<_> = PERMITTED_DEPENDENCIES.iter().cloned().collect();
// Check dependencies.
let mut visited = BTreeSet::new();
let mut unapproved = BTreeSet::new();
- for &krate in WHITELIST_CRATES.iter() {
+ for &krate in RESTRICTED_DEPENDENCY_CRATES.iter() {
let pkg = pkg_from_name(metadata, krate);
- let mut bad = check_crate_whitelist(&whitelist, metadata, &mut visited, pkg);
+ let mut bad =
+ check_crate_dependencies(&permitted_dependencies, metadata, &mut visited, pkg);
unapproved.append(&mut bad);
}
if !unapproved.is_empty() {
- println!("Dependencies not on the whitelist:");
+ println!("Dependencies not explicitly permitted:");
for dep in unapproved {
println!("* {}", dep);
}
@@ -310,9 +311,9 @@
}
/// Checks the dependencies of the given crate from the given cargo metadata to see if they are on
-/// the whitelist. Returns a list of illegal dependencies.
-fn check_crate_whitelist<'a>(
- whitelist: &'a HashSet<&'static str>,
+/// the list of permitted dependencies. Returns a list of disallowed dependencies.
+fn check_crate_dependencies<'a>(
+ permitted_dependencies: &'a HashSet<&'static str>,
metadata: &'a Metadata,
visited: &mut BTreeSet<&'a PackageId>,
krate: &'a Package,
@@ -327,10 +328,10 @@
visited.insert(&krate.id);
- // If this path is in-tree, we don't require it to be on the whitelist.
+ // If this path is in-tree, we don't require it to be explicitly permitted.
if krate.source.is_some() {
- // If this dependency is not on `WHITELIST`, add to bad set.
- if !whitelist.contains(krate.name.as_str()) {
+ // If this dependency is not on `PERMITTED_DEPENDENCIES`, add to bad set.
+ if !permitted_dependencies.contains(krate.name.as_str()) {
unapproved.insert(&krate.id);
}
}
@@ -339,7 +340,7 @@
let to_check = deps_of(metadata, &krate.id);
for dep in to_check {
- let mut bad = check_crate_whitelist(whitelist, metadata, visited, dep);
+ let mut bad = check_crate_dependencies(permitted_dependencies, metadata, visited, dep);
unapproved.append(&mut bad);
}
diff --git a/src/tools/tidy/src/error_codes_check.rs b/src/tools/tidy/src/error_codes_check.rs
index f7fd0c6..3af71f6 100644
--- a/src/tools/tidy/src/error_codes_check.rs
+++ b/src/tools/tidy/src/error_codes_check.rs
@@ -7,7 +7,7 @@
use std::path::Path;
// A few of those error codes can't be tested but all the others can and *should* be tested!
-const WHITELIST: &[&str] = &[
+const EXEMPTED_FROM_TEST: &[&str] = &[
"E0183", "E0227", "E0279", "E0280", "E0311", "E0313", "E0314", "E0315", "E0377", "E0456",
"E0461", "E0462", "E0464", "E0465", "E0472", "E0473", "E0474", "E0475", "E0476", "E0479",
"E0480", "E0481", "E0482", "E0483", "E0484", "E0485", "E0486", "E0487", "E0488", "E0489",
@@ -166,7 +166,7 @@
println!("Found {} error codes", error_codes.len());
for (err_code, nb) in &error_codes {
- if !*nb && !WHITELIST.contains(&err_code.as_str()) {
+ if !*nb && !EXEMPTED_FROM_TEST.contains(&err_code.as_str()) {
errors.push(format!("Error code {} needs to have at least one UI test!", err_code));
}
}
diff --git a/src/tools/tidy/src/extdeps.rs b/src/tools/tidy/src/extdeps.rs
index e3f92d4..4d666a5 100644
--- a/src/tools/tidy/src/extdeps.rs
+++ b/src/tools/tidy/src/extdeps.rs
@@ -3,8 +3,8 @@
use std::fs;
use std::path::Path;
-/// List of whitelisted sources for packages.
-const WHITELISTED_SOURCES: &[&str] = &["\"registry+https://github.com/rust-lang/crates.io-index\""];
+/// List of allowed sources for packages.
+const ALLOWED_SOURCES: &[&str] = &["\"registry+https://github.com/rust-lang/crates.io-index\""];
/// Checks for external package sources.
pub fn check(path: &Path, bad: &mut bool) {
@@ -24,8 +24,8 @@
// Extract source value.
let source = line.splitn(2, '=').nth(1).unwrap().trim();
- // Ensure source is whitelisted.
- if !WHITELISTED_SOURCES.contains(&&*source) {
+ // Ensure source is allowed.
+ if !ALLOWED_SOURCES.contains(&&*source) {
println!("invalid source: {}", source);
*bad = true;
}
