Rollup merge of #74241 - RalfJung:miri, r=RalfJung
update miri
This incorporates https://github.com/rust-lang/miri/pull/1474. [Last time](https://github.com/rust-lang/rust/pull/74146) that change caused trouble but I fixed xargo since then and [now it should work](https://github.com/rust-lang/rust/pull/74146#issuecomment-657051446).
Cc @rust-lang/miri r? @ghost
diff --git a/Cargo.lock b/Cargo.lock
index cedf44b..905f523 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -404,9 +404,9 @@
[[package]]
name = "cc"
-version = "1.0.54"
+version = "1.0.57"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bbb73db36c1246e9034e307d0fba23f9a2e251faa47ade70c1bd252220c8311"
+checksum = "0fde55d2a2bfaa4c9668bbc63f531fbdeee3ffe188f4662511ce2c22b3eedebe"
dependencies = [
"jobserver",
]
@@ -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 4bec6c7..582bc9d 100644
--- a/src/bootstrap/doc.rs
+++ b/src/bootstrap/doc.rs
@@ -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/native.rs b/src/bootstrap/native.rs
index cceb794..e8ec575 100644
--- a/src/bootstrap/native.rs
+++ b/src/bootstrap/native.rs
@@ -9,6 +9,7 @@
//! ensure that they're always in place if needed.
use std::env;
+use std::env::consts::EXE_EXTENSION;
use std::ffi::OsString;
use std::fs::{self, File};
use std::io;
@@ -252,8 +253,14 @@
// FIXME: if the llvm root for the build triple is overridden then we
// should use llvm-tblgen from there, also should verify that it
// actually exists most of the time in normal installs of LLVM.
- let host = builder.llvm_out(builder.config.build).join("bin/llvm-tblgen");
- cfg.define("CMAKE_CROSSCOMPILING", "True").define("LLVM_TABLEGEN", &host);
+ let host_bin = builder.llvm_out(builder.config.build).join("bin");
+ cfg.define("CMAKE_CROSSCOMPILING", "True");
+ cfg.define("LLVM_TABLEGEN", host_bin.join("llvm-tblgen").with_extension(EXE_EXTENSION));
+ cfg.define("LLVM_NM", host_bin.join("llvm-nm").with_extension(EXE_EXTENSION));
+ cfg.define(
+ "LLVM_CONFIG_PATH",
+ host_bin.join("llvm-config").with_extension(EXE_EXTENSION),
+ );
if target.contains("netbsd") {
cfg.define("CMAKE_SYSTEM_NAME", "NetBSD");
@@ -262,8 +269,6 @@
} else if target.contains("windows") {
cfg.define("CMAKE_SYSTEM_NAME", "Windows");
}
-
- cfg.define("LLVM_NATIVE_BUILD", builder.llvm_out(builder.config.build).join("build"));
}
if let Some(ref suffix) = builder.config.llvm_version_suffix {
@@ -431,6 +436,9 @@
cflags.push_str(" -miphoneos-version-min=10.0");
}
}
+ if builder.config.llvm_clang_cl.is_some() {
+ cflags.push_str(&format!(" --target={}", target))
+ }
cfg.define("CMAKE_C_FLAGS", cflags);
let mut cxxflags = builder.cflags(target, GitRepo::Llvm).join(" ");
if builder.config.llvm_static_stdcpp && !target.contains("msvc") && !target.contains("netbsd") {
@@ -439,6 +447,9 @@
if let Some(ref s) = builder.config.llvm_cxxflags {
cxxflags.push_str(&format!(" {}", s));
}
+ if builder.config.llvm_clang_cl.is_some() {
+ cxxflags.push_str(&format!(" --target={}", target))
+ }
cfg.define("CMAKE_CXX_FLAGS", cxxflags);
if let Some(ar) = builder.ar(target) {
if ar.is_absolute() {
@@ -484,7 +495,7 @@
run.builder.ensure(Lld { target: run.target });
}
- /// Compile LLVM for `target`.
+ /// Compile LLD for `target`.
fn run(self, builder: &Builder<'_>) -> PathBuf {
if builder.config.dry_run {
return PathBuf::from("lld-out-dir-test-gen");
@@ -521,6 +532,7 @@
// can't build on a system where your paths require `\` on Windows, but
// there's probably a lot of reasons you can't do that other than this.
let llvm_config_shim = env::current_exe().unwrap().with_file_name("llvm-config-wrapper");
+
cfg.out_dir(&out_dir)
.profile("Release")
.env("LLVM_CONFIG_REAL", &llvm_config)
@@ -543,7 +555,10 @@
if target != builder.config.build {
cfg.env("LLVM_CONFIG_SHIM_REPLACE", &builder.config.build)
.env("LLVM_CONFIG_SHIM_REPLACE_WITH", &target)
- .define("LLVM_TABLEGEN_EXE", llvm_config.with_file_name("llvm-tblgen"));
+ .define(
+ "LLVM_TABLEGEN_EXE",
+ llvm_config.with_file_name("llvm-tblgen").with_extension(EXE_EXTENSION),
+ );
}
// Explicitly set C++ standard, because upstream doesn't do so
@@ -595,8 +610,8 @@
}
// We may have found various cross-compilers a little differently due to our
- // extra configuration, so inform gcc of these compilers. Note, though, that
- // on MSVC we still need gcc's detection of env vars (ugh).
+ // extra configuration, so inform cc of these compilers. Note, though, that
+ // on MSVC we still need cc's detection of env vars (ugh).
if !target.contains("msvc") {
if let Some(ar) = builder.ar(target) {
cfg.archiver(ar);
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/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/etc/natvis/intrinsic.natvis b/src/etc/natvis/intrinsic.natvis
index 1611d86..874550d 100644
--- a/src/etc/natvis/intrinsic.natvis
+++ b/src/etc/natvis/intrinsic.natvis
@@ -21,4 +21,128 @@
</ArrayItems>
</Expand>
</Type>
+ <Type Name="tuple<>">
+ <DisplayString>()</DisplayString>
+ </Type>
+ <Type Name="tuple<*>">
+ <DisplayString>({__0})</DisplayString>
+ <Expand>
+ <Item Name="[0]">__0</Item>
+ </Expand>
+ </Type>
+ <Type Name="tuple<*,*>">
+ <DisplayString>({__0}, {__1})</DisplayString>
+ <Expand>
+ <Item Name="[0]">__0</Item>
+ <Item Name="[1]">__1</Item>
+ </Expand>
+ </Type>
+ <Type Name="tuple<*,*,*>">
+ <DisplayString>({__0}, {__1}, {__2})</DisplayString>
+ <Expand>
+ <Item Name="[0]">__0</Item>
+ <Item Name="[1]">__1</Item>
+ <Item Name="[2]">__2</Item>
+ </Expand>
+ </Type>
+ <Type Name="tuple<*,*,*,*>">
+ <DisplayString>({__0}, {__1}, {__2}, {__3})</DisplayString>
+ <Expand>
+ <Item Name="[0]">__0</Item>
+ <Item Name="[1]">__1</Item>
+ <Item Name="[2]">__2</Item>
+ <Item Name="[3]">__3</Item>
+ </Expand>
+ </Type>
+ <Type Name="tuple<*,*,*,*,*>">
+ <DisplayString>({__0}, {__1}, {__2}, {__3}, {__4})</DisplayString>
+ <Expand>
+ <Item Name="[0]">__0</Item>
+ <Item Name="[1]">__1</Item>
+ <Item Name="[2]">__2</Item>
+ <Item Name="[3]">__3</Item>
+ <Item Name="[4]">__4</Item>
+ </Expand>
+ </Type>
+ <Type Name="tuple<*,*,*,*,*,*>">
+ <DisplayString>({__0}, {__1}, {__2}, {__3}, {__4}, {__5})</DisplayString>
+ <Expand>
+ <Item Name="[0]">__0</Item>
+ <Item Name="[1]">__1</Item>
+ <Item Name="[2]">__2</Item>
+ <Item Name="[3]">__3</Item>
+ <Item Name="[4]">__4</Item>
+ <Item Name="[5]">__5</Item>
+ </Expand>
+ </Type>
+ <Type Name="tuple<*,*,*,*,*,*,*>">
+ <DisplayString>({__0}, {__1}, {__2}, {__3}, {__4}, {__5}, {__6})</DisplayString>
+ <Expand>
+ <Item Name="[0]">__0</Item>
+ <Item Name="[1]">__1</Item>
+ <Item Name="[2]">__2</Item>
+ <Item Name="[3]">__3</Item>
+ <Item Name="[4]">__4</Item>
+ <Item Name="[5]">__5</Item>
+ <Item Name="[6]">__6</Item>
+ </Expand>
+ </Type>
+ <Type Name="tuple<*,*,*,*,*,*,*,*>">
+ <DisplayString>({__0}, {__1}, {__2}, {__3}, {__4}, {__5}, {__6}, {__7})</DisplayString>
+ <Expand>
+ <Item Name="[0]">__0</Item>
+ <Item Name="[1]">__1</Item>
+ <Item Name="[2]">__2</Item>
+ <Item Name="[3]">__3</Item>
+ <Item Name="[4]">__4</Item>
+ <Item Name="[5]">__5</Item>
+ <Item Name="[6]">__6</Item>
+ <Item Name="[7]">__7</Item>
+ </Expand>
+ </Type>
+ <Type Name="tuple<*,*,*,*,*,*,*,*,*>">
+ <DisplayString>({__0}, {__1}, {__2}, {__3}, {__4}, {__5}, {__6}, {__7}, {__8})</DisplayString>
+ <Expand>
+ <Item Name="[0]">__0</Item>
+ <Item Name="[1]">__1</Item>
+ <Item Name="[2]">__2</Item>
+ <Item Name="[3]">__3</Item>
+ <Item Name="[4]">__4</Item>
+ <Item Name="[5]">__5</Item>
+ <Item Name="[6]">__6</Item>
+ <Item Name="[7]">__7</Item>
+ <Item Name="[8]">__8</Item>
+ </Expand>
+ </Type>
+ <Type Name="tuple<*,*,*,*,*,*,*,*,*,*>">
+ <DisplayString>({__0}, {__1}, {__2}, {__3}, {__4}, {__5}, {__6}, {__7}, {__8}, {__9})</DisplayString>
+ <Expand>
+ <Item Name="[0]">__0</Item>
+ <Item Name="[1]">__1</Item>
+ <Item Name="[2]">__2</Item>
+ <Item Name="[3]">__3</Item>
+ <Item Name="[4]">__4</Item>
+ <Item Name="[5]">__5</Item>
+ <Item Name="[6]">__6</Item>
+ <Item Name="[7]">__7</Item>
+ <Item Name="[8]">__8</Item>
+ <Item Name="[9]">__9</Item>
+ </Expand>
+ </Type>
+ <Type Name="tuple<*,*,*,*,*,*,*,*,*,*,*>">
+ <DisplayString>({__0}, {__1}, {__2}, {__3}, {__4}, {__5}, {__6}, {__7}, {__8}, {__9}, ...)</DisplayString>
+ <Expand>
+ <Item Name="[0]">__0</Item>
+ <Item Name="[1]">__1</Item>
+ <Item Name="[2]">__2</Item>
+ <Item Name="[3]">__3</Item>
+ <Item Name="[4]">__4</Item>
+ <Item Name="[5]">__5</Item>
+ <Item Name="[6]">__6</Item>
+ <Item Name="[7]">__7</Item>
+ <Item Name="[8]">__8</Item>
+ <Item Name="[9]">__9</Item>
+ <Synthetic Name="[...]"><DisplayString>...</DisplayString></Synthetic>
+ </Expand>
+ </Type>
</AutoVisualizer>
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/libcore/benches/ascii.rs b/src/libcore/benches/ascii.rs
index 76ccd3d..05dd7ad 100644
--- a/src/libcore/benches/ascii.rs
+++ b/src/libcore/benches/ascii.rs
@@ -1,3 +1,5 @@
+mod is_ascii;
+
// Lower-case ASCII 'a' is the first byte that has its highest bit set
// after wrap-adding 0x1F:
//
diff --git a/src/libcore/benches/ascii/is_ascii.rs b/src/libcore/benches/ascii/is_ascii.rs
new file mode 100644
index 0000000..729b0a0
--- /dev/null
+++ b/src/libcore/benches/ascii/is_ascii.rs
@@ -0,0 +1,82 @@
+use super::{LONG, MEDIUM, SHORT};
+use test::black_box;
+use test::Bencher;
+
+macro_rules! benches {
+ ($( fn $name: ident($arg: ident: &[u8]) $body: block )+) => {
+ benches!(mod short SHORT[..] $($name $arg $body)+);
+ benches!(mod medium MEDIUM[..] $($name $arg $body)+);
+ benches!(mod long LONG[..] $($name $arg $body)+);
+ // Ensure we benchmark cases where the functions are called with strings
+ // that are not perfectly aligned or have a length which is not a
+ // multiple of size_of::<usize>() (or both)
+ benches!(mod unaligned_head MEDIUM[1..] $($name $arg $body)+);
+ benches!(mod unaligned_tail MEDIUM[..(MEDIUM.len() - 1)] $($name $arg $body)+);
+ benches!(mod unaligned_both MEDIUM[1..(MEDIUM.len() - 1)] $($name $arg $body)+);
+ };
+
+ (mod $mod_name: ident $input: ident [$range: expr] $($name: ident $arg: ident $body: block)+) => {
+ mod $mod_name {
+ use super::*;
+ $(
+ #[bench]
+ fn $name(bencher: &mut Bencher) {
+ bencher.bytes = $input[$range].len() as u64;
+ let mut vec = $input.as_bytes().to_vec();
+ bencher.iter(|| {
+ let $arg: &[u8] = &black_box(&mut vec)[$range];
+ black_box($body)
+ })
+ }
+ )+
+ }
+ };
+}
+
+benches! {
+ fn case00_libcore(bytes: &[u8]) {
+ bytes.is_ascii()
+ }
+
+ fn case01_iter_all(bytes: &[u8]) {
+ bytes.iter().all(|b| b.is_ascii())
+ }
+
+ fn case02_align_to(bytes: &[u8]) {
+ is_ascii_align_to(bytes)
+ }
+
+ fn case03_align_to_unrolled(bytes: &[u8]) {
+ is_ascii_align_to_unrolled(bytes)
+ }
+}
+
+// These are separate since it's easier to debug errors if they don't go through
+// macro expansion first.
+fn is_ascii_align_to(bytes: &[u8]) -> bool {
+ if bytes.len() < core::mem::size_of::<usize>() {
+ return bytes.iter().all(|b| b.is_ascii());
+ }
+ // SAFETY: transmuting a sequence of `u8` to `usize` is always fine
+ let (head, body, tail) = unsafe { bytes.align_to::<usize>() };
+ head.iter().all(|b| b.is_ascii())
+ && body.iter().all(|w| !contains_nonascii(*w))
+ && tail.iter().all(|b| b.is_ascii())
+}
+
+fn is_ascii_align_to_unrolled(bytes: &[u8]) -> bool {
+ if bytes.len() < core::mem::size_of::<usize>() {
+ return bytes.iter().all(|b| b.is_ascii());
+ }
+ // SAFETY: transmuting a sequence of `u8` to `[usize; 2]` is always fine
+ let (head, body, tail) = unsafe { bytes.align_to::<[usize; 2]>() };
+ head.iter().all(|b| b.is_ascii())
+ && body.iter().all(|w| !contains_nonascii(w[0] | w[1]))
+ && tail.iter().all(|b| b.is_ascii())
+}
+
+#[inline]
+fn contains_nonascii(v: usize) -> bool {
+ const NONASCII_MASK: usize = 0x80808080_80808080u64 as usize;
+ (NONASCII_MASK & v) != 0
+}
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/intrinsics.rs b/src/libcore/intrinsics.rs
index b3e43cd..540a8cf 100644
--- a/src/libcore/intrinsics.rs
+++ b/src/libcore/intrinsics.rs
@@ -1285,7 +1285,9 @@
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- #[rustc_const_unstable(feature = "const_transmute", issue = "53605")]
+ // NOTE: While this makes the intrinsic const stable, we have some custom code in const fn
+ // checks that prevent its use within `const fn`.
+ #[rustc_const_stable(feature = "const_transmute", since = "1.46.0")]
pub fn transmute<T, U>(e: T) -> U;
/// Returns `true` if the actual type given as `T` requires drop
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
index 692d91b..820c0a4 100644
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -140,7 +140,7 @@
#![feature(rtm_target_feature)]
#![feature(f16c_target_feature)]
#![feature(hexagon_target_feature)]
-#![feature(const_transmute)]
+#![cfg_attr(not(bootstrap), feature(const_fn_transmute))]
#![feature(abi_unadjusted)]
#![feature(adx_target_feature)]
#![feature(maybe_uninit_slice)]
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/slice/mod.rs b/src/libcore/slice/mod.rs
index e7a2d7a..bed8495 100644
--- a/src/libcore/slice/mod.rs
+++ b/src/libcore/slice/mod.rs
@@ -2795,7 +2795,7 @@
#[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")]
#[inline]
pub fn is_ascii(&self) -> bool {
- self.iter().all(|b| b.is_ascii())
+ is_ascii(self)
}
/// Checks that two slices are an ASCII case-insensitive match.
@@ -2843,6 +2843,106 @@
}
}
+/// Returns `true` if any byte in the word `v` is nonascii (>= 128). Snarfed
+/// from `../str/mod.rs`, which does something similar for utf8 validation.
+#[inline]
+fn contains_nonascii(v: usize) -> bool {
+ const NONASCII_MASK: usize = 0x80808080_80808080u64 as usize;
+ (NONASCII_MASK & v) != 0
+}
+
+/// Optimized ASCII test that will use usize-at-a-time operations instead of
+/// byte-at-a-time operations (when possible).
+///
+/// The algorithm we use here is pretty simple. If `s` is too short, we just
+/// check each byte and be done with it. Otherwise:
+///
+/// - Read the first word with an unaligned load.
+/// - Align the pointer, read subsequent words until end with aligned loads.
+/// - If there's a tail, the last `usize` from `s` with an unaligned load.
+///
+/// If any of these loads produces something for which `contains_nonascii`
+/// (above) returns true, then we know the answer is false.
+#[inline]
+fn is_ascii(s: &[u8]) -> bool {
+ const USIZE_SIZE: usize = mem::size_of::<usize>();
+
+ let len = s.len();
+ let align_offset = s.as_ptr().align_offset(USIZE_SIZE);
+
+ // If we wouldn't gain anything from the word-at-a-time implementation, fall
+ // back to a scalar loop.
+ //
+ // We also do this for architectures where `size_of::<usize>()` isn't
+ // sufficient alignment for `usize`, because it's a weird edge case.
+ if len < USIZE_SIZE || len < align_offset || USIZE_SIZE < mem::align_of::<usize>() {
+ return s.iter().all(|b| b.is_ascii());
+ }
+
+ // We always read the first word unaligned, which means `align_offset` is
+ // 0, we'd read the same value again for the aligned read.
+ let offset_to_aligned = if align_offset == 0 { USIZE_SIZE } else { align_offset };
+
+ let start = s.as_ptr();
+ // SAFETY: We verify `len < USIZE_SIZE` above.
+ let first_word = unsafe { (start as *const usize).read_unaligned() };
+
+ if contains_nonascii(first_word) {
+ return false;
+ }
+ // We checked this above, somewhat implicitly. Note that `offset_to_aligned`
+ // is either `align_offset` or `USIZE_SIZE`, both of are explicitly checked
+ // above.
+ debug_assert!(offset_to_aligned <= len);
+
+ // word_ptr is the (properly aligned) usize ptr we use to read the middle chunk of the slice.
+ let mut word_ptr = unsafe { start.add(offset_to_aligned) as *const usize };
+
+ // `byte_pos` is the byte index of `word_ptr`, used for loop end checks.
+ let mut byte_pos = offset_to_aligned;
+
+ // Paranoia check about alignment, since we're about to do a bunch of
+ // unaligned loads. In practice this should be impossible barring a bug in
+ // `align_offset` though.
+ debug_assert_eq!((word_ptr as usize) % mem::align_of::<usize>(), 0);
+
+ while byte_pos <= len - USIZE_SIZE {
+ debug_assert!(
+ // Sanity check that the read is in bounds
+ (word_ptr as usize + USIZE_SIZE) <= (start.wrapping_add(len) as usize) &&
+ // And that our assumptions about `byte_pos` hold.
+ (word_ptr as usize) - (start as usize) == byte_pos
+ );
+
+ // Safety: We know `word_ptr` is properly aligned (because of
+ // `align_offset`), and we know that we have enough bytes between `word_ptr` and the end
+ let word = unsafe { word_ptr.read() };
+ if contains_nonascii(word) {
+ return false;
+ }
+
+ byte_pos += USIZE_SIZE;
+ // SAFETY: We know that `byte_pos <= len - USIZE_SIZE`, which means that
+ // after this `add`, `word_ptr` will be at most one-past-the-end.
+ word_ptr = unsafe { word_ptr.add(1) };
+ }
+
+ // If we have anything left over, it should be at-most 1 usize worth of bytes,
+ // which we check with a read_unaligned.
+ if byte_pos == len {
+ return true;
+ }
+
+ // Sanity check to ensure there really is only one `usize` left. This should
+ // be guaranteed by our loop condition.
+ debug_assert!(byte_pos < len && len - byte_pos < USIZE_SIZE);
+
+ // SAFETY: This relies on `len >= USIZE_SIZE`, which we check at the start.
+ let last_word = unsafe { (start.add(len - USIZE_SIZE) as *const usize).read_unaligned() };
+
+ !contains_nonascii(last_word)
+}
+
#[stable(feature = "rust1", since = "1.0.0")]
impl<T, I> ops::Index<I> for [T]
where
diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index 0014501..003ed7d 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -4348,7 +4348,7 @@
// We can treat each byte as character here: all multibyte characters
// start with a byte that is not in the ascii range, so we will stop
// there already.
- self.bytes().all(|b| b.is_ascii())
+ self.as_bytes().is_ascii()
}
/// Checks that two strings are an ASCII case-insensitive match.
diff --git a/src/libcore/tests/ascii.rs b/src/libcore/tests/ascii.rs
index 71275d4..57f2de1 100644
--- a/src/libcore/tests/ascii.rs
+++ b/src/libcore/tests/ascii.rs
@@ -343,3 +343,59 @@
" ",
);
}
+
+// `is_ascii` does a good amount of pointer manipulation and has
+// alignment-dependent computation. This is all sanity-checked via
+// `debug_assert!`s, so we test various sizes/alignments thoroughly versus an
+// "obviously correct" baseline function.
+#[test]
+fn test_is_ascii_align_size_thoroughly() {
+ // The "obviously-correct" baseline mentioned above.
+ fn is_ascii_baseline(s: &[u8]) -> bool {
+ s.iter().all(|b| b.is_ascii())
+ }
+
+ // Helper to repeat `l` copies of `b0` followed by `l` copies of `b1`.
+ fn repeat_concat(b0: u8, b1: u8, l: usize) -> Vec<u8> {
+ use core::iter::repeat;
+ repeat(b0).take(l).chain(repeat(b1).take(l)).collect()
+ }
+
+ // Miri is too slow for much of this, and in miri `align_offset` always
+ // returns `usize::max_value()` anyway (at the moment), so we just test
+ // lightly.
+ let iter = if cfg!(miri) { 0..5 } else { 0..100 };
+
+ for i in iter {
+ #[cfg(not(miri))]
+ let cases = &[
+ b"a".repeat(i),
+ b"\0".repeat(i),
+ b"\x7f".repeat(i),
+ b"\x80".repeat(i),
+ b"\xff".repeat(i),
+ repeat_concat(b'a', 0x80u8, i),
+ repeat_concat(0x80u8, b'a', i),
+ ];
+
+ #[cfg(miri)]
+ let cases = &[repeat_concat(b'a', 0x80u8, i)];
+
+ for case in cases {
+ for pos in 0..=case.len() {
+ // Potentially misaligned head
+ let prefix = &case[pos..];
+ assert_eq!(is_ascii_baseline(prefix), prefix.is_ascii(),);
+
+ // Potentially misaligned tail
+ let suffix = &case[..case.len() - pos];
+
+ assert_eq!(is_ascii_baseline(suffix), suffix.is_ascii(),);
+
+ // Both head and tail are potentially misaligned
+ let mid = &case[(pos / 2)..(case.len() - (pos / 2))];
+ assert_eq!(is_ascii_baseline(mid), mid.is_ascii(),);
+ }
+ }
+ }
+}
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/lib.rs b/src/librustc_ast/lib.rs
index ffd2aa6..c32ed1e 100644
--- a/src/librustc_ast/lib.rs
+++ b/src/librustc_ast/lib.rs
@@ -10,7 +10,7 @@
#![cfg_attr(bootstrap, feature(const_if_match))]
#![feature(const_fn)] // For the `transmute` in `P::new`
#![feature(const_panic)]
-#![feature(const_transmute)]
+#![cfg_attr(not(bootstrap), feature(const_fn_transmute))]
#![feature(crate_visibility_modifier)]
#![feature(label_break_value)]
#![feature(nll)]
diff --git a/src/librustc_codegen_llvm/attributes.rs b/src/librustc_codegen_llvm/attributes.rs
index c53a646..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);
@@ -343,14 +343,14 @@
}
pub fn provide(providers: &mut Providers) {
- providers.target_features_whitelist = |tcx, cnum| {
+ 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()
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/debuginfo/metadata.rs b/src/librustc_codegen_llvm/debuginfo/metadata.rs
index dab85b8..f2e042c 100644
--- a/src/librustc_codegen_llvm/debuginfo/metadata.rs
+++ b/src/librustc_codegen_llvm/debuginfo/metadata.rs
@@ -19,6 +19,7 @@
use crate::value::Value;
use log::debug;
+use rustc_ast::ast;
use rustc_codegen_ssa::traits::*;
use rustc_data_structures::const_cstr;
use rustc_data_structures::fingerprint::Fingerprint;
@@ -827,14 +828,60 @@
}
}
+trait MsvcBasicName {
+ fn msvc_basic_name(self) -> &'static str;
+}
+
+impl MsvcBasicName for ast::IntTy {
+ fn msvc_basic_name(self) -> &'static str {
+ match self {
+ ast::IntTy::Isize => "ptrdiff_t",
+ ast::IntTy::I8 => "__int8",
+ ast::IntTy::I16 => "__int16",
+ ast::IntTy::I32 => "__int32",
+ ast::IntTy::I64 => "__int64",
+ ast::IntTy::I128 => "__int128",
+ }
+ }
+}
+
+impl MsvcBasicName for ast::UintTy {
+ fn msvc_basic_name(self) -> &'static str {
+ match self {
+ ast::UintTy::Usize => "size_t",
+ ast::UintTy::U8 => "unsigned __int8",
+ ast::UintTy::U16 => "unsigned __int16",
+ ast::UintTy::U32 => "unsigned __int32",
+ ast::UintTy::U64 => "unsigned __int64",
+ ast::UintTy::U128 => "unsigned __int128",
+ }
+ }
+}
+
+impl MsvcBasicName for ast::FloatTy {
+ fn msvc_basic_name(self) -> &'static str {
+ match self {
+ ast::FloatTy::F32 => "float",
+ ast::FloatTy::F64 => "double",
+ }
+ }
+}
+
fn basic_type_metadata(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) -> &'ll DIType {
debug!("basic_type_metadata: {:?}", t);
+ // When targeting MSVC, emit MSVC style type names for compatibility with
+ // .natvis visualizers (and perhaps other existing native debuggers?)
+ let msvc_like_names = cx.tcx.sess.target.target.options.is_like_msvc;
+
let (name, encoding) = match t.kind {
ty::Never => ("!", DW_ATE_unsigned),
ty::Tuple(ref elements) if elements.is_empty() => ("()", DW_ATE_unsigned),
ty::Bool => ("bool", DW_ATE_boolean),
ty::Char => ("char", DW_ATE_unsigned_char),
+ ty::Int(int_ty) if msvc_like_names => (int_ty.msvc_basic_name(), DW_ATE_signed),
+ ty::Uint(uint_ty) if msvc_like_names => (uint_ty.msvc_basic_name(), DW_ATE_unsigned),
+ ty::Float(float_ty) if msvc_like_names => (float_ty.msvc_basic_name(), DW_ATE_float),
ty::Int(int_ty) => (int_ty.name_str(), DW_ATE_signed),
ty::Uint(uint_ty) => (uint_ty.name_str(), DW_ATE_unsigned),
ty::Float(float_ty) => (float_ty.name_str(), DW_ATE_float),
@@ -851,7 +898,30 @@
)
};
- ty_metadata
+ if !msvc_like_names {
+ return ty_metadata;
+ }
+
+ let typedef_name = match t.kind {
+ ty::Int(int_ty) => int_ty.name_str(),
+ ty::Uint(uint_ty) => uint_ty.name_str(),
+ ty::Float(float_ty) => float_ty.name_str(),
+ _ => return ty_metadata,
+ };
+
+ let typedef_metadata = unsafe {
+ llvm::LLVMRustDIBuilderCreateTypedef(
+ DIB(cx),
+ ty_metadata,
+ typedef_name.as_ptr().cast(),
+ typedef_name.len(),
+ unknown_file_metadata(cx),
+ 0,
+ None,
+ )
+ };
+
+ typedef_metadata
}
fn foreign_type_metadata(
diff --git a/src/librustc_codegen_llvm/llvm/ffi.rs b/src/librustc_codegen_llvm/llvm/ffi.rs
index 7beb4fc..64f5e10 100644
--- a/src/librustc_codegen_llvm/llvm/ffi.rs
+++ b/src/librustc_codegen_llvm/llvm/ffi.rs
@@ -1703,6 +1703,16 @@
Encoding: c_uint,
) -> &'a DIBasicType;
+ pub fn LLVMRustDIBuilderCreateTypedef(
+ Builder: &DIBuilder<'a>,
+ Type: &'a DIBasicType,
+ Name: *const c_char,
+ NameLen: size_t,
+ File: &'a DIFile,
+ LineNo: c_uint,
+ Scope: Option<&'a DIScope>,
+ ) -> &'a DIDerivedType;
+
pub fn LLVMRustDIBuilderCreatePointerType(
Builder: &DIBuilder<'a>,
PointeeTy: &'a DIType,
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..e64aafa 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 {
@@ -621,9 +619,9 @@
// Some versions of `gcc` add it implicitly, some (e.g. `musl-gcc`) don't,
// so we just always add it.
fn add_eh_frame_header(&mut self) {
- // The condition here is "uses ELF" basically.
if !self.sess.target.target.options.is_like_osx
&& !self.sess.target.target.options.is_like_windows
+ && !self.sess.target.target.options.is_like_solaris
&& self.sess.target.target.target_os != "uefi"
{
self.linker_arg("--eh-frame-hdr");
@@ -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/base.rs b/src/librustc_codegen_ssa/base.rs
index 4e257fb..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);
}
diff --git a/src/librustc_codegen_ssa/debuginfo/type_names.rs b/src/librustc_codegen_ssa/debuginfo/type_names.rs
index a64489c..20d4404 100644
--- a/src/librustc_codegen_ssa/debuginfo/type_names.rs
+++ b/src/librustc_codegen_ssa/debuginfo/type_names.rs
@@ -47,7 +47,12 @@
push_type_params(tcx, substs, output, visited);
}
ty::Tuple(component_types) => {
- output.push('(');
+ if cpp_like_names {
+ output.push_str("tuple<");
+ } else {
+ output.push('(');
+ }
+
for component_type in component_types {
push_debuginfo_type_name(tcx, component_type.expect_ty(), true, output, visited);
output.push_str(", ");
@@ -56,7 +61,12 @@
output.pop();
output.pop();
}
- output.push(')');
+
+ if cpp_like_names {
+ output.push('>');
+ } else {
+ output.push(')');
+ }
}
ty::RawPtr(ty::TypeAndMut { ty: inner_type, mutbl }) => {
if !cpp_like_names {
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_feature/active.rs b/src/librustc_feature/active.rs
index 32481bf..0da3693 100644
--- a/src/librustc_feature/active.rs
+++ b/src/librustc_feature/active.rs
@@ -573,6 +573,9 @@
/// Lazily evaluate constants. This allows constants to depend on type parameters.
(active, lazy_normalization_consts, "1.46.0", Some(72219), None),
+ /// Alloc calling `transmute` in const fn
+ (active, const_fn_transmute, "1.46.0", Some(53605), None),
+
// -------------------------------------------------------------------------
// feature-group-end: actual feature gates
// -------------------------------------------------------------------------
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 f89be02..e50622a 100644
--- a/src/librustc_interface/interface.rs
+++ b/src/librustc_interface/interface.rs
@@ -159,10 +159,7 @@
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/util.rs b/src/librustc_interface/util.rs
index fe091e9..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,7 +142,7 @@
crate::callbacks::setup_callbacks();
- scoped_thread(cfg, || {
+ let main_handler = move || {
rustc_ast::with_session_globals(edition, || {
ty::tls::GCX_PTR.set(&Lock::new(0), || {
if let Some(stderr) = stderr {
@@ -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,7 +176,7 @@
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_session_globals(edition, || {
rustc_ast::SESSION_GLOBALS.with(|ast_session_globals| {
@@ -185,13 +186,15 @@
// 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: ThreadBuilder| {
+ let main_handler = move |thread: rayon::ThreadBuilder| {
rustc_ast::SESSION_GLOBALS.set(ast_session_globals, || {
rustc_span::SESSION_GLOBALS.set(span_session_globals, || {
- if let Some(stderr) = stderr {
- io::set_panic(Some(box Sink(stderr.clone())));
- }
- ty::tls::GCX_PTR.set(gcx_ptr, || thread.run())
+ 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/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_middle/lib.rs b/src/librustc_middle/lib.rs
index 96b8ca2..c2b14cb 100644
--- a/src/librustc_middle/lib.rs
+++ b/src/librustc_middle/lib.rs
@@ -30,7 +30,7 @@
#![cfg_attr(bootstrap, feature(const_if_match))]
#![feature(const_fn)]
#![feature(const_panic)]
-#![feature(const_transmute)]
+#![cfg_attr(not(bootstrap), feature(const_fn_transmute))]
#![feature(core_intrinsics)]
#![feature(discriminant_kind)]
#![feature(drain_filter)]
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/layout.rs b/src/librustc_middle/ty/layout.rs
index 5afcb23..66ad923 100644
--- a/src/librustc_middle/ty/layout.rs
+++ b/src/librustc_middle/ty/layout.rs
@@ -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 7ca9569..bec1200 100644
--- a/src/librustc_middle/ty/mod.rs
+++ b/src/librustc_middle/ty/mod.rs
@@ -1337,18 +1337,18 @@
}
pub trait ToPredicate<'tcx> {
- fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx>;
+ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx>;
}
impl ToPredicate<'tcx> for PredicateKind<'tcx> {
#[inline(always)]
- fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
- tcx.mk_predicate(*self)
+ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
+ tcx.mk_predicate(self)
}
}
impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<TraitRef<'tcx>> {
- fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
+ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
ty::PredicateKind::Trait(
ty::Binder::dummy(ty::TraitPredicate { trait_ref: self.value }),
self.constness,
@@ -1358,7 +1358,7 @@
}
impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<&TraitRef<'tcx>> {
- fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
+ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
ty::PredicateKind::Trait(
ty::Binder::dummy(ty::TraitPredicate { trait_ref: *self.value }),
self.constness,
@@ -1368,34 +1368,34 @@
}
impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<PolyTraitRef<'tcx>> {
- fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
+ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
ty::PredicateKind::Trait(self.value.to_poly_trait_predicate(), self.constness)
.to_predicate(tcx)
}
}
impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<&PolyTraitRef<'tcx>> {
- fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
+ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
ty::PredicateKind::Trait(self.value.to_poly_trait_predicate(), self.constness)
.to_predicate(tcx)
}
}
impl<'tcx> ToPredicate<'tcx> for PolyRegionOutlivesPredicate<'tcx> {
- fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
- PredicateKind::RegionOutlives(*self).to_predicate(tcx)
+ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
+ PredicateKind::RegionOutlives(self).to_predicate(tcx)
}
}
impl<'tcx> ToPredicate<'tcx> for PolyTypeOutlivesPredicate<'tcx> {
- fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
- PredicateKind::TypeOutlives(*self).to_predicate(tcx)
+ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
+ PredicateKind::TypeOutlives(self).to_predicate(tcx)
}
}
impl<'tcx> ToPredicate<'tcx> for PolyProjectionPredicate<'tcx> {
- fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
- PredicateKind::Projection(*self).to_predicate(tcx)
+ fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
+ PredicateKind::Projection(self).to_predicate(tcx)
}
}
diff --git a/src/librustc_middle/ty/print/pretty.rs b/src/librustc_middle/ty/print/pretty.rs
index 9dda208..3809c8d 100644
--- a/src/librustc_middle/ty/print/pretty.rs
+++ b/src/librustc_middle/ty/print/pretty.rs
@@ -393,7 +393,7 @@
.tcx()
.item_children(visible_parent)
.iter()
- .find(|child| child.res.def_id() == def_id)
+ .find(|child| child.res.opt_def_id() == Some(def_id))
.map(|child| child.ident.name);
if let Some(reexport) = reexport {
*name = reexport;
diff --git a/src/librustc_mir/const_eval/fn_queries.rs b/src/librustc_mir/const_eval/fn_queries.rs
index daa458f..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());
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/transform/qualify_min_const_fn.rs b/src/librustc_mir/transform/qualify_min_const_fn.rs
index 2f52570..52b1eba 100644
--- a/src/librustc_mir/transform/qualify_min_const_fn.rs
+++ b/src/librustc_mir/transform/qualify_min_const_fn.rs
@@ -6,6 +6,7 @@
use rustc_middle::ty::{self, adjustment::PointerCast, Ty, TyCtxt};
use rustc_span::symbol::{sym, Symbol};
use rustc_span::Span;
+use rustc_target::spec::abi::Abi::RustIntrinsic;
use std::borrow::Cow;
type McfResult = Result<(), (Span, Cow<'static, str>)>;
@@ -191,8 +192,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) => {
@@ -409,6 +419,20 @@
));
}
+ // HACK: This is to "unstabilize" the `transmute` intrinsic
+ // within const fns. `transmute` is allowed in all other const contexts.
+ // This won't really scale to more intrinsics or functions. Let's allow const
+ // transmutes in const fn before we add more hacks to this.
+ if tcx.fn_sig(fn_def_id).abi() == RustIntrinsic
+ && tcx.item_name(fn_def_id) == sym::transmute
+ && !feature_allowed(tcx, def_id, sym::const_fn_transmute)
+ {
+ return Err((
+ span,
+ "can only call `transmute` from const items, not `const fn`".into(),
+ ));
+ }
+
check_operand(tcx, func, span, fn_def_id, body)?;
for arg in args {
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_passes/check_attr.rs b/src/librustc_passes/check_attr.rs
index 3272ac8..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;
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_resolve/late/diagnostics.rs b/src/librustc_resolve/late/diagnostics.rs
index e469ca8..fc41ce5 100644
--- a/src/librustc_resolve/late/diagnostics.rs
+++ b/src/librustc_resolve/late/diagnostics.rs
@@ -100,9 +100,7 @@
let ident_span = path.last().map_or(span, |ident| ident.ident.span);
let ns = source.namespace();
let is_expected = &|res| source.is_expected(res);
- let is_enum_variant = &|res| {
- if let Res::Def(DefKind::Variant, _) = res { true } else { false }
- };
+ let is_enum_variant = &|res| matches!(res, Res::Def(DefKind::Variant, _));
// Make the base error.
let expected = source.descr_expected();
@@ -168,9 +166,9 @@
if ["this", "my"].contains(&&*item_str.as_str())
&& self.self_value_is_available(path[0].ident.span, span)
{
- err.span_suggestion(
+ err.span_suggestion_short(
span,
- "did you mean",
+ "you might have meant to use `self` here instead",
"self".to_string(),
Applicability::MaybeIncorrect,
);
@@ -1044,6 +1042,7 @@
lifetime_ref
);
err.span_label(lifetime_ref.span, "undeclared lifetime");
+ let mut suggests_in_band = false;
for missing in &self.missing_named_lifetime_spots {
match missing {
MissingLifetimeSpot::Generics(generics) => {
@@ -1057,6 +1056,7 @@
}) {
(param.span.shrink_to_lo(), format!("{}, ", lifetime_ref))
} else {
+ suggests_in_band = true;
(generics.span, format!("<{}>", lifetime_ref))
};
err.span_suggestion(
@@ -1084,6 +1084,15 @@
}
}
}
+ if nightly_options::is_nightly_build()
+ && !self.tcx.features().in_band_lifetimes
+ && suggests_in_band
+ {
+ err.help(
+ "if you want to experiment with in-band lifetime bindings, \
+ add `#![feature(in_band_lifetimes)]` to the crate attributes",
+ );
+ }
err.emit();
}
diff --git a/src/librustc_resolve/late/lifetimes.rs b/src/librustc_resolve/late/lifetimes.rs
index e9b9171..1467bf5 100644
--- a/src/librustc_resolve/late/lifetimes.rs
+++ b/src/librustc_resolve/late/lifetimes.rs
@@ -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_span/symbol.rs b/src/librustc_span/symbol.rs
index 37fb754..3c55211 100644
--- a/src/librustc_span/symbol.rs
+++ b/src/librustc_span/symbol.rs
@@ -848,6 +848,7 @@
track_caller,
trait_alias,
transmute,
+ const_fn_transmute,
transparent,
transparent_enums,
transparent_unions,
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/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_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/collect.rs b/src/librustc_typeck/collect.rs
index 4f88836..1548166 100644
--- a/src/librustc_typeck/collect.rs
+++ b/src/librustc_typeck/collect.rs
@@ -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/librustdoc/core.rs b/src/librustdoc/core.rs
index db98ec5..a222920 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -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))
@@ -317,9 +317,9 @@
let no_crate_level_docs = rustc_lint::builtin::MISSING_CRATE_LEVEL_DOCS.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/render.rs b/src/librustdoc/html/render.rs
index f769a09..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;
}
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/test.rs b/src/librustdoc/test.rs
index b40a5ef..c2d644b 100644
--- a/src/librustdoc/test.rs
+++ b/src/librustdoc/test.rs
@@ -47,11 +47,11 @@
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 {
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/llvm-project b/src/llvm-project
index 6c040dd..d134a53 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit 6c040dd86ed62d38e585279027486e6efc42fb36
+Subproject commit d134a53927fa033ae7e0f3e8ee872ff2dc71468d
diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp
index 063b6ac..c92cf65 100644
--- a/src/rustllvm/RustWrapper.cpp
+++ b/src/rustllvm/RustWrapper.cpp
@@ -762,6 +762,14 @@
return wrap(Builder->createBasicType(StringRef(Name, NameLen), SizeInBits, Encoding));
}
+extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateTypedef(
+ LLVMRustDIBuilderRef Builder, LLVMMetadataRef Type, const char *Name, size_t NameLen,
+ LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Scope) {
+ return wrap(Builder->createTypedef(
+ unwrap<DIType>(Type), StringRef(Name, NameLen), unwrap<DIFile>(File),
+ LineNo, unwrap<DIScope>(Scope)));
+}
+
extern "C" LLVMMetadataRef LLVMRustDIBuilderCreatePointerType(
LLVMRustDIBuilderRef Builder, LLVMMetadataRef PointeeTy,
uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace,
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/debuginfo/simple-tuple.rs b/src/test/debuginfo/simple-tuple.rs
index c2db521..b7fcfee 100644
--- a/src/test/debuginfo/simple-tuple.rs
+++ b/src/test/debuginfo/simple-tuple.rs
@@ -123,6 +123,48 @@
// lldbg-check:[...]$6 = { 0 = 15 1 = 16 }
// lldbr-check:((i32, i16)) paddingAtEnd = { 0 = 15 1 = 16 }
+
+// === CDB TESTS ==================================================================================
+
+// cdb-command: g
+
+// cdb-command:dx noPadding8,d
+// cdb-check:noPadding8,d [...]: (-100, 100) [Type: tuple<i8, u8>]
+// cdb-check:[...][0] : -100 [Type: [...]]
+// cdb-check:[...][1] : 100 [Type: [...]]
+// cdb-command:dx noPadding16,d
+// cdb-check:noPadding16,d [...]: (0, 1, 2) [Type: tuple<i16, i16, u16>]
+// cdb-check:[...][0] : 0 [Type: [...]]
+// cdb-check:[...][1] : 1 [Type: [...]]
+// cdb-check:[...][2] : 2 [Type: [...]]
+// cdb-command:dx noPadding32,d
+// cdb-check:noPadding32,d [...]: (3, 4.5[...], 5) [Type: tuple<i32, f32, u32>]
+// cdb-check:[...][0] : 3 [Type: [...]]
+// cdb-check:[...][1] : 4.5[...] [Type: [...]]
+// cdb-check:[...][2] : 5 [Type: [...]]
+// cdb-command:dx noPadding64,d
+// cdb-check:noPadding64,d [...]: (6, 7.5[...], 8) [Type: tuple<i64, f64, u64>]
+// cdb-check:[...][0] : 6 [Type: [...]]
+// cdb-check:[...][1] : 7.500000 [Type: [...]]
+// cdb-check:[...][2] : 8 [Type: [...]]
+
+// cdb-command:dx internalPadding1,d
+// cdb-check:internalPadding1,d [...]: (9, 10) [Type: tuple<i16, i32>]
+// cdb-check:[...][0] : 9 [Type: short]
+// cdb-check:[...][1] : 10 [Type: int]
+// cdb-command:dx internalPadding2,d
+// cdb-check:internalPadding2,d [...]: (11, 12, 13, 14) [Type: tuple<i16, i32, u32, u64>]
+// cdb-check:[...][0] : 11 [Type: [...]]
+// cdb-check:[...][1] : 12 [Type: [...]]
+// cdb-check:[...][2] : 13 [Type: [...]]
+// cdb-check:[...][3] : 14 [Type: [...]]
+
+// cdb-command:dx paddingAtEnd,d
+// cdb-check:paddingAtEnd,d [...]: (15, 16) [Type: tuple<i32, i16>]
+// cdb-check:[...][0] : 15 [Type: [...]]
+// cdb-check:[...][1] : 16 [Type: [...]]
+
+
#![allow(unused_variables)]
#![allow(dead_code)]
#![feature(omit_gdb_pretty_printer_section)]
diff --git a/src/test/debuginfo/tuple-in-tuple.rs b/src/test/debuginfo/tuple-in-tuple.rs
index e0f940ca..0447d8e 100644
--- a/src/test/debuginfo/tuple-in-tuple.rs
+++ b/src/test/debuginfo/tuple-in-tuple.rs
@@ -59,6 +59,73 @@
// lldbg-check:[...]$6 = { 0 = { 0 = 21 1 = 22 } 1 = 23 }
// lldbr-check:(((i32, i16), i32)) padding_at_end2 = { 0 = { 0 = 21 1 = 22 } 1 = 23 }
+
+// === CDB TESTS ==================================================================================
+
+// cdb-command: g
+
+// cdb-command:dx no_padding1,d
+// cdb-check:no_padding1,d [...]: ((0, 1), 2, 3) [Type: tuple<tuple<u32, u32>, u32, u32>]
+// cdb-check:[...][0] : (0, 1) [Type: tuple<u32, u32>]
+// cdb-check:[...][1] : 2 [Type: [...]]
+// cdb-check:[...][2] : 3 [Type: [...]]
+// cdb-command:dx no_padding1.__0,d
+// cdb-check:no_padding1.__0,d [...]: (0, 1) [Type: tuple<u32, u32>]
+// cdb-check:[...][0] : 0 [Type: [...]]
+// cdb-check:[...][1] : 1 [Type: [...]]
+// cdb-command:dx no_padding2,d
+// cdb-check:no_padding2,d [...]: (4, (5, 6), 7) [Type: tuple<u32, tuple<u32, u32>, u32>]
+// cdb-check:[...][0] : 4 [Type: [...]]
+// cdb-check:[...][1] : (5, 6) [Type: tuple<u32, u32>]
+// cdb-check:[...][2] : 7 [Type: [...]]
+// cdb-command:dx no_padding2.__1,d
+// cdb-check:no_padding2.__1,d [...]: (5, 6) [Type: tuple<u32, u32>]
+// cdb-check:[...][0] : 5 [Type: [...]]
+// cdb-check:[...][1] : 6 [Type: [...]]
+// cdb-command:dx no_padding3,d
+// cdb-check:no_padding3,d [...]: (8, 9, (10, 11)) [Type: tuple<u32, u32, tuple<u32, u32>>]
+// cdb-check:[...][0] : 8 [Type: [...]]
+// cdb-check:[...][1] : 9 [Type: [...]]
+// cdb-check:[...][2] : (10, 11) [Type: tuple<u32, u32>]
+// cdb-command:dx no_padding3.__2,d
+// cdb-check:no_padding3.__2,d [...]: (10, 11) [Type: tuple<u32, u32>]
+// cdb-check:[...][0] : 10 [Type: [...]]
+// cdb-check:[...][1] : 11 [Type: [...]]
+
+// cdb-command:dx internal_padding1,d
+// cdb-check:internal_padding1,d [...]: (12, (13, 14)) [Type: tuple<i16, tuple<i32, i32>>]
+// cdb-check:[...][0] : 12 [Type: [...]]
+// cdb-check:[...][1] : (13, 14) [Type: tuple<i32, i32>]
+// cdb-command:dx internal_padding1.__1,d
+// cdb-check:internal_padding1.__1,d [...]: (13, 14) [Type: tuple<i32, i32>]
+// cdb-check:[...][0] : 13 [Type: [...]]
+// cdb-check:[...][1] : 14 [Type: [...]]
+// cdb-command:dx internal_padding2,d
+// cdb-check:internal_padding2,d [...]: (15, (16, 17)) [Type: tuple<i16, tuple<i16, i32>>]
+// cdb-check:[...][0] : 15 [Type: [...]]
+// cdb-check:[...][1] : (16, 17) [Type: tuple<i16, i32>]
+// cdb-command:dx internal_padding2.__1,d
+// cdb-check:internal_padding2.__1,d [...]: (16, 17) [Type: tuple<i16, i32>]
+// cdb-check:[...][0] : 16 [Type: [...]]
+// cdb-check:[...][1] : 17 [Type: [...]]
+
+// cdb-command:dx padding_at_end1,d
+// cdb-check:padding_at_end1,d [...]: (18, (19, 20)) [Type: tuple<i32, tuple<i32, i16>>]
+// cdb-check:[...][0] : 18 [Type: [...]]
+// cdb-check:[...][1] : (19, 20) [Type: tuple<i32, i16>]
+// cdb-command:dx padding_at_end1.__1,d
+// cdb-check:padding_at_end1.__1,d [...][Type: tuple<i32, i16>]
+// cdb-check:[...][0] : 19 [Type: [...]]
+// cdb-check:[...][1] : 20 [Type: [...]]
+// cdb-command:dx padding_at_end2,d
+// cdb-check:padding_at_end2,d [...]: ((21, 22), 23) [Type: tuple<tuple<i32, i16>, i32>]
+// cdb-check:[...][0] : (21, 22) [Type: tuple<i32, i16>]
+// cdb-check:[...][1] : 23 [Type: [...]]
+// cdb-command:dx padding_at_end2.__0,d
+// cdb-check:padding_at_end2.__0,d [...]: (21, 22) [Type: tuple<i32, i16>]
+// cdb-check:[...][0] : 21 [Type: [...]]
+// cdb-check:[...][1] : 22 [Type: [...]]
+
#![allow(unused_variables)]
#![feature(omit_gdb_pretty_printer_section)]
#![omit_gdb_pretty_printer_section]
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/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/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/dangling.rs b/src/test/ui/consts/const-eval/dangling.rs
index c6b8e8e..78cf000 100644
--- a/src/test/ui/consts/const-eval/dangling.rs
+++ b/src/test/ui/consts/const-eval/dangling.rs
@@ -1,4 +1,4 @@
-#![feature(const_transmute, const_raw_ptr_deref)]
+#![feature(const_raw_ptr_deref)]
use std::{mem, usize};
diff --git a/src/test/ui/consts/const-eval/double_check.rs b/src/test/ui/consts/const-eval/double_check.rs
index f156d25..56ca0aa 100644
--- a/src/test/ui/consts/const-eval/double_check.rs
+++ b/src/test/ui/consts/const-eval/double_check.rs
@@ -20,4 +20,6 @@
Union { u8: &BAR }.bar,
)};
+static FOO2: (&Foo, &Bar) = unsafe {(std::mem::transmute(&BAR), std::mem::transmute(&BAR))};
+
fn main() {}
diff --git a/src/test/ui/consts/const-eval/double_check2.rs b/src/test/ui/consts/const-eval/double_check2.rs
index 7c222b1..8402d62 100644
--- a/src/test/ui/consts/const-eval/double_check2.rs
+++ b/src/test/ui/consts/const-eval/double_check2.rs
@@ -17,5 +17,7 @@
Union { u8: &BAR }.foo,
Union { u8: &BAR }.bar,
)};
+static FOO2: (&Foo, &Bar) = unsafe {(std::mem::transmute(&BAR), std::mem::transmute(&BAR))};
+//~^ undefined behavior
fn main() {}
diff --git a/src/test/ui/consts/const-eval/double_check2.stderr b/src/test/ui/consts/const-eval/double_check2.stderr
index 513b71f..84f6080 100644
--- a/src/test/ui/consts/const-eval/double_check2.stderr
+++ b/src/test/ui/consts/const-eval/double_check2.stderr
@@ -9,6 +9,14 @@
|
= 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: aborting due to previous error
+error[E0080]: it is undefined behavior to use this value
+ --> $DIR/double_check2.rs:20:1
+ |
+LL | static FOO2: (&Foo, &Bar) = unsafe {(std::mem::transmute(&BAR), std::mem::transmute(&BAR))};
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered 0x05 at .1.<deref>.<enum-tag>, but expected a valid enum tag
+ |
+ = 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: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0080`.
diff --git a/src/test/ui/consts/const-eval/issue-55541.rs b/src/test/ui/consts/const-eval/issue-55541.rs
index 4c9e10d..fa5a493 100644
--- a/src/test/ui/consts/const-eval/issue-55541.rs
+++ b/src/test/ui/consts/const-eval/issue-55541.rs
@@ -2,7 +2,7 @@
// Test that we can handle newtypes wrapping extern types
-#![feature(extern_types, const_transmute)]
+#![feature(extern_types)]
use std::marker::PhantomData;
diff --git a/src/test/ui/consts/const-eval/transmute-const.rs b/src/test/ui/consts/const-eval/transmute-const.rs
index 48f2b39..1cfad00 100644
--- a/src/test/ui/consts/const-eval/transmute-const.rs
+++ b/src/test/ui/consts/const-eval/transmute-const.rs
@@ -1,5 +1,3 @@
-#![feature(const_transmute)]
-
use std::mem;
static FOO: bool = unsafe { mem::transmute(3u8) };
diff --git a/src/test/ui/consts/const-eval/transmute-const.stderr b/src/test/ui/consts/const-eval/transmute-const.stderr
index 0de6ead..46a4049 100644
--- a/src/test/ui/consts/const-eval/transmute-const.stderr
+++ b/src/test/ui/consts/const-eval/transmute-const.stderr
@@ -1,5 +1,5 @@
error[E0080]: it is undefined behavior to use this value
- --> $DIR/transmute-const.rs:5:1
+ --> $DIR/transmute-const.rs:3:1
|
LL | static FOO: bool = unsafe { mem::transmute(3u8) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered 0x03, but expected a boolean
diff --git a/src/test/ui/consts/const-eval/ub-enum.rs b/src/test/ui/consts/const-eval/ub-enum.rs
index c49997c..dc94f23 100644
--- a/src/test/ui/consts/const-eval/ub-enum.rs
+++ b/src/test/ui/consts/const-eval/ub-enum.rs
@@ -1,5 +1,5 @@
// normalize-stderr-64bit "0x0000000000" -> "0x00"
-#![feature(const_transmute, never_type)]
+#![feature(never_type)]
#![allow(const_err)] // make sure we cannot allow away the errors tested here
use std::mem;
@@ -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-eval/ub-int-array.rs b/src/test/ui/consts/const-eval/ub-int-array.rs
index 8907b0c..6801c7f 100644
--- a/src/test/ui/consts/const-eval/ub-int-array.rs
+++ b/src/test/ui/consts/const-eval/ub-int-array.rs
@@ -1,4 +1,3 @@
-#![feature(const_transmute)]
#![allow(const_err)] // make sure we cannot allow away the errors tested here
//! Test the "array of int" fast path in validity checking, and in particular whether it
diff --git a/src/test/ui/consts/const-eval/ub-int-array.stderr b/src/test/ui/consts/const-eval/ub-int-array.stderr
index b4a3c63..92f6548 100644
--- a/src/test/ui/consts/const-eval/ub-int-array.stderr
+++ b/src/test/ui/consts/const-eval/ub-int-array.stderr
@@ -1,5 +1,5 @@
error[E0080]: it is undefined behavior to use this value
- --> $DIR/ub-int-array.rs:15:1
+ --> $DIR/ub-int-array.rs:14:1
|
LL | / const UNINIT_INT_0: [u32; 3] = unsafe {
LL | |
@@ -13,7 +13,7 @@
= 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-int-array.rs:24:1
+ --> $DIR/ub-int-array.rs:23:1
|
LL | / const UNINIT_INT_1: [u32; 3] = unsafe {
LL | |
@@ -27,7 +27,7 @@
= 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-int-array.rs:44:1
+ --> $DIR/ub-int-array.rs:43:1
|
LL | / const UNINIT_INT_2: [u32; 3] = unsafe {
LL | |
diff --git a/src/test/ui/consts/const-eval/ub-nonnull.rs b/src/test/ui/consts/const-eval/ub-nonnull.rs
index 1f46b6c..4b90b892 100644
--- a/src/test/ui/consts/const-eval/ub-nonnull.rs
+++ b/src/test/ui/consts/const-eval/ub-nonnull.rs
@@ -1,4 +1,4 @@
-#![feature(rustc_attrs, const_transmute)]
+#![feature(rustc_attrs)]
#![allow(const_err, invalid_value)] // make sure we cannot allow away the errors tested here
use std::mem;
diff --git a/src/test/ui/consts/const-eval/ub-ref.rs b/src/test/ui/consts/const-eval/ub-ref.rs
index 10f4c8c..e8b101f 100644
--- a/src/test/ui/consts/const-eval/ub-ref.rs
+++ b/src/test/ui/consts/const-eval/ub-ref.rs
@@ -1,5 +1,4 @@
// ignore-tidy-linelength
-#![feature(const_transmute)]
#![allow(const_err, invalid_value)] // make sure we cannot allow away the errors tested here
use std::mem;
diff --git a/src/test/ui/consts/const-eval/ub-ref.stderr b/src/test/ui/consts/const-eval/ub-ref.stderr
index a219679..cd270f2 100644
--- a/src/test/ui/consts/const-eval/ub-ref.stderr
+++ b/src/test/ui/consts/const-eval/ub-ref.stderr
@@ -1,5 +1,5 @@
error[E0080]: it is undefined behavior to use this value
- --> $DIR/ub-ref.rs:7:1
+ --> $DIR/ub-ref.rs:6:1
|
LL | const UNALIGNED: &u16 = unsafe { mem::transmute(&[0u8; 4]) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered an unaligned reference (required 2 byte alignment but found 1)
@@ -7,7 +7,7 @@
= 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-ref.rs:11:1
+ --> $DIR/ub-ref.rs:10:1
|
LL | const UNALIGNED_BOX: Box<u16> = unsafe { mem::transmute(&[0u8; 4]) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered an unaligned box (required 2 byte alignment but found 1)
@@ -15,7 +15,7 @@
= 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-ref.rs:15:1
+ --> $DIR/ub-ref.rs:14:1
|
LL | const NULL: &u16 = unsafe { mem::transmute(0usize) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a NULL reference
@@ -23,7 +23,7 @@
= 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-ref.rs:18:1
+ --> $DIR/ub-ref.rs:17:1
|
LL | const NULL_BOX: Box<u16> = unsafe { mem::transmute(0usize) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a NULL box
@@ -31,7 +31,7 @@
= 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-ref.rs:24:1
+ --> $DIR/ub-ref.rs:23:1
|
LL | const REF_AS_USIZE: usize = unsafe { mem::transmute(&0) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc16, but expected initialized plain (non-pointer) bytes
@@ -39,7 +39,7 @@
= 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-ref.rs:27:1
+ --> $DIR/ub-ref.rs:26:1
|
LL | const REF_AS_USIZE_SLICE: &[usize] = &[unsafe { mem::transmute(&0) }];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a pointer at .<deref>, but expected plain (non-pointer) bytes
@@ -47,7 +47,7 @@
= 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-ref.rs:30:1
+ --> $DIR/ub-ref.rs:29:1
|
LL | const REF_AS_USIZE_BOX_SLICE: Box<[usize]> = unsafe { mem::transmute::<&[usize], _>(&[mem::transmute(&0)]) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a pointer at .<deref>, but expected plain (non-pointer) bytes
@@ -55,7 +55,7 @@
= 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-ref.rs:33:1
+ --> $DIR/ub-ref.rs:32:1
|
LL | const USIZE_AS_REF: &'static u8 = unsafe { mem::transmute(1337usize) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a dangling reference (created from integer)
@@ -63,7 +63,7 @@
= 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-ref.rs:36:1
+ --> $DIR/ub-ref.rs:35:1
|
LL | const USIZE_AS_BOX: Box<u8> = unsafe { mem::transmute(1337usize) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a dangling box (created from integer)
diff --git a/src/test/ui/consts/const-eval/ub-uninhabit.rs b/src/test/ui/consts/const-eval/ub-uninhabit.rs
index e7350ae..b81bca3 100644
--- a/src/test/ui/consts/const-eval/ub-uninhabit.rs
+++ b/src/test/ui/consts/const-eval/ub-uninhabit.rs
@@ -1,4 +1,3 @@
-#![feature(const_transmute)]
#![allow(const_err)] // make sure we cannot allow away the errors tested here
use std::mem;
diff --git a/src/test/ui/consts/const-eval/ub-uninhabit.stderr b/src/test/ui/consts/const-eval/ub-uninhabit.stderr
index 8ce4279..16f5316 100644
--- a/src/test/ui/consts/const-eval/ub-uninhabit.stderr
+++ b/src/test/ui/consts/const-eval/ub-uninhabit.stderr
@@ -1,5 +1,5 @@
error[E0080]: it is undefined behavior to use this value
- --> $DIR/ub-uninhabit.rs:15:1
+ --> $DIR/ub-uninhabit.rs:14:1
|
LL | const BAD_BAD_BAD: Bar = unsafe { MaybeUninit { uninit: () }.init };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of uninhabited type Bar
@@ -7,7 +7,7 @@
= 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-uninhabit.rs:18:1
+ --> $DIR/ub-uninhabit.rs:17:1
|
LL | const BAD_BAD_REF: &Bar = unsafe { mem::transmute(1usize) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of uninhabited type Bar at .<deref>
@@ -15,7 +15,7 @@
= 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-uninhabit.rs:21:1
+ --> $DIR/ub-uninhabit.rs:20:1
|
LL | const BAD_BAD_ARRAY: [Bar; 1] = unsafe { MaybeUninit { uninit: () }.init };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of uninhabited type Bar at [0]
diff --git a/src/test/ui/consts/const-eval/ub-upvars.rs b/src/test/ui/consts/const-eval/ub-upvars.rs
index baab14d..5d19276 100644
--- a/src/test/ui/consts/const-eval/ub-upvars.rs
+++ b/src/test/ui/consts/const-eval/ub-upvars.rs
@@ -1,4 +1,3 @@
-#![feature(const_transmute)]
#![allow(const_err, invalid_value)] // make sure we cannot allow away the errors tested here
use std::mem;
diff --git a/src/test/ui/consts/const-eval/ub-upvars.stderr b/src/test/ui/consts/const-eval/ub-upvars.stderr
index 972c9eb..afd6c90 100644
--- a/src/test/ui/consts/const-eval/ub-upvars.stderr
+++ b/src/test/ui/consts/const-eval/ub-upvars.stderr
@@ -1,5 +1,5 @@
error[E0080]: it is undefined behavior to use this value
- --> $DIR/ub-upvars.rs:6:1
+ --> $DIR/ub-upvars.rs:5:1
|
LL | / const BAD_UPVAR: &dyn FnOnce() = &{
LL | | let bad_ref: &'static u16 = unsafe { mem::transmute(0usize) };
diff --git a/src/test/ui/consts/const-eval/ub-wide-ptr.rs b/src/test/ui/consts/const-eval/ub-wide-ptr.rs
index f69f6a1..3e148af 100644
--- a/src/test/ui/consts/const-eval/ub-wide-ptr.rs
+++ b/src/test/ui/consts/const-eval/ub-wide-ptr.rs
@@ -1,5 +1,4 @@
// ignore-tidy-linelength
-#![feature(const_transmute)]
#![allow(unused)]
#![allow(const_err)] // make sure we cannot allow away the errors tested here
diff --git a/src/test/ui/consts/const-eval/ub-wide-ptr.stderr b/src/test/ui/consts/const-eval/ub-wide-ptr.stderr
index 47d29ff..b750910 100644
--- a/src/test/ui/consts/const-eval/ub-wide-ptr.stderr
+++ b/src/test/ui/consts/const-eval/ub-wide-ptr.stderr
@@ -1,5 +1,5 @@
error[E0080]: it is undefined behavior to use this value
- --> $DIR/ub-wide-ptr.rs:32:1
+ --> $DIR/ub-wide-ptr.rs:31:1
|
LL | const STR_TOO_LONG: &str = unsafe { mem::transmute((&42u8, 999usize)) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a dangling reference (going beyond the bounds of its allocation)
@@ -7,7 +7,7 @@
= 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-wide-ptr.rs:34:1
+ --> $DIR/ub-wide-ptr.rs:33:1
|
LL | const NESTED_STR_MUCH_TOO_LONG: (&str,) = (unsafe { mem::transmute((&42, usize::MAX)) },);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered invalid reference metadata: slice is bigger than largest supported object at .0
@@ -15,7 +15,7 @@
= 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-wide-ptr.rs:37:1
+ --> $DIR/ub-wide-ptr.rs:36:1
|
LL | const STR_LENGTH_PTR: &str = unsafe { mem::transmute((&42u8, &3)) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered non-integer slice length in wide pointer
@@ -23,7 +23,7 @@
= 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-wide-ptr.rs:40:1
+ --> $DIR/ub-wide-ptr.rs:39:1
|
LL | const MY_STR_LENGTH_PTR: &MyStr = unsafe { mem::transmute((&42u8, &3)) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered non-integer slice length in wide pointer
@@ -31,7 +31,7 @@
= 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-wide-ptr.rs:42:1
+ --> $DIR/ub-wide-ptr.rs:41:1
|
LL | const MY_STR_MUCH_TOO_LONG: &MyStr = unsafe { mem::transmute((&42u8, usize::MAX)) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered invalid reference metadata: slice is bigger than largest supported object
@@ -39,7 +39,7 @@
= 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-wide-ptr.rs:46:1
+ --> $DIR/ub-wide-ptr.rs:45:1
|
LL | const STR_NO_INIT: &str = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized data in `str` at .<deref>
@@ -47,7 +47,7 @@
= 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-wide-ptr.rs:49:1
+ --> $DIR/ub-wide-ptr.rs:48:1
|
LL | const MYSTR_NO_INIT: &MyStr = unsafe { mem::transmute::<&[_], _>(&[MaybeUninit::<u8> { uninit: () }]) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized data in `str` at .<deref>.0
@@ -55,7 +55,7 @@
= 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-wide-ptr.rs:56:1
+ --> $DIR/ub-wide-ptr.rs:55:1
|
LL | / const SLICE_LENGTH_UNINIT: &[u8] = unsafe {
LL | |
@@ -67,7 +67,7 @@
= 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-wide-ptr.rs:62:1
+ --> $DIR/ub-wide-ptr.rs:61:1
|
LL | const SLICE_TOO_LONG: &[u8] = unsafe { mem::transmute((&42u8, 999usize)) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a dangling reference (going beyond the bounds of its allocation)
@@ -75,7 +75,7 @@
= 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-wide-ptr.rs:65:1
+ --> $DIR/ub-wide-ptr.rs:64:1
|
LL | const SLICE_LENGTH_PTR: &[u8] = unsafe { mem::transmute((&42u8, &3)) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered non-integer slice length in wide pointer
@@ -83,7 +83,7 @@
= 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-wide-ptr.rs:68:1
+ --> $DIR/ub-wide-ptr.rs:67:1
|
LL | const SLICE_TOO_LONG_BOX: Box<[u8]> = unsafe { mem::transmute((&42u8, 999usize)) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a dangling box (going beyond the bounds of its allocation)
@@ -91,7 +91,7 @@
= 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-wide-ptr.rs:71:1
+ --> $DIR/ub-wide-ptr.rs:70:1
|
LL | const SLICE_LENGTH_PTR_BOX: Box<[u8]> = unsafe { mem::transmute((&42u8, &3)) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered non-integer slice length in wide pointer
@@ -99,7 +99,7 @@
= 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-wide-ptr.rs:75:1
+ --> $DIR/ub-wide-ptr.rs:74:1
|
LL | const SLICE_CONTENT_INVALID: &[bool] = &[unsafe { mem::transmute(3u8) }];
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered 0x03 at .<deref>[0], but expected a boolean
@@ -107,7 +107,7 @@
= 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-wide-ptr.rs:81:1
+ --> $DIR/ub-wide-ptr.rs:80:1
|
LL | const MYSLICE_PREFIX_BAD: &MySliceBool = &MySlice(unsafe { mem::transmute(3u8) }, [false]);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered 0x03 at .<deref>.0, but expected a boolean
@@ -115,7 +115,7 @@
= 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-wide-ptr.rs:84:1
+ --> $DIR/ub-wide-ptr.rs:83:1
|
LL | const MYSLICE_SUFFIX_BAD: &MySliceBool = &MySlice(true, [unsafe { mem::transmute(3u8) }]);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered 0x03 at .<deref>.1[0], but expected a boolean
@@ -123,7 +123,7 @@
= 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-wide-ptr.rs:91:1
+ --> $DIR/ub-wide-ptr.rs:90:1
|
LL | / const RAW_SLICE_LENGTH_UNINIT: *const [u8] = unsafe {
LL | |
@@ -135,7 +135,7 @@
= 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-wide-ptr.rs:99:1
+ --> $DIR/ub-wide-ptr.rs:98:1
|
LL | const TRAIT_OBJ_SHORT_VTABLE_1: &dyn Trait = unsafe { mem::transmute((&92u8, &3u8)) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered too small vtable
@@ -143,7 +143,7 @@
= 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-wide-ptr.rs:102:1
+ --> $DIR/ub-wide-ptr.rs:101:1
|
LL | const TRAIT_OBJ_SHORT_VTABLE_2: &dyn Trait = unsafe { mem::transmute((&92u8, &3u64)) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered too small vtable
@@ -151,7 +151,7 @@
= 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-wide-ptr.rs:105:1
+ --> $DIR/ub-wide-ptr.rs:104:1
|
LL | const TRAIT_OBJ_INT_VTABLE: &dyn Trait = unsafe { mem::transmute((&92u8, 4usize)) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered dangling vtable pointer in wide pointer
@@ -159,7 +159,7 @@
= 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-wide-ptr.rs:107:1
+ --> $DIR/ub-wide-ptr.rs:106:1
|
LL | const TRAIT_OBJ_UNALIGNED_VTABLE: &dyn Trait = unsafe { mem::transmute((&92u8, &[0u8; 128])) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered unaligned vtable pointer in wide pointer
@@ -167,7 +167,7 @@
= 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-wide-ptr.rs:109:1
+ --> $DIR/ub-wide-ptr.rs:108:1
|
LL | const TRAIT_OBJ_BAD_DROP_FN_NULL: &dyn Trait = unsafe { mem::transmute((&92u8, &[0usize; 8])) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered invalid drop function pointer in vtable (not pointing to a function)
@@ -175,7 +175,7 @@
= 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-wide-ptr.rs:111:1
+ --> $DIR/ub-wide-ptr.rs:110:1
|
LL | const TRAIT_OBJ_BAD_DROP_FN_INT: &dyn Trait = unsafe { mem::transmute((&92u8, &[1usize; 8])) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered invalid drop function pointer in vtable (not pointing to a function)
@@ -183,7 +183,7 @@
= 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-wide-ptr.rs:113:1
+ --> $DIR/ub-wide-ptr.rs:112:1
|
LL | const TRAIT_OBJ_BAD_DROP_FN_NOT_FN_PTR: &dyn Trait = unsafe { mem::transmute((&92u8, &[&42u8; 8])) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered invalid drop function pointer in vtable (not pointing to a function)
@@ -191,7 +191,7 @@
= 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-wide-ptr.rs:117:1
+ --> $DIR/ub-wide-ptr.rs:116:1
|
LL | const TRAIT_OBJ_CONTENT_INVALID: &dyn Trait = unsafe { mem::transmute::<_, &bool>(&3u8) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered 0x03 at .<deref>.<dyn-downcast>, but expected a boolean
@@ -199,7 +199,7 @@
= 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-wide-ptr.rs:121:1
+ --> $DIR/ub-wide-ptr.rs:120:1
|
LL | const RAW_TRAIT_OBJ_VTABLE_NULL: *const dyn Trait = unsafe { mem::transmute((&92u8, 0usize)) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered dangling vtable pointer in wide pointer
@@ -207,7 +207,7 @@
= 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-wide-ptr.rs:123:1
+ --> $DIR/ub-wide-ptr.rs:122:1
|
LL | const RAW_TRAIT_OBJ_VTABLE_INVALID: *const dyn Trait = unsafe { mem::transmute((&92u8, &3u64)) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered too small vtable
@@ -215,13 +215,13 @@
= 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]: could not evaluate static initializer
- --> $DIR/ub-wide-ptr.rs:129:5
+ --> $DIR/ub-wide-ptr.rs:128:5
|
LL | mem::transmute::<_, &dyn Trait>((&92u8, 0usize))
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ inbounds test failed: 0x0 is not a valid pointer
error[E0080]: could not evaluate static initializer
- --> $DIR/ub-wide-ptr.rs:133:5
+ --> $DIR/ub-wide-ptr.rs:132:5
|
LL | mem::transmute::<_, &dyn Trait>((&92u8, &3u64))
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: pointer must be in-bounds at offset N, but is outside bounds of allocN which has size N
diff --git a/src/test/ui/consts/const-eval/valid-const.rs b/src/test/ui/consts/const-eval/valid-const.rs
index 65c642d..9e47071 100644
--- a/src/test/ui/consts/const-eval/valid-const.rs
+++ b/src/test/ui/consts/const-eval/valid-const.rs
@@ -1,7 +1,6 @@
// check-pass
// Some constants that *are* valid
-#![feature(const_transmute)]
#![deny(const_err)]
use std::mem;
diff --git a/src/test/ui/consts/const-eval/validate_uninhabited_zsts.rs b/src/test/ui/consts/const-eval/validate_uninhabited_zsts.rs
index f18e00f..48a989b 100644
--- a/src/test/ui/consts/const-eval/validate_uninhabited_zsts.rs
+++ b/src/test/ui/consts/const-eval/validate_uninhabited_zsts.rs
@@ -1,5 +1,5 @@
#![feature(const_fn)]
-#![feature(const_transmute)]
+#![feature(const_fn_transmute)]
const fn foo() -> ! {
unsafe { std::mem::transmute(()) }
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/consts-in-patterns.rs b/src/test/ui/consts/consts-in-patterns.rs
index ee1e3cc..d512154 100644
--- a/src/test/ui/consts/consts-in-patterns.rs
+++ b/src/test/ui/consts/consts-in-patterns.rs
@@ -1,5 +1,4 @@
// run-pass
-#![feature(const_transmute)]
const FOO: isize = 10;
const BAR: isize = 3;
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/consts/miri_unleashed/abi-mismatch.stderr b/src/test/ui/consts/miri_unleashed/abi-mismatch.stderr
index d55090c..eb25008 100644
--- a/src/test/ui/consts/miri_unleashed/abi-mismatch.stderr
+++ b/src/test/ui/consts/miri_unleashed/abi-mismatch.stderr
@@ -17,11 +17,6 @@
|
LL | my_fn();
| ^^^^^^^
-help: skipping check that does not even have a feature gate
- --> $DIR/abi-mismatch.rs:16:40
- |
-LL | static VAL: () = call_rust_fn(unsafe { std::mem::transmute(c_fn as extern "C" fn()) });
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to previous error; 1 warning emitted
diff --git a/src/test/ui/consts/miri_unleashed/ptr_arith.stderr b/src/test/ui/consts/miri_unleashed/ptr_arith.stderr
index 21f11dd..d782a36 100644
--- a/src/test/ui/consts/miri_unleashed/ptr_arith.stderr
+++ b/src/test/ui/consts/miri_unleashed/ptr_arith.stderr
@@ -17,11 +17,6 @@
|
LL | let _v = x == x;
| ^^^^^^
-help: skipping check that does not even have a feature gate
- --> $DIR/ptr_arith.rs:15:20
- |
-LL | let x: usize = std::mem::transmute(&0);
- | ^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 2 previous errors; 1 warning emitted
diff --git a/src/test/ui/consts/transmute-const.rs b/src/test/ui/consts/transmute-const.rs
index e24f89c..5044d99 100644
--- a/src/test/ui/consts/transmute-const.rs
+++ b/src/test/ui/consts/transmute-const.rs
@@ -1,7 +1,5 @@
// run-pass
-#![feature(const_transmute)]
-
use std::mem;
#[repr(transparent)]
diff --git a/src/test/ui/error-codes/E0261.stderr b/src/test/ui/error-codes/E0261.stderr
index 0eab2dc..33d74fe 100644
--- a/src/test/ui/error-codes/E0261.stderr
+++ b/src/test/ui/error-codes/E0261.stderr
@@ -5,6 +5,8 @@
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/E0261.rs:5:9
@@ -13,6 +15,8 @@
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | x: &'a str,
| ^^ undeclared lifetime
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error: aborting due to 2 previous errors
diff --git a/src/test/ui/feature-gates/feature-gate-const_fn_transmute.rs b/src/test/ui/feature-gates/feature-gate-const_fn_transmute.rs
new file mode 100644
index 0000000..981680b
--- /dev/null
+++ b/src/test/ui/feature-gates/feature-gate-const_fn_transmute.rs
@@ -0,0 +1,38 @@
+use std::mem;
+
+#[repr(transparent)]
+struct Foo(u32);
+
+const TRANSMUTED_U32: u32 = unsafe { mem::transmute(Foo(3)) };
+
+const fn transmute_fn() -> u32 { unsafe { mem::transmute(Foo(3)) } }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+
+const fn transmute_fn_intrinsic() -> u32 { unsafe { std::intrinsics::transmute(Foo(3)) } }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+
+const fn transmute_fn_core_intrinsic() -> u32 { unsafe { core::intrinsics::transmute(Foo(3)) } }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+
+const unsafe fn unsafe_transmute_fn() -> u32 { mem::transmute(Foo(3)) }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+
+const unsafe fn unsafe_transmute_fn_intrinsic() -> u32 { std::intrinsics::transmute(Foo(3)) }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+
+const unsafe fn unsafe_transmute_fn_core_intrinsic() -> u32 { core::intrinsics::transmute(Foo(3)) }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+
+const fn safe_transmute_fn() -> u32 { mem::transmute(Foo(3)) }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+//~| ERROR call to unsafe function is unsafe and requires unsafe function or block
+
+const fn safe_transmute_fn_intrinsic() -> u32 { std::intrinsics::transmute(Foo(3)) }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+//~| ERROR call to unsafe function is unsafe and requires unsafe function or block
+
+const fn safe_transmute_fn_core_intrinsic() -> u32 { core::intrinsics::transmute(Foo(3)) }
+//~^ ERROR can only call `transmute` from const items, not `const fn`
+//~| ERROR call to unsafe function is unsafe and requires unsafe function or block
+
+fn main() {}
diff --git a/src/test/ui/feature-gates/feature-gate-const_fn_transmute.stderr b/src/test/ui/feature-gates/feature-gate-const_fn_transmute.stderr
new file mode 100644
index 0000000..44430fd
--- /dev/null
+++ b/src/test/ui/feature-gates/feature-gate-const_fn_transmute.stderr
@@ -0,0 +1,109 @@
+error[E0723]: can only call `transmute` from const items, not `const fn`
+ --> $DIR/feature-gate-const_fn_transmute.rs:8:43
+ |
+LL | const fn transmute_fn() -> u32 { unsafe { mem::transmute(Foo(3)) } }
+ | ^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = 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]: can only call `transmute` from const items, not `const fn`
+ --> $DIR/feature-gate-const_fn_transmute.rs:11:53
+ |
+LL | const fn transmute_fn_intrinsic() -> u32 { unsafe { std::intrinsics::transmute(Foo(3)) } }
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = 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]: can only call `transmute` from const items, not `const fn`
+ --> $DIR/feature-gate-const_fn_transmute.rs:14:58
+ |
+LL | const fn transmute_fn_core_intrinsic() -> u32 { unsafe { core::intrinsics::transmute(Foo(3)) } }
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = 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]: can only call `transmute` from const items, not `const fn`
+ --> $DIR/feature-gate-const_fn_transmute.rs:17:48
+ |
+LL | const unsafe fn unsafe_transmute_fn() -> u32 { mem::transmute(Foo(3)) }
+ | ^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = 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]: can only call `transmute` from const items, not `const fn`
+ --> $DIR/feature-gate-const_fn_transmute.rs:20:58
+ |
+LL | const unsafe fn unsafe_transmute_fn_intrinsic() -> u32 { std::intrinsics::transmute(Foo(3)) }
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = 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]: can only call `transmute` from const items, not `const fn`
+ --> $DIR/feature-gate-const_fn_transmute.rs:23:63
+ |
+LL | const unsafe fn unsafe_transmute_fn_core_intrinsic() -> u32 { core::intrinsics::transmute(Foo(3)) }
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = 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]: can only call `transmute` from const items, not `const fn`
+ --> $DIR/feature-gate-const_fn_transmute.rs:26:39
+ |
+LL | const fn safe_transmute_fn() -> u32 { mem::transmute(Foo(3)) }
+ | ^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = 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]: can only call `transmute` from const items, not `const fn`
+ --> $DIR/feature-gate-const_fn_transmute.rs:30:49
+ |
+LL | const fn safe_transmute_fn_intrinsic() -> u32 { std::intrinsics::transmute(Foo(3)) }
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = 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]: can only call `transmute` from const items, not `const fn`
+ --> $DIR/feature-gate-const_fn_transmute.rs:34:54
+ |
+LL | const fn safe_transmute_fn_core_intrinsic() -> u32 { core::intrinsics::transmute(Foo(3)) }
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = 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[E0133]: call to unsafe function is unsafe and requires unsafe function or block
+ --> $DIR/feature-gate-const_fn_transmute.rs:26:39
+ |
+LL | const fn safe_transmute_fn() -> u32 { mem::transmute(Foo(3)) }
+ | ^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
+ |
+ = note: consult the function's documentation for information on how to avoid undefined behavior
+
+error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
+ --> $DIR/feature-gate-const_fn_transmute.rs:30:49
+ |
+LL | const fn safe_transmute_fn_intrinsic() -> u32 { std::intrinsics::transmute(Foo(3)) }
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
+ |
+ = note: consult the function's documentation for information on how to avoid undefined behavior
+
+error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
+ --> $DIR/feature-gate-const_fn_transmute.rs:34:54
+ |
+LL | const fn safe_transmute_fn_core_intrinsic() -> u32 { core::intrinsics::transmute(Foo(3)) }
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
+ |
+ = note: consult the function's documentation for information on how to avoid undefined behavior
+
+error: aborting due to 12 previous errors
+
+Some errors have detailed explanations: E0133, E0723.
+For more information about an error, try `rustc --explain E0133`.
diff --git a/src/test/ui/feature-gates/feature-gate-const_transmute.rs b/src/test/ui/feature-gates/feature-gate-const_transmute.rs
deleted file mode 100644
index da53264..0000000
--- a/src/test/ui/feature-gates/feature-gate-const_transmute.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-use std::mem;
-
-#[repr(transparent)]
-struct Foo(u32);
-
-const TRANSMUTED_U32: u32 = unsafe { mem::transmute(Foo(3)) };
-//~^ ERROR `std::intrinsics::transmute` is not yet stable as a const fn
-
-fn main() {}
diff --git a/src/test/ui/feature-gates/feature-gate-const_transmute.stderr b/src/test/ui/feature-gates/feature-gate-const_transmute.stderr
deleted file mode 100644
index 772e8d2..0000000
--- a/src/test/ui/feature-gates/feature-gate-const_transmute.stderr
+++ /dev/null
@@ -1,10 +0,0 @@
-error: `std::intrinsics::transmute` is not yet stable as a const fn
- --> $DIR/feature-gate-const_transmute.rs:6:38
- |
-LL | const TRANSMUTED_U32: u32 = unsafe { mem::transmute(Foo(3)) };
- | ^^^^^^^^^^^^^^^^^^^^^^
- |
- = help: add `#![feature(const_transmute)]` to the crate attributes to enable
-
-error: aborting due to previous error
-
diff --git a/src/test/ui/feature-gates/feature-gate-in_band_lifetimes.stderr b/src/test/ui/feature-gates/feature-gate-in_band_lifetimes.stderr
index bbf3ea8..0f0406b 100644
--- a/src/test/ui/feature-gates/feature-gate-in_band_lifetimes.stderr
+++ b/src/test/ui/feature-gates/feature-gate-in_band_lifetimes.stderr
@@ -5,6 +5,8 @@
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'x` here: `<'x>`
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'x`
--> $DIR/feature-gate-in_band_lifetimes.rs:3:23
@@ -13,6 +15,8 @@
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'x` here: `<'x>`
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/feature-gate-in_band_lifetimes.rs:15:12
@@ -28,6 +32,7 @@
LL | fn inner_2(&self) -> &'b u8 {
| ^^ undeclared lifetime
|
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b, 'a> X<'b> {
@@ -44,6 +49,8 @@
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'b` here: `<'b>`
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/feature-gate-in_band_lifetimes.rs:25:27
@@ -51,6 +58,7 @@
LL | fn inner_3(&self) -> &'b u8 {
| ^^ undeclared lifetime
|
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b> X<'b> {
@@ -67,6 +75,8 @@
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/feature-gate-in_band_lifetimes.rs:35:25
@@ -74,6 +84,7 @@
LL | fn inner(&self) -> &'a u8 {
| ^^ undeclared lifetime
|
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'a` here
|
LL | impl<'a> Y<&'a u8> {
@@ -89,6 +100,7 @@
LL | fn any_lifetime() -> &'b u8;
| ^^ undeclared lifetime
|
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | trait MyTrait<'b, 'a> {
@@ -104,6 +116,7 @@
LL | fn borrowed_lifetime(&'b self) -> &'b u8;
| ^^ undeclared lifetime
|
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | trait MyTrait<'b, 'a> {
@@ -119,6 +132,7 @@
LL | fn borrowed_lifetime(&'b self) -> &'b u8;
| ^^ undeclared lifetime
|
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | trait MyTrait<'b, 'a> {
@@ -135,6 +149,8 @@
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/feature-gate-in_band_lifetimes.rs:50:25
@@ -143,6 +159,8 @@
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/feature-gate-in_band_lifetimes.rs:53:31
@@ -150,6 +168,7 @@
LL | fn my_lifetime(&self) -> &'a u8 { self.0 }
| ^^ undeclared lifetime
|
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'a` here
|
LL | impl<'a> MyTrait<'a> for Y<&'a u8> {
@@ -165,6 +184,7 @@
LL | fn any_lifetime() -> &'b u8 { &0 }
| ^^ undeclared lifetime
|
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b> MyTrait<'a> for Y<&'a u8> {
@@ -180,6 +200,7 @@
LL | fn borrowed_lifetime(&'b self) -> &'b u8 { &*self.0 }
| ^^ undeclared lifetime
|
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b> MyTrait<'a> for Y<&'a u8> {
@@ -195,6 +216,7 @@
LL | fn borrowed_lifetime(&'b self) -> &'b u8 { &*self.0 }
| ^^ undeclared lifetime
|
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b> MyTrait<'a> for Y<&'a u8> {
diff --git a/src/test/ui/generic-associated-types/generic_associated_type_undeclared_lifetimes.stderr b/src/test/ui/generic-associated-types/generic_associated_type_undeclared_lifetimes.stderr
index fc2ce1c..f164c0d 100644
--- a/src/test/ui/generic-associated-types/generic_associated_type_undeclared_lifetimes.stderr
+++ b/src/test/ui/generic-associated-types/generic_associated_type_undeclared_lifetimes.stderr
@@ -4,6 +4,7 @@
LL | + Deref<Target = Self::Item<'b>>;
| ^^ undeclared lifetime
|
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | trait Iterable<'b> {
@@ -19,6 +20,7 @@
LL | fn iter<'a>(&'a self) -> Self::Iter<'undeclared>;
| ^^^^^^^^^^^ undeclared lifetime
|
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'undeclared` here
|
LL | trait Iterable<'undeclared> {
diff --git a/src/test/ui/internal/internal-unstable-const.rs b/src/test/ui/internal/internal-unstable-const.rs
index 3b3a295..b923bc2 100644
--- a/src/test/ui/internal/internal-unstable-const.rs
+++ b/src/test/ui/internal/internal-unstable-const.rs
@@ -8,7 +8,7 @@
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_stable(feature = "rust1", since = "1.0.0")]
pub const fn foo() -> i32 {
- unsafe { std::mem::transmute(4u32) } //~ ERROR is not stable as `const fn`
+ unsafe { std::mem::transmute(4u32) } //~ ERROR can only call `transmute` from const items
}
fn main() {}
diff --git a/src/test/ui/internal/internal-unstable-const.stderr b/src/test/ui/internal/internal-unstable-const.stderr
index 5a2c58f..9626df2 100644
--- a/src/test/ui/internal/internal-unstable-const.stderr
+++ b/src/test/ui/internal/internal-unstable-const.stderr
@@ -1,4 +1,4 @@
-error[E0723]: can only call other `const fn` within a `const fn`, but `const std::intrinsics::transmute::<u32, i32>` is not stable as `const fn`
+error[E0723]: can only call `transmute` from const items, not `const fn`
--> $DIR/internal-unstable-const.rs:11:14
|
LL | unsafe { std::mem::transmute(4u32) }
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/issues/issue-74236/auxiliary/dep.rs b/src/test/ui/issues/issue-74236/auxiliary/dep.rs
new file mode 100644
index 0000000..45f2601
--- /dev/null
+++ b/src/test/ui/issues/issue-74236/auxiliary/dep.rs
@@ -0,0 +1,8 @@
+// edition:2018
+
+mod private { pub struct Pub; }
+
+// Reexport built-in attribute without a DefId (requires Rust 2018).
+pub use cfg_attr as attr;
+// This export needs to be after the built-in attribute to trigger the bug.
+pub use private::Pub as Renamed;
diff --git a/src/test/ui/issues/issue-74236/main.rs b/src/test/ui/issues/issue-74236/main.rs
new file mode 100644
index 0000000..daa7cfc
--- /dev/null
+++ b/src/test/ui/issues/issue-74236/main.rs
@@ -0,0 +1,9 @@
+// edition:2018
+// aux-build:dep.rs
+// compile-flags:--extern dep
+
+fn main() {
+ // Trigger an error that will print the path of dep::private::Pub (as "dep::Renamed").
+ let () = dep::Renamed;
+ //~^ ERROR mismatched types
+}
diff --git a/src/test/ui/issues/issue-74236/main.stderr b/src/test/ui/issues/issue-74236/main.stderr
new file mode 100644
index 0000000..51d4833
--- /dev/null
+++ b/src/test/ui/issues/issue-74236/main.stderr
@@ -0,0 +1,11 @@
+error[E0308]: mismatched types
+ --> $DIR/main.rs:7:9
+ |
+LL | let () = dep::Renamed;
+ | ^^ ------------ this expression has type `dep::Renamed`
+ | |
+ | expected struct `dep::Renamed`, found `()`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.
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/methods/method-call-lifetime-args-unresolved.stderr b/src/test/ui/methods/method-call-lifetime-args-unresolved.stderr
index c9f235c..93c0384 100644
--- a/src/test/ui/methods/method-call-lifetime-args-unresolved.stderr
+++ b/src/test/ui/methods/method-call-lifetime-args-unresolved.stderr
@@ -5,6 +5,8 @@
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | 0.clone::<'a>();
| ^^ undeclared lifetime
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error: aborting due to previous error
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/regions/regions-in-enums.stderr b/src/test/ui/regions/regions-in-enums.stderr
index 6653765..d56c1fb 100644
--- a/src/test/ui/regions/regions-in-enums.stderr
+++ b/src/test/ui/regions/regions-in-enums.stderr
@@ -5,6 +5,8 @@
| - help: consider introducing lifetime `'foo` here: `<'foo>`
LL | X5(&'foo usize)
| ^^^^ undeclared lifetime
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-in-enums.rs:17:9
@@ -13,6 +15,8 @@
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | X6(&'a usize)
| ^^ undeclared lifetime
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error: aborting due to 2 previous errors
diff --git a/src/test/ui/regions/regions-in-structs.stderr b/src/test/ui/regions/regions-in-structs.stderr
index 5dfdc2e..2750149 100644
--- a/src/test/ui/regions/regions-in-structs.stderr
+++ b/src/test/ui/regions/regions-in-structs.stderr
@@ -5,6 +5,8 @@
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | a: &'a isize,
| ^^ undeclared lifetime
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-in-structs.rs:11:9
@@ -14,6 +16,8 @@
LL | a: &'a isize,
LL | b: &'a isize,
| ^^ undeclared lifetime
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error: aborting due to 2 previous errors
diff --git a/src/test/ui/regions/regions-name-undeclared.stderr b/src/test/ui/regions/regions-name-undeclared.stderr
index eb19a30..57d39d5 100644
--- a/src/test/ui/regions/regions-name-undeclared.stderr
+++ b/src/test/ui/regions/regions-name-undeclared.stderr
@@ -4,6 +4,7 @@
LL | fn m4(&self, arg: &'b isize) { }
| ^^ undeclared lifetime
|
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b, 'a> Foo<'a> {
@@ -19,6 +20,7 @@
LL | fn m5(&'b self) { }
| ^^ undeclared lifetime
|
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b, 'a> Foo<'a> {
@@ -34,6 +36,7 @@
LL | fn m6(&self, arg: Foo<'b>) { }
| ^^ undeclared lifetime
|
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b, 'a> Foo<'a> {
@@ -50,6 +53,8 @@
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-name-undeclared.rs:27:13
@@ -58,6 +63,8 @@
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | E1(&'a isize)
| ^^ undeclared lifetime
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-name-undeclared.rs:30:13
@@ -66,6 +73,8 @@
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | f: &'a isize
| ^^ undeclared lifetime
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-name-undeclared.rs:32:14
@@ -74,6 +83,8 @@
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-name-undeclared.rs:40:17
@@ -82,6 +93,8 @@
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/regions-name-undeclared.rs:42:36
@@ -90,6 +103,7 @@
| ^^ undeclared lifetime
|
= note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | fn fn_types<'b>(a: &'a isize,
@@ -106,6 +120,7 @@
| ^^ undeclared lifetime
|
= note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | fn fn_types<'b>(a: &'a isize,
@@ -123,6 +138,8 @@
...
LL | c: &'a isize)
| ^^ undeclared lifetime
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error: aborting due to 11 previous errors
diff --git a/src/test/ui/regions/regions-undeclared.stderr b/src/test/ui/regions/regions-undeclared.stderr
index 6bfde55..f3cae18 100644
--- a/src/test/ui/regions/regions-undeclared.stderr
+++ b/src/test/ui/regions/regions-undeclared.stderr
@@ -11,6 +11,8 @@
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | Foo(&'a isize),
| ^^ undeclared lifetime
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-undeclared.rs:5:10
@@ -20,6 +22,8 @@
LL | Foo(&'a isize),
LL | Bar(&'a isize),
| ^^ undeclared lifetime
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-undeclared.rs:8:15
@@ -28,6 +32,8 @@
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-undeclared.rs:9:15
@@ -36,6 +42,8 @@
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | y: &'a isize)
| ^^ undeclared lifetime
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error: aborting due to 5 previous errors
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/self/suggest-self.stderr b/src/test/ui/self/suggest-self.stderr
index 631e43c..0d38b9d 100644
--- a/src/test/ui/self/suggest-self.stderr
+++ b/src/test/ui/self/suggest-self.stderr
@@ -5,7 +5,7 @@
| ^^^^
| |
| not found in this scope
- | help: did you mean: `self`
+ | help: you might have meant to use `self` here instead
error[E0425]: cannot find value `this` in this scope
--> $DIR/suggest-self.rs:26:9
@@ -14,7 +14,7 @@
| ^^^^
| |
| not found in this scope
- | help: did you mean: `self`
+ | help: you might have meant to use `self` here instead
error[E0425]: cannot find value `my` in this scope
--> $DIR/suggest-self.rs:31:9
@@ -23,7 +23,7 @@
| ^^
| |
| not found in this scope
- | help: did you mean: `self`
+ | help: you might have meant to use `self` here instead
error: aborting due to 3 previous errors
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/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/where-clauses/where-lifetime-resolution.stderr b/src/test/ui/where-clauses/where-lifetime-resolution.stderr
index 6c52664..a704fea 100644
--- a/src/test/ui/where-clauses/where-lifetime-resolution.stderr
+++ b/src/test/ui/where-clauses/where-lifetime-resolution.stderr
@@ -6,6 +6,8 @@
LL | for<'a> dyn Trait1<'a>: Trait1<'a>, // OK
LL | (dyn for<'a> Trait1<'a>): Trait1<'a>,
| ^^ undeclared lifetime
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/where-lifetime-resolution.rs:8:52
@@ -15,6 +17,8 @@
...
LL | for<'a> dyn for<'b> Trait2<'a, 'b>: Trait2<'a, 'b>,
| ^^ undeclared lifetime
+ |
+ = help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error: aborting due to 2 previous errors
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/missing_const_for_fn/could_be_const.stderr b/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.stderr
index 8dde56c..74d32b8 100644
--- a/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.stderr
+++ b/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.stderr
@@ -58,14 +58,6 @@
| |_^
error: this could be a `const fn`
- --> $DIR/could_be_const.rs:48:1
- |
-LL | / fn sub(x: u32) -> usize {
-LL | | unsafe { transmute(&x) }
-LL | | }
- | |_^
-
-error: this could be a `const fn`
--> $DIR/could_be_const.rs:67:9
|
LL | / pub fn b(self, a: &A) -> B {
@@ -73,5 +65,5 @@
LL | | }
| |_________^
-error: aborting due to 9 previous errors
+error: aborting due to 8 previous errors
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/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/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;
}
