From 8148053e55f799e91af10766841b593e38b07752 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=AE=B8=E6=9D=B0=E5=8F=8B=20Jieyou=20Xu=20=28Joe=29?=
<jieyouxu@outlook.com>
Date: Sat, 20 Jan 2024 16:51:59 +0000
Subject: [PATCH 01/18] Add supporting infrastructure for `run-make` V2 tests
---
Cargo.lock | 13 +
Cargo.toml | 1 +
src/bootstrap/src/core/build_steps/test.rs | 83 +++++-
src/bootstrap/src/utils/dylib.rs | 13 +
src/tools/compiletest/src/lib.rs | 35 ++-
src/tools/compiletest/src/runtest.rs | 245 ++++++++++++++++++
src/tools/run-make-support/Cargo.toml | 10 +
src/tools/run-make-support/src/lib.rs | 83 ++++++
tests/run-make/CURRENT_RUSTC_VERSION/Makefile | 6 -
tests/run-make/CURRENT_RUSTC_VERSION/rmake.rs | 18 ++
tests/run-make/a-b-a-linker-guard/Makefile | 16 --
tests/run-make/a-b-a-linker-guard/rmake.rs | 13 +
12 files changed, 504 insertions(+), 32 deletions(-)
create mode 100644 src/tools/run-make-support/Cargo.toml
create mode 100644 src/tools/run-make-support/src/lib.rs
delete mode 100644 tests/run-make/CURRENT_RUSTC_VERSION/Makefile
create mode 100644 tests/run-make/CURRENT_RUSTC_VERSION/rmake.rs
delete mode 100644 tests/run-make/a-b-a-linker-guard/Makefile
create mode 100644 tests/run-make/a-b-a-linker-guard/rmake.rs
diff --git a/Cargo.lock b/Cargo.lock
index 25f4959bf141f..62c9fdc5672f6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3258,6 +3258,13 @@ dependencies = [
"serde_json",
]
+[[package]]
+name = "run_make_support"
+version = "0.0.0"
+dependencies = [
+ "shell-words",
+]
+
[[package]]
name = "rust-demangler"
version = "0.0.1"
@@ -4968,6 +4975,12 @@ version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "45bb67a18fa91266cc7807181f62f9178a6873bfad7dc788c42e6430db40184f"
+[[package]]
+name = "shell-words"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
+
[[package]]
name = "shlex"
version = "1.1.0"
diff --git a/Cargo.toml b/Cargo.toml
index 2ea16c2266615..5847a817e76fe 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,6 +10,7 @@ members = [
"src/tools/clippy",
"src/tools/clippy/clippy_dev",
"src/tools/compiletest",
+ "src/tools/run-make-support",
"src/tools/error_index_generator",
"src/tools/linkchecker",
"src/tools/lint-docs",
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 04728e2e00dcc..346b5f7bcf1f8 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -27,6 +27,7 @@ use crate::core::config::flags::Subcommand;
use crate::core::config::TargetSelection;
use crate::utils;
use crate::utils::cache::{Interned, INTERNER};
+use crate::utils::dylib::shared_lib_name;
use crate::utils::exec::BootstrapCommand;
use crate::utils::helpers::{
self, add_link_lib_path, add_rustdoc_cargo_linker_args, dylib_path, dylib_path_var,
@@ -1344,6 +1345,53 @@ macro_rules! coverage_test_alias {
};
}
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, Ord, PartialOrd)]
+pub struct RunMakeSupport {
+ pub compiler: Compiler,
+ pub target: TargetSelection,
+}
+
+impl Step for RunMakeSupport {
+ type Output = PathBuf;
+ const DEFAULT: bool = true;
+
+ fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+ run.never()
+ }
+
+ fn make_run(run: RunConfig<'_>) {
+ let compiler = run.builder.compiler(run.builder.top_stage, run.build_triple());
+ run.builder.ensure(RunMakeSupport { compiler, target: run.target });
+ }
+
+ fn run(self, builder: &Builder<'_>) -> PathBuf {
+ builder.ensure(compile::Std::new(self.compiler, self.target));
+
+ let cargo = tool::prepare_tool_cargo(
+ builder,
+ self.compiler,
+ Mode::ToolStd,
+ self.target,
+ "build",
+ "src/tools/run-make-support",
+ SourceType::InTree,
+ &[],
+ );
+
+ let mut cargo = Command::from(cargo);
+ cargo.env("RUSTFLAGS", "-C prefer-dynamic");
+ builder.run(&mut cargo);
+
+ let lib_name = shared_lib_name("run_make_support", &self.target.to_string());
+ let lib = builder.tools_dir(self.compiler).join(&lib_name);
+
+ let cargo_out =
+ builder.cargo_out(self.compiler, Mode::ToolStd, self.target).join(&lib_name);
+ builder.copy(&cargo_out, &lib);
+ lib
+ }
+}
+
default_test!(Ui { path: "tests/ui", mode: "ui", suite: "ui" });
default_test!(RunPassValgrind {
@@ -1378,7 +1426,40 @@ host_test!(RustdocJson { path: "tests/rustdoc-json", mode: "rustdoc-json", suite
host_test!(Pretty { path: "tests/pretty", mode: "pretty", suite: "pretty" });
-default_test!(RunMake { path: "tests/run-make", mode: "run-make", suite: "run-make" });
+// Special-handling is needed for `run-make`, so don't use `default_test` for defining `RunMake`
+// tests.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct RunMake {
+ pub compiler: Compiler,
+ pub target: TargetSelection,
+}
+
+impl Step for RunMake {
+ type Output = ();
+ const DEFAULT: bool = true;
+ const ONLY_HOSTS: bool = false;
+
+ fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+ run.suite_path("tests/run-make")
+ }
+
+ fn make_run(run: RunConfig<'_>) {
+ let compiler = run.builder.compiler(run.builder.top_stage, run.build_triple());
+ run.builder.ensure(RunMakeSupport { compiler, target: run.target });
+ run.builder.ensure(RunMake { compiler, target: run.target });
+ }
+
+ fn run(self, builder: &Builder<'_>) {
+ builder.ensure(Compiletest {
+ compiler: self.compiler,
+ target: self.target,
+ mode: "run-make",
+ suite: "run-make",
+ path: "tests/run-make",
+ compare_mode: None,
+ });
+ }
+}
host_test!(RunMakeFullDeps {
path: "tests/run-make-fulldeps",
diff --git a/src/bootstrap/src/utils/dylib.rs b/src/bootstrap/src/utils/dylib.rs
index b6e7aec1756b6..ca1216ccf48ea 100644
--- a/src/bootstrap/src/utils/dylib.rs
+++ b/src/bootstrap/src/utils/dylib.rs
@@ -38,3 +38,16 @@ pub fn exe(name: &str, target: &str) -> String {
name.to_string()
}
}
+
+/// Given a shared library called `name`, return the filename for the
+/// shared library for a particular target.
+#[allow(dead_code)]
+pub fn shared_lib_name(name: &str, target: &str) -> String {
+ if target.contains("windows") {
+ format!("lib{name}.dll")
+ } else if target.contains("apple") {
+ format!("lib{name}.dylib")
+ } else {
+ format!("lib{name}.so")
+ }
+}
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index 60dd15841b766..07ece9b0b4b10 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -655,13 +655,21 @@ fn collect_tests_from_dir(
return Ok(());
}
- if config.mode == Mode::RunMake && dir.join("Makefile").exists() {
- let paths = TestPaths {
- file: dir.to_path_buf(),
- relative_dir: relative_dir_path.parent().unwrap().to_path_buf(),
- };
- tests.extend(make_test(config, cache, &paths, inputs, poisoned));
- return Ok(());
+ if config.mode == Mode::RunMake {
+ if dir.join("Makefile").exists() && dir.join("rmake.rs").exists() {
+ return Err(io::Error::other(
+ "run-make tests cannot have both `Makefile` and `rmake.rs`",
+ ));
+ }
+
+ if dir.join("Makefile").exists() || dir.join("rmake.rs").exists() {
+ let paths = TestPaths {
+ file: dir.to_path_buf(),
+ relative_dir: relative_dir_path.parent().unwrap().to_path_buf(),
+ };
+ tests.extend(make_test(config, cache, &paths, inputs, poisoned));
+ return Ok(());
+ }
}
// If we find a test foo/bar.rs, we have to build the
@@ -731,8 +739,17 @@ fn make_test(
poisoned: &mut bool,
) -> Vec<test::TestDescAndFn> {
let test_path = if config.mode == Mode::RunMake {
- // Parse directives in the Makefile
- testpaths.file.join("Makefile")
+ if testpaths.file.join("rmake.rs").exists() && testpaths.file.join("Makefile").exists() {
+ panic!("run-make tests cannot have both `rmake.rs` and `Makefile`");
+ }
+
+ if testpaths.file.join("rmake.rs").exists() {
+ // Parse directives in rmake.rs.
+ testpaths.file.join("rmake.rs")
+ } else {
+ // Parse directives in the Makefile.
+ testpaths.file.join("Makefile")
+ }
} else {
PathBuf::from(&testpaths.file)
};
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 8be4def15dedc..9699a06369b3c 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -3559,6 +3559,17 @@ impl<'test> TestCx<'test> {
}
fn run_rmake_test(&self) {
+ let test_dir = &self.testpaths.file;
+ if test_dir.join("rmake.rs").exists() {
+ self.run_rmake_v2_test();
+ } else if test_dir.join("Makefile").exists() {
+ self.run_rmake_legacy_test();
+ } else {
+ self.fatal("failed to find either `rmake.rs` or `Makefile`")
+ }
+ }
+
+ fn run_rmake_legacy_test(&self) {
let cwd = env::current_dir().unwrap();
let src_root = self.config.src_base.parent().unwrap().parent().unwrap();
let src_root = cwd.join(&src_root);
@@ -3726,6 +3737,240 @@ impl<'test> TestCx<'test> {
fs::remove_dir(path)
}
+ fn run_rmake_v2_test(&self) {
+ // For `run-make` V2, we need to perform 2 steps to build and run a `run-make` V2 recipe
+ // (`rmake.rs`) to run the actual tests. The support library is already built as a tool
+ // dylib and is available under `build/$TARGET/stageN-tools-bin/librun_make_support.so`.
+ //
+ // 1. We need to build the recipe `rmake.rs` and link in the support library.
+ // 2. We need to run the recipe to build and run the tests.
+ let cwd = env::current_dir().unwrap();
+ let src_root = self.config.src_base.parent().unwrap().parent().unwrap();
+ let src_root = cwd.join(&src_root);
+ let build_root = self.config.build_base.parent().unwrap().parent().unwrap();
+ let build_root = cwd.join(&build_root);
+
+ let tmpdir = cwd.join(self.output_base_name());
+ if tmpdir.exists() {
+ self.aggressive_rm_rf(&tmpdir).unwrap();
+ }
+ create_dir_all(&tmpdir).unwrap();
+
+ // HACK: assume stageN-target, we only want stageN.
+ let stage = self.config.stage_id.split('-').next().unwrap();
+
+ // First, we construct the path to the built support library.
+ let mut support_dylib_path = PathBuf::new();
+ support_dylib_path.push(&build_root);
+ support_dylib_path.push(format!("{}-tools-bin", stage));
+ if self.config.target.contains("windows") {
+ support_dylib_path.push("librun_make_support.dll");
+ } else if self.config.target.contains("apple") {
+ support_dylib_path.push("librun_make_support.dylib");
+ } else {
+ support_dylib_path.push("librun_make_support.so");
+ }
+
+ let mut stage_std_path = PathBuf::new();
+ stage_std_path.push(&build_root);
+ stage_std_path.push(format!("{}-std", stage));
+ stage_std_path.push(&self.config.target);
+ stage_std_path.push("release/deps");
+
+ // Then, we need to build the recipe `rmake.rs` and link in the support library.
+ let recipe_bin = tmpdir.join("rmake");
+
+ let mut support_dylib_deps = PathBuf::new();
+ support_dylib_deps.push(&build_root);
+ support_dylib_deps.push(format!("{}-tools", stage));
+ support_dylib_deps.push(&self.config.target);
+ support_dylib_deps.push("release/deps");
+
+ let mut support_dylib_deps_deps = PathBuf::new();
+ support_dylib_deps_deps.push(&build_root);
+ support_dylib_deps_deps.push(format!("{}-tools", stage));
+ support_dylib_deps_deps.push("release/deps");
+
+ debug!(?support_dylib_deps);
+ debug!(?support_dylib_deps_deps);
+
+ let res = self.cmd2procres(
+ Command::new(&self.config.rustc_path)
+ .arg("-o")
+ .arg(&recipe_bin)
+ .arg(format!(
+ "-Ldependency={}",
+ &support_dylib_path.parent().unwrap().to_string_lossy()
+ ))
+ .arg(format!("-Ldependency={}", &support_dylib_deps.to_string_lossy()))
+ .arg(format!("-Ldependency={}", &support_dylib_deps_deps.to_string_lossy()))
+ .arg("--extern")
+ .arg(format!("run_make_support={}", &support_dylib_path.to_string_lossy()))
+ .arg(&self.testpaths.file.join("rmake.rs"))
+ .env("TARGET", &self.config.target)
+ .env("PYTHON", &self.config.python)
+ .env("S", &src_root)
+ .env("RUST_BUILD_STAGE", &self.config.stage_id)
+ .env("RUSTC", cwd.join(&self.config.rustc_path))
+ .env("TMPDIR", &tmpdir)
+ .env("LD_LIB_PATH_ENVVAR", dylib_env_var())
+ .env("HOST_RPATH_DIR", cwd.join(&self.config.compile_lib_path))
+ .env("TARGET_RPATH_DIR", cwd.join(&self.config.run_lib_path))
+ .env("LLVM_COMPONENTS", &self.config.llvm_components)
+ // We for sure don't want these tests to run in parallel, so make
+ // sure they don't have access to these vars if we run via `make`
+ // at the top level
+ .env_remove("MAKEFLAGS")
+ .env_remove("MFLAGS")
+ .env_remove("CARGO_MAKEFLAGS"),
+ );
+ if !res.status.success() {
+ self.fatal_proc_rec("run-make test failed: could not build `rmake.rs` recipe", &res);
+ }
+
+ // Finally, we need to run the recipe binary to build and run the actual tests.
+ debug!(?recipe_bin);
+
+ let mut dylib_env_paths = String::new();
+ dylib_env_paths.push_str(&env::var(dylib_env_var()).unwrap());
+ dylib_env_paths.push(':');
+ dylib_env_paths.push_str(&support_dylib_path.parent().unwrap().to_string_lossy());
+ dylib_env_paths.push(':');
+ dylib_env_paths.push_str(&stage_std_path.to_string_lossy());
+
+ let mut target_rpath_env_path = String::new();
+ target_rpath_env_path.push_str(&tmpdir.to_string_lossy());
+ target_rpath_env_path.push(':');
+ target_rpath_env_path.push_str(&dylib_env_paths);
+
+ let mut cmd = Command::new(&recipe_bin);
+ cmd.current_dir(&self.testpaths.file)
+ .stdout(Stdio::piped())
+ .stderr(Stdio::piped())
+ .env("LD_LIB_PATH_ENVVAR", dylib_env_var())
+ .env("TARGET_RPATH_ENV", &target_rpath_env_path)
+ .env(dylib_env_var(), &dylib_env_paths)
+ .env("TARGET", &self.config.target)
+ .env("PYTHON", &self.config.python)
+ .env("S", &src_root)
+ .env("RUST_BUILD_STAGE", &self.config.stage_id)
+ .env("RUSTC", cwd.join(&self.config.rustc_path))
+ .env("TMPDIR", &tmpdir)
+ .env("HOST_RPATH_DIR", cwd.join(&self.config.compile_lib_path))
+ .env("TARGET_RPATH_DIR", cwd.join(&self.config.run_lib_path))
+ .env("LLVM_COMPONENTS", &self.config.llvm_components)
+ // We for sure don't want these tests to run in parallel, so make
+ // sure they don't have access to these vars if we run via `make`
+ // at the top level
+ .env_remove("MAKEFLAGS")
+ .env_remove("MFLAGS")
+ .env_remove("CARGO_MAKEFLAGS");
+
+ if let Some(ref rustdoc) = self.config.rustdoc_path {
+ cmd.env("RUSTDOC", cwd.join(rustdoc));
+ }
+
+ if let Some(ref rust_demangler) = self.config.rust_demangler_path {
+ cmd.env("RUST_DEMANGLER", cwd.join(rust_demangler));
+ }
+
+ if let Some(ref node) = self.config.nodejs {
+ cmd.env("NODE", node);
+ }
+
+ if let Some(ref linker) = self.config.target_linker {
+ cmd.env("RUSTC_LINKER", linker);
+ }
+
+ if let Some(ref clang) = self.config.run_clang_based_tests_with {
+ cmd.env("CLANG", clang);
+ }
+
+ if let Some(ref filecheck) = self.config.llvm_filecheck {
+ cmd.env("LLVM_FILECHECK", filecheck);
+ }
+
+ if let Some(ref llvm_bin_dir) = self.config.llvm_bin_dir {
+ cmd.env("LLVM_BIN_DIR", llvm_bin_dir);
+ }
+
+ if let Some(ref remote_test_client) = self.config.remote_test_client {
+ cmd.env("REMOTE_TEST_CLIENT", remote_test_client);
+ }
+
+ // We don't want RUSTFLAGS set from the outside to interfere with
+ // compiler flags set in the test cases:
+ cmd.env_remove("RUSTFLAGS");
+
+ // Use dynamic musl for tests because static doesn't allow creating dylibs
+ if self.config.host.contains("musl") {
+ cmd.env("RUSTFLAGS", "-Ctarget-feature=-crt-static").env("IS_MUSL_HOST", "1");
+ }
+
+ if self.config.bless {
+ cmd.env("RUSTC_BLESS_TEST", "--bless");
+ // Assume this option is active if the environment variable is "defined", with _any_ value.
+ // As an example, a `Makefile` can use this option by:
+ //
+ // ifdef RUSTC_BLESS_TEST
+ // cp "$(TMPDIR)"/actual_something.ext expected_something.ext
+ // else
+ // $(DIFF) expected_something.ext "$(TMPDIR)"/actual_something.ext
+ // endif
+ }
+
+ if self.config.target.contains("msvc") && self.config.cc != "" {
+ // We need to pass a path to `lib.exe`, so assume that `cc` is `cl.exe`
+ // and that `lib.exe` lives next to it.
+ let lib = Path::new(&self.config.cc).parent().unwrap().join("lib.exe");
+
+ // MSYS doesn't like passing flags of the form `/foo` as it thinks it's
+ // a path and instead passes `C:\msys64\foo`, so convert all
+ // `/`-arguments to MSVC here to `-` arguments.
+ let cflags = self
+ .config
+ .cflags
+ .split(' ')
+ .map(|s| s.replace("/", "-"))
+ .collect::<Vec<_>>()
+ .join(" ");
+ let cxxflags = self
+ .config
+ .cxxflags
+ .split(' ')
+ .map(|s| s.replace("/", "-"))
+ .collect::<Vec<_>>()
+ .join(" ");
+
+ cmd.env("IS_MSVC", "1")
+ .env("IS_WINDOWS", "1")
+ .env("MSVC_LIB", format!("'{}' -nologo", lib.display()))
+ .env("CC", format!("'{}' {}", self.config.cc, cflags))
+ .env("CXX", format!("'{}' {}", &self.config.cxx, cxxflags));
+ } else {
+ cmd.env("CC", format!("{} {}", self.config.cc, self.config.cflags))
+ .env("CXX", format!("{} {}", self.config.cxx, self.config.cxxflags))
+ .env("AR", &self.config.ar);
+
+ if self.config.target.contains("windows") {
+ cmd.env("IS_WINDOWS", "1");
+ }
+ }
+
+ let (Output { stdout, stderr, status }, truncated) =
+ self.read2_abbreviated(cmd.spawn().expect("failed to spawn `rmake`"));
+ if !status.success() {
+ let res = ProcRes {
+ status,
+ stdout: String::from_utf8_lossy(&stdout).into_owned(),
+ stderr: String::from_utf8_lossy(&stderr).into_owned(),
+ truncated,
+ cmdline: format!("{:?}", cmd),
+ };
+ self.fatal_proc_rec("rmake recipe failed to complete", &res);
+ }
+ }
+
fn run_js_doc_test(&self) {
if let Some(nodejs) = &self.config.nodejs {
let out_dir = self.output_base_dir();
diff --git a/src/tools/run-make-support/Cargo.toml b/src/tools/run-make-support/Cargo.toml
new file mode 100644
index 0000000000000..6a25cc337eebc
--- /dev/null
+++ b/src/tools/run-make-support/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "run_make_support"
+version = "0.0.0"
+edition = "2021"
+
+[lib]
+crate-type = ["dylib"]
+
+[dependencies]
+shell-words = "1.1"
diff --git a/src/tools/run-make-support/src/lib.rs b/src/tools/run-make-support/src/lib.rs
new file mode 100644
index 0000000000000..0a12022df4c11
--- /dev/null
+++ b/src/tools/run-make-support/src/lib.rs
@@ -0,0 +1,83 @@
+use std::env;
+use std::path::PathBuf;
+use std::process::{Command, Output};
+
+pub fn aux_build(args: &str) -> Output {
+ let (words, mut cmd) = build_common(args);
+ cmd.arg("--crate-type=lib");
+ for word in words {
+ cmd.arg(word);
+ }
+ let output = cmd.output().unwrap();
+ if !output.status.success() {
+ handle_failed_output(&format!("{:?}", cmd), output);
+ }
+ output
+}
+
+fn build_common(args: &str) -> (Vec<String>, Command) {
+ let rustc = env::var("RUSTC").unwrap();
+ let words = shell_words::split(args).expect("failed to parse arguments");
+ let mut cmd = Command::new(rustc);
+ cmd.arg("--out-dir")
+ .arg(env::var("TMPDIR").unwrap())
+ .arg("-L")
+ .arg(env::var("TMPDIR").unwrap());
+ (words, cmd)
+}
+
+fn handle_failed_output(cmd: &str, output: Output) -> ! {
+ println!("command failed: `{}`", cmd);
+ println!("=== STDOUT ===\n{}\n\n", String::from_utf8(output.stdout).unwrap());
+ println!("=== STDERR ===\n{}\n\n", String::from_utf8(output.stderr).unwrap());
+ std::process::exit(1)
+}
+
+pub fn rustc(args: &str) -> Output {
+ let (words, mut cmd) = build_common(args);
+ for word in words {
+ cmd.arg(word);
+ }
+ let output = cmd.output().unwrap();
+ if !output.status.success() {
+ handle_failed_output(&format!("{:?}", cmd), output);
+ }
+ output
+}
+
+fn run_common(bin_name: &str) -> (Command, Output) {
+ let mut bin_path = PathBuf::new();
+ bin_path.push(std::env::var("TMPDIR").unwrap());
+ bin_path.push(&bin_name);
+ let ld_lib_path_envvar = std::env::var("LD_LIB_PATH_ENVVAR").unwrap();
+ let mut cmd = Command::new(bin_path);
+ cmd.env(&ld_lib_path_envvar, {
+ let mut target_rpath_env_path = String::new();
+ target_rpath_env_path.push_str(&std::env::var("TMPDIR").unwrap());
+ target_rpath_env_path.push(':');
+ target_rpath_env_path.push_str(&std::env::var("TARGET_RPATH_DIR").unwrap());
+ target_rpath_env_path.push(':');
+ target_rpath_env_path.push_str(&std::env::var(&ld_lib_path_envvar).unwrap());
+ target_rpath_env_path
+ });
+ let output = cmd.output().unwrap();
+ (cmd, output)
+}
+
+/// Run a built binary and make sure it succeeds.
+pub fn run(bin_name: &str) -> Output {
+ let (cmd, output) = run_common(bin_name);
+ if !output.status.success() {
+ handle_failed_output(&format!("{:?}", cmd), output);
+ }
+ output
+}
+
+/// Run a built binary and make sure it fails.
+pub fn run_fail(bin_name: &str) -> Output {
+ let (cmd, output) = run_common(bin_name);
+ if output.status.success() {
+ handle_failed_output(&format!("{:?}", cmd), output);
+ }
+ output
+}
diff --git a/tests/run-make/CURRENT_RUSTC_VERSION/Makefile b/tests/run-make/CURRENT_RUSTC_VERSION/Makefile
deleted file mode 100644
index 7940dae207b09..0000000000000
--- a/tests/run-make/CURRENT_RUSTC_VERSION/Makefile
+++ /dev/null
@@ -1,6 +0,0 @@
-include ../tools.mk
-
-all:
- $(RUSTC) --emit=metadata --crate-type lib stable.rs
- $(RUSTC) --emit=metadata --extern stable=$(TMPDIR)/libstable.rmeta main.rs 2>&1 >/dev/null \
- | $(CGREP) -e "stable since $$(cat $(S)/src/version)(-[a-zA-Z]+)?"
diff --git a/tests/run-make/CURRENT_RUSTC_VERSION/rmake.rs b/tests/run-make/CURRENT_RUSTC_VERSION/rmake.rs
new file mode 100644
index 0000000000000..d46b5e2508e18
--- /dev/null
+++ b/tests/run-make/CURRENT_RUSTC_VERSION/rmake.rs
@@ -0,0 +1,18 @@
+// ignore-tidy-linelength
+
+extern crate run_make_support;
+
+use run_make_support::{aux_build, rustc};
+
+fn main() {
+ aux_build("--emit=metadata stable.rs");
+ let output = rustc(&format!(
+ "--emit=metadata --extern stable={}/libstable.rmeta main.rs",
+ env!("TMPDIR")
+ ));
+
+ let stderr = String::from_utf8_lossy(&output.stderr);
+ let version = include_str!(concat!(env!("S"), "/src/version"));
+ let expected_string = format!("stable since {}", version.trim());
+ assert!(stderr.contains(&expected_string));
+}
diff --git a/tests/run-make/a-b-a-linker-guard/Makefile b/tests/run-make/a-b-a-linker-guard/Makefile
deleted file mode 100644
index 43282eae09c59..0000000000000
--- a/tests/run-make/a-b-a-linker-guard/Makefile
+++ /dev/null
@@ -1,16 +0,0 @@
-# ignore-cross-compile
-include ../tools.mk
-
-# Test that if we build `b` against a version of `a` that has one set
-# of types, it will not run with a dylib that has a different set of
-# types.
-
-# NOTE(eddyb) this test only works with the `legacy` mangling,
-# and will probably get removed once `legacy` is gone.
-
-all:
- $(RUSTC) a.rs --cfg x -C prefer-dynamic -Z unstable-options -C symbol-mangling-version=legacy
- $(RUSTC) b.rs -C prefer-dynamic -Z unstable-options -C symbol-mangling-version=legacy
- $(call RUN,b)
- $(RUSTC) a.rs --cfg y -C prefer-dynamic -Z unstable-options -C symbol-mangling-version=legacy
- $(call FAIL,b)
diff --git a/tests/run-make/a-b-a-linker-guard/rmake.rs b/tests/run-make/a-b-a-linker-guard/rmake.rs
new file mode 100644
index 0000000000000..014c1a689fdcd
--- /dev/null
+++ b/tests/run-make/a-b-a-linker-guard/rmake.rs
@@ -0,0 +1,13 @@
+// ignore-tidy-linelength
+
+extern crate run_make_support;
+
+use run_make_support::{run, run_fail, rustc};
+
+fn main() {
+ rustc("a.rs --cfg x -C prefer-dynamic -Z unstable-options -C symbol-mangling-version=legacy");
+ rustc("b.rs -C prefer-dynamic -Z unstable-options -C symbol-mangling-version=legacy");
+ run("b");
+ rustc("a.rs --cfg y -C prefer-dynamic -Z unstable-options -C symbol-mangling-version=legacy");
+ run_fail("b");
+}
From e1826bf818c452ab4a6c6b5d954e789ef48a55ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=AE=B8=E6=9D=B0=E5=8F=8B=20Jieyou=20Xu=20=28Joe=29?=
<jieyouxu@outlook.com>
Date: Fri, 2 Feb 2024 11:33:39 +0000
Subject: [PATCH 02/18] Point to stage1-std when in stage2 rustc
---
src/tools/compiletest/src/runtest.rs | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 9699a06369b3c..b96c0b8d317d8 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -3773,7 +3773,12 @@ impl<'test> TestCx<'test> {
let mut stage_std_path = PathBuf::new();
stage_std_path.push(&build_root);
- stage_std_path.push(format!("{}-std", stage));
+ if stage == "stage0" {
+ stage_std_path.push("stage0-std");
+ } else {
+ // stage2 reuses stage1-std.
+ stage_std_path.push("stage1-std");
+ }
stage_std_path.push(&self.config.target);
stage_std_path.push("release/deps");
From 6b2a8249c196898c3932d818b263f4c32a5ed454 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Fri, 2 Feb 2024 22:45:25 +0000
Subject: [PATCH 03/18] Remove dead args from functions
---
compiler/rustc_borrowck/src/nll.rs | 2 +-
.../rustc_borrowck/src/region_infer/mod.rs | 41 +------------------
compiler/rustc_borrowck/src/type_check/mod.rs | 1 -
.../rustc_hir_analysis/src/astconv/bounds.rs | 2 -
.../src/astconv/generics.rs | 16 +-------
.../rustc_hir_analysis/src/astconv/mod.rs | 10 ++---
.../rustc_hir_typeck/src/fn_ctxt/_impl.rs | 12 ++----
compiler/rustc_hir_typeck/src/lib.rs | 2 +-
.../src/mem_categorization.rs | 3 +-
.../rustc_hir_typeck/src/method/confirm.rs | 1 -
compiler/rustc_infer/src/infer/mod.rs | 6 +--
.../rustc_infer/src/infer/opaque_types.rs | 1 -
.../rustc_infer/src/infer/relate/combine.rs | 5 +--
compiler/rustc_middle/src/thir.rs | 1 -
compiler/rustc_middle/src/ty/_match.rs | 2 +-
.../src/const_prop_lint.rs | 9 +---
compiler/rustc_pattern_analysis/src/lints.rs | 2 +-
.../rustc_query_system/src/dep_graph/graph.rs | 5 +--
compiler/rustc_resolve/src/late.rs | 9 ++--
.../src/solve/assembly/mod.rs | 2 +-
.../rustc_trait_selection/src/solve/mod.rs | 19 ---------
.../src/traits/select/mod.rs | 5 +--
22 files changed, 32 insertions(+), 124 deletions(-)
diff --git a/compiler/rustc_borrowck/src/nll.rs b/compiler/rustc_borrowck/src/nll.rs
index cc8208e9dc306..6a04af4506b8d 100644
--- a/compiler/rustc_borrowck/src/nll.rs
+++ b/compiler/rustc_borrowck/src/nll.rs
@@ -184,7 +184,7 @@ pub(crate) fn compute_regions<'cx, 'tcx>(
// Solve the region constraints.
let (closure_region_requirements, nll_errors) =
- regioncx.solve(infcx, param_env, body, polonius_output.clone());
+ regioncx.solve(infcx, body, polonius_output.clone());
if !nll_errors.is_empty() {
// Suppress unhelpful extra errors in `infer_opaque_types`.
diff --git a/compiler/rustc_borrowck/src/region_infer/mod.rs b/compiler/rustc_borrowck/src/region_infer/mod.rs
index 89b203f80a435..3153b709ffe38 100644
--- a/compiler/rustc_borrowck/src/region_infer/mod.rs
+++ b/compiler/rustc_borrowck/src/region_infer/mod.rs
@@ -658,7 +658,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
pub(super) fn solve(
&mut self,
infcx: &InferCtxt<'tcx>,
- param_env: ty::ParamEnv<'tcx>,
body: &Body<'tcx>,
polonius_output: Option<Rc<PoloniusOutput>>,
) -> (Option<ClosureRegionRequirements<'tcx>>, RegionErrors<'tcx>) {
@@ -674,7 +673,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
// eagerly.
let mut outlives_requirements = infcx.tcx.is_typeck_child(mir_def_id).then(Vec::new);
- self.check_type_tests(infcx, body, outlives_requirements.as_mut(), &mut errors_buffer);
+ self.check_type_tests(infcx, outlives_requirements.as_mut(), &mut errors_buffer);
debug!(?errors_buffer);
debug!(?outlives_requirements);
@@ -932,7 +931,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
fn check_type_tests(
&self,
infcx: &InferCtxt<'tcx>,
- body: &Body<'tcx>,
mut propagated_outlives_requirements: Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,
errors_buffer: &mut RegionErrors<'tcx>,
) {
@@ -957,12 +955,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
}
if let Some(propagated_outlives_requirements) = &mut propagated_outlives_requirements {
- if self.try_promote_type_test(
- infcx,
- body,
- type_test,
- propagated_outlives_requirements,
- ) {
+ if self.try_promote_type_test(infcx, type_test, propagated_outlives_requirements) {
continue;
}
}
@@ -1016,7 +1009,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
fn try_promote_type_test(
&self,
infcx: &InferCtxt<'tcx>,
- body: &Body<'tcx>,
type_test: &TypeTest<'tcx>,
propagated_outlives_requirements: &mut Vec<ClosureOutlivesRequirement<'tcx>>,
) -> bool {
@@ -1179,35 +1171,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
Some(ClosureOutlivesSubject::Ty(ClosureOutlivesSubjectTy::bind(tcx, ty)))
}
- /// Returns a universally quantified region that outlives the
- /// value of `r` (`r` may be existentially or universally
- /// quantified).
- ///
- /// Since `r` is (potentially) an existential region, it has some
- /// value which may include (a) any number of points in the CFG
- /// and (b) any number of `end('x)` elements of universally
- /// quantified regions. To convert this into a single universal
- /// region we do as follows:
- ///
- /// - Ignore the CFG points in `'r`. All universally quantified regions
- /// include the CFG anyhow.
- /// - For each `end('x)` element in `'r`, compute the mutual LUB, yielding
- /// a result `'y`.
- #[instrument(skip(self), level = "debug", ret)]
- pub(crate) fn universal_upper_bound(&self, r: RegionVid) -> RegionVid {
- debug!(r = %self.region_value_str(r));
-
- // Find the smallest universal region that contains all other
- // universal regions within `region`.
- let mut lub = self.universal_regions.fr_fn_body;
- let r_scc = self.constraint_sccs.scc(r);
- for ur in self.scc_values.universal_regions_outlived_by(r_scc) {
- lub = self.universal_region_relations.postdom_upper_bound(lub, ur);
- }
-
- lub
- }
-
/// Like `universal_upper_bound`, but returns an approximation more suitable
/// for diagnostics. If `r` contains multiple disjoint universal regions
/// (e.g. 'a and 'b in `fn foo<'a, 'b> { ... }`, we pick the lower-numbered region.
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index 59c4d9a6c78ca..64cdc2983ca40 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -217,7 +217,6 @@ pub(crate) fn type_check<'mir, 'tcx>(
CustomTypeOp::new(
|ocx| {
ocx.infcx.register_member_constraints(
- param_env,
opaque_type_key,
decl.hidden_type.ty,
decl.hidden_type.span,
diff --git a/compiler/rustc_hir_analysis/src/astconv/bounds.rs b/compiler/rustc_hir_analysis/src/astconv/bounds.rs
index c22daad334fc5..46266058ff508 100644
--- a/compiler/rustc_hir_analysis/src/astconv/bounds.rs
+++ b/compiler/rustc_hir_analysis/src/astconv/bounds.rs
@@ -235,9 +235,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
speculative: bool,
dup_bindings: &mut FxHashMap<DefId, Span>,
path_span: Span,
- constness: ty::BoundConstness,
only_self_bounds: OnlySelfBounds,
- polarity: ty::ImplPolarity,
) -> Result<(), ErrorGuaranteed> {
// Given something like `U: SomeTrait<T = X>`, we want to produce a
// predicate like `<U as SomeTrait>::T = X`. This is somewhat
diff --git a/compiler/rustc_hir_analysis/src/astconv/generics.rs b/compiler/rustc_hir_analysis/src/astconv/generics.rs
index 30b10446afcc9..aa826c1f26805 100644
--- a/compiler/rustc_hir_analysis/src/astconv/generics.rs
+++ b/compiler/rustc_hir_analysis/src/astconv/generics.rs
@@ -16,7 +16,7 @@ use rustc_middle::ty::{
self, GenericArgsRef, GenericParamDef, GenericParamDefKind, IsSuggestable, Ty, TyCtxt,
};
use rustc_session::lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS;
-use rustc_span::{symbol::kw, Span};
+use rustc_span::symbol::kw;
use smallvec::SmallVec;
/// Report an error that a generic argument did not match the generic parameter that was
@@ -404,7 +404,6 @@ pub fn create_args_for_parent_generic_args<'tcx: 'a, 'a>(
/// Used specifically for function calls.
pub fn check_generic_arg_count_for_call(
tcx: TyCtxt<'_>,
- span: Span,
def_id: DefId,
generics: &ty::Generics,
seg: &hir::PathSegment<'_>,
@@ -418,17 +417,7 @@ pub fn check_generic_arg_count_for_call(
};
let has_self = generics.parent.is_none() && generics.has_self;
- check_generic_arg_count(
- tcx,
- span,
- def_id,
- seg,
- generics,
- gen_args,
- gen_pos,
- has_self,
- seg.infer_args,
- )
+ check_generic_arg_count(tcx, def_id, seg, generics, gen_args, gen_pos, has_self, seg.infer_args)
}
/// Checks that the correct number of generic arguments have been provided.
@@ -436,7 +425,6 @@ pub fn check_generic_arg_count_for_call(
#[instrument(skip(tcx, gen_pos), level = "debug")]
pub(crate) fn check_generic_arg_count(
tcx: TyCtxt<'_>,
- span: Span,
def_id: DefId,
seg: &hir::PathSegment<'_>,
gen_params: &ty::Generics,
diff --git a/compiler/rustc_hir_analysis/src/astconv/mod.rs b/compiler/rustc_hir_analysis/src/astconv/mod.rs
index 89f39897ea874..69a70557393fd 100644
--- a/compiler/rustc_hir_analysis/src/astconv/mod.rs
+++ b/compiler/rustc_hir_analysis/src/astconv/mod.rs
@@ -25,7 +25,7 @@ use rustc_hir as hir;
use rustc_hir::def::{CtorOf, DefKind, Namespace, Res};
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_hir::intravisit::{walk_generics, Visitor as _};
-use rustc_hir::{GenericArg, GenericArgs, OpaqueTyOrigin};
+use rustc_hir::{GenericArg, GenericArgs};
use rustc_infer::infer::{InferCtxt, TyCtxtInferExt};
use rustc_infer::traits::ObligationCause;
use rustc_middle::middle::stability::AllowUnstable;
@@ -379,7 +379,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
let mut arg_count = check_generic_arg_count(
tcx,
- span,
def_id,
seg,
generics,
@@ -773,9 +772,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
speculative,
&mut dup_bindings,
binding.span,
- constness,
only_self_bounds,
- polarity,
);
// Okay to ignore `Err` because of `ErrorGuaranteed` (see above).
}
@@ -2491,7 +2488,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
let opaque_ty = tcx.hir().item(item_id);
match opaque_ty.kind {
- hir::ItemKind::OpaqueTy(&hir::OpaqueTy { origin, .. }) => {
+ hir::ItemKind::OpaqueTy(&hir::OpaqueTy { .. }) => {
let local_def_id = item_id.owner_id.def_id;
// If this is an RPITIT and we are using the new RPITIT lowering scheme, we
// generate the def_id of an associated type for the trait and return as
@@ -2501,7 +2498,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
} else {
local_def_id.to_def_id()
};
- self.impl_trait_ty_to_ty(def_id, lifetimes, origin, in_trait)
+ self.impl_trait_ty_to_ty(def_id, lifetimes, in_trait)
}
ref i => bug!("`impl Trait` pointed to non-opaque type?? {:#?}", i),
}
@@ -2571,7 +2568,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
&self,
def_id: DefId,
lifetimes: &[hir::GenericArg<'_>],
- origin: OpaqueTyOrigin,
in_trait: bool,
) -> Ty<'tcx> {
debug!("impl_trait_ty_to_ty(def_id={:?}, lifetimes={:?})", def_id, lifetimes);
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 60eb40bd8fe66..73b3ccf449c79 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -521,7 +521,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// We must not attempt to select obligations after this method has run, or risk query cycle
/// ICE.
#[instrument(level = "debug", skip(self))]
- pub(in super::super) fn resolve_coroutine_interiors(&self, def_id: DefId) {
+ pub(in super::super) fn resolve_coroutine_interiors(&self) {
// Try selecting all obligations that are not blocked on inference variables.
// Once we start unifying coroutine witnesses, trying to select obligations on them will
// trigger query cycle ICEs, as doing so requires MIR.
@@ -1175,14 +1175,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// parameter internally, but we don't allow users to specify the
// parameter's value explicitly, so we have to do some error-
// checking here.
- let arg_count = check_generic_arg_count_for_call(
- tcx,
- span,
- def_id,
- generics,
- seg,
- IsMethodCall::No,
- );
+ let arg_count =
+ check_generic_arg_count_for_call(tcx, def_id, generics, seg, IsMethodCall::No);
if let ExplicitLateBound::Yes = arg_count.explicit_late_bound {
explicit_late_bound = ExplicitLateBound::Yes;
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index deb3ad2edc740..7aa8010f17620 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -286,7 +286,7 @@ fn typeck_with_fallback<'tcx>(
debug!(pending_obligations = ?fcx.fulfillment_cx.borrow().pending_obligations());
// This must be the last thing before `report_ambiguity_errors`.
- fcx.resolve_coroutine_interiors(def_id.to_def_id());
+ fcx.resolve_coroutine_interiors();
debug!(pending_obligations = ?fcx.fulfillment_cx.borrow().pending_obligations());
diff --git a/compiler/rustc_hir_typeck/src/mem_categorization.rs b/compiler/rustc_hir_typeck/src/mem_categorization.rs
index 1ce0240f7b830..f9297550c573c 100644
--- a/compiler/rustc_hir_typeck/src/mem_categorization.rs
+++ b/compiler/rustc_hir_typeck/src/mem_categorization.rs
@@ -436,7 +436,8 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
pub(crate) fn cat_rvalue(
&self,
hir_id: hir::HirId,
- span: Span,
+ // FIXME: remove
+ _span: Span,
expr_ty: Ty<'tcx>,
) -> PlaceWithHirId<'tcx> {
PlaceWithHirId::new(hir_id, expr_ty, PlaceBase::Rvalue, Vec::new())
diff --git a/compiler/rustc_hir_typeck/src/method/confirm.rs b/compiler/rustc_hir_typeck/src/method/confirm.rs
index 6f18cc51b11c1..38a63b6dd4302 100644
--- a/compiler/rustc_hir_typeck/src/method/confirm.rs
+++ b/compiler/rustc_hir_typeck/src/method/confirm.rs
@@ -356,7 +356,6 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
let arg_count_correct = check_generic_arg_count_for_call(
self.tcx,
- self.span,
pick.item.def_id,
generics,
seg,
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index 0a39fe007fd22..432d4c0fc6255 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -862,7 +862,7 @@ impl<'tcx> InferCtxt<'tcx> {
}
#[instrument(skip(self, snapshot), level = "debug")]
- fn rollback_to(&self, cause: &str, snapshot: CombinedSnapshot<'tcx>) {
+ fn rollback_to(&self, snapshot: CombinedSnapshot<'tcx>) {
let CombinedSnapshot { undo_snapshot, region_constraints_snapshot, universe } = snapshot;
self.universe.set(universe);
@@ -894,7 +894,7 @@ impl<'tcx> InferCtxt<'tcx> {
self.commit_from(snapshot);
}
Err(_) => {
- self.rollback_to("commit_if_ok -- error", snapshot);
+ self.rollback_to(snapshot);
}
}
r
@@ -908,7 +908,7 @@ impl<'tcx> InferCtxt<'tcx> {
{
let snapshot = self.start_snapshot();
let r = f(&snapshot);
- self.rollback_to("probe", snapshot);
+ self.rollback_to(snapshot);
r
}
diff --git a/compiler/rustc_infer/src/infer/opaque_types.rs b/compiler/rustc_infer/src/infer/opaque_types.rs
index db46b39ce25fc..757ba3b1b3678 100644
--- a/compiler/rustc_infer/src/infer/opaque_types.rs
+++ b/compiler/rustc_infer/src/infer/opaque_types.rs
@@ -327,7 +327,6 @@ impl<'tcx> InferCtxt<'tcx> {
#[instrument(level = "debug", skip(self))]
pub fn register_member_constraints(
&self,
- param_env: ty::ParamEnv<'tcx>,
opaque_type_key: OpaqueTypeKey<'tcx>,
concrete_ty: Ty<'tcx>,
span: Span,
diff --git a/compiler/rustc_infer/src/infer/relate/combine.rs b/compiler/rustc_infer/src/infer/relate/combine.rs
index 1c120646f1f90..280fcfb041e47 100644
--- a/compiler/rustc_infer/src/infer/relate/combine.rs
+++ b/compiler/rustc_infer/src/infer/relate/combine.rs
@@ -225,11 +225,11 @@ impl<'tcx> InferCtxt<'tcx> {
}
(ty::ConstKind::Infer(InferConst::Var(vid)), _) => {
- return self.unify_const_variable(vid, b, relation.param_env());
+ return self.unify_const_variable(vid, b);
}
(_, ty::ConstKind::Infer(InferConst::Var(vid))) => {
- return self.unify_const_variable(vid, a, relation.param_env());
+ return self.unify_const_variable(vid, a);
}
(ty::ConstKind::Infer(InferConst::EffectVar(vid)), _) => {
@@ -310,7 +310,6 @@ impl<'tcx> InferCtxt<'tcx> {
&self,
target_vid: ty::ConstVid,
ct: ty::Const<'tcx>,
- param_env: ty::ParamEnv<'tcx>,
) -> RelateResult<'tcx, ty::Const<'tcx>> {
let span = match self.inner.borrow_mut().const_unification_table().probe_value(target_vid) {
ConstVariableValue::Known { value } => {
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
index 0fed4ccc62a83..e1e5d68148fe8 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -1038,7 +1038,6 @@ impl<'tcx> PatRangeBoundary<'tcx> {
a.partial_cmp(&b)
}
ty::Int(ity) => {
- use rustc_middle::ty::layout::IntegerExt;
let size = rustc_target::abi::Integer::from_int_ty(&tcx, *ity).size();
let a = size.sign_extend(a) as i128;
let b = size.sign_extend(b) as i128;
diff --git a/compiler/rustc_middle/src/ty/_match.rs b/compiler/rustc_middle/src/ty/_match.rs
index a2794a100f14d..417f1932c6f90 100644
--- a/compiler/rustc_middle/src/ty/_match.rs
+++ b/compiler/rustc_middle/src/ty/_match.rs
@@ -55,7 +55,7 @@ impl<'tcx> TypeRelation<'tcx> for MatchAgainstFreshVars<'tcx> {
fn regions(
&mut self,
a: ty::Region<'tcx>,
- b: ty::Region<'tcx>,
+ _b: ty::Region<'tcx>,
) -> RelateResult<'tcx, ty::Region<'tcx>> {
Ok(a)
}
diff --git a/compiler/rustc_mir_transform/src/const_prop_lint.rs b/compiler/rustc_mir_transform/src/const_prop_lint.rs
index aa22b8c7c58e0..8a7bfaec870e3 100644
--- a/compiler/rustc_mir_transform/src/const_prop_lint.rs
+++ b/compiler/rustc_mir_transform/src/const_prop_lint.rs
@@ -541,12 +541,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
}
#[instrument(level = "trace", skip(self), ret)]
- fn eval_rvalue(
- &mut self,
- rvalue: &Rvalue<'tcx>,
- location: Location,
- dest: &Place<'tcx>,
- ) -> Option<()> {
+ fn eval_rvalue(&mut self, rvalue: &Rvalue<'tcx>, dest: &Place<'tcx>) -> Option<()> {
if !dest.projection.is_empty() {
return None;
}
@@ -733,7 +728,7 @@ impl<'tcx> Visitor<'tcx> for ConstPropagator<'_, 'tcx> {
_ if place.is_indirect() => {}
ConstPropMode::NoPropagation => self.ensure_not_propagated(place.local),
ConstPropMode::OnlyInsideOwnBlock | ConstPropMode::FullConstProp => {
- if self.eval_rvalue(rvalue, location, place).is_none() {
+ if self.eval_rvalue(rvalue, place).is_none() {
// Const prop failed, so erase the destination, ensuring that whatever happens
// from here on, does not know about the previous value.
// This is important in case we have
diff --git a/compiler/rustc_pattern_analysis/src/lints.rs b/compiler/rustc_pattern_analysis/src/lints.rs
index 3f1497540d25e..30e775733de75 100644
--- a/compiler/rustc_pattern_analysis/src/lints.rs
+++ b/compiler/rustc_pattern_analysis/src/lints.rs
@@ -10,7 +10,7 @@ use crate::MatchArm;
/// Traverse the patterns to collect any variants of a non_exhaustive enum that fail to be mentioned
/// in a given column.
#[instrument(level = "debug", skip(cx), ret)]
-fn collect_nonexhaustive_missing_variants<'a, 'p, 'tcx>(
+fn collect_nonexhaustive_missing_variants<'p, 'tcx>(
cx: &RustcMatchCheckCtxt<'p, 'tcx>,
column: &PatternColumn<'p, RustcMatchCheckCtxt<'p, 'tcx>>,
) -> Result<Vec<WitnessPat<'p, 'tcx>>, ErrorGuaranteed> {
diff --git a/compiler/rustc_query_system/src/dep_graph/graph.rs b/compiler/rustc_query_system/src/dep_graph/graph.rs
index 2faa4876798e0..b6ac54a9ab59b 100644
--- a/compiler/rustc_query_system/src/dep_graph/graph.rs
+++ b/compiler/rustc_query_system/src/dep_graph/graph.rs
@@ -52,7 +52,7 @@ impl From<DepNodeIndex> for QueryInvocationId {
}
}
-pub(crate) struct MarkFrame<'a> {
+pub struct MarkFrame<'a> {
index: SerializedDepNodeIndex,
parent: Option<&'a MarkFrame<'a>>,
}
@@ -754,7 +754,6 @@ impl<D: Deps> DepGraphData<D> {
&self,
qcx: Qcx,
parent_dep_node_index: SerializedDepNodeIndex,
- dep_node: &DepNode,
frame: Option<&MarkFrame<'_>>,
) -> Option<()> {
let dep_dep_node_color = self.colors.get(parent_dep_node_index);
@@ -861,7 +860,7 @@ impl<D: Deps> DepGraphData<D> {
let prev_deps = self.previous.edge_targets_from(prev_dep_node_index);
for dep_dep_node_index in prev_deps {
- self.try_mark_parent_green(qcx, dep_dep_node_index, dep_node, Some(&frame))?;
+ self.try_mark_parent_green(qcx, dep_dep_node_index, Some(&frame))?;
}
// If we got here without hitting a `return` that means that all
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 9788fcb3c7d36..61d43e0493cd7 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -1644,7 +1644,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
debug!(?rib.kind);
match rib.kind {
LifetimeRibKind::AnonymousCreateParameter { binder, .. } => {
- let res = self.create_fresh_lifetime(lifetime.id, lifetime.ident, binder);
+ let res = self.create_fresh_lifetime(lifetime.ident, binder);
self.record_lifetime_res(lifetime.id, res, elision_candidate);
return;
}
@@ -1736,7 +1736,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
}
#[instrument(level = "debug", skip(self))]
- fn create_fresh_lifetime(&mut self, id: NodeId, ident: Ident, binder: NodeId) -> LifetimeRes {
+ fn create_fresh_lifetime(&mut self, ident: Ident, binder: NodeId) -> LifetimeRes {
debug_assert_eq!(ident.name, kw::UnderscoreLifetime);
debug!(?ident.span);
@@ -1757,7 +1757,6 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
#[instrument(level = "debug", skip(self))]
fn resolve_elided_lifetimes_in_path(
&mut self,
- path_id: NodeId,
partial_res: PartialRes,
path: &[Segment],
source: PathSource<'_>,
@@ -1890,7 +1889,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
// Group all suggestions into the first record.
let mut candidate = LifetimeElisionCandidate::Missing(missing_lifetime);
for id in node_ids {
- let res = self.create_fresh_lifetime(id, ident, binder);
+ let res = self.create_fresh_lifetime(ident, binder);
self.record_lifetime_res(
id,
res,
@@ -3935,7 +3934,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
if record_partial_res == RecordPartialRes::Yes {
// Avoid recording definition of `A::B` in `<T as A>::B::C`.
self.r.record_partial_res(node_id, partial_res);
- self.resolve_elided_lifetimes_in_path(node_id, partial_res, path, source, path_span);
+ self.resolve_elided_lifetimes_in_path(partial_res, path, source, path_span);
}
partial_res
diff --git a/compiler/rustc_trait_selection/src/solve/assembly/mod.rs b/compiler/rustc_trait_selection/src/solve/assembly/mod.rs
index 915d722dd0206..7026ca6bed75e 100644
--- a/compiler/rustc_trait_selection/src/solve/assembly/mod.rs
+++ b/compiler/rustc_trait_selection/src/solve/assembly/mod.rs
@@ -803,7 +803,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
#[instrument(level = "debug", skip(self), ret)]
pub(super) fn merge_candidates(
&mut self,
- mut candidates: Vec<Candidate<'tcx>>,
+ candidates: Vec<Candidate<'tcx>>,
) -> QueryResult<'tcx> {
// First try merging all candidates. This is complete and fully sound.
let responses = candidates.iter().map(|c| c.result).collect::<Vec<_>>();
diff --git a/compiler/rustc_trait_selection/src/solve/mod.rs b/compiler/rustc_trait_selection/src/solve/mod.rs
index 6984f0ba69473..a7330136fe789 100644
--- a/compiler/rustc_trait_selection/src/solve/mod.rs
+++ b/compiler/rustc_trait_selection/src/solve/mod.rs
@@ -124,25 +124,6 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
}
}
- #[instrument(level = "debug", skip(self))]
- fn compute_closure_kind_goal(
- &mut self,
- goal: Goal<'tcx, (DefId, ty::GenericArgsRef<'tcx>, ty::ClosureKind)>,
- ) -> QueryResult<'tcx> {
- let (_, args, expected_kind) = goal.predicate;
- let found_kind = args.as_closure().kind_ty().to_opt_closure_kind();
-
- let Some(found_kind) = found_kind else {
- return self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS);
- };
- if found_kind.extends(expected_kind) {
- self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
- } else {
- Err(NoSolution)
- }
- }
-
- #[instrument(level = "debug", skip(self))]
fn compute_object_safe_goal(&mut self, trait_def_id: DefId) -> QueryResult<'tcx> {
if self.tcx().check_is_object_safe(trait_def_id) {
self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 6a6adcbb680ea..4f5e146d2347e 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -483,7 +483,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
// Instead, we select the right impl now but report "`Bar` does
// not implement `Clone`".
if candidates.len() == 1 {
- return self.filter_reservation_impls(candidates.pop().unwrap(), stack.obligation);
+ return self.filter_reservation_impls(candidates.pop().unwrap());
}
// Winnow, but record the exact outcome of evaluation, which
@@ -557,7 +557,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
}
// Just one candidate left.
- self.filter_reservation_impls(candidates.pop().unwrap().candidate, stack.obligation)
+ self.filter_reservation_impls(candidates.pop().unwrap().candidate)
}
///////////////////////////////////////////////////////////////////////////
@@ -1436,7 +1436,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
fn filter_reservation_impls(
&mut self,
candidate: SelectionCandidate<'tcx>,
- obligation: &PolyTraitObligation<'tcx>,
) -> SelectionResult<'tcx, SelectionCandidate<'tcx>> {
let tcx = self.tcx();
// Treat reservation impls as ambiguity.
From c2a0d116706e83249f1ec78c4de5e06dee7065d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=AE=B8=E6=9D=B0=E5=8F=8B=20Jieyou=20Xu=20=28Joe=29?=
<jieyouxu@outlook.com>
Date: Fri, 2 Feb 2024 22:49:02 +0000
Subject: [PATCH 04/18] Fix incorrect stage std paths
---
src/tools/compiletest/src/runtest.rs | 10 ++--------
1 file changed, 2 insertions(+), 8 deletions(-)
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index b96c0b8d317d8..67b483bf40a7a 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -3773,14 +3773,8 @@ impl<'test> TestCx<'test> {
let mut stage_std_path = PathBuf::new();
stage_std_path.push(&build_root);
- if stage == "stage0" {
- stage_std_path.push("stage0-std");
- } else {
- // stage2 reuses stage1-std.
- stage_std_path.push("stage1-std");
- }
- stage_std_path.push(&self.config.target);
- stage_std_path.push("release/deps");
+ stage_std_path.push(&stage);
+ stage_std_path.push("lib");
// Then, we need to build the recipe `rmake.rs` and link in the support library.
let recipe_bin = tmpdir.join("rmake");
From 0bfcafd94709f2cf1d9fd7cdbe98b4ff3043f310 Mon Sep 17 00:00:00 2001
From: David Carlier <devnexen@gmail.com>
Date: Fri, 2 Feb 2024 20:55:44 +0000
Subject: [PATCH 05/18] std::thread::available_parallelism merging
linux/android/freebsd version
FreeBSD 13.1 had introduced a sched cpu affinity compatibility layer
with Linux. 13.0 and even 13.1 being EOL, we can simplify here.
---
library/std/src/sys/pal/unix/thread.rs | 33 +++++++++-----------------
1 file changed, 11 insertions(+), 22 deletions(-)
diff --git a/library/std/src/sys/pal/unix/thread.rs b/library/std/src/sys/pal/unix/thread.rs
index 7e4a01a5ecd33..84297316a421d 100644
--- a/library/std/src/sys/pal/unix/thread.rs
+++ b/library/std/src/sys/pal/unix/thread.rs
@@ -320,6 +320,7 @@ pub fn available_parallelism() -> io::Result<NonZeroUsize> {
target_os = "solaris",
target_os = "illumos",
target_os = "aix",
+ target_os = "freebsd",
))] {
#[allow(unused_assignments)]
#[allow(unused_mut)]
@@ -328,9 +329,17 @@ pub fn available_parallelism() -> io::Result<NonZeroUsize> {
#[cfg(any(target_os = "android", target_os = "linux"))]
{
quota = cgroups::quota().max(1);
- let mut set: libc::cpu_set_t = unsafe { mem::zeroed() };
+ }
+
+ #[cfg(any(target_os = "android", target_os = "linux", target_os = "freebsd"))]
+ {
+ #[cfg(not(target_os = "freebsd"))]
+ type cpuset = libc::cpu_set_t;
+ #[cfg(target_os = "freebsd")]
+ type cpuset = libc::cpuset_t;
+ let mut set: cpuset = unsafe { mem::zeroed() };
unsafe {
- if libc::sched_getaffinity(0, mem::size_of::<libc::cpu_set_t>(), &mut set) == 0 {
+ if libc::sched_getaffinity(0, mem::size_of::<cpuset>(), &mut set) == 0 {
let count = libc::CPU_COUNT(&set) as usize;
let count = count.min(quota);
@@ -355,32 +364,12 @@ pub fn available_parallelism() -> io::Result<NonZeroUsize> {
}
}
} else if #[cfg(any(
- target_os = "freebsd",
target_os = "dragonfly",
target_os = "openbsd",
target_os = "netbsd",
))] {
use crate::ptr;
- #[cfg(target_os = "freebsd")]
- {
- let mut set: libc::cpuset_t = unsafe { mem::zeroed() };
- unsafe {
- if libc::cpuset_getaffinity(
- libc::CPU_LEVEL_WHICH,
- libc::CPU_WHICH_PID,
- -1,
- mem::size_of::<libc::cpuset_t>(),
- &mut set,
- ) == 0 {
- let count = libc::CPU_COUNT(&set) as usize;
- if count > 0 {
- return Ok(NonZeroUsize::new_unchecked(count));
- }
- }
- }
- }
-
#[cfg(target_os = "netbsd")]
{
unsafe {
From 0ac1195ee0f8cd6d87e654a2312b899883272ec2 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 6 Feb 2024 09:51:39 +1100
Subject: [PATCH 06/18] Invert diagnostic lints.
That is, change `diagnostic_outside_of_impl` and
`untranslatable_diagnostic` from `allow` to `deny`, because more than
half of the compiler has be converted to use translated diagnostics.
This commit removes more `deny` attributes than it adds `allow`
attributes, which proves that this change is warranted.
---
compiler/rustc_arena/src/lib.rs | 2 --
compiler/rustc_ast/src/lib.rs | 2 --
compiler/rustc_ast_lowering/src/lib.rs | 2 --
compiler/rustc_ast_passes/src/lib.rs | 2 --
compiler/rustc_ast_pretty/src/lib.rs | 2 --
compiler/rustc_attr/src/lib.rs | 2 --
compiler/rustc_borrowck/src/borrow_set.rs | 2 --
compiler/rustc_borrowck/src/borrowck_errors.rs | 3 +++
compiler/rustc_borrowck/src/constraints/mod.rs | 3 ---
compiler/rustc_borrowck/src/consumers.rs | 2 --
compiler/rustc_borrowck/src/dataflow.rs | 2 --
compiler/rustc_borrowck/src/def_use.rs | 2 --
.../rustc_borrowck/src/diagnostics/bound_region_errors.rs | 3 ---
.../rustc_borrowck/src/diagnostics/conflict_errors.rs | 3 +++
compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs | 3 +++
.../rustc_borrowck/src/diagnostics/find_all_local_uses.rs | 3 ---
compiler/rustc_borrowck/src/diagnostics/find_use.rs | 3 ---
compiler/rustc_borrowck/src/diagnostics/move_errors.rs | 3 +++
.../rustc_borrowck/src/diagnostics/mutability_errors.rs | 3 +++
.../rustc_borrowck/src/diagnostics/outlives_suggestion.rs | 3 +++
compiler/rustc_borrowck/src/diagnostics/region_errors.rs | 2 --
compiler/rustc_borrowck/src/diagnostics/region_name.rs | 3 +++
compiler/rustc_borrowck/src/diagnostics/var_name.rs | 3 ---
compiler/rustc_borrowck/src/facts.rs | 2 --
compiler/rustc_borrowck/src/location.rs | 2 --
compiler/rustc_borrowck/src/member_constraints.rs | 2 --
compiler/rustc_borrowck/src/nll.rs | 2 --
compiler/rustc_borrowck/src/path_utils.rs | 2 --
compiler/rustc_borrowck/src/place_ext.rs | 2 --
compiler/rustc_borrowck/src/places_conflict.rs | 2 --
.../rustc_borrowck/src/polonius/loan_invalidations.rs | 2 --
compiler/rustc_borrowck/src/polonius/loan_kills.rs | 2 --
compiler/rustc_borrowck/src/prefixes.rs | 2 --
compiler/rustc_borrowck/src/region_infer/dump_mir.rs | 2 --
compiler/rustc_borrowck/src/region_infer/graphviz.rs | 2 --
compiler/rustc_borrowck/src/region_infer/opaque_types.rs | 2 ++
compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs | 2 --
compiler/rustc_borrowck/src/region_infer/values.rs | 2 --
compiler/rustc_borrowck/src/renumber.rs | 2 --
compiler/rustc_borrowck/src/type_check/mod.rs | 2 --
compiler/rustc_borrowck/src/universal_regions.rs | 3 +++
compiler/rustc_borrowck/src/used_muts.rs | 2 --
compiler/rustc_builtin_macros/src/lib.rs | 2 ++
compiler/rustc_codegen_cranelift/src/lib.rs | 2 ++
compiler/rustc_codegen_gcc/src/lib.rs | 2 --
compiler/rustc_codegen_llvm/src/lib.rs | 2 --
compiler/rustc_codegen_ssa/src/lib.rs | 2 ++
compiler/rustc_const_eval/src/lib.rs | 2 +-
compiler/rustc_data_structures/src/lib.rs | 2 --
compiler/rustc_driver_impl/src/lib.rs | 2 --
compiler/rustc_error_codes/src/lib.rs | 2 --
compiler/rustc_error_messages/src/lib.rs | 2 --
compiler/rustc_errors/src/lib.rs | 2 ++
compiler/rustc_expand/src/base.rs | 2 --
compiler/rustc_expand/src/lib.rs | 2 +-
compiler/rustc_feature/src/lib.rs | 2 --
compiler/rustc_fluent_macro/src/lib.rs | 2 --
compiler/rustc_fs_util/src/lib.rs | 2 --
compiler/rustc_graphviz/src/lib.rs | 2 --
compiler/rustc_hir/src/lib.rs | 2 --
compiler/rustc_hir_analysis/src/lib.rs | 2 ++
compiler/rustc_hir_pretty/src/lib.rs | 2 --
compiler/rustc_hir_typeck/src/lib.rs | 2 ++
compiler/rustc_incremental/src/lib.rs | 2 --
compiler/rustc_index/src/lib.rs | 2 --
compiler/rustc_infer/src/lib.rs | 2 ++
compiler/rustc_interface/src/lib.rs | 2 --
compiler/rustc_lexer/src/lib.rs | 3 +--
compiler/rustc_lint/src/internal.rs | 4 ++--
compiler/rustc_lint/src/lib.rs | 2 --
compiler/rustc_lint/src/lints.rs | 3 ++-
compiler/rustc_lint_defs/src/lib.rs | 2 --
compiler/rustc_llvm/src/lib.rs | 2 --
compiler/rustc_log/src/lib.rs | 3 ---
compiler/rustc_macros/src/lib.rs | 2 --
compiler/rustc_metadata/src/lib.rs | 2 --
compiler/rustc_middle/src/lib.rs | 4 +++-
compiler/rustc_mir_build/src/lib.rs | 3 +++
compiler/rustc_mir_dataflow/src/lib.rs | 2 --
compiler/rustc_mir_transform/src/lib.rs | 2 --
compiler/rustc_monomorphize/src/lib.rs | 2 --
compiler/rustc_parse/src/lib.rs | 4 +++-
compiler/rustc_parse_format/src/lib.rs | 2 --
compiler/rustc_passes/src/lib.rs | 2 --
compiler/rustc_pattern_analysis/src/lib.rs | 3 +++
compiler/rustc_privacy/src/lib.rs | 2 --
compiler/rustc_query_impl/src/lib.rs | 2 --
compiler/rustc_query_system/src/lib.rs | 2 --
compiler/rustc_resolve/src/lib.rs | 2 ++
compiler/rustc_serialize/src/lib.rs | 2 --
compiler/rustc_session/src/lib.rs | 2 --
compiler/rustc_span/src/lib.rs | 2 --
compiler/rustc_symbol_mangling/src/lib.rs | 2 --
compiler/rustc_target/src/lib.rs | 2 --
compiler/rustc_trait_selection/src/lib.rs | 2 ++
compiler/rustc_traits/src/lib.rs | 2 --
compiler/rustc_transmute/src/lib.rs | 2 --
compiler/rustc_ty_utils/src/lib.rs | 2 --
compiler/rustc_ty_utils/src/representability.rs | 2 --
compiler/rustc_type_ir/src/lib.rs | 2 --
src/librustdoc/lib.rs | 2 ++
src/tools/clippy/clippy_config/src/lib.rs | 4 +++-
src/tools/clippy/clippy_lints/src/lib.rs | 7 ++++++-
src/tools/clippy/clippy_utils/src/lib.rs | 8 +++++++-
src/tools/clippy/src/driver.rs | 2 ++
src/tools/miri/src/bin/miri.rs | 4 +++-
src/tools/miri/src/lib.rs | 4 +++-
107 files changed, 89 insertions(+), 166 deletions(-)
diff --git a/compiler/rustc_arena/src/lib.rs b/compiler/rustc_arena/src/lib.rs
index 90ddeec4bc7a4..5cb79d9eea53b 100644
--- a/compiler/rustc_arena/src/lib.rs
+++ b/compiler/rustc_arena/src/lib.rs
@@ -22,8 +22,6 @@
#![cfg_attr(test, feature(test))]
#![feature(strict_provenance)]
#![deny(unsafe_op_in_unsafe_fn)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#![allow(internal_features)]
#![allow(clippy::mut_from_ref)] // Arena allocators are one of the places where this pattern is fine.
diff --git a/compiler/rustc_ast/src/lib.rs b/compiler/rustc_ast/src/lib.rs
index 76d838308b461..356e9fef439ed 100644
--- a/compiler/rustc_ast/src/lib.rs
+++ b/compiler/rustc_ast/src/lib.rs
@@ -18,8 +18,6 @@
#![feature(min_specialization)]
#![feature(negative_impls)]
#![feature(stmt_expr_attributes)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate rustc_macros;
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index f26b1331ef388..0c3696074d936 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -35,8 +35,6 @@
#![doc(rust_logo)]
#![feature(box_patterns)]
#![feature(let_chains)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate tracing;
diff --git a/compiler/rustc_ast_passes/src/lib.rs b/compiler/rustc_ast_passes/src/lib.rs
index fa6cdd55c3dcb..74d0fff2734fc 100644
--- a/compiler/rustc_ast_passes/src/lib.rs
+++ b/compiler/rustc_ast_passes/src/lib.rs
@@ -11,8 +11,6 @@
#![feature(if_let_guard)]
#![feature(iter_is_partitioned)]
#![feature(let_chains)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
pub mod ast_validation;
mod errors;
diff --git a/compiler/rustc_ast_pretty/src/lib.rs b/compiler/rustc_ast_pretty/src/lib.rs
index 61617beb86b5a..b9e217a21e39f 100644
--- a/compiler/rustc_ast_pretty/src/lib.rs
+++ b/compiler/rustc_ast_pretty/src/lib.rs
@@ -1,8 +1,6 @@
#![allow(internal_features)]
#![feature(rustdoc_internals)]
#![doc(rust_logo)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#![feature(box_patterns)]
mod helpers;
diff --git a/compiler/rustc_attr/src/lib.rs b/compiler/rustc_attr/src/lib.rs
index 3c5bcecddeaa4..dd87a5c4dc384 100644
--- a/compiler/rustc_attr/src/lib.rs
+++ b/compiler/rustc_attr/src/lib.rs
@@ -8,8 +8,6 @@
#![feature(rustdoc_internals)]
#![doc(rust_logo)]
#![feature(let_chains)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate rustc_macros;
diff --git a/compiler/rustc_borrowck/src/borrow_set.rs b/compiler/rustc_borrowck/src/borrow_set.rs
index 948af03953718..6a683d129ded1 100644
--- a/compiler/rustc_borrowck/src/borrow_set.rs
+++ b/compiler/rustc_borrowck/src/borrow_set.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use crate::path_utils::allow_two_phase_borrow;
use crate::place_ext::PlaceExt;
use crate::BorrowIndex;
diff --git a/compiler/rustc_borrowck/src/borrowck_errors.rs b/compiler/rustc_borrowck/src/borrowck_errors.rs
index 6cbcda37f50b8..429bcb74a8efc 100644
--- a/compiler/rustc_borrowck/src/borrowck_errors.rs
+++ b/compiler/rustc_borrowck/src/borrowck_errors.rs
@@ -1,3 +1,6 @@
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
+
use rustc_errors::{codes::*, struct_span_code_err, DiagCtxt, DiagnosticBuilder};
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_span::Span;
diff --git a/compiler/rustc_borrowck/src/constraints/mod.rs b/compiler/rustc_borrowck/src/constraints/mod.rs
index 041ac75ec016e..ff11e4db12133 100644
--- a/compiler/rustc_borrowck/src/constraints/mod.rs
+++ b/compiler/rustc_borrowck/src/constraints/mod.rs
@@ -1,6 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
-
use rustc_data_structures::graph::scc::Sccs;
use rustc_index::{IndexSlice, IndexVec};
use rustc_middle::mir::ConstraintCategory;
diff --git a/compiler/rustc_borrowck/src/consumers.rs b/compiler/rustc_borrowck/src/consumers.rs
index becfa535a59cc..a58fe2b744701 100644
--- a/compiler/rustc_borrowck/src/consumers.rs
+++ b/compiler/rustc_borrowck/src/consumers.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
//! This file provides API for compiler consumers.
use rustc_hir::def_id::LocalDefId;
diff --git a/compiler/rustc_borrowck/src/dataflow.rs b/compiler/rustc_borrowck/src/dataflow.rs
index 1bd891bdd685c..bc5bd7879563a 100644
--- a/compiler/rustc_borrowck/src/dataflow.rs
+++ b/compiler/rustc_borrowck/src/dataflow.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use rustc_data_structures::fx::FxIndexMap;
use rustc_data_structures::graph::WithSuccessors;
use rustc_index::bit_set::BitSet;
diff --git a/compiler/rustc_borrowck/src/def_use.rs b/compiler/rustc_borrowck/src/def_use.rs
index d0cf339e7ba41..6fd80d005d9e3 100644
--- a/compiler/rustc_borrowck/src/def_use.rs
+++ b/compiler/rustc_borrowck/src/def_use.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use rustc_middle::mir::visit::{
MutatingUseContext, NonMutatingUseContext, NonUseContext, PlaceContext,
};
diff --git a/compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs b/compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs
index bb5335febbf5e..a540fcee871c7 100644
--- a/compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs
@@ -1,6 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
-
use rustc_errors::DiagnosticBuilder;
use rustc_infer::infer::canonical::Canonical;
use rustc_infer::infer::error_reporting::nice_region_error::NiceRegionError;
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index b0b7cc076bab5..226a7ddba6cc5 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -1,5 +1,8 @@
// ignore-tidy-filelength
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
+
use either::Either;
use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::FxIndexSet;
diff --git a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
index 4f66468a865f8..9627dc5368066 100644
--- a/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs
@@ -1,5 +1,8 @@
//! Print diagnostics to explain why values are borrowed.
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
+
use rustc_errors::{Applicability, Diagnostic};
use rustc_hir as hir;
use rustc_hir::intravisit::Visitor;
diff --git a/compiler/rustc_borrowck/src/diagnostics/find_all_local_uses.rs b/compiler/rustc_borrowck/src/diagnostics/find_all_local_uses.rs
index 2c4d953f011fc..ff4f2bb9614f1 100644
--- a/compiler/rustc_borrowck/src/diagnostics/find_all_local_uses.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/find_all_local_uses.rs
@@ -1,6 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
-
use std::collections::BTreeSet;
use rustc_middle::mir::visit::{PlaceContext, Visitor};
diff --git a/compiler/rustc_borrowck/src/diagnostics/find_use.rs b/compiler/rustc_borrowck/src/diagnostics/find_use.rs
index 2495613fea1d2..94b17e0a2f99c 100644
--- a/compiler/rustc_borrowck/src/diagnostics/find_use.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/find_use.rs
@@ -1,6 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
-
use std::collections::VecDeque;
use std::rc::Rc;
diff --git a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
index 0a0bb75a2a3a6..126a50c91b494 100644
--- a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
@@ -1,3 +1,6 @@
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
+
use rustc_errors::{Applicability, Diagnostic, DiagnosticBuilder};
use rustc_middle::mir::*;
use rustc_middle::ty::{self, Ty};
diff --git a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
index 3fddf67f55b97..4200bdf453db2 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
@@ -1,3 +1,6 @@
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
+
use hir::ExprKind;
use rustc_errors::{Applicability, Diagnostic, DiagnosticBuilder};
use rustc_hir as hir;
diff --git a/compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs b/compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs
index bac1d9dd57f6b..93e28a5f3f3e2 100644
--- a/compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs
@@ -1,6 +1,9 @@
//! Contains utilities for generating suggestions for borrowck errors related to unsatisfied
//! outlives constraints.
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
+
use rustc_data_structures::fx::FxIndexSet;
use rustc_errors::Diagnostic;
use rustc_middle::ty::RegionVid;
diff --git a/compiler/rustc_borrowck/src/diagnostics/region_errors.rs b/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
index 8c8ca1ead400b..3a16d37b1b1b9 100644
--- a/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
//! Error reporting machinery for lifetime errors.
use rustc_data_structures::fx::FxIndexSet;
diff --git a/compiler/rustc_borrowck/src/diagnostics/region_name.rs b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
index 15e1066e983a9..8d5a6731f9b44 100644
--- a/compiler/rustc_borrowck/src/diagnostics/region_name.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
@@ -1,3 +1,6 @@
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
+
use std::fmt::{self, Display};
use std::iter;
diff --git a/compiler/rustc_borrowck/src/diagnostics/var_name.rs b/compiler/rustc_borrowck/src/diagnostics/var_name.rs
index 28e07f2a81edd..0479cd8af35e2 100644
--- a/compiler/rustc_borrowck/src/diagnostics/var_name.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/var_name.rs
@@ -1,6 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
-
use crate::region_infer::RegionInferenceContext;
use rustc_index::IndexSlice;
use rustc_middle::mir::{Body, Local};
diff --git a/compiler/rustc_borrowck/src/facts.rs b/compiler/rustc_borrowck/src/facts.rs
index c54e7070478ca..68dc9a6764bfc 100644
--- a/compiler/rustc_borrowck/src/facts.rs
+++ b/compiler/rustc_borrowck/src/facts.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use crate::location::{LocationIndex, LocationTable};
use crate::BorrowIndex;
use polonius_engine::AllFacts as PoloniusFacts;
diff --git a/compiler/rustc_borrowck/src/location.rs b/compiler/rustc_borrowck/src/location.rs
index 6f09393169f3d..63e59217e5d7d 100644
--- a/compiler/rustc_borrowck/src/location.rs
+++ b/compiler/rustc_borrowck/src/location.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use rustc_index::IndexVec;
use rustc_middle::mir::{BasicBlock, Body, Location};
diff --git a/compiler/rustc_borrowck/src/member_constraints.rs b/compiler/rustc_borrowck/src/member_constraints.rs
index 842e90080582f..5129b32d492dd 100644
--- a/compiler/rustc_borrowck/src/member_constraints.rs
+++ b/compiler/rustc_borrowck/src/member_constraints.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::FxIndexMap;
use rustc_index::{IndexSlice, IndexVec};
diff --git a/compiler/rustc_borrowck/src/nll.rs b/compiler/rustc_borrowck/src/nll.rs
index 7ace013975e1b..67237c3adcf20 100644
--- a/compiler/rustc_borrowck/src/nll.rs
+++ b/compiler/rustc_borrowck/src/nll.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
//! The entry point of the NLL borrow checker.
use polonius_engine::{Algorithm, Output};
diff --git a/compiler/rustc_borrowck/src/path_utils.rs b/compiler/rustc_borrowck/src/path_utils.rs
index 2d997dfadf004..d2c1c384e52a8 100644
--- a/compiler/rustc_borrowck/src/path_utils.rs
+++ b/compiler/rustc_borrowck/src/path_utils.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use crate::borrow_set::{BorrowData, BorrowSet, TwoPhaseActivation};
use crate::places_conflict;
use crate::AccessDepth;
diff --git a/compiler/rustc_borrowck/src/place_ext.rs b/compiler/rustc_borrowck/src/place_ext.rs
index 3d7e8c6ebf330..b59ab7fafa576 100644
--- a/compiler/rustc_borrowck/src/place_ext.rs
+++ b/compiler/rustc_borrowck/src/place_ext.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use crate::borrow_set::LocalsStateAtExit;
use rustc_hir as hir;
use rustc_middle::mir::ProjectionElem;
diff --git a/compiler/rustc_borrowck/src/places_conflict.rs b/compiler/rustc_borrowck/src/places_conflict.rs
index 777ebf0d438dc..7e8dba43b715e 100644
--- a/compiler/rustc_borrowck/src/places_conflict.rs
+++ b/compiler/rustc_borrowck/src/places_conflict.rs
@@ -50,8 +50,6 @@
//! and either equal or disjoint.
//! - If we did run out of access, the borrow can access a part of it.
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use crate::ArtificialField;
use crate::Overlap;
use crate::{AccessDepth, Deep, Shallow};
diff --git a/compiler/rustc_borrowck/src/polonius/loan_invalidations.rs b/compiler/rustc_borrowck/src/polonius/loan_invalidations.rs
index 5c9056272cc0d..93aae1a7f9762 100644
--- a/compiler/rustc_borrowck/src/polonius/loan_invalidations.rs
+++ b/compiler/rustc_borrowck/src/polonius/loan_invalidations.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use rustc_data_structures::graph::dominators::Dominators;
use rustc_middle::mir::visit::Visitor;
use rustc_middle::mir::{self, BasicBlock, Body, Location, NonDivergingIntrinsic, Place, Rvalue};
diff --git a/compiler/rustc_borrowck/src/polonius/loan_kills.rs b/compiler/rustc_borrowck/src/polonius/loan_kills.rs
index 5df943837025e..53adad5561e60 100644
--- a/compiler/rustc_borrowck/src/polonius/loan_kills.rs
+++ b/compiler/rustc_borrowck/src/polonius/loan_kills.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use rustc_middle::mir::visit::Visitor;
use rustc_middle::mir::{
Body, Local, Location, Place, PlaceRef, ProjectionElem, Rvalue, Statement, StatementKind,
diff --git a/compiler/rustc_borrowck/src/prefixes.rs b/compiler/rustc_borrowck/src/prefixes.rs
index e9c9709bd1f1a..8bb3dc88b3467 100644
--- a/compiler/rustc_borrowck/src/prefixes.rs
+++ b/compiler/rustc_borrowck/src/prefixes.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
//! From the NLL RFC: "The deep [aka 'supporting'] prefixes for an
//! place are formed by stripping away fields and derefs, except that
//! we stop when we reach the deref of a shared reference. [...] "
diff --git a/compiler/rustc_borrowck/src/region_infer/dump_mir.rs b/compiler/rustc_borrowck/src/region_infer/dump_mir.rs
index cfbb2766c3397..53541b33c41d1 100644
--- a/compiler/rustc_borrowck/src/region_infer/dump_mir.rs
+++ b/compiler/rustc_borrowck/src/region_infer/dump_mir.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
//! As part of generating the regions, if you enable `-Zdump-mir=nll`,
//! we will generate an annotated copy of the MIR that includes the
//! state of region inference. This code handles emitting the region
diff --git a/compiler/rustc_borrowck/src/region_infer/graphviz.rs b/compiler/rustc_borrowck/src/region_infer/graphviz.rs
index 408c8390e763c..c103ba3c40709 100644
--- a/compiler/rustc_borrowck/src/region_infer/graphviz.rs
+++ b/compiler/rustc_borrowck/src/region_infer/graphviz.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
//! This module provides linkage between RegionInferenceContext and
//! `rustc_graphviz` traits, specialized to attaching borrowck analysis
//! data to rendered labels.
diff --git a/compiler/rustc_borrowck/src/region_infer/opaque_types.rs b/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
index 462b5c8da42c7..636c174e002d2 100644
--- a/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
+++ b/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
@@ -418,6 +418,8 @@ fn check_opaque_type_parameter_valid(
.into_iter()
.map(|i| tcx.def_span(opaque_generics.param_at(i, tcx).def_id))
.collect();
+ #[allow(rustc::diagnostic_outside_of_impl)]
+ #[allow(rustc::untranslatable_diagnostic)]
return Err(tcx
.dcx()
.struct_span_err(span, "non-defining opaque type use in defining scope")
diff --git a/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs b/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs
index fe56bd54a3f17..eeb944702a7f9 100644
--- a/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs
+++ b/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use crate::constraints::ConstraintSccIndex;
use crate::RegionInferenceContext;
use itertools::Itertools;
diff --git a/compiler/rustc_borrowck/src/region_infer/values.rs b/compiler/rustc_borrowck/src/region_infer/values.rs
index e147f62011db9..b1caaa6388186 100644
--- a/compiler/rustc_borrowck/src/region_infer/values.rs
+++ b/compiler/rustc_borrowck/src/region_infer/values.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::fx::FxIndexSet;
use rustc_index::bit_set::SparseBitMatrix;
diff --git a/compiler/rustc_borrowck/src/renumber.rs b/compiler/rustc_borrowck/src/renumber.rs
index a31d39e14cd28..dca8df3280028 100644
--- a/compiler/rustc_borrowck/src/renumber.rs
+++ b/compiler/rustc_borrowck/src/renumber.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use crate::BorrowckInferCtxt;
use rustc_index::IndexSlice;
use rustc_infer::infer::NllRegionVariableOrigin;
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index 59c4d9a6c78ca..63b0dea3e2924 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
//! This pass type-checks the MIR to ensure it is not broken.
use std::rc::Rc;
diff --git a/compiler/rustc_borrowck/src/universal_regions.rs b/compiler/rustc_borrowck/src/universal_regions.rs
index ae8a135f09059..7ffa98f5806a8 100644
--- a/compiler/rustc_borrowck/src/universal_regions.rs
+++ b/compiler/rustc_borrowck/src/universal_regions.rs
@@ -12,6 +12,9 @@
//! The code in this file doesn't *do anything* with those results; it
//! just returns them for other code to use.
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
+
use rustc_data_structures::fx::FxHashMap;
use rustc_errors::Diagnostic;
use rustc_hir::def_id::{DefId, LocalDefId};
diff --git a/compiler/rustc_borrowck/src/used_muts.rs b/compiler/rustc_borrowck/src/used_muts.rs
index 6ac8e1ba7156a..81757a62e5bc5 100644
--- a/compiler/rustc_borrowck/src/used_muts.rs
+++ b/compiler/rustc_borrowck/src/used_muts.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use rustc_data_structures::fx::FxIndexSet;
use rustc_middle::mir::visit::{PlaceContext, Visitor};
use rustc_middle::mir::{
diff --git a/compiler/rustc_builtin_macros/src/lib.rs b/compiler/rustc_builtin_macros/src/lib.rs
index 4d7957ef4ddb0..d30ccab239437 100644
--- a/compiler/rustc_builtin_macros/src/lib.rs
+++ b/compiler/rustc_builtin_macros/src/lib.rs
@@ -2,6 +2,8 @@
//! injecting code into the crate before it is lowered to HIR.
#![allow(internal_features)]
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
#![feature(rustdoc_internals)]
#![doc(rust_logo)]
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
diff --git a/compiler/rustc_codegen_cranelift/src/lib.rs b/compiler/rustc_codegen_cranelift/src/lib.rs
index 416f87fcc87b3..7c432e9c59051 100644
--- a/compiler/rustc_codegen_cranelift/src/lib.rs
+++ b/compiler/rustc_codegen_cranelift/src/lib.rs
@@ -3,6 +3,8 @@
#![cfg_attr(doc, doc(rust_logo))]
#![feature(rustc_private)]
// Note: please avoid adding other feature gates where possible
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
#![warn(rust_2018_idioms)]
#![warn(unused_lifetimes)]
#![warn(unreachable_pub)]
diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
index f8f054db65ede..863b6333bcc29 100644
--- a/compiler/rustc_codegen_gcc/src/lib.rs
+++ b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -27,8 +27,6 @@
#![recursion_limit="256"]
#![warn(rust_2018_idioms)]
#![warn(unused_lifetimes)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
extern crate rustc_apfloat;
extern crate rustc_ast;
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index f4f29078190a1..de96bf477adb7 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -15,8 +15,6 @@
#![feature(let_chains)]
#![feature(min_specialization)]
#![feature(impl_trait_in_assoc_type)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate rustc_macros;
diff --git a/compiler/rustc_codegen_ssa/src/lib.rs b/compiler/rustc_codegen_ssa/src/lib.rs
index fc833a3863e40..1afc597a7ef01 100644
--- a/compiler/rustc_codegen_ssa/src/lib.rs
+++ b/compiler/rustc_codegen_ssa/src/lib.rs
@@ -2,6 +2,8 @@
#![doc(rust_logo)]
#![feature(rustdoc_internals)]
#![allow(internal_features)]
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
#![feature(associated_type_bounds)]
#![feature(box_patterns)]
#![feature(if_let_guard)]
diff --git a/compiler/rustc_const_eval/src/lib.rs b/compiler/rustc_const_eval/src/lib.rs
index 946a49982aa1a..839cfd8d85acf 100644
--- a/compiler/rustc_const_eval/src/lib.rs
+++ b/compiler/rustc_const_eval/src/lib.rs
@@ -5,9 +5,9 @@ Rust MIR: a lowered representation of Rust.
*/
#![allow(internal_features)]
+#![allow(rustc::diagnostic_outside_of_impl)]
#![feature(rustdoc_internals)]
#![doc(rust_logo)]
-#![deny(rustc::untranslatable_diagnostic)]
#![feature(assert_matches)]
#![feature(box_patterns)]
#![feature(decl_macro)]
diff --git a/compiler/rustc_data_structures/src/lib.rs b/compiler/rustc_data_structures/src/lib.rs
index 563d8501890ce..ef1183e979fdd 100644
--- a/compiler/rustc_data_structures/src/lib.rs
+++ b/compiler/rustc_data_structures/src/lib.rs
@@ -11,8 +11,6 @@
#![allow(rustc::default_hash_types)]
#![allow(rustc::potential_query_instability)]
#![cfg_attr(not(parallel_compiler), feature(cell_leak))]
-#![deny(rustc::diagnostic_outside_of_impl)]
-#![deny(rustc::untranslatable_diagnostic)]
#![deny(unsafe_op_in_unsafe_fn)]
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![doc(rust_logo)]
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 5903c43ae98af..2d40f15dca3a3 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -12,8 +12,6 @@
#![feature(let_chains)]
#![feature(panic_update_hook)]
#![feature(result_flattening)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate tracing;
diff --git a/compiler/rustc_error_codes/src/lib.rs b/compiler/rustc_error_codes/src/lib.rs
index 5b2766618fccb..da688e385aa09 100644
--- a/compiler/rustc_error_codes/src/lib.rs
+++ b/compiler/rustc_error_codes/src/lib.rs
@@ -5,8 +5,6 @@
#![feature(rustdoc_internals)]
#![doc(rust_logo)]
#![deny(rustdoc::invalid_codeblock_attributes)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
// This higher-order macro defines the error codes that are in use. It is used
// in the `rustc_errors` crate. Removed error codes are listed in the comment
diff --git a/compiler/rustc_error_messages/src/lib.rs b/compiler/rustc_error_messages/src/lib.rs
index 8fd7c5764797e..e9627007e032f 100644
--- a/compiler/rustc_error_messages/src/lib.rs
+++ b/compiler/rustc_error_messages/src/lib.rs
@@ -3,8 +3,6 @@
#![feature(lazy_cell)]
#![feature(rustc_attrs)]
#![feature(type_alias_impl_trait)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#![allow(internal_features)]
#[macro_use]
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index b2bd4d8eb956e..ccdad326c6320 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -5,6 +5,8 @@
// tidy-alphabetical-start
#![allow(incomplete_features)]
#![allow(internal_features)]
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![doc(rust_logo)]
#![feature(array_windows)]
diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index 657e19277a7ed..cfeb31fc4c813 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-
use crate::base::ast::NestedMetaItem;
use crate::errors;
use crate::expand::{self, AstFragment, Invocation};
diff --git a/compiler/rustc_expand/src/lib.rs b/compiler/rustc_expand/src/lib.rs
index 2cf6a8df7c5ff..4da86d77dc88f 100644
--- a/compiler/rustc_expand/src/lib.rs
+++ b/compiler/rustc_expand/src/lib.rs
@@ -10,7 +10,7 @@
#![feature(proc_macro_internals)]
#![feature(proc_macro_span)]
#![feature(try_blocks)]
-#![deny(rustc::untranslatable_diagnostic)]
+#![allow(rustc::diagnostic_outside_of_impl)]
#![allow(internal_features)]
#[macro_use]
diff --git a/compiler/rustc_feature/src/lib.rs b/compiler/rustc_feature/src/lib.rs
index cd1d9b13daa15..f1c8f2e2dde5c 100644
--- a/compiler/rustc_feature/src/lib.rs
+++ b/compiler/rustc_feature/src/lib.rs
@@ -15,8 +15,6 @@
#![feature(rustdoc_internals)]
#![doc(rust_logo)]
#![feature(lazy_cell)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
mod accepted;
mod builtin_attrs;
diff --git a/compiler/rustc_fluent_macro/src/lib.rs b/compiler/rustc_fluent_macro/src/lib.rs
index fc65d1eb8c4ce..e3784409af8fd 100644
--- a/compiler/rustc_fluent_macro/src/lib.rs
+++ b/compiler/rustc_fluent_macro/src/lib.rs
@@ -4,8 +4,6 @@
#![feature(rustdoc_internals)]
#![feature(proc_macro_diagnostic)]
#![feature(proc_macro_span)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#![allow(rustc::default_hash_types)]
use proc_macro::TokenStream;
diff --git a/compiler/rustc_fs_util/src/lib.rs b/compiler/rustc_fs_util/src/lib.rs
index 81d6333814544..3359fef8c1c46 100644
--- a/compiler/rustc_fs_util/src/lib.rs
+++ b/compiler/rustc_fs_util/src/lib.rs
@@ -1,6 +1,4 @@
#![feature(absolute_path)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use std::ffi::CString;
use std::fs;
diff --git a/compiler/rustc_graphviz/src/lib.rs b/compiler/rustc_graphviz/src/lib.rs
index eba3215d93153..43bee5c4be029 100644
--- a/compiler/rustc_graphviz/src/lib.rs
+++ b/compiler/rustc_graphviz/src/lib.rs
@@ -276,8 +276,6 @@
#![feature(rustdoc_internals)]
#![doc(rust_logo)]
#![allow(internal_features)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use LabelText::*;
diff --git a/compiler/rustc_hir/src/lib.rs b/compiler/rustc_hir/src/lib.rs
index 6c64d802e68f1..aff946ac58081 100644
--- a/compiler/rustc_hir/src/lib.rs
+++ b/compiler/rustc_hir/src/lib.rs
@@ -9,8 +9,6 @@
#![feature(never_type)]
#![feature(rustc_attrs)]
#![feature(variant_count)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#![allow(internal_features)]
#[macro_use]
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
index 454cb97ac148b..9904d8dc5faad 100644
--- a/compiler/rustc_hir_analysis/src/lib.rs
+++ b/compiler/rustc_hir_analysis/src/lib.rs
@@ -55,7 +55,9 @@ This API is completely unstable and subject to change.
*/
+#![allow(rustc::diagnostic_outside_of_impl)]
#![allow(rustc::potential_query_instability)]
+#![allow(rustc::untranslatable_diagnostic)]
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![doc(rust_logo)]
#![feature(rustdoc_internals)]
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index 9d0c5cb0f32b0..b7709deeb4ad4 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -2,8 +2,6 @@
//! the definitions in this file have equivalents in `rustc_ast_pretty`.
#![recursion_limit = "256"]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
use rustc_ast as ast;
use rustc_ast::util::parser::{self, AssocOp, Fixity};
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index deb3ad2edc740..3054a70e6d460 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -1,3 +1,5 @@
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
#![feature(if_let_guard)]
#![feature(let_chains)]
#![feature(try_blocks)]
diff --git a/compiler/rustc_incremental/src/lib.rs b/compiler/rustc_incremental/src/lib.rs
index 82f02b7d47aac..0729986f32fdf 100644
--- a/compiler/rustc_incremental/src/lib.rs
+++ b/compiler/rustc_incremental/src/lib.rs
@@ -5,8 +5,6 @@
#![doc(rust_logo)]
#![feature(rustdoc_internals)]
#![allow(internal_features)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate rustc_middle;
diff --git a/compiler/rustc_index/src/lib.rs b/compiler/rustc_index/src/lib.rs
index 854841206b89b..6fcb3a024ab6f 100644
--- a/compiler/rustc_index/src/lib.rs
+++ b/compiler/rustc_index/src/lib.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#![cfg_attr(
feature = "nightly",
feature(extend_one, min_specialization, new_uninit, step_trait, test)
diff --git a/compiler/rustc_infer/src/lib.rs b/compiler/rustc_infer/src/lib.rs
index e2dd4b49e1a4b..622cdf0c7b895 100644
--- a/compiler/rustc_infer/src/lib.rs
+++ b/compiler/rustc_infer/src/lib.rs
@@ -16,6 +16,8 @@
#![doc(rust_logo)]
#![feature(rustdoc_internals)]
#![allow(internal_features)]
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
#![feature(associated_type_bounds)]
#![feature(box_patterns)]
#![feature(extend_one)]
diff --git a/compiler/rustc_interface/src/lib.rs b/compiler/rustc_interface/src/lib.rs
index 69414a1379515..7d69e49b209f5 100644
--- a/compiler/rustc_interface/src/lib.rs
+++ b/compiler/rustc_interface/src/lib.rs
@@ -4,8 +4,6 @@
#![feature(let_chains)]
#![feature(thread_spawn_unchecked)]
#![feature(try_blocks)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate tracing;
diff --git a/compiler/rustc_lexer/src/lib.rs b/compiler/rustc_lexer/src/lib.rs
index f6c9289b529c7..ca84e930c2439 100644
--- a/compiler/rustc_lexer/src/lib.rs
+++ b/compiler/rustc_lexer/src/lib.rs
@@ -18,8 +18,7 @@
//! lexeme types.
//!
//! [`rustc_parse::lexer`]: ../rustc_parse/lexer/index.html
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
+
// We want to be able to build this crate with a stable compiler,
// so no `#![feature]` attributes should be added.
#![deny(unstable_features)]
diff --git a/compiler/rustc_lint/src/internal.rs b/compiler/rustc_lint/src/internal.rs
index eb2490a47d09d..516df14c8943a 100644
--- a/compiler/rustc_lint/src/internal.rs
+++ b/compiler/rustc_lint/src/internal.rs
@@ -345,7 +345,7 @@ declare_tool_lint! {
///
/// More details on translatable diagnostics can be found [here](https://rustc-dev-guide.rust-lang.org/diagnostics/translation.html).
pub rustc::UNTRANSLATABLE_DIAGNOSTIC,
- Allow,
+ Deny,
"prevent creation of diagnostics which cannot be translated",
report_in_external_macro: true
}
@@ -357,7 +357,7 @@ declare_tool_lint! {
///
/// More details on diagnostics implementations can be found [here](https://rustc-dev-guide.rust-lang.org/diagnostics/diagnostic-structs.html).
pub rustc::DIAGNOSTIC_OUTSIDE_OF_IMPL,
- Allow,
+ Deny,
"prevent creation of diagnostics outside of `IntoDiagnostic`/`AddToDiagnostic` impls",
report_in_external_macro: true
}
diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
index 1d9ce10bcaf38..9a7a5c0c6df00 100644
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -37,8 +37,6 @@
#![cfg_attr(not(bootstrap), feature(trait_upcasting))]
#![feature(min_specialization)]
#![feature(rustc_attrs)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#![allow(internal_features)]
#[macro_use]
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index f916deb4a46d1..c0d76b4e27eeb 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -1,5 +1,6 @@
-#![allow(rustc::untranslatable_diagnostic)]
#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
+
use std::num::NonZeroU32;
use crate::errors::RequestedLevel;
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index eed35326c4501..8b7e82d2113f8 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -1,6 +1,4 @@
#![feature(min_specialization)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate rustc_macros;
diff --git a/compiler/rustc_llvm/src/lib.rs b/compiler/rustc_llvm/src/lib.rs
index ca0aec71052d0..6a570c97c8888 100644
--- a/compiler/rustc_llvm/src/lib.rs
+++ b/compiler/rustc_llvm/src/lib.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![doc(rust_logo)]
#![feature(rustdoc_internals)]
diff --git a/compiler/rustc_log/src/lib.rs b/compiler/rustc_log/src/lib.rs
index e3464cb8a2df6..1a78f9f0f86e5 100644
--- a/compiler/rustc_log/src/lib.rs
+++ b/compiler/rustc_log/src/lib.rs
@@ -38,9 +38,6 @@
//! debugging, you can make changes inside those crates and quickly run main.rs
//! to read the debug logs.
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
-
use std::env::{self, VarError};
use std::fmt::{self, Display};
use std::io::{self, IsTerminal};
diff --git a/compiler/rustc_macros/src/lib.rs b/compiler/rustc_macros/src/lib.rs
index 9e85a59b5b92b..af65c908ee66b 100644
--- a/compiler/rustc_macros/src/lib.rs
+++ b/compiler/rustc_macros/src/lib.rs
@@ -6,8 +6,6 @@
#![feature(proc_macro_span)]
#![feature(proc_macro_tracked_env)]
#![allow(rustc::default_hash_types)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#![allow(internal_features)]
use synstructure::decl_derive;
diff --git a/compiler/rustc_metadata/src/lib.rs b/compiler/rustc_metadata/src/lib.rs
index 471425e80174f..2e7130f356579 100644
--- a/compiler/rustc_metadata/src/lib.rs
+++ b/compiler/rustc_metadata/src/lib.rs
@@ -15,8 +15,6 @@
#![feature(try_blocks)]
#![feature(never_type)]
#![allow(rustc::potential_query_instability)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
extern crate proc_macro;
diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs
index ddfb2ece39f10..515b6703b1e36 100644
--- a/compiler/rustc_middle/src/lib.rs
+++ b/compiler/rustc_middle/src/lib.rs
@@ -57,8 +57,10 @@
#![feature(const_option)]
#![feature(ptr_alignment_type)]
#![feature(macro_metavar_expr)]
-#![allow(rustc::potential_query_instability)]
#![allow(internal_features)]
+#![allow(rustc::potential_query_instability)]
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
#[macro_use]
extern crate bitflags;
diff --git a/compiler/rustc_mir_build/src/lib.rs b/compiler/rustc_mir_build/src/lib.rs
index a3d88b1269686..43e44b47e3f96 100644
--- a/compiler/rustc_mir_build/src/lib.rs
+++ b/compiler/rustc_mir_build/src/lib.rs
@@ -1,6 +1,9 @@
//! Construction of MIR from HIR.
//!
//! This crate also contains the match exhaustiveness and usefulness checking.
+
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
#![feature(assert_matches)]
#![feature(associated_type_bounds)]
#![feature(box_patterns)]
diff --git a/compiler/rustc_mir_dataflow/src/lib.rs b/compiler/rustc_mir_dataflow/src/lib.rs
index 23111cc319956..a4b58e5bfc128 100644
--- a/compiler/rustc_mir_dataflow/src/lib.rs
+++ b/compiler/rustc_mir_dataflow/src/lib.rs
@@ -4,8 +4,6 @@
#![feature(let_chains)]
#![feature(min_specialization)]
#![feature(try_blocks)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate tracing;
diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
index 69f93fa3a0e21..fe828f535e00d 100644
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -1,5 +1,3 @@
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#![feature(assert_matches)]
#![feature(box_patterns)]
#![feature(const_type_name)]
diff --git a/compiler/rustc_monomorphize/src/lib.rs b/compiler/rustc_monomorphize/src/lib.rs
index b0cfa3568cad7..7f36ae91f1a03 100644
--- a/compiler/rustc_monomorphize/src/lib.rs
+++ b/compiler/rustc_monomorphize/src/lib.rs
@@ -1,8 +1,6 @@
#![feature(array_windows)]
#![feature(is_sorted)]
#![allow(rustc::potential_query_instability)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate tracing;
diff --git a/compiler/rustc_parse/src/lib.rs b/compiler/rustc_parse/src/lib.rs
index d5fa11086872f..5bd8bb72bd665 100644
--- a/compiler/rustc_parse/src/lib.rs
+++ b/compiler/rustc_parse/src/lib.rs
@@ -1,11 +1,13 @@
//! The main parser interface.
+#![allow(internal_features)]
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
#![feature(array_windows)]
#![feature(box_patterns)]
#![feature(if_let_guard)]
#![feature(iter_intersperse)]
#![feature(let_chains)]
-#![allow(internal_features)]
#[macro_use]
extern crate tracing;
diff --git a/compiler/rustc_parse_format/src/lib.rs b/compiler/rustc_parse_format/src/lib.rs
index d76ee161da6fd..0b65f400825ae 100644
--- a/compiler/rustc_parse_format/src/lib.rs
+++ b/compiler/rustc_parse_format/src/lib.rs
@@ -9,8 +9,6 @@
html_playground_url = "https://play.rust-lang.org/",
test(attr(deny(warnings)))
)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
// We want to be able to build this crate with a stable compiler,
// so no `#![feature]` attributes should be added.
#![deny(unstable_features)]
diff --git a/compiler/rustc_passes/src/lib.rs b/compiler/rustc_passes/src/lib.rs
index 862b76b1f6048..064af5aec35aa 100644
--- a/compiler/rustc_passes/src/lib.rs
+++ b/compiler/rustc_passes/src/lib.rs
@@ -12,8 +12,6 @@
#![feature(map_try_insert)]
#![feature(min_specialization)]
#![feature(try_blocks)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate rustc_middle;
diff --git a/compiler/rustc_pattern_analysis/src/lib.rs b/compiler/rustc_pattern_analysis/src/lib.rs
index 3d0eb117d174f..fe347231e121c 100644
--- a/compiler/rustc_pattern_analysis/src/lib.rs
+++ b/compiler/rustc_pattern_analysis/src/lib.rs
@@ -1,5 +1,8 @@
//! Analysis of patterns, notably match exhaustiveness checking.
+#![allow(rustc::untranslatable_diagnostic)]
+#![allow(rustc::diagnostic_outside_of_impl)]
+
pub mod constructor;
#[cfg(feature = "rustc")]
pub mod errors;
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index a64b06e70d6bc..a284d145a4ddb 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -5,8 +5,6 @@
#![feature(associated_type_defaults)]
#![feature(try_blocks)]
#![feature(let_chains)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate tracing;
diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs
index 818a67a7debf6..0fe5b9c664a35 100644
--- a/compiler/rustc_query_impl/src/lib.rs
+++ b/compiler/rustc_query_impl/src/lib.rs
@@ -6,8 +6,6 @@
#![feature(min_specialization)]
#![feature(rustc_attrs)]
#![allow(rustc::potential_query_instability, unused_parens)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#![allow(internal_features)]
#[macro_use]
diff --git a/compiler/rustc_query_system/src/lib.rs b/compiler/rustc_query_system/src/lib.rs
index 9b66b9a48d905..416f556f57d28 100644
--- a/compiler/rustc_query_system/src/lib.rs
+++ b/compiler/rustc_query_system/src/lib.rs
@@ -4,8 +4,6 @@
#![feature(min_specialization)]
#![feature(let_chains)]
#![allow(rustc::potential_query_instability, internal_features)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate tracing;
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 9d09d060b59b8..5fb9117f0c857 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -17,7 +17,9 @@
#![feature(let_chains)]
#![feature(rustc_attrs)]
#![allow(rustdoc::private_intra_doc_links)]
+#![allow(rustc::diagnostic_outside_of_impl)]
#![allow(rustc::potential_query_instability)]
+#![allow(rustc::untranslatable_diagnostic)]
#![allow(internal_features)]
#[macro_use]
diff --git a/compiler/rustc_serialize/src/lib.rs b/compiler/rustc_serialize/src/lib.rs
index 9c34aa9395764..95833f532f4d8 100644
--- a/compiler/rustc_serialize/src/lib.rs
+++ b/compiler/rustc_serialize/src/lib.rs
@@ -17,8 +17,6 @@
#![feature(ptr_sub_ptr)]
#![cfg_attr(test, feature(test))]
#![allow(rustc::internal)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
pub use self::serialize::{Decodable, Decoder, Encodable, Encoder};
diff --git a/compiler/rustc_session/src/lib.rs b/compiler/rustc_session/src/lib.rs
index 0d6328fbb071c..58e1394c09071 100644
--- a/compiler/rustc_session/src/lib.rs
+++ b/compiler/rustc_session/src/lib.rs
@@ -4,8 +4,6 @@
#![feature(rustc_attrs)]
#![feature(map_many_mut)]
#![feature(iter_intersperse)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#![allow(internal_features)]
#[macro_use]
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index ea6766ea583be..5f2d4ae2b8c2f 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -17,8 +17,6 @@
// tidy-alphabetical-start
#![allow(internal_features)]
-#![deny(rustc::diagnostic_outside_of_impl)]
-#![deny(rustc::untranslatable_diagnostic)]
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![doc(rust_logo)]
#![feature(array_windows)]
diff --git a/compiler/rustc_symbol_mangling/src/lib.rs b/compiler/rustc_symbol_mangling/src/lib.rs
index 362aaca63642e..02bb1fde75c1b 100644
--- a/compiler/rustc_symbol_mangling/src/lib.rs
+++ b/compiler/rustc_symbol_mangling/src/lib.rs
@@ -91,8 +91,6 @@
#![doc(rust_logo)]
#![feature(rustdoc_internals)]
#![allow(internal_features)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate rustc_middle;
diff --git a/compiler/rustc_target/src/lib.rs b/compiler/rustc_target/src/lib.rs
index bffb3681f1309..b19c5b6f28f08 100644
--- a/compiler/rustc_target/src/lib.rs
+++ b/compiler/rustc_target/src/lib.rs
@@ -17,8 +17,6 @@
#![feature(min_specialization)]
#![feature(rustc_attrs)]
#![feature(step_trait)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#![allow(internal_features)]
use std::path::{Path, PathBuf};
diff --git a/compiler/rustc_trait_selection/src/lib.rs b/compiler/rustc_trait_selection/src/lib.rs
index 5ec45212bc791..053ecfc681ceb 100644
--- a/compiler/rustc_trait_selection/src/lib.rs
+++ b/compiler/rustc_trait_selection/src/lib.rs
@@ -14,6 +14,8 @@
#![doc(rust_logo)]
#![feature(rustdoc_internals)]
#![allow(internal_features)]
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
#![feature(associated_type_bounds)]
#![feature(box_patterns)]
#![feature(control_flow_enum)]
diff --git a/compiler/rustc_traits/src/lib.rs b/compiler/rustc_traits/src/lib.rs
index c7916ec60bba2..e73bbf6048ece 100644
--- a/compiler/rustc_traits/src/lib.rs
+++ b/compiler/rustc_traits/src/lib.rs
@@ -1,7 +1,5 @@
//! Queries that are independent from the main solver code.
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#![recursion_limit = "256"]
#[macro_use]
diff --git a/compiler/rustc_transmute/src/lib.rs b/compiler/rustc_transmute/src/lib.rs
index c80389a3a4d52..ac4f67d1b5565 100644
--- a/compiler/rustc_transmute/src/lib.rs
+++ b/compiler/rustc_transmute/src/lib.rs
@@ -1,8 +1,6 @@
#![feature(alloc_layout_extra)]
#![feature(never_type)]
#![allow(dead_code, unused_variables)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate tracing;
diff --git a/compiler/rustc_ty_utils/src/lib.rs b/compiler/rustc_ty_utils/src/lib.rs
index 51acb99d29b58..411099e3d5af8 100644
--- a/compiler/rustc_ty_utils/src/lib.rs
+++ b/compiler/rustc_ty_utils/src/lib.rs
@@ -15,8 +15,6 @@
#![feature(iterator_try_collect)]
#![feature(let_chains)]
#![feature(never_type)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#[macro_use]
extern crate rustc_middle;
diff --git a/compiler/rustc_ty_utils/src/representability.rs b/compiler/rustc_ty_utils/src/representability.rs
index 3aaa2e73bb805..70f1f099688b8 100644
--- a/compiler/rustc_ty_utils/src/representability.rs
+++ b/compiler/rustc_ty_utils/src/representability.rs
@@ -1,5 +1,3 @@
-#![allow(rustc::untranslatable_diagnostic, rustc::diagnostic_outside_of_impl)]
-
use rustc_hir::def::DefKind;
use rustc_index::bit_set::BitSet;
use rustc_middle::query::Providers;
diff --git a/compiler/rustc_type_ir/src/lib.rs b/compiler/rustc_type_ir/src/lib.rs
index 83efbfb855f91..f498c5531fcff 100644
--- a/compiler/rustc_type_ir/src/lib.rs
+++ b/compiler/rustc_type_ir/src/lib.rs
@@ -2,8 +2,6 @@
feature = "nightly",
feature(associated_type_defaults, min_specialization, never_type, rustc_attrs)
)]
-#![deny(rustc::untranslatable_diagnostic)]
-#![deny(rustc::diagnostic_outside_of_impl)]
#![allow(rustc::usage_of_ty_tykind)]
#![cfg_attr(feature = "nightly", allow(internal_features))]
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 8c10f14116a0c..849127616ef62 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -18,7 +18,9 @@
#![recursion_limit = "256"]
#![warn(rustc::internal)]
#![allow(clippy::collapsible_if, clippy::collapsible_else_if)]
+#![allow(rustc::diagnostic_outside_of_impl)]
#![allow(rustc::potential_query_instability)]
+#![allow(rustc::untranslatable_diagnostic)]
extern crate thin_vec;
#[macro_use]
diff --git a/src/tools/clippy/clippy_config/src/lib.rs b/src/tools/clippy/clippy_config/src/lib.rs
index 533e375a3104c..5449feed090a9 100644
--- a/src/tools/clippy/clippy_config/src/lib.rs
+++ b/src/tools/clippy/clippy_config/src/lib.rs
@@ -4,7 +4,9 @@
#![allow(
clippy::must_use_candidate,
clippy::missing_panics_doc,
- rustc::untranslatable_diagnostic_trivial
+ rustc::diagnostic_outside_of_impl,
+ rustc::untranslatable_diagnostic,
+ rustc::untranslatable_diagnostic_trivial,
)]
extern crate rustc_ast;
diff --git a/src/tools/clippy/clippy_lints/src/lib.rs b/src/tools/clippy/clippy_lints/src/lib.rs
index feb4d188f3978..f6608b229539a 100644
--- a/src/tools/clippy/clippy_lints/src/lib.rs
+++ b/src/tools/clippy/clippy_lints/src/lib.rs
@@ -10,7 +10,12 @@
#![feature(stmt_expr_attributes)]
#![recursion_limit = "512"]
#![cfg_attr(feature = "deny-warnings", deny(warnings))]
-#![allow(clippy::missing_docs_in_private_items, clippy::must_use_candidate)]
+#![allow(
+ clippy::missing_docs_in_private_items,
+ clippy::must_use_candidate,
+ rustc::diagnostic_outside_of_impl,
+ rustc::untranslatable_diagnostic,
+)]
#![warn(trivial_casts, trivial_numeric_casts)]
// warn on lints, that are included in `rust-lang/rust`s bootstrap
#![warn(rust_2018_idioms, unused_lifetimes)]
diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs
index 4e499ff4cc612..36034861df5b9 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -8,7 +8,13 @@
#![feature(assert_matches)]
#![recursion_limit = "512"]
#![cfg_attr(feature = "deny-warnings", deny(warnings))]
-#![allow(clippy::missing_errors_doc, clippy::missing_panics_doc, clippy::must_use_candidate)]
+#![allow(
+ clippy::missing_errors_doc,
+ clippy::missing_panics_doc,
+ clippy::must_use_candidate,
+ rustc::diagnostic_outside_of_impl,
+ rustc::untranslatable_diagnostic,
+)]
// warn on the same lints as `clippy_lints`
#![warn(trivial_casts, trivial_numeric_casts)]
// warn on lints, that are included in `rust-lang/rust`s bootstrap
diff --git a/src/tools/clippy/src/driver.rs b/src/tools/clippy/src/driver.rs
index b944a299256c2..1b159f5937a28 100644
--- a/src/tools/clippy/src/driver.rs
+++ b/src/tools/clippy/src/driver.rs
@@ -1,3 +1,5 @@
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::untranslatable_diagnostic)]
#![feature(rustc_private)]
#![feature(let_chains)]
#![feature(lazy_cell)]
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index e8e10f64ad295..de7a4b79d26ff 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -2,7 +2,9 @@
#![allow(
clippy::manual_range_contains,
clippy::useless_format,
- clippy::field_reassign_with_default
+ clippy::field_reassign_with_default,
+ rustc::diagnostic_outside_of_impl,
+ rustc::untranslatable_diagnostic,
)]
extern crate rustc_data_structures;
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 057b883a3bf9e..94fb746484c6e 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -33,8 +33,10 @@
clippy::bool_to_int_with_if,
clippy::box_default,
clippy::needless_question_mark,
+ rustc::diagnostic_outside_of_impl,
// We are not implementing queries here so it's fine
- rustc::potential_query_instability
+ rustc::potential_query_instability,
+ rustc::untranslatable_diagnostic,
)]
#![warn(
rust_2018_idioms,
From ad3d04c55ec4cbd924b3f7e3a890483b6eb1604d Mon Sep 17 00:00:00 2001
From: Amanda Stjerna <amanda.stjerna@it.uu.se>
Date: Tue, 6 Feb 2024 13:07:51 +0100
Subject: [PATCH 07/18] A drive-by rewrite of give_region_a_name()
This rewrite makes the cache-updating nature of the function slightly clearer, using the Entry API into the hash table for region names to capture the update-insert nature of the method. May be marginally more efficient since it only runtime-borrows the map once, but in this context the performance impact is almost certainly completely negligible.
---
.../src/diagnostics/region_name.rs | 38 ++++++++++---------
1 file changed, 21 insertions(+), 17 deletions(-)
diff --git a/compiler/rustc_borrowck/src/diagnostics/region_name.rs b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
index 15e1066e983a9..c9de36e9064e2 100644
--- a/compiler/rustc_borrowck/src/diagnostics/region_name.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
@@ -1,6 +1,7 @@
use std::fmt::{self, Display};
use std::iter;
+use rustc_data_structures::fx::IndexEntry;
use rustc_errors::Diagnostic;
use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res};
@@ -247,25 +248,28 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
assert!(self.regioncx.universal_regions().is_universal_region(fr));
- if let Some(value) = self.region_names.try_borrow_mut().unwrap().get(&fr) {
- return Some(value.clone());
- }
+ match self.region_names.borrow_mut().entry(fr) {
+ IndexEntry::Occupied(precomputed_name) => Some(precomputed_name.get().clone()),
+ IndexEntry::Vacant(slot) => {
+ let new_name = self
+ .give_name_from_error_region(fr)
+ .or_else(|| self.give_name_if_anonymous_region_appears_in_arguments(fr))
+ .or_else(|| self.give_name_if_anonymous_region_appears_in_upvars(fr))
+ .or_else(|| self.give_name_if_anonymous_region_appears_in_output(fr))
+ .or_else(|| self.give_name_if_anonymous_region_appears_in_yield_ty(fr))
+ .or_else(|| self.give_name_if_anonymous_region_appears_in_impl_signature(fr))
+ .or_else(|| {
+ self.give_name_if_anonymous_region_appears_in_arg_position_impl_trait(fr)
+ });
+
+ if let Some(new_name) = &new_name {
+ slot.insert(new_name.clone());
+ }
+ debug!("give_region_a_name: gave name {:?}", new_name);
- let value = self
- .give_name_from_error_region(fr)
- .or_else(|| self.give_name_if_anonymous_region_appears_in_arguments(fr))
- .or_else(|| self.give_name_if_anonymous_region_appears_in_upvars(fr))
- .or_else(|| self.give_name_if_anonymous_region_appears_in_output(fr))
- .or_else(|| self.give_name_if_anonymous_region_appears_in_yield_ty(fr))
- .or_else(|| self.give_name_if_anonymous_region_appears_in_impl_signature(fr))
- .or_else(|| self.give_name_if_anonymous_region_appears_in_arg_position_impl_trait(fr));
-
- if let Some(value) = &value {
- self.region_names.try_borrow_mut().unwrap().insert(fr, value.clone());
+ new_name
+ }
}
-
- debug!("give_region_a_name: gave name {:?}", value);
- value
}
/// Checks for the case where `fr` maps to something that the
From cd21b1d036fbc1f8e72451442feb12b098c33ef5 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 7 Feb 2024 19:27:44 +0000
Subject: [PATCH 08/18] No need to take ImplTraitContext by ref
---
compiler/rustc_ast_lowering/src/asm.rs | 2 +-
compiler/rustc_ast_lowering/src/block.rs | 2 +-
compiler/rustc_ast_lowering/src/delegation.rs | 2 +-
compiler/rustc_ast_lowering/src/expr.rs | 18 ++---
compiler/rustc_ast_lowering/src/item.rs | 80 +++++++++----------
compiler/rustc_ast_lowering/src/lib.rs | 56 ++++++-------
compiler/rustc_ast_lowering/src/pat.rs | 6 +-
compiler/rustc_ast_lowering/src/path.rs | 16 ++--
8 files changed, 90 insertions(+), 92 deletions(-)
diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs
index 3742cf9d881d8..fd717e82d26df 100644
--- a/compiler/rustc_ast_lowering/src/asm.rs
+++ b/compiler/rustc_ast_lowering/src/asm.rs
@@ -205,7 +205,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
&sym.qself,
&sym.path,
ParamMode::Optional,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Path),
None,
);
hir::InlineAsmOperand::SymStatic { path, def_id }
diff --git a/compiler/rustc_ast_lowering/src/block.rs b/compiler/rustc_ast_lowering/src/block.rs
index d310f72f7a3f8..865a56b2c1f15 100644
--- a/compiler/rustc_ast_lowering/src/block.rs
+++ b/compiler/rustc_ast_lowering/src/block.rs
@@ -85,7 +85,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let ty = l
.ty
.as_ref()
- .map(|t| self.lower_ty(t, &ImplTraitContext::Disallowed(ImplTraitPosition::Variable)));
+ .map(|t| self.lower_ty(t, ImplTraitContext::Disallowed(ImplTraitPosition::Variable)));
let init = l.kind.init().map(|init| self.lower_expr(init));
let hir_id = self.lower_node_id(l.id);
let pat = self.lower_pat(&l.pat);
diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
index 6ccf39b0cb167..d1ba93f067553 100644
--- a/compiler/rustc_ast_lowering/src/delegation.rs
+++ b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -218,7 +218,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
&delegation.qself,
&delegation.path,
ParamMode::Optional,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Path),
None,
);
let block = delegation.body.as_deref();
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index c4798887637f8..942aae3d53600 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -99,7 +99,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
seg,
ParamMode::Optional,
ParenthesizedGenericArgs::Err,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Path),
None,
// Method calls can't have bound modifiers
None,
@@ -141,13 +141,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
ExprKind::Cast(expr, ty) => {
let expr = self.lower_expr(expr);
let ty =
- self.lower_ty(ty, &ImplTraitContext::Disallowed(ImplTraitPosition::Cast));
+ self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Cast));
hir::ExprKind::Cast(expr, ty)
}
ExprKind::Type(expr, ty) => {
let expr = self.lower_expr(expr);
let ty =
- self.lower_ty(ty, &ImplTraitContext::Disallowed(ImplTraitPosition::Cast));
+ self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::Cast));
hir::ExprKind::Type(expr, ty)
}
ExprKind::AddrOf(k, m, ohs) => {
@@ -267,7 +267,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
qself,
path,
ParamMode::Optional,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Path),
None,
);
hir::ExprKind::Path(qpath)
@@ -295,7 +295,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
ExprKind::OffsetOf(container, fields) => hir::ExprKind::OffsetOf(
self.lower_ty(
container,
- &ImplTraitContext::Disallowed(ImplTraitPosition::OffsetOf),
+ ImplTraitContext::Disallowed(ImplTraitPosition::OffsetOf),
),
self.arena.alloc_from_iter(fields.iter().map(|&ident| self.lower_ident(ident))),
),
@@ -314,7 +314,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
&se.qself,
&se.path,
ParamMode::Optional,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Path),
None,
)),
self.arena
@@ -1241,7 +1241,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
qself,
path,
ParamMode::Optional,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Path),
None,
);
// Destructure like a tuple struct.
@@ -1261,7 +1261,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
qself,
path,
ParamMode::Optional,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Path),
None,
);
// Destructure like a unit struct.
@@ -1286,7 +1286,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
&se.qself,
&se.path,
ParamMode::Optional,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Path),
None,
);
let fields_omitted = match &se.rest {
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index 7b81ed4875c64..75410323f97df 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -189,7 +189,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
generics,
Const::No,
id,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
|this| {
this.lower_const_item(ty, span, expr.as_deref(), ImplTraitPosition::ConstTy)
},
@@ -218,7 +218,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
let itctx = ImplTraitContext::Universal;
let (generics, decl) =
- this.lower_generics(generics, header.constness, id, &itctx, |this| {
+ this.lower_generics(generics, header.constness, id, itctx, |this| {
this.lower_fn_decl(
decl,
id,
@@ -263,7 +263,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
&generics,
Const::No,
id,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
|this| match ty {
None => {
let guar = this.dcx().span_delayed_bug(
@@ -274,7 +274,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
Some(ty) => this.lower_ty(
ty,
- &ImplTraitContext::TypeAliasesOpaqueTy { in_assoc_ty: false },
+ ImplTraitContext::TypeAliasesOpaqueTy { in_assoc_ty: false },
),
},
);
@@ -285,7 +285,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
generics,
Const::No,
id,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
|this| {
this.arena.alloc_from_iter(
enum_definition.variants.iter().map(|x| this.lower_variant(x)),
@@ -299,7 +299,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
generics,
Const::No,
id,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
|this| this.lower_variant_data(hir_id, struct_def),
);
hir::ItemKind::Struct(struct_def, generics)
@@ -309,7 +309,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
generics,
Const::No,
id,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
|this| this.lower_variant_data(hir_id, vdata),
);
hir::ItemKind::Union(vdata, generics)
@@ -339,7 +339,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
// parent lifetime.
let itctx = ImplTraitContext::Universal;
let (generics, (trait_ref, lowered_ty)) =
- self.lower_generics(ast_generics, *constness, id, &itctx, |this| {
+ self.lower_generics(ast_generics, *constness, id, itctx, |this| {
let modifiers = TraitBoundModifiers {
constness: match *constness {
Const::Yes(span) => BoundConstness::Maybe(span),
@@ -354,13 +354,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
this.lower_trait_ref(
modifiers,
trait_ref,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Trait),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Trait),
)
});
let lowered_ty = this.lower_ty(
ty,
- &ImplTraitContext::Disallowed(ImplTraitPosition::ImplSelf),
+ ImplTraitContext::Disallowed(ImplTraitPosition::ImplSelf),
);
(trait_ref, lowered_ty)
@@ -400,11 +400,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
generics,
constness,
id,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
|this| {
let bounds = this.lower_param_bounds(
bounds,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
);
let items = this.arena.alloc_from_iter(
items.iter().map(|item| this.lower_trait_item_ref(item)),
@@ -420,11 +420,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
generics,
Const::No,
id,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
|this| {
this.lower_param_bounds(
bounds,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
)
},
);
@@ -464,7 +464,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
body: Option<&Expr>,
impl_trait_position: ImplTraitPosition,
) -> (&'hir hir::Ty<'hir>, hir::BodyId) {
- let ty = self.lower_ty(ty, &ImplTraitContext::Disallowed(impl_trait_position));
+ let ty = self.lower_ty(ty, ImplTraitContext::Disallowed(impl_trait_position));
(ty, self.lower_const_body(span, body))
}
@@ -633,7 +633,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
let fdec = &sig.decl;
let itctx = ImplTraitContext::Universal;
let (generics, (fn_dec, fn_args)) =
- self.lower_generics(generics, Const::No, i.id, &itctx, |this| {
+ self.lower_generics(generics, Const::No, i.id, itctx, |this| {
(
// Disallow `impl Trait` in foreign items.
this.lower_fn_decl(
@@ -650,8 +650,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
hir::ForeignItemKind::Fn(fn_dec, fn_args, generics)
}
ForeignItemKind::Static(t, m, _) => {
- let ty = self
- .lower_ty(t, &ImplTraitContext::Disallowed(ImplTraitPosition::StaticTy));
+ let ty =
+ self.lower_ty(t, ImplTraitContext::Disallowed(ImplTraitPosition::StaticTy));
hir::ForeignItemKind::Static(ty, *m)
}
ForeignItemKind::TyAlias(..) => hir::ForeignItemKind::Type,
@@ -722,11 +722,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
qself,
path,
ParamMode::ExplicitNamed, // no `'_` in declarations (Issue #61124)
- &ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy),
+ ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy),
);
self.arena.alloc(t)
} else {
- self.lower_ty(&f.ty, &ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy))
+ self.lower_ty(&f.ty, ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy))
};
let hir_id = self.lower_node_id(f.id);
self.lower_attrs(hir_id, &f.attrs);
@@ -755,12 +755,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
generics,
Const::No,
i.id,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
|this| {
- let ty = this.lower_ty(
- ty,
- &ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy),
- );
+ let ty = this
+ .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy));
let body = expr.as_ref().map(|x| this.lower_const_body(i.span, Some(x)));
hir::TraitItemKind::Const(ty, body)
@@ -803,18 +801,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
&generics,
Const::No,
i.id,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
|this| {
let ty = ty.as_ref().map(|x| {
this.lower_ty(
x,
- &ImplTraitContext::Disallowed(ImplTraitPosition::AssocTy),
+ ImplTraitContext::Disallowed(ImplTraitPosition::AssocTy),
)
});
hir::TraitItemKind::Type(
this.lower_param_bounds(
bounds,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
),
ty,
)
@@ -882,10 +880,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
generics,
Const::No,
i.id,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
|this| {
- let ty = this
- .lower_ty(ty, &ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy));
+ let ty =
+ this.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy));
let body = this.lower_const_body(i.span, expr.as_deref());
hir::ImplItemKind::Const(ty, body)
@@ -916,7 +914,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
&generics,
Const::No,
i.id,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
|this| match ty {
None => {
let guar = this.dcx().span_delayed_bug(
@@ -929,7 +927,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
Some(ty) => {
let ty = this.lower_ty(
ty,
- &ImplTraitContext::TypeAliasesOpaqueTy { in_assoc_ty: true },
+ ImplTraitContext::TypeAliasesOpaqueTy { in_assoc_ty: true },
);
hir::ImplItemKind::Type(ty)
}
@@ -1323,7 +1321,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
// synthesize a host effect param for them. We reject `const` on them during AST validation.
let constness = if kind == FnDeclKind::Inherent { sig.header.constness } else { Const::No };
let itctx = ImplTraitContext::Universal;
- let (generics, decl) = self.lower_generics(generics, constness, id, &itctx, |this| {
+ let (generics, decl) = self.lower_generics(generics, constness, id, itctx, |this| {
this.lower_fn_decl(&sig.decl, id, sig.span, kind, coroutine_kind)
});
(generics, hir::FnSig { header, decl, span: self.lower_span(sig.span) })
@@ -1401,7 +1399,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
generics: &Generics,
constness: Const,
parent_node_id: NodeId,
- itctx: &ImplTraitContext,
+ itctx: ImplTraitContext,
f: impl FnOnce(&mut Self) -> T,
) -> (&'hir hir::Generics<'hir>, T) {
debug_assert!(self.impl_trait_defs.is_empty());
@@ -1607,7 +1605,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
bounds: &[GenericBound],
colon_span: Option<Span>,
parent_span: Span,
- itctx: &ImplTraitContext,
+ itctx: ImplTraitContext,
origin: PredicateOrigin,
) -> Option<hir::WherePredicate<'hir>> {
// Do not create a clause if we do not have anything inside it.
@@ -1681,10 +1679,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
bound_generic_params: self
.lower_generic_params(bound_generic_params, hir::GenericParamSource::Binder),
bounded_ty: self
- .lower_ty(bounded_ty, &ImplTraitContext::Disallowed(ImplTraitPosition::Bound)),
+ .lower_ty(bounded_ty, ImplTraitContext::Disallowed(ImplTraitPosition::Bound)),
bounds: self.lower_param_bounds(
bounds,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
),
span: self.lower_span(*span),
origin: PredicateOrigin::WhereClause,
@@ -1695,7 +1693,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
lifetime: self.lower_lifetime(lifetime),
bounds: self.lower_param_bounds(
bounds,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
),
in_where_clause: true,
})
@@ -1703,9 +1701,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
WherePredicate::EqPredicate(WhereEqPredicate { lhs_ty, rhs_ty, span }) => {
hir::WherePredicate::EqPredicate(hir::WhereEqPredicate {
lhs_ty: self
- .lower_ty(lhs_ty, &ImplTraitContext::Disallowed(ImplTraitPosition::Bound)),
+ .lower_ty(lhs_ty, ImplTraitContext::Disallowed(ImplTraitPosition::Bound)),
rhs_ty: self
- .lower_ty(rhs_ty, &ImplTraitContext::Disallowed(ImplTraitPosition::Bound)),
+ .lower_ty(rhs_ty, ImplTraitContext::Disallowed(ImplTraitPosition::Bound)),
span: self.lower_span(*span),
})
}
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 063b6627050bc..b289f615d27bd 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -1006,7 +1006,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
fn lower_assoc_ty_constraint(
&mut self,
constraint: &AssocConstraint,
- itctx: &ImplTraitContext,
+ itctx: ImplTraitContext,
) -> hir::TypeBinding<'hir> {
debug!("lower_assoc_ty_constraint(constraint={:?}, itctx={:?})", constraint, itctx);
// lower generic arguments of identifier in constraint
@@ -1085,9 +1085,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
hir::TypeBindingKind::Equality { term }
}
AssocConstraintKind::Bound { bounds } => {
- enum DesugarKind<'a> {
+ enum DesugarKind {
ImplTrait,
- Error(&'a ImplTraitPosition),
+ Error(ImplTraitPosition),
Bound,
}
@@ -1163,7 +1163,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
DesugarKind::Error(position) => {
let guar = self.dcx().emit_err(errors::MisplacedAssocTyBinding {
span: constraint.span,
- position: DiagnosticArgFromDisplay(position),
+ position: DiagnosticArgFromDisplay(&position),
});
let err_ty =
&*self.arena.alloc(self.ty(constraint.span, hir::TyKind::Err(guar)));
@@ -1210,7 +1210,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
fn lower_generic_arg(
&mut self,
arg: &ast::GenericArg,
- itctx: &ImplTraitContext,
+ itctx: ImplTraitContext,
) -> hir::GenericArg<'hir> {
match arg {
ast::GenericArg::Lifetime(lt) => GenericArg::Lifetime(self.lower_lifetime(lt)),
@@ -1289,7 +1289,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
#[instrument(level = "debug", skip(self))]
- fn lower_ty(&mut self, t: &Ty, itctx: &ImplTraitContext) -> &'hir hir::Ty<'hir> {
+ fn lower_ty(&mut self, t: &Ty, itctx: ImplTraitContext) -> &'hir hir::Ty<'hir> {
self.arena.alloc(self.lower_ty_direct(t, itctx))
}
@@ -1299,7 +1299,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
qself: &Option<ptr::P<QSelf>>,
path: &Path,
param_mode: ParamMode,
- itctx: &ImplTraitContext,
+ itctx: ImplTraitContext,
) -> hir::Ty<'hir> {
// Check whether we should interpret this as a bare trait object.
// This check mirrors the one in late resolution. We only introduce this special case in
@@ -1341,7 +1341,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
self.ty(span, hir::TyKind::Tup(tys))
}
- fn lower_ty_direct(&mut self, t: &Ty, itctx: &ImplTraitContext) -> hir::Ty<'hir> {
+ fn lower_ty_direct(&mut self, t: &Ty, itctx: ImplTraitContext) -> hir::Ty<'hir> {
let kind = match &t.kind {
TyKind::Infer => hir::TyKind::Infer,
TyKind::Err => {
@@ -1460,13 +1460,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
ImplTraitContext::ReturnPositionOpaqueTy { origin, fn_kind } => self
.lower_opaque_impl_trait(
span,
- *origin,
+ origin,
*def_node_id,
bounds,
- Some(*fn_kind),
+ Some(fn_kind),
itctx,
),
- &ImplTraitContext::TypeAliasesOpaqueTy { in_assoc_ty } => self
+ ImplTraitContext::TypeAliasesOpaqueTy { in_assoc_ty } => self
.lower_opaque_impl_trait(
span,
hir::OpaqueTyOrigin::TyAlias { in_assoc_ty },
@@ -1513,9 +1513,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
.create_feature_err(
MisplacedImplTrait {
span: t.span,
- position: DiagnosticArgFromDisplay(position),
+ position: DiagnosticArgFromDisplay(&position),
},
- *feature,
+ feature,
)
.emit();
hir::TyKind::Err(guar)
@@ -1523,7 +1523,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
ImplTraitContext::Disallowed(position) => {
let guar = self.dcx().emit_err(MisplacedImplTrait {
span: t.span,
- position: DiagnosticArgFromDisplay(position),
+ position: DiagnosticArgFromDisplay(&position),
});
hir::TyKind::Err(guar)
}
@@ -1581,7 +1581,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
opaque_ty_node_id: NodeId,
bounds: &GenericBounds,
fn_kind: Option<FnDeclKind>,
- itctx: &ImplTraitContext,
+ itctx: ImplTraitContext,
) -> hir::TyKind<'hir> {
// Make sure we know that some funky desugaring has been going on here.
// This is a first: there is code in other places like for loop
@@ -1848,7 +1848,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
ImplTraitContext::Disallowed(ImplTraitPosition::PointerParam)
}
};
- self.lower_ty_direct(¶m.ty, &itctx)
+ self.lower_ty_direct(¶m.ty, itctx)
}));
let output = match coro {
@@ -1876,7 +1876,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
ImplTraitContext::Disallowed(ImplTraitPosition::PointerReturn)
}
};
- hir::FnRetTy::Return(self.lower_ty(ty, &itctx))
+ hir::FnRetTy::Return(self.lower_ty(ty, itctx))
}
FnRetTy::Default(span) => hir::FnRetTy::DefaultReturn(self.lower_span(*span)),
},
@@ -1977,7 +1977,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
output: &FnRetTy,
coro: CoroutineKind,
opaque_ty_span: Span,
- nested_impl_trait_context: ImplTraitContext,
+ itctx: ImplTraitContext,
) -> hir::GenericBound<'hir> {
// Compute the `T` in `Future<Output = T>` from the return type.
let output_ty = match output {
@@ -1985,7 +1985,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// Not `OpaqueTyOrigin::AsyncFn`: that's only used for the
// `impl Future` opaque type that `async fn` implicitly
// generates.
- self.lower_ty(ty, &nested_impl_trait_context)
+ self.lower_ty(ty, itctx)
}
FnRetTy::Default(ret_ty_span) => self.arena.alloc(self.ty_tup(*ret_ty_span, &[])),
};
@@ -2025,7 +2025,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
fn lower_param_bound(
&mut self,
tpb: &GenericBound,
- itctx: &ImplTraitContext,
+ itctx: ImplTraitContext,
) -> hir::GenericBound<'hir> {
match tpb {
GenericBound::Trait(p, modifiers) => hir::GenericBound::Trait(
@@ -2164,7 +2164,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
.map(|def| {
self.lower_ty(
def,
- &ImplTraitContext::Disallowed(ImplTraitPosition::GenericDefault),
+ ImplTraitContext::Disallowed(ImplTraitPosition::GenericDefault),
)
});
@@ -2174,7 +2174,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
GenericParamKind::Const { ty, kw_span: _, default } => {
let ty = self
- .lower_ty(ty, &ImplTraitContext::Disallowed(ImplTraitPosition::GenericDefault));
+ .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::GenericDefault));
// Not only do we deny const param defaults in binders but we also map them to `None`
// since later compiler stages cannot handle them (and shouldn't need to be able to).
@@ -2204,7 +2204,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
&mut self,
modifiers: ast::TraitBoundModifiers,
p: &TraitRef,
- itctx: &ImplTraitContext,
+ itctx: ImplTraitContext,
) -> hir::TraitRef<'hir> {
let path = match self.lower_qpath(
p.ref_id,
@@ -2224,7 +2224,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
fn lower_poly_trait_ref(
&mut self,
p: &PolyTraitRef,
- itctx: &ImplTraitContext,
+ itctx: ImplTraitContext,
modifiers: ast::TraitBoundModifiers,
) -> hir::PolyTraitRef<'hir> {
let bound_generic_params =
@@ -2233,7 +2233,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
hir::PolyTraitRef { bound_generic_params, trait_ref, span: self.lower_span(p.span) }
}
- fn lower_mt(&mut self, mt: &MutTy, itctx: &ImplTraitContext) -> hir::MutTy<'hir> {
+ fn lower_mt(&mut self, mt: &MutTy, itctx: ImplTraitContext) -> hir::MutTy<'hir> {
hir::MutTy { ty: self.lower_ty(&mt.ty, itctx), mutbl: mt.mutbl }
}
@@ -2241,7 +2241,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
fn lower_param_bounds(
&mut self,
bounds: &[GenericBound],
- itctx: &ImplTraitContext,
+ itctx: ImplTraitContext,
) -> hir::GenericBounds<'hir> {
self.arena.alloc_from_iter(self.lower_param_bounds_mut(bounds, itctx))
}
@@ -2249,7 +2249,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
fn lower_param_bounds_mut<'s>(
&'s mut self,
bounds: &'s [GenericBound],
- itctx: &'s ImplTraitContext,
+ itctx: ImplTraitContext,
) -> impl Iterator<Item = hir::GenericBound<'hir>> + Captures<'s> + Captures<'a> {
bounds.iter().map(move |bound| self.lower_param_bound(bound, itctx))
}
@@ -2285,7 +2285,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
bounds,
/* colon_span */ None,
span,
- &ImplTraitContext::Universal,
+ ImplTraitContext::Universal,
hir::PredicateOrigin::ImplTrait,
);
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
index 0af141ff99a27..c097feb6b3476 100644
--- a/compiler/rustc_ast_lowering/src/pat.rs
+++ b/compiler/rustc_ast_lowering/src/pat.rs
@@ -38,7 +38,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
qself,
path,
ParamMode::Optional,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Path),
None,
);
let (pats, ddpos) = self.lower_pat_tuple(pats, "tuple struct");
@@ -55,7 +55,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
qself,
path,
ParamMode::Optional,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Path),
None,
);
break hir::PatKind::Path(qpath);
@@ -66,7 +66,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
qself,
path,
ParamMode::Optional,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Path),
None,
);
diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
index 76c7e530a6bb7..48941a232c266 100644
--- a/compiler/rustc_ast_lowering/src/path.rs
+++ b/compiler/rustc_ast_lowering/src/path.rs
@@ -27,7 +27,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
qself: &Option<ptr::P<QSelf>>,
p: &Path,
param_mode: ParamMode,
- itctx: &ImplTraitContext,
+ itctx: ImplTraitContext,
// modifiers of the impl/bound if this is a trait path
modifiers: Option<ast::TraitBoundModifiers>,
) -> hir::QPath<'hir> {
@@ -205,7 +205,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
segment,
param_mode,
ParenthesizedGenericArgs::Err,
- &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+ ImplTraitContext::Disallowed(ImplTraitPosition::Path),
None,
None,
)
@@ -220,7 +220,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
segment: &PathSegment,
param_mode: ParamMode,
parenthesized_generic_args: ParenthesizedGenericArgs,
- itctx: &ImplTraitContext,
+ itctx: ImplTraitContext,
constness: Option<ast::BoundConstness>,
// Additional features ungated with a bound modifier like `async`.
// This is passed down to the implicit associated type binding in
@@ -374,7 +374,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
&mut self,
data: &AngleBracketedArgs,
param_mode: ParamMode,
- itctx: &ImplTraitContext,
+ itctx: ImplTraitContext,
) -> (GenericArgsCtor<'hir>, bool) {
let has_non_lt_args = data.args.iter().any(|arg| match arg {
AngleBracketedArg::Arg(ast::GenericArg::Lifetime(_))
@@ -405,7 +405,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
fn lower_parenthesized_parameter_data(
&mut self,
data: &ParenthesizedArgs,
- itctx: &ImplTraitContext,
+ itctx: ImplTraitContext,
bound_modifier_allowed_features: Option<Lrc<[Symbol]>>,
) -> (GenericArgsCtor<'hir>, bool) {
// Switch to `PassThrough` mode for anonymous lifetimes; this
@@ -415,7 +415,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// we generally don't permit such things (see #51008).
let ParenthesizedArgs { span, inputs, inputs_span, output } = data;
let inputs = self.arena.alloc_from_iter(inputs.iter().map(|ty| {
- self.lower_ty_direct(ty, &ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitParam))
+ self.lower_ty_direct(ty, ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitParam))
}));
let output_ty = match output {
// Only allow `impl Trait` in return position. i.e.:
@@ -429,7 +429,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
} else {
self.lower_ty(
ty,
- &ImplTraitContext::FeatureGated(
+ ImplTraitContext::FeatureGated(
ImplTraitPosition::FnTraitReturn,
sym::impl_trait_in_fn_trait_return,
),
@@ -437,7 +437,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
}
FnRetTy::Ty(ty) => {
- self.lower_ty(ty, &ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitReturn))
+ self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitReturn))
}
FnRetTy::Default(_) => self.arena.alloc(self.ty_tup(*span, &[])),
};
From 0e4b55bd7d2f6d043c293721909c45466bf95a10 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 8 Feb 2024 16:02:20 +1100
Subject: [PATCH 09/18] Reorder the diagnostic API methods.
The current order is almost perfectly random. This commit puts them into
a predictable order in their own impl block, going from the highest
level (`Block`) to the lowest (`Expect`). Within each level this is the
order:
- struct_err, err
- struct_span_err, span_err
- create_err, emit_err
The first one in each pair creates a diagnostic, the second one creates
*and* emits a diagnostic. Not every method is present for every level.
The diff is messy, but other than moving methods around, the only thing
it does is create the new `impl DiagCtxt` block with its own comment.
---
compiler/rustc_errors/src/lib.rs | 618 ++++++++++++++++---------------
1 file changed, 312 insertions(+), 306 deletions(-)
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index ec5029e505f96..0c982f290d2e9 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -712,216 +712,6 @@ impl DiagCtxt {
self.inner.borrow_mut().emit_stashed_diagnostics()
}
- /// Construct a builder at the `Warning` level at the given `span` and with the `msg`.
- ///
- /// An `emit` call on the builder will only emit if `can_emit_warnings` is `true`.
- #[rustc_lint_diagnostics]
- #[track_caller]
- pub fn struct_span_warn(
- &self,
- span: impl Into<MultiSpan>,
- msg: impl Into<DiagnosticMessage>,
- ) -> DiagnosticBuilder<'_, ()> {
- self.struct_warn(msg).with_span(span)
- }
-
- /// Construct a builder at the `Warning` level with the `msg`.
- ///
- /// An `emit` call on the builder will only emit if `can_emit_warnings` is `true`.
- #[rustc_lint_diagnostics]
- #[track_caller]
- pub fn struct_warn(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_, ()> {
- DiagnosticBuilder::new(self, Warning, msg)
- }
-
- /// Construct a builder at the `Allow` level with the `msg`.
- #[rustc_lint_diagnostics]
- #[track_caller]
- pub fn struct_allow(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_, ()> {
- DiagnosticBuilder::new(self, Allow, msg)
- }
-
- /// Construct a builder at the `Expect` level with the `msg`.
- #[rustc_lint_diagnostics]
- #[track_caller]
- pub fn struct_expect(
- &self,
- msg: impl Into<DiagnosticMessage>,
- id: LintExpectationId,
- ) -> DiagnosticBuilder<'_, ()> {
- DiagnosticBuilder::new(self, Expect(id), msg)
- }
-
- /// Construct a builder at the `Error` level at the given `span` and with the `msg`.
- #[rustc_lint_diagnostics]
- #[track_caller]
- pub fn struct_span_err(
- &self,
- span: impl Into<MultiSpan>,
- msg: impl Into<DiagnosticMessage>,
- ) -> DiagnosticBuilder<'_> {
- self.struct_err(msg).with_span(span)
- }
-
- /// Construct a builder at the `Error` level with the `msg`.
- // FIXME: This method should be removed (every error should have an associated error code).
- #[rustc_lint_diagnostics]
- #[track_caller]
- pub fn struct_err(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_> {
- DiagnosticBuilder::new(self, Error, msg)
- }
-
- /// Construct a builder at the `Fatal` level at the given `span` and with the `msg`.
- #[rustc_lint_diagnostics]
- #[track_caller]
- pub fn struct_span_fatal(
- &self,
- span: impl Into<MultiSpan>,
- msg: impl Into<DiagnosticMessage>,
- ) -> DiagnosticBuilder<'_, FatalAbort> {
- self.struct_fatal(msg).with_span(span)
- }
-
- /// Construct a builder at the `Fatal` level with the `msg`.
- #[rustc_lint_diagnostics]
- #[track_caller]
- pub fn struct_fatal(
- &self,
- msg: impl Into<DiagnosticMessage>,
- ) -> DiagnosticBuilder<'_, FatalAbort> {
- DiagnosticBuilder::new(self, Fatal, msg)
- }
-
- /// Construct a builder at the `Help` level with the `msg`.
- #[rustc_lint_diagnostics]
- pub fn struct_help(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_, ()> {
- DiagnosticBuilder::new(self, Help, msg)
- }
-
- /// Construct a builder at the `Note` level with the `msg`.
- #[rustc_lint_diagnostics]
- #[track_caller]
- pub fn struct_note(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_, ()> {
- DiagnosticBuilder::new(self, Note, msg)
- }
-
- /// Construct a builder at the `Bug` level with the `msg`.
- #[rustc_lint_diagnostics]
- #[track_caller]
- pub fn struct_bug(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_, BugAbort> {
- DiagnosticBuilder::new(self, Bug, msg)
- }
-
- /// Construct a builder at the `Bug` level at the given `span` with the `msg`.
- #[rustc_lint_diagnostics]
- #[track_caller]
- pub fn struct_span_bug(
- &self,
- span: impl Into<MultiSpan>,
- msg: impl Into<DiagnosticMessage>,
- ) -> DiagnosticBuilder<'_, BugAbort> {
- self.struct_bug(msg).with_span(span)
- }
-
- #[rustc_lint_diagnostics]
- #[track_caller]
- pub fn span_fatal(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagnosticMessage>) -> ! {
- self.struct_span_fatal(span, msg).emit()
- }
-
- #[rustc_lint_diagnostics]
- #[track_caller]
- pub fn span_err(
- &self,
- span: impl Into<MultiSpan>,
- msg: impl Into<DiagnosticMessage>,
- ) -> ErrorGuaranteed {
- self.struct_span_err(span, msg).emit()
- }
-
- #[rustc_lint_diagnostics]
- #[track_caller]
- pub fn span_warn(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagnosticMessage>) {
- self.struct_span_warn(span, msg).emit()
- }
-
- pub fn span_bug(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagnosticMessage>) -> ! {
- self.struct_span_bug(span, msg).emit()
- }
-
- /// Ensures that compilation cannot succeed.
- ///
- /// If this function has been called but no errors have been emitted and
- /// compilation succeeds, it will cause an internal compiler error (ICE).
- ///
- /// This can be used in code paths that should never run on successful compilations.
- /// For example, it can be used to create an [`ErrorGuaranteed`]
- /// (but you should prefer threading through the [`ErrorGuaranteed`] from an error emission
- /// directly).
- #[track_caller]
- pub fn delayed_bug(&self, msg: impl Into<DiagnosticMessage>) -> ErrorGuaranteed {
- DiagnosticBuilder::<ErrorGuaranteed>::new(self, DelayedBug, msg).emit()
- }
-
- /// Like `delayed_bug`, but takes an additional span.
- ///
- /// Note: this function used to be called `delay_span_bug`. It was renamed
- /// to match similar functions like `span_err`, `span_warn`, etc.
- #[track_caller]
- pub fn span_delayed_bug(
- &self,
- sp: impl Into<MultiSpan>,
- msg: impl Into<DiagnosticMessage>,
- ) -> ErrorGuaranteed {
- DiagnosticBuilder::<ErrorGuaranteed>::new(self, DelayedBug, msg).with_span(sp).emit()
- }
-
- /// Ensures that a diagnostic is printed. See `Level::GoodPathDelayedBug`.
- pub fn good_path_delayed_bug(&self, msg: impl Into<DiagnosticMessage>) {
- DiagnosticBuilder::<()>::new(self, GoodPathDelayedBug, msg).emit()
- }
-
- #[track_caller]
- #[rustc_lint_diagnostics]
- pub fn span_note(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagnosticMessage>) {
- self.struct_span_note(span, msg).emit()
- }
-
- #[track_caller]
- #[rustc_lint_diagnostics]
- pub fn struct_span_note(
- &self,
- span: impl Into<MultiSpan>,
- msg: impl Into<DiagnosticMessage>,
- ) -> DiagnosticBuilder<'_, ()> {
- DiagnosticBuilder::new(self, Note, msg).with_span(span)
- }
-
- #[rustc_lint_diagnostics]
- pub fn fatal(&self, msg: impl Into<DiagnosticMessage>) -> ! {
- self.struct_fatal(msg).emit()
- }
-
- #[rustc_lint_diagnostics]
- pub fn err(&self, msg: impl Into<DiagnosticMessage>) -> ErrorGuaranteed {
- self.struct_err(msg).emit()
- }
-
- #[rustc_lint_diagnostics]
- pub fn warn(&self, msg: impl Into<DiagnosticMessage>) {
- self.struct_warn(msg).emit()
- }
-
- #[rustc_lint_diagnostics]
- pub fn note(&self, msg: impl Into<DiagnosticMessage>) {
- self.struct_note(msg).emit()
- }
-
- #[rustc_lint_diagnostics]
- pub fn bug(&self, msg: impl Into<DiagnosticMessage>) -> ! {
- self.struct_bug(msg).emit()
- }
-
/// This excludes lint errors and delayed bugs.
#[inline]
pub fn err_count(&self) -> usize {
@@ -1061,56 +851,110 @@ impl DiagCtxt {
self.inner.borrow_mut().emit_diagnostic(diagnostic)
}
- #[track_caller]
- pub fn emit_err<'a>(&'a self, err: impl IntoDiagnostic<'a>) -> ErrorGuaranteed {
- self.create_err(err).emit()
+ pub fn emit_artifact_notification(&self, path: &Path, artifact_type: &str) {
+ self.inner.borrow_mut().emitter.emit_artifact_notification(path, artifact_type);
}
- #[track_caller]
- pub fn create_err<'a>(&'a self, err: impl IntoDiagnostic<'a>) -> DiagnosticBuilder<'a> {
- err.into_diagnostic(self, Error)
+ pub fn emit_future_breakage_report(&self) {
+ let mut inner = self.inner.borrow_mut();
+ let diags = std::mem::take(&mut inner.future_breakage_diagnostics);
+ if !diags.is_empty() {
+ inner.emitter.emit_future_breakage_report(diags);
+ }
}
- #[track_caller]
- pub fn create_warn<'a>(
- &'a self,
- warning: impl IntoDiagnostic<'a, ()>,
- ) -> DiagnosticBuilder<'a, ()> {
- warning.into_diagnostic(self, Warning)
- }
+ pub fn emit_unused_externs(
+ &self,
+ lint_level: rustc_lint_defs::Level,
+ loud: bool,
+ unused_externs: &[&str],
+ ) {
+ let mut inner = self.inner.borrow_mut();
- #[track_caller]
- pub fn emit_warn<'a>(&'a self, warning: impl IntoDiagnostic<'a, ()>) {
- self.create_warn(warning).emit()
- }
+ if loud && lint_level.is_error() {
+ inner.lint_err_count += 1;
+ inner.panic_if_treat_err_as_bug();
+ }
- #[track_caller]
- pub fn create_almost_fatal<'a>(
- &'a self,
- fatal: impl IntoDiagnostic<'a, FatalError>,
- ) -> DiagnosticBuilder<'a, FatalError> {
- fatal.into_diagnostic(self, Fatal)
+ inner.emitter.emit_unused_externs(lint_level, unused_externs)
}
- #[track_caller]
- pub fn emit_almost_fatal<'a>(
- &'a self,
- fatal: impl IntoDiagnostic<'a, FatalError>,
- ) -> FatalError {
- self.create_almost_fatal(fatal).emit()
+ pub fn update_unstable_expectation_id(
+ &self,
+ unstable_to_stable: &FxIndexMap<LintExpectationId, LintExpectationId>,
+ ) {
+ let mut inner = self.inner.borrow_mut();
+ let diags = std::mem::take(&mut inner.unstable_expect_diagnostics);
+ inner.check_unstable_expect_diagnostics = true;
+
+ if !diags.is_empty() {
+ inner.suppressed_expected_diag = true;
+ for mut diag in diags.into_iter() {
+ diag.update_unstable_expectation_id(unstable_to_stable);
+
+ // Here the diagnostic is given back to `emit_diagnostic` where it was first
+ // intercepted. Now it should be processed as usual, since the unstable expectation
+ // id is now stable.
+ inner.emit_diagnostic(diag);
+ }
+ }
+
+ inner
+ .stashed_diagnostics
+ .values_mut()
+ .for_each(|diag| diag.update_unstable_expectation_id(unstable_to_stable));
+ inner
+ .future_breakage_diagnostics
+ .iter_mut()
+ .for_each(|diag| diag.update_unstable_expectation_id(unstable_to_stable));
+ }
+
+ /// This methods steals all [`LintExpectationId`]s that are stored inside
+ /// [`DiagCtxtInner`] and indicate that the linked expectation has been fulfilled.
+ #[must_use]
+ pub fn steal_fulfilled_expectation_ids(&self) -> FxHashSet<LintExpectationId> {
+ assert!(
+ self.inner.borrow().unstable_expect_diagnostics.is_empty(),
+ "`DiagCtxtInner::unstable_expect_diagnostics` should be empty at this point",
+ );
+ std::mem::take(&mut self.inner.borrow_mut().fulfilled_expectations)
+ }
+
+ pub fn flush_delayed(&self) {
+ self.inner.borrow_mut().flush_delayed(DelayedBugKind::Normal);
}
+}
+// This `impl` block contains only the public diagnostic creation/emission API.
+//
+// Functions beginning with `struct_`/`create_` create a diagnostic. Other
+// functions create and emit a diagnostic all in one go.
+impl DiagCtxt {
+ /// Construct a builder at the `Bug` level with the `msg`.
+ #[rustc_lint_diagnostics]
#[track_caller]
- pub fn create_fatal<'a>(
- &'a self,
- fatal: impl IntoDiagnostic<'a, FatalAbort>,
- ) -> DiagnosticBuilder<'a, FatalAbort> {
- fatal.into_diagnostic(self, Fatal)
+ pub fn struct_bug(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_, BugAbort> {
+ DiagnosticBuilder::new(self, Bug, msg)
}
+ #[rustc_lint_diagnostics]
+ pub fn bug(&self, msg: impl Into<DiagnosticMessage>) -> ! {
+ self.struct_bug(msg).emit()
+ }
+
+ /// Construct a builder at the `Bug` level at the given `span` with the `msg`.
+ #[rustc_lint_diagnostics]
#[track_caller]
- pub fn emit_fatal<'a>(&'a self, fatal: impl IntoDiagnostic<'a, FatalAbort>) -> ! {
- self.create_fatal(fatal).emit()
+ pub fn struct_span_bug(
+ &self,
+ span: impl Into<MultiSpan>,
+ msg: impl Into<DiagnosticMessage>,
+ ) -> DiagnosticBuilder<'_, BugAbort> {
+ self.struct_bug(msg).with_span(span)
+ }
+
+ pub fn span_bug(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagnosticMessage>) -> ! {
+ self.struct_span_bug(span, msg).emit()
}
#[track_caller]
@@ -1126,90 +970,252 @@ impl DiagCtxt {
self.create_bug(bug).emit()
}
+ /// Construct a builder at the `Fatal` level with the `msg`.
+ #[rustc_lint_diagnostics]
#[track_caller]
- pub fn emit_note<'a>(&'a self, note: impl IntoDiagnostic<'a, ()>) {
- self.create_note(note).emit()
+ pub fn struct_fatal(
+ &self,
+ msg: impl Into<DiagnosticMessage>,
+ ) -> DiagnosticBuilder<'_, FatalAbort> {
+ DiagnosticBuilder::new(self, Fatal, msg)
+ }
+
+ #[rustc_lint_diagnostics]
+ pub fn fatal(&self, msg: impl Into<DiagnosticMessage>) -> ! {
+ self.struct_fatal(msg).emit()
}
+ /// Construct a builder at the `Fatal` level at the given `span` and with the `msg`.
+ #[rustc_lint_diagnostics]
#[track_caller]
- pub fn create_note<'a>(
+ pub fn struct_span_fatal(
+ &self,
+ span: impl Into<MultiSpan>,
+ msg: impl Into<DiagnosticMessage>,
+ ) -> DiagnosticBuilder<'_, FatalAbort> {
+ self.struct_fatal(msg).with_span(span)
+ }
+
+ #[rustc_lint_diagnostics]
+ #[track_caller]
+ pub fn span_fatal(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagnosticMessage>) -> ! {
+ self.struct_span_fatal(span, msg).emit()
+ }
+
+ #[track_caller]
+ pub fn create_fatal<'a>(
&'a self,
- note: impl IntoDiagnostic<'a, ()>,
- ) -> DiagnosticBuilder<'a, ()> {
- note.into_diagnostic(self, Note)
+ fatal: impl IntoDiagnostic<'a, FatalAbort>,
+ ) -> DiagnosticBuilder<'a, FatalAbort> {
+ fatal.into_diagnostic(self, Fatal)
}
- pub fn emit_artifact_notification(&self, path: &Path, artifact_type: &str) {
- self.inner.borrow_mut().emitter.emit_artifact_notification(path, artifact_type);
+ #[track_caller]
+ pub fn emit_fatal<'a>(&'a self, fatal: impl IntoDiagnostic<'a, FatalAbort>) -> ! {
+ self.create_fatal(fatal).emit()
}
- pub fn emit_future_breakage_report(&self) {
- let mut inner = self.inner.borrow_mut();
- let diags = std::mem::take(&mut inner.future_breakage_diagnostics);
- if !diags.is_empty() {
- inner.emitter.emit_future_breakage_report(diags);
- }
+ #[track_caller]
+ pub fn create_almost_fatal<'a>(
+ &'a self,
+ fatal: impl IntoDiagnostic<'a, FatalError>,
+ ) -> DiagnosticBuilder<'a, FatalError> {
+ fatal.into_diagnostic(self, Fatal)
}
- pub fn emit_unused_externs(
+ #[track_caller]
+ pub fn emit_almost_fatal<'a>(
+ &'a self,
+ fatal: impl IntoDiagnostic<'a, FatalError>,
+ ) -> FatalError {
+ self.create_almost_fatal(fatal).emit()
+ }
+
+ /// Construct a builder at the `Error` level with the `msg`.
+ // FIXME: This method should be removed (every error should have an associated error code).
+ #[rustc_lint_diagnostics]
+ #[track_caller]
+ pub fn struct_err(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_> {
+ DiagnosticBuilder::new(self, Error, msg)
+ }
+
+ #[rustc_lint_diagnostics]
+ pub fn err(&self, msg: impl Into<DiagnosticMessage>) -> ErrorGuaranteed {
+ self.struct_err(msg).emit()
+ }
+
+ /// Construct a builder at the `Error` level at the given `span` and with the `msg`.
+ #[rustc_lint_diagnostics]
+ #[track_caller]
+ pub fn struct_span_err(
&self,
- lint_level: rustc_lint_defs::Level,
- loud: bool,
- unused_externs: &[&str],
- ) {
- let mut inner = self.inner.borrow_mut();
+ span: impl Into<MultiSpan>,
+ msg: impl Into<DiagnosticMessage>,
+ ) -> DiagnosticBuilder<'_> {
+ self.struct_err(msg).with_span(span)
+ }
- if loud && lint_level.is_error() {
- inner.lint_err_count += 1;
- inner.panic_if_treat_err_as_bug();
- }
+ #[rustc_lint_diagnostics]
+ #[track_caller]
+ pub fn span_err(
+ &self,
+ span: impl Into<MultiSpan>,
+ msg: impl Into<DiagnosticMessage>,
+ ) -> ErrorGuaranteed {
+ self.struct_span_err(span, msg).emit()
+ }
- inner.emitter.emit_unused_externs(lint_level, unused_externs)
+ #[track_caller]
+ pub fn create_err<'a>(&'a self, err: impl IntoDiagnostic<'a>) -> DiagnosticBuilder<'a> {
+ err.into_diagnostic(self, Error)
}
- pub fn update_unstable_expectation_id(
+ #[track_caller]
+ pub fn emit_err<'a>(&'a self, err: impl IntoDiagnostic<'a>) -> ErrorGuaranteed {
+ self.create_err(err).emit()
+ }
+
+ /// Ensures that compilation cannot succeed.
+ ///
+ /// If this function has been called but no errors have been emitted and
+ /// compilation succeeds, it will cause an internal compiler error (ICE).
+ ///
+ /// This can be used in code paths that should never run on successful compilations.
+ /// For example, it can be used to create an [`ErrorGuaranteed`]
+ /// (but you should prefer threading through the [`ErrorGuaranteed`] from an error emission
+ /// directly).
+ #[track_caller]
+ pub fn delayed_bug(&self, msg: impl Into<DiagnosticMessage>) -> ErrorGuaranteed {
+ DiagnosticBuilder::<ErrorGuaranteed>::new(self, DelayedBug, msg).emit()
+ }
+
+ /// Like `delayed_bug`, but takes an additional span.
+ ///
+ /// Note: this function used to be called `delay_span_bug`. It was renamed
+ /// to match similar functions like `span_err`, `span_warn`, etc.
+ #[track_caller]
+ pub fn span_delayed_bug(
&self,
- unstable_to_stable: &FxIndexMap<LintExpectationId, LintExpectationId>,
- ) {
- let mut inner = self.inner.borrow_mut();
- let diags = std::mem::take(&mut inner.unstable_expect_diagnostics);
- inner.check_unstable_expect_diagnostics = true;
+ sp: impl Into<MultiSpan>,
+ msg: impl Into<DiagnosticMessage>,
+ ) -> ErrorGuaranteed {
+ DiagnosticBuilder::<ErrorGuaranteed>::new(self, DelayedBug, msg).with_span(sp).emit()
+ }
- if !diags.is_empty() {
- inner.suppressed_expected_diag = true;
- for mut diag in diags.into_iter() {
- diag.update_unstable_expectation_id(unstable_to_stable);
+ /// Ensures that a diagnostic is printed. See `Level::GoodPathDelayedBug`.
+ pub fn good_path_delayed_bug(&self, msg: impl Into<DiagnosticMessage>) {
+ DiagnosticBuilder::<()>::new(self, GoodPathDelayedBug, msg).emit()
+ }
- // Here the diagnostic is given back to `emit_diagnostic` where it was first
- // intercepted. Now it should be processed as usual, since the unstable expectation
- // id is now stable.
- inner.emit_diagnostic(diag);
- }
- }
+ /// Construct a builder at the `Warning` level with the `msg`.
+ ///
+ /// An `emit` call on the builder will only emit if `can_emit_warnings` is `true`.
+ #[rustc_lint_diagnostics]
+ #[track_caller]
+ pub fn struct_warn(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_, ()> {
+ DiagnosticBuilder::new(self, Warning, msg)
+ }
- inner
- .stashed_diagnostics
- .values_mut()
- .for_each(|diag| diag.update_unstable_expectation_id(unstable_to_stable));
- inner
- .future_breakage_diagnostics
- .iter_mut()
- .for_each(|diag| diag.update_unstable_expectation_id(unstable_to_stable));
+ #[rustc_lint_diagnostics]
+ pub fn warn(&self, msg: impl Into<DiagnosticMessage>) {
+ self.struct_warn(msg).emit()
}
- /// This methods steals all [`LintExpectationId`]s that are stored inside
- /// [`DiagCtxtInner`] and indicate that the linked expectation has been fulfilled.
- #[must_use]
- pub fn steal_fulfilled_expectation_ids(&self) -> FxHashSet<LintExpectationId> {
- assert!(
- self.inner.borrow().unstable_expect_diagnostics.is_empty(),
- "`DiagCtxtInner::unstable_expect_diagnostics` should be empty at this point",
- );
- std::mem::take(&mut self.inner.borrow_mut().fulfilled_expectations)
+ /// Construct a builder at the `Warning` level at the given `span` and with the `msg`.
+ ///
+ /// An `emit` call on the builder will only emit if `can_emit_warnings` is `true`.
+ #[rustc_lint_diagnostics]
+ #[track_caller]
+ pub fn struct_span_warn(
+ &self,
+ span: impl Into<MultiSpan>,
+ msg: impl Into<DiagnosticMessage>,
+ ) -> DiagnosticBuilder<'_, ()> {
+ self.struct_warn(msg).with_span(span)
}
- pub fn flush_delayed(&self) {
- self.inner.borrow_mut().flush_delayed(DelayedBugKind::Normal);
+ #[rustc_lint_diagnostics]
+ #[track_caller]
+ pub fn span_warn(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagnosticMessage>) {
+ self.struct_span_warn(span, msg).emit()
+ }
+
+ #[track_caller]
+ pub fn create_warn<'a>(
+ &'a self,
+ warning: impl IntoDiagnostic<'a, ()>,
+ ) -> DiagnosticBuilder<'a, ()> {
+ warning.into_diagnostic(self, Warning)
+ }
+
+ #[track_caller]
+ pub fn emit_warn<'a>(&'a self, warning: impl IntoDiagnostic<'a, ()>) {
+ self.create_warn(warning).emit()
+ }
+
+ /// Construct a builder at the `Note` level with the `msg`.
+ #[rustc_lint_diagnostics]
+ #[track_caller]
+ pub fn struct_note(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_, ()> {
+ DiagnosticBuilder::new(self, Note, msg)
+ }
+
+ #[rustc_lint_diagnostics]
+ pub fn note(&self, msg: impl Into<DiagnosticMessage>) {
+ self.struct_note(msg).emit()
+ }
+
+ #[track_caller]
+ #[rustc_lint_diagnostics]
+ pub fn struct_span_note(
+ &self,
+ span: impl Into<MultiSpan>,
+ msg: impl Into<DiagnosticMessage>,
+ ) -> DiagnosticBuilder<'_, ()> {
+ DiagnosticBuilder::new(self, Note, msg).with_span(span)
+ }
+
+ #[track_caller]
+ #[rustc_lint_diagnostics]
+ pub fn span_note(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagnosticMessage>) {
+ self.struct_span_note(span, msg).emit()
+ }
+
+ #[track_caller]
+ pub fn create_note<'a>(
+ &'a self,
+ note: impl IntoDiagnostic<'a, ()>,
+ ) -> DiagnosticBuilder<'a, ()> {
+ note.into_diagnostic(self, Note)
+ }
+
+ #[track_caller]
+ pub fn emit_note<'a>(&'a self, note: impl IntoDiagnostic<'a, ()>) {
+ self.create_note(note).emit()
+ }
+
+ /// Construct a builder at the `Help` level with the `msg`.
+ #[rustc_lint_diagnostics]
+ pub fn struct_help(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_, ()> {
+ DiagnosticBuilder::new(self, Help, msg)
+ }
+
+ /// Construct a builder at the `Allow` level with the `msg`.
+ #[rustc_lint_diagnostics]
+ #[track_caller]
+ pub fn struct_allow(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_, ()> {
+ DiagnosticBuilder::new(self, Allow, msg)
+ }
+
+ /// Construct a builder at the `Expect` level with the `msg`.
+ #[rustc_lint_diagnostics]
+ #[track_caller]
+ pub fn struct_expect(
+ &self,
+ msg: impl Into<DiagnosticMessage>,
+ id: LintExpectationId,
+ ) -> DiagnosticBuilder<'_, ()> {
+ DiagnosticBuilder::new(self, Expect(id), msg)
}
}
From d1920a70c03bb6af2ab3f6dfcc21bfdc1fb3d3e9 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 8 Feb 2024 16:09:30 +1100
Subject: [PATCH 10/18] Fix inconsistencies in the diagnostic API methods.
- Remove low-value comments about functionality that is obvious.
- Add missing `track_caller` attributes -- every method should have one.
- Adjust `rustc_lint_diagnostic` attributes. Every method involving a
`impl Into<DiagnosticMessage>` or `impl Into<SubdiangnosticMessage>`
argument should have one, except for those producing bugs, which
aren't user-facing.
---
compiler/rustc_errors/src/lib.rs | 53 +++++++++++++-------------------
1 file changed, 21 insertions(+), 32 deletions(-)
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index 0c982f290d2e9..37901bd02b4f8 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -930,20 +930,19 @@ impl DiagCtxt {
// Functions beginning with `struct_`/`create_` create a diagnostic. Other
// functions create and emit a diagnostic all in one go.
impl DiagCtxt {
- /// Construct a builder at the `Bug` level with the `msg`.
- #[rustc_lint_diagnostics]
+ // No `#[rustc_lint_diagnostics]` because bug messages aren't user-facing.
#[track_caller]
pub fn struct_bug(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_, BugAbort> {
DiagnosticBuilder::new(self, Bug, msg)
}
- #[rustc_lint_diagnostics]
+ // No `#[rustc_lint_diagnostics]` because bug messages aren't user-facing.
+ #[track_caller]
pub fn bug(&self, msg: impl Into<DiagnosticMessage>) -> ! {
self.struct_bug(msg).emit()
}
- /// Construct a builder at the `Bug` level at the given `span` with the `msg`.
- #[rustc_lint_diagnostics]
+ // No `#[rustc_lint_diagnostics]` because bug messages aren't user-facing.
#[track_caller]
pub fn struct_span_bug(
&self,
@@ -953,6 +952,8 @@ impl DiagCtxt {
self.struct_bug(msg).with_span(span)
}
+ // No `#[rustc_lint_diagnostics]` because bug messages aren't user-facing.
+ #[track_caller]
pub fn span_bug(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagnosticMessage>) -> ! {
self.struct_span_bug(span, msg).emit()
}
@@ -966,11 +967,10 @@ impl DiagCtxt {
}
#[track_caller]
- pub fn emit_bug<'a>(&'a self, bug: impl IntoDiagnostic<'a, diagnostic_builder::BugAbort>) -> ! {
+ pub fn emit_bug<'a>(&'a self, bug: impl IntoDiagnostic<'a, BugAbort>) -> ! {
self.create_bug(bug).emit()
}
- /// Construct a builder at the `Fatal` level with the `msg`.
#[rustc_lint_diagnostics]
#[track_caller]
pub fn struct_fatal(
@@ -981,11 +981,11 @@ impl DiagCtxt {
}
#[rustc_lint_diagnostics]
+ #[track_caller]
pub fn fatal(&self, msg: impl Into<DiagnosticMessage>) -> ! {
self.struct_fatal(msg).emit()
}
- /// Construct a builder at the `Fatal` level at the given `span` and with the `msg`.
#[rustc_lint_diagnostics]
#[track_caller]
pub fn struct_span_fatal(
@@ -1031,7 +1031,6 @@ impl DiagCtxt {
self.create_almost_fatal(fatal).emit()
}
- /// Construct a builder at the `Error` level with the `msg`.
// FIXME: This method should be removed (every error should have an associated error code).
#[rustc_lint_diagnostics]
#[track_caller]
@@ -1040,11 +1039,11 @@ impl DiagCtxt {
}
#[rustc_lint_diagnostics]
+ #[track_caller]
pub fn err(&self, msg: impl Into<DiagnosticMessage>) -> ErrorGuaranteed {
self.struct_err(msg).emit()
}
- /// Construct a builder at the `Error` level at the given `span` and with the `msg`.
#[rustc_lint_diagnostics]
#[track_caller]
pub fn struct_span_err(
@@ -1075,24 +1074,18 @@ impl DiagCtxt {
self.create_err(err).emit()
}
- /// Ensures that compilation cannot succeed.
- ///
- /// If this function has been called but no errors have been emitted and
- /// compilation succeeds, it will cause an internal compiler error (ICE).
- ///
- /// This can be used in code paths that should never run on successful compilations.
- /// For example, it can be used to create an [`ErrorGuaranteed`]
- /// (but you should prefer threading through the [`ErrorGuaranteed`] from an error emission
- /// directly).
+ /// Ensures that an error is printed. See `Level::DelayedBug`.
+ // No `#[rustc_lint_diagnostics]` because bug messages aren't user-facing.
#[track_caller]
pub fn delayed_bug(&self, msg: impl Into<DiagnosticMessage>) -> ErrorGuaranteed {
DiagnosticBuilder::<ErrorGuaranteed>::new(self, DelayedBug, msg).emit()
}
- /// Like `delayed_bug`, but takes an additional span.
+ /// Ensures that an error is printed. See `Level::DelayedBug`.
///
/// Note: this function used to be called `delay_span_bug`. It was renamed
/// to match similar functions like `span_err`, `span_warn`, etc.
+ // No `#[rustc_lint_diagnostics]` because bug messages aren't user-facing.
#[track_caller]
pub fn span_delayed_bug(
&self,
@@ -1103,13 +1096,12 @@ impl DiagCtxt {
}
/// Ensures that a diagnostic is printed. See `Level::GoodPathDelayedBug`.
+ // No `#[rustc_lint_diagnostics]` because bug messages aren't user-facing.
+ #[track_caller]
pub fn good_path_delayed_bug(&self, msg: impl Into<DiagnosticMessage>) {
DiagnosticBuilder::<()>::new(self, GoodPathDelayedBug, msg).emit()
}
- /// Construct a builder at the `Warning` level with the `msg`.
- ///
- /// An `emit` call on the builder will only emit if `can_emit_warnings` is `true`.
#[rustc_lint_diagnostics]
#[track_caller]
pub fn struct_warn(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_, ()> {
@@ -1117,13 +1109,11 @@ impl DiagCtxt {
}
#[rustc_lint_diagnostics]
+ #[track_caller]
pub fn warn(&self, msg: impl Into<DiagnosticMessage>) {
self.struct_warn(msg).emit()
}
- /// Construct a builder at the `Warning` level at the given `span` and with the `msg`.
- ///
- /// An `emit` call on the builder will only emit if `can_emit_warnings` is `true`.
#[rustc_lint_diagnostics]
#[track_caller]
pub fn struct_span_warn(
@@ -1153,7 +1143,6 @@ impl DiagCtxt {
self.create_warn(warning).emit()
}
- /// Construct a builder at the `Note` level with the `msg`.
#[rustc_lint_diagnostics]
#[track_caller]
pub fn struct_note(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_, ()> {
@@ -1161,12 +1150,13 @@ impl DiagCtxt {
}
#[rustc_lint_diagnostics]
+ #[track_caller]
pub fn note(&self, msg: impl Into<DiagnosticMessage>) {
self.struct_note(msg).emit()
}
- #[track_caller]
#[rustc_lint_diagnostics]
+ #[track_caller]
pub fn struct_span_note(
&self,
span: impl Into<MultiSpan>,
@@ -1175,8 +1165,8 @@ impl DiagCtxt {
DiagnosticBuilder::new(self, Note, msg).with_span(span)
}
- #[track_caller]
#[rustc_lint_diagnostics]
+ #[track_caller]
pub fn span_note(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagnosticMessage>) {
self.struct_span_note(span, msg).emit()
}
@@ -1194,20 +1184,18 @@ impl DiagCtxt {
self.create_note(note).emit()
}
- /// Construct a builder at the `Help` level with the `msg`.
#[rustc_lint_diagnostics]
+ #[track_caller]
pub fn struct_help(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_, ()> {
DiagnosticBuilder::new(self, Help, msg)
}
- /// Construct a builder at the `Allow` level with the `msg`.
#[rustc_lint_diagnostics]
#[track_caller]
pub fn struct_allow(&self, msg: impl Into<DiagnosticMessage>) -> DiagnosticBuilder<'_, ()> {
DiagnosticBuilder::new(self, Allow, msg)
}
- /// Construct a builder at the `Expect` level with the `msg`.
#[rustc_lint_diagnostics]
#[track_caller]
pub fn struct_expect(
@@ -1576,6 +1564,7 @@ pub enum Level {
ForceWarning(Option<LintExpectationId>),
/// A warning about the code being compiled. Does not prevent compilation from finishing.
+ /// Will be skipped if `can_emit_warnings` is false.
Warning,
/// A message giving additional context.
From 795be51dd931848b8cbf3dc84c526ca92634803c Mon Sep 17 00:00:00 2001
From: Amanda Stjerna <amanda.stjerna@it.uu.se>
Date: Wed, 7 Feb 2024 14:51:51 +0100
Subject: [PATCH 11/18] Make `RegionName` `Copy` by (transitively) interning
the few string variants
---
.../src/diagnostics/region_name.rs | 26 +++++++++----------
1 file changed, 13 insertions(+), 13 deletions(-)
diff --git a/compiler/rustc_borrowck/src/diagnostics/region_name.rs b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
index c9de36e9064e2..a31e6ce5f297f 100644
--- a/compiler/rustc_borrowck/src/diagnostics/region_name.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
@@ -15,7 +15,7 @@ use crate::{universal_regions::DefiningTy, MirBorrowckCtxt};
/// A name for a particular region used in emitting diagnostics. This name could be a generated
/// name like `'1`, a name used by the user like `'a`, or a name like `'static`.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
pub(crate) struct RegionName {
/// The name of the region (interned).
pub(crate) name: Symbol,
@@ -26,7 +26,7 @@ pub(crate) struct RegionName {
/// Denotes the source of a region that is named by a `RegionName`. For example, a free region that
/// was named by the user would get `NamedLateParamRegion` and `'static` lifetime would get `Static`.
/// This helps to print the right kinds of diagnostics.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
pub(crate) enum RegionNameSource {
/// A bound (not free) region that was instantiated at the def site (not an HRTB).
NamedEarlyParamRegion(Span),
@@ -43,7 +43,7 @@ pub(crate) enum RegionNameSource {
/// The region corresponding to the return type of a closure.
AnonRegionFromOutput(RegionNameHighlight, &'static str),
/// The region from a type yielded by a coroutine.
- AnonRegionFromYieldTy(Span, String),
+ AnonRegionFromYieldTy(Span, Symbol),
/// An anonymous region from an async fn.
AnonRegionFromAsyncFn(Span),
/// An anonymous region from an impl self type or trait
@@ -52,7 +52,7 @@ pub(crate) enum RegionNameSource {
/// Describes what to highlight to explain to the user that we're giving an anonymous region a
/// synthesized name, and how to highlight it.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
pub(crate) enum RegionNameHighlight {
/// The anonymous region corresponds to a reference that was found by traversing the type in the HIR.
MatchedHirTy(Span),
@@ -60,11 +60,11 @@ pub(crate) enum RegionNameHighlight {
MatchedAdtAndSegment(Span),
/// The anonymous region corresponds to a region where the type annotation is completely missing
/// from the code, e.g. in a closure arguments `|x| { ... }`, where `x` is a reference.
- CannotMatchHirTy(Span, String),
+ CannotMatchHirTy(Span, Symbol),
/// The anonymous region corresponds to a region where the type annotation is completely missing
/// from the code, and *even if* we print out the full name of the type, the region name won't
/// be included. This currently occurs for opaque types like `impl Future`.
- Occluded(Span, String),
+ Occluded(Span, Symbol),
}
impl RegionName {
@@ -249,7 +249,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
assert!(self.regioncx.universal_regions().is_universal_region(fr));
match self.region_names.borrow_mut().entry(fr) {
- IndexEntry::Occupied(precomputed_name) => Some(precomputed_name.get().clone()),
+ IndexEntry::Occupied(precomputed_name) => Some(*precomputed_name.get()),
IndexEntry::Vacant(slot) => {
let new_name = self
.give_name_from_error_region(fr)
@@ -262,8 +262,8 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
self.give_name_if_anonymous_region_appears_in_arg_position_impl_trait(fr)
});
- if let Some(new_name) = &new_name {
- slot.insert(new_name.clone());
+ if let Some(new_name) = new_name {
+ slot.insert(new_name);
}
debug!("give_region_a_name: gave name {:?}", new_name);
@@ -460,9 +460,9 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
);
if type_name.contains(&format!("'{counter}")) {
// Only add a label if we can confirm that a region was labelled.
- RegionNameHighlight::CannotMatchHirTy(span, type_name)
+ RegionNameHighlight::CannotMatchHirTy(span, Symbol::intern(&type_name))
} else {
- RegionNameHighlight::Occluded(span, type_name)
+ RegionNameHighlight::Occluded(span, Symbol::intern(&type_name))
}
}
@@ -882,7 +882,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
Some(RegionName {
name: self.synthesize_region_name(),
- source: RegionNameSource::AnonRegionFromYieldTy(yield_span, type_name),
+ source: RegionNameSource::AnonRegionFromYieldTy(yield_span, Symbol::intern(&type_name)),
})
}
@@ -974,7 +974,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
Some(RegionName {
name: region_name,
source: RegionNameSource::AnonRegionFromArgument(
- RegionNameHighlight::CannotMatchHirTy(arg_span, arg_name?.to_string()),
+ RegionNameHighlight::CannotMatchHirTy(arg_span, arg_name?),
),
})
} else {
From eb0d70ece36896b6c20a7f4da58f879c95eb928a Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Mon, 29 Jan 2024 17:09:17 +0100
Subject: [PATCH 12/18] also try to normalize opaque types in alias-relate
with this, alias-relate treats all aliases the same way
and it can be used for structural normalization.
---
compiler/rustc_hir_typeck/src/lib.rs | 2 +
compiler/rustc_hir_typeck/src/writeback.rs | 4 +-
compiler/rustc_infer/src/infer/mod.rs | 6 ++
.../src/solve/alias_relate.rs | 86 +++----------------
.../rustc_trait_selection/src/solve/mod.rs | 27 +-----
5 files changed, 27 insertions(+), 98 deletions(-)
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index deb3ad2edc740..f88c013755338 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -302,6 +302,8 @@ fn typeck_with_fallback<'tcx>(
let typeck_results = fcx.resolve_type_vars_in_body(body);
+ let _ = fcx.infcx.take_opaque_types();
+
// Consistency check our TypeckResults instance can hold all ItemLocalIds
// it will need to hold.
assert_eq!(typeck_results.hir_owner, id.owner);
diff --git a/compiler/rustc_hir_typeck/src/writeback.rs b/compiler/rustc_hir_typeck/src/writeback.rs
index 3430a5fb00dc9..8e4c7bc4012e8 100644
--- a/compiler/rustc_hir_typeck/src/writeback.rs
+++ b/compiler/rustc_hir_typeck/src/writeback.rs
@@ -562,7 +562,9 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
#[instrument(skip(self), level = "debug")]
fn visit_opaque_types(&mut self) {
- let opaque_types = self.fcx.infcx.take_opaque_types();
+ // We clone the opaques instead of stealing them here as they are still used for
+ // normalization in the next generation trait solver.
+ let opaque_types = self.fcx.infcx.clone_opaque_types();
for (opaque_type_key, decl) in opaque_types {
let hidden_type = self.resolve(decl.hidden_type, &decl.hidden_type.span);
let opaque_type_key = self.resolve(opaque_type_key, &decl.hidden_type.span);
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index 2d8b47a9cc057..b991b07f2adfc 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -1319,6 +1319,12 @@ impl<'tcx> InferCtxt<'tcx> {
std::mem::take(&mut self.inner.borrow_mut().opaque_type_storage.opaque_types)
}
+ #[instrument(level = "debug", skip(self), ret)]
+ pub fn clone_opaque_types(&self) -> opaque_types::OpaqueTypeMap<'tcx> {
+ debug_assert_ne!(self.defining_use_anchor, DefiningAnchor::Error);
+ self.inner.borrow().opaque_type_storage.opaque_types.clone()
+ }
+
pub fn ty_to_string(&self, t: Ty<'tcx>) -> String {
self.resolve_vars_if_possible(t).to_string()
}
diff --git a/compiler/rustc_trait_selection/src/solve/alias_relate.rs b/compiler/rustc_trait_selection/src/solve/alias_relate.rs
index c05c996175042..999367e758978 100644
--- a/compiler/rustc_trait_selection/src/solve/alias_relate.rs
+++ b/compiler/rustc_trait_selection/src/solve/alias_relate.rs
@@ -3,27 +3,22 @@
//! of our more general approach to "lazy normalization".
//!
//! This is done by first normalizing both sides of the goal, ending up in
-//! either a concrete type, rigid projection, opaque, or an infer variable.
+//! either a concrete type, rigid alias, or an infer variable.
//! These are related further according to the rules below:
//!
-//! (1.) If we end up with a rigid projection and a rigid projection, then we
-//! relate those projections structurally.
+//! (1.) If we end up with two rigid aliases, then we relate them structurally.
//!
-//! (2.) If we end up with a rigid projection and an alias, then the opaque will
-//! have its hidden type defined to be that rigid projection.
-//!
-//! (3.) If we end up with an opaque and an opaque, then we assemble two
-//! candidates, one defining the LHS to be the hidden type of the RHS, and vice
-//! versa.
-//!
-//! (4.) If we end up with an infer var and an opaque or rigid projection, then
+//! (2.) If we end up with an infer var and a rigid alias, then
//! we assign the alias to the infer var.
//!
-//! (5.) If we end up with an opaque and a rigid (non-projection) type, then we
-//! define the hidden type of the opaque to be the rigid type.
-//!
-//! (6.) Otherwise, if we end with two rigid (non-projection) or infer types,
+//! (3.) Otherwise, if we end with two rigid (non-projection) or infer types,
//! relate them structurally.
+//!
+//! Subtle: when relating an opaque to another type, we emit a
+//! `NormalizesTo(opaque, ?fresh_var)` goal when trying to normalize the opaque.
+//! This nested goal starts out as ambiguous and does not actually define the opaque.
+//! However, if `?fresh_var` ends up geteting equated to another type, we retry the
+//! `NormalizesTo` goal, at which point the opaque is actually defined.
use super::{EvalCtxt, GoalSource};
use rustc_infer::infer::DefineOpaqueTypes;
@@ -59,31 +54,26 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
}
- (Some(alias), None) => {
+ (Some(_), None) => {
if rhs.is_infer() {
self.relate(param_env, lhs, variance, rhs)?;
self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
- } else if alias.is_opaque(tcx) {
- // FIXME: This doesn't account for variance.
- self.define_opaque(param_env, alias, rhs)
} else {
Err(NoSolution)
}
}
- (None, Some(alias)) => {
+ (None, Some(_)) => {
if lhs.is_infer() {
self.relate(param_env, lhs, variance, rhs)?;
self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
- } else if alias.is_opaque(tcx) {
- // FIXME: This doesn't account for variance.
- self.define_opaque(param_env, alias, lhs)
} else {
Err(NoSolution)
}
}
(Some(alias_lhs), Some(alias_rhs)) => {
- self.relate_rigid_alias_or_opaque(param_env, alias_lhs, variance, alias_rhs)
+ self.relate(param_env, alias_lhs, variance, alias_rhs)?;
+ self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
}
}
}
@@ -118,52 +108,4 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
}
}
}
-
- fn define_opaque(
- &mut self,
- param_env: ty::ParamEnv<'tcx>,
- opaque: ty::AliasTy<'tcx>,
- term: ty::Term<'tcx>,
- ) -> QueryResult<'tcx> {
- self.add_goal(
- GoalSource::Misc,
- Goal::new(self.tcx(), param_env, ty::NormalizesTo { alias: opaque, term }),
- );
- self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
- }
-
- fn relate_rigid_alias_or_opaque(
- &mut self,
- param_env: ty::ParamEnv<'tcx>,
- lhs: ty::AliasTy<'tcx>,
- variance: ty::Variance,
- rhs: ty::AliasTy<'tcx>,
- ) -> QueryResult<'tcx> {
- let tcx = self.tcx();
- let mut candidates = vec![];
- if lhs.is_opaque(tcx) {
- candidates.extend(
- self.probe_misc_candidate("define-lhs-opaque")
- .enter(|ecx| ecx.define_opaque(param_env, lhs, rhs.to_ty(tcx).into())),
- );
- }
-
- if rhs.is_opaque(tcx) {
- candidates.extend(
- self.probe_misc_candidate("define-rhs-opaque")
- .enter(|ecx| ecx.define_opaque(param_env, rhs, lhs.to_ty(tcx).into())),
- );
- }
-
- candidates.extend(self.probe_misc_candidate("args-relate").enter(|ecx| {
- ecx.relate(param_env, lhs, variance, rhs)?;
- ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
- }));
-
- if let Some(result) = self.try_merge_responses(&candidates) {
- Ok(result)
- } else {
- self.flounder(&candidates)
- }
- }
}
diff --git a/compiler/rustc_trait_selection/src/solve/mod.rs b/compiler/rustc_trait_selection/src/solve/mod.rs
index 6984f0ba69473..dd9fd2a904e12 100644
--- a/compiler/rustc_trait_selection/src/solve/mod.rs
+++ b/compiler/rustc_trait_selection/src/solve/mod.rs
@@ -22,8 +22,7 @@ use rustc_middle::traits::solve::{
CanonicalResponse, Certainty, ExternalConstraintsData, Goal, GoalSource, IsNormalizesToHack,
QueryResult, Response,
};
-use rustc_middle::traits::Reveal;
-use rustc_middle::ty::{self, OpaqueTypeKey, Ty, TyCtxt, UniverseIndex};
+use rustc_middle::ty::{self, Ty, TyCtxt, UniverseIndex};
use rustc_middle::ty::{
CoercePredicate, RegionOutlivesPredicate, SubtypePredicate, TypeOutlivesPredicate,
};
@@ -311,32 +310,10 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
return None;
}
- let ty::Alias(kind, alias) = *ty.kind() else {
+ let ty::Alias(_, alias) = *ty.kind() else {
return Some(ty);
};
- // We do no always define opaque types eagerly to allow non-defining uses
- // in the defining scope. However, if we can unify this opaque to an existing
- // opaque, then we should attempt to eagerly reveal the opaque, and we fall
- // through.
- if let DefineOpaqueTypes::No = define_opaque_types
- && let Reveal::UserFacing = param_env.reveal()
- && let ty::Opaque = kind
- && let Some(def_id) = alias.def_id.as_local()
- && self.can_define_opaque_ty(def_id)
- {
- if self
- .unify_existing_opaque_tys(
- param_env,
- OpaqueTypeKey { def_id, args: alias.args },
- self.next_ty_infer(),
- )
- .is_empty()
- {
- return Some(ty);
- }
- }
-
match self.commit_if_ok(|this| {
let normalized_ty = this.next_ty_infer();
let normalizes_to_goal = Goal::new(
From 3eef669b04495b191ce8888d678f352a9812ae87 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Thu, 1 Feb 2024 12:34:38 +0100
Subject: [PATCH 13/18] use alias-relate to structurally normalize in the
solver
---
.../src/solve/alias_relate.rs | 41 +++++++++++---
.../src/solve/assembly/mod.rs | 24 +++-----
.../rustc_trait_selection/src/solve/mod.rs | 56 +++++++------------
.../src/solve/normalizes_to/opaques.rs | 20 ++-----
.../src/solve/trait_goals.rs | 10 ++--
.../recursive-coroutine-boxed.next.stderr | 17 ++++++
.../impl-trait/recursive-coroutine-boxed.rs | 3 +-
.../two_tait_defining_each_other2.next.stderr | 4 +-
.../two_tait_defining_each_other2.rs | 2 +-
...e-closure-signature-after-normalization.rs | 5 +-
...osure-signature-after-normalization.stderr | 14 +++++
...e_of-tait-in-defining-scope.is_send.stderr | 13 +----
..._of-tait-in-defining-scope.not_send.stderr | 13 +----
.../dont-type_of-tait-in-defining-scope.rs | 2 +-
14 files changed, 116 insertions(+), 108 deletions(-)
create mode 100644 tests/ui/impl-trait/recursive-coroutine-boxed.next.stderr
create mode 100644 tests/ui/traits/next-solver/deduce-closure-signature-after-normalization.stderr
diff --git a/compiler/rustc_trait_selection/src/solve/alias_relate.rs b/compiler/rustc_trait_selection/src/solve/alias_relate.rs
index 999367e758978..81be5c091644e 100644
--- a/compiler/rustc_trait_selection/src/solve/alias_relate.rs
+++ b/compiler/rustc_trait_selection/src/solve/alias_relate.rs
@@ -21,10 +21,9 @@
//! `NormalizesTo` goal, at which point the opaque is actually defined.
use super::{EvalCtxt, GoalSource};
-use rustc_infer::infer::DefineOpaqueTypes;
use rustc_infer::traits::query::NoSolution;
use rustc_middle::traits::solve::{Certainty, Goal, QueryResult};
-use rustc_middle::ty;
+use rustc_middle::ty::{self, Ty};
impl<'tcx> EvalCtxt<'_, 'tcx> {
#[instrument(level = "debug", skip(self), ret)]
@@ -79,7 +78,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
}
// FIXME: This needs a name that reflects that it's okay to bottom-out with an inference var.
- /// Normalize the `term` to equate it later. This does not define opaque types.
+ /// Normalize the `term` to equate it later.
#[instrument(level = "debug", skip(self, param_env), ret)]
fn try_normalize_term(
&mut self,
@@ -88,10 +87,7 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
) -> Result<Option<ty::Term<'tcx>>, NoSolution> {
match term.unpack() {
ty::TermKind::Ty(ty) => {
- // We do no define opaque types here but instead do so in `relate_rigid_alias_or_opaque`.
- Ok(self
- .try_normalize_ty_recur(param_env, DefineOpaqueTypes::No, 0, ty)
- .map(Into::into))
+ Ok(self.try_normalize_ty_recur(param_env, 0, ty).map(Into::into))
}
ty::TermKind::Const(_) => {
if let Some(alias) = term.to_alias_ty(self.tcx()) {
@@ -108,4 +104,35 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
}
}
}
+
+ fn try_normalize_ty_recur(
+ &mut self,
+ param_env: ty::ParamEnv<'tcx>,
+ depth: usize,
+ ty: Ty<'tcx>,
+ ) -> Option<Ty<'tcx>> {
+ if !self.tcx().recursion_limit().value_within_limit(depth) {
+ return None;
+ }
+
+ let ty::Alias(_, alias) = *ty.kind() else {
+ return Some(ty);
+ };
+
+ match self.commit_if_ok(|this| {
+ let normalized_ty = this.next_ty_infer();
+ let normalizes_to_goal = Goal::new(
+ this.tcx(),
+ param_env,
+ ty::NormalizesTo { alias, term: normalized_ty.into() },
+ );
+ this.add_goal(GoalSource::Misc, normalizes_to_goal);
+ this.try_evaluate_added_goals()?;
+ let ty = this.resolve_vars_if_possible(normalized_ty);
+ Ok(this.try_normalize_ty_recur(param_env, depth + 1, ty))
+ }) {
+ Ok(ty) => ty,
+ Err(NoSolution) => Some(ty),
+ }
+ }
}
diff --git a/compiler/rustc_trait_selection/src/solve/assembly/mod.rs b/compiler/rustc_trait_selection/src/solve/assembly/mod.rs
index 7052fd776b0f2..24d7dd1dc572d 100644
--- a/compiler/rustc_trait_selection/src/solve/assembly/mod.rs
+++ b/compiler/rustc_trait_selection/src/solve/assembly/mod.rs
@@ -285,13 +285,11 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
vec![Candidate { source, result }]
};
- let Some(normalized_self_ty) =
- self.try_normalize_ty(goal.param_env, goal.predicate.self_ty())
+ let Ok(normalized_self_ty) =
+ self.structurally_normalize_ty(goal.param_env, goal.predicate.self_ty())
else {
- debug!("overflow while evaluating self type");
- return dummy_candidate(self, Certainty::OVERFLOW);
+ return vec![];
};
-
if normalized_self_ty.is_ty_var() {
debug!("self type has been normalized to infer");
return dummy_candidate(self, Certainty::AMBIGUOUS);
@@ -793,19 +791,11 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
let result = self.probe_misc_candidate("coherence unknowable").enter(|ecx| {
let trait_ref = goal.predicate.trait_ref(tcx);
- #[derive(Debug)]
- struct Overflow;
- let lazily_normalize_ty = |ty| match ecx.try_normalize_ty(goal.param_env, ty) {
- Some(ty) => Ok(ty),
- None => Err(Overflow),
- };
+ let lazily_normalize_ty = |ty| ecx.structurally_normalize_ty(goal.param_env, ty);
- match coherence::trait_ref_is_knowable(tcx, trait_ref, lazily_normalize_ty) {
- Err(Overflow) => {
- ecx.evaluate_added_goals_and_make_canonical_response(Certainty::OVERFLOW)
- }
- Ok(Ok(())) => Err(NoSolution),
- Ok(Err(_)) => {
+ match coherence::trait_ref_is_knowable(tcx, trait_ref, lazily_normalize_ty)? {
+ Ok(()) => Err(NoSolution),
+ Err(_) => {
ecx.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
}
}
diff --git a/compiler/rustc_trait_selection/src/solve/mod.rs b/compiler/rustc_trait_selection/src/solve/mod.rs
index dd9fd2a904e12..3fbf9cfb354d3 100644
--- a/compiler/rustc_trait_selection/src/solve/mod.rs
+++ b/compiler/rustc_trait_selection/src/solve/mod.rs
@@ -15,14 +15,13 @@
//! about it on zulip.
use rustc_hir::def_id::DefId;
use rustc_infer::infer::canonical::{Canonical, CanonicalVarValues};
-use rustc_infer::infer::DefineOpaqueTypes;
use rustc_infer::traits::query::NoSolution;
use rustc_middle::infer::canonical::CanonicalVarInfos;
use rustc_middle::traits::solve::{
CanonicalResponse, Certainty, ExternalConstraintsData, Goal, GoalSource, IsNormalizesToHack,
QueryResult, Response,
};
-use rustc_middle::ty::{self, Ty, TyCtxt, UniverseIndex};
+use rustc_middle::ty::{self, AliasRelationDirection, Ty, TyCtxt, UniverseIndex};
use rustc_middle::ty::{
CoercePredicate, RegionOutlivesPredicate, SubtypePredicate, TypeOutlivesPredicate,
};
@@ -285,49 +284,32 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
Ok(self.make_ambiguous_response_no_constraints(maybe_cause))
}
- /// Normalize a type when it is structually matched on.
+ /// Normalize a type for when it is structurally matched on.
///
- /// In nearly all cases this function must be used before matching on a type.
+ /// This function is necessary in nearly all cases before matching on a type.
/// Not doing so is likely to be incomplete and therefore unsound during
/// coherence.
- #[instrument(level = "debug", skip(self), ret)]
- fn try_normalize_ty(
- &mut self,
- param_env: ty::ParamEnv<'tcx>,
- ty: Ty<'tcx>,
- ) -> Option<Ty<'tcx>> {
- self.try_normalize_ty_recur(param_env, DefineOpaqueTypes::Yes, 0, ty)
- }
-
- fn try_normalize_ty_recur(
+ fn structurally_normalize_ty(
&mut self,
param_env: ty::ParamEnv<'tcx>,
- define_opaque_types: DefineOpaqueTypes,
- depth: usize,
ty: Ty<'tcx>,
- ) -> Option<Ty<'tcx>> {
- if !self.tcx().recursion_limit().value_within_limit(depth) {
- return None;
- }
-
- let ty::Alias(_, alias) = *ty.kind() else {
- return Some(ty);
- };
-
- match self.commit_if_ok(|this| {
- let normalized_ty = this.next_ty_infer();
- let normalizes_to_goal = Goal::new(
- this.tcx(),
+ ) -> Result<Ty<'tcx>, NoSolution> {
+ if let ty::Alias(..) = ty.kind() {
+ let normalized_ty = self.next_ty_infer();
+ let alias_relate_goal = Goal::new(
+ self.tcx(),
param_env,
- ty::NormalizesTo { alias, term: normalized_ty.into() },
+ ty::PredicateKind::AliasRelate(
+ ty.into(),
+ normalized_ty.into(),
+ AliasRelationDirection::Equate,
+ ),
);
- this.add_goal(GoalSource::Misc, normalizes_to_goal);
- this.try_evaluate_added_goals()?;
- let ty = this.resolve_vars_if_possible(normalized_ty);
- Ok(this.try_normalize_ty_recur(param_env, define_opaque_types, depth + 1, ty))
- }) {
- Ok(ty) => ty,
- Err(NoSolution) => Some(ty),
+ self.add_goal(GoalSource::Misc, alias_relate_goal);
+ self.try_evaluate_added_goals()?;
+ Ok(self.resolve_vars_if_possible(normalized_ty))
+ } else {
+ Ok(ty)
}
}
}
diff --git a/compiler/rustc_trait_selection/src/solve/normalizes_to/opaques.rs b/compiler/rustc_trait_selection/src/solve/normalizes_to/opaques.rs
index b5d1aa06e4eeb..356c3776c04ce 100644
--- a/compiler/rustc_trait_selection/src/solve/normalizes_to/opaques.rs
+++ b/compiler/rustc_trait_selection/src/solve/normalizes_to/opaques.rs
@@ -58,21 +58,11 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
}
}
- let expected = match self.try_normalize_ty(goal.param_env, expected) {
- Some(ty) => {
- if ty.is_ty_var() {
- return self.evaluate_added_goals_and_make_canonical_response(
- Certainty::AMBIGUOUS,
- );
- } else {
- ty
- }
- }
- None => {
- return self
- .evaluate_added_goals_and_make_canonical_response(Certainty::OVERFLOW);
- }
- };
+ let expected = self.structurally_normalize_ty(goal.param_env, expected)?;
+ if expected.is_ty_var() {
+ return self
+ .evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS);
+ }
// Otherwise, define a new opaque type
self.insert_hidden_type(opaque_type_key, goal.param_env, expected)?;
diff --git a/compiler/rustc_trait_selection/src/solve/trait_goals.rs b/compiler/rustc_trait_selection/src/solve/trait_goals.rs
index fd09a6b671dad..aaf7bef613880 100644
--- a/compiler/rustc_trait_selection/src/solve/trait_goals.rs
+++ b/compiler/rustc_trait_selection/src/solve/trait_goals.rs
@@ -581,11 +581,11 @@ impl<'tcx> assembly::GoalKind<'tcx> for TraitPredicate<'tcx> {
let a_ty = goal.predicate.self_ty();
// We need to normalize the b_ty since it's matched structurally
// in the other functions below.
- let b_ty = match ecx
- .try_normalize_ty(goal.param_env, goal.predicate.trait_ref.args.type_at(1))
- {
- Some(b_ty) => b_ty,
- None => return vec![misc_candidate(ecx, Certainty::OVERFLOW)],
+ let Ok(b_ty) = ecx.structurally_normalize_ty(
+ goal.param_env,
+ goal.predicate.trait_ref.args.type_at(1),
+ ) else {
+ return vec![];
};
let goal = goal.with(ecx.tcx(), (a_ty, b_ty));
diff --git a/tests/ui/impl-trait/recursive-coroutine-boxed.next.stderr b/tests/ui/impl-trait/recursive-coroutine-boxed.next.stderr
new file mode 100644
index 0000000000000..0d9e2ee8469e8
--- /dev/null
+++ b/tests/ui/impl-trait/recursive-coroutine-boxed.next.stderr
@@ -0,0 +1,17 @@
+error[E0282]: type annotations needed
+ --> $DIR/recursive-coroutine-boxed.rs:10:23
+ |
+LL | let mut gen = Box::pin(foo());
+ | ^^^^^^^^ cannot infer type of the type parameter `T` declared on the struct `Box`
+LL |
+LL | let mut r = gen.as_mut().resume(());
+ | ------ type must be known at this point
+ |
+help: consider specifying the generic argument
+ |
+LL | let mut gen = Box::<T>::pin(foo());
+ | +++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/impl-trait/recursive-coroutine-boxed.rs b/tests/ui/impl-trait/recursive-coroutine-boxed.rs
index b9291f07e2138..2c5d679994f07 100644
--- a/tests/ui/impl-trait/recursive-coroutine-boxed.rs
+++ b/tests/ui/impl-trait/recursive-coroutine-boxed.rs
@@ -1,5 +1,5 @@
-// check-pass
// revisions: current next
+//[current] check-pass
//[next] compile-flags: -Znext-solver
#![feature(coroutines, coroutine_trait)]
@@ -8,6 +8,7 @@ use std::ops::{Coroutine, CoroutineState};
fn foo() -> impl Coroutine<Yield = (), Return = ()> {
|| {
let mut gen = Box::pin(foo());
+ //[next]~^ ERROR type annotations needed
let mut r = gen.as_mut().resume(());
while let CoroutineState::Yielded(v) = r {
yield v;
diff --git a/tests/ui/impl-trait/two_tait_defining_each_other2.next.stderr b/tests/ui/impl-trait/two_tait_defining_each_other2.next.stderr
index e49d1d18b0cf7..69328e2058313 100644
--- a/tests/ui/impl-trait/two_tait_defining_each_other2.next.stderr
+++ b/tests/ui/impl-trait/two_tait_defining_each_other2.next.stderr
@@ -1,8 +1,8 @@
-error[E0284]: type annotations needed: cannot satisfy `A <: B`
+error[E0284]: type annotations needed: cannot satisfy `A == B`
--> $DIR/two_tait_defining_each_other2.rs:11:5
|
LL | x // B's hidden type is A (opaquely)
- | ^ cannot satisfy `A <: B`
+ | ^ cannot satisfy `A == B`
error: aborting due to 1 previous error
diff --git a/tests/ui/impl-trait/two_tait_defining_each_other2.rs b/tests/ui/impl-trait/two_tait_defining_each_other2.rs
index 8a79af19776b7..b2f768f4dcd70 100644
--- a/tests/ui/impl-trait/two_tait_defining_each_other2.rs
+++ b/tests/ui/impl-trait/two_tait_defining_each_other2.rs
@@ -10,7 +10,7 @@ trait Foo {}
fn muh(x: A) -> B {
x // B's hidden type is A (opaquely)
//[current]~^ ERROR opaque type's hidden type cannot be another opaque type
- //[next]~^^ ERROR type annotations needed: cannot satisfy `A <: B`
+ //[next]~^^ ERROR type annotations needed: cannot satisfy `A == B`
}
struct Bar;
diff --git a/tests/ui/traits/next-solver/deduce-closure-signature-after-normalization.rs b/tests/ui/traits/next-solver/deduce-closure-signature-after-normalization.rs
index 08f26686b2f20..f9f5a1dc24d47 100644
--- a/tests/ui/traits/next-solver/deduce-closure-signature-after-normalization.rs
+++ b/tests/ui/traits/next-solver/deduce-closure-signature-after-normalization.rs
@@ -1,9 +1,10 @@
// compile-flags: -Znext-solver
-// check-pass
-
+// FIXME(-Znext-solver): This test is currently broken because the `deduce_closure_signature`
+// is unable to look at nested obligations.
trait Foo {
fn test() -> impl Fn(u32) -> u32 {
|x| x.count_ones()
+ //~^ ERROR type annotations needed
}
}
diff --git a/tests/ui/traits/next-solver/deduce-closure-signature-after-normalization.stderr b/tests/ui/traits/next-solver/deduce-closure-signature-after-normalization.stderr
new file mode 100644
index 0000000000000..3d7cd1af4677f
--- /dev/null
+++ b/tests/ui/traits/next-solver/deduce-closure-signature-after-normalization.stderr
@@ -0,0 +1,14 @@
+error[E0282]: type annotations needed
+ --> $DIR/deduce-closure-signature-after-normalization.rs:6:10
+ |
+LL | |x| x.count_ones()
+ | ^ - type must be known at this point
+ |
+help: consider giving this closure parameter an explicit type
+ |
+LL | |x: /* Type */| x.count_ones()
+ | ++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/traits/next-solver/dont-type_of-tait-in-defining-scope.is_send.stderr b/tests/ui/traits/next-solver/dont-type_of-tait-in-defining-scope.is_send.stderr
index bafc4ba18a7a3..158fefd1538f3 100644
--- a/tests/ui/traits/next-solver/dont-type_of-tait-in-defining-scope.is_send.stderr
+++ b/tests/ui/traits/next-solver/dont-type_of-tait-in-defining-scope.is_send.stderr
@@ -1,16 +1,9 @@
-error[E0283]: type annotations needed: cannot satisfy `Foo: Send`
+error[E0284]: type annotations needed: cannot satisfy `Foo == _`
--> $DIR/dont-type_of-tait-in-defining-scope.rs:15:18
|
LL | needs_send::<Foo>();
- | ^^^
- |
- = note: cannot satisfy `Foo: Send`
-note: required by a bound in `needs_send`
- --> $DIR/dont-type_of-tait-in-defining-scope.rs:12:18
- |
-LL | fn needs_send<T: Send>() {}
- | ^^^^ required by this bound in `needs_send`
+ | ^^^ cannot satisfy `Foo == _`
error: aborting due to 1 previous error
-For more information about this error, try `rustc --explain E0283`.
+For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/traits/next-solver/dont-type_of-tait-in-defining-scope.not_send.stderr b/tests/ui/traits/next-solver/dont-type_of-tait-in-defining-scope.not_send.stderr
index bafc4ba18a7a3..158fefd1538f3 100644
--- a/tests/ui/traits/next-solver/dont-type_of-tait-in-defining-scope.not_send.stderr
+++ b/tests/ui/traits/next-solver/dont-type_of-tait-in-defining-scope.not_send.stderr
@@ -1,16 +1,9 @@
-error[E0283]: type annotations needed: cannot satisfy `Foo: Send`
+error[E0284]: type annotations needed: cannot satisfy `Foo == _`
--> $DIR/dont-type_of-tait-in-defining-scope.rs:15:18
|
LL | needs_send::<Foo>();
- | ^^^
- |
- = note: cannot satisfy `Foo: Send`
-note: required by a bound in `needs_send`
- --> $DIR/dont-type_of-tait-in-defining-scope.rs:12:18
- |
-LL | fn needs_send<T: Send>() {}
- | ^^^^ required by this bound in `needs_send`
+ | ^^^ cannot satisfy `Foo == _`
error: aborting due to 1 previous error
-For more information about this error, try `rustc --explain E0283`.
+For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/traits/next-solver/dont-type_of-tait-in-defining-scope.rs b/tests/ui/traits/next-solver/dont-type_of-tait-in-defining-scope.rs
index ef0360248b59a..9720a653e2bc0 100644
--- a/tests/ui/traits/next-solver/dont-type_of-tait-in-defining-scope.rs
+++ b/tests/ui/traits/next-solver/dont-type_of-tait-in-defining-scope.rs
@@ -13,7 +13,7 @@ fn needs_send<T: Send>() {}
fn test(_: Foo) {
needs_send::<Foo>();
- //~^ ERROR type annotations needed: cannot satisfy `Foo: Send`
+ //~^ ERROR type annotations needed: cannot satisfy `Foo == _`
}
fn defines(_: Foo) {
From 4ced2693cf4d854a03a58991e13060d022483e1f Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Thu, 1 Feb 2024 13:24:05 +0100
Subject: [PATCH 14/18] add revisions
---
....stderr => self-referential-2.current.stderr} | 2 +-
.../type-alias-impl-trait/self-referential-2.rs | 5 ++++-
.../type-alias-impl-trait-tuple.next.stderr | 16 ++++++++++++++++
.../type-alias-impl-trait-tuple.rs | 6 +++++-
...a_let.stderr => type_of_a_let.current.stderr} | 4 ++--
tests/ui/type-alias-impl-trait/type_of_a_let.rs | 8 ++++++--
6 files changed, 34 insertions(+), 7 deletions(-)
rename tests/ui/type-alias-impl-trait/{self-referential-2.stderr => self-referential-2.current.stderr} (92%)
create mode 100644 tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.next.stderr
rename tests/ui/type-alias-impl-trait/{type_of_a_let.stderr => type_of_a_let.current.stderr} (91%)
diff --git a/tests/ui/type-alias-impl-trait/self-referential-2.stderr b/tests/ui/type-alias-impl-trait/self-referential-2.current.stderr
similarity index 92%
rename from tests/ui/type-alias-impl-trait/self-referential-2.stderr
rename to tests/ui/type-alias-impl-trait/self-referential-2.current.stderr
index ab57812ba9bb7..019e01a07d3fa 100644
--- a/tests/ui/type-alias-impl-trait/self-referential-2.stderr
+++ b/tests/ui/type-alias-impl-trait/self-referential-2.current.stderr
@@ -1,5 +1,5 @@
error[E0277]: can't compare `i32` with `Foo`
- --> $DIR/self-referential-2.rs:6:13
+ --> $DIR/self-referential-2.rs:9:13
|
LL | fn bar() -> Bar {
| ^^^ no implementation for `i32 == Foo`
diff --git a/tests/ui/type-alias-impl-trait/self-referential-2.rs b/tests/ui/type-alias-impl-trait/self-referential-2.rs
index 8781196c39fa1..3a765a2e3ef82 100644
--- a/tests/ui/type-alias-impl-trait/self-referential-2.rs
+++ b/tests/ui/type-alias-impl-trait/self-referential-2.rs
@@ -1,10 +1,13 @@
+// revisions: current next
+//[next] compile-flags: -Znext-solver
+//[next] check-pass
#![feature(type_alias_impl_trait)]
type Foo = impl std::fmt::Debug;
type Bar = impl PartialEq<Foo>;
fn bar() -> Bar {
- 42_i32 //~^ ERROR can't compare `i32` with `Foo`
+ 42_i32 //[current]~^ ERROR can't compare `i32` with `Foo`
}
fn main() {}
diff --git a/tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.next.stderr b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.next.stderr
new file mode 100644
index 0000000000000..1bfea8a0e3003
--- /dev/null
+++ b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.next.stderr
@@ -0,0 +1,16 @@
+error[E0284]: type annotations needed: cannot satisfy `Foo == _`
+ --> $DIR/type-alias-impl-trait-tuple.rs:21:24
+ |
+LL | Blah { my_foo: make_foo(), my_u8: 12 }
+ | ^^^^^^^^^^ cannot satisfy `Foo == _`
+
+error[E0282]: type annotations needed
+ --> $DIR/type-alias-impl-trait-tuple.rs:24:28
+ |
+LL | fn into_inner(self) -> (Foo, u8, Foo) {
+ | ^^^^^^^^^^^^^^ cannot infer type for tuple `(Foo, u8, Foo)`
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0282, E0284.
+For more information about an error, try `rustc --explain E0282`.
diff --git a/tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.rs b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.rs
index 1f2d0e47ea3b2..2f25ab4df90ee 100644
--- a/tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.rs
+++ b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.rs
@@ -1,4 +1,6 @@
-// check-pass
+// revisions: current next
+//[next] compile-flags: -Znext-solver
+//[current] check-pass
#![feature(type_alias_impl_trait)]
#![allow(dead_code)]
@@ -17,8 +19,10 @@ struct Blah {
impl Blah {
fn new() -> Blah {
Blah { my_foo: make_foo(), my_u8: 12 }
+ //[next]~^ ERROR type annotations needed: cannot satisfy `Foo == _`
}
fn into_inner(self) -> (Foo, u8, Foo) {
+ //[next]~^ ERROR type annotations needed
(self.my_foo, self.my_u8, make_foo())
}
}
diff --git a/tests/ui/type-alias-impl-trait/type_of_a_let.stderr b/tests/ui/type-alias-impl-trait/type_of_a_let.current.stderr
similarity index 91%
rename from tests/ui/type-alias-impl-trait/type_of_a_let.stderr
rename to tests/ui/type-alias-impl-trait/type_of_a_let.current.stderr
index 7d7cad874faec..22a3d7bd32fd7 100644
--- a/tests/ui/type-alias-impl-trait/type_of_a_let.stderr
+++ b/tests/ui/type-alias-impl-trait/type_of_a_let.current.stderr
@@ -1,5 +1,5 @@
error[E0382]: use of moved value: `x`
- --> $DIR/type_of_a_let.rs:16:16
+ --> $DIR/type_of_a_let.rs:20:16
|
LL | let x: Foo = 22_u32;
| - move occurs because `x` has type `Foo`, which does not implement the `Copy` trait
@@ -9,7 +9,7 @@ LL | same_type((x, y));
| ^ value used here after move
error[E0382]: use of moved value: `y`
- --> $DIR/type_of_a_let.rs:17:6
+ --> $DIR/type_of_a_let.rs:21:6
|
LL | let y: Foo = x;
| - move occurs because `y` has type `Foo`, which does not implement the `Copy` trait
diff --git a/tests/ui/type-alias-impl-trait/type_of_a_let.rs b/tests/ui/type-alias-impl-trait/type_of_a_let.rs
index 36161171555ca..0f4dac6c68333 100644
--- a/tests/ui/type-alias-impl-trait/type_of_a_let.rs
+++ b/tests/ui/type-alias-impl-trait/type_of_a_let.rs
@@ -1,3 +1,7 @@
+// revisions: current next
+//[next] compile-flags: -Znext-solver
+//[next] check-pass
+
#![feature(type_alias_impl_trait)]
#![allow(dead_code)]
@@ -13,8 +17,8 @@ fn foo1() -> (u32, Foo) {
fn foo2() -> (u32, Foo) {
let x: Foo = 22_u32;
let y: Foo = x;
- same_type((x, y)); //~ ERROR use of moved value
- (y, todo!()) //~ ERROR use of moved value
+ same_type((x, y)); //[current]~ ERROR use of moved value
+ (y, todo!()) //[current]~ ERROR use of moved value
}
fn same_type<T>(x: (T, T)) {}
From 45377df7be3f4c29387096b7fd54a155de662b2a Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Thu, 8 Feb 2024 10:20:15 +0100
Subject: [PATCH 15/18] one must imagine ci happy
---
.../type-alias-impl-trait-tuple.next.stderr | 11 +++++------
.../type-alias-impl-trait-tuple.rs | 2 +-
2 files changed, 6 insertions(+), 7 deletions(-)
diff --git a/tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.next.stderr b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.next.stderr
index 1bfea8a0e3003..b380dc66f03fc 100644
--- a/tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.next.stderr
+++ b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.next.stderr
@@ -4,13 +4,12 @@ error[E0284]: type annotations needed: cannot satisfy `Foo == _`
LL | Blah { my_foo: make_foo(), my_u8: 12 }
| ^^^^^^^^^^ cannot satisfy `Foo == _`
-error[E0282]: type annotations needed
- --> $DIR/type-alias-impl-trait-tuple.rs:24:28
+error[E0284]: type annotations needed: cannot satisfy `Foo == _`
+ --> $DIR/type-alias-impl-trait-tuple.rs:25:10
|
-LL | fn into_inner(self) -> (Foo, u8, Foo) {
- | ^^^^^^^^^^^^^^ cannot infer type for tuple `(Foo, u8, Foo)`
+LL | (self.my_foo, self.my_u8, make_foo())
+ | ^^^^^^^^^^^ cannot satisfy `Foo == _`
error: aborting due to 2 previous errors
-Some errors have detailed explanations: E0282, E0284.
-For more information about an error, try `rustc --explain E0282`.
+For more information about this error, try `rustc --explain E0284`.
diff --git a/tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.rs b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.rs
index 2f25ab4df90ee..7bf899a96be12 100644
--- a/tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.rs
+++ b/tests/ui/type-alias-impl-trait/type-alias-impl-trait-tuple.rs
@@ -22,8 +22,8 @@ impl Blah {
//[next]~^ ERROR type annotations needed: cannot satisfy `Foo == _`
}
fn into_inner(self) -> (Foo, u8, Foo) {
- //[next]~^ ERROR type annotations needed
(self.my_foo, self.my_u8, make_foo())
+ //[next]~^ ERROR type annotations needed: cannot satisfy `Foo == _`
}
}
From 9224387bf2e5e6d18a728c21e044893372182558 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Fri, 2 Feb 2024 17:13:22 +0100
Subject: [PATCH 16/18] Correctly generate path for non-local items in source
code pages
---
src/librustdoc/formats/item_type.rs | 37 ++++--
src/librustdoc/html/format.rs | 192 ++++++++++++++++++++--------
2 files changed, 165 insertions(+), 64 deletions(-)
diff --git a/src/librustdoc/formats/item_type.rs b/src/librustdoc/formats/item_type.rs
index e80da46adb4ca..f10c829bf4eed 100644
--- a/src/librustdoc/formats/item_type.rs
+++ b/src/librustdoc/formats/item_type.rs
@@ -4,7 +4,7 @@ use std::fmt;
use serde::{Serialize, Serializer};
-use rustc_hir::def::DefKind;
+use rustc_hir::def::{CtorOf, DefKind};
use rustc_span::hygiene::MacroKind;
use crate::clean;
@@ -115,7 +115,15 @@ impl<'a> From<&'a clean::Item> for ItemType {
impl From<DefKind> for ItemType {
fn from(other: DefKind) -> Self {
- match other {
+ Self::from_def_kind(other, None)
+ }
+}
+
+impl ItemType {
+ /// Depending on the parent kind, some variants have a different translation (like a `Method`
+ /// becoming a `TyMethod`).
+ pub(crate) fn from_def_kind(kind: DefKind, parent_kind: Option<DefKind>) -> Self {
+ match kind {
DefKind::Enum => Self::Enum,
DefKind::Fn => Self::Function,
DefKind::Mod => Self::Module,
@@ -131,30 +139,35 @@ impl From<DefKind> for ItemType {
MacroKind::Attr => ItemType::ProcAttribute,
MacroKind::Derive => ItemType::ProcDerive,
},
- DefKind::ForeignTy
- | DefKind::Variant
- | DefKind::AssocTy
- | DefKind::TyParam
+ DefKind::ForeignTy => Self::ForeignType,
+ DefKind::Variant => Self::Variant,
+ DefKind::Field => Self::StructField,
+ DefKind::AssocTy => Self::AssocType,
+ DefKind::AssocFn => {
+ if let Some(DefKind::Trait) = parent_kind {
+ Self::TyMethod
+ } else {
+ Self::Method
+ }
+ }
+ DefKind::Ctor(CtorOf::Struct, _) => Self::Struct,
+ DefKind::Ctor(CtorOf::Variant, _) => Self::Variant,
+ DefKind::AssocConst => Self::AssocConst,
+ DefKind::TyParam
| DefKind::ConstParam
- | DefKind::Ctor(..)
- | DefKind::AssocFn
- | DefKind::AssocConst
| DefKind::ExternCrate
| DefKind::Use
| DefKind::ForeignMod
| DefKind::AnonConst
| DefKind::InlineConst
| DefKind::OpaqueTy
- | DefKind::Field
| DefKind::LifetimeParam
| DefKind::GlobalAsm
| DefKind::Impl { .. }
| DefKind::Closure => Self::ForeignType,
}
}
-}
-impl ItemType {
pub(crate) fn as_str(&self) -> &'static str {
match *self {
ItemType::Module => "mod",
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 1923fc1511970..6c6d5384882b0 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -32,6 +32,7 @@ use crate::clean::{
self, types::ExternalLocation, utils::find_nearest_parent_module, ExternalCrate, ItemId,
PrimitiveType,
};
+use crate::formats::cache::Cache;
use crate::formats::item_type::ItemType;
use crate::html::escape::Escape;
use crate::html::render::Context;
@@ -581,7 +582,7 @@ fn generate_macro_def_id_path(
cx: &Context<'_>,
root_path: Option<&str>,
) -> Result<(String, ItemType, Vec<Symbol>), HrefError> {
- let tcx = cx.shared.tcx;
+ let tcx = cx.tcx();
let crate_name = tcx.crate_name(def_id.krate);
let cache = cx.cache();
@@ -651,92 +652,179 @@ fn generate_macro_def_id_path(
Ok((url, ItemType::Macro, fqp))
}
+fn generate_item_def_id_path(
+ mut def_id: DefId,
+ original_def_id: DefId,
+ cx: &Context<'_>,
+ root_path: Option<&str>,
+ original_def_kind: DefKind,
+) -> Result<(String, ItemType, Vec<Symbol>), HrefError> {
+ use crate::rustc_trait_selection::infer::TyCtxtInferExt;
+ use crate::rustc_trait_selection::traits::query::normalize::QueryNormalizeExt;
+ use rustc_middle::traits::ObligationCause;
+
+ let tcx = cx.tcx();
+ let crate_name = tcx.crate_name(def_id.krate);
+
+ // No need to try to infer the actual parent item if it's not an associated item from the `impl`
+ // block.
+ if def_id != original_def_id && matches!(tcx.def_kind(def_id), DefKind::Impl { .. }) {
+ let infcx = tcx.infer_ctxt().build();
+ def_id = infcx
+ .at(&ObligationCause::dummy(), tcx.param_env(def_id))
+ .query_normalize(ty::Binder::dummy(tcx.type_of(def_id).instantiate_identity()))
+ .map(|resolved| infcx.resolve_vars_if_possible(resolved.value))
+ .ok()
+ .and_then(|normalized| normalized.skip_binder().ty_adt_def())
+ .map(|adt| adt.did())
+ .unwrap_or(def_id);
+ }
+
+ let relative: Vec<Symbol> = tcx
+ .def_path(def_id)
+ .data
+ .into_iter()
+ .filter_map(|elem| {
+ // extern blocks (and a few others things) have an empty name.
+ match elem.data.get_opt_name() {
+ Some(s) if !s.is_empty() => Some(s),
+ _ => None,
+ }
+ })
+ .collect();
+ let fqp: Vec<Symbol> = once(crate_name).chain(relative).collect();
+
+ let def_kind = tcx.def_kind(def_id);
+ let shortty = def_kind.into();
+ let module_fqp = to_module_fqp(shortty, &fqp);
+ let mut is_remote = false;
+
+ let url_parts = url_parts(cx.cache(), def_id, &module_fqp, &cx.current, &mut is_remote)?;
+ let (url_parts, shortty, fqp) = make_href(root_path, shortty, url_parts, &fqp, is_remote)?;
+ if def_id == original_def_id {
+ return Ok((url_parts, shortty, fqp));
+ }
+ let kind = ItemType::from_def_kind(original_def_kind, Some(def_kind));
+ Ok((format!("{url_parts}#{kind}.{}", tcx.item_name(original_def_id)), shortty, fqp))
+}
+
+fn to_module_fqp(shortty: ItemType, fqp: &[Symbol]) -> &[Symbol] {
+ if shortty == ItemType::Module { fqp } else { &fqp[..fqp.len() - 1] }
+}
+
+fn url_parts(
+ cache: &Cache,
+ def_id: DefId,
+ module_fqp: &[Symbol],
+ relative_to: &[Symbol],
+ is_remote: &mut bool,
+) -> Result<UrlPartsBuilder, HrefError> {
+ match cache.extern_locations[&def_id.krate] {
+ ExternalLocation::Remote(ref s) => {
+ *is_remote = true;
+ let s = s.trim_end_matches('/');
+ let mut builder = UrlPartsBuilder::singleton(s);
+ builder.extend(module_fqp.iter().copied());
+ Ok(builder)
+ }
+ ExternalLocation::Local => Ok(href_relative_parts(module_fqp, relative_to).collect()),
+ ExternalLocation::Unknown => Err(HrefError::DocumentationNotBuilt),
+ }
+}
+
+fn make_href(
+ root_path: Option<&str>,
+ shortty: ItemType,
+ mut url_parts: UrlPartsBuilder,
+ fqp: &[Symbol],
+ is_remote: bool,
+) -> Result<(String, ItemType, Vec<Symbol>), HrefError> {
+ if !is_remote && let Some(root_path) = root_path {
+ let root = root_path.trim_end_matches('/');
+ url_parts.push_front(root);
+ }
+ debug!(?url_parts);
+ match shortty {
+ ItemType::Module => {
+ url_parts.push("index.html");
+ }
+ _ => {
+ let prefix = shortty.as_str();
+ let last = fqp.last().unwrap();
+ url_parts.push_fmt(format_args!("{prefix}.{last}.html"));
+ }
+ }
+ Ok((url_parts.finish(), shortty, fqp.to_vec()))
+}
+
pub(crate) fn href_with_root_path(
- did: DefId,
+ original_did: DefId,
cx: &Context<'_>,
root_path: Option<&str>,
) -> Result<(String, ItemType, Vec<Symbol>), HrefError> {
let tcx = cx.tcx();
- let def_kind = tcx.def_kind(did);
+ let def_kind = tcx.def_kind(original_did);
let did = match def_kind {
DefKind::AssocTy | DefKind::AssocFn | DefKind::AssocConst | DefKind::Variant => {
// documented on their parent's page
- tcx.parent(did)
+ tcx.parent(original_did)
}
+ // If this a constructor, we get the parent (either a struct or a variant) and then
+ // generate the link for this item.
+ DefKind::Ctor(..) => return href_with_root_path(tcx.parent(original_did), cx, root_path),
DefKind::ExternCrate => {
// Link to the crate itself, not the `extern crate` item.
- if let Some(local_did) = did.as_local() {
+ if let Some(local_did) = original_did.as_local() {
tcx.extern_mod_stmt_cnum(local_did).unwrap_or(LOCAL_CRATE).as_def_id()
} else {
- did
+ original_did
}
}
- _ => did,
+ _ => original_did,
};
let cache = cx.cache();
let relative_to = &cx.current;
- fn to_module_fqp(shortty: ItemType, fqp: &[Symbol]) -> &[Symbol] {
- if shortty == ItemType::Module { fqp } else { &fqp[..fqp.len() - 1] }
- }
- if !did.is_local()
- && !cache.effective_visibilities.is_directly_public(tcx, did)
- && !cache.document_private
- && !cache.primitive_locations.values().any(|&id| id == did)
- {
- return Err(HrefError::Private);
+ if !original_did.is_local() {
+ // If we are generating an href for the "jump to def" feature, then the only case we want
+ // to ignore is if the item is `doc(hidden)` because we can't link to it.
+ if root_path.is_some() {
+ if tcx.is_doc_hidden(original_did) {
+ return Err(HrefError::Private);
+ }
+ } else if !cache.effective_visibilities.is_directly_public(tcx, did)
+ && !cache.document_private
+ && !cache.primitive_locations.values().any(|&id| id == did)
+ {
+ return Err(HrefError::Private);
+ }
}
let mut is_remote = false;
- let (fqp, shortty, mut url_parts) = match cache.paths.get(&did) {
+ let (fqp, shortty, url_parts) = match cache.paths.get(&did) {
Some(&(ref fqp, shortty)) => (fqp, shortty, {
let module_fqp = to_module_fqp(shortty, fqp.as_slice());
debug!(?fqp, ?shortty, ?module_fqp);
href_relative_parts(module_fqp, relative_to).collect()
}),
None => {
- if let Some(&(ref fqp, shortty)) = cache.external_paths.get(&did) {
+ // Associated items are handled differently with "jump to def". The anchor is generated
+ // directly here whereas for intra-doc links, we have some extra computation being
+ // performed there.
+ let def_id_to_get = if root_path.is_some() { original_did } else { did };
+ if let Some(&(ref fqp, shortty)) = cache.external_paths.get(&def_id_to_get) {
let module_fqp = to_module_fqp(shortty, fqp);
- (
- fqp,
- shortty,
- match cache.extern_locations[&did.krate] {
- ExternalLocation::Remote(ref s) => {
- is_remote = true;
- let s = s.trim_end_matches('/');
- let mut builder = UrlPartsBuilder::singleton(s);
- builder.extend(module_fqp.iter().copied());
- builder
- }
- ExternalLocation::Local => {
- href_relative_parts(module_fqp, relative_to).collect()
- }
- ExternalLocation::Unknown => return Err(HrefError::DocumentationNotBuilt),
- },
- )
+ (fqp, shortty, url_parts(cache, did, module_fqp, relative_to, &mut is_remote)?)
} else if matches!(def_kind, DefKind::Macro(_)) {
return generate_macro_def_id_path(did, cx, root_path);
+ } else if did.is_local() {
+ return Err(HrefError::Private);
} else {
- return Err(HrefError::NotInExternalCache);
+ return generate_item_def_id_path(did, original_did, cx, root_path, def_kind);
}
}
};
- if !is_remote && let Some(root_path) = root_path {
- let root = root_path.trim_end_matches('/');
- url_parts.push_front(root);
- }
- debug!(?url_parts);
- match shortty {
- ItemType::Module => {
- url_parts.push("index.html");
- }
- _ => {
- let prefix = shortty.as_str();
- let last = fqp.last().unwrap();
- url_parts.push_fmt(format_args!("{prefix}.{last}.html"));
- }
- }
- Ok((url_parts.finish(), shortty, fqp.to_vec()))
+ make_href(root_path, shortty, url_parts, fqp, is_remote)
}
pub(crate) fn href(
From 41f9b579773bdd747a5febac566ea7b89a99cac2 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sat, 3 Feb 2024 01:28:08 +0100
Subject: [PATCH 17/18] Add regression test for non local items link generation
---
tests/rustdoc/jump-to-non-local-method.rs | 15 +++++++++++++++
1 file changed, 15 insertions(+)
create mode 100644 tests/rustdoc/jump-to-non-local-method.rs
diff --git a/tests/rustdoc/jump-to-non-local-method.rs b/tests/rustdoc/jump-to-non-local-method.rs
new file mode 100644
index 0000000000000..4f4252a584257
--- /dev/null
+++ b/tests/rustdoc/jump-to-non-local-method.rs
@@ -0,0 +1,15 @@
+// compile-flags: -Zunstable-options --generate-link-to-definition
+
+#![crate_name = "foo"]
+
+use std::sync::atomic::AtomicIsize;
+
+// @has 'src/foo/jump-to-non-local-method.rs.html'
+// @has - '//a[@href="https://doc.rust-lang.org/nightly/core/sync/atomic/struct.AtomicIsize.html#method.new"]' 'AtomicIsize::new'
+
+pub fn bar() {
+ let _ = AtomicIsize::new(0);
+ b();
+}
+
+fn b() {}
From 11bd2ea9397391acd3232f9f765dec36c24d289c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sat, 3 Feb 2024 01:35:46 +0100
Subject: [PATCH 18/18] Unify item relative path computation in one function
---
src/librustdoc/clean/inline.rs | 19 +++++++++--
src/librustdoc/html/format.rs | 26 ++------------
tests/rustdoc/jump-to-non-local-method.rs | 41 ++++++++++++++++++++---
3 files changed, 55 insertions(+), 31 deletions(-)
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index f65c09bf0e810..7ca4392233ed4 100644
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -191,6 +191,20 @@ pub(crate) fn load_attrs<'hir>(cx: &DocContext<'hir>, did: DefId) -> &'hir [ast:
cx.tcx.get_attrs_unchecked(did)
}
+pub(crate) fn item_relative_path(tcx: TyCtxt<'_>, def_id: DefId) -> Vec<Symbol> {
+ tcx.def_path(def_id)
+ .data
+ .into_iter()
+ .filter_map(|elem| {
+ // extern blocks (and a few others things) have an empty name.
+ match elem.data.get_opt_name() {
+ Some(s) if !s.is_empty() => Some(s),
+ _ => None,
+ }
+ })
+ .collect()
+}
+
/// Record an external fully qualified name in the external_paths cache.
///
/// These names are used later on by HTML rendering to generate things like
@@ -206,8 +220,7 @@ pub(crate) fn record_extern_fqn(cx: &mut DocContext<'_>, did: DefId, kind: ItemT
let crate_name = cx.tcx.crate_name(did.krate);
- let relative =
- cx.tcx.def_path(did).data.into_iter().filter_map(|elem| elem.data.get_opt_name());
+ let relative = item_relative_path(cx.tcx, did);
let fqn = if let ItemType::Macro = kind {
// Check to see if it is a macro 2.0 or built-in macro
if matches!(
@@ -218,7 +231,7 @@ pub(crate) fn record_extern_fqn(cx: &mut DocContext<'_>, did: DefId, kind: ItemT
) {
once(crate_name).chain(relative).collect()
} else {
- vec![crate_name, relative.last().expect("relative was empty")]
+ vec![crate_name, *relative.last().expect("relative was empty")]
}
} else {
once(crate_name).chain(relative).collect()
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 6c6d5384882b0..4ba1665bdc9f1 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -586,18 +586,7 @@ fn generate_macro_def_id_path(
let crate_name = tcx.crate_name(def_id.krate);
let cache = cx.cache();
- let fqp: Vec<Symbol> = tcx
- .def_path(def_id)
- .data
- .into_iter()
- .filter_map(|elem| {
- // extern blocks (and a few others things) have an empty name.
- match elem.data.get_opt_name() {
- Some(s) if !s.is_empty() => Some(s),
- _ => None,
- }
- })
- .collect();
+ let fqp = clean::inline::item_relative_path(tcx, def_id);
let mut relative = fqp.iter().copied();
let cstore = CStore::from_tcx(tcx);
// We need this to prevent a `panic` when this function is used from intra doc links...
@@ -680,18 +669,7 @@ fn generate_item_def_id_path(
.unwrap_or(def_id);
}
- let relative: Vec<Symbol> = tcx
- .def_path(def_id)
- .data
- .into_iter()
- .filter_map(|elem| {
- // extern blocks (and a few others things) have an empty name.
- match elem.data.get_opt_name() {
- Some(s) if !s.is_empty() => Some(s),
- _ => None,
- }
- })
- .collect();
+ let relative = clean::inline::item_relative_path(tcx, def_id);
let fqp: Vec<Symbol> = once(crate_name).chain(relative).collect();
let def_kind = tcx.def_kind(def_id);
diff --git a/tests/rustdoc/jump-to-non-local-method.rs b/tests/rustdoc/jump-to-non-local-method.rs
index 4f4252a584257..571de11f26b21 100644
--- a/tests/rustdoc/jump-to-non-local-method.rs
+++ b/tests/rustdoc/jump-to-non-local-method.rs
@@ -2,14 +2,47 @@
#![crate_name = "foo"]
+// @has 'src/foo/jump-to-non-local-method.rs.html'
+
+// @has - '//a[@href="https://doc.rust-lang.org/nightly/core/sync/atomic/struct.AtomicIsize.html"]' 'std::sync::atomic::AtomicIsize'
use std::sync::atomic::AtomicIsize;
+// @has - '//a[@href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html"]' 'std::io::Read'
+use std::io::Read;
+// @has - '//a[@href="https://doc.rust-lang.org/nightly/std/io/index.html"]' 'std::io'
+use std::io;
+// @has - '//a[@href="https://doc.rust-lang.org/nightly/std/process/fn.exit.html"]' 'std::process::exit'
+use std::process::exit;
+use std::cmp::Ordering;
+use std::marker::PhantomData;
-// @has 'src/foo/jump-to-non-local-method.rs.html'
-// @has - '//a[@href="https://doc.rust-lang.org/nightly/core/sync/atomic/struct.AtomicIsize.html#method.new"]' 'AtomicIsize::new'
+pub fn bar2<T: Read>(readable: T) {
+ // @has - '//a[@href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html#tymethod.read"]' 'read'
+ let _ = readable.read(&mut []);
+}
pub fn bar() {
+ // @has - '//a[@href="https://doc.rust-lang.org/nightly/core/sync/atomic/struct.AtomicIsize.html#method.new"]' 'AtomicIsize::new'
let _ = AtomicIsize::new(0);
- b();
+ // @has - '//a[@href="#48"]' 'local_private'
+ local_private();
+}
+
+pub fn extern_call() {
+ // @has - '//a[@href="https://doc.rust-lang.org/nightly/std/process/fn.exit.html"]' 'exit'
+ exit(0);
+}
+
+pub fn macro_call() -> Result<(), ()> {
+ // @has - '//a[@href="https://doc.rust-lang.org/nightly/core/macro.try.html"]' 'try!'
+ try!(Err(()));
+ Ok(())
+}
+
+pub fn variant() {
+ // @has - '//a[@href="https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html#variant.Less"]' 'Ordering::Less'
+ let _ = Ordering::Less;
+ // @has - '//a[@href="https://doc.rust-lang.org/nightly/core/marker/struct.PhantomData.html"]' 'PhantomData'
+ let _: PhantomData::<usize> = PhantomData;
}
-fn b() {}
+fn local_private() {}