diff --git a/Cargo.lock b/Cargo.lock
index 910d6ba22c16f..5381c655b20a2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1138,10 +1138,12 @@ dependencies = [
[[package]]
name = "getopts"
-version = "0.2.19"
+version = "0.2.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72327b15c228bfe31f1390f93dd5e9279587f0463836393c9df719ce62a3e450"
+checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5"
dependencies = [
+ "rustc-std-workspace-core",
+ "rustc-std-workspace-std",
"unicode-width",
]
@@ -2364,6 +2366,9 @@ dependencies = [
[[package]]
name = "proc_macro"
version = "0.0.0"
+dependencies = [
+ "std",
+]
[[package]]
name = "profiler_builtins"
@@ -3052,6 +3057,13 @@ dependencies = [
"core",
]
+[[package]]
+name = "rustc-std-workspace-std"
+version = "1.0.0"
+dependencies = [
+ "std",
+]
+
[[package]]
name = "rustc-workspace-hack"
version = "1.0.0"
@@ -4039,6 +4051,10 @@ dependencies = [
[[package]]
name = "term"
version = "0.0.0"
+dependencies = [
+ "core",
+ "std",
+]
[[package]]
name = "term"
@@ -4085,8 +4101,12 @@ dependencies = [
name = "test"
version = "0.0.0"
dependencies = [
+ "core",
"getopts",
+ "libc",
+ "panic_unwind",
"proc_macro",
+ "std",
"term 0.0.0",
]
@@ -4463,9 +4483,14 @@ checksum = "aa6024fc12ddfd1c6dbc14a80fa2324d4568849869b779f6bd37e5e4c03344d1"
[[package]]
name = "unicode-width"
-version = "0.1.5"
+version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "882386231c45df4700b275c7ff55b6f3698780a650026380e72dabe76fa46526"
+checksum = "7007dbd421b92cc6e28410fe7362e2e0a2503394908f417b68ec8d1c364c4e20"
+dependencies = [
+ "compiler_builtins",
+ "rustc-std-workspace-core",
+ "rustc-std-workspace-std",
+]
[[package]]
name = "unicode-xid"
diff --git a/Cargo.toml b/Cargo.toml
index ccd7e8b7654a6..a242f090fbc07 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -68,6 +68,7 @@ rustc-workspace-hack = { path = 'src/tools/rustc-workspace-hack' }
# here
rustc-std-workspace-core = { path = 'src/tools/rustc-std-workspace-core' }
rustc-std-workspace-alloc = { path = 'src/tools/rustc-std-workspace-alloc' }
+rustc-std-workspace-std = { path = 'src/tools/rustc-std-workspace-std' }
[patch."https://github.com/rust-lang/rust-clippy"]
clippy_lints = { path = "src/tools/clippy/clippy_lints" }
diff --git a/src/bootstrap/builder.rs b/src/bootstrap/builder.rs
index f0054c36c0c88..da00752ab89d7 100644
--- a/src/bootstrap/builder.rs
+++ b/src/bootstrap/builder.rs
@@ -337,7 +337,6 @@ impl<'a> Builder<'a> {
match kind {
Kind::Build => describe!(
compile::Std,
- compile::Test,
compile::Rustc,
compile::CodegenBackend,
compile::StartupObjects,
@@ -363,7 +362,6 @@ impl<'a> Builder<'a> {
),
Kind::Check | Kind::Clippy | Kind::Fix => describe!(
check::Std,
- check::Test,
check::Rustc,
check::CodegenBackend,
check::Rustdoc
@@ -425,8 +423,6 @@ impl<'a> Builder<'a> {
doc::TheBook,
doc::Standalone,
doc::Std,
- doc::Test,
- doc::WhitelistedRustc,
doc::Rustc,
doc::Rustdoc,
doc::ErrorIndex,
@@ -795,7 +791,7 @@ impl<'a> Builder<'a> {
}
match mode {
- Mode::Std | Mode::Test | Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolTest=> {},
+ Mode::Std | Mode::ToolBootstrap | Mode::ToolStd => {},
Mode::Rustc | Mode::Codegen | Mode::ToolRustc => {
// Build proc macros both for the host and the target
if target != compiler.host && cmd != "check" {
@@ -846,7 +842,6 @@ impl<'a> Builder<'a> {
// things still build right, please do!
match mode {
Mode::Std => metadata.push_str("std"),
- Mode::Test => metadata.push_str("test"),
_ => {},
}
cargo.env("__CARGO_DEFAULT_LIB_METADATA", &metadata);
@@ -943,9 +938,9 @@ impl<'a> Builder<'a> {
let debuginfo_level = match mode {
Mode::Rustc | Mode::Codegen => self.config.rust_debuginfo_level_rustc,
- Mode::Std | Mode::Test => self.config.rust_debuginfo_level_std,
+ Mode::Std => self.config.rust_debuginfo_level_std,
Mode::ToolBootstrap | Mode::ToolStd |
- Mode::ToolTest | Mode::ToolRustc => self.config.rust_debuginfo_level_tools,
+ Mode::ToolRustc => self.config.rust_debuginfo_level_tools,
};
cargo.env("RUSTC_DEBUGINFO_LEVEL", debuginfo_level.to_string());
@@ -1145,7 +1140,6 @@ impl<'a> Builder<'a> {
match (mode, self.config.rust_codegen_units_std, self.config.rust_codegen_units) {
(Mode::Std, Some(n), _) |
- (Mode::Test, Some(n), _) |
(_, _, Some(n)) => {
cargo.env("RUSTC_CODEGEN_UNITS", n.to_string());
}
diff --git a/src/bootstrap/builder/tests.rs b/src/bootstrap/builder/tests.rs
index d1542b1fca6b7..2bb90fdb04edc 100644
--- a/src/bootstrap/builder/tests.rs
+++ b/src/bootstrap/builder/tests.rs
@@ -365,27 +365,6 @@ fn dist_with_same_targets_and_hosts() {
},
]
);
- assert_eq!(
- first(builder.cache.all::<compile::Test>()),
- &[
- compile::Test {
- compiler: Compiler { host: a, stage: 0 },
- target: a,
- },
- compile::Test {
- compiler: Compiler { host: a, stage: 1 },
- target: a,
- },
- compile::Test {
- compiler: Compiler { host: a, stage: 2 },
- target: a,
- },
- compile::Test {
- compiler: Compiler { host: a, stage: 1 },
- target: b,
- },
- ]
- );
assert_eq!(
first(builder.cache.all::<compile::Assemble>()),
&[
@@ -415,7 +394,47 @@ fn build_default() {
let b = INTERNER.intern_str("B");
let c = INTERNER.intern_str("C");
- assert!(!builder.cache.all::<compile::Std>().is_empty());
+ assert_eq!(
+ first(builder.cache.all::<compile::Std>()),
+ &[
+ compile::Std {
+ compiler: Compiler { host: a, stage: 0 },
+ target: a,
+ },
+ compile::Std {
+ compiler: Compiler { host: a, stage: 1 },
+ target: a,
+ },
+ compile::Std {
+ compiler: Compiler { host: a, stage: 2 },
+ target: a,
+ },
+ compile::Std {
+ compiler: Compiler { host: b, stage: 2 },
+ target: a,
+ },
+ compile::Std {
+ compiler: Compiler { host: a, stage: 1 },
+ target: b,
+ },
+ compile::Std {
+ compiler: Compiler { host: a, stage: 2 },
+ target: b,
+ },
+ compile::Std {
+ compiler: Compiler { host: b, stage: 2 },
+ target: b,
+ },
+ compile::Std {
+ compiler: Compiler { host: a, stage: 2 },
+ target: c,
+ },
+ compile::Std {
+ compiler: Compiler { host: b, stage: 2 },
+ target: c,
+ },
+ ]
+ );
assert!(!builder.cache.all::<compile::Assemble>().is_empty());
assert_eq!(
first(builder.cache.all::<compile::Rustc>()),
@@ -450,63 +469,61 @@ fn build_default() {
},
]
);
+}
+
+#[test]
+fn build_with_target_flag() {
+ let mut config = configure(&["B"], &["C"]);
+ config.skip_only_host_steps = true;
+ let build = Build::new(config);
+ let mut builder = Builder::new(&build);
+ builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Build), &[]);
+
+ let a = INTERNER.intern_str("A");
+ let b = INTERNER.intern_str("B");
+ let c = INTERNER.intern_str("C");
assert_eq!(
- first(builder.cache.all::<compile::Test>()),
+ first(builder.cache.all::<compile::Std>()),
&[
- compile::Test {
+ compile::Std {
compiler: Compiler { host: a, stage: 0 },
target: a,
},
- compile::Test {
+ compile::Std {
compiler: Compiler { host: a, stage: 1 },
target: a,
},
- compile::Test {
+ compile::Std {
compiler: Compiler { host: a, stage: 2 },
target: a,
},
- compile::Test {
+ compile::Std {
compiler: Compiler { host: b, stage: 2 },
target: a,
},
- compile::Test {
+ compile::Std {
compiler: Compiler { host: a, stage: 1 },
target: b,
},
- compile::Test {
+ compile::Std {
compiler: Compiler { host: a, stage: 2 },
target: b,
},
- compile::Test {
+ compile::Std {
compiler: Compiler { host: b, stage: 2 },
target: b,
},
- compile::Test {
+ compile::Std {
compiler: Compiler { host: a, stage: 2 },
target: c,
},
- compile::Test {
+ compile::Std {
compiler: Compiler { host: b, stage: 2 },
target: c,
},
]
);
-}
-
-#[test]
-fn build_with_target_flag() {
- let mut config = configure(&["B"], &["C"]);
- config.skip_only_host_steps = true;
- let build = Build::new(config);
- let mut builder = Builder::new(&build);
- builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Build), &[]);
-
- let a = INTERNER.intern_str("A");
- let b = INTERNER.intern_str("B");
- let c = INTERNER.intern_str("C");
-
- assert!(!builder.cache.all::<compile::Std>().is_empty());
assert_eq!(
first(builder.cache.all::<compile::Assemble>()),
&[
@@ -541,48 +558,6 @@ fn build_with_target_flag() {
},
]
);
-
- assert_eq!(
- first(builder.cache.all::<compile::Test>()),
- &[
- compile::Test {
- compiler: Compiler { host: a, stage: 0 },
- target: a,
- },
- compile::Test {
- compiler: Compiler { host: a, stage: 1 },
- target: a,
- },
- compile::Test {
- compiler: Compiler { host: a, stage: 2 },
- target: a,
- },
- compile::Test {
- compiler: Compiler { host: b, stage: 2 },
- target: a,
- },
- compile::Test {
- compiler: Compiler { host: a, stage: 1 },
- target: b,
- },
- compile::Test {
- compiler: Compiler { host: a, stage: 2 },
- target: b,
- },
- compile::Test {
- compiler: Compiler { host: b, stage: 2 },
- target: b,
- },
- compile::Test {
- compiler: Compiler { host: a, stage: 2 },
- target: c,
- },
- compile::Test {
- compiler: Compiler { host: b, stage: 2 },
- target: c,
- },
- ]
- );
}
#[test]
diff --git a/src/bootstrap/check.rs b/src/bootstrap/check.rs
index 6e6fea6b831a7..e9a9b7881a068 100644
--- a/src/bootstrap/check.rs
+++ b/src/bootstrap/check.rs
@@ -1,6 +1,6 @@
//! Implementation of compiling the compiler and standard library, in "check"-based modes.
-use crate::compile::{run_cargo, std_cargo, test_cargo, rustc_cargo, rustc_cargo_env,
+use crate::compile::{run_cargo, std_cargo, rustc_cargo, rustc_cargo_env,
add_to_sysroot};
use crate::builder::{RunConfig, Builder, Kind, ShouldRun, Step};
use crate::tool::{prepare_tool_cargo, SourceType};
@@ -92,7 +92,7 @@ impl Step for Rustc {
let compiler = builder.compiler(0, builder.config.build);
let target = self.target;
- builder.ensure(Test { target });
+ builder.ensure(Std { target });
let mut cargo = builder.cargo(compiler, Mode::Rustc, target,
cargo_subcommand(builder.kind));
@@ -159,47 +159,6 @@ impl Step for CodegenBackend {
}
}
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub struct Test {
- pub target: Interned<String>,
-}
-
-impl Step for Test {
- type Output = ();
- const DEFAULT: bool = true;
-
- fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
- run.all_krates("test")
- }
-
- fn make_run(run: RunConfig<'_>) {
- run.builder.ensure(Test {
- target: run.target,
- });
- }
-
- fn run(self, builder: &Builder<'_>) {
- let compiler = builder.compiler(0, builder.config.build);
- let target = self.target;
-
- builder.ensure(Std { target });
-
- let mut cargo = builder.cargo(compiler, Mode::Test, target, cargo_subcommand(builder.kind));
- test_cargo(builder, &compiler, target, &mut cargo);
-
- builder.info(&format!("Checking test artifacts ({} -> {})", &compiler.host, target));
- run_cargo(builder,
- &mut cargo,
- args(builder.kind),
- &libtest_stamp(builder, compiler, target),
- true);
-
- let libdir = builder.sysroot_libdir(compiler, target);
- let hostdir = builder.sysroot_libdir(compiler, compiler.host);
- add_to_sysroot(builder, &libdir, &hostdir, &libtest_stamp(builder, compiler, target));
- }
-}
-
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Rustdoc {
pub target: Interned<String>,
@@ -258,16 +217,6 @@ pub fn libstd_stamp(
builder.cargo_out(compiler, Mode::Std, target).join(".libstd-check.stamp")
}
-/// Cargo's output path for libtest in a given stage, compiled by a particular
-/// compiler for the specified target.
-pub fn libtest_stamp(
- builder: &Builder<'_>,
- compiler: Compiler,
- target: Interned<String>,
-) -> PathBuf {
- builder.cargo_out(compiler, Mode::Test, target).join(".libtest-check.stamp")
-}
-
/// Cargo's output path for librustc in a given stage, compiled by a particular
/// compiler for the specified target.
pub fn librustc_stamp(
diff --git a/src/bootstrap/compile.rs b/src/bootstrap/compile.rs
index 96987d081594f..7dad146b48d83 100644
--- a/src/bootstrap/compile.rs
+++ b/src/bootstrap/compile.rs
@@ -216,7 +216,7 @@ pub fn std_cargo(builder: &Builder<'_>,
cargo.arg("--features").arg(features)
.arg("--manifest-path")
- .arg(builder.src.join("src/libstd/Cargo.toml"));
+ .arg(builder.src.join("src/libtest/Cargo.toml"));
if target.contains("musl") {
if let Some(p) = builder.musl_root(target) {
@@ -358,129 +358,6 @@ impl Step for StartupObjects {
}
}
-#[derive(Debug, PartialOrd, Ord, Copy, Clone, PartialEq, Eq, Hash)]
-pub struct Test {
- pub target: Interned<String>,
- pub compiler: Compiler,
-}
-
-impl Step for Test {
- type Output = ();
- const DEFAULT: bool = true;
-
- fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
- run.all_krates("test")
- }
-
- fn make_run(run: RunConfig<'_>) {
- run.builder.ensure(Test {
- compiler: run.builder.compiler(run.builder.top_stage, run.host),
- target: run.target,
- });
- }
-
- /// Builds libtest.
- ///
- /// This will build libtest and supporting libraries for a particular stage of
- /// the build using the `compiler` targeting the `target` architecture. The
- /// artifacts created will also be linked into the sysroot directory.
- fn run(self, builder: &Builder<'_>) {
- let target = self.target;
- let compiler = self.compiler;
-
- builder.ensure(Std { compiler, target });
-
- if builder.config.keep_stage.contains(&compiler.stage) {
- builder.info("Warning: Using a potentially old libtest. This may not behave well.");
- builder.ensure(TestLink {
- compiler,
- target_compiler: compiler,
- target,
- });
- return;
- }
-
- let compiler_to_use = builder.compiler_for(compiler.stage, compiler.host, target);
- if compiler_to_use != compiler {
- builder.ensure(Test {
- compiler: compiler_to_use,
- target,
- });
- builder.info(
- &format!("Uplifting stage1 test ({} -> {})", builder.config.build, target));
- builder.ensure(TestLink {
- compiler: compiler_to_use,
- target_compiler: compiler,
- target,
- });
- return;
- }
-
- let mut cargo = builder.cargo(compiler, Mode::Test, target, "build");
- test_cargo(builder, &compiler, target, &mut cargo);
-
- builder.info(&format!("Building stage{} test artifacts ({} -> {})", compiler.stage,
- &compiler.host, target));
- run_cargo(builder,
- &mut cargo,
- vec![],
- &libtest_stamp(builder, compiler, target),
- false);
-
- builder.ensure(TestLink {
- compiler: builder.compiler(compiler.stage, builder.config.build),
- target_compiler: compiler,
- target,
- });
- }
-}
-
-/// Same as `std_cargo`, but for libtest
-pub fn test_cargo(builder: &Builder<'_>,
- _compiler: &Compiler,
- _target: Interned<String>,
- cargo: &mut Command) {
- if let Some(target) = env::var_os("MACOSX_STD_DEPLOYMENT_TARGET") {
- cargo.env("MACOSX_DEPLOYMENT_TARGET", target);
- }
- cargo.arg("--manifest-path")
- .arg(builder.src.join("src/libtest/Cargo.toml"));
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub struct TestLink {
- pub compiler: Compiler,
- pub target_compiler: Compiler,
- pub target: Interned<String>,
-}
-
-impl Step for TestLink {
- type Output = ();
-
- fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
- run.never()
- }
-
- /// Same as `std_link`, only for libtest
- fn run(self, builder: &Builder<'_>) {
- let compiler = self.compiler;
- let target_compiler = self.target_compiler;
- let target = self.target;
- builder.info(&format!("Copying stage{} test from stage{} ({} -> {} / {})",
- target_compiler.stage,
- compiler.stage,
- &compiler.host,
- target_compiler.host,
- target));
- add_to_sysroot(
- builder,
- &builder.sysroot_libdir(target_compiler, target),
- &builder.sysroot_libdir(target_compiler, compiler.host),
- &libtest_stamp(builder, compiler, target)
- );
- }
-}
-
#[derive(Debug, PartialOrd, Ord, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Rustc {
pub target: Interned<String>,
@@ -512,7 +389,7 @@ impl Step for Rustc {
let compiler = self.compiler;
let target = self.target;
- builder.ensure(Test { compiler, target });
+ builder.ensure(Std { compiler, target });
if builder.config.keep_stage.contains(&compiler.stage) {
builder.info("Warning: Using a potentially old librustc. This may not behave well.");
@@ -541,7 +418,7 @@ impl Step for Rustc {
}
// Ensure that build scripts and proc macros have a std / libproc_macro to link against.
- builder.ensure(Test {
+ builder.ensure(Std {
compiler: builder.compiler(self.compiler.stage, builder.config.build),
target: builder.config.build,
});
@@ -872,16 +749,6 @@ pub fn libstd_stamp(
builder.cargo_out(compiler, Mode::Std, target).join(".libstd.stamp")
}
-/// Cargo's output path for libtest in a given stage, compiled by a particular
-/// compiler for the specified target.
-pub fn libtest_stamp(
- builder: &Builder<'_>,
- compiler: Compiler,
- target: Interned<String>,
-) -> PathBuf {
- builder.cargo_out(compiler, Mode::Test, target).join(".libtest.stamp")
-}
-
/// Cargo's output path for librustc in a given stage, compiled by a particular
/// compiler for the specified target.
pub fn librustc_stamp(
diff --git a/src/bootstrap/dist.rs b/src/bootstrap/dist.rs
index bd012a887c26e..6893fbe9733dd 100644
--- a/src/bootstrap/dist.rs
+++ b/src/bootstrap/dist.rs
@@ -673,12 +673,7 @@ impl Step for Std {
if builder.hosts.iter().any(|t| t == target) {
builder.ensure(compile::Rustc { compiler, target });
} else {
- if builder.no_std(target) == Some(true) {
- // the `test` doesn't compile for no-std targets
- builder.ensure(compile::Std { compiler, target });
- } else {
- builder.ensure(compile::Test { compiler, target });
- }
+ builder.ensure(compile::Std { compiler, target });
}
let image = tmpdir(builder).join(format!("{}-{}-image", name, target));
diff --git a/src/bootstrap/doc.rs b/src/bootstrap/doc.rs
index 36229720e42cd..6ca1f1c60b631 100644
--- a/src/bootstrap/doc.rs
+++ b/src/bootstrap/doc.rs
@@ -478,138 +478,12 @@ impl Step for Std {
builder.run(&mut cargo);
builder.cp_r(&my_out, &out);
};
- for krate in &["alloc", "core", "std"] {
+ for krate in &["alloc", "core", "std", "proc_macro", "test"] {
run_cargo_rustdoc_for(krate);
}
}
}
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct Test {
- stage: u32,
- target: Interned<String>,
-}
-
-impl Step for Test {
- type Output = ();
- const DEFAULT: bool = true;
-
- fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
- let builder = run.builder;
- run.krate("test").default_condition(builder.config.docs)
- }
-
- fn make_run(run: RunConfig<'_>) {
- run.builder.ensure(Test {
- stage: run.builder.top_stage,
- target: run.target,
- });
- }
-
- /// Compile all libtest documentation.
- ///
- /// This will generate all documentation for libtest and its dependencies. This
- /// is largely just a wrapper around `cargo doc`.
- fn run(self, builder: &Builder<'_>) {
- let stage = self.stage;
- let target = self.target;
- builder.info(&format!("Documenting stage{} test ({})", stage, target));
- let out = builder.doc_out(target);
- t!(fs::create_dir_all(&out));
- let compiler = builder.compiler_for(stage, builder.config.build, target);
-
- // Build libstd docs so that we generate relative links
- builder.ensure(Std { stage, target });
-
- builder.ensure(compile::Test { compiler, target });
- let out_dir = builder.stage_out(compiler, Mode::Test)
- .join(target).join("doc");
-
- // See docs in std above for why we symlink
- let my_out = builder.crate_doc_out(target);
- t!(symlink_dir_force(&builder.config, &my_out, &out_dir));
-
- let mut cargo = builder.cargo(compiler, Mode::Test, target, "doc");
- compile::test_cargo(builder, &compiler, target, &mut cargo);
-
- cargo.arg("--no-deps")
- .arg("-p").arg("test")
- .env("RUSTDOC_RESOURCE_SUFFIX", crate::channel::CFG_RELEASE_NUM)
- .env("RUSTDOC_GENERATE_REDIRECT_PAGES", "1");
-
- builder.run(&mut cargo);
- builder.cp_r(&my_out, &out);
- }
-}
-
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub struct WhitelistedRustc {
- stage: u32,
- target: Interned<String>,
-}
-
-impl Step for WhitelistedRustc {
- type Output = ();
- const DEFAULT: bool = true;
- const ONLY_HOSTS: bool = true;
-
- fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
- let builder = run.builder;
- run.krate("rustc-main").default_condition(builder.config.docs)
- }
-
- fn make_run(run: RunConfig<'_>) {
- run.builder.ensure(WhitelistedRustc {
- stage: run.builder.top_stage,
- target: run.target,
- });
- }
-
- /// Generates whitelisted compiler crate documentation.
- ///
- /// This will generate all documentation for crates that are whitelisted
- /// to be included in the standard documentation. This documentation is
- /// included in the standard Rust documentation, so we should always
- /// document it and symlink to merge with the rest of the std and test
- /// documentation. We don't build other compiler documentation
- /// here as we want to be able to keep it separate from the standard
- /// documentation. This is largely just a wrapper around `cargo doc`.
- fn run(self, builder: &Builder<'_>) {
- let stage = self.stage;
- let target = self.target;
- builder.info(&format!("Documenting stage{} whitelisted compiler ({})", stage, target));
- let out = builder.doc_out(target);
- t!(fs::create_dir_all(&out));
- let compiler = builder.compiler_for(stage, builder.config.build, target);
-
- // Build libstd docs so that we generate relative links
- builder.ensure(Std { stage, target });
-
- builder.ensure(compile::Rustc { compiler, target });
- let out_dir = builder.stage_out(compiler, Mode::Rustc)
- .join(target).join("doc");
-
- // See docs in std above for why we symlink
- let my_out = builder.crate_doc_out(target);
- t!(symlink_dir_force(&builder.config, &my_out, &out_dir));
-
- let mut cargo = builder.cargo(compiler, Mode::Rustc, target, "doc");
- compile::rustc_cargo(builder, &mut cargo);
-
- // We don't want to build docs for internal compiler dependencies in this
- // step (there is another step for that). Therefore, we whitelist the crates
- // for which docs must be built.
- for krate in &["proc_macro"] {
- cargo.arg("-p").arg(krate)
- .env("RUSTDOC_RESOURCE_SUFFIX", crate::channel::CFG_RELEASE_NUM)
- .env("RUSTDOC_GENERATE_REDIRECT_PAGES", "1");
- }
-
- builder.run(&mut cargo);
- builder.cp_r(&my_out, &out);
- }
-}
-
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct Rustc {
stage: u32,
diff --git a/src/bootstrap/lib.rs b/src/bootstrap/lib.rs
index b72aa78f3de19..c0e0ad1a857b9 100644
--- a/src/bootstrap/lib.rs
+++ b/src/bootstrap/lib.rs
@@ -297,9 +297,6 @@ pub enum Mode {
/// Build the standard library, placing output in the "stageN-std" directory.
Std,
- /// Build libtest, placing output in the "stageN-test" directory.
- Test,
-
/// Build librustc, and compiler libraries, placing output in the "stageN-rustc" directory.
Rustc,
@@ -315,7 +312,6 @@ pub enum Mode {
/// Compile a tool which uses all libraries we compile (up to rustc).
/// Doesn't use the stage0 compiler libraries like "other", and includes
/// tools like rustdoc, cargo, rls, etc.
- ToolTest,
ToolStd,
ToolRustc,
}
@@ -536,11 +532,10 @@ impl Build {
fn stage_out(&self, compiler: Compiler, mode: Mode) -> PathBuf {
let suffix = match mode {
Mode::Std => "-std",
- Mode::Test => "-test",
Mode::Rustc => "-rustc",
Mode::Codegen => "-codegen",
Mode::ToolBootstrap => "-bootstrap-tools",
- Mode::ToolStd | Mode::ToolTest | Mode::ToolRustc => "-tools",
+ Mode::ToolStd | Mode::ToolRustc => "-tools",
};
self.out.join(&*compiler.host)
.join(format!("stage{}{}", compiler.stage, suffix))
diff --git a/src/bootstrap/test.rs b/src/bootstrap/test.rs
index c2c134bfd1d7d..0de73684c39bf 100644
--- a/src/bootstrap/test.rs
+++ b/src/bootstrap/test.rs
@@ -1040,21 +1040,10 @@ impl Step for Compiletest {
builder.ensure(compile::Rustc { compiler, target });
}
- if builder.no_std(target) == Some(true) {
- // the `test` doesn't compile for no-std targets
- builder.ensure(compile::Std { compiler, target });
- } else {
- builder.ensure(compile::Test { compiler, target });
- }
-
- if builder.no_std(target) == Some(true) {
- // for no_std run-make (e.g., thumb*),
- // we need a host compiler which is called by cargo.
- builder.ensure(compile::Std { compiler, target: compiler.host });
- }
+ builder.ensure(compile::Std { compiler, target });
+ // ensure that `libproc_macro` is available on the host.
+ builder.ensure(compile::Std { compiler, target: compiler.host });
- // HACK(eddyb) ensure that `libproc_macro` is available on the host.
- builder.ensure(compile::Test { compiler, target: compiler.host });
// Also provide `rust_test_helpers` for the host.
builder.ensure(native::TestHelpers { target: compiler.host });
@@ -1399,7 +1388,7 @@ impl Step for DocTest {
fn run(self, builder: &Builder<'_>) {
let compiler = self.compiler;
- builder.ensure(compile::Test {
+ builder.ensure(compile::Std {
compiler,
target: compiler.host,
});
@@ -1711,7 +1700,7 @@ impl Step for Crate {
fn should_run(mut run: ShouldRun<'_>) -> ShouldRun<'_> {
let builder = run.builder;
run = run.krate("test");
- for krate in run.builder.in_tree_crates("std") {
+ for krate in run.builder.in_tree_crates("test") {
if !(krate.name.starts_with("rustc_") && krate.name.ends_with("san")) {
run = run.path(krate.local_path(&builder).to_str().unwrap());
}
@@ -1735,14 +1724,9 @@ impl Step for Crate {
});
};
- for krate in builder.in_tree_crates("std") {
- if run.path.ends_with(&krate.local_path(&builder)) {
- make(Mode::Std, krate);
- }
- }
for krate in builder.in_tree_crates("test") {
if run.path.ends_with(&krate.local_path(&builder)) {
- make(Mode::Test, krate);
+ make(Mode::Std, krate);
}
}
}
@@ -1762,7 +1746,7 @@ impl Step for Crate {
let test_kind = self.test_kind;
let krate = self.krate;
- builder.ensure(compile::Test { compiler, target });
+ builder.ensure(compile::Std { compiler, target });
builder.ensure(RemoteCopyLibs { compiler, target });
// If we're not doing a full bootstrap but we're testing a stage2
@@ -1776,9 +1760,6 @@ impl Step for Crate {
Mode::Std => {
compile::std_cargo(builder, &compiler, target, &mut cargo);
}
- Mode::Test => {
- compile::test_cargo(builder, &compiler, target, &mut cargo);
- }
Mode::Rustc => {
builder.ensure(compile::Rustc { compiler, target });
compile::rustc_cargo(builder, &mut cargo);
@@ -1980,7 +1961,7 @@ impl Step for RemoteCopyLibs {
return;
}
- builder.ensure(compile::Test { compiler, target });
+ builder.ensure(compile::Std { compiler, target });
builder.info(&format!("REMOTE copy libs to emulator ({})", target));
t!(fs::create_dir_all(builder.out.join("tmp")));
diff --git a/src/bootstrap/tool.rs b/src/bootstrap/tool.rs
index df7eb7c455d02..54fe26f18e741 100644
--- a/src/bootstrap/tool.rs
+++ b/src/bootstrap/tool.rs
@@ -577,12 +577,6 @@ impl Step for Cargo {
}
fn run(self, builder: &Builder<'_>) -> PathBuf {
- // Cargo depends on procedural macros, so make sure the host
- // libstd/libproc_macro is available.
- builder.ensure(compile::Test {
- compiler: self.compiler,
- target: builder.config.build,
- });
builder.ensure(ToolBuild {
compiler: self.compiler,
target: self.target,
@@ -650,31 +644,10 @@ macro_rules! tool_extended {
tool_extended!((self, builder),
Cargofmt, rustfmt, "src/tools/rustfmt", "cargo-fmt", {};
- CargoClippy, clippy, "src/tools/clippy", "cargo-clippy", {
- // Clippy depends on procedural macros, so make sure that's built for
- // the compiler itself.
- builder.ensure(compile::Test {
- compiler: self.compiler,
- target: builder.config.build,
- });
- };
- Clippy, clippy, "src/tools/clippy", "clippy-driver", {
- // Clippy depends on procedural macros, so make sure that's built for
- // the compiler itself.
- builder.ensure(compile::Test {
- compiler: self.compiler,
- target: builder.config.build,
- });
- };
+ CargoClippy, clippy, "src/tools/clippy", "cargo-clippy", {};
+ Clippy, clippy, "src/tools/clippy", "clippy-driver", {};
Miri, miri, "src/tools/miri", "miri", {};
- CargoMiri, miri, "src/tools/miri", "cargo-miri", {
- // Miri depends on procedural macros, so make sure that's built for
- // the compiler itself.
- builder.ensure(compile::Test {
- compiler: self.compiler,
- target: builder.config.build,
- });
- };
+ CargoMiri, miri, "src/tools/miri", "cargo-miri", {};
Rls, rls, "src/tools/rls", "rls", {
let clippy = builder.ensure(Clippy {
compiler: self.compiler,
@@ -684,12 +657,6 @@ tool_extended!((self, builder),
if clippy.is_some() {
self.extra_features.push("clippy".to_owned());
}
- // RLS depends on procedural macros, so make sure that's built for
- // the compiler itself.
- builder.ensure(compile::Test {
- compiler: self.compiler,
- target: builder.config.build,
- });
};
Rustfmt, rustfmt, "src/tools/rustfmt", "rustfmt", {};
);
diff --git a/src/libproc_macro/Cargo.toml b/src/libproc_macro/Cargo.toml
index b3d0ee94f0e12..187bdac80019d 100644
--- a/src/libproc_macro/Cargo.toml
+++ b/src/libproc_macro/Cargo.toml
@@ -6,3 +6,6 @@ edition = "2018"
[lib]
path = "lib.rs"
+
+[dependencies]
+std = { path = "../libstd" }
diff --git a/src/librustc_lexer/src/lib.rs b/src/librustc_lexer/src/lib.rs
index afef307a0ed37..41b47befaf141 100644
--- a/src/librustc_lexer/src/lib.rs
+++ b/src/librustc_lexer/src/lib.rs
@@ -23,9 +23,6 @@ pub enum TokenKind {
Lifetime { starts_with_number: bool },
Semi,
Comma,
- DotDotDot,
- DotDotEq,
- DotDot,
Dot,
OpenParen,
CloseParen,
@@ -37,41 +34,19 @@ pub enum TokenKind {
Pound,
Tilde,
Question,
- ColonColon,
Colon,
Dollar,
- EqEq,
Eq,
- FatArrow,
- Ne,
Not,
- Le,
- LArrow,
Lt,
- ShlEq,
- Shl,
- Ge,
Gt,
- ShrEq,
- Shr,
- RArrow,
Minus,
- MinusEq,
And,
- AndAnd,
- AndEq,
Or,
- OrOr,
- OrEq,
- PlusEq,
Plus,
- StarEq,
Star,
- SlashEq,
Slash,
- CaretEq,
Caret,
- PercentEq,
Percent,
Unknown,
}
@@ -135,13 +110,7 @@ impl Cursor<'_> {
'/' => match self.nth_char(0) {
'/' => self.line_comment(),
'*' => self.block_comment(),
- _ => {
- if self.eat_assign() {
- SlashEq
- } else {
- Slash
- }
- }
+ _ => Slash,
},
c if character_properties::is_whitespace(c) => self.whitespace(),
'r' => match (self.nth_char(0), self.nth_char(1)) {
@@ -199,22 +168,7 @@ impl Cursor<'_> {
}
';' => Semi,
',' => Comma,
- '.' => {
- if self.nth_char(0) == '.' {
- self.bump();
- if self.nth_char(0) == '.' {
- self.bump();
- DotDotDot
- } else if self.nth_char(0) == '=' {
- self.bump();
- DotDotEq
- } else {
- DotDot
- }
- } else {
- Dot
- }
- }
+ '.' => Dot,
'(' => OpenParen,
')' => CloseParen,
'{' => OpenBrace,
@@ -225,112 +179,19 @@ impl Cursor<'_> {
'#' => Pound,
'~' => Tilde,
'?' => Question,
- ':' => {
- if self.nth_char(0) == ':' {
- self.bump();
- ColonColon
- } else {
- Colon
- }
- }
+ ':' => Colon,
'$' => Dollar,
- '=' => {
- if self.nth_char(0) == '=' {
- self.bump();
- EqEq
- } else if self.nth_char(0) == '>' {
- self.bump();
- FatArrow
- } else {
- Eq
- }
- }
- '!' => {
- if self.nth_char(0) == '=' {
- self.bump();
- Ne
- } else {
- Not
- }
- }
- '<' => match self.nth_char(0) {
- '=' => {
- self.bump();
- Le
- }
- '<' => {
- self.bump();
- if self.eat_assign() { ShlEq } else { Shl }
- }
- '-' => {
- self.bump();
- LArrow
- }
- _ => Lt,
- },
- '>' => match self.nth_char(0) {
- '=' => {
- self.bump();
- Ge
- }
- '>' => {
- self.bump();
- if self.eat_assign() { ShrEq } else { Shr }
- }
- _ => Gt,
- },
- '-' => {
- if self.nth_char(0) == '>' {
- self.bump();
- RArrow
- } else {
- if self.eat_assign() { MinusEq } else { Minus }
- }
- }
- '&' => {
- if self.nth_char(0) == '&' {
- self.bump();
- AndAnd
- } else {
- if self.eat_assign() { AndEq } else { And }
- }
- }
- '|' => {
- if self.nth_char(0) == '|' {
- self.bump();
- OrOr
- } else {
- if self.eat_assign() { OrEq } else { Or }
- }
- }
- '+' => {
- if self.eat_assign() {
- PlusEq
- } else {
- Plus
- }
- }
- '*' => {
- if self.eat_assign() {
- StarEq
- } else {
- Star
- }
- }
- '^' => {
- if self.eat_assign() {
- CaretEq
- } else {
- Caret
- }
- }
- '%' => {
- if self.eat_assign() {
- PercentEq
- } else {
- Percent
- }
- }
+ '=' => Eq,
+ '!' => Not,
+ '<' => Lt,
+ '>' => Gt,
+ '-' => Minus,
+ '&' => And,
+ '|' => Or,
+ '+' => Plus,
+ '*' => Star,
+ '^' => Caret,
+ '%' => Percent,
'\'' => self.lifetime_or_char(),
'"' => {
let terminated = self.double_quoted_string();
@@ -643,15 +504,6 @@ impl Cursor<'_> {
self.bump();
}
}
-
- fn eat_assign(&mut self) -> bool {
- if self.nth_char(0) == '=' {
- self.bump();
- true
- } else {
- false
- }
- }
}
pub mod character_properties {
diff --git a/src/librustc_mir/interpret/cast.rs b/src/librustc_mir/interpret/cast.rs
index 26cfbfe53a35c..210647ac1e9a3 100644
--- a/src/librustc_mir/interpret/cast.rs
+++ b/src/librustc_mir/interpret/cast.rs
@@ -1,4 +1,4 @@
-use rustc::ty::{self, Ty, TypeAndMut};
+use rustc::ty::{self, Ty, TypeAndMut, TypeFoldable};
use rustc::ty::layout::{self, TyLayout, Size};
use rustc::ty::adjustment::{PointerCast};
use syntax::ast::FloatTy;
@@ -36,15 +36,15 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
// The src operand does not matter, just its type
match src.layout.ty.sty {
ty::FnDef(def_id, substs) => {
+ // All reifications must be monomorphic, bail out otherwise.
+ if src.layout.ty.needs_subst() {
+ throw_inval!(TooGeneric);
+ }
+
if self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
bug!("reifying a fn ptr that requires const arguments");
}
- let instance = ty::Instance::resolve(
- *self.tcx,
- self.param_env,
- def_id,
- substs,
- ).ok_or_else(|| err_inval!(TooGeneric))?;
+ let instance = self.resolve(def_id, substs)?;
let fn_ptr = self.memory.create_fn_alloc(FnVal::Instance(instance));
self.write_scalar(Scalar::Ptr(fn_ptr.into()), dest)?;
}
@@ -67,7 +67,11 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
// The src operand does not matter, just its type
match src.layout.ty.sty {
ty::Closure(def_id, substs) => {
- let substs = self.subst_and_normalize_erasing_regions(substs)?;
+ // All reifications must be monomorphic, bail out otherwise.
+ if src.layout.ty.needs_subst() {
+ throw_inval!(TooGeneric);
+ }
+
let instance = ty::Instance::resolve_closure(
*self.tcx,
def_id,
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
index 6f4227ed34cc4..6f48396cdd7cf 100644
--- a/src/librustc_mir/interpret/eval_context.rs
+++ b/src/librustc_mir/interpret/eval_context.rs
@@ -9,7 +9,7 @@ use rustc::mir;
use rustc::ty::layout::{
self, Size, Align, HasDataLayout, LayoutOf, TyLayout
};
-use rustc::ty::subst::{Subst, SubstsRef};
+use rustc::ty::subst::SubstsRef;
use rustc::ty::{self, Ty, TyCtxt, TypeFoldable};
use rustc::ty::query::TyCtxtAt;
use rustc_data_structures::indexed_vec::IndexVec;
@@ -291,41 +291,6 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
ty.is_freeze(*self.tcx, self.param_env, DUMMY_SP)
}
- pub(super) fn subst_and_normalize_erasing_regions<T: TypeFoldable<'tcx>>(
- &self,
- substs: T,
- ) -> InterpResult<'tcx, T> {
- match self.stack.last() {
- Some(frame) => Ok(self.tcx.subst_and_normalize_erasing_regions(
- frame.instance.substs,
- self.param_env,
- &substs,
- )),
- None => if substs.needs_subst() {
- throw_inval!(TooGeneric)
- } else {
- Ok(substs)
- },
- }
- }
-
- pub(super) fn resolve(
- &self,
- def_id: DefId,
- substs: SubstsRef<'tcx>
- ) -> InterpResult<'tcx, ty::Instance<'tcx>> {
- trace!("resolve: {:?}, {:#?}", def_id, substs);
- trace!("param_env: {:#?}", self.param_env);
- let substs = self.subst_and_normalize_erasing_regions(substs)?;
- trace!("substs: {:#?}", substs);
- ty::Instance::resolve(
- *self.tcx,
- self.param_env,
- def_id,
- substs,
- ).ok_or_else(|| err_inval!(TooGeneric).into())
- }
-
pub fn load_mir(
&self,
instance: ty::InstanceDef<'tcx>,
@@ -349,34 +314,34 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
}
}
- pub(super) fn monomorphize<T: TypeFoldable<'tcx> + Subst<'tcx>>(
+ /// Call this on things you got out of the MIR (so it is as generic as the current
+ /// stack frame), to bring it into the proper environment for this interpreter.
+ pub(super) fn subst_from_frame_and_normalize_erasing_regions<T: TypeFoldable<'tcx>>(
&self,
- t: T,
- ) -> InterpResult<'tcx, T> {
- match self.stack.last() {
- Some(frame) => Ok(self.monomorphize_with_substs(t, frame.instance.substs)?),
- None => if t.needs_subst() {
- throw_inval!(TooGeneric)
- } else {
- Ok(t)
- },
- }
+ value: T,
+ ) -> T {
+ self.tcx.subst_and_normalize_erasing_regions(
+ self.frame().instance.substs,
+ self.param_env,
+ &value,
+ )
}
- fn monomorphize_with_substs<T: TypeFoldable<'tcx> + Subst<'tcx>>(
+ /// The `substs` are assumed to already be in our interpreter "universe" (param_env).
+ pub(super) fn resolve(
&self,
- t: T,
+ def_id: DefId,
substs: SubstsRef<'tcx>
- ) -> InterpResult<'tcx, T> {
- // miri doesn't care about lifetimes, and will choke on some crazy ones
- // let's simply get rid of them
- let substituted = t.subst(*self.tcx, substs);
-
- if substituted.needs_subst() {
- throw_inval!(TooGeneric)
- }
-
- Ok(self.tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), substituted))
+ ) -> InterpResult<'tcx, ty::Instance<'tcx>> {
+ trace!("resolve: {:?}, {:#?}", def_id, substs);
+ trace!("param_env: {:#?}", self.param_env);
+ trace!("substs: {:#?}", substs);
+ ty::Instance::resolve(
+ *self.tcx,
+ self.param_env,
+ def_id,
+ substs,
+ ).ok_or_else(|| err_inval!(TooGeneric).into())
}
pub fn layout_of_local(
@@ -391,7 +356,11 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
None => {
let layout = crate::interpret::operand::from_known_layout(layout, || {
let local_ty = frame.body.local_decls[local].ty;
- let local_ty = self.monomorphize_with_substs(local_ty, frame.instance.substs)?;
+ let local_ty = self.tcx.subst_and_normalize_erasing_regions(
+ frame.instance.substs,
+ self.param_env,
+ &local_ty,
+ );
self.layout_of(local_ty)
})?;
if let Some(state) = frame.locals.get(local) {
diff --git a/src/librustc_mir/interpret/operand.rs b/src/librustc_mir/interpret/operand.rs
index 726ae6fab1009..7a545e8ad6f79 100644
--- a/src/librustc_mir/interpret/operand.rs
+++ b/src/librustc_mir/interpret/operand.rs
@@ -522,7 +522,10 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
Move(ref place) =>
self.eval_place_to_op(place, layout)?,
- Constant(ref constant) => self.eval_const_to_op(constant.literal, layout)?,
+ Constant(ref constant) => {
+ let val = self.subst_from_frame_and_normalize_erasing_regions(constant.literal);
+ self.eval_const_to_op(val, layout)?
+ }
};
trace!("{:?}: {:?}", mir_op, *op);
Ok(op)
@@ -540,6 +543,8 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
// Used when the miri-engine runs into a constant and for extracting information from constants
// in patterns via the `const_eval` module
+ /// The `val` and `layout` are assumed to already be in our interpreter
+ /// "universe" (param_env).
crate fn eval_const_to_op(
&self,
val: &'tcx ty::Const<'tcx>,
@@ -552,7 +557,6 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
// Early-return cases.
match val.val {
ConstValue::Param(_) =>
- // FIXME(oli-obk): try to monomorphize
throw_inval!(TooGeneric),
ConstValue::Unevaluated(def_id, substs) => {
let instance = self.resolve(def_id, substs)?;
@@ -565,7 +569,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
}
// Other cases need layout.
let layout = from_known_layout(layout, || {
- self.layout_of(self.monomorphize(val.ty)?)
+ self.layout_of(val.ty)
})?;
let op = match val.val {
ConstValue::ByRef { alloc, offset } => {
diff --git a/src/librustc_mir/interpret/place.rs b/src/librustc_mir/interpret/place.rs
index ef9f20d5c9724..85f9cbd37589a 100644
--- a/src/librustc_mir/interpret/place.rs
+++ b/src/librustc_mir/interpret/place.rs
@@ -640,8 +640,11 @@ where
// their layout on return.
PlaceTy {
place: *return_place,
- layout: self
- .layout_of(self.monomorphize(self.frame().body.return_ty())?)?,
+ layout: self.layout_of(
+ self.subst_from_frame_and_normalize_erasing_regions(
+ self.frame().body.return_ty()
+ )
+ )?,
}
}
None => throw_unsup!(InvalidNullPointerUsage),
diff --git a/src/librustc_mir/interpret/step.rs b/src/librustc_mir/interpret/step.rs
index b010bf049dd24..ca4da451a1f2d 100644
--- a/src/librustc_mir/interpret/step.rs
+++ b/src/librustc_mir/interpret/step.rs
@@ -254,7 +254,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
}
NullaryOp(mir::NullOp::SizeOf, ty) => {
- let ty = self.monomorphize(ty)?;
+ let ty = self.subst_from_frame_and_normalize_erasing_regions(ty);
let layout = self.layout_of(ty)?;
assert!(!layout.is_unsized(),
"SizeOf nullary MIR operator called for unsized type");
diff --git a/src/librustc_mir/interpret/traits.rs b/src/librustc_mir/interpret/traits.rs
index e55b0d0fb1f2a..a2fc75739ffa0 100644
--- a/src/librustc_mir/interpret/traits.rs
+++ b/src/librustc_mir/interpret/traits.rs
@@ -1,4 +1,4 @@
-use rustc::ty::{self, Ty, Instance};
+use rustc::ty::{self, Ty, Instance, TypeFoldable};
use rustc::ty::layout::{Size, Align, LayoutOf};
use rustc::mir::interpret::{Scalar, Pointer, InterpResult, PointerArithmetic,};
@@ -20,6 +20,11 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let (ty, poly_trait_ref) = self.tcx.erase_regions(&(ty, poly_trait_ref));
+ // All vtables must be monomorphic, bail out otherwise.
+ if ty.needs_subst() || poly_trait_ref.needs_subst() {
+ throw_inval!(TooGeneric);
+ }
+
if let Some(&vtable) = self.vtables.get(&(ty, poly_trait_ref)) {
// This means we guarantee that there are no duplicate vtables, we will
// always use the same vtable for the same (Type, Trait) combination.
@@ -77,7 +82,6 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
for (i, method) in methods.iter().enumerate() {
if let Some((def_id, substs)) = *method {
// resolve for vtable: insert shims where needed
- let substs = self.subst_and_normalize_erasing_regions(substs)?;
let instance = ty::Instance::resolve_for_vtable(
*self.tcx,
self.param_env,
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
index e979bc7bf25b5..312a598af02bf 100644
--- a/src/librustc_typeck/collect.rs
+++ b/src/librustc_typeck/collect.rs
@@ -900,6 +900,20 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::Generics {
let parent_id = tcx.hir().get_parent_item(hir_id);
Some(tcx.hir().local_def_id(parent_id))
}
+ // FIXME(#43408) enable this in all cases when we get lazy normalization.
+ Node::AnonConst(&anon_const) => {
+ // HACK(eddyb) this provides the correct generics when the workaround
+ // for a const parameter `AnonConst` is being used elsewhere, as then
+ // there won't be the kind of cyclic dependency blocking #43408.
+ let expr = &tcx.hir().body(anon_const.body).value;
+ let icx = ItemCtxt::new(tcx, def_id);
+ if AstConv::const_param_def_id(&icx, expr).is_some() {
+ let parent_id = tcx.hir().get_parent_item(hir_id);
+ Some(tcx.hir().local_def_id(parent_id))
+ } else {
+ None
+ }
+ }
Node::Expr(&hir::Expr {
node: hir::ExprKind::Closure(..),
..
diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs
index bdf468a52bb39..66add869359d8 100644
--- a/src/libsyntax/parse/lexer/mod.rs
+++ b/src/libsyntax/parse/lexer/mod.rs
@@ -273,9 +273,6 @@ impl<'a> StringReader<'a> {
}
rustc_lexer::TokenKind::Semi => token::Semi,
rustc_lexer::TokenKind::Comma => token::Comma,
- rustc_lexer::TokenKind::DotDotDot => token::DotDotDot,
- rustc_lexer::TokenKind::DotDotEq => token::DotDotEq,
- rustc_lexer::TokenKind::DotDot => token::DotDot,
rustc_lexer::TokenKind::Dot => token::Dot,
rustc_lexer::TokenKind::OpenParen => token::OpenDelim(token::Paren),
rustc_lexer::TokenKind::CloseParen => token::CloseDelim(token::Paren),
@@ -287,42 +284,20 @@ impl<'a> StringReader<'a> {
rustc_lexer::TokenKind::Pound => token::Pound,
rustc_lexer::TokenKind::Tilde => token::Tilde,
rustc_lexer::TokenKind::Question => token::Question,
- rustc_lexer::TokenKind::ColonColon => token::ModSep,
rustc_lexer::TokenKind::Colon => token::Colon,
rustc_lexer::TokenKind::Dollar => token::Dollar,
- rustc_lexer::TokenKind::EqEq => token::EqEq,
rustc_lexer::TokenKind::Eq => token::Eq,
- rustc_lexer::TokenKind::FatArrow => token::FatArrow,
- rustc_lexer::TokenKind::Ne => token::Ne,
rustc_lexer::TokenKind::Not => token::Not,
- rustc_lexer::TokenKind::Le => token::Le,
- rustc_lexer::TokenKind::LArrow => token::LArrow,
rustc_lexer::TokenKind::Lt => token::Lt,
- rustc_lexer::TokenKind::ShlEq => token::BinOpEq(token::Shl),
- rustc_lexer::TokenKind::Shl => token::BinOp(token::Shl),
- rustc_lexer::TokenKind::Ge => token::Ge,
rustc_lexer::TokenKind::Gt => token::Gt,
- rustc_lexer::TokenKind::ShrEq => token::BinOpEq(token::Shr),
- rustc_lexer::TokenKind::Shr => token::BinOp(token::Shr),
- rustc_lexer::TokenKind::RArrow => token::RArrow,
rustc_lexer::TokenKind::Minus => token::BinOp(token::Minus),
- rustc_lexer::TokenKind::MinusEq => token::BinOpEq(token::Minus),
rustc_lexer::TokenKind::And => token::BinOp(token::And),
- rustc_lexer::TokenKind::AndEq => token::BinOpEq(token::And),
- rustc_lexer::TokenKind::AndAnd => token::AndAnd,
rustc_lexer::TokenKind::Or => token::BinOp(token::Or),
- rustc_lexer::TokenKind::OrEq => token::BinOpEq(token::Or),
- rustc_lexer::TokenKind::OrOr => token::OrOr,
rustc_lexer::TokenKind::Plus => token::BinOp(token::Plus),
- rustc_lexer::TokenKind::PlusEq => token::BinOpEq(token::Plus),
rustc_lexer::TokenKind::Star => token::BinOp(token::Star),
- rustc_lexer::TokenKind::StarEq => token::BinOpEq(token::Star),
rustc_lexer::TokenKind::Slash => token::BinOp(token::Slash),
- rustc_lexer::TokenKind::SlashEq => token::BinOpEq(token::Slash),
rustc_lexer::TokenKind::Caret => token::BinOp(token::Caret),
- rustc_lexer::TokenKind::CaretEq => token::BinOpEq(token::Caret),
rustc_lexer::TokenKind::Percent => token::BinOp(token::Percent),
- rustc_lexer::TokenKind::PercentEq => token::BinOpEq(token::Percent),
rustc_lexer::TokenKind::Unknown => {
let c = self.str_from(start).chars().next().unwrap();
diff --git a/src/libsyntax/parse/lexer/tests.rs b/src/libsyntax/parse/lexer/tests.rs
index 94570140996f1..a915aa42fd15a 100644
--- a/src/libsyntax/parse/lexer/tests.rs
+++ b/src/libsyntax/parse/lexer/tests.rs
@@ -75,42 +75,50 @@ fn mk_lit(kind: token::LitKind, symbol: &str, suffix: Option<&str>) -> TokenKind
}
#[test]
-fn doublecolonparsing() {
+fn doublecolon_parsing() {
with_default_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
- check_tokenization(setup(&sm, &sh, "a b".to_string()),
- vec![mk_ident("a"), token::Whitespace, mk_ident("b")]);
+ check_tokenization(
+ setup(&sm, &sh, "a b".to_string()),
+ vec![mk_ident("a"), token::Whitespace, mk_ident("b")],
+ );
})
}
#[test]
-fn dcparsing_2() {
+fn doublecolon_parsing_2() {
with_default_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
- check_tokenization(setup(&sm, &sh, "a::b".to_string()),
- vec![mk_ident("a"), token::ModSep, mk_ident("b")]);
+ check_tokenization(
+ setup(&sm, &sh, "a::b".to_string()),
+ vec![mk_ident("a"), token::Colon, token::Colon, mk_ident("b")],
+ );
})
}
#[test]
-fn dcparsing_3() {
+fn doublecolon_parsing_3() {
with_default_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
- check_tokenization(setup(&sm, &sh, "a ::b".to_string()),
- vec![mk_ident("a"), token::Whitespace, token::ModSep, mk_ident("b")]);
+ check_tokenization(
+ setup(&sm, &sh, "a ::b".to_string()),
+ vec![mk_ident("a"), token::Whitespace, token::Colon, token::Colon, mk_ident("b")],
+ );
})
}
#[test]
-fn dcparsing_4() {
+fn doublecolon_parsing_4() {
with_default_globals(|| {
let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let sh = mk_sess(sm.clone());
- check_tokenization(setup(&sm, &sh, "a:: b".to_string()),
- vec![mk_ident("a"), token::ModSep, token::Whitespace, mk_ident("b")]);
+ check_tokenization(
+ setup(&sm, &sh, "a:: b".to_string()),
+ vec![mk_ident("a"), token::Colon, token::Colon, token::Whitespace, mk_ident("b")],
+ );
})
}
diff --git a/src/libsyntax/parse/lexer/tokentrees.rs b/src/libsyntax/parse/lexer/tokentrees.rs
index 37e67a2729e6d..e5ba7e45309dd 100644
--- a/src/libsyntax/parse/lexer/tokentrees.rs
+++ b/src/libsyntax/parse/lexer/tokentrees.rs
@@ -39,29 +39,29 @@ struct TokenTreesReader<'a> {
impl<'a> TokenTreesReader<'a> {
// Parse a stream of tokens into a list of `TokenTree`s, up to an `Eof`.
fn parse_all_token_trees(&mut self) -> PResult<'a, TokenStream> {
- let mut tts = Vec::new();
+ let mut buf = TokenStreamBuilder::default();
self.real_token();
while self.token != token::Eof {
- tts.push(self.parse_token_tree()?);
+ buf.push(self.parse_token_tree()?);
}
- Ok(TokenStream::new(tts))
+ Ok(buf.into_token_stream())
}
// Parse a stream of tokens into a list of `TokenTree`s, up to a `CloseDelim`.
fn parse_token_trees_until_close_delim(&mut self) -> TokenStream {
- let mut tts = vec![];
+ let mut buf = TokenStreamBuilder::default();
loop {
if let token::CloseDelim(..) = self.token.kind {
- return TokenStream::new(tts);
+ return buf.into_token_stream();
}
match self.parse_token_tree() {
- Ok(tree) => tts.push(tree),
+ Ok(tree) => buf.push(tree),
Err(mut e) => {
e.emit();
- return TokenStream::new(tts);
+ return buf.into_token_stream();
}
}
}
@@ -223,8 +223,32 @@ impl<'a> TokenTreesReader<'a> {
_ => {
self.token = token;
return;
- },
+ }
+ }
+ }
+ }
+}
+
+#[derive(Default)]
+struct TokenStreamBuilder {
+ buf: Vec<TreeAndJoint>,
+}
+
+impl TokenStreamBuilder {
+ fn push(&mut self, (tree, joint): TreeAndJoint) {
+ if let Some((TokenTree::Token(prev_token), Joint)) = self.buf.last() {
+ if let TokenTree::Token(token) = &tree {
+ if let Some(glued) = prev_token.glue(token) {
+ self.buf.pop();
+ self.buf.push((TokenTree::Token(glued), joint));
+ return;
+ }
}
}
+ self.buf.push((tree, joint))
+ }
+
+ fn into_token_stream(self) -> TokenStream {
+ TokenStream::new(self.buf)
}
}
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index be800b4de66af..1865f925165bd 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -551,7 +551,7 @@ impl Token {
}
}
- crate fn glue(self, joint: Token) -> Option<Token> {
+ crate fn glue(&self, joint: &Token) -> Option<Token> {
let kind = match self.kind {
Eq => match joint.kind {
Eq => EqEq,
diff --git a/src/libsyntax/tokenstream.rs b/src/libsyntax/tokenstream.rs
index 6ff8898fe2162..09a1b93c7bb19 100644
--- a/src/libsyntax/tokenstream.rs
+++ b/src/libsyntax/tokenstream.rs
@@ -414,7 +414,7 @@ impl TokenStreamBuilder {
let last_tree_if_joint = self.0.last().and_then(TokenStream::last_tree_if_joint);
if let Some(TokenTree::Token(last_token)) = last_tree_if_joint {
if let Some((TokenTree::Token(token), is_joint)) = stream.first_tree_and_joint() {
- if let Some(glued_tok) = last_token.glue(token) {
+ if let Some(glued_tok) = last_token.glue(&token) {
let last_stream = self.0.pop().unwrap();
self.push_all_but_last_tree(&last_stream);
let glued_tt = TokenTree::Token(glued_tok);
diff --git a/src/libterm/Cargo.toml b/src/libterm/Cargo.toml
index 4eba9a9d79cc4..2931e0bda9518 100644
--- a/src/libterm/Cargo.toml
+++ b/src/libterm/Cargo.toml
@@ -5,6 +5,8 @@ version = "0.0.0"
edition = "2018"
[lib]
-name = "term"
path = "lib.rs"
-crate-type = ["dylib", "rlib"]
+
+[dependencies]
+core = { path = "../libcore" }
+std = { path = "../libstd" }
diff --git a/src/libtest/Cargo.toml b/src/libtest/Cargo.toml
index a72e4c7050289..44eed462888ac 100644
--- a/src/libtest/Cargo.toml
+++ b/src/libtest/Cargo.toml
@@ -10,8 +10,21 @@ path = "lib.rs"
crate-type = ["dylib", "rlib"]
[dependencies]
-getopts = "0.2.19"
+getopts = { version = "0.2.21", features = ['rustc-dep-of-std'] }
term = { path = "../libterm" }
+std = { path = "../libstd" }
+core = { path = "../libcore" }
+libc = { version = "0.2", default-features = false }
+panic_unwind = { path = "../libpanic_unwind" }
# not actually used but needed to always have proc_macro in the sysroot
proc_macro = { path = "../libproc_macro" }
+
+# Forward features to the `std` crate as necessary
+[features]
+backtrace = ["std/backtrace"]
+compiler-builtins-c = ["std/compiler-builtins-c"]
+llvm-libunwind = ["std/llvm-libunwind"]
+panic-unwind = ["std/panic_unwind"]
+panic_immediate_abort = ["std/panic_immediate_abort"]
+profiler = ["std/profiler"]
diff --git a/src/test/ui/const-generics/issue-61432.rs b/src/test/ui/const-generics/issue-61432.rs
new file mode 100644
index 0000000000000..832095ce54206
--- /dev/null
+++ b/src/test/ui/const-generics/issue-61432.rs
@@ -0,0 +1,17 @@
+// run-pass
+
+#![feature(const_generics)]
+//~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash
+
+fn promote<const N: i32>() {
+ // works:
+ //
+ // let n = N;
+ // &n;
+
+ &N;
+}
+
+fn main() {
+ promote::<0>();
+}
diff --git a/src/test/ui/const-generics/issue-61432.stderr b/src/test/ui/const-generics/issue-61432.stderr
new file mode 100644
index 0000000000000..33f77b028104e
--- /dev/null
+++ b/src/test/ui/const-generics/issue-61432.stderr
@@ -0,0 +1,8 @@
+warning: the feature `const_generics` is incomplete and may cause the compiler to crash
+ --> $DIR/issue-61432.rs:3:12
+ |
+LL | #![feature(const_generics)]
+ | ^^^^^^^^^^^^^^
+ |
+ = note: `#[warn(incomplete_features)]` on by default
+
diff --git a/src/test/ui/consts/too_generic_eval_ice.rs b/src/test/ui/consts/too_generic_eval_ice.rs
new file mode 100644
index 0000000000000..7a299169bc4e1
--- /dev/null
+++ b/src/test/ui/consts/too_generic_eval_ice.rs
@@ -0,0 +1,13 @@
+pub struct Foo<A, B>(A, B);
+
+impl<A, B> Foo<A, B> {
+ const HOST_SIZE: usize = std::mem::size_of::<B>();
+
+ pub fn crash() -> bool {
+ [5; Self::HOST_SIZE] == [6; 0] //~ ERROR no associated item named `HOST_SIZE`
+ //~^ the size for values of type `A` cannot be known
+ //~| the size for values of type `B` cannot be known
+ }
+}
+
+fn main() {}
diff --git a/src/test/ui/consts/too_generic_eval_ice.stderr b/src/test/ui/consts/too_generic_eval_ice.stderr
new file mode 100644
index 0000000000000..eef79421270ce
--- /dev/null
+++ b/src/test/ui/consts/too_generic_eval_ice.stderr
@@ -0,0 +1,47 @@
+error[E0599]: no associated item named `HOST_SIZE` found for type `Foo<A, B>` in the current scope
+ --> $DIR/too_generic_eval_ice.rs:7:19
+ |
+LL | pub struct Foo<A, B>(A, B);
+ | --------------------------- associated item `HOST_SIZE` not found for this
+...
+LL | [5; Self::HOST_SIZE] == [6; 0]
+ | ^^^^^^^^^ associated item not found in `Foo<A, B>`
+ |
+ = note: the method `HOST_SIZE` exists but the following trait bounds were not satisfied:
+ `A : std::marker::Sized`
+ `B : std::marker::Sized`
+
+error[E0277]: the size for values of type `A` cannot be known at compilation time
+ --> $DIR/too_generic_eval_ice.rs:7:13
+ |
+LL | [5; Self::HOST_SIZE] == [6; 0]
+ | ^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+ |
+ = help: the trait `std::marker::Sized` is not implemented for `A`
+ = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
+ = help: consider adding a `where A: std::marker::Sized` bound
+note: required by `Foo`
+ --> $DIR/too_generic_eval_ice.rs:1:1
+ |
+LL | pub struct Foo<A, B>(A, B);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0277]: the size for values of type `B` cannot be known at compilation time
+ --> $DIR/too_generic_eval_ice.rs:7:13
+ |
+LL | [5; Self::HOST_SIZE] == [6; 0]
+ | ^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+ |
+ = help: the trait `std::marker::Sized` is not implemented for `B`
+ = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
+ = help: consider adding a `where B: std::marker::Sized` bound
+note: required by `Foo`
+ --> $DIR/too_generic_eval_ice.rs:1:1
+ |
+LL | pub struct Foo<A, B>(A, B);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0277, E0599.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/src/tools/rustc-std-workspace-std/Cargo.toml b/src/tools/rustc-std-workspace-std/Cargo.toml
new file mode 100644
index 0000000000000..ce1644809dbe6
--- /dev/null
+++ b/src/tools/rustc-std-workspace-std/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "rustc-std-workspace-std"
+version = "1.0.0"
+authors = ["Alex Crichton <alex@alexcrichton.com>"]
+license = 'MIT OR Apache-2.0'
+description = """
+Hack for the compiler's own build system
+"""
+edition = "2018"
+
+[lib]
+path = "lib.rs"
+
+[dependencies]
+std = { path = "../../libstd" }
diff --git a/src/tools/rustc-std-workspace-std/README.md b/src/tools/rustc-std-workspace-std/README.md
new file mode 100644
index 0000000000000..2228907f304c4
--- /dev/null
+++ b/src/tools/rustc-std-workspace-std/README.md
@@ -0,0 +1,3 @@
+# The `rustc-std-workspace-std` crate
+
+See documentation for the `rustc-std-workspace-core` crate.
diff --git a/src/tools/rustc-std-workspace-std/lib.rs b/src/tools/rustc-std-workspace-std/lib.rs
new file mode 100644
index 0000000000000..f40d09cafbb47
--- /dev/null
+++ b/src/tools/rustc-std-workspace-std/lib.rs
@@ -0,0 +1 @@
+pub use std::*;
diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index de54eb8f57312..e07a07234c71e 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -90,15 +90,18 @@ const WHITELIST: &[Crate<'_>] = &[
Crate("crossbeam-epoch"),
Crate("crossbeam-utils"),
Crate("datafrog"),
+ Crate("dlmalloc"),
Crate("either"),
Crate("ena"),
Crate("env_logger"),
Crate("filetime"),
Crate("flate2"),
+ Crate("fortanix-sgx-abi"),
Crate("fuchsia-zircon"),
Crate("fuchsia-zircon-sys"),
Crate("getopts"),
Crate("getrandom"),
+ Crate("hashbrown"),
Crate("humantime"),
Crate("indexmap"),
Crate("itertools"),