Rollup merge of #131355 - clubby789:old-tests, r=jieyouxu

Add tests for some old fixed issues
Closes#30867Closes#30472Closes#28994Closes#26719 (and migrates the relevant test to the new run-make)
Closes#23600
cc `@jieyouxu` for the run-make-support changes
try-job: x86_64-msvc

Author: Zalathar

src/tools/run-make-support/src/macros.rs

@@ -70,6 +70,30 @@ macro_rules! impl_common_helpers {
 self
 }
 
+/// Configuration for the child process’s standard input (stdin) handle.
+///
+/// See [`std::process::Command::stdin`].
+pubfn stdin<T:Into<::std::process::Stdio>>(&mutself, cfg:T) -> &mutSelf{
+self.cmd.stdin(cfg);
+self
+}
+
+/// Configuration for the child process’s standard output (stdout) handle.
+///
+/// See [`std::process::Command::stdout`].
+pubfn stdout<T:Into<::std::process::Stdio>>(&mutself, cfg:T) -> &mutSelf{
+self.cmd.stdout(cfg);
+self
+}
+
+/// Configuration for the child process’s standard error (stderr) handle.
+///
+/// See [`std::process::Command::stderr`].
+pubfn stderr<T:Into<::std::process::Stdio>>(&mutself, cfg:T) -> &mutSelf{
+self.cmd.stderr(cfg);
+self
+}
+
 /// Inspect what the underlying [`Command`] is up to the
 /// current construction.
 pubfn inspect<I>(&mutself, inspector:I) -> &mutSelf

src/tools/tidy/src/allowed_run_make_makefiles.txt

@@ -1,6 +1,5 @@
 run-make/branch-protection-check-IBT/Makefile
 run-make/cat-and-grep-sanity-check/Makefile
-run-make/emit-to-stdout/Makefile
 run-make/extern-fn-reachable/Makefile
 run-make/incr-add-rust-src-component/Makefile
 run-make/issue-84395-lto-embed-bitcode/Makefile

src/tools/tidy/src/issues.txt

@@ -802,7 +802,6 @@ ui/consts/issue-70942-trait-vs-impl-mismatch.rs
 ui/consts/issue-73976-monomorphic.rs
 ui/consts/issue-73976-polymorphic.rs
 ui/consts/issue-76064.rs
-ui/consts/issue-77062-large-zst-array.rs
 ui/consts/issue-78655.rs
 ui/consts/issue-79137-monomorphic.rs
 ui/consts/issue-79137-toogeneric.rs

tests/run-make/emit-to-stdout/Makefile

@@ -0,0 +1,73 @@
+//! If `-o -` or `--emit KIND=-` is provided, output should be written to stdout
+//! instead. Binary output (`obj`, `llvm-bc`, `link` and `metadata`)
+//! being written this way will result in an error if stdout is a tty.
+//! Multiple output types going to stdout will trigger an error too,
+//! as they would all be mixed together.
+//!
+//! See <https://github.com/rust-lang/rust/pull/111626>.
+
+use std::fs::File;
+
+use run_make_support::{diff, run_in_tmpdir, rustc};
+
+// Test emitting text outputs to stdout works correctly
+fnrun_diff(name:&str,file_args:&[&str]){
+rustc().emit(format!("{name}={name}")).input("test.rs").args(file_args).run();
+let out = rustc().emit(format!("{name}=-")).input("test.rs").run().stdout_utf8();
+diff().expected_file(name).actual_text("stdout",&out).run();
+}
+
+// Test that emitting binary formats to a terminal gives the correct error
+fnrun_terminal_err_diff(name:&str){
+#[cfg(not(windows))]
+let terminal = File::create("/dev/ptmx").unwrap();
+// FIXME: If this test fails and the compiler does print to the console,
+// then this will produce a lot of output.
+// We should spawn a new console instead to print stdout.
+#[cfg(windows)]
+let terminal = File::options().read(true).write(true).open(r"\\.\CONOUT$").unwrap();
+
+let err = File::create(name).unwrap();
+rustc().emit(format!("{name}=-")).input("test.rs").stdout(terminal).stderr(err).run_fail();
+diff().expected_file(format!("emit-{name}.stderr")).actual_file(name).run();
+}
+
+fnmain(){
+run_in_tmpdir(|| {
+run_diff("asm",&[]);
+run_diff("llvm-ir",&[]);
+run_diff("dep-info",&["-Zdep-info-omit-d-target=yes"]);
+run_diff("mir",&[]);
+
+run_terminal_err_diff("llvm-bc");
+run_terminal_err_diff("obj");
+run_terminal_err_diff("metadata");
+run_terminal_err_diff("link");
+
+// Test error for emitting multiple types to stdout
+rustc()
+.input("test.rs")
+.emit("asm=-")
+.emit("llvm-ir=-")
+.emit("dep-info=-")
+.emit("mir=-")
+.stderr(File::create("multiple-types").unwrap())
+.run_fail();
+diff().expected_file("emit-multiple-types.stderr").actual_file("multiple-types").run();
+
+// Same as above, but using `-o`
+rustc()
+.input("test.rs")
+.output("-")
+.emit("asm,llvm-ir,dep-info,mir")
+.stderr(File::create("multiple-types-option-o").unwrap())
+.run_fail();
+diff()
+.expected_file("emit-multiple-types.stderr")
+.actual_file("multiple-types-option-o")
+.run();
+
+// Test that `-o -` redirected to a file works correctly (#26719)
+rustc().input("test.rs").output("-").stdout(File::create("out-stdout").unwrap()).run();
+});
+}

