From 25e395653df2a91fc9a76dfd3ef050f1c7ba9fca Mon Sep 17 00:00:00 2001 From: Caio Date: Sun, 14 May 2023 09:49:20 -0300 Subject: [PATCH 1/8] Move tests --- src/tools/tidy/src/ui_tests.rs | 4 ++-- tests/ui/{issues => async-await}/issue-78115.rs | 0 tests/ui/{issues => coercion}/issue-3794.rs | 0 tests/ui/{issues => consts}/issue-16538.mir.stderr | 0 tests/ui/{issues => consts}/issue-16538.rs | 0 tests/ui/{issues => consts}/issue-16538.thir.stderr | 0 tests/ui/{issues => consts}/issue-28822.rs | 0 tests/ui/{issues => enum-discriminant}/issue-50689.rs | 0 tests/ui/{issues => extern}/issue-1251.rs | 0 tests/ui/{issues => for-loop-while}/issue-1257.rs | 0 tests/ui/{issues => mir}/issue-29798.rs | 0 tests/ui/{ => pattern}/issue-94866.rs | 0 tests/ui/{ => pattern}/issue-94866.stderr | 0 tests/ui/{issues => recursion}/issue-3008-1.rs | 0 tests/ui/{issues => recursion}/issue-3008-1.stderr | 0 tests/ui/{issues => recursion}/issue-3008-2.rs | 0 tests/ui/{issues => recursion}/issue-3008-2.stderr | 0 tests/ui/{issues => recursion}/issue-3008-3.rs | 0 tests/ui/{issues => recursion}/issue-3008-3.stderr | 0 tests/ui/{issues => typeck}/issue-1871.rs | 0 tests/ui/{issues => typeck}/issue-1871.stderr | 0 tests/ui/{issues => typeck}/issue-2063-resource.rs | 0 tests/ui/{issues => typeck}/issue-2063.rs | 0 tests/ui/{issues => where-clauses}/issue-50825-1.rs | 0 tests/ui/{issues => where-clauses}/issue-50825.rs | 0 25 files changed, 2 insertions(+), 2 deletions(-) rename tests/ui/{issues => async-await}/issue-78115.rs (100%) rename tests/ui/{issues => coercion}/issue-3794.rs (100%) rename tests/ui/{issues => consts}/issue-16538.mir.stderr (100%) rename tests/ui/{issues => consts}/issue-16538.rs (100%) rename tests/ui/{issues => consts}/issue-16538.thir.stderr (100%) rename tests/ui/{issues => consts}/issue-28822.rs (100%) rename tests/ui/{issues => enum-discriminant}/issue-50689.rs (100%) rename tests/ui/{issues => extern}/issue-1251.rs (100%) rename tests/ui/{issues => for-loop-while}/issue-1257.rs (100%) rename tests/ui/{issues => mir}/issue-29798.rs (100%) rename tests/ui/{ => pattern}/issue-94866.rs (100%) rename tests/ui/{ => pattern}/issue-94866.stderr (100%) rename tests/ui/{issues => recursion}/issue-3008-1.rs (100%) rename tests/ui/{issues => recursion}/issue-3008-1.stderr (100%) rename tests/ui/{issues => recursion}/issue-3008-2.rs (100%) rename tests/ui/{issues => recursion}/issue-3008-2.stderr (100%) rename tests/ui/{issues => recursion}/issue-3008-3.rs (100%) rename tests/ui/{issues => recursion}/issue-3008-3.stderr (100%) rename tests/ui/{issues => typeck}/issue-1871.rs (100%) rename tests/ui/{issues => typeck}/issue-1871.stderr (100%) rename tests/ui/{issues => typeck}/issue-2063-resource.rs (100%) rename tests/ui/{issues => typeck}/issue-2063.rs (100%) rename tests/ui/{issues => where-clauses}/issue-50825-1.rs (100%) rename tests/ui/{issues => where-clauses}/issue-50825.rs (100%) diff --git a/src/tools/tidy/src/ui_tests.rs b/src/tools/tidy/src/ui_tests.rs index be3a5d3aa0f03..3e9bf18a28711 100644 --- a/src/tools/tidy/src/ui_tests.rs +++ b/src/tools/tidy/src/ui_tests.rs @@ -10,8 +10,8 @@ use std::path::{Path, PathBuf}; const ENTRY_LIMIT: usize = 900; // FIXME: The following limits should be reduced eventually. -const ISSUES_ENTRY_LIMIT: usize = 1920; -const ROOT_ENTRY_LIMIT: usize = 896; +const ISSUES_ENTRY_LIMIT: usize = 1898; +const ROOT_ENTRY_LIMIT: usize = 894; const EXPECTED_TEST_FILE_EXTENSIONS: &[&str] = &[ "rs", // test source files diff --git a/tests/ui/issues/issue-78115.rs b/tests/ui/async-await/issue-78115.rs similarity index 100% rename from tests/ui/issues/issue-78115.rs rename to tests/ui/async-await/issue-78115.rs diff --git a/tests/ui/issues/issue-3794.rs b/tests/ui/coercion/issue-3794.rs similarity index 100% rename from tests/ui/issues/issue-3794.rs rename to tests/ui/coercion/issue-3794.rs diff --git a/tests/ui/issues/issue-16538.mir.stderr b/tests/ui/consts/issue-16538.mir.stderr similarity index 100% rename from tests/ui/issues/issue-16538.mir.stderr rename to tests/ui/consts/issue-16538.mir.stderr diff --git a/tests/ui/issues/issue-16538.rs b/tests/ui/consts/issue-16538.rs similarity index 100% rename from tests/ui/issues/issue-16538.rs rename to tests/ui/consts/issue-16538.rs diff --git a/tests/ui/issues/issue-16538.thir.stderr b/tests/ui/consts/issue-16538.thir.stderr similarity index 100% rename from tests/ui/issues/issue-16538.thir.stderr rename to tests/ui/consts/issue-16538.thir.stderr diff --git a/tests/ui/issues/issue-28822.rs b/tests/ui/consts/issue-28822.rs similarity index 100% rename from tests/ui/issues/issue-28822.rs rename to tests/ui/consts/issue-28822.rs diff --git a/tests/ui/issues/issue-50689.rs b/tests/ui/enum-discriminant/issue-50689.rs similarity index 100% rename from tests/ui/issues/issue-50689.rs rename to tests/ui/enum-discriminant/issue-50689.rs diff --git a/tests/ui/issues/issue-1251.rs b/tests/ui/extern/issue-1251.rs similarity index 100% rename from tests/ui/issues/issue-1251.rs rename to tests/ui/extern/issue-1251.rs diff --git a/tests/ui/issues/issue-1257.rs b/tests/ui/for-loop-while/issue-1257.rs similarity index 100% rename from tests/ui/issues/issue-1257.rs rename to tests/ui/for-loop-while/issue-1257.rs diff --git a/tests/ui/issues/issue-29798.rs b/tests/ui/mir/issue-29798.rs similarity index 100% rename from tests/ui/issues/issue-29798.rs rename to tests/ui/mir/issue-29798.rs diff --git a/tests/ui/issue-94866.rs b/tests/ui/pattern/issue-94866.rs similarity index 100% rename from tests/ui/issue-94866.rs rename to tests/ui/pattern/issue-94866.rs diff --git a/tests/ui/issue-94866.stderr b/tests/ui/pattern/issue-94866.stderr similarity index 100% rename from tests/ui/issue-94866.stderr rename to tests/ui/pattern/issue-94866.stderr diff --git a/tests/ui/issues/issue-3008-1.rs b/tests/ui/recursion/issue-3008-1.rs similarity index 100% rename from tests/ui/issues/issue-3008-1.rs rename to tests/ui/recursion/issue-3008-1.rs diff --git a/tests/ui/issues/issue-3008-1.stderr b/tests/ui/recursion/issue-3008-1.stderr similarity index 100% rename from tests/ui/issues/issue-3008-1.stderr rename to tests/ui/recursion/issue-3008-1.stderr diff --git a/tests/ui/issues/issue-3008-2.rs b/tests/ui/recursion/issue-3008-2.rs similarity index 100% rename from tests/ui/issues/issue-3008-2.rs rename to tests/ui/recursion/issue-3008-2.rs diff --git a/tests/ui/issues/issue-3008-2.stderr b/tests/ui/recursion/issue-3008-2.stderr similarity index 100% rename from tests/ui/issues/issue-3008-2.stderr rename to tests/ui/recursion/issue-3008-2.stderr diff --git a/tests/ui/issues/issue-3008-3.rs b/tests/ui/recursion/issue-3008-3.rs similarity index 100% rename from tests/ui/issues/issue-3008-3.rs rename to tests/ui/recursion/issue-3008-3.rs diff --git a/tests/ui/issues/issue-3008-3.stderr b/tests/ui/recursion/issue-3008-3.stderr similarity index 100% rename from tests/ui/issues/issue-3008-3.stderr rename to tests/ui/recursion/issue-3008-3.stderr diff --git a/tests/ui/issues/issue-1871.rs b/tests/ui/typeck/issue-1871.rs similarity index 100% rename from tests/ui/issues/issue-1871.rs rename to tests/ui/typeck/issue-1871.rs diff --git a/tests/ui/issues/issue-1871.stderr b/tests/ui/typeck/issue-1871.stderr similarity index 100% rename from tests/ui/issues/issue-1871.stderr rename to tests/ui/typeck/issue-1871.stderr diff --git a/tests/ui/issues/issue-2063-resource.rs b/tests/ui/typeck/issue-2063-resource.rs similarity index 100% rename from tests/ui/issues/issue-2063-resource.rs rename to tests/ui/typeck/issue-2063-resource.rs diff --git a/tests/ui/issues/issue-2063.rs b/tests/ui/typeck/issue-2063.rs similarity index 100% rename from tests/ui/issues/issue-2063.rs rename to tests/ui/typeck/issue-2063.rs diff --git a/tests/ui/issues/issue-50825-1.rs b/tests/ui/where-clauses/issue-50825-1.rs similarity index 100% rename from tests/ui/issues/issue-50825-1.rs rename to tests/ui/where-clauses/issue-50825-1.rs diff --git a/tests/ui/issues/issue-50825.rs b/tests/ui/where-clauses/issue-50825.rs similarity index 100% rename from tests/ui/issues/issue-50825.rs rename to tests/ui/where-clauses/issue-50825.rs From 41d414e3f44fa728c0231d2ef69bdf60313e2431 Mon Sep 17 00:00:00 2001 From: Caio Date: Wed, 24 May 2023 19:54:13 -0300 Subject: [PATCH 2/8] Address comments --- tests/ui/{mir => consts}/issue-29798.rs | 0 tests/ui/{recursion => enum-discriminant}/issue-3008-1.rs | 0 tests/ui/{recursion => enum-discriminant}/issue-3008-1.stderr | 0 tests/ui/{recursion => enum-discriminant}/issue-3008-2.rs | 0 tests/ui/{recursion => enum-discriminant}/issue-3008-2.stderr | 0 tests/ui/{recursion => enum-discriminant}/issue-3008-3.rs | 0 tests/ui/{recursion => enum-discriminant}/issue-3008-3.stderr | 0 7 files changed, 0 insertions(+), 0 deletions(-) rename tests/ui/{mir => consts}/issue-29798.rs (100%) rename tests/ui/{recursion => enum-discriminant}/issue-3008-1.rs (100%) rename tests/ui/{recursion => enum-discriminant}/issue-3008-1.stderr (100%) rename tests/ui/{recursion => enum-discriminant}/issue-3008-2.rs (100%) rename tests/ui/{recursion => enum-discriminant}/issue-3008-2.stderr (100%) rename tests/ui/{recursion => enum-discriminant}/issue-3008-3.rs (100%) rename tests/ui/{recursion => enum-discriminant}/issue-3008-3.stderr (100%) diff --git a/tests/ui/mir/issue-29798.rs b/tests/ui/consts/issue-29798.rs similarity index 100% rename from tests/ui/mir/issue-29798.rs rename to tests/ui/consts/issue-29798.rs diff --git a/tests/ui/recursion/issue-3008-1.rs b/tests/ui/enum-discriminant/issue-3008-1.rs similarity index 100% rename from tests/ui/recursion/issue-3008-1.rs rename to tests/ui/enum-discriminant/issue-3008-1.rs diff --git a/tests/ui/recursion/issue-3008-1.stderr b/tests/ui/enum-discriminant/issue-3008-1.stderr similarity index 100% rename from tests/ui/recursion/issue-3008-1.stderr rename to tests/ui/enum-discriminant/issue-3008-1.stderr diff --git a/tests/ui/recursion/issue-3008-2.rs b/tests/ui/enum-discriminant/issue-3008-2.rs similarity index 100% rename from tests/ui/recursion/issue-3008-2.rs rename to tests/ui/enum-discriminant/issue-3008-2.rs diff --git a/tests/ui/recursion/issue-3008-2.stderr b/tests/ui/enum-discriminant/issue-3008-2.stderr similarity index 100% rename from tests/ui/recursion/issue-3008-2.stderr rename to tests/ui/enum-discriminant/issue-3008-2.stderr diff --git a/tests/ui/recursion/issue-3008-3.rs b/tests/ui/enum-discriminant/issue-3008-3.rs similarity index 100% rename from tests/ui/recursion/issue-3008-3.rs rename to tests/ui/enum-discriminant/issue-3008-3.rs diff --git a/tests/ui/recursion/issue-3008-3.stderr b/tests/ui/enum-discriminant/issue-3008-3.stderr similarity index 100% rename from tests/ui/recursion/issue-3008-3.stderr rename to tests/ui/enum-discriminant/issue-3008-3.stderr From 38c712f45889c237d5ac08258f0a40dccb9adbba Mon Sep 17 00:00:00 2001 From: AngelicosPhosphoros Date: Sun, 21 May 2023 21:53:02 +0400 Subject: [PATCH 3/8] Added build instructions for cranelift backend as part of Rust repo All other instructions assume that user works with separate repository than Rust compiler repository. When one follows default instructions, cranelift codegen tries to use different sys-root and compiler internal crates which leads to compiler errors when building it. I needed to do all this steps while adding new intrinsic to rustc. --- compiler/rustc_codegen_cranelift/Readme.md | 26 ++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/compiler/rustc_codegen_cranelift/Readme.md b/compiler/rustc_codegen_cranelift/Readme.md index c5222982aa739..26dccf309e1e4 100644 --- a/compiler/rustc_codegen_cranelift/Readme.md +++ b/compiler/rustc_codegen_cranelift/Readme.md @@ -42,6 +42,32 @@ This will build your project with rustc_codegen_cranelift instead of the usual L For additional ways to use rustc_codegen_cranelift like the JIT mode see [usage.md](docs/usage.md). +## Building and testing with changes in rustc code + +This is useful when changing code in `rustc_codegen_cranelift` as part of changing [main Rust repository](https://github.com/rust-lang/rust/). +This can happen, for example, when you are implementing a new compiler intrinsic. + +Instruction below uses `$RustCheckoutDir` as substitute for any folder where you cloned Rust repository. + +You need to do this steps to successfully compile and use the cranelift backend with your changes in rustc code: + +1. `cd $RustCheckoutDir` +2. Run `python x.py setup` and choose option for compiler (`b`). +3. Build compiler and necessary tools: `python x.py build --stage=2 compiler library/std src/tools/rustdoc src/tools/rustfmt` + * (Optional) You can also build cargo by adding `src/tools/cargo` to previous command. +4. Copy exectutable files from `./build/host/stage2-tools//release` +to `./build/host/stage2/bin/`. Note that you would need to do this every time you rebuilt `rust` repository. +5. Copy cargo from another toolchain: `cp $(rustup which cargo) .build//stage2/bin/cargo` + * Another option is to build it at step 3 and copy with other executables at step 4. +6. Link your new `rustc` to toolchain: `rustup toolchain link stage2 ./build/host/stage2/`. +7. (Windows only) compile y.rs: `rustc +stage2 -O y.rs`. +8. You need to prefix every `./y.rs` (or `y` if you built `y.rs`) command by `rustup run stage2` to make cg_clif use your local changes in rustc. + + * `rustup run stage2 ./y.rs prepare` + * `rustup run stage2 ./y.rs build` + * (Optional) run tests: `rustup run stage2 ./y.rs test` +9. Now you can use your cg_clif build to compile other Rust programs, e.g. you can open any Rust crate and run commands like `$RustCheckoutDir/compiler/rustc_codegen_cranelift/dist/cargo-clif build --release`. + ## Configuration See the documentation on the `BackendConfig` struct in [config.rs](src/config.rs) for all From 976adf3d6de5eb708cd9b346e7749eb2cac00ea9 Mon Sep 17 00:00:00 2001 From: Boxy Date: Fri, 26 May 2023 18:54:59 +0100 Subject: [PATCH 4/8] better `TyKind::Debug` --- compiler/rustc_middle/src/ty/context.rs | 10 +++ compiler/rustc_middle/src/ty/mod.rs | 2 +- compiler/rustc_middle/src/ty/print/pretty.rs | 62 +++++----------- .../rustc_middle/src/ty/structural_impls.rs | 59 +++++++++++++-- compiler/rustc_middle/src/ty/sty.rs | 3 +- compiler/rustc_type_ir/src/lib.rs | 23 ++++-- .../rustc_type_ir/src/structural_impls.rs | 21 +++++- compiler/rustc_type_ir/src/sty.rs | 72 +++++++++++++------ tests/ui/thir-print/thir-flat.stdout | 2 +- 9 files changed, 176 insertions(+), 78 deletions(-) diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs index 2bde55bc4fd31..0cde46ae4c2ab 100644 --- a/compiler/rustc_middle/src/ty/context.rs +++ b/compiler/rustc_middle/src/ty/context.rs @@ -115,6 +115,16 @@ impl<'tcx> Interner for TyCtxt<'tcx> { type FreeRegion = ty::FreeRegion; type RegionVid = ty::RegionVid; type PlaceholderRegion = ty::PlaceholderRegion; + + fn ty_and_mut_to_parts( + TypeAndMut { ty, mutbl }: TypeAndMut<'tcx>, + ) -> (Self::Ty, Self::Mutability) { + (ty, mutbl) + } + + fn mutability_is_mut(mutbl: Self::Mutability) -> bool { + mutbl.is_mut() + } } type InternedSet<'tcx, T> = ShardedHashMap, ()>; diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs index a8d0dca37ff99..025432fcaa802 100644 --- a/compiler/rustc_middle/src/ty/mod.rs +++ b/compiler/rustc_middle/src/ty/mod.rs @@ -1496,7 +1496,7 @@ impl<'tcx> OpaqueHiddenType<'tcx> { /// identified by both a universe, as well as a name residing within that universe. Distinct bound /// regions/types/consts within the same universe simply have an unknown relationship to one /// another. -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)] #[derive(HashStable, TyEncodable, TyDecodable)] pub struct Placeholder { pub universe: UniverseIndex, diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs index a064174e2616b..1c216960d118e 100644 --- a/compiler/rustc_middle/src/ty/print/pretty.rs +++ b/compiler/rustc_middle/src/ty/print/pretty.rs @@ -685,29 +685,30 @@ pub trait PrettyPrinter<'tcx>: } ty::FnPtr(ref bare_fn) => p!(print(bare_fn)), ty::Infer(infer_ty) => { - let verbose = self.should_print_verbose(); + if self.should_print_verbose() { + p!(write("{:?}", ty.kind())); + return Ok(self); + } + if let ty::TyVar(ty_vid) = infer_ty { if let Some(name) = self.ty_infer_name(ty_vid) { p!(write("{}", name)) } else { - if verbose { - p!(write("{:?}", infer_ty)) - } else { - p!(write("{}", infer_ty)) - } + p!(write("{}", infer_ty)) } } else { - if verbose { p!(write("{:?}", infer_ty)) } else { p!(write("{}", infer_ty)) } + p!(write("{}", infer_ty)) } } ty::Error(_) => p!("[type error]"), ty::Param(ref param_ty) => p!(print(param_ty)), ty::Bound(debruijn, bound_ty) => match bound_ty.kind { - ty::BoundTyKind::Anon => debug_bound_var(&mut self, debruijn, bound_ty.var)?, + ty::BoundTyKind::Anon => { + rustc_type_ir::debug_bound_var(&mut self, debruijn, bound_ty.var)? + } ty::BoundTyKind::Param(_, s) => match self.should_print_verbose() { - true if debruijn == ty::INNERMOST => p!(write("^{}", s)), - true => p!(write("^{}_{}", debruijn.index(), s)), - false => p!(write("{}", s)), + true => p!(write("{:?}", ty.kind())), + false => p!(write("{s}")), }, }, ty::Adt(def, substs) => { @@ -740,10 +741,11 @@ pub trait PrettyPrinter<'tcx>: } } ty::Placeholder(placeholder) => match placeholder.bound.kind { - ty::BoundTyKind::Anon => { - debug_placeholder_var(&mut self, placeholder.universe, placeholder.bound.var)?; - } - ty::BoundTyKind::Param(_, name) => p!(write("{}", name)), + ty::BoundTyKind::Anon => p!(write("{placeholder:?}")), + ty::BoundTyKind::Param(_, name) => match self.should_print_verbose() { + true => p!(write("{:?}", ty.kind())), + false => p!(write("{name}")), + }, }, ty::Alias(ty::Opaque, ty::AliasTy { def_id, substs, .. }) => { // We use verbose printing in 'NO_QUERIES' mode, to @@ -1372,11 +1374,9 @@ pub trait PrettyPrinter<'tcx>: } ty::ConstKind::Bound(debruijn, bound_var) => { - debug_bound_var(&mut self, debruijn, bound_var)? + rustc_type_ir::debug_bound_var(&mut self, debruijn, bound_var)? } - ty::ConstKind::Placeholder(placeholder) => { - debug_placeholder_var(&mut self, placeholder.universe, placeholder.bound)?; - }, + ty::ConstKind::Placeholder(placeholder) => p!(write("{placeholder:?}")), // FIXME(generic_const_exprs): // write out some legible representation of an abstract const? ty::ConstKind::Expr(_) => p!("[const expr]"), @@ -3065,27 +3065,3 @@ pub struct OpaqueFnEntry<'tcx> { fn_trait_ref: Option>, return_ty: Option>>, } - -pub fn debug_bound_var( - fmt: &mut T, - debruijn: ty::DebruijnIndex, - var: ty::BoundVar, -) -> Result<(), std::fmt::Error> { - if debruijn == ty::INNERMOST { - write!(fmt, "^{}", var.index()) - } else { - write!(fmt, "^{}_{}", debruijn.index(), var.index()) - } -} - -pub fn debug_placeholder_var( - fmt: &mut T, - universe: ty::UniverseIndex, - bound: ty::BoundVar, -) -> Result<(), std::fmt::Error> { - if universe == ty::UniverseIndex::ROOT { - write!(fmt, "!{}", bound.index()) - } else { - write!(fmt, "!{}_{}", universe.index(), bound.index()) - } -} diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs index 16cb6c910463a..a965450d27d43 100644 --- a/compiler/rustc_middle/src/ty/structural_impls.rs +++ b/compiler/rustc_middle/src/ty/structural_impls.rs @@ -88,7 +88,35 @@ impl fmt::Debug for ty::FreeRegion { impl<'tcx> fmt::Debug for ty::FnSig<'tcx> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "({:?}; c_variadic: {})->{:?}", self.inputs(), self.c_variadic, self.output()) + let ty::FnSig { inputs_and_output: _, c_variadic, unsafety, abi } = self; + + write!(f, "{}", unsafety.prefix_str())?; + match abi { + rustc_target::spec::abi::Abi::Rust => (), + abi => write!(f, "extern \"{abi:?}\" ")?, + }; + + write!(f, "fn(")?; + let inputs = self.inputs(); + match inputs.len() { + 0 if *c_variadic => write!(f, "...)")?, + 0 => write!(f, ")")?, + _ => { + for ty in &self.inputs()[0..(self.inputs().len() - 1)] { + write!(f, "{ty:?}, ")?; + } + write!(f, "{:?}", self.inputs().last().unwrap())?; + if *c_variadic { + write!(f, "...")?; + } + write!(f, ")")?; + } + } + + match self.output().kind() { + ty::Tuple(list) if list.is_empty() => Ok(()), + _ => write!(f, " -> {:?}", self.output()), + } } } @@ -216,20 +244,37 @@ impl<'tcx> fmt::Debug for ty::ConstKind<'tcx> { match self { Param(param) => write!(f, "{param:?}"), Infer(var) => write!(f, "{var:?}"), - Bound(debruijn, var) => ty::print::debug_bound_var(f, *debruijn, *var), - Placeholder(placeholder) => { - ty::print::debug_placeholder_var(f, placeholder.universe, placeholder.bound) - } + Bound(debruijn, var) => rustc_type_ir::debug_bound_var(f, *debruijn, *var), + Placeholder(placeholder) => write!(f, "{placeholder:?}"), Unevaluated(uv) => { f.debug_tuple("Unevaluated").field(&uv.substs).field(&uv.def).finish() } Value(valtree) => write!(f, "{valtree:?}"), - Error(_) => write!(f, "[const error]"), + Error(_) => write!(f, "{{const error}}"), Expr(expr) => write!(f, "{expr:?}"), } } } +impl fmt::Debug for ty::BoundTy { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self.kind { + ty::BoundTyKind::Anon => write!(f, "{:?}", self.var), + ty::BoundTyKind::Param(_, sym) => write!(f, "{sym:?}"), + } + } +} + +impl fmt::Debug for ty::Placeholder { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + if self.universe == ty::UniverseIndex::ROOT { + write!(f, "!{:?}", self.bound) + } else { + write!(f, "!{}_{:?}", self.universe.index(), self.bound) + } + } +} + /////////////////////////////////////////////////////////////////////////// // Atomic structs // @@ -294,6 +339,7 @@ TrivialTypeTraversalAndLiftImpls! { crate::ty::AliasRelationDirection, crate::ty::Placeholder, crate::ty::Placeholder, + crate::ty::Placeholder, crate::ty::ClosureKind, crate::ty::FreeRegion, crate::ty::InferTy, @@ -310,7 +356,6 @@ TrivialTypeTraversalAndLiftImpls! { interpret::Scalar, rustc_target::abi::Size, ty::BoundVar, - ty::Placeholder, } TrivialTypeTraversalAndLiftImpls! { diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs index e6d51c4ec9770..0b722d9368bc4 100644 --- a/compiler/rustc_middle/src/ty/sty.rs +++ b/compiler/rustc_middle/src/ty/sty.rs @@ -1511,10 +1511,11 @@ impl Atom for RegionVid { rustc_index::newtype_index! { #[derive(HashStable)] + #[debug_format = "{}"] pub struct BoundVar {} } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)] #[derive(HashStable)] pub struct BoundTy { pub var: BoundVar, diff --git a/compiler/rustc_type_ir/src/lib.rs b/compiler/rustc_type_ir/src/lib.rs index f6b44bdf27ef9..ae16fbb162e5c 100644 --- a/compiler/rustc_type_ir/src/lib.rs +++ b/compiler/rustc_type_ir/src/lib.rs @@ -52,7 +52,7 @@ pub trait Interner: Sized { type PolyFnSig: Clone + Debug + Hash + Ord; type ListBinderExistentialPredicate: Clone + Debug + Hash + Ord; type BinderListTy: Clone + Debug + Hash + Ord; - type ListTy: Clone + Debug + Hash + Ord; + type ListTy: Clone + Debug + Hash + Ord + IntoIterator; type AliasTy: Clone + Debug + Hash + Ord; type ParamTy: Clone + Debug + Hash + Ord; type BoundTy: Clone + Debug + Hash + Ord; @@ -67,6 +67,9 @@ pub trait Interner: Sized { type FreeRegion: Clone + Debug + Hash + Ord; type RegionVid: Clone + Debug + Hash + Ord; type PlaceholderRegion: Clone + Debug + Hash + Ord; + + fn ty_and_mut_to_parts(ty_and_mut: Self::TypeAndMut) -> (Self::Ty, Self::Mutability); + fn mutability_is_mut(mutbl: Self::Mutability) -> bool; } /// Imagine you have a function `F: FnOnce(&[T]) -> R`, plus an iterator `iter` @@ -390,7 +393,19 @@ impl DebruijnIndex { } } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] +pub fn debug_bound_var( + fmt: &mut T, + debruijn: DebruijnIndex, + var: impl std::fmt::Debug, +) -> Result<(), std::fmt::Error> { + if debruijn == INNERMOST { + write!(fmt, "^{:?}", var) + } else { + write!(fmt, "^{}_{:?}", debruijn.index(), var) + } +} + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Encodable, Decodable, HashStable_Generic)] pub enum IntTy { Isize, @@ -448,7 +463,7 @@ impl IntTy { } } -#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, Debug)] +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy)] #[derive(Encodable, Decodable, HashStable_Generic)] pub enum UintTy { Usize, @@ -506,7 +521,7 @@ impl UintTy { } } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Encodable, Decodable, HashStable_Generic)] pub enum FloatTy { F32, diff --git a/compiler/rustc_type_ir/src/structural_impls.rs b/compiler/rustc_type_ir/src/structural_impls.rs index 45a2e9023c9ca..553d7f31b2d19 100644 --- a/compiler/rustc_type_ir/src/structural_impls.rs +++ b/compiler/rustc_type_ir/src/structural_impls.rs @@ -4,11 +4,12 @@ use crate::fold::{FallibleTypeFolder, TypeFoldable}; use crate::visit::{TypeVisitable, TypeVisitor}; -use crate::Interner; +use crate::{FloatTy, IntTy, Interner, UintTy}; use rustc_data_structures::functor::IdFunctor; use rustc_data_structures::sync::Lrc; use rustc_index::{Idx, IndexVec}; +use core::fmt; use std::ops::ControlFlow; /////////////////////////////////////////////////////////////////////////// @@ -163,3 +164,21 @@ impl, Ix: Idx> TypeVisitable for IndexVec) -> fmt::Result { + write!(f, "{}", self.name_str()) + } +} + +impl fmt::Debug for UintTy { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.name_str()) + } +} + +impl fmt::Debug for FloatTy { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.name_str()) + } +} diff --git a/compiler/rustc_type_ir/src/sty.rs b/compiler/rustc_type_ir/src/sty.rs index f7344bacc028c..fa18f921ee4ba 100644 --- a/compiler/rustc_type_ir/src/sty.rs +++ b/compiler/rustc_type_ir/src/sty.rs @@ -294,7 +294,7 @@ impl Clone for TyKind { Str => Str, Array(t, c) => Array(t.clone(), c.clone()), Slice(t) => Slice(t.clone()), - RawPtr(t) => RawPtr(t.clone()), + RawPtr(p) => RawPtr(p.clone()), Ref(r, t, m) => Ref(r.clone(), t.clone(), m.clone()), FnDef(d, s) => FnDef(d.clone(), s.clone()), FnPtr(s) => FnPtr(s.clone()), @@ -499,33 +499,65 @@ impl hash::Hash for TyKind { impl fmt::Debug for TyKind { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { - Bool => f.write_str("Bool"), - Char => f.write_str("Char"), - Int(i) => f.debug_tuple_field1_finish("Int", i), - Uint(u) => f.debug_tuple_field1_finish("Uint", u), - Float(float) => f.debug_tuple_field1_finish("Float", float), + Bool => write!(f, "bool"), + Char => write!(f, "char"), + Int(i) => write!(f, "{i:?}"), + Uint(u) => write!(f, "{u:?}"), + Float(float) => write!(f, "{float:?}"), Adt(d, s) => f.debug_tuple_field2_finish("Adt", d, s), Foreign(d) => f.debug_tuple_field1_finish("Foreign", d), - Str => f.write_str("Str"), - Array(t, c) => f.debug_tuple_field2_finish("Array", t, c), - Slice(t) => f.debug_tuple_field1_finish("Slice", t), - RawPtr(t) => f.debug_tuple_field1_finish("RawPtr", t), - Ref(r, t, m) => f.debug_tuple_field3_finish("Ref", r, t, m), + Str => write!(f, "str"), + Array(t, c) => write!(f, "[{t:?}; {c:?}]"), + Slice(t) => write!(f, "[{t:?}]"), + RawPtr(p) => { + let (ty, mutbl) = I::ty_and_mut_to_parts(p.clone()); + match I::mutability_is_mut(mutbl) { + true => write!(f, "*mut "), + false => write!(f, "*const "), + }?; + write!(f, "{ty:?}") + } + Ref(r, t, m) => match I::mutability_is_mut(m.clone()) { + true => write!(f, "&{r:?} mut {t:?}"), + false => write!(f, "&{r:?} {t:?}"), + }, FnDef(d, s) => f.debug_tuple_field2_finish("FnDef", d, s), - FnPtr(s) => f.debug_tuple_field1_finish("FnPtr", s), - Dynamic(p, r, repr) => f.debug_tuple_field3_finish("Dynamic", p, r, repr), + FnPtr(s) => write!(f, "{s:?}"), + Dynamic(p, r, repr) => match repr { + DynKind::Dyn => write!(f, "dyn {p:?} + {r:?}"), + DynKind::DynStar => write!(f, "dyn* {p:?} + {r:?}"), + }, Closure(d, s) => f.debug_tuple_field2_finish("Closure", d, s), Generator(d, s, m) => f.debug_tuple_field3_finish("Generator", d, s, m), GeneratorWitness(g) => f.debug_tuple_field1_finish("GeneratorWitness", g), GeneratorWitnessMIR(d, s) => f.debug_tuple_field2_finish("GeneratorWitnessMIR", d, s), - Never => f.write_str("Never"), - Tuple(t) => f.debug_tuple_field1_finish("Tuple", t), + Never => write!(f, "!"), + Tuple(t) => { + let mut iter = t.clone().into_iter(); + + write!(f, "(")?; + + match iter.next() { + None => return write!(f, ")"), + Some(ty) => write!(f, "{ty:?}")?, + }; + + match iter.next() { + None => return write!(f, ",)"), + Some(ty) => write!(f, "{ty:?})")?, + } + + for ty in iter { + write!(f, ", {ty:?}")?; + } + write!(f, ")") + } Alias(i, a) => f.debug_tuple_field2_finish("Alias", i, a), - Param(p) => f.debug_tuple_field1_finish("Param", p), - Bound(d, b) => f.debug_tuple_field2_finish("Bound", d, b), - Placeholder(p) => f.debug_tuple_field1_finish("Placeholder", p), - Infer(t) => f.debug_tuple_field1_finish("Infer", t), - TyKind::Error(e) => f.debug_tuple_field1_finish("Error", e), + Param(p) => write!(f, "{p:?}"), + Bound(d, b) => crate::debug_bound_var(f, *d, b), + Placeholder(p) => write!(f, "{p:?}"), + Infer(t) => write!(f, "{t:?}"), + TyKind::Error(_) => write!(f, "{{type error}}"), } } } diff --git a/tests/ui/thir-print/thir-flat.stdout b/tests/ui/thir-print/thir-flat.stdout index 9d467f73d0970..b0aa44b56aa95 100644 --- a/tests/ui/thir-print/thir-flat.stdout +++ b/tests/ui/thir-print/thir-flat.stdout @@ -1,7 +1,7 @@ DefId(0:3 ~ thir_flat[7b97]::main): Thir { body_type: Fn( - ([]; c_variadic: false)->(), + fn(), ), arms: [], blocks: [ From 00c92bd873c24ee5386bc08ec854391358a8be6c Mon Sep 17 00:00:00 2001 From: Michael Goulet Date: Sat, 27 May 2023 17:35:17 +0000 Subject: [PATCH 5/8] Check nested obligations during coercion unify --- compiler/rustc_hir_typeck/src/coercion.rs | 19 ++++++++++++++++++- tests/ui/impl-trait/autoderef.rs | 2 ++ 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs index 08c4082e885d9..369dd4ae59506 100644 --- a/compiler/rustc_hir_typeck/src/coercion.rs +++ b/compiler/rustc_hir_typeck/src/coercion.rs @@ -62,6 +62,7 @@ use rustc_span::{self, BytePos, DesugaringKind, Span}; use rustc_target::spec::abi::Abi; use rustc_trait_selection::infer::InferCtxtExt as _; use rustc_trait_selection::traits::error_reporting::TypeErrCtxtExt as _; +use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt; use rustc_trait_selection::traits::{ self, NormalizeExt, ObligationCause, ObligationCauseCode, ObligationCtxt, }; @@ -144,12 +145,28 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { debug!("unify(a: {:?}, b: {:?}, use_lub: {})", a, b, self.use_lub); self.commit_if_ok(|_| { let at = self.at(&self.cause, self.fcx.param_env); - if self.use_lub { + + let res = if self.use_lub { at.lub(DefineOpaqueTypes::Yes, b, a) } else { at.sup(DefineOpaqueTypes::Yes, b, a) .map(|InferOk { value: (), obligations }| InferOk { value: a, obligations }) + }; + + // In the new solver, lazy norm may allow us to shallowly equate + // more types, but we emit possibly impossible-to-satisfy obligations. + // Filter these cases out to make sure our coercion is more accurate. + if self.tcx.trait_solver_next() { + if let Ok(res) = &res { + for obligation in &res.obligations { + if !self.predicate_may_hold(&obligation) { + return Err(TypeError::Mismatch); + } + } + } } + + res }) } diff --git a/tests/ui/impl-trait/autoderef.rs b/tests/ui/impl-trait/autoderef.rs index 5e4f4995447e1..0d07a549640f0 100644 --- a/tests/ui/impl-trait/autoderef.rs +++ b/tests/ui/impl-trait/autoderef.rs @@ -1,3 +1,5 @@ +// revisions: current next +//[next] compile-flag: -Ztrait-solver=next // check-pass use std::path::Path; From 2f65aac667302849407fe677cc34078300b57eee Mon Sep 17 00:00:00 2001 From: mu001999 Date: Mon, 29 May 2023 12:26:27 +0800 Subject: [PATCH 6/8] Determine `self_ty` with expected `ty` --- .../src/check/compare_impl_item.rs | 2 +- tests/ui/mismatched_types/E0053.stderr | 2 +- tests/ui/mismatched_types/issue-112036.rs | 7 +++++++ tests/ui/mismatched_types/issue-112036.stderr | 15 +++++++++++++++ 4 files changed, 24 insertions(+), 2 deletions(-) create mode 100644 tests/ui/mismatched_types/issue-112036.rs create mode 100644 tests/ui/mismatched_types/issue-112036.stderr diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs index 283a9ed3388eb..7df811ccdb5c1 100644 --- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs +++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs @@ -901,7 +901,7 @@ fn report_trait_method_mismatch<'tcx>( if trait_m.fn_has_self_parameter => { let ty = trait_sig.inputs()[0]; - let sugg = match ExplicitSelf::determine(ty, |_| ty == impl_trait_ref.self_ty()) { + let sugg = match ExplicitSelf::determine(ty, |ty| ty == impl_trait_ref.self_ty()) { ExplicitSelf::ByValue => "self".to_owned(), ExplicitSelf::ByReference(_, hir::Mutability::Not) => "&self".to_owned(), ExplicitSelf::ByReference(_, hir::Mutability::Mut) => "&mut self".to_owned(), diff --git a/tests/ui/mismatched_types/E0053.stderr b/tests/ui/mismatched_types/E0053.stderr index 154f2fcbee0ff..d0bd5b46cf59f 100644 --- a/tests/ui/mismatched_types/E0053.stderr +++ b/tests/ui/mismatched_types/E0053.stderr @@ -22,7 +22,7 @@ LL | fn bar(&mut self) { } | ^^^^^^^^^ | | | types differ in mutability - | help: change the self-receiver type to match the trait: `self: &Bar` + | help: change the self-receiver type to match the trait: `&self` | note: type in trait --> $DIR/E0053.rs:3:12 diff --git a/tests/ui/mismatched_types/issue-112036.rs b/tests/ui/mismatched_types/issue-112036.rs new file mode 100644 index 0000000000000..e63471e974771 --- /dev/null +++ b/tests/ui/mismatched_types/issue-112036.rs @@ -0,0 +1,7 @@ +struct Foo; + +impl Drop for Foo { + fn drop(self) {} //~ ERROR method `drop` has an incompatible type for trait +} + +fn main() {} diff --git a/tests/ui/mismatched_types/issue-112036.stderr b/tests/ui/mismatched_types/issue-112036.stderr new file mode 100644 index 0000000000000..a883aba35bfba --- /dev/null +++ b/tests/ui/mismatched_types/issue-112036.stderr @@ -0,0 +1,15 @@ +error[E0053]: method `drop` has an incompatible type for trait + --> $DIR/issue-112036.rs:4:13 + | +LL | fn drop(self) {} + | ^^^^ + | | + | expected `&mut Foo`, found `Foo` + | help: change the self-receiver type to match the trait: `&mut self` + | + = note: expected signature `fn(&mut Foo)` + found signature `fn(Foo)` + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0053`. From 8d406b8459a56b96b283689a999b9c83c41f4f24 Mon Sep 17 00:00:00 2001 From: Maybe Waffle Date: Mon, 29 May 2023 13:44:39 +0000 Subject: [PATCH 7/8] Add a test for issue 110457 --- .../auxiliary/egui_inspect_derive.rs | 90 +++++++++++++++++++ .../issue-110457-same-span-closures/main.rs | 47 ++++++++++ 2 files changed, 137 insertions(+) create mode 100644 tests/incremental/issue-110457-same-span-closures/auxiliary/egui_inspect_derive.rs create mode 100644 tests/incremental/issue-110457-same-span-closures/main.rs diff --git a/tests/incremental/issue-110457-same-span-closures/auxiliary/egui_inspect_derive.rs b/tests/incremental/issue-110457-same-span-closures/auxiliary/egui_inspect_derive.rs new file mode 100644 index 0000000000000..e7d91235e7356 --- /dev/null +++ b/tests/incremental/issue-110457-same-span-closures/auxiliary/egui_inspect_derive.rs @@ -0,0 +1,90 @@ +// force-host +// no-prefer-dynamic +#![crate_type = "proc-macro"] + +extern crate proc_macro; + +use proc_macro::{Delimiter, Group, Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree}; + +#[proc_macro] +pub fn expand(_: TokenStream) -> TokenStream { + // Hand expansion/rewriting of + // ``` + // quote! { + // output_mut(|o| o.copied_text = "".into()); + // output_mut(|o| o.copied_text = format!("{:?}", self.tile_db)); + // }.into() + // ``` + stream([ + ident("output_mut"), + group( + Delimiter::Parenthesis, + [ + or(), + ident("o"), + or(), + ident("o"), + dot(), + ident("copied_text"), + eq(), + string(""), + dot(), + ident("into"), + group(Delimiter::Parenthesis, []), + ], + ), + semi(), + ident("output_mut"), + group( + Delimiter::Parenthesis, + [ + or(), + ident("o"), + or(), + ident("o"), + dot(), + ident("copied_text"), + eq(), + ident("format"), + bang(), + group( + Delimiter::Parenthesis, + [string("{:?}"), comma(), ident("self"), dot(), ident("tile_db")], + ), + ], + ), + semi(), + ]) +} + +fn stream(s: impl IntoIterator) -> TokenStream { + s.into_iter().collect() +} + +fn ident(i: &str) -> TokenTree { + TokenTree::Ident(Ident::new(i, Span::call_site())) +} +fn group(d: Delimiter, s: impl IntoIterator) -> TokenTree { + TokenTree::Group(Group::new(d, s.into_iter().collect())) +} +fn semi() -> TokenTree { + TokenTree::Punct(Punct::new(';', Spacing::Alone)) +} +fn or() -> TokenTree { + TokenTree::Punct(Punct::new('|', Spacing::Alone)) +} +fn dot() -> TokenTree { + TokenTree::Punct(Punct::new('.', Spacing::Alone)) +} +fn eq() -> TokenTree { + TokenTree::Punct(Punct::new('=', Spacing::Alone)) +} +fn bang() -> TokenTree { + TokenTree::Punct(Punct::new('!', Spacing::Alone)) +} +fn comma() -> TokenTree { + TokenTree::Punct(Punct::new(',', Spacing::Alone)) +} +fn string(s: &str) -> TokenTree { + TokenTree::Literal(Literal::string(s)) +} diff --git a/tests/incremental/issue-110457-same-span-closures/main.rs b/tests/incremental/issue-110457-same-span-closures/main.rs new file mode 100644 index 0000000000000..b44fda3d36a29 --- /dev/null +++ b/tests/incremental/issue-110457-same-span-closures/main.rs @@ -0,0 +1,47 @@ +// aux-build: egui_inspect_derive.rs +// revisions: cpass1 cpass2 + +extern crate egui_inspect_derive; + +pub struct TileDef { + pub layer: (), + #[cfg(cpass2)] + pub blend_graphic: String, +} + +pub(crate) struct GameState { + pub(crate) tile_db: TileDb, +} + +impl GameState { + fn inspect_mut(&mut self) { + egui_inspect_derive::expand! {} + } +} + +fn new() -> GameState { + loop {} +} + +fn main() { + let mut app = new(); + app.inspect_mut(); +} +// this is actually used +pub struct TileDb { + unknown_bg: TileDef, +} + +impl std::fmt::Debug for TileDb { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + loop {} + } +} + +pub struct PlatformOutput { + pub copied_text: String, +} + +pub fn output_mut(writer: impl FnOnce(&mut PlatformOutput) -> R) -> R { + loop {} +} From c62d49e75eb8d03c039e59878de4529f656f26b4 Mon Sep 17 00:00:00 2001 From: Caio Date: Mon, 29 May 2023 12:07:41 -0300 Subject: [PATCH 8/8] Address comment --- tests/ui/{enum-discriminant => structs-enums}/issue-3008-1.rs | 0 tests/ui/{enum-discriminant => structs-enums}/issue-3008-1.stderr | 0 tests/ui/{enum-discriminant => structs-enums}/issue-3008-2.rs | 0 tests/ui/{enum-discriminant => structs-enums}/issue-3008-2.stderr | 0 tests/ui/{enum-discriminant => structs-enums}/issue-3008-3.rs | 0 tests/ui/{enum-discriminant => structs-enums}/issue-3008-3.stderr | 0 6 files changed, 0 insertions(+), 0 deletions(-) rename tests/ui/{enum-discriminant => structs-enums}/issue-3008-1.rs (100%) rename tests/ui/{enum-discriminant => structs-enums}/issue-3008-1.stderr (100%) rename tests/ui/{enum-discriminant => structs-enums}/issue-3008-2.rs (100%) rename tests/ui/{enum-discriminant => structs-enums}/issue-3008-2.stderr (100%) rename tests/ui/{enum-discriminant => structs-enums}/issue-3008-3.rs (100%) rename tests/ui/{enum-discriminant => structs-enums}/issue-3008-3.stderr (100%) diff --git a/tests/ui/enum-discriminant/issue-3008-1.rs b/tests/ui/structs-enums/issue-3008-1.rs similarity index 100% rename from tests/ui/enum-discriminant/issue-3008-1.rs rename to tests/ui/structs-enums/issue-3008-1.rs diff --git a/tests/ui/enum-discriminant/issue-3008-1.stderr b/tests/ui/structs-enums/issue-3008-1.stderr similarity index 100% rename from tests/ui/enum-discriminant/issue-3008-1.stderr rename to tests/ui/structs-enums/issue-3008-1.stderr diff --git a/tests/ui/enum-discriminant/issue-3008-2.rs b/tests/ui/structs-enums/issue-3008-2.rs similarity index 100% rename from tests/ui/enum-discriminant/issue-3008-2.rs rename to tests/ui/structs-enums/issue-3008-2.rs diff --git a/tests/ui/enum-discriminant/issue-3008-2.stderr b/tests/ui/structs-enums/issue-3008-2.stderr similarity index 100% rename from tests/ui/enum-discriminant/issue-3008-2.stderr rename to tests/ui/structs-enums/issue-3008-2.stderr diff --git a/tests/ui/enum-discriminant/issue-3008-3.rs b/tests/ui/structs-enums/issue-3008-3.rs similarity index 100% rename from tests/ui/enum-discriminant/issue-3008-3.rs rename to tests/ui/structs-enums/issue-3008-3.rs diff --git a/tests/ui/enum-discriminant/issue-3008-3.stderr b/tests/ui/structs-enums/issue-3008-3.stderr similarity index 100% rename from tests/ui/enum-discriminant/issue-3008-3.stderr rename to tests/ui/structs-enums/issue-3008-3.stderr