tests/run-make/emit-to-stdout/rmake.rs

@@ -1,4 +1,5 @@
 //@ build-pass
+pubstaticFOO:[(); usize::MAX] = [(); usize::MAX];
 
 fnmain(){
 let _ = &[(); usize::MAX];

…ui/consts/issue-77062-large-zst-array.rs tests/ui/consts/large-zst-array-77062.rstests/ui/consts/issue-77062-large-zst-array.rs renamed to tests/ui/consts/large-zst-array-77062.rs tests/ui/consts/issue-77062-large-zst-array.rs renamed to tests/ui/consts/large-zst-array-77062.rs

@@ -0,0 +1,32 @@
+//@ check-pass
+//! Tests that associated type projections normalize properly in the presence of HRTBs.
+//! Original issue: <https://github.com/rust-lang/rust/issues/30472>
+
+
+pubtraitMyFrom<T>{}
+impl<T>MyFrom<T>forT{}
+
+pubtraitMyInto<T>{}
+impl<T,U>MyInto<U>forTwhereU:MyFrom<T>{}
+
+
+pubtraitA<'self_>{
+typeT;
+}
+pubtraitB:for<'self_>A<'self_>{
+// Originally caused the `type U = usize` example below to fail with a type mismatch error
+typeU:for<'self_>MyFrom<<SelfasA<'self_>>::T>;
+}
+
+
+pubstructM;
+impl<'self_>A<'self_>forM{
+typeT = usize;
+}
+
+implBforM{
+typeU = usize;
+}
+
+
+fnmain(){}

tests/ui/traits/assoc-type-hrtb-normalization-30472.rs

@@ -0,0 +1,22 @@
+//@ check-pass
+//! Tests that a HRTB + FnOnce bound involving an associated type don't prevent
+//! a function pointer from implementing `Fn` traits.
+//! Test for <https://github.com/rust-lang/rust/issues/28994>
+
+traitLifetimeToType<'a>{
+typeOut;
+}
+
+impl<'a>LifetimeToType<'a>for(){
+typeOut = &'a();
+}
+
+fnid<'a>(val:&'a()) -> <()asLifetimeToType<'a>>::Out{
+ val
+}
+
+fnassert_fn<F:for<'a>FnOnce(&'a()) -> <()asLifetimeToType<'a>>::Out>(_func:F){}
+
+fnmain(){
+assert_fn(id);
+}

tests/ui/traits/fn-pointer/hrtb-assoc-fn-traits-28994.rs

@@ -0,0 +1,14 @@
+//@ check-pass
+//! Tests that HRTB impl selection covers type parameters not directly related
+//! to the trait.
+//! Test for <https://github.com/rust-lang/rust/issues/30867>
+
+#![crate_type = "lib"]
+
+traitUnary<T>{}
+impl<T,U,F:Fn(T) -> U>Unary<T>forF{}
+fnunary<F:for<'a>Unary<&'aT>,T>(){}
+
+pubfntest<F:for<'a>Fn(&'ai32) -> &'ai32>(){
+unary::<F,i32>()
+}