diff options
Diffstat (limited to 'src')
570 files changed, 6521 insertions, 4282 deletions
diff --git a/src/bootstrap/bin/rustdoc.rs b/src/bootstrap/bin/rustdoc.rs index 8c56cf1cb34..ab846adf942 100644 --- a/src/bootstrap/bin/rustdoc.rs +++ b/src/bootstrap/bin/rustdoc.rs @@ -48,12 +48,6 @@ fn main() { cmd.arg(arg); } - // Bootstrap's Cargo-command builder sets this variable to the current Rust version; let's pick - // it up so we can make rustdoc print this into the docs - if let Some(version) = env::var_os("RUSTDOC_CRATE_VERSION") { - cmd.arg("--crate-version").arg(version); - } - // Needed to be able to run all rustdoc tests. if let Some(ref x) = env::var_os("RUSTDOC_RESOURCE_SUFFIX") { // This "unstable-options" can be removed when `--resource-suffix` is stabilized diff --git a/src/bootstrap/builder.rs b/src/bootstrap/builder.rs index e13a5f24653..709b202052e 100644 --- a/src/bootstrap/builder.rs +++ b/src/bootstrap/builder.rs @@ -404,6 +404,7 @@ impl<'a> Builder<'a> { test::CrateLibrustc, test::CrateRustdoc, test::Linkcheck, + test::TierCheck, test::Cargotest, test::Cargo, test::Rls, @@ -744,7 +745,6 @@ impl<'a> Builder<'a> { .env("RUSTDOC_LIBDIR", self.rustc_libdir(compiler)) .env("CFG_RELEASE_CHANNEL", &self.config.channel) .env("RUSTDOC_REAL", self.rustdoc(compiler)) - .env("RUSTDOC_CRATE_VERSION", self.rust_version()) .env("RUSTC_BOOTSTRAP", "1") .arg("-Winvalid_codeblock_attributes"); if self.config.deny_warnings { @@ -1270,7 +1270,11 @@ impl<'a> Builder<'a> { } // For `cargo doc` invocations, make rustdoc print the Rust version into the docs - cargo.env("RUSTDOC_CRATE_VERSION", self.rust_version()); + // This replaces spaces with newlines because RUSTDOCFLAGS does not + // support arguments with regular spaces. Hopefully someday Cargo will + // have space support. + let rust_version = self.rust_version().replace(' ', "\n"); + rustdocflags.arg("--crate-version").arg(&rust_version); // Environment variables *required* throughout the build // @@ -1447,14 +1451,14 @@ impl Rustflags { fn env(&mut self, env: &str) { if let Ok(s) = env::var(env) { - for part in s.split_whitespace() { + for part in s.split(' ') { self.arg(part); } } } fn arg(&mut self, arg: &str) -> &mut Self { - assert_eq!(arg.split_whitespace().count(), 1); + assert_eq!(arg.split(' ').count(), 1); if !self.0.is_empty() { self.0.push_str(" "); } diff --git a/src/bootstrap/native.rs b/src/bootstrap/native.rs index 48b2cc24d4c..f1bc3d11d8b 100644 --- a/src/bootstrap/native.rs +++ b/src/bootstrap/native.rs @@ -178,7 +178,7 @@ impl Step for Llvm { .define("LLVM_TARGET_ARCH", target_native.split('-').next().unwrap()) .define("LLVM_DEFAULT_TARGET_TRIPLE", target_native); - if !target.contains("netbsd") { + if !target.contains("netbsd") && target != "aarch64-apple-darwin" { cfg.define("LLVM_ENABLE_ZLIB", "ON"); } else { // FIXME: Enable zlib on NetBSD too @@ -282,14 +282,6 @@ impl Step for Llvm { "LLVM_CONFIG_PATH", host_bin.join("llvm-config").with_extension(EXE_EXTENSION), ); - - if target.contains("netbsd") { - cfg.define("CMAKE_SYSTEM_NAME", "NetBSD"); - } else if target.contains("freebsd") { - cfg.define("CMAKE_SYSTEM_NAME", "FreeBSD"); - } else if target.contains("windows") { - cfg.define("CMAKE_SYSTEM_NAME", "Windows"); - } } if let Some(ref suffix) = builder.config.llvm_version_suffix { @@ -378,6 +370,22 @@ fn configure_cmake( } cfg.target(&target.triple).host(&builder.config.build.triple); + if target != builder.config.build { + if target.contains("netbsd") { + cfg.define("CMAKE_SYSTEM_NAME", "NetBSD"); + } else if target.contains("freebsd") { + cfg.define("CMAKE_SYSTEM_NAME", "FreeBSD"); + } else if target.contains("windows") { + cfg.define("CMAKE_SYSTEM_NAME", "Windows"); + } + // When cross-compiling we should also set CMAKE_SYSTEM_VERSION, but in + // that case like CMake we cannot easily determine system version either. + // + // Since, the LLVM itself makes rather limited use of version checks in + // CMakeFiles (and then only in tests), and so far no issues have been + // reported, the system version is currently left unset. + } + let sanitize_cc = |cc: &Path| { if target.contains("msvc") { OsString::from(cc.to_str().unwrap().replace("\\", "/")) @@ -786,6 +794,7 @@ fn supported_sanitizers( } "x86_64-apple-darwin" => darwin_libs("osx", &["asan", "lsan", "tsan"]), "x86_64-fuchsia" => common_libs("fuchsia", "x86_64", &["asan"]), + "x86_64-unknown-freebsd" => common_libs("freebsd", "x86_64", &["asan", "msan", "tsan"]), "x86_64-unknown-linux-gnu" => { common_libs("linux", "x86_64", &["asan", "lsan", "msan", "tsan"]) } diff --git a/src/bootstrap/test.rs b/src/bootstrap/test.rs index bb5b9296c0a..ac833a55d4c 100644 --- a/src/bootstrap/test.rs +++ b/src/bootstrap/test.rs @@ -599,7 +599,6 @@ impl Step for RustdocTheme { .env("RUSTDOC_LIBDIR", builder.sysroot_libdir(self.compiler, self.compiler.host)) .env("CFG_RELEASE_CHANNEL", &builder.config.channel) .env("RUSTDOC_REAL", builder.rustdoc(self.compiler)) - .env("RUSTDOC_CRATE_VERSION", builder.rust_version()) .env("RUSTC_BOOTSTRAP", "1"); if let Some(linker) = builder.linker(self.compiler.host, true) { cmd.env("RUSTC_TARGET_LINKER", linker); @@ -2043,3 +2042,47 @@ impl Step for Bootstrap { run.builder.ensure(Bootstrap); } } + +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub struct TierCheck { + pub compiler: Compiler, + target: TargetSelection, +} + +impl Step for TierCheck { + type Output = (); + const DEFAULT: bool = true; + const ONLY_HOSTS: bool = true; + + fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> { + run.path("src/tools/tier-check") + } + + fn make_run(run: RunConfig<'_>) { + let compiler = run.builder.compiler_for(run.builder.top_stage, run.host, run.host); + run.builder.ensure(TierCheck { compiler, target: run.host }); + } + + /// Tests the Platform Support page in the rustc book. + fn run(self, builder: &Builder<'_>) { + builder.ensure(compile::Std { compiler: self.compiler, target: self.target }); + let mut cargo = tool::prepare_tool_cargo( + builder, + self.compiler, + Mode::ToolRustc, + self.target, + "run", + "src/tools/tier-check", + SourceType::InTree, + &[], + ); + cargo.arg(builder.src.join("src/doc/rustc/src/platform-support.md")); + cargo.arg(&builder.rustc(self.compiler)); + if builder.is_verbose() { + cargo.arg("--verbose"); + } + + builder.info("platform support check"); + try_run(builder, &mut cargo.into()); + } +} diff --git a/src/ci/docker/host-x86_64/dist-x86_64-freebsd/Dockerfile b/src/ci/docker/host-x86_64/dist-x86_64-freebsd/Dockerfile index 766e6531c95..bfc768f9935 100644 --- a/src/ci/docker/host-x86_64/dist-x86_64-freebsd/Dockerfile +++ b/src/ci/docker/host-x86_64/dist-x86_64-freebsd/Dockerfile @@ -29,5 +29,5 @@ ENV \ ENV HOSTS=x86_64-unknown-freebsd -ENV RUST_CONFIGURE_ARGS --enable-extended --enable-profiler --disable-docs +ENV RUST_CONFIGURE_ARGS --enable-extended --enable-profiler --enable-sanitizers --disable-docs ENV SCRIPT python3 ../x.py dist --host $HOSTS --target $HOSTS diff --git a/src/ci/docker/host-x86_64/i686-gnu-nopt/Dockerfile b/src/ci/docker/host-x86_64/i686-gnu-nopt/Dockerfile index 6a596b3465f..cb507dced42 100644 --- a/src/ci/docker/host-x86_64/i686-gnu-nopt/Dockerfile +++ b/src/ci/docker/host-x86_64/i686-gnu-nopt/Dockerfile @@ -19,8 +19,13 @@ RUN apt-get update && apt-get install -y --no-install-recommends \ COPY scripts/sccache.sh /scripts/ RUN sh /scripts/sccache.sh +RUN mkdir -p /config +RUN echo "[rust]" > /config/nopt-std-config.toml +RUN echo "optimize = false" >> /config/nopt-std-config.toml + ENV RUST_CONFIGURE_ARGS --build=i686-unknown-linux-gnu --disable-optimize-tests -ENV SCRIPT python3 ../x.py --stage 2 test +ENV SCRIPT python3 ../x.py test --stage 0 --config /config/nopt-std-config.toml library/std \ + && python3 ../x.py --stage 2 test # FIXME(#59637) takes too long on CI right now ENV NO_LLVM_ASSERTIONS=1 NO_DEBUG_ASSERTIONS=1 diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-nopt/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-nopt/Dockerfile index fa769cac9c1..41e83c69e54 100644 --- a/src/ci/docker/host-x86_64/x86_64-gnu-nopt/Dockerfile +++ b/src/ci/docker/host-x86_64/x86_64-gnu-nopt/Dockerfile @@ -18,7 +18,12 @@ RUN apt-get update && apt-get install -y --no-install-recommends \ COPY scripts/sccache.sh /scripts/ RUN sh /scripts/sccache.sh +RUN mkdir -p /config +RUN echo "[rust]" > /config/nopt-std-config.toml +RUN echo "optimize = false" >> /config/nopt-std-config.toml + ENV RUST_CONFIGURE_ARGS --build=x86_64-unknown-linux-gnu \ --disable-optimize-tests \ --set rust.test-compare-mode -ENV SCRIPT python3 ../x.py --stage 2 test +ENV SCRIPT python3 ../x.py test --stage 0 --config /config/nopt-std-config.toml library/std \ + && python3 ../x.py --stage 2 test diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md index b603c7b231e..57013e9194b 100644 --- a/src/doc/rustc/src/SUMMARY.md +++ b/src/doc/rustc/src/SUMMARY.md @@ -11,6 +11,7 @@ - [Deny-by-default lints](lints/listing/deny-by-default.md) - [Codegen options](codegen-options/index.md) - [JSON Output](json.md) +- [Platform Support](platform-support.md) - [Targets](targets/index.md) - [Built-in Targets](targets/built-in.md) - [Custom Targets](targets/custom.md) diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md new file mode 100644 index 00000000000..b8d3c985cb5 --- /dev/null +++ b/src/doc/rustc/src/platform-support.md @@ -0,0 +1,223 @@ +# Platform Support + +<style type="text/css"> + td code { + white-space: nowrap; + } +</style> + +Support for different platforms are organized into three tiers, each with a +different set of guarantees. + +Platforms are identified by their "target triple" which is the string to +inform the compiler what kind of output should be produced. The columns in the +tables below have the following meanings: + +* std: + * ✓ indicates the full standard library is available. + * \* indicates the target only supports [`no_std`] development. + * ? indicates the standard library support is unknown or a work-in-progress. +* host: A ✓ indicates that `rustc` and `cargo` can run on the host platform. + +[`no_std`]: https://rust-embedded.github.io/book/intro/no-std.html + +## Tier 1 + +Tier 1 platforms can be thought of as "guaranteed to work". +Specifically they will each satisfy the following requirements: + +* Official binary releases are provided for the platform. +* Automated testing is set up to run tests for the platform. +* Landing changes to the `rust-lang/rust` repository's master branch is gated + on tests passing. +* Documentation for how to use and how to build the platform is available. + +target | std | host | notes +-------|-----|------|------- +`i686-pc-windows-gnu` | ✓ | ✓ | 32-bit MinGW (Windows 7+) +`i686-pc-windows-msvc` | ✓ | ✓ | 32-bit MSVC (Windows 7+) +`i686-unknown-linux-gnu` | ✓ | ✓ | 32-bit Linux (kernel 2.6.32+, glibc 2.11+) +`x86_64-apple-darwin` | ✓ | ✓ | 64-bit OSX (10.7+, Lion+) +`x86_64-pc-windows-gnu` | ✓ | ✓ | 64-bit MinGW (Windows 7+) +`x86_64-pc-windows-msvc` | ✓ | ✓ | 64-bit MSVC (Windows 7+) +`x86_64-unknown-linux-gnu` | ✓ | ✓ | 64-bit Linux (kernel 2.6.32+, glibc 2.11+) + +## Tier 2 + +Tier 2 platforms can be thought of as "guaranteed to build". Automated tests +are not run so it's not guaranteed to produce a working build, but platforms +often work to quite a good degree and patches are always welcome! +Specifically, these platforms are required to have each of the following: + +* Official binary releases are provided for the platform. +* Automated building is set up, but may not be running tests. +* Landing changes to the `rust-lang/rust` repository's master branch is gated on + platforms **building**. For some platforms only the standard library is + compiled, but for others `rustc` and `cargo` are too. + +target | std | host | notes +-------|-----|------|------- +`aarch64-apple-ios` | ✓[^apple] | | ARM64 iOS +`aarch64-fuchsia` | ✓ | | ARM64 Fuchsia +`aarch64-linux-android` | ✓ | | ARM64 Android +`aarch64-pc-windows-msvc` | ✓ | | ARM64 Windows MSVC +`aarch64-unknown-linux-gnu` | ✓ | ✓ | ARM64 Linux (kernel 4.2, glibc 2.17) +`aarch64-unknown-linux-musl` | ✓ | | ARM64 Linux with MUSL +`aarch64-unknown-none` | * | | Bare ARM64, hardfloat +`aarch64-unknown-none-softfloat` | * | | Bare ARM64, softfloat +`arm-linux-androideabi` | ✓ | | ARMv7 Android +`arm-unknown-linux-gnueabi` | ✓ | ✓ | ARMv6 Linux (kernel 3.2, glibc 2.17) +`arm-unknown-linux-gnueabihf` | ✓ | ✓ | ARMv6 Linux, hardfloat (kernel 3.2, glibc 2.17) +`arm-unknown-linux-musleabi` | ✓ | | ARMv6 Linux with MUSL +`arm-unknown-linux-musleabihf` | ✓ | | ARMv6 Linux with MUSL, hardfloat +`armebv7r-none-eabi` | * | | Bare ARMv7-R, Big Endian +`armebv7r-none-eabihf` | * | | Bare ARMv7-R, Big Endian, hardfloat +`armv5te-unknown-linux-gnueabi` | ✓ | | ARMv5TE Linux (kernel 4.4, glibc 2.23) +`armv5te-unknown-linux-musleabi` | ✓ | | ARMv5TE Linux with MUSL +`armv7-linux-androideabi` | ✓ | | ARMv7a Android +`armv7a-none-eabi` | * | | Bare ARMv7-A +`armv7r-none-eabi` | * | | Bare ARMv7-R +`armv7r-none-eabihf` | * | | Bare ARMv7-R, hardfloat +`armv7-unknown-linux-gnueabi` | ✓ | | ARMv7 Linux (kernel 4.15, glibc 2.27) +`armv7-unknown-linux-gnueabihf` | ✓ | ✓ | ARMv7 Linux, hardfloat (kernel 3.2, glibc 2.17) +`armv7-unknown-linux-musleabi` | ✓ | | ARMv7 Linux, MUSL +`armv7-unknown-linux-musleabihf` | ✓ | | ARMv7 Linux with MUSL +`asmjs-unknown-emscripten` | ✓ | | asm.js via Emscripten +`i586-pc-windows-msvc` | ✓ | | 32-bit Windows w/o SSE +`i586-unknown-linux-gnu` | ✓ | | 32-bit Linux w/o SSE (kernel 4.4, glibc 2.23) +`i586-unknown-linux-musl` | ✓ | | 32-bit Linux w/o SSE, MUSL +`i686-linux-android` | ✓ | | 32-bit x86 Android +`i686-unknown-freebsd` | ✓ | ✓ | 32-bit FreeBSD +`i686-unknown-linux-musl` | ✓ | | 32-bit Linux with MUSL +`mips-unknown-linux-gnu` | ✓ | ✓ | MIPS Linux (kernel 4.4, glibc 2.23) +`mips-unknown-linux-musl` | ✓ | | MIPS Linux with MUSL +`mips64-unknown-linux-gnuabi64` | ✓ | ✓ | MIPS64 Linux, n64 ABI (kernel 4.4, glibc 2.23) +`mips64-unknown-linux-muslabi64` | ✓ | | MIPS64 Linux, n64 ABI, MUSL +`mips64el-unknown-linux-gnuabi64` | ✓ | ✓ | MIPS64 (LE) Linux, n64 ABI (kernel 4.4, glibc 2.23) +`mips64el-unknown-linux-muslabi64` | ✓ | | MIPS64 (LE) Linux, n64 ABI, MUSL +`mipsel-unknown-linux-gnu` | ✓ | ✓ | MIPS (LE) Linux (kernel 4.4, glibc 2.23) +`mipsel-unknown-linux-musl` | ✓ | | MIPS (LE) Linux with MUSL +`nvptx64-nvidia-cuda` | ✓ | | --emit=asm generates PTX code that [runs on NVIDIA GPUs] +`powerpc-unknown-linux-gnu` | ✓ | ✓ | PowerPC Linux (kernel 2.6.32, glibc 2.11) +`powerpc64-unknown-linux-gnu` | ✓ | ✓ | PPC64 Linux (kernel 2.6.32, glibc 2.11) +`powerpc64le-unknown-linux-gnu` | ✓ | ✓ | PPC64LE Linux (kernel 3.10, glibc 2.17) +`riscv32i-unknown-none-elf` | * | | Bare RISC-V (RV32I ISA) +`riscv32imac-unknown-none-elf` | * | | Bare RISC-V (RV32IMAC ISA) +`riscv32imc-unknown-none-elf` | * | | Bare RISC-V (RV32IMC ISA) +`riscv64gc-unknown-linux-gnu` | ✓ | ✓ | RISC-V Linux (kernel 4.20, glibc 2.29) +`riscv64gc-unknown-none-elf` | * | | Bare RISC-V (RV64IMAFDC ISA) +`riscv64imac-unknown-none-elf` | * | | Bare RISC-V (RV64IMAC ISA) +`s390x-unknown-linux-gnu` | ✓ | ✓ | S390x Linux (kernel 2.6.32, glibc 2.11) +`sparc64-unknown-linux-gnu` | ✓ | | SPARC Linux (kernel 4.4, glibc 2.23) +`sparcv9-sun-solaris` | ✓ | | SPARC Solaris 10/11, illumos +`thumbv6m-none-eabi` | * | | Bare Cortex-M0, M0+, M1 +`thumbv7em-none-eabi` | * | | Bare Cortex-M4, M7 +`thumbv7em-none-eabihf` | * | | Bare Cortex-M4F, M7F, FPU, hardfloat +`thumbv7m-none-eabi` | * | | Bare Cortex-M3 +`thumbv7neon-linux-androideabi` | ✓ | | Thumb2-mode ARMv7a Android with NEON +`thumbv7neon-unknown-linux-gnueabihf` | ✓ | | Thumb2-mode ARMv7a Linux with NEON (kernel 4.4, glibc 2.23) +`thumbv8m.base-none-eabi` | * | | ARMv8-M Baseline +`thumbv8m.main-none-eabi` | * | | ARMv8-M Mainline +`thumbv8m.main-none-eabihf` | * | | ARMv8-M Baseline, hardfloat +`wasm32-unknown-emscripten` | ✓ | | WebAssembly via Emscripten +`wasm32-unknown-unknown` | ✓ | | WebAssembly +`wasm32-wasi` | ✓ | | WebAssembly with WASI +`x86_64-apple-ios` | ✓[^apple] | | 64-bit x86 iOS +`x86_64-fortanix-unknown-sgx` | ✓ | | [Fortanix ABI] for 64-bit Intel SGX +`x86_64-fuchsia` | ✓ | | 64-bit Fuchsia +`x86_64-linux-android` | ✓ | | 64-bit x86 Android +`x86_64-rumprun-netbsd` | ✓ | | 64-bit NetBSD Rump Kernel +`x86_64-sun-solaris` | ✓ | | 64-bit Solaris 10/11, illumos +`x86_64-unknown-cloudabi` | ✓ | | 64-bit CloudABI +`x86_64-unknown-freebsd` | ✓ | ✓ | 64-bit FreeBSD +`x86_64-unknown-illumos` | ✓ | ✓ | illumos +`x86_64-unknown-linux-gnux32` | ✓ | | 64-bit Linux (x32 ABI) (kernel 4.15, glibc 2.27) +`x86_64-unknown-linux-musl` | ✓ | ✓ | 64-bit Linux with MUSL +`x86_64-unknown-netbsd` | ✓ | ✓ | NetBSD/amd64 +`x86_64-unknown-redox` | ✓ | | Redox OS + +[Fortanix ABI]: https://edp.fortanix.com/ + +## Tier 3 + +Tier 3 platforms are those which the Rust codebase has support for, but which +are not built or tested automatically, and may not work. Official builds are +not available. + +target | std | host | notes +-------|-----|------|------- +`aarch64-apple-darwin` | ? | | ARM64 macOS +`aarch64-apple-tvos` | *[^apple] | | ARM64 tvOS +`aarch64-unknown-cloudabi` | ✓ | | ARM64 CloudABI +`aarch64-unknown-freebsd` | ✓ | ✓ | ARM64 FreeBSD +`aarch64-unknown-hermit` | ? | | +`aarch64-unknown-netbsd` | ? | | +`aarch64-unknown-openbsd` | ✓ | ✓ | ARM64 OpenBSD +`aarch64-unknown-redox` | ? | | ARM64 Redox OS +`aarch64-uwp-windows-msvc` | ? | | +`aarch64-wrs-vxworks` | ? | | +`armv4t-unknown-linux-gnueabi` | ? | | +`armv6-unknown-freebsd` | ✓ | ✓ | ARMv6 FreeBSD +`armv6-unknown-netbsd-eabihf` | ? | | +`armv7-apple-ios` | ✓[^apple] | | ARMv7 iOS, Cortex-a8 +`armv7-unknown-cloudabi-eabihf` | ✓ | | ARMv7 CloudABI, hardfloat +`armv7-unknown-freebsd` | ✓ | ✓ | ARMv7 FreeBSD +`armv7-unknown-netbsd-eabihf` | ? | | +`armv7-wrs-vxworks-eabihf` | ? | | +`armv7a-none-eabihf` | * | | ARM Cortex-A, hardfloat +`armv7s-apple-ios` | ✓[^apple] | | +`avr-unknown-unknown` | ? | | AVR +`hexagon-unknown-linux-musl` | ? | | +`i386-apple-ios` | ✓[^apple] | | 32-bit x86 iOS +`i686-apple-darwin` | ✓ | ✓ | 32-bit OSX (10.7+, Lion+) +`i686-pc-windows-msvc` | ✓ | | 32-bit Windows XP support +`i686-unknown-cloudabi` | ✓ | | 32-bit CloudABI +`i686-unknown-uefi` | ? | | 32-bit UEFI +`i686-unknown-haiku` | ✓ | ✓ | 32-bit Haiku +`i686-unknown-netbsd` | ✓ | | NetBSD/i386 with SSE2 +`i686-unknown-openbsd` | ✓ | ✓ | 32-bit OpenBSD +`i686-uwp-windows-gnu` | ? | | +`i686-uwp-windows-msvc` | ? | | +`i686-wrs-vxworks` | ? | | +`mips-unknown-linux-uclibc` | ✓ | | MIPS Linux with uClibc +`mipsel-unknown-linux-uclibc` | ✓ | | MIPS (LE) Linux with uClibc +`mipsel-sony-psp` | * | | MIPS (LE) Sony PlayStation Portable (PSP) +`mipsisa32r6-unknown-linux-gnu` | ? | | +`mipsisa32r6el-unknown-linux-gnu` | ? | | +`mipsisa64r6-unknown-linux-gnuabi64` | ? | | +`mipsisa64r6el-unknown-linux-gnuabi64` | ? | | +`msp430-none-elf` | * | | 16-bit MSP430 microcontrollers +`powerpc-unknown-linux-gnuspe` | ✓ | | PowerPC SPE Linux +`powerpc-unknown-linux-musl` | ? | | +`powerpc-unknown-netbsd` | ? | | +`powerpc-wrs-vxworks` | ? | | +`powerpc-wrs-vxworks-spe` | ? | | +`powerpc64-unknown-freebsd` | ✓ | ✓ | PPC64 FreeBSD (ELFv1 and ELFv2) +`powerpc64-unknown-linux-musl` | ? | | +`powerpc64-wrs-vxworks` | ? | | +`powerpc64le-unknown-linux-musl` | ? | | +`sparc-unknown-linux-gnu` | ✓ | | 32-bit SPARC Linux +`sparc64-unknown-netbsd` | ✓ | ✓ | NetBSD/sparc64 +`sparc64-unknown-openbsd` | ? | | +`thumbv7a-pc-windows-msvc` | ? | | +`thumbv7a-uwp-windows-msvc` | ✓ | | +`thumbv7neon-unknown-linux-musleabihf` | ? | | Thumb2-mode ARMv7a Linux with NEON, MUSL +`thumbv4t-none-eabi` | * | | ARMv4T T32 +`x86_64-apple-ios-macabi` | ✓[^apple] | | Apple Catalyst +`x86_64-apple-tvos` | *[^apple] | | x86 64-bit tvOS +`x86_64-linux-kernel` | ? | | Linux kernel modules +`x86_64-pc-solaris` | ? | | +`x86_64-pc-windows-msvc` | ✓ | | 64-bit Windows XP support +`x86_64-unknown-dragonfly` | ✓ | ✓ | 64-bit DragonFlyBSD +`x86_64-unknown-haiku` | ✓ | ✓ | 64-bit Haiku +`x86_64-unknown-hermit` | ? | | +`x86_64-unknown-hermit-kernel` | ? | | HermitCore kernel +`x86_64-unknown-l4re-uclibc` | ? | | +`x86_64-unknown-openbsd` | ✓ | ✓ | 64-bit OpenBSD +`x86_64-unknown-uefi` | ? | | +`x86_64-uwp-windows-gnu` | ✓ | | +`x86_64-uwp-windows-msvc` | ✓ | | +`x86_64-wrs-vxworks` | ? | | + +[runs on NVIDIA GPUs]: https://github.com/japaric-archived/nvptx#targets +[^apple]: These targets are only available on macOS. diff --git a/src/doc/rustc/src/targets/built-in.md b/src/doc/rustc/src/targets/built-in.md index 2e94ebe345a..c33b506cdae 100644 --- a/src/doc/rustc/src/targets/built-in.md +++ b/src/doc/rustc/src/targets/built-in.md @@ -2,9 +2,14 @@ `rustc` ships with the ability to compile to many targets automatically, we call these "built-in" targets, and they generally correspond to targets that -the team is supporting directly. +the team is supporting directly. To see the list of built-in targets, you can +run `rustc --print target-list`. -To see the list of built-in targets, you can run `rustc --print target-list`, -or look at [the API -docs](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_target/spec/index.html#modules). -Each module there defines a builder for a particular target. \ No newline at end of file +Typically, a target needs a compiled copy of the Rust standard library to +work. If using [rustup], then check out the documentation on +[Cross-compilation][rustup-cross] on how to download a pre-built standard +library built by the official Rust distributions. Most targets will need a +system linker, and possibly other things. + +[rustup]: https://github.com/rust-lang/rustup +[rustup-cross]: https://github.com/rust-lang/rustup#cross-compilation diff --git a/src/librustc_arena/lib.rs b/src/librustc_arena/lib.rs index 5cf4f97fb88..5e6a0340d12 100644 --- a/src/librustc_arena/lib.rs +++ b/src/librustc_arena/lib.rs @@ -611,11 +611,7 @@ macro_rules! which_arena_for_type { #[macro_export] macro_rules! declare_arena { - // This macro has to take the same input as - // `impl_arena_allocatable_decoders` which requires a second version of - // each type. We ignore that type until we can fix - // `impl_arena_allocatable_decoders`. - ([], [$($a:tt $name:ident: $ty:ty, $_gen_ty:ty;)*], $tcx:lifetime) => { + ([], [$($a:tt $name:ident: $ty:ty,)*], $tcx:lifetime) => { #[derive(Default)] pub struct Arena<$tcx> { pub dropless: $crate::DroplessArena, diff --git a/src/librustc_ast/Cargo.toml b/src/librustc_ast/Cargo.toml index ab0ab7244db..73c5e33753f 100644 --- a/src/librustc_ast/Cargo.toml +++ b/src/librustc_ast/Cargo.toml @@ -11,7 +11,7 @@ doctest = false [dependencies] rustc_serialize = { path = "../librustc_serialize" } -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc_span = { path = "../librustc_span" } rustc_data_structures = { path = "../librustc_data_structures" } rustc_index = { path = "../librustc_index" } diff --git a/src/librustc_ast/ast.rs b/src/librustc_ast/ast.rs index a0541158bc2..6dff02486ff 100644 --- a/src/librustc_ast/ast.rs +++ b/src/librustc_ast/ast.rs @@ -53,7 +53,7 @@ mod tests; /// ``` /// /// `'outer` is a label. -#[derive(Clone, RustcEncodable, RustcDecodable, Copy, HashStable_Generic)] +#[derive(Clone, Encodable, Decodable, Copy, HashStable_Generic)] pub struct Label { pub ident: Ident, } @@ -66,7 +66,7 @@ impl fmt::Debug for Label { /// A "Lifetime" is an annotation of the scope in which variable /// can be used, e.g. `'a` in `&'a i32`. -#[derive(Clone, RustcEncodable, RustcDecodable, Copy)] +#[derive(Clone, Encodable, Decodable, Copy)] pub struct Lifetime { pub id: NodeId, pub ident: Ident, @@ -90,7 +90,7 @@ impl fmt::Display for Lifetime { /// along with a bunch of supporting information. /// /// E.g., `std::cmp::PartialEq`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct Path { pub span: Span, /// The segments in the path: the things separated by `::`. @@ -128,7 +128,7 @@ impl Path { /// A segment of a path: an identifier, an optional lifetime, and a set of types. /// /// E.g., `std`, `String` or `Box<T>`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct PathSegment { /// The identifier portion of this path segment. pub ident: Ident, @@ -156,7 +156,7 @@ impl PathSegment { /// The arguments of a path segment. /// /// E.g., `<A, B>` as in `Foo<A, B>` or `(A, B)` as in `Foo(A, B)`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum GenericArgs { /// The `<'a, A, B, C>` in `foo::bar::baz::<'a, A, B, C>`. AngleBracketed(AngleBracketedArgs), @@ -188,7 +188,7 @@ impl GenericArgs { } /// Concrete argument in the sequence of generic args. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum GenericArg { /// `'a` in `Foo<'a>` Lifetime(Lifetime), @@ -209,7 +209,7 @@ impl GenericArg { } /// A path like `Foo<'a, T>`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Default)] +#[derive(Clone, Encodable, Decodable, Debug, Default)] pub struct AngleBracketedArgs { /// The overall span. pub span: Span, @@ -219,7 +219,7 @@ pub struct AngleBracketedArgs { /// Either an argument for a parameter e.g., `'a`, `Vec<u8>`, `0`, /// or a constraint on an associated item, e.g., `Item = String` or `Item: Bound`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum AngleBracketedArg { /// Argument for a generic parameter. Arg(GenericArg), @@ -240,7 +240,7 @@ impl Into<Option<P<GenericArgs>>> for ParenthesizedArgs { } /// A path like `Foo(A, B) -> C`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct ParenthesizedArgs { /// Overall span pub span: Span, @@ -269,7 +269,7 @@ pub use crate::node_id::{NodeId, CRATE_NODE_ID, DUMMY_NODE_ID}; /// A modifier on a bound, e.g., `?Sized` or `?const Trait`. /// /// Negative bounds should also be handled here. -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug)] pub enum TraitBoundModifier { /// No modifiers None, @@ -290,7 +290,7 @@ pub enum TraitBoundModifier { /// `typeck::collect::compute_bounds` matches these against /// the "special" built-in traits (see `middle::lang_items`) and /// detects `Copy`, `Send` and `Sync`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum GenericBound { Trait(PolyTraitRef, TraitBoundModifier), Outlives(Lifetime), @@ -357,7 +357,7 @@ impl fmt::Display for ParamKindOrd { } } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum GenericParamKind { /// A lifetime definition (e.g., `'a: 'b + 'c + 'd`). Lifetime, @@ -371,7 +371,7 @@ pub enum GenericParamKind { }, } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct GenericParam { pub id: NodeId, pub ident: Ident, @@ -383,7 +383,7 @@ pub struct GenericParam { /// Represents lifetime, type and const parameters attached to a declaration of /// a function, enum, trait, etc. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct Generics { pub params: Vec<GenericParam>, pub where_clause: WhereClause, @@ -406,7 +406,7 @@ impl Default for Generics { } /// A where-clause in a definition. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct WhereClause { /// `true` if we ate a `where` token: this can happen /// if we parsed no predicates (e.g. `struct Foo where {}`). @@ -418,7 +418,7 @@ pub struct WhereClause { } /// A single predicate in a where-clause. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum WherePredicate { /// A type binding (e.g., `for<'c> Foo: Send + Clone + 'c`). BoundPredicate(WhereBoundPredicate), @@ -441,7 +441,7 @@ impl WherePredicate { /// A type bound. /// /// E.g., `for<'c> Foo: Send + Clone + 'c`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct WhereBoundPredicate { pub span: Span, /// Any generics from a `for` binding. @@ -455,7 +455,7 @@ pub struct WhereBoundPredicate { /// A lifetime predicate. /// /// E.g., `'a: 'b + 'c`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct WhereRegionPredicate { pub span: Span, pub lifetime: Lifetime, @@ -465,7 +465,7 @@ pub struct WhereRegionPredicate { /// An equality predicate (unsupported). /// /// E.g., `T = int`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct WhereEqPredicate { pub id: NodeId, pub span: Span, @@ -473,7 +473,7 @@ pub struct WhereEqPredicate { pub rhs_ty: P<Ty>, } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct Crate { pub module: Mod, pub attrs: Vec<Attribute>, @@ -490,7 +490,7 @@ pub struct Crate { /// Possible values inside of compile-time attribute lists. /// /// E.g., the '..' in `#[name(..)]`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)] pub enum NestedMetaItem { /// A full MetaItem, for recursive meta items. MetaItem(MetaItem), @@ -503,7 +503,7 @@ pub enum NestedMetaItem { /// A spanned compile-time attribute item. /// /// E.g., `#[test]`, `#[derive(..)]`, `#[rustfmt::skip]` or `#[feature = "foo"]`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)] pub struct MetaItem { pub path: Path, pub kind: MetaItemKind, @@ -513,7 +513,7 @@ pub struct MetaItem { /// A compile-time attribute item. /// /// E.g., `#[test]`, `#[derive(..)]` or `#[feature = "foo"]`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)] pub enum MetaItemKind { /// Word meta item. /// @@ -532,7 +532,7 @@ pub enum MetaItemKind { /// A block (`{ .. }`). /// /// E.g., `{ .. }` as in `fn foo() { .. }`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct Block { /// The statements in the block. pub stmts: Vec<Stmt>, @@ -545,7 +545,7 @@ pub struct Block { /// A match pattern. /// /// Patterns appear in match statements and some other contexts, such as `let` and `if let`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct Pat { pub id: NodeId, pub kind: PatKind, @@ -636,7 +636,7 @@ impl Pat { /// Patterns like the fields of Foo `{ x, ref y, ref mut z }` /// are treated the same as` x: x, y: ref y, z: ref mut z`, /// except is_shorthand is true -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct FieldPat { /// The identifier for the field pub ident: Ident, @@ -649,19 +649,19 @@ pub struct FieldPat { pub is_placeholder: bool, } -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] +#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy)] pub enum BindingMode { ByRef(Mutability), ByValue(Mutability), } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum RangeEnd { Included(RangeSyntax), Excluded, } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum RangeSyntax { /// `...` DotDotDot, @@ -669,7 +669,7 @@ pub enum RangeSyntax { DotDotEq, } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum PatKind { /// Represents a wildcard pattern (`_`). Wild, @@ -736,8 +736,8 @@ pub enum PatKind { MacCall(MacCall), } -#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, Debug, Copy)] -#[derive(HashStable_Generic)] +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Copy)] +#[derive(HashStable_Generic, Encodable, Decodable)] pub enum Mutability { Mut, Not, @@ -770,7 +770,7 @@ impl Mutability { /// The kind of borrow in an `AddrOf` expression, /// e.g., `&place` or `&raw const place`. #[derive(Clone, Copy, PartialEq, Eq, Debug)] -#[derive(RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Encodable, Decodable, HashStable_Generic)] pub enum BorrowKind { /// A normal borrow, `&$expr` or `&mut $expr`. /// The resulting type is either `&'a T` or `&'a mut T` @@ -782,7 +782,7 @@ pub enum BorrowKind { Raw, } -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] +#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy)] pub enum BinOpKind { /// The `+` operator (addition) Add, @@ -881,7 +881,7 @@ pub type BinOp = Spanned<BinOpKind>; /// Unary operator. /// /// Note that `&data` is not an operator, it's an `AddrOf` expression. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Copy)] +#[derive(Clone, Encodable, Decodable, Debug, Copy)] pub enum UnOp { /// The `*` operator for dereferencing Deref, @@ -910,7 +910,7 @@ impl UnOp { } /// A statement -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct Stmt { pub id: NodeId, pub kind: StmtKind, @@ -944,7 +944,7 @@ impl Stmt { } } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum StmtKind { /// A local (let) binding. Local(P<Local>), @@ -960,7 +960,7 @@ pub enum StmtKind { MacCall(P<(MacCall, MacStmtStyle, AttrVec)>), } -#[derive(Clone, Copy, PartialEq, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug)] pub enum MacStmtStyle { /// The macro statement had a trailing semicolon (e.g., `foo! { ... };` /// `foo!(...);`, `foo![...];`). @@ -974,7 +974,7 @@ pub enum MacStmtStyle { } /// Local represents a `let` statement, e.g., `let <pat>:<ty> = <expr>;`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct Local { pub id: NodeId, pub pat: P<Pat>, @@ -995,7 +995,7 @@ pub struct Local { /// _ => { println!("no match!") }, /// } /// ``` -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct Arm { pub attrs: Vec<Attribute>, /// Match arm pattern, e.g. `10` in `match foo { 10 => {}, _ => {} }` @@ -1010,7 +1010,7 @@ pub struct Arm { } /// Access of a named (e.g., `obj.foo`) or unnamed (e.g., `obj.0`) struct field. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct Field { pub attrs: AttrVec, pub id: NodeId, @@ -1021,13 +1021,13 @@ pub struct Field { pub is_placeholder: bool, } -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] +#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy)] pub enum BlockCheckMode { Default, Unsafe(UnsafeSource), } -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] +#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy)] pub enum UnsafeSource { CompilerGenerated, UserProvided, @@ -1038,14 +1038,14 @@ pub enum UnsafeSource { /// These are usually found nested inside types (e.g., array lengths) /// or expressions (e.g., repeat counts), and also used to define /// explicit discriminant values for enum variants. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct AnonConst { pub id: NodeId, pub value: P<Expr>, } /// An expression. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct Expr { pub id: NodeId, pub kind: ExprKind, @@ -1204,7 +1204,7 @@ impl Expr { } /// Limit types of a range (inclusive or exclusive) -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] +#[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug)] pub enum RangeLimits { /// Inclusive at the beginning, exclusive at the end HalfOpen, @@ -1212,7 +1212,7 @@ pub enum RangeLimits { Closed, } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum ExprKind { /// A `box x` expression. Box(P<Expr>), @@ -1369,7 +1369,7 @@ pub enum ExprKind { /// ^~~~~ ^ /// ty position = 0 /// ``` -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct QSelf { pub ty: P<Ty>, @@ -1381,7 +1381,7 @@ pub struct QSelf { } /// A capture clause used in closures and `async` blocks. -#[derive(Clone, Copy, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)] pub enum CaptureBy { /// `move |x| y + x`. Value, @@ -1391,7 +1391,7 @@ pub enum CaptureBy { /// The movability of a generator / closure literal: /// whether a generator contains self-references, causing it to be `!Unpin`. -#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, Debug, Copy)] +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Encodable, Decodable, Debug, Copy)] #[derive(HashStable_Generic)] pub enum Movability { /// May contain self-references, `!Unpin`. @@ -1402,7 +1402,7 @@ pub enum Movability { /// Represents a macro invocation. The `path` indicates which macro /// is being invoked, and the `args` are arguments passed to it. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct MacCall { pub path: Path, pub args: P<MacArgs>, @@ -1416,7 +1416,7 @@ impl MacCall { } /// Arguments passed to an attribute or a function-like macro. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)] pub enum MacArgs { /// No arguments - `#[attr]`. Empty, @@ -1477,7 +1477,7 @@ impl MacArgs { } } -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug, HashStable_Generic)] pub enum MacDelimiter { Parenthesis, Bracket, @@ -1504,14 +1504,14 @@ impl MacDelimiter { } /// Represents a macro definition. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)] pub struct MacroDef { pub body: P<MacArgs>, /// `true` if macro was defined with `macro_rules`. pub macro_rules: bool, } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Copy, Hash, Eq, PartialEq)] +#[derive(Clone, Encodable, Decodable, Debug, Copy, Hash, Eq, PartialEq)] #[derive(HashStable_Generic)] pub enum StrStyle { /// A regular string, like `"foo"`. @@ -1523,7 +1523,7 @@ pub enum StrStyle { } /// An AST literal. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)] pub struct Lit { /// The original literal token as written in source code. pub token: token::Lit, @@ -1535,7 +1535,7 @@ pub struct Lit { } /// Same as `Lit`, but restricted to string literals. -#[derive(Clone, Copy, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Copy, Encodable, Decodable, Debug)] pub struct StrLit { /// The original literal token as written in source code. pub style: StrStyle, @@ -1562,7 +1562,7 @@ impl StrLit { } /// Type of the integer literal based on provided suffix. -#[derive(Clone, Copy, RustcEncodable, RustcDecodable, Debug, Hash, Eq, PartialEq)] +#[derive(Clone, Copy, Encodable, Decodable, Debug, Hash, Eq, PartialEq)] #[derive(HashStable_Generic)] pub enum LitIntType { /// e.g. `42_i32`. @@ -1574,7 +1574,7 @@ pub enum LitIntType { } /// Type of the float literal based on provided suffix. -#[derive(Clone, Copy, RustcEncodable, RustcDecodable, Debug, Hash, Eq, PartialEq)] +#[derive(Clone, Copy, Encodable, Decodable, Debug, Hash, Eq, PartialEq)] #[derive(HashStable_Generic)] pub enum LitFloatType { /// A float literal with a suffix (`1f32` or `1E10f32`). @@ -1586,7 +1586,7 @@ pub enum LitFloatType { /// Literal kind. /// /// E.g., `"foo"`, `42`, `12.34`, or `bool`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Hash, Eq, PartialEq, HashStable_Generic)] +#[derive(Clone, Encodable, Decodable, Debug, Hash, Eq, PartialEq, HashStable_Generic)] pub enum LitKind { /// A string literal (`"foo"`). Str(Symbol, StrStyle), @@ -1658,7 +1658,7 @@ impl LitKind { // N.B., If you change this, you'll probably want to change the corresponding // type structure in `middle/ty.rs` as well. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct MutTy { pub ty: P<Ty>, pub mutbl: Mutability, @@ -1666,14 +1666,14 @@ pub struct MutTy { /// Represents a function's signature in a trait declaration, /// trait implementation, or free function. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct FnSig { pub header: FnHeader, pub decl: P<FnDecl>, } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, Debug)] -#[derive(HashStable_Generic)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] +#[derive(Encodable, Decodable, HashStable_Generic)] pub enum FloatTy { F32, F64, @@ -1702,8 +1702,8 @@ impl FloatTy { } } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, Debug)] -#[derive(HashStable_Generic)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] +#[derive(Encodable, Decodable, HashStable_Generic)] pub enum IntTy { Isize, I8, @@ -1767,8 +1767,8 @@ impl IntTy { } } -#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, Copy, Debug)] -#[derive(HashStable_Generic)] +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, Debug)] +#[derive(Encodable, Decodable, HashStable_Generic)] pub enum UintTy { Usize, U8, @@ -1831,7 +1831,7 @@ impl UintTy { /// A constraint on an associated type (e.g., `A = Bar` in `Foo<A = Bar>` or /// `A: TraitA + TraitB` in `Foo<A: TraitA + TraitB>`). -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct AssocTyConstraint { pub id: NodeId, pub ident: Ident, @@ -1840,7 +1840,7 @@ pub struct AssocTyConstraint { } /// The kinds of an `AssocTyConstraint`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum AssocTyConstraintKind { /// E.g., `A = Bar` in `Foo<A = Bar>`. Equality { ty: P<Ty> }, @@ -1848,14 +1848,14 @@ pub enum AssocTyConstraintKind { Bound { bounds: GenericBounds }, } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct Ty { pub id: NodeId, pub kind: TyKind, pub span: Span, } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct BareFnTy { pub unsafety: Unsafe, pub ext: Extern, @@ -1864,7 +1864,7 @@ pub struct BareFnTy { } /// The various kinds of type recognized by the compiler. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum TyKind { /// A variable-length slice (`[T]`). Slice(P<Ty>), @@ -1923,7 +1923,7 @@ impl TyKind { } /// Syntax used to declare a trait object. -#[derive(Clone, Copy, PartialEq, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug)] pub enum TraitObjectSyntax { Dyn, None, @@ -1932,14 +1932,14 @@ pub enum TraitObjectSyntax { /// Inline assembly operand explicit register or register class. /// /// E.g., `"eax"` as in `asm!("mov eax, 2", out("eax") result)`. -#[derive(Clone, Copy, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Copy, Encodable, Decodable, Debug)] pub enum InlineAsmRegOrRegClass { Reg(Symbol), RegClass(Symbol), } bitflags::bitflags! { - #[derive(RustcEncodable, RustcDecodable, HashStable_Generic)] + #[derive(Encodable, Decodable, HashStable_Generic)] pub struct InlineAsmOptions: u8 { const PURE = 1 << 0; const NOMEM = 1 << 1; @@ -1951,7 +1951,7 @@ bitflags::bitflags! { } } -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)] pub enum InlineAsmTemplatePiece { String(String), Placeholder { operand_idx: usize, modifier: Option<char>, span: Span }, @@ -1995,7 +1995,7 @@ impl InlineAsmTemplatePiece { /// Inline assembly operand. /// /// E.g., `out("eax") result` as in `asm!("mov eax, 2", out("eax") result)`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum InlineAsmOperand { In { reg: InlineAsmRegOrRegClass, @@ -2028,7 +2028,7 @@ pub enum InlineAsmOperand { /// Inline assembly. /// /// E.g., `asm!("NOP");`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct InlineAsm { pub template: Vec<InlineAsmTemplatePiece>, pub operands: Vec<(InlineAsmOperand, Span)>, @@ -2039,7 +2039,7 @@ pub struct InlineAsm { /// Inline assembly dialect. /// /// E.g., `"intel"` as in `llvm_asm!("mov eax, 2" : "={eax}"(result) : : : "intel")`. -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy, HashStable_Generic)] +#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy, HashStable_Generic)] pub enum LlvmAsmDialect { Att, Intel, @@ -2048,7 +2048,7 @@ pub enum LlvmAsmDialect { /// LLVM-style inline assembly. /// /// E.g., `"={eax}"(result)` as in `llvm_asm!("mov eax, 2" : "={eax}"(result) : : : "intel")`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct LlvmInlineAsmOutput { pub constraint: Symbol, pub expr: P<Expr>, @@ -2059,7 +2059,7 @@ pub struct LlvmInlineAsmOutput { /// LLVM-style inline assembly. /// /// E.g., `llvm_asm!("NOP");`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct LlvmInlineAsm { pub asm: Symbol, pub asm_str_style: StrStyle, @@ -2074,7 +2074,7 @@ pub struct LlvmInlineAsm { /// A parameter in a function header. /// /// E.g., `bar: usize` as in `fn foo(bar: usize)`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct Param { pub attrs: AttrVec, pub ty: P<Ty>, @@ -2087,7 +2087,7 @@ pub struct Param { /// Alternative representation for `Arg`s describing `self` parameter of methods. /// /// E.g., `&mut self` as in `fn foo(&mut self)`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum SelfKind { /// `self`, `mut self` Value(Mutability), @@ -2165,7 +2165,7 @@ impl Param { /// /// Please note that it's different from `FnHeader` structure /// which contains metadata about function safety, asyncness, constness and ABI. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct FnDecl { pub inputs: Vec<Param>, pub output: FnRetTy, @@ -2187,20 +2187,20 @@ impl FnDecl { } /// Is the trait definition an auto trait? -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)] pub enum IsAuto { Yes, No, } -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Encodable, Decodable, Debug)] #[derive(HashStable_Generic)] pub enum Unsafe { Yes(Span), No, } -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Copy, Clone, Encodable, Decodable, Debug)] pub enum Async { Yes { span: Span, closure_id: NodeId, return_impl_trait_id: NodeId }, No, @@ -2220,7 +2220,7 @@ impl Async { } } -#[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, Encodable, Decodable, Debug)] #[derive(HashStable_Generic)] pub enum Const { Yes(Span), @@ -2229,13 +2229,13 @@ pub enum Const { /// Item defaultness. /// For details see the [RFC #2532](https://github.com/rust-lang/rfcs/pull/2532). -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)] pub enum Defaultness { Default(Span), Final, } -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Encodable, Decodable, HashStable_Generic)] pub enum ImplPolarity { /// `impl Trait for Type` Positive, @@ -2252,7 +2252,7 @@ impl fmt::Debug for ImplPolarity { } } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum FnRetTy { /// Returns type is not specified. /// @@ -2275,7 +2275,7 @@ impl FnRetTy { /// Module declaration. /// /// E.g., `mod foo;` or `mod foo { .. }`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Default)] +#[derive(Clone, Encodable, Decodable, Debug, Default)] pub struct Mod { /// A span from the first token past `{` to the last token until `}`. /// For `mod foo;`, the inner span ranges from the first token @@ -2289,7 +2289,7 @@ pub struct Mod { /// Foreign module declaration. /// /// E.g., `extern { .. }` or `extern C { .. }`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct ForeignMod { pub abi: Option<StrLit>, pub items: Vec<P<ForeignItem>>, @@ -2298,17 +2298,17 @@ pub struct ForeignMod { /// Global inline assembly. /// /// Also known as "module-level assembly" or "file-scoped assembly". -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Copy)] +#[derive(Clone, Encodable, Decodable, Debug, Copy)] pub struct GlobalAsm { pub asm: Symbol, } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct EnumDef { pub variants: Vec<Variant>, } /// Enum variant. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct Variant { /// Attributes of the variant. pub attrs: Vec<Attribute>, @@ -2330,7 +2330,7 @@ pub struct Variant { } /// Part of `use` item to the right of its prefix. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum UseTreeKind { /// `use prefix` or `use prefix as rename` /// @@ -2345,7 +2345,7 @@ pub enum UseTreeKind { /// A tree of paths sharing common prefixes. /// Used in `use` items both at top-level and inside of braces in import groups. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct UseTree { pub prefix: Path, pub kind: UseTreeKind, @@ -2367,7 +2367,7 @@ impl UseTree { /// Distinguishes between `Attribute`s that decorate items and Attributes that /// are contained as statements within items. These two cases need to be /// distinguished for pretty-printing. -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy, HashStable_Generic)] +#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy, HashStable_Generic)] pub enum AttrStyle { Outer, Inner, @@ -2380,19 +2380,19 @@ rustc_index::newtype_index! { } } -impl rustc_serialize::Encodable for AttrId { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder> rustc_serialize::Encodable<S> for AttrId { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_unit() } } -impl rustc_serialize::Decodable for AttrId { - fn decode<D: Decoder>(d: &mut D) -> Result<AttrId, D::Error> { +impl<D: Decoder> rustc_serialize::Decodable<D> for AttrId { + fn decode(d: &mut D) -> Result<AttrId, D::Error> { d.read_nil().map(|_| crate::attr::mk_attr_id()) } } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)] pub struct AttrItem { pub path: Path, pub args: MacArgs, @@ -2402,7 +2402,7 @@ pub struct AttrItem { pub type AttrVec = ThinVec<Attribute>; /// Metadata associated with an item. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct Attribute { pub kind: AttrKind, pub id: AttrId, @@ -2412,7 +2412,7 @@ pub struct Attribute { pub span: Span, } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum AttrKind { /// A normal attribute. Normal(AttrItem), @@ -2429,13 +2429,13 @@ pub enum AttrKind { /// that the `ref_id` is for. The `impl_id` maps to the "self type" of this impl. /// If this impl is an `ItemKind::Impl`, the `impl_id` is redundant (it could be the /// same as the impl's `NodeId`). -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct TraitRef { pub path: Path, pub ref_id: NodeId, } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct PolyTraitRef { /// The `'a` in `<'a> Foo<&'a T>`. pub bound_generic_params: Vec<GenericParam>, @@ -2456,7 +2456,7 @@ impl PolyTraitRef { } } -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, Encodable, Decodable, Debug, HashStable_Generic)] pub enum CrateSugar { /// Source is `pub(crate)`. PubCrate, @@ -2467,7 +2467,7 @@ pub enum CrateSugar { pub type Visibility = Spanned<VisibilityKind>; -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum VisibilityKind { Public, Crate(CrateSugar), @@ -2484,7 +2484,7 @@ impl VisibilityKind { /// Field of a struct. /// /// E.g., `bar: usize` as in `struct Foo { bar: usize }`. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct StructField { pub attrs: Vec<Attribute>, pub id: NodeId, @@ -2497,7 +2497,7 @@ pub struct StructField { } /// Fields and constructor ids of enum variants and structs. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum VariantData { /// Struct variant. /// @@ -2532,7 +2532,7 @@ impl VariantData { } /// An item definition. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct Item<K = ItemKind> { pub attrs: Vec<Attribute>, pub id: NodeId, @@ -2569,7 +2569,7 @@ impl<K: Into<ItemKind>> Item<K> { } /// `extern` qualifier on a function item or function type. -#[derive(Clone, Copy, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Copy, Encodable, Decodable, Debug)] pub enum Extern { None, Implicit, @@ -2586,7 +2586,7 @@ impl Extern { /// /// All the information between the visibility and the name of the function is /// included in this struct (e.g., `async unsafe fn` or `const extern "C" fn`). -#[derive(Clone, Copy, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Copy, Encodable, Decodable, Debug)] pub struct FnHeader { pub unsafety: Unsafe, pub asyncness: Async, @@ -2616,7 +2616,7 @@ impl Default for FnHeader { } } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum ItemKind { /// An `extern crate` item, with the optional *original* crate name if the crate was renamed. /// @@ -2755,7 +2755,7 @@ pub type AssocItem = Item<AssocItemKind>; /// In an implementation, all items must be provided. /// The `Option`s below denote the bodies, where `Some(_)` /// means "provided" and conversely `None` means "required". -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum AssocItemKind { /// An associated constant, `const $ident: $ty $def?;` where `def ::= "=" $expr? ;`. /// If `def` is parsed, then the constant is provided, and otherwise required. @@ -2803,7 +2803,7 @@ impl TryFrom<ItemKind> for AssocItemKind { } /// An item in `extern` block. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub enum ForeignItemKind { /// A foreign static item (`static FOO: u8`). Static(P<Ty>, Mutability, Option<P<Expr>>), diff --git a/src/librustc_ast/ast/tests.rs b/src/librustc_ast/ast/tests.rs index 7558e9cc3a3..8ba55bf037b 100644 --- a/src/librustc_ast/ast/tests.rs +++ b/src/librustc_ast/ast/tests.rs @@ -3,6 +3,9 @@ use super::*; // Are ASTs encodable? #[test] fn check_asts_encodable() { - fn assert_encodable<T: rustc_serialize::Encodable>() {} + fn assert_encodable< + T: for<'a> rustc_serialize::Encodable<rustc_serialize::json::Encoder<'a>>, + >() { + } assert_encodable::<Crate>(); } diff --git a/src/librustc_ast/crate_disambiguator.rs b/src/librustc_ast/crate_disambiguator.rs index 95d4c09dac3..bd7d8516714 100644 --- a/src/librustc_ast/crate_disambiguator.rs +++ b/src/librustc_ast/crate_disambiguator.rs @@ -9,7 +9,7 @@ use std::fmt; /// Hash value constructed out of all the `-C metadata` arguments passed to the /// compiler. Together with the crate-name forms a unique global identifier for /// the crate. -#[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Clone, Copy, RustcEncodable, RustcDecodable)] +#[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Clone, Copy, Encodable, Decodable)] pub struct CrateDisambiguator(Fingerprint); impl CrateDisambiguator { diff --git a/src/librustc_ast/lib.rs b/src/librustc_ast/lib.rs index 3f876169d22..fb5ce311826 100644 --- a/src/librustc_ast/lib.rs +++ b/src/librustc_ast/lib.rs @@ -18,8 +18,7 @@ #![feature(unicode_internals)] #![recursion_limit = "256"] -// FIXME(#56935): Work around ICEs during cross-compilation. -#[allow(unused)] +#[macro_use] extern crate rustc_macros; #[macro_export] diff --git a/src/librustc_ast/node_id.rs b/src/librustc_ast/node_id.rs index cd562c48e91..1035e945538 100644 --- a/src/librustc_ast/node_id.rs +++ b/src/librustc_ast/node_id.rs @@ -1,10 +1,8 @@ -use rustc_serialize::{Decoder, Encoder}; use rustc_span::ExpnId; use std::fmt; rustc_index::newtype_index! { pub struct NodeId { - ENCODABLE = custom DEBUG_FORMAT = "NodeId({})" } } @@ -34,15 +32,3 @@ impl fmt::Display for NodeId { fmt::Display::fmt(&self.as_u32(), f) } } - -impl rustc_serialize::UseSpecializedEncodable for NodeId { - fn default_encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_u32(self.as_u32()) - } -} - -impl rustc_serialize::UseSpecializedDecodable for NodeId { - fn default_decode<D: Decoder>(d: &mut D) -> Result<NodeId, D::Error> { - d.read_u32().map(NodeId::from_u32) - } -} diff --git a/src/librustc_ast/ptr.rs b/src/librustc_ast/ptr.rs index 4597624ef88..e4a3cccb7ea 100644 --- a/src/librustc_ast/ptr.rs +++ b/src/librustc_ast/ptr.rs @@ -114,14 +114,14 @@ impl<T> fmt::Pointer for P<T> { } } -impl<T: 'static + Decodable> Decodable for P<T> { - fn decode<D: Decoder>(d: &mut D) -> Result<P<T>, D::Error> { +impl<D: Decoder, T: 'static + Decodable<D>> Decodable<D> for P<T> { + fn decode(d: &mut D) -> Result<P<T>, D::Error> { Decodable::decode(d).map(P) } } -impl<T: Encodable> Encodable for P<T> { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, T: Encodable<S>> Encodable<S> for P<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { (**self).encode(s) } } @@ -197,14 +197,14 @@ impl<'a, T> IntoIterator for &'a P<[T]> { } } -impl<T: Encodable> Encodable for P<[T]> { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, T: Encodable<S>> Encodable<S> for P<[T]> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { Encodable::encode(&**self, s) } } -impl<T: Decodable> Decodable for P<[T]> { - fn decode<D: Decoder>(d: &mut D) -> Result<P<[T]>, D::Error> { +impl<D: Decoder, T: Decodable<D>> Decodable<D> for P<[T]> { + fn decode(d: &mut D) -> Result<P<[T]>, D::Error> { Ok(P::from_vec(Decodable::decode(d)?)) } } diff --git a/src/librustc_ast/token.rs b/src/librustc_ast/token.rs index bcce881ed48..46c4be0a33b 100644 --- a/src/librustc_ast/token.rs +++ b/src/librustc_ast/token.rs @@ -17,13 +17,13 @@ use rustc_span::{self, Span, DUMMY_SP}; use std::borrow::Cow; use std::{fmt, mem}; -#[derive(Clone, Copy, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)] pub enum CommentKind { Line, Block, } -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, Encodable, Decodable, Hash, Debug, Copy)] #[derive(HashStable_Generic)] pub enum BinOpToken { Plus, @@ -39,7 +39,7 @@ pub enum BinOpToken { } /// A delimiter token. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] +#[derive(Clone, PartialEq, Eq, Encodable, Decodable, Hash, Debug, Copy)] #[derive(HashStable_Generic)] pub enum DelimToken { /// A round parenthesis (i.e., `(` or `)`). @@ -62,7 +62,7 @@ impl DelimToken { } } -#[derive(Clone, Copy, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)] pub enum LitKind { Bool, // AST only, must never appear in a `Token` Byte, @@ -77,7 +77,7 @@ pub enum LitKind { } /// A literal token. -#[derive(Clone, Copy, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)] pub struct Lit { pub kind: LitKind, pub symbol: Symbol, @@ -188,7 +188,7 @@ fn ident_can_begin_type(name: Symbol, span: Span, is_raw: bool) -> bool { .contains(&name) } -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)] pub enum TokenKind { /* Expression-operator symbols. */ Eq, @@ -267,7 +267,7 @@ pub enum TokenKind { #[cfg(target_arch = "x86_64")] rustc_data_structures::static_assert_size!(TokenKind, 16); -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)] pub struct Token { pub kind: TokenKind, pub span: Span, @@ -688,7 +688,7 @@ impl PartialEq<TokenKind> for Token { } } -#[derive(Clone, RustcEncodable, RustcDecodable)] +#[derive(Clone, Encodable, Decodable)] /// For interpolation during macro expansion. pub enum Nonterminal { NtItem(P<ast::Item>), @@ -711,7 +711,7 @@ pub enum Nonterminal { #[cfg(target_arch = "x86_64")] rustc_data_structures::static_assert_size!(Nonterminal, 40); -#[derive(Debug, Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)] +#[derive(Debug, Copy, Clone, PartialEq, Encodable, Decodable)] pub enum NonterminalKind { Item, Block, diff --git a/src/librustc_ast/tokenstream.rs b/src/librustc_ast/tokenstream.rs index 9d0199078fa..151acddae84 100644 --- a/src/librustc_ast/tokenstream.rs +++ b/src/librustc_ast/tokenstream.rs @@ -35,7 +35,7 @@ use std::{iter, mem}; /// /// The RHS of an MBE macro is the only place `SubstNt`s are substituted. /// Nothing special happens to misnamed or misplaced `SubstNt`s. -#[derive(Debug, Clone, PartialEq, RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Debug, Clone, PartialEq, Encodable, Decodable, HashStable_Generic)] pub enum TokenTree { /// A single token Token(Token), @@ -124,7 +124,7 @@ where /// The goal is for procedural macros to work with `TokenStream`s and `TokenTree`s /// instead of a representation of the abstract syntax tree. /// Today's `TokenTree`s can still contain AST via `token::Interpolated` for back-compat. -#[derive(Clone, Debug, Default, RustcEncodable, RustcDecodable)] +#[derive(Clone, Debug, Default, Encodable, Decodable)] pub struct TokenStream(pub Lrc<Vec<TreeAndJoint>>); pub type TreeAndJoint = (TokenTree, IsJoint); @@ -133,7 +133,7 @@ pub type TreeAndJoint = (TokenTree, IsJoint); #[cfg(target_arch = "x86_64")] rustc_data_structures::static_assert_size!(TokenStream, 8); -#[derive(Clone, Copy, Debug, PartialEq, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, Debug, PartialEq, Encodable, Decodable)] pub enum IsJoint { Joint, NonJoint, @@ -408,7 +408,7 @@ impl Cursor { } } -#[derive(Debug, Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Debug, Copy, Clone, PartialEq, Encodable, Decodable, HashStable_Generic)] pub struct DelimSpan { pub open: Span, pub close: Span, diff --git a/src/librustc_ast/util/literal.rs b/src/librustc_ast/util/literal.rs index 4428d09902b..597e5b437fc 100644 --- a/src/librustc_ast/util/literal.rs +++ b/src/librustc_ast/util/literal.rs @@ -10,8 +10,8 @@ use rustc_lexer::unescape::{unescape_byte_literal, unescape_literal, Mode}; use rustc_span::symbol::{kw, sym, Symbol}; use rustc_span::Span; -use log::debug; use std::ascii; +use tracing::debug; pub enum LitError { NotLiteral, diff --git a/src/librustc_ast/util/parser.rs b/src/librustc_ast/util/parser.rs index e5bcc571d41..2ee94965756 100644 --- a/src/librustc_ast/util/parser.rs +++ b/src/librustc_ast/util/parser.rs @@ -222,7 +222,6 @@ impl AssocOp { Greater | // `{ 42 } > 3` GreaterEqual | // `{ 42 } >= 3` AssignOp(_) | // `{ 42 } +=` - LAnd | // `{ 42 } &&foo` As | // `{ 42 } as usize` // Equal | // `{ 42 } == { 42 }` Accepting these here would regress incorrect // NotEqual | // `{ 42 } != { 42 } struct literals parser recovery. diff --git a/src/librustc_ast/visit.rs b/src/librustc_ast/visit.rs index 2c3d1e97df9..b65a88cb90e 100644 --- a/src/librustc_ast/visit.rs +++ b/src/librustc_ast/visit.rs @@ -50,6 +50,13 @@ impl<'a> FnKind<'a> { } } + pub fn ident(&self) -> Option<&Ident> { + match self { + FnKind::Fn(_, ident, ..) => Some(ident), + _ => None, + } + } + pub fn decl(&self) -> &'a FnDecl { match self { FnKind::Fn(_, _, sig, _, _) => &sig.decl, diff --git a/src/librustc_ast_passes/ast_validation.rs b/src/librustc_ast_passes/ast_validation.rs index 244377dfa1d..3c2a063cf24 100644 --- a/src/librustc_ast_passes/ast_validation.rs +++ b/src/librustc_ast_passes/ast_validation.rs @@ -777,7 +777,7 @@ fn validate_generic_param_order<'a>( if sess.features_untracked().const_generics { ", then consts and types" } else if sess.features_untracked().min_const_generics { - ", then consts, then types" + ", then types, then consts" } else { ", then types" }, diff --git a/src/librustc_attr/builtin.rs b/src/librustc_attr/builtin.rs index 5f131fae385..3ddabcc17f8 100644 --- a/src/librustc_attr/builtin.rs +++ b/src/librustc_attr/builtin.rs @@ -67,7 +67,7 @@ fn handle_errors(sess: &ParseSess, span: Span, error: AttrError) { } } -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable)] +#[derive(Clone, PartialEq, Encodable, Decodable)] pub enum InlineAttr { None, Hint, @@ -75,7 +75,7 @@ pub enum InlineAttr { Never, } -#[derive(Clone, RustcEncodable, RustcDecodable)] +#[derive(Clone, Encodable, Decodable)] pub enum OptimizeAttr { None, Speed, @@ -130,7 +130,7 @@ pub fn find_unwind_attr(sess: &Session, attrs: &[Attribute]) -> Option<UnwindAtt /// /// - `#[stable]` /// - `#[unstable]` -#[derive(RustcEncodable, RustcDecodable, Copy, Clone, Debug, PartialEq, Eq, Hash)] +#[derive(Encodable, Decodable, Copy, Clone, Debug, PartialEq, Eq, Hash)] #[derive(HashStable_Generic)] pub struct Stability { pub level: StabilityLevel, @@ -138,7 +138,7 @@ pub struct Stability { } /// Represents the `#[rustc_const_unstable]` and `#[rustc_const_stable]` attributes. -#[derive(RustcEncodable, RustcDecodable, Copy, Clone, Debug, PartialEq, Eq, Hash)] +#[derive(Encodable, Decodable, Copy, Clone, Debug, PartialEq, Eq, Hash)] #[derive(HashStable_Generic)] pub struct ConstStability { pub level: StabilityLevel, @@ -150,7 +150,7 @@ pub struct ConstStability { } /// The available stability levels. -#[derive(RustcEncodable, RustcDecodable, PartialEq, PartialOrd, Copy, Clone, Debug, Eq, Hash)] +#[derive(Encodable, Decodable, PartialEq, PartialOrd, Copy, Clone, Debug, Eq, Hash)] #[derive(HashStable_Generic)] pub enum StabilityLevel { // Reason for the current stability level and the relevant rust-lang issue @@ -632,7 +632,7 @@ pub fn eval_condition( } } -#[derive(RustcEncodable, RustcDecodable, Clone, HashStable_Generic)] +#[derive(Encodable, Decodable, Clone, HashStable_Generic)] pub struct Deprecation { pub since: Option<Symbol>, /// The note to issue a reason. @@ -797,7 +797,7 @@ where depr } -#[derive(PartialEq, Debug, RustcEncodable, RustcDecodable, Copy, Clone)] +#[derive(PartialEq, Debug, Encodable, Decodable, Copy, Clone)] pub enum ReprAttr { ReprInt(IntType), ReprC, @@ -808,7 +808,8 @@ pub enum ReprAttr { ReprNoNiche, } -#[derive(Eq, PartialEq, Debug, RustcEncodable, RustcDecodable, Copy, Clone, HashStable_Generic)] +#[derive(Eq, PartialEq, Debug, Copy, Clone)] +#[derive(Encodable, Decodable, HashStable_Generic)] pub enum IntType { SignedInt(ast::IntTy), UnsignedInt(ast::UintTy), diff --git a/src/librustc_attr/lib.rs b/src/librustc_attr/lib.rs index 5754bb48d24..149a950f7d4 100644 --- a/src/librustc_attr/lib.rs +++ b/src/librustc_attr/lib.rs @@ -6,8 +6,7 @@ #![feature(or_patterns)] -// FIXME(#56935): Work around ICEs during cross-compilation. -#[allow(unused)] +#[macro_use] extern crate rustc_macros; mod builtin; diff --git a/src/librustc_builtin_macros/format.rs b/src/librustc_builtin_macros/format.rs index 55eab24b8a5..78cead02b7b 100644 --- a/src/librustc_builtin_macros/format.rs +++ b/src/librustc_builtin_macros/format.rs @@ -149,7 +149,7 @@ fn parse_args<'a>( return Err(err); } else { // ...after that delegate to `expect` to also include the other expected tokens. - return Err(p.expect(&token::Comma).err().unwrap()); + let _ = p.expect(&token::Comma)?; } } first = false; @@ -359,24 +359,18 @@ impl<'a, 'b> Context<'a, 'b> { // for `println!("{7:7$}", 1);` refs.sort(); refs.dedup(); - let (arg_list, mut sp) = if refs.len() == 1 { - let spans: Vec<_> = spans.into_iter().filter_map(|sp| sp.copied()).collect(); - ( - format!("argument {}", refs[0]), - if spans.is_empty() { - MultiSpan::from_span(self.fmtsp) - } else { - MultiSpan::from_spans(spans) - }, - ) + let spans: Vec<_> = spans.into_iter().filter_map(|sp| sp.copied()).collect(); + let sp = if self.arg_spans.is_empty() || spans.is_empty() { + MultiSpan::from_span(self.fmtsp) + } else { + MultiSpan::from_spans(spans) + }; + let arg_list = if refs.len() == 1 { + format!("argument {}", refs[0]) } else { - let pos = MultiSpan::from_spans(spans.into_iter().map(|s| *s.unwrap()).collect()); let reg = refs.pop().unwrap(); - (format!("arguments {head} and {tail}", head = refs.join(", "), tail = reg,), pos) + format!("arguments {head} and {tail}", head = refs.join(", "), tail = reg) }; - if self.arg_spans.is_empty() { - sp = MultiSpan::from_span(self.fmtsp); - } e = self.ecx.struct_span_err( sp, @@ -1067,10 +1061,9 @@ pub fn expand_preparsed_format_args( let args_unused = errs_len; let mut diag = { - if errs_len == 1 { - let (sp, msg) = errs.into_iter().next().unwrap(); - let mut diag = cx.ecx.struct_span_err(sp, msg); - diag.span_label(sp, msg); + if let [(sp, msg)] = &errs[..] { + let mut diag = cx.ecx.struct_span_err(*sp, *msg); + diag.span_label(*sp, *msg); diag } else { let mut diag = cx.ecx.struct_span_err( diff --git a/src/librustc_codegen_llvm/back/write.rs b/src/librustc_codegen_llvm/back/write.rs index 54271d3dd04..1a5794d1133 100644 --- a/src/librustc_codegen_llvm/back/write.rs +++ b/src/librustc_codegen_llvm/back/write.rs @@ -975,7 +975,6 @@ pub unsafe fn with_llvm_pmb( (llvm::CodeGenOptLevel::Default, ..) => { llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder, 225); } - (llvm::CodeGenOptLevel::Other, ..) => bug!("CodeGenOptLevel::Other selected"), } f(builder); diff --git a/src/librustc_codegen_llvm/consts.rs b/src/librustc_codegen_llvm/consts.rs index 024834bfe2a..0c749657001 100644 --- a/src/librustc_codegen_llvm/consts.rs +++ b/src/librustc_codegen_llvm/consts.rs @@ -215,7 +215,7 @@ impl CodegenCx<'ll, 'tcx> { debug!("get_static: sym={} instance={:?}", sym, instance); let g = if let Some(def_id) = def_id.as_local() { - let id = self.tcx.hir().as_local_hir_id(def_id); + let id = self.tcx.hir().local_def_id_to_hir_id(def_id); let llty = self.layout_of(ty).llvm_type(self); // FIXME: refactor this to work without accessing the HIR let (g, attrs) = match self.tcx.hir().get(id) { diff --git a/src/librustc_codegen_llvm/coverageinfo/mod.rs b/src/librustc_codegen_llvm/coverageinfo/mod.rs index 90831f0bcfb..da567293d7b 100644 --- a/src/librustc_codegen_llvm/coverageinfo/mod.rs +++ b/src/librustc_codegen_llvm/coverageinfo/mod.rs @@ -8,7 +8,7 @@ use llvm::coverageinfo::CounterMappingRegion; use log::debug; use rustc_codegen_ssa::coverageinfo::map::{CounterExpression, ExprKind, FunctionCoverage, Region}; use rustc_codegen_ssa::traits::{ - BaseTypeMethods, CoverageInfoBuilderMethods, CoverageInfoMethods, StaticMethods, + BaseTypeMethods, CoverageInfoBuilderMethods, CoverageInfoMethods, MiscMethods, StaticMethods, }; use rustc_data_structures::fx::FxHashMap; use rustc_llvm::RustString; @@ -44,6 +44,16 @@ impl CoverageInfoMethods for CodegenCx<'ll, 'tcx> { } impl CoverageInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> { + /// Calls llvm::createPGOFuncNameVar() with the given function instance's mangled function name. + /// The LLVM API returns an llvm::GlobalVariable containing the function name, with the specific + /// variable name and linkage required by LLVM InstrProf source-based coverage instrumentation. + fn create_pgo_func_name_var(&self, instance: Instance<'tcx>) -> Self::Value { + let llfn = self.cx.get_fn(instance); + let mangled_fn_name = CString::new(self.tcx.symbol_name(instance).name) + .expect("error converting function name to C string"); + unsafe { llvm::LLVMRustCoverageCreatePGOFuncNameVar(llfn, mangled_fn_name.as_ptr()) } + } + fn add_counter_region( &mut self, instance: Instance<'tcx>, diff --git a/src/librustc_codegen_llvm/intrinsic.rs b/src/librustc_codegen_llvm/intrinsic.rs index dfd5104a31f..14aec1ff5e1 100644 --- a/src/librustc_codegen_llvm/intrinsic.rs +++ b/src/librustc_codegen_llvm/intrinsic.rs @@ -215,19 +215,19 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> { self.call(llfn, &[], None) } sym::count_code_region => { - let coverageinfo = tcx.coverageinfo(caller_instance.def_id()); - let mangled_fn = tcx.symbol_name(caller_instance); - let (mangled_fn_name, _len_val) = self.const_str(Symbol::intern(mangled_fn.name)); - let num_counters = self.const_u32(coverageinfo.num_counters); use coverage::count_code_region_args::*; + let coverageinfo = tcx.coverageinfo(caller_instance.def_id()); + + let fn_name = self.create_pgo_func_name_var(caller_instance); let hash = args[FUNCTION_SOURCE_HASH].immediate(); + let num_counters = self.const_u32(coverageinfo.num_counters); let index = args[COUNTER_ID].immediate(); debug!( "translating Rust intrinsic `count_code_region()` to LLVM intrinsic: \ - instrprof.increment(fn_name={}, hash={:?}, num_counters={:?}, index={:?})", - mangled_fn.name, hash, num_counters, index, + instrprof.increment(fn_name={:?}, hash={:?}, num_counters={:?}, index={:?})", + fn_name, hash, num_counters, index, ); - self.instrprof_increment(mangled_fn_name, hash, num_counters, index) + self.instrprof_increment(fn_name, hash, num_counters, index) } sym::va_start => self.va_start(args[0].immediate()), sym::va_end => self.va_end(args[0].immediate()), diff --git a/src/librustc_codegen_llvm/llvm/ffi.rs b/src/librustc_codegen_llvm/llvm/ffi.rs index eb7dc827f93..63b0aa64bd3 100644 --- a/src/librustc_codegen_llvm/llvm/ffi.rs +++ b/src/librustc_codegen_llvm/llvm/ffi.rs @@ -337,9 +337,6 @@ impl AtomicOrdering { #[derive(Copy, Clone)] #[repr(C)] pub enum SynchronizationScope { - // FIXME: figure out if this variant is needed at all. - #[allow(dead_code)] - Other, SingleThread, CrossThread, } @@ -347,7 +344,6 @@ pub enum SynchronizationScope { impl SynchronizationScope { pub fn from_generic(sc: rustc_codegen_ssa::common::SynchronizationScope) -> Self { match sc { - rustc_codegen_ssa::common::SynchronizationScope::Other => SynchronizationScope::Other, rustc_codegen_ssa::common::SynchronizationScope::SingleThread => { SynchronizationScope::SingleThread } @@ -362,9 +358,6 @@ impl SynchronizationScope { #[derive(Copy, Clone)] #[repr(C)] pub enum FileType { - // FIXME: figure out if this variant is needed at all. - #[allow(dead_code)] - Other, AssemblyFile, ObjectFile, } @@ -391,9 +384,6 @@ pub enum MetadataType { #[derive(Copy, Clone)] #[repr(C)] pub enum AsmDialect { - // FIXME: figure out if this variant is needed at all. - #[allow(dead_code)] - Other, Att, Intel, } @@ -411,9 +401,6 @@ impl AsmDialect { #[derive(Copy, Clone, PartialEq)] #[repr(C)] pub enum CodeGenOptLevel { - // FIXME: figure out if this variant is needed at all. - #[allow(dead_code)] - Other, None, Less, Default, @@ -513,9 +500,6 @@ pub enum DiagnosticLevel { #[derive(Copy, Clone)] #[repr(C)] pub enum ArchiveKind { - // FIXME: figure out if this variant is needed at all. - #[allow(dead_code)] - Other, K_GNU, K_BSD, K_DARWIN, @@ -1802,6 +1786,8 @@ extern "C" { BufferOut: &RustString, ); + pub fn LLVMRustCoverageCreatePGOFuncNameVar(F: &'a Value, FuncName: *const c_char) + -> &'a Value; pub fn LLVMRustCoverageComputeHash(Name: *const c_char) -> u64; #[allow(improper_ctypes)] diff --git a/src/librustc_codegen_llvm/llvm_util.rs b/src/librustc_codegen_llvm/llvm_util.rs index b631c10334c..f0b50459837 100644 --- a/src/librustc_codegen_llvm/llvm_util.rs +++ b/src/librustc_codegen_llvm/llvm_util.rs @@ -73,7 +73,8 @@ unsafe fn configure_llvm(sess: &Session) { llvm_c_strs.push(s); } }; - add("rustc", true); // fake program name + // Set the llvm "program name" to make usage and invalid argument messages more clear. + add("rustc -Cllvm-args=\"...\" with", true); if sess.time_llvm_passes() { add("-time-passes", false); } diff --git a/src/librustc_codegen_ssa/Cargo.toml b/src/librustc_codegen_ssa/Cargo.toml index 8fa0de37648..ff9dac372ab 100644 --- a/src/librustc_codegen_ssa/Cargo.toml +++ b/src/librustc_codegen_ssa/Cargo.toml @@ -33,5 +33,6 @@ rustc_fs_util = { path = "../librustc_fs_util" } rustc_hir = { path = "../librustc_hir" } rustc_incremental = { path = "../librustc_incremental" } rustc_index = { path = "../librustc_index" } +rustc_macros = { path = "../librustc_macros" } rustc_target = { path = "../librustc_target" } rustc_session = { path = "../librustc_session" } diff --git a/src/librustc_codegen_ssa/back/link.rs b/src/librustc_codegen_ssa/back/link.rs index d725a60118e..bfcf979d125 100644 --- a/src/librustc_codegen_ssa/back/link.rs +++ b/src/librustc_codegen_ssa/back/link.rs @@ -769,9 +769,22 @@ fn link_natively<'a, B: ArchiveBuilder<'a>>( } fn link_sanitizers(sess: &Session, crate_type: CrateType, linker: &mut dyn Linker) { - if crate_type != CrateType::Executable { + // On macOS the runtimes are distributed as dylibs which should be linked to + // both executables and dynamic shared objects. Everywhere else the runtimes + // are currently distributed as static liraries which should be linked to + // executables only. + let needs_runtime = match crate_type { + CrateType::Executable => true, + CrateType::Dylib | CrateType::Cdylib | CrateType::ProcMacro => { + sess.target.target.options.is_like_osx + } + CrateType::Rlib | CrateType::Staticlib => false, + }; + + if !needs_runtime { return; } + let sanitizer = sess.opts.debugging_opts.sanitizer; if sanitizer.contains(SanitizerSet::ADDRESS) { link_sanitizer_runtime(sess, linker, "asan"); @@ -809,6 +822,7 @@ fn link_sanitizer_runtime(sess: &Session, linker: &mut dyn Linker, name: &str) { "aarch64-fuchsia" | "aarch64-unknown-linux-gnu" | "x86_64-fuchsia" + | "x86_64-unknown-freebsd" | "x86_64-unknown-linux-gnu" => { let filename = format!("librustc{}_rt.{}.a", channel, name); let path = default_tlib.join(&filename); diff --git a/src/librustc_codegen_ssa/back/linker.rs b/src/librustc_codegen_ssa/back/linker.rs index f9a782af24c..5100ef8ad4f 100644 --- a/src/librustc_codegen_ssa/back/linker.rs +++ b/src/librustc_codegen_ssa/back/linker.rs @@ -35,7 +35,7 @@ pub fn disable_localization(linker: &mut Command) { /// For all the linkers we support, and information they might /// need out of the shared crate context before we get rid of it. -#[derive(RustcEncodable, RustcDecodable)] +#[derive(Encodable, Decodable)] pub struct LinkerInfo { exports: FxHashMap<CrateType, Vec<String>>, } diff --git a/src/librustc_codegen_ssa/back/symbol_export.rs b/src/librustc_codegen_ssa/back/symbol_export.rs index 7d742e7a7af..87d7f00c703 100644 --- a/src/librustc_codegen_ssa/back/symbol_export.rs +++ b/src/librustc_codegen_ssa/back/symbol_export.rs @@ -190,7 +190,9 @@ fn exported_symbols_provider_local( } } - if tcx.sess.opts.cg.profile_generate.enabled() { + if tcx.sess.opts.debugging_opts.instrument_coverage + || tcx.sess.opts.cg.profile_generate.enabled() + { // These are weak symbols that point to the profile version and the // profile name, which need to be treated as exported so LTO doesn't nix // them. @@ -203,17 +205,6 @@ fn exported_symbols_provider_local( })); } - if tcx.sess.opts.debugging_opts.instrument_coverage { - // Similar to PGO profiling, preserve symbols used by LLVM InstrProf coverage profiling. - const COVERAGE_WEAK_SYMBOLS: [&str; 3] = - ["__llvm_profile_filename", "__llvm_coverage_mapping", "__llvm_covmap"]; - - symbols.extend(COVERAGE_WEAK_SYMBOLS.iter().map(|sym| { - let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, sym)); - (exported_symbol, SymbolExportLevel::C) - })); - } - if tcx.sess.opts.debugging_opts.sanitizer.contains(SanitizerSet::MEMORY) { // Similar to profiling, preserve weak msan symbol during LTO. const MSAN_WEAK_SYMBOLS: [&str; 2] = ["__msan_track_origins", "__msan_keep_going"]; @@ -370,7 +361,7 @@ fn upstream_drop_glue_for_provider<'tcx>( fn is_unreachable_local_definition_provider(tcx: TyCtxt<'_>, def_id: DefId) -> bool { if let Some(def_id) = def_id.as_local() { - !tcx.reachable_set(LOCAL_CRATE).contains(&tcx.hir().as_local_hir_id(def_id)) + !tcx.reachable_set(LOCAL_CRATE).contains(&tcx.hir().local_def_id_to_hir_id(def_id)) } else { bug!("is_unreachable_local_definition called with non-local DefId: {:?}", def_id) } diff --git a/src/librustc_codegen_ssa/common.rs b/src/librustc_codegen_ssa/common.rs index 432b2f3bdc3..e04ed531bbf 100644 --- a/src/librustc_codegen_ssa/common.rs +++ b/src/librustc_codegen_ssa/common.rs @@ -72,9 +72,6 @@ pub enum AtomicOrdering { } pub enum SynchronizationScope { - // FIXME: figure out if this variant is needed at all. - #[allow(dead_code)] - Other, SingleThread, CrossThread, } diff --git a/src/librustc_codegen_ssa/lib.rs b/src/librustc_codegen_ssa/lib.rs index 85260d30a3d..6bfbda0f1d7 100644 --- a/src/librustc_codegen_ssa/lib.rs +++ b/src/librustc_codegen_ssa/lib.rs @@ -17,6 +17,8 @@ //! have to be implemented by each backends. #[macro_use] +extern crate rustc_macros; +#[macro_use] extern crate log; #[macro_use] extern crate rustc_middle; @@ -74,7 +76,7 @@ impl<M> ModuleCodegen<M> { } } -#[derive(Debug, RustcEncodable, RustcDecodable)] +#[derive(Debug, Encodable, Decodable)] pub struct CompiledModule { pub name: String, pub kind: ModuleKind, @@ -87,7 +89,7 @@ pub struct CachedModuleCodegen { pub source: WorkProduct, } -#[derive(Copy, Clone, Debug, PartialEq, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, PartialEq, Encodable, Decodable)] pub enum ModuleKind { Regular, Metadata, @@ -110,7 +112,7 @@ bitflags::bitflags! { /// identifiers (`CrateNum`) to `CrateSource`. The other fields map `CrateNum` to the crate's own /// additional properties, so that effectively we can retrieve each dependent crate's `CrateSource` /// and the corresponding properties without referencing information outside of a `CrateInfo`. -#[derive(Debug, RustcEncodable, RustcDecodable)] +#[derive(Debug, Encodable, Decodable)] pub struct CrateInfo { pub panic_runtime: Option<CrateNum>, pub compiler_builtins: Option<CrateNum>, @@ -128,7 +130,7 @@ pub struct CrateInfo { pub dependency_formats: Lrc<Dependencies>, } -#[derive(RustcEncodable, RustcDecodable)] +#[derive(Encodable, Decodable)] pub struct CodegenResults { pub crate_name: Symbol, pub modules: Vec<CompiledModule>, diff --git a/src/librustc_codegen_ssa/mir/debuginfo.rs b/src/librustc_codegen_ssa/mir/debuginfo.rs index d166a27b5a9..d8a530d98fa 100644 --- a/src/librustc_codegen_ssa/mir/debuginfo.rs +++ b/src/librustc_codegen_ssa/mir/debuginfo.rs @@ -1,6 +1,7 @@ use crate::traits::*; use rustc_hir::def_id::CrateNum; use rustc_index::vec::IndexVec; +use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags; use rustc_middle::mir; use rustc_middle::ty; use rustc_session::config::DebugInfo; @@ -216,6 +217,13 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { LocalRef::Operand(None) => return, LocalRef::Operand(Some(operand)) => { + // Don't spill operands onto the stack in naked functions. + // See: https://github.com/rust-lang/rust/issues/42779 + let attrs = bx.tcx().codegen_fn_attrs(self.instance.def_id()); + if attrs.flags.contains(CodegenFnAttrFlags::NAKED) { + return; + } + // "Spill" the value onto the stack, for debuginfo, // without forcing non-debuginfo uses of the local // to also load from the stack every single time. diff --git a/src/librustc_codegen_ssa/traits/coverageinfo.rs b/src/librustc_codegen_ssa/traits/coverageinfo.rs index 2b5878f46bc..5602599b0c2 100644 --- a/src/librustc_codegen_ssa/traits/coverageinfo.rs +++ b/src/librustc_codegen_ssa/traits/coverageinfo.rs @@ -7,6 +7,8 @@ pub trait CoverageInfoMethods: BackendTypes { } pub trait CoverageInfoBuilderMethods<'tcx>: BackendTypes { + fn create_pgo_func_name_var(&self, instance: Instance<'tcx>) -> Self::Value; + fn add_counter_region( &mut self, instance: Instance<'tcx>, diff --git a/src/librustc_data_structures/Cargo.toml b/src/librustc_data_structures/Cargo.toml index 36c32e60031..1926dbf06e7 100644 --- a/src/librustc_data_structures/Cargo.toml +++ b/src/librustc_data_structures/Cargo.toml @@ -17,6 +17,7 @@ jobserver_crate = { version = "0.1.13", package = "jobserver" } lazy_static = "1" once_cell = { version = "1", features = ["parking_lot"] } rustc_serialize = { path = "../librustc_serialize" } +rustc_macros = { path = "../librustc_macros" } rustc_graphviz = { path = "../librustc_graphviz" } cfg-if = "0.1.2" crossbeam-utils = { version = "0.7", features = ["nightly"] } diff --git a/src/librustc_data_structures/fingerprint.rs b/src/librustc_data_structures/fingerprint.rs index 282626611d5..f8d631ce01e 100644 --- a/src/librustc_data_structures/fingerprint.rs +++ b/src/librustc_data_structures/fingerprint.rs @@ -1,5 +1,8 @@ use crate::stable_hasher; -use rustc_serialize::opaque::{Decoder, EncodeResult, Encoder}; +use rustc_serialize::{ + opaque::{self, EncodeResult}, + Decodable, Encodable, +}; use std::mem; #[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Clone, Copy)] @@ -49,14 +52,14 @@ impl Fingerprint { format!("{:x}{:x}", self.0, self.1) } - pub fn encode_opaque(&self, encoder: &mut Encoder) -> EncodeResult { + pub fn encode_opaque(&self, encoder: &mut opaque::Encoder) -> EncodeResult { let bytes: [u8; 16] = unsafe { mem::transmute([self.0.to_le(), self.1.to_le()]) }; encoder.emit_raw_bytes(&bytes); Ok(()) } - pub fn decode_opaque(decoder: &mut Decoder<'_>) -> Result<Fingerprint, String> { + pub fn decode_opaque(decoder: &mut opaque::Decoder<'_>) -> Result<Fingerprint, String> { let mut bytes = [0; 16]; decoder.read_raw_bytes(&mut bytes)?; @@ -83,18 +86,45 @@ impl stable_hasher::StableHasherResult for Fingerprint { impl_stable_hash_via_hash!(Fingerprint); -impl rustc_serialize::UseSpecializedEncodable for Fingerprint {} +impl<E: rustc_serialize::Encoder> Encodable<E> for Fingerprint { + fn encode(&self, s: &mut E) -> Result<(), E::Error> { + s.encode_fingerprint(self) + } +} -impl rustc_serialize::UseSpecializedDecodable for Fingerprint {} +impl<D: rustc_serialize::Decoder> Decodable<D> for Fingerprint { + fn decode(d: &mut D) -> Result<Self, D::Error> { + d.decode_fingerprint() + } +} -impl rustc_serialize::SpecializedEncoder<Fingerprint> for Encoder { - fn specialized_encode(&mut self, f: &Fingerprint) -> Result<(), Self::Error> { +pub trait FingerprintEncoder: rustc_serialize::Encoder { + fn encode_fingerprint(&mut self, f: &Fingerprint) -> Result<(), Self::Error>; +} + +pub trait FingerprintDecoder: rustc_serialize::Decoder { + fn decode_fingerprint(&mut self) -> Result<Fingerprint, Self::Error>; +} + +impl<E: rustc_serialize::Encoder> FingerprintEncoder for E { + default fn encode_fingerprint(&mut self, _: &Fingerprint) -> Result<(), E::Error> { + panic!("Cannot encode `Fingerprint` with `{}`", std::any::type_name::<E>()); + } +} + +impl FingerprintEncoder for opaque::Encoder { + fn encode_fingerprint(&mut self, f: &Fingerprint) -> EncodeResult { f.encode_opaque(self) } } -impl<'a> rustc_serialize::SpecializedDecoder<Fingerprint> for Decoder<'a> { - fn specialized_decode(&mut self) -> Result<Fingerprint, Self::Error> { +impl<D: rustc_serialize::Decoder> FingerprintDecoder for D { + default fn decode_fingerprint(&mut self) -> Result<Fingerprint, D::Error> { + panic!("Cannot decode `Fingerprint` with `{}`", std::any::type_name::<D>()); + } +} +impl FingerprintDecoder for opaque::Decoder<'_> { + fn decode_fingerprint(&mut self) -> Result<Fingerprint, String> { Fingerprint::decode_opaque(self) } } diff --git a/src/librustc_data_structures/lib.rs b/src/librustc_data_structures/lib.rs index 3884fc05105..017511cc50d 100644 --- a/src/librustc_data_structures/lib.rs +++ b/src/librustc_data_structures/lib.rs @@ -29,6 +29,8 @@ extern crate log; #[macro_use] extern crate cfg_if; +#[macro_use] +extern crate rustc_macros; #[inline(never)] #[cold] diff --git a/src/librustc_data_structures/sorted_map.rs b/src/librustc_data_structures/sorted_map.rs index 652268dcee8..856eb73e629 100644 --- a/src/librustc_data_structures/sorted_map.rs +++ b/src/librustc_data_structures/sorted_map.rs @@ -16,18 +16,7 @@ pub use index_map::SortedIndexMultiMap; /// stores data in a more compact way. It also supports accessing contiguous /// ranges of elements as a slice, and slices of already sorted elements can be /// inserted efficiently. -#[derive( - Clone, - PartialEq, - Eq, - PartialOrd, - Ord, - Hash, - Default, - Debug, - RustcEncodable, - RustcDecodable -)] +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Debug, Encodable, Decodable)] pub struct SortedMap<K: Ord, V> { data: Vec<(K, V)>, } diff --git a/src/librustc_data_structures/svh.rs b/src/librustc_data_structures/svh.rs index 476eb9e14f9..02103de2e8d 100644 --- a/src/librustc_data_structures/svh.rs +++ b/src/librustc_data_structures/svh.rs @@ -48,14 +48,14 @@ impl fmt::Display for Svh { } } -impl Encodable for Svh { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder> Encodable<S> for Svh { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_u64(self.as_u64().to_le()) } } -impl Decodable for Svh { - fn decode<D: Decoder>(d: &mut D) -> Result<Svh, D::Error> { +impl<D: Decoder> Decodable<D> for Svh { + fn decode(d: &mut D) -> Result<Svh, D::Error> { d.read_u64().map(u64::from_le).map(Svh::new) } } diff --git a/src/librustc_data_structures/thin_vec.rs b/src/librustc_data_structures/thin_vec.rs index 43002178eb9..4d673fd5cf9 100644 --- a/src/librustc_data_structures/thin_vec.rs +++ b/src/librustc_data_structures/thin_vec.rs @@ -3,7 +3,7 @@ use crate::stable_hasher::{HashStable, StableHasher}; /// A vector type optimized for cases where this size is usually 0 (cf. `SmallVector`). /// The `Option<Box<..>>` wrapping allows us to represent a zero sized vector with `None`, /// which uses only a single (null) pointer. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, Encodable, Decodable, Debug)] pub struct ThinVec<T>(Option<Box<Vec<T>>>); impl<T> ThinVec<T> { diff --git a/src/librustc_data_structures/transitive_relation.rs b/src/librustc_data_structures/transitive_relation.rs index 7d137a55033..fe60a99dde0 100644 --- a/src/librustc_data_structures/transitive_relation.rs +++ b/src/librustc_data_structures/transitive_relation.rs @@ -1,8 +1,6 @@ use crate::fx::FxIndexSet; -use crate::stable_hasher::{HashStable, StableHasher}; use crate::sync::Lock; use rustc_index::bit_set::BitMatrix; -use rustc_serialize::{Decodable, Decoder, Encodable, Encoder}; use std::fmt::Debug; use std::hash::Hash; use std::mem; @@ -42,10 +40,10 @@ impl<T: Eq + Hash> Default for TransitiveRelation<T> { } } -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, RustcEncodable, RustcDecodable, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Debug)] struct Index(usize); -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, PartialEq, Eq, Debug)] struct Edge { source: Index, target: Index, @@ -402,66 +400,3 @@ fn pare_down(candidates: &mut Vec<usize>, closure: &BitMatrix<usize, usize>) { candidates.truncate(j - dead); } } - -impl<T> Encodable for TransitiveRelation<T> -where - T: Clone + Encodable + Debug + Eq + Hash + Clone, -{ - fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> { - s.emit_struct("TransitiveRelation", 2, |s| { - s.emit_struct_field("elements", 0, |s| self.elements.encode(s))?; - s.emit_struct_field("edges", 1, |s| self.edges.encode(s))?; - Ok(()) - }) - } -} - -impl<T> Decodable for TransitiveRelation<T> -where - T: Clone + Decodable + Debug + Eq + Hash + Clone, -{ - fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error> { - d.read_struct("TransitiveRelation", 2, |d| { - Ok(TransitiveRelation { - elements: d.read_struct_field("elements", 0, |d| Decodable::decode(d))?, - edges: d.read_struct_field("edges", 1, |d| Decodable::decode(d))?, - closure: Lock::new(None), - }) - }) - } -} - -impl<CTX, T> HashStable<CTX> for TransitiveRelation<T> -where - T: HashStable<CTX> + Eq + Debug + Clone + Hash, -{ - fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) { - // We are assuming here that the relation graph has been built in a - // deterministic way and we can just hash it the way it is. - let TransitiveRelation { - ref elements, - ref edges, - // "closure" is just a copy of the data above - closure: _, - } = *self; - - elements.hash_stable(hcx, hasher); - edges.hash_stable(hcx, hasher); - } -} - -impl<CTX> HashStable<CTX> for Edge { - fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) { - let Edge { ref source, ref target } = *self; - - source.hash_stable(hcx, hasher); - target.hash_stable(hcx, hasher); - } -} - -impl<CTX> HashStable<CTX> for Index { - fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) { - let Index(idx) = *self; - idx.hash_stable(hcx, hasher); - } -} diff --git a/src/librustc_driver/Cargo.toml b/src/librustc_driver/Cargo.toml index 6474a69b216..46331c63113 100644 --- a/src/librustc_driver/Cargo.toml +++ b/src/librustc_driver/Cargo.toml @@ -12,7 +12,7 @@ crate-type = ["dylib"] [dependencies] lazy_static = "1.0" libc = "0.2" -log = { package = "tracing", version = "0.1.18", features = ["release_max_level_info"] } +tracing = { version = "0.1.18", features = ["release_max_level_info"] } tracing-subscriber = { version = "0.2.10", default-features = false, features = ["fmt", "env-filter", "smallvec", "parking_lot", "ansi"] } rustc_middle = { path = "../librustc_middle" } rustc_ast_pretty = { path = "../librustc_ast_pretty" } diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index cc954cee907..cd94ccc7ad7 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -9,7 +9,7 @@ #![recursion_limit = "256"] #[macro_use] -extern crate log; +extern crate tracing; #[macro_use] extern crate lazy_static; @@ -348,8 +348,10 @@ pub fn run_compiler( queries.global_ctxt()?; // Drop AST after creating GlobalCtxt to free memory - let _timer = sess.prof.generic_activity("drop_ast"); - mem::drop(queries.expansion()?.take()); + { + let _timer = sess.prof.generic_activity("drop_ast"); + mem::drop(queries.expansion()?.take()); + } if sess.opts.debugging_opts.no_analysis || sess.opts.debugging_opts.ast_json { return early_exit(); @@ -1224,13 +1226,13 @@ pub fn install_ice_hook() { } /// This allows tools to enable rust logging without having to magically match rustc's -/// log crate version. +/// tracing crate version. pub fn init_rustc_env_logger() { init_env_logger("RUSTC_LOG") } /// This allows tools to enable rust logging without having to magically match rustc's -/// log crate version. In contrast to `init_rustc_env_logger` it allows you to choose an env var +/// tracing crate version. In contrast to `init_rustc_env_logger` it allows you to choose an env var /// other than `RUSTC_LOG`. pub fn init_env_logger(env: &str) { // Don't register a dispatcher if there's no filter to print anything diff --git a/src/librustc_error_codes/error_codes/E0477.md b/src/librustc_error_codes/error_codes/E0477.md index 794456451ef..9cfefb1de63 100644 --- a/src/librustc_error_codes/error_codes/E0477.md +++ b/src/librustc_error_codes/error_codes/E0477.md @@ -37,8 +37,7 @@ fn i_want_static_closure<F>(a: F) fn print_string(s: Mutex<MyString<'static>>) { - i_want_static_closure(move || { // error: this closure has lifetime 'a - // rather than 'static + i_want_static_closure(move || { // ok! println!("{}", s.lock().unwrap().data); }); } diff --git a/src/librustc_error_codes/error_codes/E0751.md b/src/librustc_error_codes/error_codes/E0751.md index 809b888d92a..8794f7868f3 100644 --- a/src/librustc_error_codes/error_codes/E0751.md +++ b/src/librustc_error_codes/error_codes/E0751.md @@ -5,8 +5,8 @@ Erroneous code example: ```compile_fail,E0751 trait MyTrait {} impl MyTrait for i32 { } -impl !MyTrait for i32 { } +impl !MyTrait for i32 { } // error! ``` -Negative implementations are a promise that the trait will never be -implemented for the given types. +Negative implementations are a promise that the trait will never be implemented +for the given types. Therefore, both cannot exists at the same time. diff --git a/src/librustc_error_codes/error_codes/E0752.md b/src/librustc_error_codes/error_codes/E0752.md index 86945f83b55..9736da80c2b 100644 --- a/src/librustc_error_codes/error_codes/E0752.md +++ b/src/librustc_error_codes/error_codes/E0752.md @@ -1,11 +1,19 @@ -`fn main()` or the specified start function is not allowed to be -async. You might be seeing this error because your async runtime -library is not set up correctly. +The entry point of the program was marked as `async`. Erroneous code example: ```compile_fail,E0752 -async fn main() -> Result<i32, ()> { - Ok(1) +async fn main() -> Result<(), ()> { // error! + Ok(()) +} +``` + +`fn main()` or the specified start function is not allowed to be `async`. Not +having a correct async runtime library setup may cause this error. To fix it, +declare the entry point without `async`: + +``` +fn main() -> Result<(), ()> { // ok! + Ok(()) } ``` diff --git a/src/librustc_errors/Cargo.toml b/src/librustc_errors/Cargo.toml index d0f04c3fe76..7c794bcd98f 100644 --- a/src/librustc_errors/Cargo.toml +++ b/src/librustc_errors/Cargo.toml @@ -10,9 +10,10 @@ path = "lib.rs" doctest = false [dependencies] -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc_serialize = { path = "../librustc_serialize" } rustc_span = { path = "../librustc_span" } +rustc_macros = { path = "../librustc_macros" } rustc_data_structures = { path = "../librustc_data_structures" } unicode-width = "0.1.4" atty = "0.2" diff --git a/src/librustc_errors/diagnostic.rs b/src/librustc_errors/diagnostic.rs index acaa26c6ad2..cd4b5d56f36 100644 --- a/src/librustc_errors/diagnostic.rs +++ b/src/librustc_errors/diagnostic.rs @@ -9,7 +9,7 @@ use rustc_span::{MultiSpan, Span, DUMMY_SP}; use std::fmt; #[must_use] -#[derive(Clone, Debug, PartialEq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Debug, PartialEq, Hash, Encodable, Decodable)] pub struct Diagnostic { pub level: Level, pub message: Vec<(String, Style)>, @@ -24,14 +24,14 @@ pub struct Diagnostic { pub sort_span: Span, } -#[derive(Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Debug, PartialEq, Eq, Hash, Encodable, Decodable)] pub enum DiagnosticId { Error(String), Lint(String), } /// For example a note attached to an error. -#[derive(Clone, Debug, PartialEq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Debug, PartialEq, Hash, Encodable, Decodable)] pub struct SubDiagnostic { pub level: Level, pub message: Vec<(String, Style)>, diff --git a/src/librustc_errors/diagnostic_builder.rs b/src/librustc_errors/diagnostic_builder.rs index 22bf8fe34aa..dc52e29fa9b 100644 --- a/src/librustc_errors/diagnostic_builder.rs +++ b/src/librustc_errors/diagnostic_builder.rs @@ -1,11 +1,11 @@ use crate::{Applicability, Handler, Level, StashKey}; use crate::{Diagnostic, DiagnosticId, DiagnosticStyledString}; -use log::debug; use rustc_span::{MultiSpan, Span}; use std::fmt::{self, Debug}; use std::ops::{Deref, DerefMut}; use std::thread::panicking; +use tracing::debug; /// Used for emitting structured error messages and other diagnostic information. /// diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs index cca8b47c781..5a654e83aed 100644 --- a/src/librustc_errors/emitter.rs +++ b/src/librustc_errors/emitter.rs @@ -18,7 +18,6 @@ use crate::{ pluralize, CodeSuggestion, Diagnostic, DiagnosticId, Level, SubDiagnostic, SuggestionStyle, }; -use log::*; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::sync::Lrc; use rustc_span::hygiene::{ExpnKind, MacroKind}; @@ -30,6 +29,7 @@ use std::iter; use std::path::Path; use termcolor::{Ansi, BufferWriter, ColorChoice, ColorSpec, StandardStream}; use termcolor::{Buffer, Color, WriteColor}; +use tracing::*; /// Default column width, used in tests and when terminal dimensions cannot be determined. const DEFAULT_COLUMN_WIDTH: usize = 140; diff --git a/src/librustc_errors/json.rs b/src/librustc_errors/json.rs index 24186198fd2..750d36d3d89 100644 --- a/src/librustc_errors/json.rs +++ b/src/librustc_errors/json.rs @@ -145,7 +145,7 @@ impl Emitter for JsonEmitter { // The following data types are provided just for serialisation. -#[derive(RustcEncodable)] +#[derive(Encodable)] struct Diagnostic { /// The primary error message. message: String, @@ -159,7 +159,7 @@ struct Diagnostic { rendered: Option<String>, } -#[derive(RustcEncodable)] +#[derive(Encodable)] struct DiagnosticSpan { file_name: String, byte_start: u32, @@ -186,7 +186,7 @@ struct DiagnosticSpan { expansion: Option<Box<DiagnosticSpanMacroExpansion>>, } -#[derive(RustcEncodable)] +#[derive(Encodable)] struct DiagnosticSpanLine { text: String, @@ -196,7 +196,7 @@ struct DiagnosticSpanLine { highlight_end: usize, } -#[derive(RustcEncodable)] +#[derive(Encodable)] struct DiagnosticSpanMacroExpansion { /// span where macro was applied to generate this code; note that /// this may itself derive from a macro (if @@ -210,7 +210,7 @@ struct DiagnosticSpanMacroExpansion { def_site_span: DiagnosticSpan, } -#[derive(RustcEncodable)] +#[derive(Encodable)] struct DiagnosticCode { /// The code itself. code: String, @@ -218,7 +218,7 @@ struct DiagnosticCode { explanation: Option<&'static str>, } -#[derive(RustcEncodable)] +#[derive(Encodable)] struct ArtifactNotification<'a> { /// The path of the artifact. artifact: &'a Path, diff --git a/src/librustc_errors/json/tests.rs b/src/librustc_errors/json/tests.rs index dcfcdbc63f2..e69e868c8ed 100644 --- a/src/librustc_errors/json/tests.rs +++ b/src/librustc_errors/json/tests.rs @@ -10,12 +10,12 @@ use rustc_span::{BytePos, Span}; use std::str; -#[derive(RustcDecodable, Debug, PartialEq, Eq)] +#[derive(Decodable, Debug, PartialEq, Eq)] struct TestData { spans: Vec<SpanTestData>, } -#[derive(RustcDecodable, Debug, PartialEq, Eq)] +#[derive(Decodable, Debug, PartialEq, Eq)] struct SpanTestData { pub byte_start: u32, pub byte_end: u32, diff --git a/src/librustc_errors/lib.rs b/src/librustc_errors/lib.rs index 73d71063b23..d4f0a9d83ef 100644 --- a/src/librustc_errors/lib.rs +++ b/src/librustc_errors/lib.rs @@ -6,9 +6,12 @@ #![feature(crate_visibility_modifier)] #![feature(nll)] +#[macro_use] +extern crate rustc_macros; + pub use emitter::ColorConfig; -use log::debug; +use tracing::debug; use Level::*; use emitter::{is_case_difference, Emitter, EmitterWriter}; @@ -50,7 +53,7 @@ rustc_data_structures::static_assert_size!(PResult<'_, bool>, 16); /// All suggestions are marked with an `Applicability`. Tools use the applicability of a suggestion /// to determine whether it should be automatically applied or if the user should be consulted /// before applying the suggestion. -#[derive(Copy, Clone, Debug, PartialEq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, PartialEq, Hash, Encodable, Decodable)] pub enum Applicability { /// The suggestion is definitely what the user intended. This suggestion should be /// automatically applied. @@ -69,7 +72,7 @@ pub enum Applicability { Unspecified, } -#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, RustcEncodable, RustcDecodable)] +#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, Encodable, Decodable)] pub enum SuggestionStyle { /// Hide the suggested code when displaying this suggestion inline. HideCodeInline, @@ -94,7 +97,7 @@ impl SuggestionStyle { } } -#[derive(Clone, Debug, PartialEq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Debug, PartialEq, Hash, Encodable, Decodable)] pub struct CodeSuggestion { /// Each substitute can have multiple variants due to multiple /// applicable suggestions @@ -129,13 +132,13 @@ pub struct CodeSuggestion { pub applicability: Applicability, } -#[derive(Clone, Debug, PartialEq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Debug, PartialEq, Hash, Encodable, Decodable)] /// See the docs on `CodeSuggestion::substitutions` pub struct Substitution { pub parts: Vec<SubstitutionPart>, } -#[derive(Clone, Debug, PartialEq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Debug, PartialEq, Hash, Encodable, Decodable)] pub struct SubstitutionPart { pub span: Span, pub snippet: String, @@ -943,7 +946,7 @@ impl HandlerInner { } } -#[derive(Copy, PartialEq, Clone, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Copy, PartialEq, Clone, Hash, Debug, Encodable, Decodable)] pub enum Level { Bug, Fatal, @@ -1012,7 +1015,7 @@ macro_rules! pluralize { // Useful type to use with `Result<>` indicate that an error has already // been reported to the user, so no need to continue checking. -#[derive(Clone, Copy, Debug, RustcEncodable, RustcDecodable, Hash, PartialEq, Eq)] +#[derive(Clone, Copy, Debug, Encodable, Decodable, Hash, PartialEq, Eq)] pub struct ErrorReported; rustc_data_structures::impl_stable_hash_via_hash!(ErrorReported); diff --git a/src/librustc_errors/snippet.rs b/src/librustc_errors/snippet.rs index 0660590a725..160bf577799 100644 --- a/src/librustc_errors/snippet.rs +++ b/src/librustc_errors/snippet.rs @@ -173,7 +173,7 @@ pub struct StyledString { pub style: Style, } -#[derive(Copy, Clone, Debug, PartialEq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, PartialEq, Hash, Encodable, Decodable)] pub enum Style { MainHeaderMsg, HeaderMsg, diff --git a/src/librustc_expand/Cargo.toml b/src/librustc_expand/Cargo.toml index bdf039c36ab..55a1862971b 100644 --- a/src/librustc_expand/Cargo.toml +++ b/src/librustc_expand/Cargo.toml @@ -12,7 +12,7 @@ doctest = false [dependencies] rustc_serialize = { path = "../librustc_serialize" } -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc_span = { path = "../librustc_span" } rustc_ast_pretty = { path = "../librustc_ast_pretty" } rustc_ast_passes = { path = "../librustc_ast_passes" } @@ -20,6 +20,7 @@ rustc_attr = { path = "../librustc_attr" } rustc_data_structures = { path = "../librustc_data_structures" } rustc_errors = { path = "../librustc_errors" } rustc_feature = { path = "../librustc_feature" } +rustc_macros = { path = "../librustc_macros" } rustc_lexer = { path = "../librustc_lexer" } rustc_parse = { path = "../librustc_parse" } rustc_session = { path = "../librustc_session" } diff --git a/src/librustc_expand/lib.rs b/src/librustc_expand/lib.rs index 1e3ab2c5ec2..7f631cb71af 100644 --- a/src/librustc_expand/lib.rs +++ b/src/librustc_expand/lib.rs @@ -8,6 +8,9 @@ #![feature(proc_macro_span)] #![feature(try_blocks)] +#[macro_use] +extern crate rustc_macros; + extern crate proc_macro as pm; mod placeholders; diff --git a/src/librustc_expand/mbe.rs b/src/librustc_expand/mbe.rs index 6f2daaa81c0..9920e0650a7 100644 --- a/src/librustc_expand/mbe.rs +++ b/src/librustc_expand/mbe.rs @@ -19,7 +19,7 @@ use rustc_data_structures::sync::Lrc; /// Contains the sub-token-trees of a "delimited" token tree, such as the contents of `(`. Note /// that the delimiter itself might be `NoDelim`. -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, PartialEq, Encodable, Decodable, Debug)] struct Delimited { delim: token::DelimToken, tts: Vec<TokenTree>, @@ -37,7 +37,7 @@ impl Delimited { } } -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, PartialEq, Encodable, Decodable, Debug)] struct SequenceRepetition { /// The sequence of token trees tts: Vec<TokenTree>, @@ -49,7 +49,7 @@ struct SequenceRepetition { num_captures: usize, } -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] +#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy)] struct KleeneToken { span: Span, op: KleeneOp, @@ -63,7 +63,7 @@ impl KleeneToken { /// A Kleene-style [repetition operator](http://en.wikipedia.org/wiki/Kleene_star) /// for token sequences. -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy)] +#[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy)] enum KleeneOp { /// Kleene star (`*`) for zero or more repetitions ZeroOrMore, @@ -75,7 +75,7 @@ enum KleeneOp { /// Similar to `tokenstream::TokenTree`, except that `$i`, `$i:ident`, and `$(...)` /// are "first-class" token trees. Useful for parsing macros. -#[derive(Debug, Clone, PartialEq, RustcEncodable, RustcDecodable)] +#[derive(Debug, Clone, PartialEq, Encodable, Decodable)] enum TokenTree { Token(Token), Delimited(DelimSpan, Lrc<Delimited>), diff --git a/src/librustc_expand/mbe/macro_rules.rs b/src/librustc_expand/mbe/macro_rules.rs index 15b2c14a257..808d77842cb 100644 --- a/src/librustc_expand/mbe/macro_rules.rs +++ b/src/librustc_expand/mbe/macro_rules.rs @@ -25,10 +25,10 @@ use rustc_span::hygiene::Transparency; use rustc_span::symbol::{kw, sym, Ident, MacroRulesNormalizedIdent}; use rustc_span::Span; -use log::debug; use std::borrow::Cow; use std::collections::hash_map::Entry; use std::{mem, slice}; +use tracing::debug; crate struct ParserAnyMacro<'a> { parser: Parser<'a>, diff --git a/src/librustc_hir/Cargo.toml b/src/librustc_hir/Cargo.toml index 4a404e176e1..a473a8edcdd 100644 --- a/src/librustc_hir/Cargo.toml +++ b/src/librustc_hir/Cargo.toml @@ -18,5 +18,5 @@ rustc_span = { path = "../librustc_span" } rustc_serialize = { path = "../librustc_serialize" } rustc_ast = { path = "../librustc_ast" } lazy_static = "1" -log = { package = "tracing", version = "0.1" } +tracing = "0.1" smallvec = { version = "1.0", features = ["union", "may_dangle"] } diff --git a/src/librustc_hir/arena.rs b/src/librustc_hir/arena.rs index f439db71531..6ba39666607 100644 --- a/src/librustc_hir/arena.rs +++ b/src/librustc_hir/arena.rs @@ -12,41 +12,41 @@ macro_rules! arena_types { ($macro:path, $args:tt, $tcx:lifetime) => ( $macro!($args, [ // HIR types - [few] hir_krate: rustc_hir::Crate<$tcx>, rustc_hir::Crate<'_x>; - [] arm: rustc_hir::Arm<$tcx>, rustc_hir::Arm<'_x>; - [] asm_operand: rustc_hir::InlineAsmOperand<$tcx>, rustc_hir::InlineAsmOperand<'_x>; - [] asm_template: rustc_ast::ast::InlineAsmTemplatePiece, rustc_ast::ast::InlineAsmTemplatePiece; - [] attribute: rustc_ast::ast::Attribute, rustc_ast::ast::Attribute; - [] block: rustc_hir::Block<$tcx>, rustc_hir::Block<'_x>; - [] bare_fn_ty: rustc_hir::BareFnTy<$tcx>, rustc_hir::BareFnTy<'_x>; - [few] global_asm: rustc_hir::GlobalAsm, rustc_hir::GlobalAsm; - [] generic_arg: rustc_hir::GenericArg<$tcx>, rustc_hir::GenericArg<'_x>; - [] generic_args: rustc_hir::GenericArgs<$tcx>, rustc_hir::GenericArgs<'_x>; - [] generic_bound: rustc_hir::GenericBound<$tcx>, rustc_hir::GenericBound<'_x>; - [] generic_param: rustc_hir::GenericParam<$tcx>, rustc_hir::GenericParam<'_x>; - [] expr: rustc_hir::Expr<$tcx>, rustc_hir::Expr<'_x>; - [] field: rustc_hir::Field<$tcx>, rustc_hir::Field<'_x>; - [] field_pat: rustc_hir::FieldPat<$tcx>, rustc_hir::FieldPat<'_x>; - [] fn_decl: rustc_hir::FnDecl<$tcx>, rustc_hir::FnDecl<'_x>; - [] foreign_item: rustc_hir::ForeignItem<$tcx>, rustc_hir::ForeignItem<'_x>; - [] impl_item_ref: rustc_hir::ImplItemRef<$tcx>, rustc_hir::ImplItemRef<'_x>; - [few] inline_asm: rustc_hir::InlineAsm<$tcx>, rustc_hir::InlineAsm<'_x>; - [few] llvm_inline_asm: rustc_hir::LlvmInlineAsm<$tcx>, rustc_hir::LlvmInlineAsm<'_x>; - [] local: rustc_hir::Local<$tcx>, rustc_hir::Local<'_x>; - [few] macro_def: rustc_hir::MacroDef<$tcx>, rustc_hir::MacroDef<'_x>; - [] param: rustc_hir::Param<$tcx>, rustc_hir::Param<'_x>; - [] pat: rustc_hir::Pat<$tcx>, rustc_hir::Pat<'_x>; - [] path: rustc_hir::Path<$tcx>, rustc_hir::Path<'_x>; - [] path_segment: rustc_hir::PathSegment<$tcx>, rustc_hir::PathSegment<'_x>; - [] poly_trait_ref: rustc_hir::PolyTraitRef<$tcx>, rustc_hir::PolyTraitRef<'_x>; - [] qpath: rustc_hir::QPath<$tcx>, rustc_hir::QPath<'_x>; - [] stmt: rustc_hir::Stmt<$tcx>, rustc_hir::Stmt<'_x>; - [] struct_field: rustc_hir::StructField<$tcx>, rustc_hir::StructField<'_x>; - [] trait_item_ref: rustc_hir::TraitItemRef, rustc_hir::TraitItemRef; - [] ty: rustc_hir::Ty<$tcx>, rustc_hir::Ty<'_x>; - [] type_binding: rustc_hir::TypeBinding<$tcx>, rustc_hir::TypeBinding<'_x>; - [] variant: rustc_hir::Variant<$tcx>, rustc_hir::Variant<'_x>; - [] where_predicate: rustc_hir::WherePredicate<$tcx>, rustc_hir::WherePredicate<'_x>; + [few] hir_krate: rustc_hir::Crate<$tcx>, + [] arm: rustc_hir::Arm<$tcx>, + [] asm_operand: rustc_hir::InlineAsmOperand<$tcx>, + [] asm_template: rustc_ast::ast::InlineAsmTemplatePiece, + [] attribute: rustc_ast::ast::Attribute, + [] block: rustc_hir::Block<$tcx>, + [] bare_fn_ty: rustc_hir::BareFnTy<$tcx>, + [few] global_asm: rustc_hir::GlobalAsm, + [] generic_arg: rustc_hir::GenericArg<$tcx>, + [] generic_args: rustc_hir::GenericArgs<$tcx>, + [] generic_bound: rustc_hir::GenericBound<$tcx>, + [] generic_param: rustc_hir::GenericParam<$tcx>, + [] expr: rustc_hir::Expr<$tcx>, + [] field: rustc_hir::Field<$tcx>, + [] field_pat: rustc_hir::FieldPat<$tcx>, + [] fn_decl: rustc_hir::FnDecl<$tcx>, + [] foreign_item: rustc_hir::ForeignItem<$tcx>, + [] impl_item_ref: rustc_hir::ImplItemRef<$tcx>, + [few] inline_asm: rustc_hir::InlineAsm<$tcx>, + [few] llvm_inline_asm: rustc_hir::LlvmInlineAsm<$tcx>, + [] local: rustc_hir::Local<$tcx>, + [few] macro_def: rustc_hir::MacroDef<$tcx>, + [] param: rustc_hir::Param<$tcx>, + [] pat: rustc_hir::Pat<$tcx>, + [] path: rustc_hir::Path<$tcx>, + [] path_segment: rustc_hir::PathSegment<$tcx>, + [] poly_trait_ref: rustc_hir::PolyTraitRef<$tcx>, + [] qpath: rustc_hir::QPath<$tcx>, + [] stmt: rustc_hir::Stmt<$tcx>, + [] struct_field: rustc_hir::StructField<$tcx>, + [] trait_item_ref: rustc_hir::TraitItemRef, + [] ty: rustc_hir::Ty<$tcx>, + [] type_binding: rustc_hir::TypeBinding<$tcx>, + [] variant: rustc_hir::Variant<$tcx>, + [] where_predicate: rustc_hir::WherePredicate<$tcx>, ], $tcx); ) } diff --git a/src/librustc_hir/def.rs b/src/librustc_hir/def.rs index 618f3e99c3f..c4877be3f64 100644 --- a/src/librustc_hir/def.rs +++ b/src/librustc_hir/def.rs @@ -9,7 +9,7 @@ use rustc_span::hygiene::MacroKind; use std::fmt::Debug; /// Encodes if a `DefKind::Ctor` is the constructor of an enum variant or a struct. -#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] #[derive(HashStable_Generic)] pub enum CtorOf { /// This `DefKind::Ctor` is a synthesized constructor of a tuple or unit struct. @@ -18,7 +18,7 @@ pub enum CtorOf { Variant, } -#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] #[derive(HashStable_Generic)] pub enum CtorKind { /// Constructor function automatically created by a tuple struct/variant. @@ -29,7 +29,7 @@ pub enum CtorKind { Fictive, } -#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] #[derive(HashStable_Generic)] pub enum NonMacroAttrKind { /// Single-segment attribute defined by the language (`#[inline]`) @@ -42,7 +42,7 @@ pub enum NonMacroAttrKind { Registered, } -#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] #[derive(HashStable_Generic)] pub enum DefKind { // Type namespace @@ -191,7 +191,7 @@ impl DefKind { } /// The resolution of a path or export. -#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] #[derive(HashStable_Generic)] pub enum Res<Id = hir::HirId> { Def(DefKind, DefId), diff --git a/src/librustc_hir/definitions.rs b/src/librustc_hir/definitions.rs index 79b70682739..628fc931411 100644 --- a/src/librustc_hir/definitions.rs +++ b/src/librustc_hir/definitions.rs @@ -15,15 +15,15 @@ use rustc_index::vec::IndexVec; use rustc_span::hygiene::ExpnId; use rustc_span::symbol::{sym, Symbol}; -use log::debug; use std::fmt::Write; use std::hash::Hash; +use tracing::debug; /// The `DefPathTable` maps `DefIndex`es to `DefKey`s and vice versa. /// Internally the `DefPathTable` holds a tree of `DefKey`s, where each `DefKey` /// stores the `DefIndex` of its parent. /// There is one `DefPathTable` for each crate. -#[derive(Clone, Default, RustcDecodable, RustcEncodable)] +#[derive(Clone, Default, Decodable, Encodable)] pub struct DefPathTable { index_to_key: IndexVec<DefIndex, DefKey>, def_path_hashes: IndexVec<DefIndex, DefPathHash>, @@ -92,7 +92,7 @@ pub struct Definitions { /// A unique identifier that we can use to lookup a definition /// precisely. It combines the index of the definition's parent (if /// any) with a `DisambiguatedDefPathData`. -#[derive(Copy, Clone, PartialEq, Debug, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Debug, Encodable, Decodable)] pub struct DefKey { /// The parent path. pub parent: Option<DefIndex>, @@ -143,13 +143,13 @@ impl DefKey { /// between them. This introduces some artificial ordering dependency /// but means that if you have, e.g., two impls for the same type in /// the same module, they do get distinct `DefId`s. -#[derive(Copy, Clone, PartialEq, Debug, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Debug, Encodable, Decodable)] pub struct DisambiguatedDefPathData { pub data: DefPathData, pub disambiguator: u32, } -#[derive(Clone, Debug, RustcEncodable, RustcDecodable)] +#[derive(Clone, Debug, Encodable, Decodable)] pub struct DefPath { /// The path leading from the crate root to the item. pub data: Vec<DisambiguatedDefPathData>, @@ -244,7 +244,7 @@ impl DefPath { } } -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Encodable, Decodable)] pub enum DefPathData { // Root: these should only be used for the root nodes, because // they are treated specially by the `def_path` function. @@ -307,11 +307,6 @@ impl Definitions { } #[inline] - pub fn as_local_hir_id(&self, def_id: LocalDefId) -> hir::HirId { - self.local_def_id_to_hir_id(def_id) - } - - #[inline] pub fn local_def_id_to_hir_id(&self, id: LocalDefId) -> hir::HirId { self.def_id_to_hir_id[id].unwrap() } diff --git a/src/librustc_hir/hir.rs b/src/librustc_hir/hir.rs index 6474dc318d3..928235adac3 100644 --- a/src/librustc_hir/hir.rs +++ b/src/librustc_hir/hir.rs @@ -23,7 +23,7 @@ use smallvec::SmallVec; use std::collections::{BTreeMap, BTreeSet}; use std::fmt; -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Copy, Clone, Encodable, HashStable_Generic)] pub struct Lifetime { pub hir_id: HirId, pub span: Span, @@ -37,7 +37,7 @@ pub struct Lifetime { pub name: LifetimeName, } -#[derive(Debug, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] +#[derive(Debug, Clone, PartialEq, Eq, Encodable, Hash, Copy)] #[derive(HashStable_Generic)] pub enum ParamName { /// Some user-given name like `T` or `'x`. @@ -83,7 +83,7 @@ impl ParamName { } } -#[derive(Debug, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] +#[derive(Debug, Clone, PartialEq, Eq, Encodable, Hash, Copy)] #[derive(HashStable_Generic)] pub enum LifetimeName { /// User-given names or fresh (synthetic) names. @@ -182,7 +182,7 @@ impl Lifetime { /// A `Path` is essentially Rust's notion of a name; for instance, /// `std::cmp::PartialEq`. It's represented as a sequence of identifiers, /// along with a bunch of supporting information. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct Path<'hir> { pub span: Span, /// The resolution for the path. @@ -199,7 +199,7 @@ impl Path<'_> { /// A segment of a path: an identifier, an optional lifetime, and a set of /// types. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct PathSegment<'hir> { /// The identifier portion of this path segment. #[stable_hasher(project(name))] @@ -242,13 +242,13 @@ impl<'hir> PathSegment<'hir> { } } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Encodable, Debug, HashStable_Generic)] pub struct ConstArg { pub value: AnonConst, pub span: Span, } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum GenericArg<'hir> { Lifetime(Lifetime), Type(Ty<'hir>), @@ -288,7 +288,7 @@ impl GenericArg<'_> { } } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct GenericArgs<'hir> { /// The generic arguments for this path segment. pub args: &'hir [GenericArg<'hir>], @@ -348,7 +348,7 @@ impl GenericArgs<'_> { /// A modifier on a bound, currently this is only used for `?Sized`, where the /// modifier is `Maybe`. Negative bounds should also be handled here. -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, Encodable, Hash, Debug)] #[derive(HashStable_Generic)] pub enum TraitBoundModifier { None, @@ -360,7 +360,7 @@ pub enum TraitBoundModifier { /// `typeck::collect::compute_bounds` matches these against /// the "special" built-in traits (see `middle::lang_items`) and /// detects `Copy`, `Send` and `Sync`. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum GenericBound<'hir> { Trait(PolyTraitRef<'hir>, TraitBoundModifier), Outlives(Lifetime), @@ -384,7 +384,7 @@ impl GenericBound<'_> { pub type GenericBounds<'hir> = &'hir [GenericBound<'hir>]; -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug, HashStable_Generic)] pub enum LifetimeParamKind { // Indicates that the lifetime definition was explicitly declared (e.g., in // `fn foo<'a>(x: &'a u8) -> &'a u8 { x }`). @@ -403,7 +403,7 @@ pub enum LifetimeParamKind { Error, } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum GenericParamKind<'hir> { /// A lifetime definition (e.g., `'a: 'b + 'c + 'd`). Lifetime { @@ -418,7 +418,7 @@ pub enum GenericParamKind<'hir> { }, } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct GenericParam<'hir> { pub hir_id: HirId, pub name: ParamName, @@ -448,7 +448,7 @@ pub struct GenericParamCount { /// Represents lifetimes and type parameters attached to a declaration /// of a function, enum, trait, etc. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct Generics<'hir> { pub params: &'hir [GenericParam<'hir>], pub where_clause: WhereClause<'hir>, @@ -501,14 +501,14 @@ impl Generics<'hir> { /// Synthetic type parameters are converted to another form during lowering; this allows /// us to track the original form they had, and is useful for error messages. -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] #[derive(HashStable_Generic)] pub enum SyntheticTyParamKind { ImplTrait, } /// A where-clause in a definition. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct WhereClause<'hir> { pub predicates: &'hir [WherePredicate<'hir>], // Only valid if predicates aren't empty. @@ -535,7 +535,7 @@ impl WhereClause<'_> { } /// A single predicate in a where-clause. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum WherePredicate<'hir> { /// A type binding (e.g., `for<'c> Foo: Send + Clone + 'c`). BoundPredicate(WhereBoundPredicate<'hir>), @@ -556,7 +556,7 @@ impl WherePredicate<'_> { } /// A type bound (e.g., `for<'c> Foo: Send + Clone + 'c`). -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct WhereBoundPredicate<'hir> { pub span: Span, /// Any generics from a `for` binding. @@ -568,7 +568,7 @@ pub struct WhereBoundPredicate<'hir> { } /// A lifetime predicate (e.g., `'a: 'b + 'c`). -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct WhereRegionPredicate<'hir> { pub span: Span, pub lifetime: Lifetime, @@ -576,7 +576,7 @@ pub struct WhereRegionPredicate<'hir> { } /// An equality predicate (e.g., `T = int`); currently unsupported. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct WhereEqPredicate<'hir> { pub hir_id: HirId, pub span: Span, @@ -584,7 +584,7 @@ pub struct WhereEqPredicate<'hir> { pub rhs_ty: &'hir Ty<'hir>, } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Encodable, Debug, HashStable_Generic)] pub struct ModuleItems { // Use BTreeSets here so items are in the same order as in the // list of all items in Crate @@ -594,7 +594,7 @@ pub struct ModuleItems { } /// A type representing only the top-level module. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Encodable, Debug, HashStable_Generic)] pub struct CrateItem<'hir> { pub module: Mod<'hir>, pub attrs: &'hir [Attribute], @@ -607,7 +607,7 @@ pub struct CrateItem<'hir> { /// For more details, see the [rustc dev guide]. /// /// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/hir.html -#[derive(RustcEncodable, RustcDecodable, Debug)] +#[derive(Debug)] pub struct Crate<'hir> { pub item: CrateItem<'hir>, pub exported_macros: &'hir [MacroDef<'hir>], @@ -715,7 +715,7 @@ impl Crate<'_> { /// A macro definition, in this crate or imported from another. /// /// Not parsed directly, but created on macro import or `macro_rules!` expansion. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct MacroDef<'hir> { pub ident: Ident, pub vis: Visibility<'hir>, @@ -728,7 +728,7 @@ pub struct MacroDef<'hir> { /// A block of statements `{ .. }`, which may have a label (in this case the /// `targeted_by_break` field will be `true`) and may be `unsafe` by means of /// the `rules` being anything but `DefaultBlock`. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct Block<'hir> { /// Statements in a block. pub stmts: &'hir [Stmt<'hir>], @@ -746,7 +746,7 @@ pub struct Block<'hir> { pub targeted_by_break: bool, } -#[derive(Debug, RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct Pat<'hir> { #[stable_hasher(ignore)] pub hir_id: HirId, @@ -824,7 +824,7 @@ impl Pat<'_> { /// Patterns like the fields of Foo `{ x, ref y, ref mut z }` /// are treated the same as` x: x, y: ref y, z: ref mut z`, /// except `is_shorthand` is true. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct FieldPat<'hir> { #[stable_hasher(ignore)] pub hir_id: HirId, @@ -840,7 +840,7 @@ pub struct FieldPat<'hir> { /// Explicit binding annotations given in the HIR for a binding. Note /// that this is not the final binding *mode* that we infer after type /// inference. -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] pub enum BindingAnnotation { /// No binding annotation given: this means that the final binding mode /// will depend on whether we have skipped through a `&` reference @@ -861,7 +861,7 @@ pub enum BindingAnnotation { RefMut, } -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] pub enum RangeEnd { Included, Excluded, @@ -876,7 +876,7 @@ impl fmt::Display for RangeEnd { } } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum PatKind<'hir> { /// Represents a wildcard pattern (i.e., `_`). Wild, @@ -932,7 +932,7 @@ pub enum PatKind<'hir> { Slice(&'hir [&'hir Pat<'hir>], Option<&'hir Pat<'hir>>, &'hir [&'hir Pat<'hir>]), } -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] pub enum BinOpKind { /// The `+` operator (addition). Add, @@ -1066,7 +1066,7 @@ impl Into<ast::BinOpKind> for BinOpKind { pub type BinOp = Spanned<BinOpKind>; -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] pub enum UnOp { /// The `*` operator (deferencing). UnDeref, @@ -1095,7 +1095,7 @@ impl UnOp { } /// A statement. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct Stmt<'hir> { pub hir_id: HirId, pub kind: StmtKind<'hir>, @@ -1103,7 +1103,7 @@ pub struct Stmt<'hir> { } /// The contents of a statement. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum StmtKind<'hir> { /// A local (`let`) binding. Local(&'hir Local<'hir>), @@ -1129,7 +1129,7 @@ impl StmtKind<'hir> { } /// Represents a `let` statement (i.e., `let <pat>:<ty> = <expr>;`). -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct Local<'hir> { pub pat: &'hir Pat<'hir>, /// Type annotation, if any (otherwise the type will be inferred). @@ -1146,7 +1146,7 @@ pub struct Local<'hir> { /// Represents a single arm of a `match` expression, e.g. /// `<pat> (if <guard>) => <body>`. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct Arm<'hir> { #[stable_hasher(ignore)] pub hir_id: HirId, @@ -1160,12 +1160,12 @@ pub struct Arm<'hir> { pub body: &'hir Expr<'hir>, } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum Guard<'hir> { If(&'hir Expr<'hir>), } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct Field<'hir> { #[stable_hasher(ignore)] pub hir_id: HirId, @@ -1175,7 +1175,7 @@ pub struct Field<'hir> { pub is_shorthand: bool, } -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] pub enum BlockCheckMode { DefaultBlock, UnsafeBlock(UnsafeSource), @@ -1183,13 +1183,13 @@ pub enum BlockCheckMode { PopUnsafeBlock(UnsafeSource), } -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] pub enum UnsafeSource { CompilerGenerated, UserProvided, } -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Hash, Debug)] pub struct BodyId { pub hir_id: HirId, } @@ -1215,7 +1215,7 @@ pub struct BodyId { /// /// All bodies have an **owner**, which can be accessed via the HIR /// map using `body_owner_def_id()`. -#[derive(RustcEncodable, RustcDecodable, Debug)] +#[derive(Debug)] pub struct Body<'hir> { pub params: &'hir [Param<'hir>], pub value: Expr<'hir>, @@ -1233,7 +1233,7 @@ impl Body<'hir> { } /// The type of source expression that caused this generator to be created. -#[derive(Clone, PartialEq, Eq, HashStable_Generic, RustcEncodable, RustcDecodable, Debug, Copy)] +#[derive(Clone, PartialEq, Eq, HashStable_Generic, Encodable, Decodable, Debug, Copy)] pub enum GeneratorKind { /// An explicit `async` block or the body of an async function. Async(AsyncGeneratorKind), @@ -1256,7 +1256,7 @@ impl fmt::Display for GeneratorKind { /// /// This helps error messages but is also used to drive coercions in /// type-checking (see #60424). -#[derive(Clone, PartialEq, Eq, HashStable_Generic, RustcEncodable, RustcDecodable, Debug, Copy)] +#[derive(Clone, PartialEq, Eq, HashStable_Generic, Encodable, Decodable, Debug, Copy)] pub enum AsyncGeneratorKind { /// An explicit `async` block written by the user. Block, @@ -1357,14 +1357,14 @@ pub type Lit = Spanned<LitKind>; /// These are usually found nested inside types (e.g., array lengths) /// or expressions (e.g., repeat counts), and also used to define /// explicit discriminant values for enum variants. -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Eq, Encodable, Debug, HashStable_Generic)] pub struct AnonConst { pub hir_id: HirId, pub body: BodyId, } /// An expression. -#[derive(Debug, RustcEncodable, RustcDecodable)] +#[derive(Debug)] pub struct Expr<'hir> { pub hir_id: HirId, pub kind: ExprKind<'hir>, @@ -1543,7 +1543,7 @@ pub fn is_range_literal(sm: &SourceMap, expr: &Expr<'_>) -> bool { false } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum ExprKind<'hir> { /// A `box x` expression. Box(&'hir Expr<'hir>), @@ -1660,7 +1660,7 @@ pub enum ExprKind<'hir> { /// To resolve the path to a `DefId`, call [`qpath_res`]. /// /// [`qpath_res`]: ../rustc_middle/ty/struct.TypeckResults.html#method.qpath_res -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum QPath<'hir> { /// Path to a definition, optionally "fully-qualified" with a `Self` /// type, if the path points to an associated item in a trait. @@ -1680,7 +1680,7 @@ pub enum QPath<'hir> { } /// Hints at the original code for a let statement. -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, Encodable, Debug, HashStable_Generic)] pub enum LocalSource { /// A `match _ { .. }`. Normal, @@ -1702,7 +1702,7 @@ pub enum LocalSource { } /// Hints at the original code for a `match _ { .. }`. -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, Encodable, Hash, Debug)] #[derive(HashStable_Generic)] pub enum MatchSource { /// A `match _ { .. }`. @@ -1739,7 +1739,7 @@ impl MatchSource { } /// The loop type that yielded an `ExprKind::Loop`. -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] pub enum LoopSource { /// A `loop { .. }` loop. Loop, @@ -1761,7 +1761,7 @@ impl LoopSource { } } -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, Encodable, Debug, HashStable_Generic)] pub enum LoopIdError { OutsideLoopScope, UnlabeledCfInWhileCondition, @@ -1780,7 +1780,7 @@ impl fmt::Display for LoopIdError { } } -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, Encodable, Debug, HashStable_Generic)] pub struct Destination { // This is `Some(_)` iff there is an explicit user-specified `label pub label: Option<Label>, @@ -1791,7 +1791,7 @@ pub struct Destination { } /// The yield kind that caused an `ExprKind::Yield`. -#[derive(Copy, Clone, PartialEq, Eq, Debug, RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Eq, Debug, Encodable, Decodable, HashStable_Generic)] pub enum YieldSource { /// An `<expr>.await`. Await { expr: Option<HirId> }, @@ -1829,7 +1829,7 @@ impl From<GeneratorKind> for YieldSource { // N.B., if you change this, you'll probably want to change the corresponding // type structure in middle/ty.rs as well. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct MutTy<'hir> { pub ty: &'hir Ty<'hir>, pub mutbl: Mutability, @@ -1837,7 +1837,7 @@ pub struct MutTy<'hir> { /// Represents a function's signature in a trait declaration, /// trait implementation, or a free function. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct FnSig<'hir> { pub header: FnHeader, pub decl: &'hir FnDecl<'hir>, @@ -1846,7 +1846,7 @@ pub struct FnSig<'hir> { // The bodies for items are stored "out of line", in a separate // hashmap in the `Crate`. Here we just record the node-id of the item // so it can fetched later. -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Debug)] pub struct TraitItemId { pub hir_id: HirId, } @@ -1855,7 +1855,7 @@ pub struct TraitItemId { /// possibly including a default implementation. A trait item is /// either required (meaning it doesn't have an implementation, just a /// signature) or provided (meaning it has a default implementation). -#[derive(RustcEncodable, RustcDecodable, Debug)] +#[derive(Debug)] pub struct TraitItem<'hir> { pub ident: Ident, pub hir_id: HirId, @@ -1866,7 +1866,7 @@ pub struct TraitItem<'hir> { } /// Represents a trait method's body (or just argument names). -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Encodable, Debug, HashStable_Generic)] pub enum TraitFn<'hir> { /// No default body in the trait, just a signature. Required(&'hir [Ident]), @@ -1876,7 +1876,7 @@ pub enum TraitFn<'hir> { } /// Represents a trait method or associated constant or type -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum TraitItemKind<'hir> { /// An associated constant with an optional value (otherwise `impl`s must contain a value). Const(&'hir Ty<'hir>, Option<BodyId>), @@ -1890,13 +1890,13 @@ pub enum TraitItemKind<'hir> { // The bodies for items are stored "out of line", in a separate // hashmap in the `Crate`. Here we just record the node-id of the item // so it can fetched later. -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Debug)] pub struct ImplItemId { pub hir_id: HirId, } /// Represents anything within an `impl` block. -#[derive(RustcEncodable, RustcDecodable, Debug)] +#[derive(Debug)] pub struct ImplItem<'hir> { pub ident: Ident, pub hir_id: HirId, @@ -1909,7 +1909,7 @@ pub struct ImplItem<'hir> { } /// Represents various kinds of content within an `impl`. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum ImplItemKind<'hir> { /// An associated constant of the given type, set to the constant result /// of the expression. @@ -1947,7 +1947,7 @@ pub const FN_OUTPUT_NAME: Symbol = sym::Output; /// Binding(...), /// } /// ``` -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct TypeBinding<'hir> { pub hir_id: HirId, #[stable_hasher(project(name))] @@ -1957,7 +1957,7 @@ pub struct TypeBinding<'hir> { } // Represents the two kinds of type bindings. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum TypeBindingKind<'hir> { /// E.g., `Foo<Bar: Send>`. Constraint { bounds: &'hir [GenericBound<'hir>] }, @@ -1974,7 +1974,7 @@ impl TypeBinding<'_> { } } -#[derive(Debug, RustcEncodable, RustcDecodable)] +#[derive(Debug)] pub struct Ty<'hir> { pub hir_id: HirId, pub kind: TyKind<'hir>, @@ -1982,7 +1982,7 @@ pub struct Ty<'hir> { } /// Not represented directly in the AST; referred to by name through a `ty_path`. -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] #[derive(HashStable_Generic)] pub enum PrimTy { Int(IntTy), @@ -1993,7 +1993,7 @@ pub enum PrimTy { Char, } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct BareFnTy<'hir> { pub unsafety: Unsafety, pub abi: Abi, @@ -2002,7 +2002,7 @@ pub struct BareFnTy<'hir> { pub param_names: &'hir [Ident], } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct OpaqueTy<'hir> { pub generics: Generics<'hir>, pub bounds: GenericBounds<'hir>, @@ -2011,7 +2011,7 @@ pub struct OpaqueTy<'hir> { } /// From whence the opaque type came. -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, Encodable, Decodable, Debug, HashStable_Generic)] pub enum OpaqueTyOrigin { /// `-> impl Trait` FnReturn, @@ -2024,7 +2024,7 @@ pub enum OpaqueTyOrigin { } /// The various kinds of types recognized by the compiler. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum TyKind<'hir> { /// A variable length slice (i.e., `[T]`). Slice(&'hir Ty<'hir>), @@ -2063,7 +2063,7 @@ pub enum TyKind<'hir> { Err, } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum InlineAsmOperand<'hir> { In { reg: InlineAsmRegOrRegClass, @@ -2105,7 +2105,7 @@ impl<'hir> InlineAsmOperand<'hir> { } } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct InlineAsm<'hir> { pub template: &'hir [InlineAsmTemplatePiece], pub operands: &'hir [InlineAsmOperand<'hir>], @@ -2113,7 +2113,7 @@ pub struct InlineAsm<'hir> { pub line_spans: &'hir [Span], } -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic, PartialEq)] +#[derive(Copy, Clone, Encodable, Decodable, Debug, HashStable_Generic, PartialEq)] pub struct LlvmInlineAsmOutput { pub constraint: Symbol, pub is_rw: bool, @@ -2122,8 +2122,9 @@ pub struct LlvmInlineAsmOutput { } // NOTE(eddyb) This is used within MIR as well, so unlike the rest of the HIR, -// it needs to be `Clone` and use plain `Vec<T>` instead of arena-allocated slice. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic, PartialEq)] +// it needs to be `Clone` and `Decodable` and use plain `Vec<T>` instead of +// arena-allocated slice. +#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic, PartialEq)] pub struct LlvmInlineAsmInner { pub asm: Symbol, pub asm_str_style: StrStyle, @@ -2135,7 +2136,7 @@ pub struct LlvmInlineAsmInner { pub dialect: LlvmAsmDialect, } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct LlvmInlineAsm<'hir> { pub inner: LlvmInlineAsmInner, pub outputs_exprs: &'hir [Expr<'hir>], @@ -2143,7 +2144,7 @@ pub struct LlvmInlineAsm<'hir> { } /// Represents a parameter in a function header. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct Param<'hir> { pub attrs: &'hir [Attribute], pub hir_id: HirId, @@ -2153,7 +2154,7 @@ pub struct Param<'hir> { } /// Represents the header (not the body) of a function declaration. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct FnDecl<'hir> { /// The types of the function's parameters. /// @@ -2166,7 +2167,7 @@ pub struct FnDecl<'hir> { } /// Represents what type of implicit self a function has, if any. -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, Encodable, Decodable, Debug, HashStable_Generic)] pub enum ImplicitSelfKind { /// Represents a `fn x(self);`. Imm, @@ -2191,24 +2192,14 @@ impl ImplicitSelfKind { } } -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Decodable, Debug)] #[derive(HashStable_Generic)] pub enum IsAsync { Async, NotAsync, } -#[derive( - Copy, - Clone, - PartialEq, - RustcEncodable, - RustcDecodable, - Debug, - HashStable_Generic, - Eq, - Hash -)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Encodable, Decodable, HashStable_Generic)] pub enum Defaultness { Default { has_value: bool }, Final, @@ -2234,7 +2225,7 @@ impl Defaultness { } } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum FnRetTy<'hir> { /// Return type is not specified. /// @@ -2255,7 +2246,7 @@ impl FnRetTy<'_> { } } -#[derive(RustcEncodable, RustcDecodable, Debug)] +#[derive(Encodable, Debug)] pub struct Mod<'hir> { /// A span from the first token past `{` to the last token until `}`. /// For `mod foo;`, the inner span ranges from the first token @@ -2264,23 +2255,23 @@ pub struct Mod<'hir> { pub item_ids: &'hir [ItemId], } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct ForeignMod<'hir> { pub abi: Abi, pub items: &'hir [ForeignItem<'hir>], } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Encodable, Debug, HashStable_Generic)] pub struct GlobalAsm { pub asm: Symbol, } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct EnumDef<'hir> { pub variants: &'hir [Variant<'hir>], } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct Variant<'hir> { /// Name of the variant. #[stable_hasher(project(name))] @@ -2297,7 +2288,7 @@ pub struct Variant<'hir> { pub span: Span, } -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] pub enum UseKind { /// One import, e.g., `use foo::bar` or `use foo::bar as baz`. /// Also produced for each element of a list `use`, e.g. @@ -2319,7 +2310,7 @@ pub enum UseKind { /// that the `ref_id` is for. Note that `ref_id`'s value is not the `HirId` of the /// trait being referred to but just a unique `HirId` that serves as a key /// within the resolution map. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct TraitRef<'hir> { pub path: &'hir Path<'hir>, // Don't hash the `ref_id`. It is tracked via the thing it is used to access. @@ -2338,7 +2329,7 @@ impl TraitRef<'_> { } } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct PolyTraitRef<'hir> { /// The `'a` in `for<'a> Foo<&'a T>`. pub bound_generic_params: &'hir [GenericParam<'hir>], @@ -2351,7 +2342,7 @@ pub struct PolyTraitRef<'hir> { pub type Visibility<'hir> = Spanned<VisibilityKind<'hir>>; -#[derive(RustcEncodable, RustcDecodable, Debug)] +#[derive(Debug)] pub enum VisibilityKind<'hir> { Public, Crate(CrateSugar), @@ -2384,7 +2375,7 @@ impl VisibilityKind<'_> { } } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct StructField<'hir> { pub span: Span, #[stable_hasher(project(name))] @@ -2404,7 +2395,7 @@ impl StructField<'_> { } /// Fields and constructor IDs of enum variants and structs. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum VariantData<'hir> { /// A struct variant. /// @@ -2441,7 +2432,7 @@ impl VariantData<'hir> { // The bodies for items are stored "out of line", in a separate // hashmap in the `Crate`. Here we just record the node-id of the item // so it can fetched later. -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug)] +#[derive(Copy, Clone, Encodable, Debug)] pub struct ItemId { pub id: HirId, } @@ -2449,7 +2440,7 @@ pub struct ItemId { /// An item /// /// The name might be a dummy name in case of anonymous items -#[derive(RustcEncodable, RustcDecodable, Debug)] +#[derive(Debug)] pub struct Item<'hir> { pub ident: Ident, pub hir_id: HirId, @@ -2460,7 +2451,7 @@ pub struct Item<'hir> { } #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] -#[derive(RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Encodable, Decodable, HashStable_Generic)] pub enum Unsafety { Unsafe, Normal, @@ -2485,13 +2476,13 @@ impl fmt::Display for Unsafety { } #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] -#[derive(RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Encodable, Decodable, HashStable_Generic)] pub enum Constness { Const, NotConst, } -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, Encodable, Debug, HashStable_Generic)] pub struct FnHeader { pub unsafety: Unsafety, pub constness: Constness, @@ -2508,7 +2499,7 @@ impl FnHeader { } } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum ItemKind<'hir> { /// An `extern crate` item, with optional *original* crate name if the crate was renamed. /// @@ -2590,7 +2581,7 @@ impl ItemKind<'_> { /// type or method, and whether it is public). This allows other /// passes to find the impl they want without loading the ID (which /// means fewer edges in the incremental compilation graph). -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Encodable, Debug, HashStable_Generic)] pub struct TraitItemRef { pub id: TraitItemId, #[stable_hasher(project(name))] @@ -2606,7 +2597,7 @@ pub struct TraitItemRef { /// type or method, and whether it is public). This allows other /// passes to find the impl they want without loading the ID (which /// means fewer edges in the incremental compilation graph). -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct ImplItemRef<'hir> { pub id: ImplItemId, #[stable_hasher(project(name))] @@ -2617,14 +2608,14 @@ pub struct ImplItemRef<'hir> { pub defaultness: Defaultness, } -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Encodable, Debug, HashStable_Generic)] pub enum AssocItemKind { Const, Fn { has_self: bool }, Type, } -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub struct ForeignItem<'hir> { #[stable_hasher(project(name))] pub ident: Ident, @@ -2636,7 +2627,7 @@ pub struct ForeignItem<'hir> { } /// An item within an `extern` block. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable_Generic)] +#[derive(Debug, HashStable_Generic)] pub enum ForeignItemKind<'hir> { /// A foreign function. Fn(&'hir FnDecl<'hir>, &'hir [Ident], Generics<'hir>), @@ -2647,7 +2638,7 @@ pub enum ForeignItemKind<'hir> { } /// A variable captured by a closure. -#[derive(Debug, Copy, Clone, RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Debug, Copy, Clone, Encodable, HashStable_Generic)] pub struct Upvar { // First span where it is accessed (there can be multiple). pub span: Span, @@ -2658,7 +2649,7 @@ pub type CaptureModeMap = NodeMap<CaptureBy>; // The TraitCandidate's import_ids is empty if the trait is defined in the same module, and // has length > 0 if the trait is found through an chain of imports, starting with the // import/use statement in the scope where the trait is used. -#[derive(RustcEncodable, RustcDecodable, Clone, Debug)] +#[derive(Encodable, Decodable, Clone, Debug)] pub struct TraitCandidate { pub def_id: DefId, pub import_ids: SmallVec<[LocalDefId; 1]>, diff --git a/src/librustc_hir/hir_id.rs b/src/librustc_hir/hir_id.rs index d782c3dd70a..fea850c12d9 100644 --- a/src/librustc_hir/hir_id.rs +++ b/src/librustc_hir/hir_id.rs @@ -11,7 +11,8 @@ use std::fmt; /// the `local_id` part of the `HirId` changing, which is a very useful property in /// incremental compilation where we have to persist things through changes to /// the code base. -#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, PartialOrd, Ord, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)] +#[derive(Encodable, Decodable)] pub struct HirId { pub owner: LocalDefId, pub local_id: ItemLocalId, diff --git a/src/librustc_hir/lang_items.rs b/src/librustc_hir/lang_items.rs index 7f473a45848..b09657bd9b4 100644 --- a/src/librustc_hir/lang_items.rs +++ b/src/librustc_hir/lang_items.rs @@ -45,7 +45,7 @@ macro_rules! language_item_table { enum_from_u32! { /// A representation of all the valid language items in Rust. - #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] + #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Encodable, Decodable)] pub enum LangItem { $($variant,)* } @@ -165,6 +165,7 @@ language_item_table! { BoolImplItem, sym::bool, bool_impl, Target::Impl; CharImplItem, sym::char, char_impl, Target::Impl; StrImplItem, sym::str, str_impl, Target::Impl; + ArrayImplItem, sym::array, array_impl, Target::Impl; SliceImplItem, sym::slice, slice_impl, Target::Impl; SliceU8ImplItem, sym::slice_u8, slice_u8_impl, Target::Impl; StrAllocImplItem, sym::str_alloc, str_alloc_impl, Target::Impl; diff --git a/src/librustc_hir/lib.rs b/src/librustc_hir/lib.rs index 52131cb3d3d..a64565b20e7 100644 --- a/src/librustc_hir/lib.rs +++ b/src/librustc_hir/lib.rs @@ -7,10 +7,12 @@ #![feature(const_panic)] #![feature(in_band_lifetimes)] #![feature(or_patterns)] -#![feature(min_specialization)] #![recursion_limit = "256"] #[macro_use] +extern crate rustc_macros; + +#[macro_use] extern crate rustc_data_structures; mod arena; diff --git a/src/librustc_incremental/Cargo.toml b/src/librustc_incremental/Cargo.toml index 60a87078d63..1f7e3725412 100644 --- a/src/librustc_incremental/Cargo.toml +++ b/src/librustc_incremental/Cargo.toml @@ -11,13 +11,14 @@ doctest = false [dependencies] rustc_graphviz = { path = "../librustc_graphviz" } -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rand = "0.7" rustc_middle = { path = "../librustc_middle" } rustc_data_structures = { path = "../librustc_data_structures" } rustc_hir = { path = "../librustc_hir" } rustc_serialize = { path = "../librustc_serialize" } rustc_ast = { path = "../librustc_ast" } +rustc_macros = { path = "../librustc_macros" } rustc_span = { path = "../librustc_span" } rustc_fs_util = { path = "../librustc_fs_util" } rustc_session = { path = "../librustc_session" } diff --git a/src/librustc_incremental/lib.rs b/src/librustc_incremental/lib.rs index 7fd4b3c2554..ad189138054 100644 --- a/src/librustc_incremental/lib.rs +++ b/src/librustc_incremental/lib.rs @@ -8,7 +8,7 @@ #[macro_use] extern crate rustc_middle; #[macro_use] -extern crate log; +extern crate tracing; mod assert_dep_graph; pub mod assert_module_sources; diff --git a/src/librustc_incremental/persist/data.rs b/src/librustc_incremental/persist/data.rs index ea0fd4eb7ee..81e5410978d 100644 --- a/src/librustc_incremental/persist/data.rs +++ b/src/librustc_incremental/persist/data.rs @@ -1,8 +1,9 @@ //! The data that we will serialize and deserialize. +use rustc_macros::{Decodable, Encodable}; use rustc_middle::dep_graph::{WorkProduct, WorkProductId}; -#[derive(Debug, RustcEncodable, RustcDecodable)] +#[derive(Debug, Encodable, Decodable)] pub struct SerializedWorkProduct { /// node that produced the work-product pub id: WorkProductId, diff --git a/src/librustc_index/Cargo.toml b/src/librustc_index/Cargo.toml index 00b23760182..8aaf1cb9cbc 100644 --- a/src/librustc_index/Cargo.toml +++ b/src/librustc_index/Cargo.toml @@ -10,5 +10,6 @@ path = "lib.rs" doctest = false [dependencies] -rustc_serialize = { path = "../librustc_serialize" } arrayvec = "0.5.1" +rustc_serialize = { path = "../librustc_serialize" } +rustc_macros = { path = "../librustc_macros" } diff --git a/src/librustc_index/bit_set.rs b/src/librustc_index/bit_set.rs index e4b7c24a249..c43d1a6830d 100644 --- a/src/librustc_index/bit_set.rs +++ b/src/librustc_index/bit_set.rs @@ -7,6 +7,8 @@ use std::mem; use std::ops::{BitAnd, BitAndAssign, BitOrAssign, Not, Range, Shl}; use std::slice; +use rustc_macros::{Decodable, Encodable}; + #[cfg(test)] mod tests; @@ -26,7 +28,7 @@ pub const WORD_BITS: usize = WORD_BYTES * 8; /// will panic if the bitsets have differing domain sizes. /// /// [`GrowableBitSet`]: struct.GrowableBitSet.html -#[derive(Clone, Eq, PartialEq, RustcDecodable, RustcEncodable)] +#[derive(Clone, Eq, PartialEq, Decodable, Encodable)] pub struct BitSet<T: Idx> { domain_size: usize, words: Vec<Word>, @@ -700,7 +702,7 @@ impl<T: Idx> GrowableBitSet<T> { /// /// All operations that involve a row and/or column index will panic if the /// index exceeds the relevant bound. -#[derive(Clone, Eq, PartialEq, RustcDecodable, RustcEncodable)] +#[derive(Clone, Eq, PartialEq, Decodable, Encodable)] pub struct BitMatrix<R: Idx, C: Idx> { num_rows: usize, num_columns: usize, @@ -1108,7 +1110,7 @@ impl std::fmt::Debug for FiniteBitSet<u128> { /// A fixed-sized bitset type represented by an integer type. Indices outwith than the range /// representable by `T` are considered set. -#[derive(Copy, Clone, Eq, PartialEq, RustcDecodable, RustcEncodable)] +#[derive(Copy, Clone, Eq, PartialEq, Decodable, Encodable)] pub struct FiniteBitSet<T: FiniteBitSetTy>(pub T); impl<T: FiniteBitSetTy> FiniteBitSet<T> { diff --git a/src/librustc_index/vec.rs b/src/librustc_index/vec.rs index c5dedab9793..2420f82c041 100644 --- a/src/librustc_index/vec.rs +++ b/src/librustc_index/vec.rs @@ -320,14 +320,14 @@ macro_rules! newtype_index { derive [$($derives:ident,)+] $($tokens:tt)*) => ( $crate::newtype_index!( - @derives [$($derives,)+ RustcEncodable,] + @derives [$($derives,)+] @attrs [$(#[$attrs])*] @type [$type] @max [$max] @vis [$v] @debug_format [$debug_format] $($tokens)*); - $crate::newtype_index!(@decodable $type); + $crate::newtype_index!(@serializable $type); ); // The case where no derives are added, but encodable is overridden. Don't @@ -357,22 +357,27 @@ macro_rules! newtype_index { @debug_format [$debug_format:tt] $($tokens:tt)*) => ( $crate::newtype_index!( - @derives [RustcEncodable,] + @derives [] @attrs [$(#[$attrs])*] @type [$type] @max [$max] @vis [$v] @debug_format [$debug_format] $($tokens)*); - $crate::newtype_index!(@decodable $type); + $crate::newtype_index!(@serializable $type); ); - (@decodable $type:ident) => ( - impl ::rustc_serialize::Decodable for $type { - fn decode<D: ::rustc_serialize::Decoder>(d: &mut D) -> Result<Self, D::Error> { + (@serializable $type:ident) => ( + impl<D: ::rustc_serialize::Decoder> ::rustc_serialize::Decodable<D> for $type { + fn decode(d: &mut D) -> Result<Self, D::Error> { d.read_u32().map(Self::from_u32) } } + impl<E: ::rustc_serialize::Encoder> ::rustc_serialize::Encodable<E> for $type { + fn encode(&self, e: &mut E) -> Result<(), E::Error> { + e.emit_u32(self.private) + } + } ); // Rewrite final without comma to one that includes comma @@ -483,14 +488,20 @@ pub struct IndexVec<I: Idx, T> { // not the phantom data. unsafe impl<I: Idx, T> Send for IndexVec<I, T> where T: Send {} -impl<I: Idx, T: Encodable> Encodable for IndexVec<I, T> { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, I: Idx, T: Encodable<S>> Encodable<S> for IndexVec<I, T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { Encodable::encode(&self.raw, s) } } -impl<I: Idx, T: Decodable> Decodable for IndexVec<I, T> { - fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error> { +impl<S: Encoder, I: Idx, T: Encodable<S>> Encodable<S> for &IndexVec<I, T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + Encodable::encode(&self.raw, s) + } +} + +impl<D: Decoder, I: Idx, T: Decodable<D>> Decodable<D> for IndexVec<I, T> { + fn decode(d: &mut D) -> Result<Self, D::Error> { Decodable::decode(d).map(|v| IndexVec { raw: v, _marker: PhantomData }) } } @@ -669,6 +680,17 @@ impl<I: Idx, T> IndexVec<I, T> { } } + /// Returns mutable references to three distinct elements or panics otherwise. + #[inline] + pub fn pick3_mut(&mut self, a: I, b: I, c: I) -> (&mut T, &mut T, &mut T) { + let (ai, bi, ci) = (a.index(), b.index(), c.index()); + assert!(ai != bi && bi != ci && ci != ai); + let len = self.raw.len(); + assert!(ai < len && bi < len && ci < len); + let ptr = self.raw.as_mut_ptr(); + unsafe { (&mut *ptr.add(ai), &mut *ptr.add(bi), &mut *ptr.add(ci)) } + } + pub fn convert_index_type<Ix: Idx>(self) -> IndexVec<Ix, T> { IndexVec { raw: self.raw, _marker: PhantomData } } diff --git a/src/librustc_infer/Cargo.toml b/src/librustc_infer/Cargo.toml index 9d56fa223a9..e1698d66323 100644 --- a/src/librustc_infer/Cargo.toml +++ b/src/librustc_infer/Cargo.toml @@ -11,7 +11,7 @@ doctest = false [dependencies] rustc_graphviz = { path = "../librustc_graphviz" } -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc_middle = { path = "../librustc_middle" } rustc_data_structures = { path = "../librustc_data_structures" } rustc_errors = { path = "../librustc_errors" } diff --git a/src/librustc_infer/infer/error_reporting/mod.rs b/src/librustc_infer/infer/error_reporting/mod.rs index 063246f79fe..2b2c42207e4 100644 --- a/src/librustc_infer/infer/error_reporting/mod.rs +++ b/src/librustc_infer/infer/error_reporting/mod.rs @@ -144,7 +144,7 @@ fn msg_span_from_early_bound_and_free_regions( let sm = tcx.sess.source_map(); let scope = region.free_region_binding_scope(tcx); - let node = tcx.hir().as_local_hir_id(scope.expect_local()); + let node = tcx.hir().local_def_id_to_hir_id(scope.expect_local()); let tag = match tcx.hir().find(node) { Some(Node::Block(_) | Node::Expr(_)) => "body", Some(Node::Item(it)) => item_scope_tag(&it), @@ -1707,7 +1707,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { .in_progress_typeck_results .map(|typeck_results| typeck_results.borrow().hir_owner) .map(|owner| { - let hir_id = hir.as_local_hir_id(owner); + let hir_id = hir.local_def_id_to_hir_id(owner); let parent_id = hir.get_parent_item(hir_id); ( // Parent item could be a `mod`, so we check the HIR before calling: @@ -1733,7 +1733,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { // Get the `hir::Param` to verify whether it already has any bounds. // We do this to avoid suggesting code that ends up as `T: 'a'b`, // instead we suggest `T: 'a + 'b` in that case. - let id = hir.as_local_hir_id(def_id); + let id = hir.local_def_id_to_hir_id(def_id); let mut has_bounds = false; if let Node::GenericParam(param) = hir.get(id) { has_bounds = !param.bounds.is_empty(); @@ -1786,7 +1786,10 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { .and_then(|(_, g)| g.params.first()) .and_then(|param| param.def_id.as_local()) .map(|def_id| { - (hir.span(hir.as_local_hir_id(def_id)).shrink_to_lo(), format!("{}, ", new_lt)) + ( + hir.span(hir.local_def_id_to_hir_id(def_id)).shrink_to_lo(), + format!("{}, ", new_lt), + ) }); let labeled_user_string = match bound_kind { diff --git a/src/librustc_infer/infer/error_reporting/nice_region_error/find_anon_type.rs b/src/librustc_infer/infer/error_reporting/nice_region_error/find_anon_type.rs index 20617bb8bd8..eb1521f0565 100644 --- a/src/librustc_infer/infer/error_reporting/nice_region_error/find_anon_type.rs +++ b/src/librustc_infer/infer/error_reporting/nice_region_error/find_anon_type.rs @@ -28,7 +28,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> { br: &ty::BoundRegion, ) -> Option<(&hir::Ty<'tcx>, &hir::FnDecl<'tcx>)> { if let Some(anon_reg) = self.tcx().is_suitable_region(region) { - let hir_id = self.tcx().hir().as_local_hir_id(anon_reg.def_id); + let hir_id = self.tcx().hir().local_def_id_to_hir_id(anon_reg.def_id); let fndecl = match self.tcx().hir().get(hir_id) { Node::Item(&hir::Item { kind: hir::ItemKind::Fn(ref m, ..), .. }) | Node::TraitItem(&hir::TraitItem { diff --git a/src/librustc_infer/infer/error_reporting/nice_region_error/trait_impl_difference.rs b/src/librustc_infer/infer/error_reporting/nice_region_error/trait_impl_difference.rs index 1ddf88c0306..788eabf296d 100644 --- a/src/librustc_infer/infer/error_reporting/nice_region_error/trait_impl_difference.rs +++ b/src/librustc_infer/infer/error_reporting/nice_region_error/trait_impl_difference.rs @@ -67,7 +67,8 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> { match assoc_item.kind { ty::AssocKind::Fn => { let hir = self.tcx().hir(); - if let Some(hir_id) = assoc_item.def_id.as_local().map(|id| hir.as_local_hir_id(id)) + if let Some(hir_id) = + assoc_item.def_id.as_local().map(|id| hir.local_def_id_to_hir_id(id)) { if let Some(decl) = hir.fn_decl_by_hir_id(hir_id) { visitor.visit_fn_decl(decl); diff --git a/src/librustc_infer/infer/error_reporting/nice_region_error/util.rs b/src/librustc_infer/infer/error_reporting/nice_region_error/util.rs index 28e9dd90cfd..6e2d49f1ad7 100644 --- a/src/librustc_infer/infer/error_reporting/nice_region_error/util.rs +++ b/src/librustc_infer/infer/error_reporting/nice_region_error/util.rs @@ -49,7 +49,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> { }; let hir = &self.tcx().hir(); - let hir_id = hir.as_local_hir_id(id.as_local()?); + let hir_id = hir.local_def_id_to_hir_id(id.as_local()?); let body_id = hir.maybe_body_owned_by(hir_id)?; let body = hir.body(body_id); let owner_id = hir.body_owner(body_id); diff --git a/src/librustc_infer/infer/free_regions.rs b/src/librustc_infer/infer/free_regions.rs index d975038b010..ffe5fb172be 100644 --- a/src/librustc_infer/infer/free_regions.rs +++ b/src/librustc_infer/infer/free_regions.rs @@ -7,17 +7,14 @@ use rustc_data_structures::transitive_relation::TransitiveRelation; use rustc_hir::def_id::DefId; use rustc_middle::ty::{self, Lift, Region, TyCtxt}; -/// Combines a `region::ScopeTree` (which governs relationships between -/// scopes) and a `FreeRegionMap` (which governs relationships between -/// free regions) to yield a complete relation between concrete -/// regions. +/// Combines a `FreeRegionMap` and a `TyCtxt`. /// /// This stuff is a bit convoluted and should be refactored, but as we /// transition to NLL, it'll all go away anyhow. pub struct RegionRelations<'a, 'tcx> { pub tcx: TyCtxt<'tcx>, - /// The context used to fetch the region maps. + /// The context used for debug messages pub context: DefId, /// Free-region relationships. @@ -34,7 +31,7 @@ impl<'a, 'tcx> RegionRelations<'a, 'tcx> { } } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Default, HashStable)] +#[derive(Clone, Debug, Default)] pub struct FreeRegionMap<'tcx> { // Stores the relation `a < b`, where `a` and `b` are regions. // diff --git a/src/librustc_infer/lib.rs b/src/librustc_infer/lib.rs index bacb7fa153e..f135bde7f83 100644 --- a/src/librustc_infer/lib.rs +++ b/src/librustc_infer/lib.rs @@ -33,7 +33,7 @@ extern crate rustc_macros; #[macro_use] extern crate rustc_data_structures; #[macro_use] -extern crate log; +extern crate tracing; #[macro_use] extern crate rustc_middle; diff --git a/src/librustc_interface/Cargo.toml b/src/librustc_interface/Cargo.toml index 5c7edc10dd5..b9837c6ade9 100644 --- a/src/librustc_interface/Cargo.toml +++ b/src/librustc_interface/Cargo.toml @@ -11,7 +11,7 @@ doctest = false [dependencies] libc = "0.2" -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rayon = { version = "0.3.0", package = "rustc-rayon" } smallvec = { version = "1.0", features = ["union", "may_dangle"] } rustc_ast = { path = "../librustc_ast" } diff --git a/src/librustc_interface/interface.rs b/src/librustc_interface/interface.rs index 4dccf273dd9..122d6e3543c 100644 --- a/src/librustc_interface/interface.rs +++ b/src/librustc_interface/interface.rs @@ -198,7 +198,7 @@ pub fn create_compiler_and_run<R>(config: Config, f: impl FnOnce(&Compiler) -> R } pub fn run_compiler<R: Send>(mut config: Config, f: impl FnOnce(&Compiler) -> R + Send) -> R { - log::trace!("run_compiler"); + tracing::trace!("run_compiler"); let stderr = config.stderr.take(); util::setup_callbacks_and_run_in_thread_pool_with_globals( config.opts.edition, diff --git a/src/librustc_interface/passes.rs b/src/librustc_interface/passes.rs index 701fca8e4b5..daa7444fb9e 100644 --- a/src/librustc_interface/passes.rs +++ b/src/librustc_interface/passes.rs @@ -2,7 +2,6 @@ use crate::interface::{Compiler, Result}; use crate::proc_macro_decls; use crate::util; -use log::{info, warn}; use once_cell::sync::Lazy; use rustc_ast::mut_visit::MutVisitor; use rustc_ast::{self, ast, visit}; @@ -39,6 +38,7 @@ use rustc_span::symbol::Symbol; use rustc_span::{FileName, RealFileName}; use rustc_trait_selection::traits; use rustc_typeck as typeck; +use tracing::{info, warn}; use rustc_serialize::json; use tempfile::Builder as TempFileBuilder; @@ -104,7 +104,7 @@ pub fn configure_and_expand( krate: ast::Crate, crate_name: &str, ) -> Result<(ast::Crate, BoxedResolver)> { - log::trace!("configure_and_expand"); + tracing::trace!("configure_and_expand"); // Currently, we ignore the name resolution data structures for the purposes of dependency // tracking. Instead we will run name resolution and include its output in the hash of each // item, much like we do for macro expansion. In other words, the hash reflects not just @@ -229,7 +229,7 @@ fn configure_and_expand_inner<'a>( resolver_arenas: &'a ResolverArenas<'a>, metadata_loader: &'a MetadataLoaderDyn, ) -> Result<(ast::Crate, Resolver<'a>)> { - log::trace!("configure_and_expand_inner"); + tracing::trace!("configure_and_expand_inner"); pre_expansion_lint(sess, lint_store, &krate); let mut resolver = Resolver::new(sess, &krate, crate_name, metadata_loader, &resolver_arenas); @@ -342,7 +342,7 @@ fn configure_and_expand_inner<'a>( }); if let Some(PpMode::PpmSource(PpSourceMode::PpmEveryBodyLoops)) = sess.opts.pretty { - log::debug!("replacing bodies with loop {{}}"); + tracing::debug!("replacing bodies with loop {{}}"); util::ReplaceBodyWithLoop::new(&mut resolver).visit_crate(&mut krate); } diff --git a/src/librustc_interface/queries.rs b/src/librustc_interface/queries.rs index d1a22c69ee0..2f32737cca0 100644 --- a/src/librustc_interface/queries.rs +++ b/src/librustc_interface/queries.rs @@ -168,7 +168,7 @@ impl<'tcx> Queries<'tcx> { pub fn expansion( &self, ) -> Result<&Query<(ast::Crate, Steal<Rc<RefCell<BoxedResolver>>>, Lrc<LintStore>)>> { - log::trace!("expansion"); + tracing::trace!("expansion"); self.expansion.compute(|| { let crate_name = self.crate_name()?.peek().clone(); let (krate, lint_store) = self.register_plugins()?.take(); diff --git a/src/librustc_interface/util.rs b/src/librustc_interface/util.rs index e403a60ff32..36eaad16079 100644 --- a/src/librustc_interface/util.rs +++ b/src/librustc_interface/util.rs @@ -1,4 +1,3 @@ -use log::info; use rustc_ast::ast::{AttrVec, BlockCheckMode}; use rustc_ast::mut_visit::{visit_clobber, MutVisitor, *}; use rustc_ast::ptr::P; @@ -33,6 +32,7 @@ use std::path::{Path, PathBuf}; use std::sync::{Arc, Mutex, Once}; #[cfg(not(parallel_compiler))] use std::{panic, thread}; +use tracing::info; /// Adds `target_feature = "..."` cfgs for a variety of platform /// specific features (SSE, NEON etc.). diff --git a/src/librustc_lint/Cargo.toml b/src/librustc_lint/Cargo.toml index 3ba1566023d..d779f15f19a 100644 --- a/src/librustc_lint/Cargo.toml +++ b/src/librustc_lint/Cargo.toml @@ -9,7 +9,7 @@ name = "rustc_lint" path = "lib.rs" [dependencies] -log = { package = "tracing", version = "0.1" } +tracing = "0.1" unicode-security = "0.0.5" rustc_middle = { path = "../librustc_middle" } rustc_ast_pretty = { path = "../librustc_ast_pretty" } diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index c42794e00b4..3859d0f163a 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -51,8 +51,8 @@ use rustc_trait_selection::traits::misc::can_type_implement_copy; use crate::nonstandard_style::{method_context, MethodLateContext}; -use log::{debug, trace}; use std::fmt::Write; +use tracing::{debug, trace}; // hardwired lints from librustc_middle pub use rustc_session::lint::builtin::*; @@ -440,7 +440,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc { // reported for missing docs. let real_trait = trait_ref.path.res.def_id(); if let Some(def_id) = real_trait.as_local() { - let hir_id = cx.tcx.hir().as_local_hir_id(def_id); + let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def_id); if let Some(Node::Item(item)) = cx.tcx.hir().find(hir_id) { if let hir::VisibilityKind::Inherited = item.vis.node { for impl_item_ref in items { @@ -614,7 +614,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDebugImplementations { cx.tcx.for_each_impl(debug, |d| { if let Some(ty_def) = cx.tcx.type_of(d).ty_adt_def() { if let Some(def_id) = ty_def.did.as_local() { - impls.insert(cx.tcx.hir().as_local_hir_id(def_id)); + impls.insert(cx.tcx.hir().local_def_id_to_hir_id(def_id)); } } }); diff --git a/src/librustc_lint/early.rs b/src/librustc_lint/early.rs index d891466611a..017d4e31e4a 100644 --- a/src/librustc_lint/early.rs +++ b/src/librustc_lint/early.rs @@ -23,8 +23,8 @@ use rustc_session::Session; use rustc_span::symbol::Ident; use rustc_span::Span; -use log::debug; use std::slice; +use tracing::debug; macro_rules! run_early_pass { ($cx:expr, $f:ident, $($args:expr),*) => ({ $cx.pass.$f(&$cx.context, $($args),*); diff --git a/src/librustc_lint/late.rs b/src/librustc_lint/late.rs index f43c197d2d2..6c497d02285 100644 --- a/src/librustc_lint/late.rs +++ b/src/librustc_lint/late.rs @@ -28,10 +28,10 @@ use rustc_session::lint::LintPass; use rustc_span::symbol::Symbol; use rustc_span::Span; -use log::debug; use std::any::Any; use std::cell::Cell; use std::slice; +use tracing::debug; /// Extract the `LintStore` from the query context. /// This function exists because we've erased `LintStore` as `dyn Any` in the context. @@ -379,7 +379,7 @@ fn late_lint_mod_pass<'tcx, T: LateLintPass<'tcx>>( param_env: ty::ParamEnv::empty(), access_levels, lint_store: unerased_lint_store(tcx), - last_node_with_lint_attrs: tcx.hir().as_local_hir_id(module_def_id), + last_node_with_lint_attrs: tcx.hir().local_def_id_to_hir_id(module_def_id), generics: None, only_module: true, }; diff --git a/src/librustc_lint/types.rs b/src/librustc_lint/types.rs index 5c53e435fd7..5891abcfd9c 100644 --- a/src/librustc_lint/types.rs +++ b/src/librustc_lint/types.rs @@ -19,8 +19,8 @@ use rustc_target::abi::Abi; use rustc_target::abi::{Integer, LayoutOf, TagEncoding, VariantIdx, Variants}; use rustc_target::spec::abi::Abi as SpecAbi; -use log::debug; use std::cmp; +use tracing::debug; declare_lint! { UNUSED_COMPARISONS, diff --git a/src/librustc_lint/unused.rs b/src/librustc_lint/unused.rs index ecc8a192f18..95e51b47be3 100644 --- a/src/librustc_lint/unused.rs +++ b/src/librustc_lint/unused.rs @@ -17,7 +17,7 @@ use rustc_span::symbol::Symbol; use rustc_span::symbol::{kw, sym}; use rustc_span::{BytePos, Span, DUMMY_SP}; -use log::debug; +use tracing::debug; declare_lint! { pub UNUSED_MUST_USE, diff --git a/src/librustc_macros/src/lib.rs b/src/librustc_macros/src/lib.rs index 6b30ae42a19..7fb3b0e7ea6 100644 --- a/src/librustc_macros/src/lib.rs +++ b/src/librustc_macros/src/lib.rs @@ -8,6 +8,7 @@ use proc_macro::TokenStream; mod hash_stable; mod lift; mod query; +mod serialize; mod symbols; mod type_foldable; @@ -27,5 +28,11 @@ decl_derive!( hash_stable::hash_stable_generic_derive ); +decl_derive!([Decodable] => serialize::decodable_derive); +decl_derive!([Encodable] => serialize::encodable_derive); +decl_derive!([TyDecodable] => serialize::type_decodable_derive); +decl_derive!([TyEncodable] => serialize::type_encodable_derive); +decl_derive!([MetadataDecodable] => serialize::meta_decodable_derive); +decl_derive!([MetadataEncodable] => serialize::meta_encodable_derive); decl_derive!([TypeFoldable, attributes(type_foldable)] => type_foldable::type_foldable_derive); decl_derive!([Lift, attributes(lift)] => lift::lift_derive); diff --git a/src/librustc_macros/src/serialize.rs b/src/librustc_macros/src/serialize.rs new file mode 100644 index 00000000000..dbeb3c75504 --- /dev/null +++ b/src/librustc_macros/src/serialize.rs @@ -0,0 +1,290 @@ +use proc_macro2::TokenStream; +use quote::quote; +use syn::parse_quote; + +pub fn type_decodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream { + let decoder_ty = quote! { __D }; + if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") { + s.add_impl_generic(parse_quote! { 'tcx }); + } + s.add_impl_generic(parse_quote! {#decoder_ty: ::rustc_middle::ty::codec::TyDecoder<'tcx>}); + s.add_bounds(synstructure::AddBounds::Generics); + + decodable_body(s, decoder_ty) +} + +pub fn meta_decodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream { + if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") { + s.add_impl_generic(parse_quote! { 'tcx }); + } + s.add_impl_generic(parse_quote! { '__a }); + let decoder_ty = quote! { DecodeContext<'__a, 'tcx> }; + s.add_bounds(synstructure::AddBounds::Generics); + + decodable_body(s, decoder_ty) +} + +pub fn decodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream { + let decoder_ty = quote! { __D }; + s.add_impl_generic(parse_quote! {#decoder_ty: ::rustc_serialize::Decoder}); + s.add_bounds(synstructure::AddBounds::Generics); + + decodable_body(s, decoder_ty) +} + +fn decodable_body( + s: synstructure::Structure<'_>, + decoder_ty: TokenStream, +) -> proc_macro2::TokenStream { + if let syn::Data::Union(_) = s.ast().data { + panic!("cannot derive on union") + } + let ty_name = s.ast().ident.to_string(); + let decode_body = match s.variants() { + [vi] => { + let construct = vi.construct(|field, index| decode_field(field, index, true)); + let n_fields = vi.ast().fields.len(); + quote! { + ::rustc_serialize::Decoder::read_struct( + __decoder, + #ty_name, + #n_fields, + |__decoder| { ::std::result::Result::Ok(#construct) }, + ) + } + } + variants => { + let match_inner: TokenStream = variants + .iter() + .enumerate() + .map(|(idx, vi)| { + let construct = vi.construct(|field, index| decode_field(field, index, false)); + quote! { #idx => { ::std::result::Result::Ok(#construct) } } + }) + .collect(); + let names: TokenStream = variants + .iter() + .map(|vi| { + let variant_name = vi.ast().ident.to_string(); + quote!(#variant_name,) + }) + .collect(); + let message = format!( + "invalid enum variant tag while decoding `{}`, expected 0..{}", + ty_name, + variants.len() + ); + quote! { + ::rustc_serialize::Decoder::read_enum( + __decoder, + #ty_name, + |__decoder| { + ::rustc_serialize::Decoder::read_enum_variant( + __decoder, + &[#names], + |__decoder, __variant_idx| { + match __variant_idx { + #match_inner + _ => return ::std::result::Result::Err( + ::rustc_serialize::Decoder::error(__decoder, #message)), + } + }) + } + ) + } + } + }; + + s.bound_impl( + quote!(::rustc_serialize::Decodable<#decoder_ty>), + quote! { + fn decode( + __decoder: &mut #decoder_ty, + ) -> ::std::result::Result<Self, <#decoder_ty as ::rustc_serialize::Decoder>::Error> { + #decode_body + } + }, + ) +} + +fn decode_field(field: &syn::Field, index: usize, is_struct: bool) -> proc_macro2::TokenStream { + let decode_inner_method = if let syn::Type::Reference(_) = field.ty { + quote! { ::rustc_middle::ty::codec::RefDecodable::decode } + } else { + quote! { ::rustc_serialize::Decodable::decode } + }; + let (decode_method, opt_field_name) = if is_struct { + let field_name = field.ident.as_ref().map_or_else(|| index.to_string(), |i| i.to_string()); + ( + proc_macro2::Ident::new("read_struct_field", proc_macro2::Span::call_site()), + quote! { #field_name, }, + ) + } else { + ( + proc_macro2::Ident::new("read_enum_variant_arg", proc_macro2::Span::call_site()), + quote! {}, + ) + }; + + quote! { + match ::rustc_serialize::Decoder::#decode_method( + __decoder, #opt_field_name #index, #decode_inner_method) { + ::std::result::Result::Ok(__res) => __res, + ::std::result::Result::Err(__err) => return ::std::result::Result::Err(__err), + } + } +} + +pub fn type_encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream { + if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") { + s.add_impl_generic(parse_quote! {'tcx}); + } + let encoder_ty = quote! { __E }; + s.add_impl_generic(parse_quote! {#encoder_ty: ::rustc_middle::ty::codec::TyEncoder<'tcx>}); + s.add_bounds(synstructure::AddBounds::Generics); + + encodable_body(s, encoder_ty, false) +} + +pub fn meta_encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream { + if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") { + s.add_impl_generic(parse_quote! {'tcx}); + } + s.add_impl_generic(parse_quote! { '__a }); + let encoder_ty = quote! { EncodeContext<'__a, 'tcx> }; + s.add_bounds(synstructure::AddBounds::Generics); + + encodable_body(s, encoder_ty, true) +} + +pub fn encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream { + let encoder_ty = quote! { __E }; + s.add_impl_generic(parse_quote! { #encoder_ty: ::rustc_serialize::Encoder}); + s.add_bounds(synstructure::AddBounds::Generics); + + encodable_body(s, encoder_ty, false) +} + +fn encodable_body( + mut s: synstructure::Structure<'_>, + encoder_ty: TokenStream, + allow_unreachable_code: bool, +) -> proc_macro2::TokenStream { + if let syn::Data::Union(_) = s.ast().data { + panic!("cannot derive on union") + } + + s.bind_with(|binding| { + // Handle the lack of a blanket reference impl. + if let syn::Type::Reference(_) = binding.ast().ty { + synstructure::BindStyle::Move + } else { + synstructure::BindStyle::Ref + } + }); + + let ty_name = s.ast().ident.to_string(); + let encode_body = match s.variants() { + [_] => { + let mut field_idx = 0usize; + let encode_inner = s.each_variant(|vi| { + vi.bindings() + .iter() + .map(|binding| { + let bind_ident = &binding.binding; + let field_name = binding + .ast() + .ident + .as_ref() + .map_or_else(|| field_idx.to_string(), |i| i.to_string()); + let result = quote! { + match ::rustc_serialize::Encoder::emit_struct_field( + __encoder, + #field_name, + #field_idx, + |__encoder| + ::rustc_serialize::Encodable::encode(#bind_ident, __encoder), + ) { + ::std::result::Result::Ok(()) => (), + ::std::result::Result::Err(__err) + => return ::std::result::Result::Err(__err), + } + }; + field_idx += 1; + result + }) + .collect::<TokenStream>() + }); + quote! { + ::rustc_serialize::Encoder::emit_struct(__encoder, #ty_name, #field_idx, |__encoder| { + ::std::result::Result::Ok(match *self { #encode_inner }) + }) + } + } + _ => { + let mut variant_idx = 0usize; + let encode_inner = s.each_variant(|vi| { + let variant_name = vi.ast().ident.to_string(); + let mut field_idx = 0usize; + + let encode_fields: TokenStream = vi + .bindings() + .iter() + .map(|binding| { + let bind_ident = &binding.binding; + let result = quote! { + match ::rustc_serialize::Encoder::emit_enum_variant_arg( + __encoder, + #field_idx, + |__encoder| + ::rustc_serialize::Encodable::encode(#bind_ident, __encoder), + ) { + ::std::result::Result::Ok(()) => (), + ::std::result::Result::Err(__err) + => return ::std::result::Result::Err(__err), + } + }; + field_idx += 1; + result + }) + .collect(); + + let result = quote! { ::rustc_serialize::Encoder::emit_enum_variant( + __encoder, + #variant_name, + #variant_idx, + #field_idx, + |__encoder| { ::std::result::Result::Ok({ #encode_fields }) } + ) }; + variant_idx += 1; + result + }); + quote! { + ::rustc_serialize::Encoder::emit_enum(__encoder, #ty_name, |__encoder| { + match *self { + #encode_inner + } + }) + } + } + }; + + let lints = if allow_unreachable_code { + quote! { #![allow(unreachable_code)] } + } else { + quote! {} + }; + + s.bound_impl( + quote!(::rustc_serialize::Encodable<#encoder_ty>), + quote! { + fn encode( + &self, + __encoder: &mut #encoder_ty, + ) -> ::std::result::Result<(), <#encoder_ty as ::rustc_serialize::Encoder>::Error> { + #lints + #encode_body + } + }, + ) +} diff --git a/src/librustc_macros/src/symbols.rs b/src/librustc_macros/src/symbols.rs index 2e9b3a2a256..352665f0ab1 100644 --- a/src/librustc_macros/src/symbols.rs +++ b/src/librustc_macros/src/symbols.rs @@ -167,7 +167,7 @@ pub fn symbols(input: TokenStream) -> TokenStream { } } - macro_rules! symbols { + macro_rules! define_symbols { () => { #symbols_stream diff --git a/src/librustc_metadata/Cargo.toml b/src/librustc_metadata/Cargo.toml index 2c0e2aa39fd..af6aacfd64b 100644 --- a/src/librustc_metadata/Cargo.toml +++ b/src/librustc_metadata/Cargo.toml @@ -12,7 +12,7 @@ doctest = false [dependencies] flate2 = "1.0" libc = "0.2" -log = { package = "tracing", version = "0.1" } +tracing = "0.1" memmap = "0.7" smallvec = { version = "1.0", features = ["union", "may_dangle"] } rustc_middle = { path = "../librustc_middle" } @@ -23,6 +23,7 @@ rustc_hir = { path = "../librustc_hir" } rustc_hir_pretty = { path = "../librustc_hir_pretty" } rustc_target = { path = "../librustc_target" } rustc_index = { path = "../librustc_index" } +rustc_macros = { path = "../librustc_macros" } rustc_serialize = { path = "../librustc_serialize" } stable_deref_trait = "1.0.0" rustc_ast = { path = "../librustc_ast" } diff --git a/src/librustc_metadata/creader.rs b/src/librustc_metadata/creader.rs index e15655e3794..9827b222331 100644 --- a/src/librustc_metadata/creader.rs +++ b/src/librustc_metadata/creader.rs @@ -26,10 +26,10 @@ use rustc_span::symbol::{sym, Symbol}; use rustc_span::{Span, DUMMY_SP}; use rustc_target::spec::{PanicStrategy, TargetTriple}; -use log::{debug, info}; use proc_macro::bridge::client::ProcMacro; use std::path::Path; use std::{cmp, env, fs}; +use tracing::{debug, info}; #[derive(Clone)] pub struct CStore { diff --git a/src/librustc_metadata/dependency_format.rs b/src/librustc_metadata/dependency_format.rs index bb5ae4d0557..f7454da90a3 100644 --- a/src/librustc_metadata/dependency_format.rs +++ b/src/librustc_metadata/dependency_format.rs @@ -159,11 +159,11 @@ fn calculate_type(tcx: TyCtxt<'_>, ty: CrateType) -> DependencyList { let name = tcx.crate_name(cnum); let src = tcx.used_crate_source(cnum); if src.dylib.is_some() { - log::info!("adding dylib: {}", name); + tracing::info!("adding dylib: {}", name); add_library(tcx, cnum, RequireDynamic, &mut formats); let deps = tcx.dylib_dependency_formats(cnum); for &(depnum, style) in deps.iter() { - log::info!("adding {:?}: {}", style, tcx.crate_name(depnum)); + tracing::info!("adding {:?}: {}", style, tcx.crate_name(depnum)); add_library(tcx, depnum, style, &mut formats); } } @@ -191,7 +191,7 @@ fn calculate_type(tcx: TyCtxt<'_>, ty: CrateType) -> DependencyList { && tcx.dep_kind(cnum) == CrateDepKind::Explicit { assert!(src.rlib.is_some() || src.rmeta.is_some()); - log::info!("adding staticlib: {}", tcx.crate_name(cnum)); + tracing::info!("adding staticlib: {}", tcx.crate_name(cnum)); add_library(tcx, cnum, RequireStatic, &mut formats); ret[cnum.as_usize() - 1] = Linkage::Static; } diff --git a/src/librustc_metadata/lib.rs b/src/librustc_metadata/lib.rs index 059ae340bcf..e50fa34554d 100644 --- a/src/librustc_metadata/lib.rs +++ b/src/librustc_metadata/lib.rs @@ -16,6 +16,8 @@ extern crate proc_macro; #[macro_use] +extern crate rustc_macros; +#[macro_use] extern crate rustc_middle; #[macro_use] extern crate rustc_data_structures; diff --git a/src/librustc_metadata/locator.rs b/src/librustc_metadata/locator.rs index 8828b318d1e..bdd20a4bf6f 100644 --- a/src/librustc_metadata/locator.rs +++ b/src/librustc_metadata/locator.rs @@ -230,11 +230,11 @@ use rustc_span::Span; use rustc_target::spec::{Target, TargetTriple}; use flate2::read::DeflateDecoder; -use log::{debug, info, warn}; use std::io::{Read, Result as IoResult, Write}; use std::ops::Deref; use std::path::{Path, PathBuf}; use std::{cmp, fmt, fs}; +use tracing::{debug, info, warn}; #[derive(Clone)] crate struct CrateLocator<'a> { diff --git a/src/librustc_metadata/rmeta/decoder.rs b/src/librustc_metadata/rmeta/decoder.rs index 8aea9a9f588..1e4556f5fc8 100644 --- a/src/librustc_metadata/rmeta/decoder.rs +++ b/src/librustc_metadata/rmeta/decoder.rs @@ -7,7 +7,7 @@ use crate::rmeta::*; use rustc_ast::ast; use rustc_attr as attr; use rustc_data_structures::captures::Captures; -use rustc_data_structures::fingerprint::Fingerprint; +use rustc_data_structures::fingerprint::{Fingerprint, FingerprintDecoder}; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::svh::Svh; use rustc_data_structures::sync::{AtomicCell, Lock, LockGuard, Lrc, OnceCell}; @@ -15,7 +15,7 @@ use rustc_expand::base::{SyntaxExtension, SyntaxExtensionKind}; use rustc_expand::proc_macro::{AttrProcMacro, BangProcMacro, ProcMacroDerive}; use rustc_hir as hir; use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res}; -use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE}; +use rustc_hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE}; use rustc_hir::definitions::DefPathTable; use rustc_hir::definitions::{DefKey, DefPath, DefPathData, DefPathHash}; use rustc_hir::lang_items; @@ -26,24 +26,24 @@ use rustc_middle::middle::cstore::{CrateSource, ExternCrate}; use rustc_middle::middle::cstore::{ForeignModule, LinkagePreference, NativeLib}; use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportLevel}; use rustc_middle::mir::interpret::{AllocDecodingSession, AllocDecodingState}; -use rustc_middle::mir::{self, interpret, Body, Promoted}; +use rustc_middle::mir::{self, Body, Promoted}; use rustc_middle::ty::codec::TyDecoder; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_middle::util::common::record_time; -use rustc_serialize::{opaque, Decodable, Decoder, SpecializedDecoder, UseSpecializedDecodable}; +use rustc_serialize::{opaque, Decodable, Decoder}; use rustc_session::Session; use rustc_span::hygiene::ExpnDataDecodeMode; use rustc_span::source_map::{respan, Spanned}; use rustc_span::symbol::{sym, Ident, Symbol}; use rustc_span::{self, hygiene::MacroKind, BytePos, ExpnId, Pos, Span, SyntaxContext, DUMMY_SP}; -use log::debug; use proc_macro::bridge::client::ProcMacro; use std::cell::Cell; use std::io; use std::mem; use std::num::NonZeroUsize; use std::path::Path; +use tracing::debug; pub use cstore_impl::{provide, provide_extern}; use rustc_span::hygiene::HygieneDecodeContext; @@ -229,7 +229,7 @@ impl<'a, 'tcx> Metadata<'a, 'tcx> for (&'a CrateMetadataRef<'a>, TyCtxt<'tcx>) { } } -impl<'a, 'tcx, T: Decodable> Lazy<T, ()> { +impl<'a, 'tcx, T: Decodable<DecodeContext<'a, 'tcx>>> Lazy<T> { fn decode<M: Metadata<'a, 'tcx>>(self, metadata: M) -> T { let mut dcx = metadata.decoder(self.position.get()); dcx.lazy_state = LazyState::NodeStart(self.position); @@ -237,7 +237,7 @@ impl<'a, 'tcx, T: Decodable> Lazy<T, ()> { } } -impl<'a: 'x, 'tcx: 'x, 'x, T: Decodable> Lazy<[T], usize> { +impl<'a: 'x, 'tcx: 'x, 'x, T: Decodable<DecodeContext<'a, 'tcx>>> Lazy<[T]> { fn decode<M: Metadata<'a, 'tcx>>( self, metadata: M, @@ -278,6 +278,8 @@ impl<'a, 'tcx> DecodeContext<'a, 'tcx> { } impl<'a, 'tcx> TyDecoder<'tcx> for DecodeContext<'a, 'tcx> { + const CLEAR_CROSS_CRATE: bool = true; + #[inline] fn tcx(&self) -> TyCtxt<'tcx> { self.tcx.expect("missing TyCtxt in DecodeContext") @@ -351,68 +353,92 @@ impl<'a, 'tcx> TyDecoder<'tcx> for DecodeContext<'a, 'tcx> { fn map_encoded_cnum_to_current(&self, cnum: CrateNum) -> CrateNum { if cnum == LOCAL_CRATE { self.cdata().cnum } else { self.cdata().cnum_map[cnum] } } -} -impl<'a, 'tcx, T> SpecializedDecoder<Lazy<T, ()>> for DecodeContext<'a, 'tcx> { - fn specialized_decode(&mut self) -> Result<Lazy<T>, Self::Error> { - self.read_lazy_with_meta(()) + fn decode_alloc_id(&mut self) -> Result<rustc_middle::mir::interpret::AllocId, Self::Error> { + if let Some(alloc_decoding_session) = self.alloc_decoding_session { + alloc_decoding_session.decode_alloc_id(self) + } else { + bug!("Attempting to decode interpret::AllocId without CrateMetadata") + } } } -impl<'a, 'tcx, T> SpecializedDecoder<Lazy<[T], usize>> for DecodeContext<'a, 'tcx> { - fn specialized_decode(&mut self) -> Result<Lazy<[T]>, Self::Error> { - let len = self.read_usize()?; - if len == 0 { Ok(Lazy::empty()) } else { self.read_lazy_with_meta(len) } +impl<'a, 'tcx> Decodable<DecodeContext<'a, 'tcx>> for CrateNum { + fn decode(d: &mut DecodeContext<'a, 'tcx>) -> Result<CrateNum, String> { + let cnum = CrateNum::from_u32(d.read_u32()?); + Ok(d.map_encoded_cnum_to_current(cnum)) } } -impl<'a, 'tcx, I: Idx, T> SpecializedDecoder<Lazy<Table<I, T>, usize>> for DecodeContext<'a, 'tcx> -where - Option<T>: FixedSizeEncoding, -{ - fn specialized_decode(&mut self) -> Result<Lazy<Table<I, T>>, Self::Error> { - let len = self.read_usize()?; - self.read_lazy_with_meta(len) +impl<'a, 'tcx> Decodable<DecodeContext<'a, 'tcx>> for DefIndex { + fn decode(d: &mut DecodeContext<'a, 'tcx>) -> Result<DefIndex, String> { + Ok(DefIndex::from_u32(d.read_u32()?)) } } -impl<'a, 'tcx> SpecializedDecoder<DefId> for DecodeContext<'a, 'tcx> { - #[inline] - fn specialized_decode(&mut self) -> Result<DefId, Self::Error> { - let krate = CrateNum::decode(self)?; - let index = DefIndex::decode(self)?; - - Ok(DefId { krate, index }) +impl<'a, 'tcx> FingerprintDecoder for DecodeContext<'a, 'tcx> { + fn decode_fingerprint(&mut self) -> Result<Fingerprint, String> { + Fingerprint::decode_opaque(&mut self.opaque) } } -impl<'a, 'tcx> SpecializedDecoder<DefIndex> for DecodeContext<'a, 'tcx> { - #[inline] - fn specialized_decode(&mut self) -> Result<DefIndex, Self::Error> { - Ok(DefIndex::from_u32(self.read_u32()?)) +impl<'a, 'tcx> Decodable<DecodeContext<'a, 'tcx>> for SyntaxContext { + fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> Result<SyntaxContext, String> { + let cdata = decoder.cdata(); + let sess = decoder.sess.unwrap(); + let cname = cdata.root.name; + rustc_span::hygiene::decode_syntax_context(decoder, &cdata.hygiene_context, |_, id| { + debug!("SpecializedDecoder<SyntaxContext>: decoding {}", id); + Ok(cdata + .root + .syntax_contexts + .get(&cdata, id) + .unwrap_or_else(|| panic!("Missing SyntaxContext {:?} for crate {:?}", id, cname)) + .decode((&cdata, sess))) + }) } } -impl<'a, 'tcx> SpecializedDecoder<LocalDefId> for DecodeContext<'a, 'tcx> { - #[inline] - fn specialized_decode(&mut self) -> Result<LocalDefId, Self::Error> { - Ok(DefId::decode(self)?.expect_local()) - } -} +impl<'a, 'tcx> Decodable<DecodeContext<'a, 'tcx>> for ExpnId { + fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> Result<ExpnId, String> { + let local_cdata = decoder.cdata(); + let sess = decoder.sess.unwrap(); + let expn_cnum = Cell::new(None); + let get_ctxt = |cnum| { + expn_cnum.set(Some(cnum)); + if cnum == LOCAL_CRATE { + &local_cdata.hygiene_context + } else { + &local_cdata.cstore.get_crate_data(cnum).cdata.hygiene_context + } + }; -impl<'a, 'tcx> SpecializedDecoder<interpret::AllocId> for DecodeContext<'a, 'tcx> { - fn specialized_decode(&mut self) -> Result<interpret::AllocId, Self::Error> { - if let Some(alloc_decoding_session) = self.alloc_decoding_session { - alloc_decoding_session.decode_alloc_id(self) - } else { - bug!("Attempting to decode interpret::AllocId without CrateMetadata") - } + rustc_span::hygiene::decode_expn_id( + decoder, + ExpnDataDecodeMode::Metadata(get_ctxt), + |_this, index| { + let cnum = expn_cnum.get().unwrap(); + // Lookup local `ExpnData`s in our own crate data. Foreign `ExpnData`s + // are stored in the owning crate, to avoid duplication. + let crate_data = if cnum == LOCAL_CRATE { + local_cdata + } else { + local_cdata.cstore.get_crate_data(cnum) + }; + Ok(crate_data + .root + .expn_data + .get(&crate_data, index) + .unwrap() + .decode((&crate_data, sess))) + }, + ) } } -impl<'a, 'tcx> SpecializedDecoder<Span> for DecodeContext<'a, 'tcx> { - fn specialized_decode(&mut self) -> Result<Span, Self::Error> { - let tag = u8::decode(self)?; +impl<'a, 'tcx> Decodable<DecodeContext<'a, 'tcx>> for Span { + fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> Result<Span, String> { + let tag = u8::decode(decoder)?; if tag == TAG_INVALID_SPAN { return Ok(DUMMY_SP); @@ -420,12 +446,12 @@ impl<'a, 'tcx> SpecializedDecoder<Span> for DecodeContext<'a, 'tcx> { debug_assert!(tag == TAG_VALID_SPAN_LOCAL || tag == TAG_VALID_SPAN_FOREIGN); - let lo = BytePos::decode(self)?; - let len = BytePos::decode(self)?; - let ctxt = SyntaxContext::decode(self)?; + let lo = BytePos::decode(decoder)?; + let len = BytePos::decode(decoder)?; + let ctxt = SyntaxContext::decode(decoder)?; let hi = lo + len; - let sess = if let Some(sess) = self.sess { + let sess = if let Some(sess) = decoder.sess { sess } else { bug!("Cannot decode Span without Session.") @@ -460,22 +486,22 @@ impl<'a, 'tcx> SpecializedDecoder<Span> for DecodeContext<'a, 'tcx> { // we can call `imported_source_files` for the proper crate, and binary search // through the returned slice using our span. let imported_source_files = if tag == TAG_VALID_SPAN_LOCAL { - self.cdata().imported_source_files(sess) + decoder.cdata().imported_source_files(sess) } else { // When we encode a proc-macro crate, all `Span`s should be encoded // with `TAG_VALID_SPAN_LOCAL` - if self.cdata().root.is_proc_macro_crate() { + if decoder.cdata().root.is_proc_macro_crate() { // Decode `CrateNum` as u32 - using `CrateNum::decode` will ICE // since we don't have `cnum_map` populated. - let cnum = u32::decode(self)?; + let cnum = u32::decode(decoder)?; panic!( "Decoding of crate {:?} tried to access proc-macro dep {:?}", - self.cdata().root.name, + decoder.cdata().root.name, cnum ); } // tag is TAG_VALID_SPAN_FOREIGN, checked by `debug_assert` above - let cnum = CrateNum::decode(self)?; + let cnum = CrateNum::decode(decoder)?; debug!( "SpecializedDecoder<Span>::specialized_decode: loading source files from cnum {:?}", cnum @@ -485,16 +511,16 @@ impl<'a, 'tcx> SpecializedDecoder<Span> for DecodeContext<'a, 'tcx> { // not worth it to maintain a per-CrateNum cache for `last_source_file_index`. // We just set it to 0, to ensure that we don't try to access something out // of bounds for our initial 'guess' - self.last_source_file_index = 0; + decoder.last_source_file_index = 0; - let foreign_data = self.cdata().cstore.get_crate_data(cnum); + let foreign_data = decoder.cdata().cstore.get_crate_data(cnum); foreign_data.imported_source_files(sess) }; let source_file = { // Optimize for the case that most spans within a translated item // originate from the same source_file. - let last_source_file = &imported_source_files[self.last_source_file_index]; + let last_source_file = &imported_source_files[decoder.last_source_file_index]; if lo >= last_source_file.original_start_pos && lo <= last_source_file.original_end_pos { @@ -507,7 +533,7 @@ impl<'a, 'tcx> SpecializedDecoder<Span> for DecodeContext<'a, 'tcx> { // Don't try to cache the index for foreign spans, // as this would require a map from CrateNums to indices if tag == TAG_VALID_SPAN_LOCAL { - self.last_source_file_index = index; + decoder.last_source_file_index = index; } &imported_source_files[index] } @@ -540,19 +566,37 @@ impl<'a, 'tcx> SpecializedDecoder<Span> for DecodeContext<'a, 'tcx> { } } -impl<'a, 'tcx> SpecializedDecoder<Fingerprint> for DecodeContext<'a, 'tcx> { - fn specialized_decode(&mut self) -> Result<Fingerprint, Self::Error> { - Fingerprint::decode_opaque(&mut self.opaque) +impl<'a, 'tcx> Decodable<DecodeContext<'a, 'tcx>> for &'tcx [(ty::Predicate<'tcx>, Span)] { + fn decode(d: &mut DecodeContext<'a, 'tcx>) -> Result<Self, String> { + ty::codec::RefDecodable::decode(d) + } +} + +impl<'a, 'tcx, T: Decodable<DecodeContext<'a, 'tcx>>> Decodable<DecodeContext<'a, 'tcx>> + for Lazy<T> +{ + fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> Result<Self, String> { + decoder.read_lazy_with_meta(()) } } -impl<'a, 'tcx, T> SpecializedDecoder<mir::ClearCrossCrate<T>> for DecodeContext<'a, 'tcx> +impl<'a, 'tcx, T: Decodable<DecodeContext<'a, 'tcx>>> Decodable<DecodeContext<'a, 'tcx>> + for Lazy<[T]> +{ + fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> Result<Self, String> { + let len = decoder.read_usize()?; + if len == 0 { Ok(Lazy::empty()) } else { decoder.read_lazy_with_meta(len) } + } +} + +impl<'a, 'tcx, I: Idx, T: Decodable<DecodeContext<'a, 'tcx>>> Decodable<DecodeContext<'a, 'tcx>> + for Lazy<Table<I, T>> where - mir::ClearCrossCrate<T>: UseSpecializedDecodable, + Option<T>: FixedSizeEncoding, { - #[inline] - fn specialized_decode(&mut self) -> Result<mir::ClearCrossCrate<T>, Self::Error> { - Ok(mir::ClearCrossCrate::Clear) + fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> Result<Self, String> { + let len = decoder.read_usize()?; + decoder.read_lazy_with_meta(len) } } @@ -1840,57 +1884,3 @@ fn macro_kind(raw: &ProcMacro) -> MacroKind { ProcMacro::Bang { .. } => MacroKind::Bang, } } - -impl<'a, 'tcx> SpecializedDecoder<SyntaxContext> for DecodeContext<'a, 'tcx> { - fn specialized_decode(&mut self) -> Result<SyntaxContext, Self::Error> { - let cdata = self.cdata(); - let sess = self.sess.unwrap(); - let cname = cdata.root.name; - rustc_span::hygiene::decode_syntax_context(self, &cdata.hygiene_context, |_, id| { - debug!("SpecializedDecoder<SyntaxContext>: decoding {}", id); - Ok(cdata - .root - .syntax_contexts - .get(&cdata, id) - .unwrap_or_else(|| panic!("Missing SyntaxContext {:?} for crate {:?}", id, cname)) - .decode((&cdata, sess))) - }) - } -} - -impl<'a, 'tcx> SpecializedDecoder<ExpnId> for DecodeContext<'a, 'tcx> { - fn specialized_decode(&mut self) -> Result<ExpnId, Self::Error> { - let local_cdata = self.cdata(); - let sess = self.sess.unwrap(); - let expn_cnum = Cell::new(None); - let get_ctxt = |cnum| { - expn_cnum.set(Some(cnum)); - if cnum == LOCAL_CRATE { - &local_cdata.hygiene_context - } else { - &local_cdata.cstore.get_crate_data(cnum).cdata.hygiene_context - } - }; - - rustc_span::hygiene::decode_expn_id( - self, - ExpnDataDecodeMode::Metadata(get_ctxt), - |_this, index| { - let cnum = expn_cnum.get().unwrap(); - // Lookup local `ExpnData`s in our own crate data. Foreign `ExpnData`s - // are stored in the owning crate, to avoid duplication. - let crate_data = if cnum == LOCAL_CRATE { - local_cdata - } else { - local_cdata.cstore.get_crate_data(cnum) - }; - Ok(crate_data - .root - .expn_data - .get(&crate_data, index) - .unwrap() - .decode((&crate_data, sess))) - }, - ) - } -} diff --git a/src/librustc_metadata/rmeta/encoder.rs b/src/librustc_metadata/rmeta/encoder.rs index 6723e236a1f..0343fbeb0fa 100644 --- a/src/librustc_metadata/rmeta/encoder.rs +++ b/src/librustc_metadata/rmeta/encoder.rs @@ -1,9 +1,8 @@ use crate::rmeta::table::{FixedSizeEncoding, TableBuilder}; use crate::rmeta::*; -use log::{debug, trace}; use rustc_ast::ast; -use rustc_data_structures::fingerprint::Fingerprint; +use rustc_data_structures::fingerprint::{Fingerprint, FingerprintEncoder}; use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet}; use rustc_data_structures::stable_hasher::StableHasher; use rustc_data_structures::sync::{join, Lrc}; @@ -23,11 +22,11 @@ use rustc_middle::middle::dependency_format::Linkage; use rustc_middle::middle::exported_symbols::{ metadata_symbol_name, ExportedSymbol, SymbolExportLevel, }; -use rustc_middle::mir::{self, interpret}; +use rustc_middle::mir::interpret; use rustc_middle::traits::specialization_graph; -use rustc_middle::ty::codec::{self as ty_codec, TyEncoder}; +use rustc_middle::ty::codec::TyEncoder; use rustc_middle::ty::{self, SymbolName, Ty, TyCtxt}; -use rustc_serialize::{opaque, Encodable, Encoder, SpecializedEncoder, UseSpecializedEncodable}; +use rustc_serialize::{opaque, Encodable, Encoder}; use rustc_session::config::CrateType; use rustc_span::hygiene::{ExpnDataEncodeMode, HygieneEncodeContext}; use rustc_span::source_map::Spanned; @@ -37,8 +36,9 @@ use rustc_target::abi::VariantIdx; use std::hash::Hash; use std::num::NonZeroUsize; use std::path::Path; +use tracing::{debug, trace}; -struct EncodeContext<'a, 'tcx> { +pub(super) struct EncodeContext<'a, 'tcx> { opaque: opaque::Encoder, tcx: TyCtxt<'tcx>, @@ -107,100 +107,87 @@ impl<'a, 'tcx> Encoder for EncodeContext<'a, 'tcx> { } } -impl<'a, 'tcx, T> SpecializedEncoder<Lazy<T, ()>> for EncodeContext<'a, 'tcx> { - fn specialized_encode(&mut self, lazy: &Lazy<T>) -> Result<(), Self::Error> { - self.emit_lazy_distance(*lazy) +impl<'a, 'tcx, T: Encodable<EncodeContext<'a, 'tcx>>> Encodable<EncodeContext<'a, 'tcx>> + for Lazy<T> +{ + fn encode(&self, e: &mut EncodeContext<'a, 'tcx>) -> opaque::EncodeResult { + e.emit_lazy_distance(*self) } } -impl<'a, 'tcx, T> SpecializedEncoder<Lazy<[T], usize>> for EncodeContext<'a, 'tcx> { - fn specialized_encode(&mut self, lazy: &Lazy<[T]>) -> Result<(), Self::Error> { - self.emit_usize(lazy.meta)?; - if lazy.meta == 0 { +impl<'a, 'tcx, T: Encodable<EncodeContext<'a, 'tcx>>> Encodable<EncodeContext<'a, 'tcx>> + for Lazy<[T]> +{ + fn encode(&self, e: &mut EncodeContext<'a, 'tcx>) -> opaque::EncodeResult { + e.emit_usize(self.meta)?; + if self.meta == 0 { return Ok(()); } - self.emit_lazy_distance(*lazy) + e.emit_lazy_distance(*self) } } -impl<'a, 'tcx, I: Idx, T> SpecializedEncoder<Lazy<Table<I, T>, usize>> for EncodeContext<'a, 'tcx> +impl<'a, 'tcx, I: Idx, T: Encodable<EncodeContext<'a, 'tcx>>> Encodable<EncodeContext<'a, 'tcx>> + for Lazy<Table<I, T>> where Option<T>: FixedSizeEncoding, { - fn specialized_encode(&mut self, lazy: &Lazy<Table<I, T>>) -> Result<(), Self::Error> { - self.emit_usize(lazy.meta)?; - self.emit_lazy_distance(*lazy) - } -} - -impl<'a, 'tcx> SpecializedEncoder<CrateNum> for EncodeContext<'a, 'tcx> { - #[inline] - fn specialized_encode(&mut self, cnum: &CrateNum) -> Result<(), Self::Error> { - self.emit_u32(cnum.as_u32()) + fn encode(&self, e: &mut EncodeContext<'a, 'tcx>) -> opaque::EncodeResult { + e.emit_usize(self.meta)?; + e.emit_lazy_distance(*self) } } -impl<'a, 'tcx> SpecializedEncoder<DefId> for EncodeContext<'a, 'tcx> { - #[inline] - fn specialized_encode(&mut self, def_id: &DefId) -> Result<(), Self::Error> { - let DefId { krate, index } = *def_id; - - krate.encode(self)?; - index.encode(self) +impl<'a, 'tcx> Encodable<EncodeContext<'a, 'tcx>> for DefIndex { + fn encode(&self, s: &mut EncodeContext<'a, 'tcx>) -> opaque::EncodeResult { + s.emit_u32(self.as_u32()) } } -impl<'a, 'tcx> SpecializedEncoder<SyntaxContext> for EncodeContext<'a, 'tcx> { - fn specialized_encode(&mut self, ctxt: &SyntaxContext) -> Result<(), Self::Error> { - rustc_span::hygiene::raw_encode_syntax_context(*ctxt, &self.hygiene_ctxt, self) +impl<'a, 'tcx> Encodable<EncodeContext<'a, 'tcx>> for SyntaxContext { + fn encode(&self, s: &mut EncodeContext<'a, 'tcx>) -> opaque::EncodeResult { + rustc_span::hygiene::raw_encode_syntax_context(*self, &s.hygiene_ctxt, s) } } -impl<'a, 'tcx> SpecializedEncoder<ExpnId> for EncodeContext<'a, 'tcx> { - fn specialized_encode(&mut self, expn: &ExpnId) -> Result<(), Self::Error> { +impl<'a, 'tcx> Encodable<EncodeContext<'a, 'tcx>> for ExpnId { + fn encode(&self, s: &mut EncodeContext<'a, 'tcx>) -> opaque::EncodeResult { rustc_span::hygiene::raw_encode_expn_id( - *expn, - &self.hygiene_ctxt, + *self, + &s.hygiene_ctxt, ExpnDataEncodeMode::Metadata, - self, + s, ) } } -impl<'a, 'tcx> SpecializedEncoder<DefIndex> for EncodeContext<'a, 'tcx> { - #[inline] - fn specialized_encode(&mut self, def_index: &DefIndex) -> Result<(), Self::Error> { - self.emit_u32(def_index.as_u32()) - } -} - -impl<'a, 'tcx> SpecializedEncoder<Span> for EncodeContext<'a, 'tcx> { - fn specialized_encode(&mut self, span: &Span) -> Result<(), Self::Error> { - if span.is_dummy() { - return TAG_INVALID_SPAN.encode(self); +impl<'a, 'tcx> Encodable<EncodeContext<'a, 'tcx>> for Span { + fn encode(&self, s: &mut EncodeContext<'a, 'tcx>) -> opaque::EncodeResult { + if self.is_dummy() { + return TAG_INVALID_SPAN.encode(s); } - let span = span.data(); + let span = self.data(); // The Span infrastructure should make sure that this invariant holds: debug_assert!(span.lo <= span.hi); - if !self.source_file_cache.0.contains(span.lo) { - let source_map = self.tcx.sess.source_map(); + if !s.source_file_cache.0.contains(span.lo) { + let source_map = s.tcx.sess.source_map(); let source_file_index = source_map.lookup_source_file_idx(span.lo); - self.source_file_cache = + s.source_file_cache = (source_map.files()[source_file_index].clone(), source_file_index); } - if !self.source_file_cache.0.contains(span.hi) { + if !s.source_file_cache.0.contains(span.hi) { // Unfortunately, macro expansion still sometimes generates Spans // that malformed in this way. - return TAG_INVALID_SPAN.encode(self); + return TAG_INVALID_SPAN.encode(s); } - let source_files = self.required_source_files.as_mut().expect("Already encoded SourceMap!"); + let source_files = s.required_source_files.as_mut().expect("Already encoded SourceMap!"); // Record the fact that we need to encode the data for this `SourceFile` - source_files.insert(self.source_file_cache.1); + source_files.insert(s.source_file_cache.1); // There are two possible cases here: // 1. This span comes from a 'foreign' crate - e.g. some crate upstream of the @@ -218,7 +205,7 @@ impl<'a, 'tcx> SpecializedEncoder<Span> for EncodeContext<'a, 'tcx> { // if we're a proc-macro crate. // This allows us to avoid loading the dependencies of proc-macro crates: all of // the information we need to decode `Span`s is stored in the proc-macro crate. - let (tag, lo, hi) = if self.source_file_cache.0.is_imported() && !self.is_proc_macro { + let (tag, lo, hi) = if s.source_file_cache.0.is_imported() && !s.is_proc_macro { // To simplify deserialization, we 'rebase' this span onto the crate it originally came from // (the crate that 'owns' the file it references. These rebased 'lo' and 'hi' values // are relative to the source map information for the 'foreign' crate whose CrateNum @@ -230,26 +217,26 @@ impl<'a, 'tcx> SpecializedEncoder<Span> for EncodeContext<'a, 'tcx> { // Span that can be used without any additional trouble. let external_start_pos = { // Introduce a new scope so that we drop the 'lock()' temporary - match &*self.source_file_cache.0.external_src.lock() { + match &*s.source_file_cache.0.external_src.lock() { ExternalSource::Foreign { original_start_pos, .. } => *original_start_pos, src => panic!("Unexpected external source {:?}", src), } }; - let lo = (span.lo - self.source_file_cache.0.start_pos) + external_start_pos; - let hi = (span.hi - self.source_file_cache.0.start_pos) + external_start_pos; + let lo = (span.lo - s.source_file_cache.0.start_pos) + external_start_pos; + let hi = (span.hi - s.source_file_cache.0.start_pos) + external_start_pos; (TAG_VALID_SPAN_FOREIGN, lo, hi) } else { (TAG_VALID_SPAN_LOCAL, span.lo, span.hi) }; - tag.encode(self)?; - lo.encode(self)?; + tag.encode(s)?; + lo.encode(s)?; // Encode length which is usually less than span.hi and profits more // from the variable-length integer encoding that we use. let len = hi - lo; - len.encode(self)?; + len.encode(s)?; // Don't serialize any `SyntaxContext`s from a proc-macro crate, // since we don't load proc-macro dependencies during serialization. @@ -282,101 +269,85 @@ impl<'a, 'tcx> SpecializedEncoder<Span> for EncodeContext<'a, 'tcx> { // IMPORTANT: If this is ever changed, be sure to update // `rustc_span::hygiene::raw_encode_expn_id` to handle // encoding `ExpnData` for proc-macro crates. - if self.is_proc_macro { - SyntaxContext::root().encode(self)?; + if s.is_proc_macro { + SyntaxContext::root().encode(s)?; } else { - span.ctxt.encode(self)?; + span.ctxt.encode(s)?; } if tag == TAG_VALID_SPAN_FOREIGN { - // This needs to be two lines to avoid holding the `self.source_file_cache` - // while calling `cnum.encode(self)` - let cnum = self.source_file_cache.0.cnum; - cnum.encode(self)?; + // This needs to be two lines to avoid holding the `s.source_file_cache` + // while calling `cnum.encode(s)` + let cnum = s.source_file_cache.0.cnum; + cnum.encode(s)?; } Ok(()) } } -impl<'a, 'tcx> SpecializedEncoder<LocalDefId> for EncodeContext<'a, 'tcx> { - #[inline] - fn specialized_encode(&mut self, def_id: &LocalDefId) -> Result<(), Self::Error> { - self.specialized_encode(&def_id.to_def_id()) +impl<'a, 'tcx> FingerprintEncoder for EncodeContext<'a, 'tcx> { + fn encode_fingerprint(&mut self, f: &Fingerprint) -> Result<(), Self::Error> { + f.encode_opaque(&mut self.opaque) } } -impl<'a, 'b, 'c, 'tcx> SpecializedEncoder<&'a ty::TyS<'b>> for EncodeContext<'c, 'tcx> -where - &'a ty::TyS<'b>: UseSpecializedEncodable, -{ - fn specialized_encode(&mut self, ty: &&'a ty::TyS<'b>) -> Result<(), Self::Error> { - debug_assert!(self.tcx.lift(ty).is_some()); - let ty = unsafe { std::mem::transmute::<&&'a ty::TyS<'b>, &&'tcx ty::TyS<'tcx>>(ty) }; - ty_codec::encode_with_shorthand(self, ty, |ecx| &mut ecx.type_shorthands) +impl<'a, 'tcx> TyEncoder<'tcx> for EncodeContext<'a, 'tcx> { + const CLEAR_CROSS_CRATE: bool = true; + + fn position(&self) -> usize { + self.opaque.position() } -} -impl<'a, 'b, 'tcx> SpecializedEncoder<ty::Predicate<'b>> for EncodeContext<'a, 'tcx> { - fn specialized_encode(&mut self, predicate: &ty::Predicate<'b>) -> Result<(), Self::Error> { - debug_assert!(self.tcx.lift(predicate).is_some()); - let predicate = - unsafe { std::mem::transmute::<&ty::Predicate<'b>, &ty::Predicate<'tcx>>(predicate) }; - ty_codec::encode_with_shorthand(self, predicate, |encoder| { - &mut encoder.predicate_shorthands - }) + fn tcx(&self) -> TyCtxt<'tcx> { + self.tcx } -} -impl<'a, 'tcx> SpecializedEncoder<interpret::AllocId> for EncodeContext<'a, 'tcx> { - fn specialized_encode(&mut self, alloc_id: &interpret::AllocId) -> Result<(), Self::Error> { - let (index, _) = self.interpret_allocs.insert_full(*alloc_id); - index.encode(self) + fn type_shorthands(&mut self) -> &mut FxHashMap<Ty<'tcx>, usize> { + &mut self.type_shorthands } -} -impl<'a, 'tcx> SpecializedEncoder<Fingerprint> for EncodeContext<'a, 'tcx> { - fn specialized_encode(&mut self, f: &Fingerprint) -> Result<(), Self::Error> { - f.encode_opaque(&mut self.opaque) + fn predicate_shorthands(&mut self) -> &mut FxHashMap<rustc_middle::ty::Predicate<'tcx>, usize> { + &mut self.predicate_shorthands } -} -impl<'a, 'tcx, T> SpecializedEncoder<mir::ClearCrossCrate<T>> for EncodeContext<'a, 'tcx> -where - mir::ClearCrossCrate<T>: UseSpecializedEncodable, -{ - fn specialized_encode(&mut self, _: &mir::ClearCrossCrate<T>) -> Result<(), Self::Error> { - Ok(()) + fn encode_alloc_id( + &mut self, + alloc_id: &rustc_middle::mir::interpret::AllocId, + ) -> Result<(), Self::Error> { + let (index, _) = self.interpret_allocs.insert_full(*alloc_id); + + index.encode(self) } } -impl<'a, 'tcx> TyEncoder for EncodeContext<'a, 'tcx> { - fn position(&self) -> usize { - self.opaque.position() +impl<'a, 'tcx> Encodable<EncodeContext<'a, 'tcx>> for &'tcx [(ty::Predicate<'tcx>, Span)] { + fn encode(&self, s: &mut EncodeContext<'a, 'tcx>) -> opaque::EncodeResult { + (**self).encode(s) } } /// Helper trait to allow overloading `EncodeContext::lazy` for iterators. -trait EncodeContentsForLazy<T: ?Sized + LazyMeta> { +trait EncodeContentsForLazy<'a, 'tcx, T: ?Sized + LazyMeta> { fn encode_contents_for_lazy(self, ecx: &mut EncodeContext<'a, 'tcx>) -> T::Meta; } -impl<T: Encodable> EncodeContentsForLazy<T> for &T { +impl<'a, 'tcx, T: Encodable<EncodeContext<'a, 'tcx>>> EncodeContentsForLazy<'a, 'tcx, T> for &T { fn encode_contents_for_lazy(self, ecx: &mut EncodeContext<'a, 'tcx>) { self.encode(ecx).unwrap() } } -impl<T: Encodable> EncodeContentsForLazy<T> for T { +impl<'a, 'tcx, T: Encodable<EncodeContext<'a, 'tcx>>> EncodeContentsForLazy<'a, 'tcx, T> for T { fn encode_contents_for_lazy(self, ecx: &mut EncodeContext<'a, 'tcx>) { self.encode(ecx).unwrap() } } -impl<I, T: Encodable> EncodeContentsForLazy<[T]> for I +impl<'a, 'tcx, I, T: Encodable<EncodeContext<'a, 'tcx>>> EncodeContentsForLazy<'a, 'tcx, [T]> for I where I: IntoIterator, - I::Item: EncodeContentsForLazy<T>, + I::Item: EncodeContentsForLazy<'a, 'tcx, T>, { fn encode_contents_for_lazy(self, ecx: &mut EncodeContext<'a, 'tcx>) -> usize { self.into_iter().map(|value| value.encode_contents_for_lazy(ecx)).count() @@ -421,7 +392,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { self.emit_usize(distance) } - fn lazy<T: ?Sized + LazyMeta>(&mut self, value: impl EncodeContentsForLazy<T>) -> Lazy<T> { + fn lazy<T: ?Sized + LazyMeta>( + &mut self, + value: impl EncodeContentsForLazy<'a, 'tcx, T>, + ) -> Lazy<T> { let pos = NonZeroUsize::new(self.position()).unwrap(); assert_eq!(self.lazy_state, LazyState::NoNode); @@ -733,7 +707,7 @@ impl EncodeContext<'a, 'tcx> { is_non_exhaustive: variant.is_field_list_non_exhaustive(), }; - let enum_id = tcx.hir().as_local_hir_id(def.did.expect_local()); + let enum_id = tcx.hir().local_def_id_to_hir_id(def.did.expect_local()); let enum_vis = &tcx.hir().expect_item(enum_id).vis; record!(self.tables.kind[def_id] <- EntryKind::Variant(self.lazy(data))); @@ -780,7 +754,7 @@ impl EncodeContext<'a, 'tcx> { // Variant constructors have the same visibility as the parent enums, unless marked as // non-exhaustive, in which case they are lowered to `pub(crate)`. - let enum_id = tcx.hir().as_local_hir_id(def.did.expect_local()); + let enum_id = tcx.hir().local_def_id_to_hir_id(def.did.expect_local()); let enum_vis = &tcx.hir().expect_item(enum_id).vis; let mut ctor_vis = ty::Visibility::from_hir(enum_vis, enum_id, tcx); if variant.is_field_list_non_exhaustive() && ctor_vis == ty::Visibility::Public { @@ -819,11 +793,11 @@ impl EncodeContext<'a, 'tcx> { let data = ModData { reexports: match tcx.module_exports(local_def_id) { Some(exports) => { - let hir_map = self.tcx.hir(); + let hir = self.tcx.hir(); self.lazy( exports .iter() - .map(|export| export.map_id(|id| hir_map.as_local_hir_id(id))), + .map(|export| export.map_id(|id| hir.local_def_id_to_hir_id(id))), ) } _ => Lazy::empty(), @@ -855,7 +829,7 @@ impl EncodeContext<'a, 'tcx> { let def_id = field.did; debug!("EncodeContext::encode_field({:?})", def_id); - let variant_id = tcx.hir().as_local_hir_id(variant.def_id.expect_local()); + let variant_id = tcx.hir().local_def_id_to_hir_id(variant.def_id.expect_local()); let variant_data = tcx.hir().expect_variant_data(variant_id); record!(self.tables.kind[def_id] <- EntryKind::Field); @@ -883,7 +857,7 @@ impl EncodeContext<'a, 'tcx> { is_non_exhaustive: variant.is_field_list_non_exhaustive(), }; - let struct_id = tcx.hir().as_local_hir_id(adt_def.did.expect_local()); + let struct_id = tcx.hir().local_def_id_to_hir_id(adt_def.did.expect_local()); let struct_vis = &tcx.hir().expect_item(struct_id).vis; let mut ctor_vis = ty::Visibility::from_hir(struct_vis, struct_id, tcx); for field in &variant.fields { @@ -945,7 +919,7 @@ impl EncodeContext<'a, 'tcx> { debug!("EncodeContext::encode_info_for_trait_item({:?})", def_id); let tcx = self.tcx; - let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let ast_item = tcx.hir().expect_trait_item(hir_id); let trait_item = tcx.associated_item(def_id); @@ -1034,7 +1008,7 @@ impl EncodeContext<'a, 'tcx> { debug!("EncodeContext::encode_info_for_impl_item({:?})", def_id); let tcx = self.tcx; - let hir_id = self.tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let ast_item = self.tcx.hir().expect_impl_item(hir_id); let impl_item = self.tcx.associated_item(def_id); @@ -1438,7 +1412,7 @@ impl EncodeContext<'a, 'tcx> { // NOTE(eddyb) `tcx.type_of(def_id)` isn't used because it's fully generic, // including on the signature, which is inferred in `typeck. - let hir_id = self.tcx.hir().as_local_hir_id(def_id); + let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); let ty = self.tcx.typeck(def_id).node_type(hir_id); record!(self.tables.kind[def_id.to_def_id()] <- match ty.kind { @@ -1465,7 +1439,7 @@ impl EncodeContext<'a, 'tcx> { fn encode_info_for_anon_const(&mut self, def_id: LocalDefId) { debug!("EncodeContext::encode_info_for_anon_const({:?})", def_id); - let id = self.tcx.hir().as_local_hir_id(def_id); + let id = self.tcx.hir().local_def_id_to_hir_id(def_id); let body_id = self.tcx.hir().body_owned_by(id); let const_data = self.encode_rendered_const_for_body(body_id); let qualifs = self.tcx.mir_const_qualif(def_id); diff --git a/src/librustc_metadata/rmeta/mod.rs b/src/librustc_metadata/rmeta/mod.rs index 1c287be9f6b..b15c20e515f 100644 --- a/src/librustc_metadata/rmeta/mod.rs +++ b/src/librustc_metadata/rmeta/mod.rs @@ -26,8 +26,10 @@ use rustc_target::spec::{PanicStrategy, TargetTriple}; use std::marker::PhantomData; use std::num::NonZeroUsize; +use decoder::DecodeContext; pub use decoder::{provide, provide_extern}; crate use decoder::{CrateMetadata, CrateNumMap, MetadataBlob}; +use encoder::EncodeContext; use rustc_span::hygiene::SyntaxContextData; mod decoder; @@ -141,9 +143,6 @@ impl<T: ?Sized + LazyMeta> Clone for Lazy<T> { } } -impl<T: ?Sized + LazyMeta> rustc_serialize::UseSpecializedEncodable for Lazy<T> {} -impl<T: ?Sized + LazyMeta> rustc_serialize::UseSpecializedDecodable for Lazy<T> {} - /// Encoding / decoding state for `Lazy`. #[derive(Copy, Clone, PartialEq, Eq, Debug)] enum LazyState { @@ -172,7 +171,7 @@ macro_rules! Lazy { type SyntaxContextTable = Lazy<Table<u32, Lazy<SyntaxContextData>>>; type ExpnDataTable = Lazy<Table<u32, Lazy<ExpnData>>>; -#[derive(RustcEncodable, RustcDecodable)] +#[derive(MetadataEncodable, MetadataDecodable)] crate struct CrateRoot<'tcx> { name: Symbol, triple: TargetTriple, @@ -221,7 +220,7 @@ crate struct CrateRoot<'tcx> { symbol_mangling_version: SymbolManglingVersion, } -#[derive(RustcEncodable, RustcDecodable)] +#[derive(Encodable, Decodable)] crate struct CrateDep { pub name: Symbol, pub hash: Svh, @@ -230,7 +229,7 @@ crate struct CrateDep { pub extra_filename: String, } -#[derive(RustcEncodable, RustcDecodable)] +#[derive(MetadataEncodable, MetadataDecodable)] crate struct TraitImpls { trait_id: (u32, DefIndex), impls: Lazy<[(DefIndex, Option<ty::fast_reject::SimplifiedType>)]>, @@ -239,7 +238,7 @@ crate struct TraitImpls { /// Define `LazyTables` and `TableBuilders` at the same time. macro_rules! define_tables { ($($name:ident: Table<DefIndex, $T:ty>),+ $(,)?) => { - #[derive(RustcEncodable, RustcDecodable)] + #[derive(MetadataEncodable, MetadataDecodable)] crate struct LazyTables<'tcx> { $($name: Lazy!(Table<DefIndex, $T>)),+ } @@ -288,7 +287,7 @@ define_tables! { unused_generic_params: Table<DefIndex, Lazy<FiniteBitSet<u32>>>, } -#[derive(Copy, Clone, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, MetadataEncodable, MetadataDecodable)] enum EntryKind { AnonConst(mir::ConstQualifs, Lazy<RenderedConst>), Const(mir::ConstQualifs, Lazy<RenderedConst>), @@ -324,23 +323,23 @@ enum EntryKind { /// Contains a constant which has been rendered to a String. /// Used by rustdoc. -#[derive(RustcEncodable, RustcDecodable)] +#[derive(Encodable, Decodable)] struct RenderedConst(String); -#[derive(RustcEncodable, RustcDecodable)] +#[derive(MetadataEncodable, MetadataDecodable)] struct ModData { reexports: Lazy<[Export<hir::HirId>]>, expansion: ExpnId, } -#[derive(RustcEncodable, RustcDecodable)] +#[derive(MetadataEncodable, MetadataDecodable)] struct FnData { asyncness: hir::IsAsync, constness: hir::Constness, param_names: Lazy<[Ident]>, } -#[derive(RustcEncodable, RustcDecodable)] +#[derive(TyEncodable, TyDecodable)] struct VariantData { ctor_kind: CtorKind, discr: ty::VariantDiscr, @@ -349,7 +348,7 @@ struct VariantData { is_non_exhaustive: bool, } -#[derive(RustcEncodable, RustcDecodable)] +#[derive(TyEncodable, TyDecodable)] struct TraitData { unsafety: hir::Unsafety, paren_sugar: bool, @@ -358,7 +357,7 @@ struct TraitData { specialization_kind: ty::trait_def::TraitSpecializationKind, } -#[derive(RustcEncodable, RustcDecodable)] +#[derive(TyEncodable, TyDecodable)] struct ImplData { polarity: ty::ImplPolarity, defaultness: hir::Defaultness, @@ -372,7 +371,7 @@ struct ImplData { /// Describes whether the container of an associated item /// is a trait or an impl and whether, in a trait, it has /// a default, or an in impl, whether it's marked "default". -#[derive(Copy, Clone, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, TyEncodable, TyDecodable)] enum AssocContainer { TraitRequired, TraitWithDefault, @@ -404,14 +403,14 @@ impl AssocContainer { } } -#[derive(RustcEncodable, RustcDecodable)] +#[derive(MetadataEncodable, MetadataDecodable)] struct AssocFnData { fn_data: FnData, container: AssocContainer, has_self: bool, } -#[derive(RustcEncodable, RustcDecodable)] +#[derive(TyEncodable, TyDecodable)] struct GeneratorData<'tcx> { layout: mir::GeneratorLayout<'tcx>, } diff --git a/src/librustc_metadata/rmeta/table.rs b/src/librustc_metadata/rmeta/table.rs index e1d0a0dbf2f..28858e146e4 100644 --- a/src/librustc_metadata/rmeta/table.rs +++ b/src/librustc_metadata/rmeta/table.rs @@ -1,11 +1,11 @@ use crate::rmeta::*; -use log::debug; use rustc_index::vec::Idx; -use rustc_serialize::{opaque::Encoder, Encodable}; +use rustc_serialize::opaque::Encoder; use std::convert::TryInto; use std::marker::PhantomData; use std::num::NonZeroUsize; +use tracing::debug; /// Helper trait, for encoding to, and decoding from, a fixed number of bytes. /// Used mainly for Lazy positions and lengths. @@ -78,7 +78,7 @@ impl FixedSizeEncoding for u32 { // NOTE(eddyb) there could be an impl for `usize`, which would enable a more // generic `Lazy<T>` impl, but in the general case we might not need / want to // fit every `usize` in `u32`. -impl<T: Encodable> FixedSizeEncoding for Option<Lazy<T>> { +impl<T> FixedSizeEncoding for Option<Lazy<T>> { fixed_size_encoding_byte_len_and_defaults!(u32::BYTE_LEN); fn from_bytes(b: &[u8]) -> Self { @@ -93,7 +93,7 @@ impl<T: Encodable> FixedSizeEncoding for Option<Lazy<T>> { } } -impl<T: Encodable> FixedSizeEncoding for Option<Lazy<[T]>> { +impl<T> FixedSizeEncoding for Option<Lazy<[T]>> { fixed_size_encoding_byte_len_and_defaults!(u32::BYTE_LEN * 2); fn from_bytes(b: &[u8]) -> Self { diff --git a/src/librustc_middle/Cargo.toml b/src/librustc_middle/Cargo.toml index 03431cb5a88..311126361bc 100644 --- a/src/librustc_middle/Cargo.toml +++ b/src/librustc_middle/Cargo.toml @@ -12,7 +12,7 @@ doctest = false [dependencies] rustc_arena = { path = "../librustc_arena" } bitflags = "1.2.1" -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc-rayon-core = "0.3.0" polonius-engine = "0.12.0" rustc_apfloat = { path = "../librustc_apfloat" } diff --git a/src/librustc_middle/arena.rs b/src/librustc_middle/arena.rs index f2259e5e9f8..99889c74da0 100644 --- a/src/librustc_middle/arena.rs +++ b/src/librustc_middle/arena.rs @@ -11,13 +11,11 @@ macro_rules! arena_types { ($macro:path, $args:tt, $tcx:lifetime) => ( $macro!($args, [ - [] layouts: rustc_target::abi::Layout, rustc_target::abi::Layout; + [] layouts: rustc_target::abi::Layout, // AdtDef are interned and compared by address - [] adt_def: rustc_middle::ty::AdtDef, rustc_middle::ty::AdtDef; - [] steal_mir: - rustc_middle::ty::steal::Steal<rustc_middle::mir::Body<$tcx>>, - rustc_middle::ty::steal::Steal<rustc_middle::mir::Body<$tcx>>; - [decode] mir: rustc_middle::mir::Body<$tcx>, rustc_middle::mir::Body<'_x>; + [] adt_def: rustc_middle::ty::AdtDef, + [] steal_mir: rustc_middle::ty::steal::Steal<rustc_middle::mir::Body<$tcx>>, + [decode] mir: rustc_middle::mir::Body<$tcx>, [] steal_promoted: rustc_middle::ty::steal::Steal< rustc_index::vec::IndexVec< @@ -25,127 +23,86 @@ macro_rules! arena_types { rustc_middle::mir::Body<$tcx> > >, - rustc_middle::ty::steal::Steal< - rustc_index::vec::IndexVec< - rustc_middle::mir::Promoted, - rustc_middle::mir::Body<$tcx> - > - >; [decode] promoted: rustc_index::vec::IndexVec< rustc_middle::mir::Promoted, rustc_middle::mir::Body<$tcx> >, - rustc_index::vec::IndexVec< - rustc_middle::mir::Promoted, - rustc_middle::mir::Body<'_x> - >; - [decode] typeck_results: rustc_middle::ty::TypeckResults<$tcx>, rustc_middle::ty::TypeckResults<'_x>; + [decode] typeck_results: rustc_middle::ty::TypeckResults<$tcx>, [decode] borrowck_result: rustc_middle::mir::BorrowCheckResult<$tcx>, - rustc_middle::mir::BorrowCheckResult<'_x>; - [decode] unsafety_check_result: rustc_middle::mir::UnsafetyCheckResult, rustc_middle::mir::UnsafetyCheckResult; - [] const_allocs: rustc_middle::mir::interpret::Allocation, rustc_middle::mir::interpret::Allocation; + [decode] unsafety_check_result: rustc_middle::mir::UnsafetyCheckResult, + [] const_allocs: rustc_middle::mir::interpret::Allocation, // Required for the incremental on-disk cache - [few, decode] mir_keys: rustc_hir::def_id::DefIdSet, rustc_hir::def_id::DefIdSet; - [] region_scope_tree: rustc_middle::middle::region::ScopeTree, rustc_middle::middle::region::ScopeTree; + [few] mir_keys: rustc_hir::def_id::DefIdSet, + [] region_scope_tree: rustc_middle::middle::region::ScopeTree, [] dropck_outlives: rustc_middle::infer::canonical::Canonical<'tcx, rustc_middle::infer::canonical::QueryResponse<'tcx, rustc_middle::traits::query::DropckOutlivesResult<'tcx> > >, - rustc_middle::infer::canonical::Canonical<'_x, - rustc_middle::infer::canonical::QueryResponse<'_y, - rustc_middle::traits::query::DropckOutlivesResult<'_z> - > - >; [] normalize_projection_ty: rustc_middle::infer::canonical::Canonical<'tcx, rustc_middle::infer::canonical::QueryResponse<'tcx, rustc_middle::traits::query::NormalizationResult<'tcx> > >, - rustc_middle::infer::canonical::Canonical<'_x, - rustc_middle::infer::canonical::QueryResponse<'_y, - rustc_middle::traits::query::NormalizationResult<'_z> - > - >; [] implied_outlives_bounds: rustc_middle::infer::canonical::Canonical<'tcx, rustc_middle::infer::canonical::QueryResponse<'tcx, Vec<rustc_middle::traits::query::OutlivesBound<'tcx>> > >, - rustc_middle::infer::canonical::Canonical<'_x, - rustc_middle::infer::canonical::QueryResponse<'_y, - Vec<rustc_middle::traits::query::OutlivesBound<'_z>> - > - >; [] type_op_subtype: rustc_middle::infer::canonical::Canonical<'tcx, rustc_middle::infer::canonical::QueryResponse<'tcx, ()> >, - rustc_middle::infer::canonical::Canonical<'_x, - rustc_middle::infer::canonical::QueryResponse<'_y, ()> - >; [] type_op_normalize_poly_fn_sig: rustc_middle::infer::canonical::Canonical<'tcx, rustc_middle::infer::canonical::QueryResponse<'tcx, rustc_middle::ty::PolyFnSig<'tcx>> >, - rustc_middle::infer::canonical::Canonical<'_x, - rustc_middle::infer::canonical::QueryResponse<'_y, rustc_middle::ty::PolyFnSig<'_z>> - >; [] type_op_normalize_fn_sig: rustc_middle::infer::canonical::Canonical<'tcx, rustc_middle::infer::canonical::QueryResponse<'tcx, rustc_middle::ty::FnSig<'tcx>> >, - rustc_middle::infer::canonical::Canonical<'_x, - rustc_middle::infer::canonical::QueryResponse<'_y, rustc_middle::ty::FnSig<'_z>> - >; [] type_op_normalize_predicate: rustc_middle::infer::canonical::Canonical<'tcx, rustc_middle::infer::canonical::QueryResponse<'tcx, rustc_middle::ty::Predicate<'tcx>> >, - rustc_middle::infer::canonical::Canonical<'_x, - rustc_middle::infer::canonical::QueryResponse<'_y, rustc_middle::ty::Predicate<'_z>> - >; [] type_op_normalize_ty: rustc_middle::infer::canonical::Canonical<'tcx, rustc_middle::infer::canonical::QueryResponse<'tcx, rustc_middle::ty::Ty<'tcx>> >, - rustc_middle::infer::canonical::Canonical<'_x, - rustc_middle::infer::canonical::QueryResponse<'_y, &'_z rustc_middle::ty::TyS<'_w>> - >; - [few] all_traits: Vec<rustc_hir::def_id::DefId>, Vec<rustc_hir::def_id::DefId>; - [few] privacy_access_levels: rustc_middle::middle::privacy::AccessLevels, rustc_middle::middle::privacy::AccessLevels; - [few] foreign_module: rustc_middle::middle::cstore::ForeignModule, rustc_middle::middle::cstore::ForeignModule; - [few] foreign_modules: Vec<rustc_middle::middle::cstore::ForeignModule>, Vec<rustc_middle::middle::cstore::ForeignModule>; - [] upvars_mentioned: rustc_data_structures::fx::FxIndexMap<rustc_hir::HirId, rustc_hir::Upvar>, rustc_data_structures::fx::FxIndexMap<rustc_hir::HirId, rustc_hir::Upvar>; - [] object_safety_violations: rustc_middle::traits::ObjectSafetyViolation, rustc_middle::traits::ObjectSafetyViolation; - [] codegen_unit: rustc_middle::mir::mono::CodegenUnit<$tcx>, rustc_middle::mir::mono::CodegenUnit<'_x>; - [] attribute: rustc_ast::ast::Attribute, rustc_ast::ast::Attribute; - [] name_set: rustc_data_structures::fx::FxHashSet<rustc_span::symbol::Symbol>, rustc_data_structures::fx::FxHashSet<rustc_span::symbol::Symbol>; - [] hir_id_set: rustc_hir::HirIdSet, rustc_hir::HirIdSet; + [few] all_traits: Vec<rustc_hir::def_id::DefId>, + [few] privacy_access_levels: rustc_middle::middle::privacy::AccessLevels, + [few] foreign_module: rustc_middle::middle::cstore::ForeignModule, + [few] foreign_modules: Vec<rustc_middle::middle::cstore::ForeignModule>, + [] upvars_mentioned: rustc_data_structures::fx::FxIndexMap<rustc_hir::HirId, rustc_hir::Upvar>, + [] object_safety_violations: rustc_middle::traits::ObjectSafetyViolation, + [] codegen_unit: rustc_middle::mir::mono::CodegenUnit<$tcx>, + [] attribute: rustc_ast::ast::Attribute, + [] name_set: rustc_data_structures::fx::FxHashSet<rustc_span::symbol::Symbol>, + [] hir_id_set: rustc_hir::HirIdSet, // Interned types - [] tys: rustc_middle::ty::TyS<$tcx>, rustc_middle::ty::TyS<'_x>; - [] predicates: rustc_middle::ty::PredicateInner<$tcx>, rustc_middle::ty::PredicateInner<'_x>; + [] tys: rustc_middle::ty::TyS<$tcx>, + [] predicates: rustc_middle::ty::PredicateInner<$tcx>, // HIR query types - [few] indexed_hir: rustc_middle::hir::map::IndexedHir<$tcx>, rustc_middle::hir::map::IndexedHir<'_x>; - [few] hir_definitions: rustc_hir::definitions::Definitions, rustc_hir::definitions::Definitions; - [] hir_owner: rustc_middle::hir::Owner<$tcx>, rustc_middle::hir::Owner<'_x>; - [] hir_owner_nodes: rustc_middle::hir::OwnerNodes<$tcx>, rustc_middle::hir::OwnerNodes<'_x>; + [few] indexed_hir: rustc_middle::hir::map::IndexedHir<$tcx>, + [few] hir_definitions: rustc_hir::definitions::Definitions, + [] hir_owner: rustc_middle::hir::Owner<$tcx>, + [] hir_owner_nodes: rustc_middle::hir::OwnerNodes<$tcx>, // Note that this deliberately duplicates items in the `rustc_hir::arena`, // since we need to allocate this type on both the `rustc_hir` arena // (during lowering) and the `librustc_middle` arena (for decoding MIR) - [decode] asm_template: rustc_ast::ast::InlineAsmTemplatePiece, rustc_ast::ast::InlineAsmTemplatePiece; + [decode] asm_template: rustc_ast::ast::InlineAsmTemplatePiece, // This is used to decode the &'tcx [Span] for InlineAsm's line_spans. - [decode] span: rustc_span::Span, rustc_span::Span; - [decode] used_trait_imports: rustc_data_structures::fx::FxHashSet<rustc_hir::def_id::LocalDefId>, rustc_data_structures::fx::FxHashSet<rustc_hir::def_id::LocalDefId>; + [decode] span: rustc_span::Span, + [decode] used_trait_imports: rustc_data_structures::fx::FxHashSet<rustc_hir::def_id::LocalDefId>, ], $tcx); ) } diff --git a/src/librustc_middle/dep_graph/dep_node.rs b/src/librustc_middle/dep_graph/dep_node.rs index 98eed4045a3..a61b9af9bac 100644 --- a/src/librustc_middle/dep_graph/dep_node.rs +++ b/src/librustc_middle/dep_graph/dep_node.rs @@ -110,8 +110,7 @@ macro_rules! define_dep_nodes { $variant:ident $(( $tuple_arg_ty:ty $(,)? ))* ,)* ) => ( - #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, - RustcEncodable, RustcDecodable)] + #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Encodable, Decodable)] #[allow(non_camel_case_types)] pub enum DepKind { $($variant),* diff --git a/src/librustc_middle/dep_graph/mod.rs b/src/librustc_middle/dep_graph/mod.rs index 682b335c5d0..66975242798 100644 --- a/src/librustc_middle/dep_graph/mod.rs +++ b/src/librustc_middle/dep_graph/mod.rs @@ -185,6 +185,6 @@ impl<'tcx> DepContext for TyCtxt<'tcx> { } fn def_id_corresponds_to_hir_dep_node(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool { - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); def_id == hir_id.owner } diff --git a/src/librustc_middle/hir/exports.rs b/src/librustc_middle/hir/exports.rs index af48c9e94ff..be9e38aca65 100644 --- a/src/librustc_middle/hir/exports.rs +++ b/src/librustc_middle/hir/exports.rs @@ -13,7 +13,7 @@ use std::fmt::Debug; /// within. pub type ExportMap<Id> = FxHashMap<LocalDefId, Vec<Export<Id>>>; -#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable)] pub struct Export<Id> { /// The name of the target. pub ident: Ident, diff --git a/src/librustc_middle/hir/map/mod.rs b/src/librustc_middle/hir/map/mod.rs index 250f4d5187f..0794caca1ba 100644 --- a/src/librustc_middle/hir/map/mod.rs +++ b/src/librustc_middle/hir/map/mod.rs @@ -174,11 +174,6 @@ impl<'hir> Map<'hir> { } #[inline] - pub fn as_local_hir_id(&self, def_id: LocalDefId) -> HirId { - self.tcx.definitions.as_local_hir_id(def_id) - } - - #[inline] pub fn local_def_id_to_hir_id(&self, def_id: LocalDefId) -> HirId { self.tcx.definitions.local_def_id_to_hir_id(def_id) } @@ -450,7 +445,7 @@ impl<'hir> Map<'hir> { } pub fn get_module(&self, module: LocalDefId) -> (&'hir Mod<'hir>, Span, HirId) { - let hir_id = self.as_local_hir_id(module); + let hir_id = self.local_def_id_to_hir_id(module); match self.get_entry(hir_id).node { Node::Item(&Item { span, kind: ItemKind::Mod(ref m), .. }) => (m, span, hir_id), Node::Crate(item) => (&item.module, item.span, hir_id), @@ -483,7 +478,7 @@ impl<'hir> Map<'hir> { } pub fn get_if_local(&self, id: DefId) -> Option<Node<'hir>> { - id.as_local().map(|id| self.get(self.as_local_hir_id(id))) + id.as_local().map(|id| self.get(self.local_def_id_to_hir_id(id))) } pub fn get_generics(&self, id: DefId) -> Option<&'hir Generics<'hir>> { @@ -872,7 +867,7 @@ impl<'hir> Map<'hir> { } pub fn span_if_local(&self, id: DefId) -> Option<Span> { - id.as_local().map(|id| self.span(self.as_local_hir_id(id))) + id.as_local().map(|id| self.span(self.local_def_id_to_hir_id(id))) } pub fn res_span(&self, res: Res) -> Option<Span> { diff --git a/src/librustc_middle/hir/mod.rs b/src/librustc_middle/hir/mod.rs index b014f3c8eb7..ae3b30217cc 100644 --- a/src/librustc_middle/hir/mod.rs +++ b/src/librustc_middle/hir/mod.rs @@ -66,20 +66,20 @@ impl<'tcx> TyCtxt<'tcx> { pub fn provide(providers: &mut Providers) { providers.parent_module_from_def_id = |tcx, id| { let hir = tcx.hir(); - hir.local_def_id(hir.get_module_parent_node(hir.as_local_hir_id(id))) + hir.local_def_id(hir.get_module_parent_node(hir.local_def_id_to_hir_id(id))) }; providers.hir_crate = |tcx, _| tcx.untracked_crate; providers.index_hir = map::index_hir; providers.hir_module_items = |tcx, id| { let hir = tcx.hir(); - let module = hir.as_local_hir_id(id); + let module = hir.local_def_id_to_hir_id(id); &tcx.untracked_crate.modules[&module] }; providers.hir_owner = |tcx, id| tcx.index_hir(LOCAL_CRATE).map[id].signature; providers.hir_owner_nodes = |tcx, id| tcx.index_hir(LOCAL_CRATE).map[id].with_bodies.as_deref(); providers.fn_arg_names = |tcx, id| { let hir = tcx.hir(); - let hir_id = hir.as_local_hir_id(id.expect_local()); + let hir_id = hir.local_def_id_to_hir_id(id.expect_local()); if let Some(body_id) = hir.maybe_body_owned_by(hir_id) { tcx.arena.alloc_from_iter(hir.body_param_names(body_id)) } else if let Node::TraitItem(&TraitItem { diff --git a/src/librustc_middle/hir/place.rs b/src/librustc_middle/hir/place.rs index d85165bcccf..bcb56fae170 100644 --- a/src/librustc_middle/hir/place.rs +++ b/src/librustc_middle/hir/place.rs @@ -4,7 +4,7 @@ use crate::ty::Ty; use rustc_hir::HirId; use rustc_target::abi::VariantIdx; -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable, HashStable)] pub enum PlaceBase { /// A temporary variable Rvalue, @@ -16,7 +16,7 @@ pub enum PlaceBase { Upvar(ty::UpvarId), } -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable, HashStable)] pub enum ProjectionKind { /// A dereference of a pointer, reference or `Box<T>` of the given type Deref, @@ -36,7 +36,7 @@ pub enum ProjectionKind { Subslice, } -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable, HashStable)] pub struct Projection<'tcx> { /// Type after the projection is being applied. pub ty: Ty<'tcx>, @@ -48,7 +48,7 @@ pub struct Projection<'tcx> { /// A `Place` represents how a value is located in memory. /// /// This is an HIR version of `mir::Place` -#[derive(Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable, HashStable)] pub struct Place<'tcx> { /// The type of the `PlaceBase` pub base_ty: Ty<'tcx>, @@ -61,7 +61,7 @@ pub struct Place<'tcx> { /// A `PlaceWithHirId` represents how a value is located in memory. /// /// This is an HIR version of `mir::Place` -#[derive(Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable, HashStable)] pub struct PlaceWithHirId<'tcx> { /// `HirId` of the expression or pattern producing this value. pub hir_id: HirId, diff --git a/src/librustc_middle/infer/canonical.rs b/src/librustc_middle/infer/canonical.rs index 9433d282ad2..1e15ae49a0c 100644 --- a/src/librustc_middle/infer/canonical.rs +++ b/src/librustc_middle/infer/canonical.rs @@ -26,14 +26,13 @@ use crate::ty::subst::GenericArg; use crate::ty::{self, BoundVar, List, Region, TyCtxt}; use rustc_index::vec::IndexVec; use rustc_macros::HashStable; -use rustc_serialize::UseSpecializedDecodable; use smallvec::SmallVec; use std::ops::Index; /// A "canonicalized" type `V` is one where all free inference /// variables have been rewritten to "canonical vars". These are /// numbered starting from 0 in order of first appearance. -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcDecodable, RustcEncodable)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TyDecodable, TyEncodable)] #[derive(HashStable, TypeFoldable, Lift)] pub struct Canonical<'tcx, V> { pub max_universe: ty::UniverseIndex, @@ -43,8 +42,6 @@ pub struct Canonical<'tcx, V> { pub type CanonicalVarInfos<'tcx> = &'tcx List<CanonicalVarInfo>; -impl<'tcx> UseSpecializedDecodable for CanonicalVarInfos<'tcx> {} - /// A set of values corresponding to the canonical variables from some /// `Canonical`. You can give these values to /// `canonical_value.substitute` to substitute them into the canonical @@ -54,7 +51,7 @@ impl<'tcx> UseSpecializedDecodable for CanonicalVarInfos<'tcx> {} /// vectors with the original values that were replaced by canonical /// variables. You will need to supply it later to instantiate the /// canonicalized query response. -#[derive(Clone, Debug, PartialEq, Eq, Hash, RustcDecodable, RustcEncodable)] +#[derive(Clone, Debug, PartialEq, Eq, Hash, TyDecodable, TyEncodable)] #[derive(HashStable, TypeFoldable, Lift)] pub struct CanonicalVarValues<'tcx> { pub var_values: IndexVec<BoundVar, GenericArg<'tcx>>, @@ -90,7 +87,7 @@ impl Default for OriginalQueryValues<'tcx> { /// canonical value. This is sufficient information for code to create /// a copy of the canonical value in some other inference context, /// with fresh inference variables replacing the canonical values. -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcDecodable, RustcEncodable, HashStable)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TyDecodable, TyEncodable, HashStable)] pub struct CanonicalVarInfo { pub kind: CanonicalVarKind, } @@ -115,7 +112,7 @@ impl CanonicalVarInfo { /// Describes the "kind" of the canonical variable. This is a "kind" /// in the type-theory sense of the term -- i.e., a "meta" type system /// that analyzes type-like values. -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcDecodable, RustcEncodable, HashStable)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TyDecodable, TyEncodable, HashStable)] pub enum CanonicalVarKind { /// Some kind of type inference variable. Ty(CanonicalTyVarKind), @@ -160,7 +157,7 @@ impl CanonicalVarKind { /// 22.) can only be instantiated with integral/float types (e.g., /// usize or f32). In order to faithfully reproduce a type, we need to /// know what set of types a given type variable can be unified with. -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcDecodable, RustcEncodable, HashStable)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TyDecodable, TyEncodable, HashStable)] pub enum CanonicalTyVarKind { /// General type variable `?T` that can be unified with arbitrary types. General(ty::UniverseIndex), diff --git a/src/librustc_middle/lib.rs b/src/librustc_middle/lib.rs index 4c06472ceb8..ec1dcd29ef2 100644 --- a/src/librustc_middle/lib.rs +++ b/src/librustc_middle/lib.rs @@ -60,7 +60,7 @@ extern crate rustc_macros; #[macro_use] extern crate rustc_data_structures; #[macro_use] -extern crate log; +extern crate tracing; #[macro_use] extern crate smallvec; diff --git a/src/librustc_middle/middle/codegen_fn_attrs.rs b/src/librustc_middle/middle/codegen_fn_attrs.rs index d2749f8529b..62a6198b9b4 100644 --- a/src/librustc_middle/middle/codegen_fn_attrs.rs +++ b/src/librustc_middle/middle/codegen_fn_attrs.rs @@ -3,7 +3,7 @@ use rustc_attr::{InlineAttr, OptimizeAttr}; use rustc_session::config::SanitizerSet; use rustc_span::symbol::Symbol; -#[derive(Clone, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, TyEncodable, TyDecodable, HashStable)] pub struct CodegenFnAttrs { pub flags: CodegenFnAttrFlags, /// Parsed representation of the `#[inline]` attribute @@ -37,7 +37,7 @@ pub struct CodegenFnAttrs { } bitflags! { - #[derive(RustcEncodable, RustcDecodable, HashStable)] + #[derive(TyEncodable, TyDecodable, HashStable)] pub struct CodegenFnAttrFlags: u32 { /// `#[cold]`: a hint to LLVM that this function, when called, is never on /// the hot path. diff --git a/src/librustc_middle/middle/cstore.rs b/src/librustc_middle/middle/cstore.rs index 0a34c06adf0..6a8f6c3e202 100644 --- a/src/librustc_middle/middle/cstore.rs +++ b/src/librustc_middle/middle/cstore.rs @@ -25,7 +25,7 @@ use std::path::{Path, PathBuf}; /// Where a crate came from on the local filesystem. One of these three options /// must be non-None. -#[derive(PartialEq, Clone, Debug, HashStable, RustcEncodable, RustcDecodable)] +#[derive(PartialEq, Clone, Debug, HashStable, Encodable, Decodable)] pub struct CrateSource { pub dylib: Option<(PathBuf, PathKind)>, pub rlib: Option<(PathBuf, PathKind)>, @@ -38,7 +38,7 @@ impl CrateSource { } } -#[derive(RustcEncodable, RustcDecodable, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)] +#[derive(Encodable, Decodable, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)] #[derive(HashStable)] pub enum CrateDepKind { /// A dependency that is only used for its macros. @@ -60,7 +60,7 @@ impl CrateDepKind { } } -#[derive(PartialEq, Clone, Debug, RustcEncodable, RustcDecodable)] +#[derive(PartialEq, Clone, Debug, Encodable, Decodable)] pub enum LibSource { Some(PathBuf), MetadataOnly, @@ -80,13 +80,13 @@ impl LibSource { } } -#[derive(Copy, Debug, PartialEq, Clone, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Debug, PartialEq, Clone, Encodable, Decodable, HashStable)] pub enum LinkagePreference { RequireDynamic, RequireStatic, } -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Debug, Encodable, Decodable, HashStable)] pub struct NativeLib { pub kind: NativeLibKind, pub name: Option<Symbol>, @@ -95,7 +95,7 @@ pub struct NativeLib { pub wasm_import_module: Option<Symbol>, } -#[derive(Clone, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, TyEncodable, TyDecodable, HashStable)] pub struct ForeignModule { pub foreign_items: Vec<DefId>, pub def_id: DefId, @@ -145,7 +145,7 @@ pub enum ExternCrateSource { Path, } -#[derive(RustcEncodable, RustcDecodable)] +#[derive(Encodable, Decodable)] pub struct EncodedMetadata { pub raw_data: Vec<u8>, } diff --git a/src/librustc_middle/middle/dependency_format.rs b/src/librustc_middle/middle/dependency_format.rs index 16ce315368a..e079843bfbc 100644 --- a/src/librustc_middle/middle/dependency_format.rs +++ b/src/librustc_middle/middle/dependency_format.rs @@ -19,7 +19,7 @@ pub type DependencyList = Vec<Linkage>; /// This is local to the tcx, and is generally relevant to one session. pub type Dependencies = Vec<(CrateType, DependencyList)>; -#[derive(Copy, Clone, PartialEq, Debug, HashStable, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Debug, HashStable, Encodable, Decodable)] pub enum Linkage { NotLinked, IncludedFromDylib, diff --git a/src/librustc_middle/middle/exported_symbols.rs b/src/librustc_middle/middle/exported_symbols.rs index 569af70c5b5..276e45ce99b 100644 --- a/src/librustc_middle/middle/exported_symbols.rs +++ b/src/librustc_middle/middle/exported_symbols.rs @@ -8,7 +8,7 @@ use rustc_macros::HashStable; /// kind of crate, including cdylibs which export very few things. /// `Rust` will only be exported if the crate produced is a Rust /// dylib. -#[derive(Eq, PartialEq, Debug, Copy, Clone, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Eq, PartialEq, Debug, Copy, Clone, TyEncodable, TyDecodable, HashStable)] pub enum SymbolExportLevel { C, Rust, @@ -21,7 +21,7 @@ impl SymbolExportLevel { } } -#[derive(Eq, PartialEq, Debug, Copy, Clone, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Eq, PartialEq, Debug, Copy, Clone, TyEncodable, TyDecodable, HashStable)] pub enum ExportedSymbol<'tcx> { NonGeneric(DefId), Generic(DefId, SubstsRef<'tcx>), diff --git a/src/librustc_middle/middle/region.rs b/src/librustc_middle/middle/region.rs index 943a065a8b5..4c6ac820604 100644 --- a/src/librustc_middle/middle/region.rs +++ b/src/librustc_middle/middle/region.rs @@ -80,7 +80,7 @@ use std::fmt; // placate the same deriving in `ty::FreeRegion`, but we may want to // actually attach a more meaningful ordering to scopes than the one // generated via deriving here. -#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Copy, RustcEncodable, RustcDecodable)] +#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Copy, TyEncodable, TyDecodable)] #[derive(HashStable)] pub struct Scope { pub id: hir::ItemLocalId, @@ -104,7 +104,7 @@ impl fmt::Debug for Scope { } } -#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Debug, Copy, RustcEncodable, RustcDecodable)] +#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Debug, Copy, TyEncodable, TyDecodable)] #[derive(HashStable)] pub enum ScopeData { Node, @@ -324,7 +324,7 @@ pub struct ScopeTree { pub body_expr_count: FxHashMap<hir::BodyId, usize>, } -#[derive(Debug, Copy, Clone, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Debug, Copy, Clone, TyEncodable, TyDecodable, HashStable)] pub struct YieldData { /// The `Span` of the yield. pub span: Span, diff --git a/src/librustc_middle/middle/resolve_lifetime.rs b/src/librustc_middle/middle/resolve_lifetime.rs index c21ba1b3bd2..3d0144e9c8a 100644 --- a/src/librustc_middle/middle/resolve_lifetime.rs +++ b/src/librustc_middle/middle/resolve_lifetime.rs @@ -11,7 +11,7 @@ use rustc_macros::HashStable; /// The origin of a named lifetime definition. /// /// This is used to prevent the usage of in-band lifetimes in `Fn`/`fn` syntax. -#[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug, HashStable)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable, Debug, HashStable)] pub enum LifetimeDefOrigin { // Explicit binders like `fn foo<'a>(x: &'a u8)` or elided like `impl Foo<&u32>` ExplicitOrElided, @@ -35,7 +35,7 @@ impl LifetimeDefOrigin { } } -#[derive(Clone, Copy, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug, HashStable)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable, Debug, HashStable)] pub enum Region { Static, EarlyBound(/* index */ u32, /* lifetime decl */ DefId, LifetimeDefOrigin), @@ -47,7 +47,7 @@ pub enum Region { /// A set containing, at most, one known element. /// If two distinct values are inserted into a set, then it /// becomes `Many`, which can be used to detect ambiguities. -#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Debug, HashStable)] +#[derive(Copy, Clone, PartialEq, Eq, TyEncodable, TyDecodable, Debug, HashStable)] pub enum Set1<T> { Empty, One(T), diff --git a/src/librustc_middle/mir/interpret/allocation.rs b/src/librustc_middle/mir/interpret/allocation.rs index b23deb2e3bc..bee8d13c762 100644 --- a/src/librustc_middle/mir/interpret/allocation.rs +++ b/src/librustc_middle/mir/interpret/allocation.rs @@ -14,7 +14,7 @@ use super::{ UninitBytesAccess, }; -#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)] #[derive(HashStable)] pub struct Allocation<Tag = (), Extra = ()> { /// The actual bytes of the allocation. @@ -172,8 +172,6 @@ impl<Tag, Extra> Allocation<Tag, Extra> { } } -impl<'tcx> rustc_serialize::UseSpecializedDecodable for &'tcx Allocation {} - /// Byte accessors. impl<'tcx, Tag: Copy, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra> { /// Just a small local helper function to avoid a bit of code repetition. @@ -666,7 +664,7 @@ impl<Tag, Extra> Allocation<Tag, Extra> { } /// Relocations. -#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)] pub struct Relocations<Tag = (), Id = AllocId>(SortedMap<Size, (Tag, Id)>); impl<Tag, Id> Relocations<Tag, Id> { @@ -747,7 +745,7 @@ type Block = u64; /// A bitmask where each bit refers to the byte with the same index. If the bit is `true`, the byte /// is initialized. If it is `false` the byte is uninitialized. -#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)] #[derive(HashStable)] pub struct InitMask { blocks: Vec<Block>, diff --git a/src/librustc_middle/mir/interpret/error.rs b/src/librustc_middle/mir/interpret/error.rs index 5be09c0e9bc..059925088ce 100644 --- a/src/librustc_middle/mir/interpret/error.rs +++ b/src/librustc_middle/mir/interpret/error.rs @@ -11,7 +11,7 @@ use rustc_span::def_id::DefId; use rustc_target::abi::{Align, Size}; use std::{any::Any, backtrace::Backtrace, fmt, mem}; -#[derive(Debug, Copy, Clone, PartialEq, Eq, HashStable, RustcEncodable, RustcDecodable)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)] pub enum ErrorHandled { /// Already reported an error for this evaluation, and the compilation is /// *guaranteed* to fail. Warnings/lints *must not* produce `Reported`. @@ -137,7 +137,7 @@ impl fmt::Display for InvalidProgramInfo<'_> { } /// Details of why a pointer had to be in-bounds. -#[derive(Debug, Copy, Clone, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Debug, Copy, Clone, TyEncodable, TyDecodable, HashStable)] pub enum CheckInAllocMsg { MemoryAccessTest, NullPointerTest, diff --git a/src/librustc_middle/mir/interpret/mod.rs b/src/librustc_middle/mir/interpret/mod.rs index 2507f2184ff..e607da29ce4 100644 --- a/src/librustc_middle/mir/interpret/mod.rs +++ b/src/librustc_middle/mir/interpret/mod.rs @@ -108,11 +108,11 @@ use rustc_data_structures::sync::{HashMapExt, Lock}; use rustc_data_structures::tiny_list::TinyList; use rustc_hir::def_id::DefId; use rustc_macros::HashStable; -use rustc_serialize::{Decodable, Encodable, Encoder}; +use rustc_serialize::{Decodable, Encodable}; use rustc_target::abi::{Endian, Size}; use crate::mir; -use crate::ty::codec::TyDecoder; +use crate::ty::codec::{TyDecoder, TyEncoder}; use crate::ty::subst::GenericArgKind; use crate::ty::{self, Instance, Ty, TyCtxt}; @@ -132,7 +132,7 @@ pub use self::pointer::{Pointer, PointerArithmetic}; /// - A constant /// - A static /// - A const fn where all arguments (if any) are zero-sized types -#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, TyEncodable, TyDecodable)] #[derive(HashStable, Lift)] pub struct GlobalId<'tcx> { /// For a constant or static, the `Instance` of the item itself. @@ -182,17 +182,14 @@ impl fmt::Display for AllocId { } } -impl rustc_serialize::UseSpecializedEncodable for AllocId {} -impl rustc_serialize::UseSpecializedDecodable for AllocId {} - -#[derive(RustcDecodable, RustcEncodable)] +#[derive(TyDecodable, TyEncodable)] enum AllocDiscriminant { Alloc, Fn, Static, } -pub fn specialized_encode_alloc_id<'tcx, E: Encoder>( +pub fn specialized_encode_alloc_id<'tcx, E: TyEncoder<'tcx>>( encoder: &mut E, tcx: TyCtxt<'tcx>, alloc_id: AllocId, @@ -333,7 +330,7 @@ impl<'s> AllocDecodingSession<'s> { let alloc_id = decoder.with_position(pos, |decoder| { match alloc_kind { AllocDiscriminant::Alloc => { - let alloc = <&'tcx Allocation as Decodable>::decode(decoder)?; + let alloc = <&'tcx Allocation as Decodable<_>>::decode(decoder)?; // We already have a reserved `AllocId`. let alloc_id = alloc_id.unwrap(); trace!("decoded alloc {:?}: {:#?}", alloc_id, alloc); @@ -351,7 +348,7 @@ impl<'s> AllocDecodingSession<'s> { AllocDiscriminant::Static => { assert!(alloc_id.is_none()); trace!("creating extern static alloc ID"); - let did = DefId::decode(decoder)?; + let did = <DefId as Decodable<D>>::decode(decoder)?; trace!("decoded static def-ID: {:?}", did); let alloc_id = decoder.tcx().create_static_alloc(did); Ok(alloc_id) @@ -369,7 +366,7 @@ impl<'s> AllocDecodingSession<'s> { /// An allocation in the global (tcx-managed) memory can be either a function pointer, /// a static, or a "real" allocation with some data in it. -#[derive(Debug, Clone, Eq, PartialEq, Hash, RustcDecodable, RustcEncodable, HashStable)] +#[derive(Debug, Clone, Eq, PartialEq, Hash, TyDecodable, TyEncodable, HashStable)] pub enum GlobalAlloc<'tcx> { /// The alloc ID is used as a function pointer. Function(Instance<'tcx>), diff --git a/src/librustc_middle/mir/interpret/pointer.rs b/src/librustc_middle/mir/interpret/pointer.rs index ccad4f0a135..e3d5a085613 100644 --- a/src/librustc_middle/mir/interpret/pointer.rs +++ b/src/librustc_middle/mir/interpret/pointer.rs @@ -87,7 +87,7 @@ impl<T: HasDataLayout> PointerArithmetic for T {} /// /// `Pointer` is generic over the `Tag` associated with each pointer, /// which is used to do provenance tracking during execution. -#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, RustcEncodable, RustcDecodable, Hash)] +#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, TyEncodable, TyDecodable, Hash)] #[derive(HashStable)] pub struct Pointer<Tag = ()> { pub alloc_id: AllocId, diff --git a/src/librustc_middle/mir/interpret/value.rs b/src/librustc_middle/mir/interpret/value.rs index 50c76e29663..4c47f25105d 100644 --- a/src/librustc_middle/mir/interpret/value.rs +++ b/src/librustc_middle/mir/interpret/value.rs @@ -23,7 +23,7 @@ pub struct RawConst<'tcx> { /// Represents a constant value in Rust. `Scalar` and `Slice` are optimizations for /// array length computations, enum discriminants and the pattern matching logic. -#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Hash)] +#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, TyEncodable, TyDecodable, Hash)] #[derive(HashStable)] pub enum ConstValue<'tcx> { /// Used only for types with `layout::abi::Scalar` ABI and ZSTs. @@ -108,7 +108,7 @@ impl<'tcx> ConstValue<'tcx> { /// `memory::Allocation`. It is in many ways like a small chunk of a `Allocation`, up to 8 bytes in /// size. Like a range of bytes in an `Allocation`, a `Scalar` can either represent the raw bytes /// of a simple value or a pointer into another `Allocation` -#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, RustcEncodable, RustcDecodable, Hash)] +#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, TyEncodable, TyDecodable, Hash)] #[derive(HashStable)] pub enum Scalar<Tag = ()> { /// The raw bytes of a simple value. @@ -562,7 +562,7 @@ impl<Tag> From<Pointer<Tag>> for Scalar<Tag> { } } -#[derive(Clone, Copy, Eq, PartialEq, RustcEncodable, RustcDecodable, HashStable, Hash)] +#[derive(Clone, Copy, Eq, PartialEq, TyEncodable, TyDecodable, HashStable, Hash)] pub enum ScalarMaybeUninit<Tag = ()> { Scalar(Scalar<Tag>), Uninit, diff --git a/src/librustc_middle/mir/mod.rs b/src/librustc_middle/mir/mod.rs index 3b0c480f6d4..6a2b1d11584 100644 --- a/src/librustc_middle/mir/mod.rs +++ b/src/librustc_middle/mir/mod.rs @@ -5,6 +5,7 @@ use crate::mir::interpret::{Allocation, ConstValue, GlobalAlloc, Scalar}; use crate::mir::visit::MirVisitable; use crate::ty::adjustment::PointerCast; +use crate::ty::codec::{TyDecoder, TyEncoder}; use crate::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor}; use crate::ty::print::{FmtPrinter, Printer}; use crate::ty::subst::{Subst, SubstsRef}; @@ -73,7 +74,7 @@ impl<'tcx> HasLocalDecls<'tcx> for Body<'tcx> { /// The various "big phases" that MIR goes through. /// /// Warning: ordering of variants is significant. -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, PartialEq, Eq, PartialOrd, Ord)] +#[derive(Copy, Clone, TyEncodable, TyDecodable, Debug, PartialEq, Eq, PartialOrd, Ord)] #[derive(HashStable)] pub enum MirPhase { Build = 0, @@ -91,7 +92,7 @@ impl MirPhase { } /// The lowered representation of a single function. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable, TypeFoldable)] +#[derive(Clone, TyEncodable, TyDecodable, Debug, HashStable, TypeFoldable)] pub struct Body<'tcx> { /// A list of basic blocks. References to basic block use a newtyped index type `BasicBlock` /// that indexes into this vector. @@ -413,7 +414,7 @@ impl<'tcx> Body<'tcx> { } } -#[derive(Copy, Clone, PartialEq, Eq, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, PartialEq, Eq, Debug, TyEncodable, TyDecodable, HashStable)] pub enum Safety { Safe, /// Unsafe because of a PushUnsafeBlock @@ -465,9 +466,13 @@ impl<T> ClearCrossCrate<T> { const TAG_CLEAR_CROSS_CRATE_CLEAR: u8 = 0; const TAG_CLEAR_CROSS_CRATE_SET: u8 = 1; -impl<T: Encodable> rustc_serialize::UseSpecializedEncodable for ClearCrossCrate<T> { +impl<'tcx, E: TyEncoder<'tcx>, T: Encodable<E>> Encodable<E> for ClearCrossCrate<T> { #[inline] - fn default_encode<E: rustc_serialize::Encoder>(&self, e: &mut E) -> Result<(), E::Error> { + fn encode(&self, e: &mut E) -> Result<(), E::Error> { + if E::CLEAR_CROSS_CRATE { + return Ok(()); + } + match *self { ClearCrossCrate::Clear => TAG_CLEAR_CROSS_CRATE_CLEAR.encode(e), ClearCrossCrate::Set(ref val) => { @@ -477,12 +482,13 @@ impl<T: Encodable> rustc_serialize::UseSpecializedEncodable for ClearCrossCrate< } } } -impl<T: Decodable> rustc_serialize::UseSpecializedDecodable for ClearCrossCrate<T> { +impl<'tcx, D: TyDecoder<'tcx>, T: Decodable<D>> Decodable<D> for ClearCrossCrate<T> { #[inline] - fn default_decode<D>(d: &mut D) -> Result<ClearCrossCrate<T>, D::Error> - where - D: rustc_serialize::Decoder, - { + fn decode(d: &mut D) -> Result<ClearCrossCrate<T>, D::Error> { + if D::CLEAR_CROSS_CRATE { + return Ok(ClearCrossCrate::Clear); + } + let discr = u8::decode(d)?; match discr { @@ -491,7 +497,7 @@ impl<T: Decodable> rustc_serialize::UseSpecializedDecodable for ClearCrossCrate< let val = T::decode(d)?; Ok(ClearCrossCrate::Set(val)) } - _ => unreachable!(), + tag => Err(d.error(&format!("Invalid tag for ClearCrossCrate: {:?}", tag))), } } } @@ -501,7 +507,7 @@ impl<T: Decodable> rustc_serialize::UseSpecializedDecodable for ClearCrossCrate< /// Most passes can work with it as a whole, within a single function. // The unofficial Cranelift backend, at least as of #65828, needs `SourceInfo` to implement `Eq` and // `Hash`. Please ping @bjorn3 if removing them. -#[derive(Copy, Clone, Debug, Eq, PartialEq, RustcEncodable, RustcDecodable, Hash, HashStable)] +#[derive(Copy, Clone, Debug, Eq, PartialEq, TyEncodable, TyDecodable, Hash, HashStable)] pub struct SourceInfo { /// The source span for the AST pertaining to this MIR entity. pub span: Span, @@ -521,7 +527,7 @@ impl SourceInfo { /////////////////////////////////////////////////////////////////////////// // Borrow kinds -#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, TyEncodable, TyDecodable)] #[derive(HashStable)] pub enum BorrowKind { /// Data must be immutable and is aliasable. @@ -632,7 +638,7 @@ pub enum LocalKind { ReturnPointer, } -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable)] pub struct VarBindingForm<'tcx> { /// Is variable bound via `x`, `mut x`, `ref x`, or `ref mut x`? pub binding_mode: ty::BindingMode, @@ -654,7 +660,7 @@ pub struct VarBindingForm<'tcx> { pub pat_span: Span, } -#[derive(Clone, Debug, RustcEncodable, RustcDecodable)] +#[derive(Clone, Debug, TyEncodable, TyDecodable)] pub enum BindingForm<'tcx> { /// This is a binding for a non-`self` binding, or a `self` that has an explicit type. Var(VarBindingForm<'tcx>), @@ -665,7 +671,7 @@ pub enum BindingForm<'tcx> { } /// Represents what type of implicit self a function has, if any. -#[derive(Clone, Copy, PartialEq, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Copy, PartialEq, Debug, TyEncodable, TyDecodable, HashStable)] pub enum ImplicitSelfKind { /// Represents a `fn x(self);`. Imm, @@ -708,7 +714,7 @@ mod binding_form_impl { /// involved in borrow_check errors, e.g., explanations of where the /// temporaries come from, when their destructors are run, and/or how /// one might revise the code to satisfy the borrow checker's rules. -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable)] pub struct BlockTailInfo { /// If `true`, then the value resulting from evaluating this tail /// expression is ignored by the block's expression context. @@ -725,7 +731,7 @@ pub struct BlockTailInfo { /// /// This can be a binding declared by the user, a temporary inserted by the compiler, a function /// argument, or the return place. -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub struct LocalDecl<'tcx> { /// Whether this is a mutable minding (i.e., `let x` or `let mut x`). /// @@ -857,10 +863,13 @@ pub struct LocalDecl<'tcx> { #[cfg(target_arch = "x86_64")] static_assert_size!(LocalDecl<'_>, 56); -/// Extra information about a some locals that's used for diagnostics. (Not -/// used for non-StaticRef temporaries, the return place, or anonymous function -/// parameters.) -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)] +/// Extra information about a some locals that's used for diagnostics and for +/// classifying variables into local variables, statics, etc, which is needed e.g. +/// for unsafety checking. +/// +/// Not used for non-StaticRef temporaries, the return place, or anonymous +/// function parameters. +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub enum LocalInfo<'tcx> { /// A user-defined local variable or function parameter /// @@ -1003,7 +1012,7 @@ impl<'tcx> LocalDecl<'tcx> { } /// Debug information pertaining to a user variable. -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub struct VarDebugInfo<'tcx> { pub name: Symbol, @@ -1038,7 +1047,7 @@ impl BasicBlock { /////////////////////////////////////////////////////////////////////////// // BasicBlockData and Terminator -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub struct BasicBlockData<'tcx> { /// List of statements in this block. pub statements: Vec<Statement<'tcx>>, @@ -1061,7 +1070,7 @@ pub struct BasicBlockData<'tcx> { } /// Information about an assertion failure. -#[derive(Clone, RustcEncodable, RustcDecodable, HashStable, PartialEq)] +#[derive(Clone, TyEncodable, TyDecodable, HashStable, PartialEq)] pub enum AssertKind<O> { BoundsCheck { len: O, index: O }, Overflow(BinOp, O, O), @@ -1072,7 +1081,7 @@ pub enum AssertKind<O> { ResumedAfterPanic(GeneratorKind), } -#[derive(Clone, Debug, PartialEq, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)] +#[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub enum InlineAsmOperand<'tcx> { In { reg: InlineAsmRegOrRegClass, @@ -1317,7 +1326,7 @@ impl<O: fmt::Debug> fmt::Debug for AssertKind<O> { /////////////////////////////////////////////////////////////////////////// // Statements -#[derive(Clone, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)] +#[derive(Clone, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub struct Statement<'tcx> { pub source_info: SourceInfo, pub kind: StatementKind<'tcx>, @@ -1343,7 +1352,7 @@ impl Statement<'_> { } } -#[derive(Clone, Debug, PartialEq, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)] +#[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub enum StatementKind<'tcx> { /// Write the RHS Rvalue to the LHS Place. Assign(Box<(Place<'tcx>, Rvalue<'tcx>)>), @@ -1396,7 +1405,7 @@ pub enum StatementKind<'tcx> { } /// Describes what kind of retag is to be performed. -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, PartialEq, Eq, HashStable)] +#[derive(Copy, Clone, TyEncodable, TyDecodable, Debug, PartialEq, Eq, HashStable)] pub enum RetagKind { /// The initial retag when entering a function. FnEntry, @@ -1409,7 +1418,7 @@ pub enum RetagKind { } /// The `FakeReadCause` describes the type of pattern why a FakeRead statement exists. -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, HashStable, PartialEq)] +#[derive(Copy, Clone, TyEncodable, TyDecodable, Debug, HashStable, PartialEq)] pub enum FakeReadCause { /// Inject a fake read of the borrowed input at the end of each guards /// code. @@ -1451,7 +1460,7 @@ pub enum FakeReadCause { ForIndex, } -#[derive(Clone, Debug, PartialEq, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)] +#[derive(Clone, Debug, PartialEq, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub struct LlvmInlineAsm<'tcx> { pub asm: hir::LlvmInlineAsmInner, pub outputs: Box<[Place<'tcx>]>, @@ -1496,7 +1505,7 @@ impl Debug for Statement<'_> { /// A path to a value; something that can be evaluated without /// changing or disturbing program state. -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, HashStable)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, HashStable)] pub struct Place<'tcx> { pub local: Local, @@ -1504,10 +1513,8 @@ pub struct Place<'tcx> { pub projection: &'tcx List<PlaceElem<'tcx>>, } -impl<'tcx> rustc_serialize::UseSpecializedDecodable for Place<'tcx> {} - #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[derive(RustcEncodable, RustcDecodable, HashStable)] +#[derive(TyEncodable, TyDecodable, HashStable)] pub enum ProjectionElem<V, T> { Deref, Field(Field, T), @@ -1732,7 +1739,7 @@ rustc_index::newtype_index! { } } -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable)] pub struct SourceScopeData { pub span: Span, pub parent_scope: Option<SourceScope>, @@ -1742,7 +1749,7 @@ pub struct SourceScopeData { pub local_data: ClearCrossCrate<SourceScopeLocalData>, } -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable)] pub struct SourceScopeLocalData { /// An `HirId` with lint levels equivalent to this scope's lint levels. pub lint_root: hir::HirId, @@ -1755,7 +1762,7 @@ pub struct SourceScopeLocalData { /// These are values that can appear inside an rvalue. They are intentionally /// limited to prevent rvalues from being nested in one another. -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, PartialEq, TyEncodable, TyDecodable, HashStable)] pub enum Operand<'tcx> { /// Copy: The value must be available for use afterwards. /// @@ -1889,7 +1896,7 @@ impl<'tcx> Operand<'tcx> { /////////////////////////////////////////////////////////////////////////// /// Rvalues -#[derive(Clone, RustcEncodable, RustcDecodable, HashStable, PartialEq)] +#[derive(Clone, TyEncodable, TyDecodable, HashStable, PartialEq)] pub enum Rvalue<'tcx> { /// x (either a move or copy, depending on type of x) Use(Operand<'tcx>), @@ -1935,13 +1942,13 @@ pub enum Rvalue<'tcx> { Aggregate(Box<AggregateKind<'tcx>>, Vec<Operand<'tcx>>), } -#[derive(Clone, Copy, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, TyEncodable, TyDecodable, HashStable)] pub enum CastKind { Misc, Pointer(PointerCast), } -#[derive(Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Debug, PartialEq, Eq, TyEncodable, TyDecodable, HashStable)] pub enum AggregateKind<'tcx> { /// The type is of the element Array(Ty<'tcx>), @@ -1958,7 +1965,7 @@ pub enum AggregateKind<'tcx> { Generator(DefId, SubstsRef<'tcx>, hir::Movability), } -#[derive(Copy, Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, TyEncodable, TyDecodable, HashStable)] pub enum BinOp { /// The `+` operator (addition) Add, @@ -2006,7 +2013,7 @@ impl BinOp { } } -#[derive(Copy, Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, TyEncodable, TyDecodable, HashStable)] pub enum NullOp { /// Returns the size of a value of that type SizeOf, @@ -2014,7 +2021,7 @@ pub enum NullOp { Box, } -#[derive(Copy, Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, TyEncodable, TyDecodable, HashStable)] pub enum UnOp { /// The `!` operator for logical inversion Not, @@ -2127,7 +2134,7 @@ impl<'tcx> Debug for Rvalue<'tcx> { AggregateKind::Closure(def_id, substs) => ty::tls::with(|tcx| { if let Some(def_id) = def_id.as_local() { - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let name = if tcx.sess.opts.debugging_opts.span_free_formats { let substs = tcx.lift(&substs).unwrap(); format!( @@ -2155,7 +2162,7 @@ impl<'tcx> Debug for Rvalue<'tcx> { AggregateKind::Generator(def_id, _, _) => ty::tls::with(|tcx| { if let Some(def_id) = def_id.as_local() { - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let name = format!("[generator@{:?}]", tcx.hir().span(hir_id)); let mut struct_fmt = fmt.debug_struct(&name); @@ -2184,7 +2191,7 @@ impl<'tcx> Debug for Rvalue<'tcx> { /// this does not necessarily mean that they are "==" in Rust -- in /// particular one must be wary of `NaN`! -#[derive(Clone, Copy, PartialEq, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Copy, PartialEq, TyEncodable, TyDecodable, HashStable)] pub struct Constant<'tcx> { pub span: Span, @@ -2245,7 +2252,7 @@ impl Constant<'tcx> { /// The first will lead to the constraint `w: &'1 str` (for some /// inferred region `'1`). The second will lead to the constraint `w: /// &'static str`. -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub struct UserTypeProjections { pub contents: Vec<(UserTypeProjection, Span)>, } @@ -2322,7 +2329,7 @@ impl<'tcx> UserTypeProjections { /// * `let (x, _): T = ...` -- here, the `projs` vector would contain /// `field[0]` (aka `.0`), indicating that the type of `s` is /// determined by finding the type of the `.0` field from `T`. -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, PartialEq)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable, PartialEq)] pub struct UserTypeProjection { pub base: UserTypeAnnotationIndex, pub projs: Vec<ProjectionKind>, diff --git a/src/librustc_middle/mir/mono.rs b/src/librustc_middle/mir/mono.rs index bb204223b60..0d5f6619df5 100644 --- a/src/librustc_middle/mir/mono.rs +++ b/src/librustc_middle/mir/mono.rs @@ -198,10 +198,10 @@ impl<'tcx> MonoItem<'tcx> { pub fn local_span(&self, tcx: TyCtxt<'tcx>) -> Option<Span> { match *self { MonoItem::Fn(Instance { def, .. }) => { - def.def_id().as_local().map(|def_id| tcx.hir().as_local_hir_id(def_id)) + def.def_id().as_local().map(|def_id| tcx.hir().local_def_id_to_hir_id(def_id)) } MonoItem::Static(def_id) => { - def_id.as_local().map(|def_id| tcx.hir().as_local_hir_id(def_id)) + def_id.as_local().map(|def_id| tcx.hir().local_def_id_to_hir_id(def_id)) } MonoItem::GlobalAsm(hir_id) => Some(hir_id), } @@ -242,7 +242,7 @@ pub struct CodegenUnit<'tcx> { /// Specifies the linkage type for a `MonoItem`. /// /// See https://llvm.org/docs/LangRef.html#linkage-types for more details about these variants. -#[derive(Copy, Clone, PartialEq, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, PartialEq, Debug, TyEncodable, TyDecodable, HashStable)] pub enum Linkage { External, AvailableExternally, @@ -346,9 +346,10 @@ impl<'tcx> CodegenUnit<'tcx> { // instances into account. The others don't matter for // the codegen tests and can even make item order // unstable. - InstanceDef::Item(def) => { - def.did.as_local().map(|def_id| tcx.hir().as_local_hir_id(def_id)) - } + InstanceDef::Item(def) => def + .did + .as_local() + .map(|def_id| tcx.hir().local_def_id_to_hir_id(def_id)), InstanceDef::VtableShim(..) | InstanceDef::ReifyShim(..) | InstanceDef::Intrinsic(..) @@ -360,7 +361,7 @@ impl<'tcx> CodegenUnit<'tcx> { } } MonoItem::Static(def_id) => { - def_id.as_local().map(|def_id| tcx.hir().as_local_hir_id(def_id)) + def_id.as_local().map(|def_id| tcx.hir().local_def_id_to_hir_id(def_id)) } MonoItem::GlobalAsm(hir_id) => Some(hir_id), }, diff --git a/src/librustc_middle/mir/predecessors.rs b/src/librustc_middle/mir/predecessors.rs index 7508c023939..b16a1d53fff 100644 --- a/src/librustc_middle/mir/predecessors.rs +++ b/src/librustc_middle/mir/predecessors.rs @@ -54,16 +54,16 @@ impl PredecessorCache { } } -impl serialize::Encodable for PredecessorCache { +impl<S: serialize::Encoder> serialize::Encodable<S> for PredecessorCache { #[inline] - fn encode<S: serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { serialize::Encodable::encode(&(), s) } } -impl serialize::Decodable for PredecessorCache { +impl<D: serialize::Decoder> serialize::Decodable<D> for PredecessorCache { #[inline] - fn decode<D: serialize::Decoder>(d: &mut D) -> Result<Self, D::Error> { + fn decode(d: &mut D) -> Result<Self, D::Error> { serialize::Decodable::decode(d).map(|_v: ()| Self::new()) } } diff --git a/src/librustc_middle/mir/query.rs b/src/librustc_middle/mir/query.rs index 6ce5d61fbed..0878e9313d8 100644 --- a/src/librustc_middle/mir/query.rs +++ b/src/librustc_middle/mir/query.rs @@ -16,7 +16,7 @@ use std::fmt::{self, Debug}; use super::{Field, SourceInfo}; -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable)] pub enum UnsafetyViolationKind { /// Only permitted in regular `fn`s, prohibited in `const fn`s. General, @@ -35,7 +35,7 @@ pub enum UnsafetyViolationKind { UnsafeFnBorrowPacked, } -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable)] pub enum UnsafetyViolationDetails { CallToUnsafeFunction, UseOfInlineAssembly, @@ -120,7 +120,7 @@ impl UnsafetyViolationDetails { } } -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable)] pub struct UnsafetyViolation { pub source_info: SourceInfo, pub lint_root: hir::HirId, @@ -128,7 +128,7 @@ pub struct UnsafetyViolation { pub details: UnsafetyViolationDetails, } -#[derive(Clone, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, TyEncodable, TyDecodable, HashStable)] pub struct UnsafetyCheckResult { /// Violations that are propagated *upwards* from this function. pub violations: Lrc<[UnsafetyViolation]>, @@ -145,7 +145,7 @@ rustc_index::newtype_index! { } /// The layout of generator state. -#[derive(Clone, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)] +#[derive(Clone, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub struct GeneratorLayout<'tcx> { /// The type of every local stored inside the generator. pub field_tys: IndexVec<GeneratorSavedLocal, Ty<'tcx>>, @@ -220,7 +220,7 @@ impl Debug for GeneratorLayout<'_> { } } -#[derive(Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Debug, TyEncodable, TyDecodable, HashStable)] pub struct BorrowCheckResult<'tcx> { /// All the opaque types that are restricted to concrete types /// by this function. Unlike the value in `TypeckResults`, this has @@ -235,7 +235,7 @@ pub struct BorrowCheckResult<'tcx> { /// Each field corresponds to an implementer of the `Qualif` trait in /// `librustc_mir/transform/check_consts/qualifs.rs`. See that file for more information on each /// `Qualif`. -#[derive(Clone, Copy, Debug, Default, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Copy, Debug, Default, TyEncodable, TyDecodable, HashStable)] pub struct ConstQualifs { pub has_mut_interior: bool, pub needs_drop: bool, @@ -291,7 +291,7 @@ pub struct ConstQualifs { /// `ReEarlyBound`, `ReFree`). We use these because in a query response we /// cannot use `ReVar` (which is what we use internally within the rest of the /// NLL code). -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable)] pub struct ClosureRegionRequirements<'tcx> { /// The number of external regions defined on the closure. In our /// example above, it would be 3 -- one for `'static`, then `'1` @@ -307,7 +307,7 @@ pub struct ClosureRegionRequirements<'tcx> { /// Indicates an outlives-constraint between a type or between two /// free regions declared on the closure. -#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable)] pub struct ClosureOutlivesRequirement<'tcx> { // This region or type ... pub subject: ClosureOutlivesSubject<'tcx>, @@ -328,7 +328,7 @@ pub struct ClosureOutlivesRequirement<'tcx> { /// /// See also `rustc_mir::borrow_check::constraints`. #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)] -#[derive(RustcEncodable, RustcDecodable, HashStable)] +#[derive(TyEncodable, TyDecodable, HashStable)] pub enum ConstraintCategory { Return(ReturnConstraint), Yield, @@ -365,7 +365,7 @@ pub enum ConstraintCategory { } #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)] -#[derive(RustcEncodable, RustcDecodable, HashStable)] +#[derive(TyEncodable, TyDecodable, HashStable)] pub enum ReturnConstraint { Normal, ClosureUpvar(hir::HirId), @@ -373,7 +373,7 @@ pub enum ReturnConstraint { /// The subject of a `ClosureOutlivesRequirement` -- that is, the thing /// that must outlive some region. -#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable)] pub enum ClosureOutlivesSubject<'tcx> { /// Subject is a type, typically a type parameter, but could also /// be a projection. Indicates a requirement like `T: 'a` being @@ -398,7 +398,7 @@ pub struct DestructuredConst<'tcx> { /// Coverage information summarized from a MIR if instrumented for source code coverage (see /// compiler option `-Zinstrument-coverage`). This information is generated by the /// `InstrumentCoverage` MIR pass and can be retrieved via the `coverageinfo` query. -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable)] +#[derive(Clone, TyEncodable, TyDecodable, Debug, HashStable)] pub struct CoverageInfo { /// The total number of coverage region counters added to the MIR `Body`. pub num_counters: u32, diff --git a/src/librustc_middle/mir/terminator/mod.rs b/src/librustc_middle/mir/terminator/mod.rs index 1f5041141d5..0ab78381224 100644 --- a/src/librustc_middle/mir/terminator/mod.rs +++ b/src/librustc_middle/mir/terminator/mod.rs @@ -16,7 +16,7 @@ use std::slice; pub use super::query::*; -#[derive(Clone, RustcEncodable, RustcDecodable, HashStable, PartialEq)] +#[derive(Clone, TyEncodable, TyDecodable, HashStable, PartialEq)] pub enum TerminatorKind<'tcx> { /// Block should have one successor in the graph; we jump there. Goto { target: BasicBlock }, @@ -194,7 +194,7 @@ pub enum TerminatorKind<'tcx> { destination: Option<BasicBlock>, }, } -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable)] pub struct Terminator<'tcx> { pub source_info: SourceInfo, pub kind: TerminatorKind<'tcx>, diff --git a/src/librustc_middle/query/mod.rs b/src/librustc_middle/query/mod.rs index a8f6723a356..d364a464638 100644 --- a/src/librustc_middle/query/mod.rs +++ b/src/librustc_middle/query/mod.rs @@ -352,7 +352,7 @@ rustc_queries! { /// per-type-parameter predicates for resolving `T::AssocTy`. query type_param_predicates(key: (DefId, LocalDefId)) -> ty::GenericPredicates<'tcx> { desc { |tcx| "computing the bounds for type parameter `{}`", { - let id = tcx.hir().as_local_hir_id(key.1); + let id = tcx.hir().local_def_id_to_hir_id(key.1); tcx.hir().ty_param_name(id) }} } diff --git a/src/librustc_middle/traits/mod.rs b/src/librustc_middle/traits/mod.rs index 585f29386a8..ea9c8b7a415 100644 --- a/src/librustc_middle/traits/mod.rs +++ b/src/librustc_middle/traits/mod.rs @@ -426,7 +426,7 @@ pub type SelectionResult<'tcx, T> = Result<Option<T>, SelectionError<'tcx>>; /// ### The type parameter `N` /// /// See explanation on `ImplSourceUserDefinedData`. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable, TypeFoldable, Lift)] +#[derive(Clone, PartialEq, Eq, TyEncodable, TyDecodable, HashStable, TypeFoldable, Lift)] pub enum ImplSource<'tcx, N> { /// ImplSource identifying a particular impl. ImplSourceUserDefined(ImplSourceUserDefinedData<'tcx, N>), @@ -557,14 +557,14 @@ impl<'tcx, N> ImplSource<'tcx, N> { /// is `Obligation`, as one might expect. During codegen, however, this /// is `()`, because codegen only requires a shallow resolution of an /// impl, and nested obligations are satisfied later. -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable, TypeFoldable, Lift)] +#[derive(Clone, PartialEq, Eq, TyEncodable, TyDecodable, HashStable, TypeFoldable, Lift)] pub struct ImplSourceUserDefinedData<'tcx, N> { pub impl_def_id: DefId, pub substs: SubstsRef<'tcx>, pub nested: Vec<N>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable, TypeFoldable, Lift)] +#[derive(Clone, PartialEq, Eq, TyEncodable, TyDecodable, HashStable, TypeFoldable, Lift)] pub struct ImplSourceGeneratorData<'tcx, N> { pub generator_def_id: DefId, pub substs: SubstsRef<'tcx>, @@ -573,7 +573,7 @@ pub struct ImplSourceGeneratorData<'tcx, N> { pub nested: Vec<N>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable, TypeFoldable, Lift)] +#[derive(Clone, PartialEq, Eq, TyEncodable, TyDecodable, HashStable, TypeFoldable, Lift)] pub struct ImplSourceClosureData<'tcx, N> { pub closure_def_id: DefId, pub substs: SubstsRef<'tcx>, @@ -582,18 +582,18 @@ pub struct ImplSourceClosureData<'tcx, N> { pub nested: Vec<N>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable, TypeFoldable, Lift)] +#[derive(Clone, PartialEq, Eq, TyEncodable, TyDecodable, HashStable, TypeFoldable, Lift)] pub struct ImplSourceAutoImplData<N> { pub trait_def_id: DefId, pub nested: Vec<N>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable, TypeFoldable, Lift)] +#[derive(Clone, PartialEq, Eq, TyEncodable, TyDecodable, HashStable, TypeFoldable, Lift)] pub struct ImplSourceBuiltinData<N> { pub nested: Vec<N>, } -#[derive(PartialEq, Eq, Clone, RustcEncodable, RustcDecodable, HashStable, TypeFoldable, Lift)] +#[derive(PartialEq, Eq, Clone, TyEncodable, TyDecodable, HashStable, TypeFoldable, Lift)] pub struct ImplSourceObjectData<'tcx, N> { /// `Foo` upcast to the obligation trait. This will be some supertrait of `Foo`. pub upcast_trait_ref: ty::PolyTraitRef<'tcx>, @@ -606,17 +606,17 @@ pub struct ImplSourceObjectData<'tcx, N> { pub nested: Vec<N>, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable, TypeFoldable, Lift)] +#[derive(Clone, PartialEq, Eq, TyEncodable, TyDecodable, HashStable, TypeFoldable, Lift)] pub struct ImplSourceFnPointerData<'tcx, N> { pub fn_ty: Ty<'tcx>, pub nested: Vec<N>, } // FIXME(@lcnr): This should be refactored and merged with other builtin vtables. -#[derive(Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Debug, PartialEq, Eq, TyEncodable, TyDecodable, HashStable)] pub struct ImplSourceDiscriminantKindData; -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable, TypeFoldable, Lift)] +#[derive(Clone, PartialEq, Eq, TyEncodable, TyDecodable, HashStable, TypeFoldable, Lift)] pub struct ImplSourceTraitAliasData<'tcx, N> { pub alias_def_id: DefId, pub substs: SubstsRef<'tcx>, diff --git a/src/librustc_middle/traits/specialization_graph.rs b/src/librustc_middle/traits/specialization_graph.rs index c9aae898007..969404c68ca 100644 --- a/src/librustc_middle/traits/specialization_graph.rs +++ b/src/librustc_middle/traits/specialization_graph.rs @@ -23,7 +23,7 @@ use rustc_span::symbol::Ident; /// parents of a given specializing impl, which is needed for extracting /// default items amongst other things. In the simple "chain" rule, every impl /// has at most one parent. -#[derive(RustcEncodable, RustcDecodable, HashStable)] +#[derive(TyEncodable, TyDecodable, HashStable)] pub struct Graph { /// All impls have a parent; the "root" impls have as their parent the `def_id` /// of the trait. @@ -50,7 +50,7 @@ impl Graph { /// Children of a given impl, grouped into blanket/non-blanket varieties as is /// done in `TraitDef`. -#[derive(Default, RustcEncodable, RustcDecodable)] +#[derive(Default, TyEncodable, TyDecodable)] pub struct Children { // Impls of a trait (or specializations of a given impl). To allow for // quicker lookup, the impls are indexed by a simplified version of their diff --git a/src/librustc_middle/ty/adjustment.rs b/src/librustc_middle/ty/adjustment.rs index 52ebcd63e7c..0ab07aea426 100644 --- a/src/librustc_middle/ty/adjustment.rs +++ b/src/librustc_middle/ty/adjustment.rs @@ -5,7 +5,7 @@ use rustc_hir::def_id::DefId; use rustc_hir::lang_items::{DerefMutTraitLangItem, DerefTraitLangItem}; use rustc_macros::HashStable; -#[derive(Clone, Copy, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, TyEncodable, TyDecodable, HashStable)] pub enum PointerCast { /// Go from a fn-item type to a fn-pointer type. ReifyFnPointer, @@ -76,7 +76,7 @@ pub enum PointerCast { /// At some point, of course, `Box` should move out of the compiler, in which /// case this is analogous to transforming a struct. E.g., Box<[i32; 4]> -> /// Box<[i32]> is an `Adjust::Unsize` with the target `Box<[i32]>`. -#[derive(Clone, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)] +#[derive(Clone, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub struct Adjustment<'tcx> { pub kind: Adjust<'tcx>, pub target: Ty<'tcx>, @@ -91,7 +91,7 @@ impl Adjustment<'tcx> { } } -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub enum Adjust<'tcx> { /// Go from ! to any type. NeverToAny, @@ -109,7 +109,7 @@ pub enum Adjust<'tcx> { /// call, with the signature `&'a T -> &'a U` or `&'a mut T -> &'a mut U`. /// The target type is `U` in both cases, with the region and mutability /// being those shared by both the receiver and the returned reference. -#[derive(Copy, Clone, PartialEq, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)] +#[derive(Copy, Clone, PartialEq, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub struct OverloadedDeref<'tcx> { pub region: ty::Region<'tcx>, pub mutbl: hir::Mutability, @@ -143,13 +143,13 @@ impl<'tcx> OverloadedDeref<'tcx> { /// new code via two-phase borrows, so we try to limit where we create two-phase /// capable mutable borrows. /// See #49434 for tracking. -#[derive(Copy, Clone, PartialEq, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, PartialEq, Debug, TyEncodable, TyDecodable, HashStable)] pub enum AllowTwoPhase { Yes, No, } -#[derive(Copy, Clone, PartialEq, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, PartialEq, Debug, TyEncodable, TyDecodable, HashStable)] pub enum AutoBorrowMutability { Mut { allow_two_phase_borrow: AllowTwoPhase }, Not, @@ -164,7 +164,7 @@ impl From<AutoBorrowMutability> for hir::Mutability { } } -#[derive(Copy, Clone, PartialEq, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)] +#[derive(Copy, Clone, PartialEq, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable)] pub enum AutoBorrow<'tcx> { /// Converts from T to &T. Ref(ty::Region<'tcx>, AutoBorrowMutability), @@ -179,7 +179,7 @@ pub enum AutoBorrow<'tcx> { /// This struct can be obtained via the `coerce_impl_info` query. /// Demanding this struct also has the side-effect of reporting errors /// for inappropriate impls. -#[derive(Clone, Copy, RustcEncodable, RustcDecodable, Debug, HashStable)] +#[derive(Clone, Copy, TyEncodable, TyDecodable, Debug, HashStable)] pub struct CoerceUnsizedInfo { /// If this is a "custom coerce" impl, then what kind of custom /// coercion is it? This applies to impls of `CoerceUnsized` for @@ -188,7 +188,7 @@ pub struct CoerceUnsizedInfo { pub custom_kind: Option<CustomCoerceUnsized>, } -#[derive(Clone, Copy, RustcEncodable, RustcDecodable, Debug, HashStable)] +#[derive(Clone, Copy, TyEncodable, TyDecodable, Debug, HashStable)] pub enum CustomCoerceUnsized { /// Records the index of the field being coerced. Struct(usize), diff --git a/src/librustc_middle/ty/binding.rs b/src/librustc_middle/ty/binding.rs index 5ee88115090..3237147c8ba 100644 --- a/src/librustc_middle/ty/binding.rs +++ b/src/librustc_middle/ty/binding.rs @@ -2,7 +2,7 @@ use rustc_hir::BindingAnnotation; use rustc_hir::BindingAnnotation::*; use rustc_hir::Mutability; -#[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy, HashStable)] +#[derive(Clone, PartialEq, TyEncodable, TyDecodable, Debug, Copy, HashStable)] pub enum BindingMode { BindByReference(Mutability), BindByValue(Mutability), diff --git a/src/librustc_middle/ty/cast.rs b/src/librustc_middle/ty/cast.rs index 31c106cb230..3a3caa55f60 100644 --- a/src/librustc_middle/ty/cast.rs +++ b/src/librustc_middle/ty/cast.rs @@ -31,7 +31,7 @@ pub enum CastTy<'tcx> { } /// Cast Kind. See RFC 401 (or librustc_typeck/check/cast.rs) -#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable)] pub enum CastKind { CoercionCast, PtrPtrCast, diff --git a/src/librustc_middle/ty/codec.rs b/src/librustc_middle/ty/codec.rs index a7c7b160480..291648869fb 100644 --- a/src/librustc_middle/ty/codec.rs +++ b/src/librustc_middle/ty/codec.rs @@ -8,12 +8,15 @@ use crate::arena::ArenaAllocatable; use crate::infer::canonical::{CanonicalVarInfo, CanonicalVarInfos}; -use crate::mir::{self, interpret::Allocation}; +use crate::mir::{ + self, + interpret::{AllocId, Allocation}, +}; use crate::ty::subst::SubstsRef; use crate::ty::{self, List, Ty, TyCtxt}; use rustc_data_structures::fx::FxHashMap; use rustc_hir::def_id::{CrateNum, DefId}; -use rustc_serialize::{opaque, Decodable, Decoder, Encodable, Encoder}; +use rustc_serialize::{Decodable, Decoder, Encodable, Encoder}; use rustc_span::Span; use std::convert::{TryFrom, TryInto}; use std::hash::Hash; @@ -25,46 +28,75 @@ use std::marker::DiscriminantKind; /// This offset is also chosen so that the first byte is never < 0x80. pub const SHORTHAND_OFFSET: usize = 0x80; -pub trait EncodableWithShorthand: Clone + Eq + Hash { - type Variant: Encodable; +pub trait EncodableWithShorthand<'tcx, E: TyEncoder<'tcx>>: Copy + Eq + Hash { + type Variant: Encodable<E>; fn variant(&self) -> &Self::Variant; } #[allow(rustc::usage_of_ty_tykind)] -impl<'tcx> EncodableWithShorthand for Ty<'tcx> { +impl<'tcx, E: TyEncoder<'tcx>> EncodableWithShorthand<'tcx, E> for Ty<'tcx> { type Variant = ty::TyKind<'tcx>; fn variant(&self) -> &Self::Variant { &self.kind } } -impl<'tcx> EncodableWithShorthand for ty::Predicate<'tcx> { +impl<'tcx, E: TyEncoder<'tcx>> EncodableWithShorthand<'tcx, E> for ty::Predicate<'tcx> { type Variant = ty::PredicateKind<'tcx>; fn variant(&self) -> &Self::Variant { self.kind() } } -pub trait TyEncoder: Encoder { - fn position(&self) -> usize; +pub trait OpaqueEncoder: Encoder { + fn opaque(&mut self) -> &mut rustc_serialize::opaque::Encoder; + fn encoder_position(&self) -> usize; } -impl TyEncoder for opaque::Encoder { +impl OpaqueEncoder for rustc_serialize::opaque::Encoder { + #[inline] + fn opaque(&mut self) -> &mut rustc_serialize::opaque::Encoder { + self + } #[inline] - fn position(&self) -> usize { + fn encoder_position(&self) -> usize { self.position() } } +pub trait TyEncoder<'tcx>: Encoder { + const CLEAR_CROSS_CRATE: bool; + + fn tcx(&self) -> TyCtxt<'tcx>; + fn position(&self) -> usize; + fn type_shorthands(&mut self) -> &mut FxHashMap<Ty<'tcx>, usize>; + fn predicate_shorthands(&mut self) -> &mut FxHashMap<ty::Predicate<'tcx>, usize>; + fn encode_alloc_id(&mut self, alloc_id: &AllocId) -> Result<(), Self::Error>; +} + +/// Trait for decoding to a reference. +/// +/// This is a separate trait from `Decodable` so that we can implement it for +/// upstream types, such as `FxHashSet`. +/// +/// The `TyDecodable` derive macro will use this trait for fields that are +/// references (and don't use a type alias to hide that). +/// +/// `Decodable` can still be implemented in cases where `Decodable` is required +/// by a trait bound. +pub trait RefDecodable<'tcx, D: TyDecoder<'tcx>> { + fn decode(d: &mut D) -> Result<&'tcx Self, D::Error>; +} + /// Encode the given value or a previously cached shorthand. pub fn encode_with_shorthand<E, T, M>(encoder: &mut E, value: &T, cache: M) -> Result<(), E::Error> where - E: TyEncoder, + E: TyEncoder<'tcx>, M: for<'b> Fn(&'b mut E) -> &'b mut FxHashMap<T, usize>, - T: EncodableWithShorthand, + T: EncodableWithShorthand<'tcx, E>, <T::Variant as DiscriminantKind>::Discriminant: Ord + TryFrom<usize>, { - let existing_shorthand = cache(encoder).get(value).cloned(); + let existing_shorthand = cache(encoder).get(value).copied(); if let Some(shorthand) = existing_shorthand { return encoder.emit_usize(shorthand); } @@ -89,13 +121,51 @@ where // Check that the shorthand is a not longer than the // full encoding itself, i.e., it's an obvious win. if leb128_bits >= 64 || (shorthand as u64) < (1 << leb128_bits) { - cache(encoder).insert(value.clone(), shorthand); + cache(encoder).insert(*value, shorthand); } Ok(()) } +impl<'tcx, E: TyEncoder<'tcx>> Encodable<E> for Ty<'tcx> { + fn encode(&self, e: &mut E) -> Result<(), E::Error> { + encode_with_shorthand(e, self, TyEncoder::type_shorthands) + } +} + +impl<'tcx, E: TyEncoder<'tcx>> Encodable<E> for ty::Predicate<'tcx> { + fn encode(&self, e: &mut E) -> Result<(), E::Error> { + encode_with_shorthand(e, self, TyEncoder::predicate_shorthands) + } +} + +impl<'tcx, E: TyEncoder<'tcx>> Encodable<E> for AllocId { + fn encode(&self, e: &mut E) -> Result<(), E::Error> { + e.encode_alloc_id(self) + } +} + +macro_rules! encodable_via_deref { + ($($t:ty),+) => { + $(impl<'tcx, E: TyEncoder<'tcx>> Encodable<E> for $t { + fn encode(&self, e: &mut E) -> Result<(), E::Error> { + (**self).encode(e) + } + })* + } +} + +encodable_via_deref! { + &'tcx ty::TypeckResults<'tcx>, + ty::Region<'tcx>, + &'tcx mir::Body<'tcx>, + &'tcx mir::UnsafetyCheckResult, + &'tcx mir::BorrowCheckResult<'tcx> +} + pub trait TyDecoder<'tcx>: Decoder { + const CLEAR_CROSS_CRATE: bool; + fn tcx(&self) -> TyCtxt<'tcx>; fn peek_byte(&self) -> u8; @@ -127,10 +197,12 @@ pub trait TyDecoder<'tcx>: Decoder { fn positioned_at_shorthand(&self) -> bool { (self.peek_byte() & (SHORTHAND_OFFSET as u8)) != 0 } + + fn decode_alloc_id(&mut self) -> Result<AllocId, Self::Error>; } #[inline] -pub fn decode_arena_allocable<'tcx, D, T: ArenaAllocatable<'tcx> + Decodable>( +pub fn decode_arena_allocable<'tcx, D, T: ArenaAllocatable<'tcx> + Decodable<D>>( decoder: &mut D, ) -> Result<&'tcx T, D::Error> where @@ -140,172 +212,157 @@ where } #[inline] -pub fn decode_arena_allocable_slice<'tcx, D, T: ArenaAllocatable<'tcx> + Decodable>( +pub fn decode_arena_allocable_slice<'tcx, D, T: ArenaAllocatable<'tcx> + Decodable<D>>( decoder: &mut D, ) -> Result<&'tcx [T], D::Error> where D: TyDecoder<'tcx>, { - Ok(decoder.tcx().arena.alloc_from_iter(<Vec<T> as Decodable>::decode(decoder)?)) + Ok(decoder.tcx().arena.alloc_from_iter(<Vec<T> as Decodable<D>>::decode(decoder)?)) } -#[inline] -pub fn decode_cnum<D>(decoder: &mut D) -> Result<CrateNum, D::Error> -where - D: TyDecoder<'tcx>, -{ - let cnum = CrateNum::from_u32(u32::decode(decoder)?); - Ok(decoder.map_encoded_cnum_to_current(cnum)) +impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for Ty<'tcx> { + #[allow(rustc::usage_of_ty_tykind)] + fn decode(decoder: &mut D) -> Result<Ty<'tcx>, D::Error> { + // Handle shorthands first, if we have an usize > 0x80. + if decoder.positioned_at_shorthand() { + let pos = decoder.read_usize()?; + assert!(pos >= SHORTHAND_OFFSET); + let shorthand = pos - SHORTHAND_OFFSET; + + decoder.cached_ty_for_shorthand(shorthand, |decoder| { + decoder.with_position(shorthand, Ty::decode) + }) + } else { + let tcx = decoder.tcx(); + Ok(tcx.mk_ty(ty::TyKind::decode(decoder)?)) + } + } } -#[allow(rustc::usage_of_ty_tykind)] -#[inline] -pub fn decode_ty<D>(decoder: &mut D) -> Result<Ty<'tcx>, D::Error> -where - D: TyDecoder<'tcx>, -{ - // Handle shorthands first, if we have an usize > 0x80. - if decoder.positioned_at_shorthand() { - let pos = decoder.read_usize()?; - assert!(pos >= SHORTHAND_OFFSET); - let shorthand = pos - SHORTHAND_OFFSET; - - decoder.cached_ty_for_shorthand(shorthand, |decoder| { - decoder.with_position(shorthand, Ty::decode) - }) - } else { - let tcx = decoder.tcx(); - Ok(tcx.mk_ty(ty::TyKind::decode(decoder)?)) +impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for ty::Predicate<'tcx> { + fn decode(decoder: &mut D) -> Result<ty::Predicate<'tcx>, D::Error> { + // Handle shorthands first, if we have an usize > 0x80. + let predicate_kind = if decoder.positioned_at_shorthand() { + let pos = decoder.read_usize()?; + assert!(pos >= SHORTHAND_OFFSET); + let shorthand = pos - SHORTHAND_OFFSET; + + decoder.with_position(shorthand, ty::PredicateKind::decode) + } else { + ty::PredicateKind::decode(decoder) + }?; + let predicate = decoder.tcx().mk_predicate(predicate_kind); + Ok(predicate) } } -#[inline] -pub fn decode_predicate<D>(decoder: &mut D) -> Result<ty::Predicate<'tcx>, D::Error> -where - D: TyDecoder<'tcx>, -{ - // Handle shorthands first, if we have an usize > 0x80. - if decoder.positioned_at_shorthand() { - let pos = decoder.read_usize()?; - assert!(pos >= SHORTHAND_OFFSET); - let shorthand = pos - SHORTHAND_OFFSET; - - decoder.cached_predicate_for_shorthand(shorthand, |decoder| { - decoder.with_position(shorthand, ty::Predicate::decode) - }) - } else { +impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for SubstsRef<'tcx> { + fn decode(decoder: &mut D) -> Result<Self, D::Error> { + let len = decoder.read_usize()?; let tcx = decoder.tcx(); - Ok(tcx.mk_predicate(ty::PredicateKind::decode(decoder)?)) + Ok(tcx.mk_substs((0..len).map(|_| Decodable::decode(decoder)))?) } } -#[inline] -pub fn decode_spanned_predicates<D>( - decoder: &mut D, -) -> Result<&'tcx [(ty::Predicate<'tcx>, Span)], D::Error> -where - D: TyDecoder<'tcx>, -{ - let tcx = decoder.tcx(); - Ok(tcx.arena.alloc_from_iter( - (0..decoder.read_usize()?) - .map(|_| Decodable::decode(decoder)) - .collect::<Result<Vec<_>, _>>()?, - )) +impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for mir::Place<'tcx> { + fn decode(decoder: &mut D) -> Result<Self, D::Error> { + let local: mir::Local = Decodable::decode(decoder)?; + let len = decoder.read_usize()?; + let projection: &'tcx List<mir::PlaceElem<'tcx>> = + decoder.tcx().mk_place_elems((0..len).map(|_| Decodable::decode(decoder)))?; + Ok(mir::Place { local, projection }) + } } -#[inline] -pub fn decode_substs<D>(decoder: &mut D) -> Result<SubstsRef<'tcx>, D::Error> -where - D: TyDecoder<'tcx>, -{ - let len = decoder.read_usize()?; - let tcx = decoder.tcx(); - Ok(tcx.mk_substs((0..len).map(|_| Decodable::decode(decoder)))?) +impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for ty::Region<'tcx> { + fn decode(decoder: &mut D) -> Result<Self, D::Error> { + Ok(decoder.tcx().mk_region(Decodable::decode(decoder)?)) + } } -#[inline] -pub fn decode_place<D>(decoder: &mut D) -> Result<mir::Place<'tcx>, D::Error> -where - D: TyDecoder<'tcx>, -{ - let local: mir::Local = Decodable::decode(decoder)?; - let len = decoder.read_usize()?; - let projection: &'tcx List<mir::PlaceElem<'tcx>> = - decoder.tcx().mk_place_elems((0..len).map(|_| Decodable::decode(decoder)))?; - Ok(mir::Place { local, projection }) +impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for CanonicalVarInfos<'tcx> { + fn decode(decoder: &mut D) -> Result<Self, D::Error> { + let len = decoder.read_usize()?; + let interned: Result<Vec<CanonicalVarInfo>, _> = + (0..len).map(|_| Decodable::decode(decoder)).collect(); + Ok(decoder.tcx().intern_canonical_var_infos(interned?.as_slice())) + } } -#[inline] -pub fn decode_region<D>(decoder: &mut D) -> Result<ty::Region<'tcx>, D::Error> -where - D: TyDecoder<'tcx>, -{ - Ok(decoder.tcx().mk_region(Decodable::decode(decoder)?)) +impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for AllocId { + fn decode(decoder: &mut D) -> Result<Self, D::Error> { + decoder.decode_alloc_id() + } } -#[inline] -pub fn decode_ty_slice<D>(decoder: &mut D) -> Result<&'tcx ty::List<Ty<'tcx>>, D::Error> -where - D: TyDecoder<'tcx>, -{ - let len = decoder.read_usize()?; - Ok(decoder.tcx().mk_type_list((0..len).map(|_| Decodable::decode(decoder)))?) +impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for ty::SymbolName<'tcx> { + fn decode(decoder: &mut D) -> Result<Self, D::Error> { + Ok(ty::SymbolName::new(decoder.tcx(), &decoder.read_str()?)) + } } -#[inline] -pub fn decode_adt_def<D>(decoder: &mut D) -> Result<&'tcx ty::AdtDef, D::Error> -where - D: TyDecoder<'tcx>, -{ - let def_id = DefId::decode(decoder)?; - Ok(decoder.tcx().adt_def(def_id)) +macro_rules! impl_decodable_via_ref { + ($($t:ty),+) => { + $(impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for $t { + fn decode(decoder: &mut D) -> Result<Self, D::Error> { + RefDecodable::decode(decoder) + } + })* + } } -#[inline] -pub fn decode_symbol_name<D>(decoder: &mut D) -> Result<ty::SymbolName<'tcx>, D::Error> -where - D: TyDecoder<'tcx>, -{ - Ok(ty::SymbolName::new(decoder.tcx(), &decoder.read_str()?)) +impl<'tcx, D: TyDecoder<'tcx>> RefDecodable<'tcx, D> for ty::AdtDef { + fn decode(decoder: &mut D) -> Result<&'tcx Self, D::Error> { + let def_id = <DefId as Decodable<D>>::decode(decoder)?; + Ok(decoder.tcx().adt_def(def_id)) + } } -#[inline] -pub fn decode_existential_predicate_slice<D>( - decoder: &mut D, -) -> Result<&'tcx ty::List<ty::ExistentialPredicate<'tcx>>, D::Error> -where - D: TyDecoder<'tcx>, -{ - let len = decoder.read_usize()?; - Ok(decoder.tcx().mk_existential_predicates((0..len).map(|_| Decodable::decode(decoder)))?) +impl<'tcx, D: TyDecoder<'tcx>> RefDecodable<'tcx, D> for ty::List<Ty<'tcx>> { + fn decode(decoder: &mut D) -> Result<&'tcx Self, D::Error> { + let len = decoder.read_usize()?; + Ok(decoder.tcx().mk_type_list((0..len).map(|_| Decodable::decode(decoder)))?) + } } -#[inline] -pub fn decode_canonical_var_infos<D>(decoder: &mut D) -> Result<CanonicalVarInfos<'tcx>, D::Error> -where - D: TyDecoder<'tcx>, -{ - let len = decoder.read_usize()?; - let interned: Result<Vec<CanonicalVarInfo>, _> = - (0..len).map(|_| Decodable::decode(decoder)).collect(); - Ok(decoder.tcx().intern_canonical_var_infos(interned?.as_slice())) +impl<'tcx, D: TyDecoder<'tcx>> RefDecodable<'tcx, D> for ty::List<ty::ExistentialPredicate<'tcx>> { + fn decode(decoder: &mut D) -> Result<&'tcx Self, D::Error> { + let len = decoder.read_usize()?; + Ok(decoder.tcx().mk_existential_predicates((0..len).map(|_| Decodable::decode(decoder)))?) + } } -#[inline] -pub fn decode_const<D>(decoder: &mut D) -> Result<&'tcx ty::Const<'tcx>, D::Error> -where - D: TyDecoder<'tcx>, -{ - Ok(decoder.tcx().mk_const(Decodable::decode(decoder)?)) +impl<'tcx, D: TyDecoder<'tcx>> RefDecodable<'tcx, D> for ty::Const<'tcx> { + fn decode(decoder: &mut D) -> Result<&'tcx Self, D::Error> { + Ok(decoder.tcx().mk_const(Decodable::decode(decoder)?)) + } } -#[inline] -pub fn decode_allocation<D>(decoder: &mut D) -> Result<&'tcx Allocation, D::Error> -where - D: TyDecoder<'tcx>, -{ - Ok(decoder.tcx().intern_const_alloc(Decodable::decode(decoder)?)) +impl<'tcx, D: TyDecoder<'tcx>> RefDecodable<'tcx, D> for Allocation { + fn decode(decoder: &mut D) -> Result<&'tcx Self, D::Error> { + Ok(decoder.tcx().intern_const_alloc(Decodable::decode(decoder)?)) + } +} + +impl<'tcx, D: TyDecoder<'tcx>> RefDecodable<'tcx, D> for [(ty::Predicate<'tcx>, Span)] { + fn decode(decoder: &mut D) -> Result<&'tcx Self, D::Error> { + Ok(decoder.tcx().arena.alloc_from_iter( + (0..decoder.read_usize()?) + .map(|_| Decodable::decode(decoder)) + .collect::<Result<Vec<_>, _>>()?, + )) + } +} + +impl_decodable_via_ref! { + &'tcx ty::TypeckResults<'tcx>, + &'tcx ty::List<Ty<'tcx>>, + &'tcx ty::List<ty::ExistentialPredicate<'tcx>>, + &'tcx Allocation, + &'tcx mir::Body<'tcx>, + &'tcx mir::UnsafetyCheckResult, + &'tcx mir::BorrowCheckResult<'tcx> } #[macro_export] @@ -320,42 +377,21 @@ macro_rules! __impl_decoder_methods { } } -#[macro_export] macro_rules! impl_arena_allocatable_decoder { ([]$args:tt) => {}; ([decode $(, $attrs:ident)*] - [[$DecoderName:ident [$($typaram:tt),*]], [$name:ident: $ty:ty, $gen_ty:ty], $tcx:lifetime]) => { - // FIXME(#36588): These impls are horribly unsound as they allow - // the caller to pick any lifetime for `'tcx`, including `'static`. - #[allow(unused_lifetimes)] - impl<'_x, '_y, '_z, '_w, '_a, $($typaram),*> SpecializedDecoder<&'_a $gen_ty> - for $DecoderName<$($typaram),*> - where &'_a $gen_ty: UseSpecializedDecodable - { + [[$name:ident: $ty:ty], $tcx:lifetime]) => { + impl<$tcx, D: TyDecoder<$tcx>> RefDecodable<$tcx, D> for $ty { #[inline] - fn specialized_decode(&mut self) -> Result<&'_a $gen_ty, Self::Error> { - unsafe { - std::mem::transmute::< - Result<&$tcx $ty, Self::Error>, - Result<&'_a $gen_ty, Self::Error>, - >(decode_arena_allocable(self)) - } + fn decode(decoder: &mut D) -> Result<&$tcx Self, D::Error> { + decode_arena_allocable(decoder) } } - #[allow(unused_lifetimes)] - impl<'_x, '_y, '_z, '_w, '_a, $($typaram),*> SpecializedDecoder<&'_a [$gen_ty]> - for $DecoderName<$($typaram),*> - where &'_a [$gen_ty]: UseSpecializedDecodable - { + impl<$tcx, D: TyDecoder<$tcx>> RefDecodable<$tcx, D> for [$ty] { #[inline] - fn specialized_decode(&mut self) -> Result<&'_a [$gen_ty], Self::Error> { - unsafe { - std::mem::transmute::< - Result<&$tcx [$ty], Self::Error>, - Result<&'_a [$gen_ty], Self::Error>, - >(decode_arena_allocable_slice(self)) - } + fn decode(decoder: &mut D) -> Result<&$tcx Self, D::Error> { + decode_arena_allocable_slice(decoder) } } }; @@ -364,38 +400,30 @@ macro_rules! impl_arena_allocatable_decoder { }; } -#[macro_export] macro_rules! impl_arena_allocatable_decoders { - ($args:tt, [$($a:tt $name:ident: $ty:ty, $gen_ty:ty;)*], $tcx:lifetime) => { + ([], [$($a:tt $name:ident: $ty:ty,)*], $tcx:lifetime) => { $( - impl_arena_allocatable_decoder!($a [$args, [$name: $ty, $gen_ty], $tcx]); + impl_arena_allocatable_decoder!($a [[$name: $ty], $tcx]); )* } } +rustc_hir::arena_types!(impl_arena_allocatable_decoders, [], 'tcx); +arena_types!(impl_arena_allocatable_decoders, [], 'tcx); + #[macro_export] macro_rules! implement_ty_decoder { ($DecoderName:ident <$($typaram:tt),*>) => { mod __ty_decoder_impl { use std::borrow::Cow; - use std::mem::transmute; - - use rustc_serialize::{Decoder, SpecializedDecoder, UseSpecializedDecodable}; - - use $crate::infer::canonical::CanonicalVarInfos; - use $crate::ty; - use $crate::ty::codec::*; - use $crate::ty::subst::InternalSubsts; - use rustc_hir::def_id::CrateNum; - - use rustc_span::Span; + use rustc_serialize::Decoder; use super::$DecoderName; impl<$($typaram ),*> Decoder for $DecoderName<$($typaram),*> { type Error = String; - __impl_decoder_methods! { + $crate::__impl_decoder_methods! { read_nil -> (); read_u128 -> u128; @@ -423,135 +451,6 @@ macro_rules! implement_ty_decoder { self.opaque.error(err) } } - - // FIXME(#36588): These impls are horribly unsound as they allow - // the caller to pick any lifetime for `'tcx`, including `'static`. - - arena_types!(impl_arena_allocatable_decoders, [$DecoderName [$($typaram),*]], 'tcx); - - impl<$($typaram),*> SpecializedDecoder<CrateNum> - for $DecoderName<$($typaram),*> { - fn specialized_decode(&mut self) -> Result<CrateNum, Self::Error> { - decode_cnum(self) - } - } - - impl<'_x, '_y, $($typaram),*> SpecializedDecoder<&'_x ty::TyS<'_y>> - for $DecoderName<$($typaram),*> - where &'_x ty::TyS<'_y>: UseSpecializedDecodable - { - fn specialized_decode(&mut self) -> Result<&'_x ty::TyS<'_y>, Self::Error> { - unsafe { - transmute::< - Result<ty::Ty<'tcx>, Self::Error>, - Result<&'_x ty::TyS<'_y>, Self::Error>, - >(decode_ty(self)) - } - } - } - - impl<'_x, $($typaram),*> SpecializedDecoder<ty::Predicate<'_x>> - for $DecoderName<$($typaram),*> { - fn specialized_decode(&mut self) -> Result<ty::Predicate<'_x>, Self::Error> { - unsafe { - transmute::< - Result<ty::Predicate<'tcx>, Self::Error>, - Result<ty::Predicate<'_x>, Self::Error>, - >(decode_predicate(self)) - } - } - } - - impl<'_x, '_y, $($typaram),*> SpecializedDecoder<&'_x [(ty::Predicate<'_y>, Span)]> - for $DecoderName<$($typaram),*> - where &'_x [(ty::Predicate<'_y>, Span)]: UseSpecializedDecodable { - fn specialized_decode(&mut self) - -> Result<&'_x [(ty::Predicate<'_y>, Span)], Self::Error> - { - unsafe { transmute(decode_spanned_predicates(self)) } - } - } - - impl<'_x, '_y, $($typaram),*> SpecializedDecoder<&'_x InternalSubsts<'_y>> - for $DecoderName<$($typaram),*> - where &'_x InternalSubsts<'_y>: UseSpecializedDecodable { - fn specialized_decode(&mut self) -> Result<&'_x InternalSubsts<'_y>, Self::Error> { - unsafe { transmute(decode_substs(self)) } - } - } - - impl<'_x, $($typaram),*> SpecializedDecoder<$crate::mir::Place<'_x>> - for $DecoderName<$($typaram),*> { - fn specialized_decode( - &mut self - ) -> Result<$crate::mir::Place<'_x>, Self::Error> { - unsafe { transmute(decode_place(self)) } - } - } - - impl<'_x, $($typaram),*> SpecializedDecoder<ty::Region<'_x>> - for $DecoderName<$($typaram),*> { - fn specialized_decode(&mut self) -> Result<ty::Region<'_x>, Self::Error> { - unsafe { transmute(decode_region(self)) } - } - } - - impl<'_x, '_y, '_z, $($typaram),*> SpecializedDecoder<&'_x ty::List<&'_y ty::TyS<'_z>>> - for $DecoderName<$($typaram),*> - where &'_x ty::List<&'_y ty::TyS<'_z>>: UseSpecializedDecodable { - fn specialized_decode(&mut self) - -> Result<&'_x ty::List<&'_y ty::TyS<'_z>>, Self::Error> { - unsafe { transmute(decode_ty_slice(self)) } - } - } - - impl<'_x, $($typaram),*> SpecializedDecoder<&'_x ty::AdtDef> - for $DecoderName<$($typaram),*> { - fn specialized_decode(&mut self) -> Result<&'_x ty::AdtDef, Self::Error> { - unsafe { transmute(decode_adt_def(self)) } - } - } - - impl<'_x, $($typaram),*> SpecializedDecoder<ty::SymbolName<'_x>> - for $DecoderName<$($typaram),*> { - fn specialized_decode(&mut self) -> Result<ty::SymbolName<'_x>, Self::Error> { - unsafe { transmute(decode_symbol_name(self)) } - } - } - - impl<'_x, '_y, $($typaram),*> SpecializedDecoder<&'_x ty::List<ty::ExistentialPredicate<'_y>>> - for $DecoderName<$($typaram),*> - where &'_x ty::List<ty::ExistentialPredicate<'_y>>: UseSpecializedDecodable { - fn specialized_decode(&mut self) - -> Result<&'_x ty::List<ty::ExistentialPredicate<'_y>>, Self::Error> { - unsafe { transmute(decode_existential_predicate_slice(self)) } - } - } - - impl<'_x, $($typaram),*> SpecializedDecoder<CanonicalVarInfos<'_x>> - for $DecoderName<$($typaram),*> { - fn specialized_decode(&mut self) - -> Result<CanonicalVarInfos<'_x>, Self::Error> { - unsafe { transmute(decode_canonical_var_infos(self)) } - } - } - - impl<'_x, '_y, $($typaram),*> SpecializedDecoder<&'_x $crate::ty::Const<'_y>> - for $DecoderName<$($typaram),*> - where &'_x $crate::ty::Const<'_y>: UseSpecializedDecodable { - fn specialized_decode(&mut self) -> Result<&'_x ty::Const<'_y>, Self::Error> { - unsafe { transmute(decode_const(self)) } - } - } - - impl<'_x, $($typaram),*> SpecializedDecoder<&'_x $crate::mir::interpret::Allocation> - for $DecoderName<$($typaram),*> { - fn specialized_decode( - &mut self - ) -> Result<&'_x $crate::mir::interpret::Allocation, Self::Error> { - unsafe { transmute(decode_allocation(self)) } - } - } } - }; + } } diff --git a/src/librustc_middle/ty/consts.rs b/src/librustc_middle/ty/consts.rs index c0b5693dc59..64faacc1c0b 100644 --- a/src/librustc_middle/ty/consts.rs +++ b/src/librustc_middle/ty/consts.rs @@ -15,7 +15,7 @@ pub use int::*; pub use kind::*; /// Typed constant value. -#[derive(Copy, Clone, Debug, Hash, RustcEncodable, RustcDecodable, Eq, PartialEq, Ord, PartialOrd)] +#[derive(Copy, Clone, Debug, Hash, TyEncodable, TyDecodable, Eq, PartialEq, Ord, PartialOrd)] #[derive(HashStable)] pub struct Const<'tcx> { pub ty: Ty<'tcx>, @@ -88,7 +88,7 @@ impl<'tcx> Const<'tcx> { ExprKind::Path(QPath::Resolved(_, &Path { res: Res::Def(ConstParam, def_id), .. })) => { // Find the name and index of the const parameter by indexing the generics of // the parent item and construct a `ParamConst`. - let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let item_id = tcx.hir().get_parent_node(hir_id); let item_def_id = tcx.hir().local_def_id(item_id); let generics = tcx.generics_of(item_def_id.to_def_id()); diff --git a/src/librustc_middle/ty/consts/kind.rs b/src/librustc_middle/ty/consts/kind.rs index e8a1e714a8f..a4c177160f5 100644 --- a/src/librustc_middle/ty/consts/kind.rs +++ b/src/librustc_middle/ty/consts/kind.rs @@ -10,7 +10,7 @@ use rustc_macros::HashStable; use rustc_target::abi::Size; /// Represents a constant in Rust. -#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Hash)] +#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, TyEncodable, TyDecodable, Hash)] #[derive(HashStable)] pub enum ConstKind<'tcx> { /// A const generic parameter. @@ -68,7 +68,7 @@ impl<'tcx> ConstKind<'tcx> { } /// An inference variable for a const, for use in const generics. -#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Hash)] +#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, TyEncodable, TyDecodable, Hash)] #[derive(HashStable)] pub enum InferConst<'tcx> { /// Infer the value of the const. diff --git a/src/librustc_middle/ty/context.rs b/src/librustc_middle/ty/context.rs index d6bcfbf49cf..6887f729322 100644 --- a/src/librustc_middle/ty/context.rs +++ b/src/librustc_middle/ty/context.rs @@ -263,7 +263,7 @@ impl<'a, V> LocalTableInContextMut<'a, V> { } /// All information necessary to validate and reveal an `impl Trait`. -#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)] +#[derive(TyEncodable, TyDecodable, Debug, HashStable)] pub struct ResolvedOpaqueTy<'tcx> { /// The revealed type as seen by this function. pub concrete_type: Ty<'tcx>, @@ -291,7 +291,7 @@ pub struct ResolvedOpaqueTy<'tcx> { /// /// Here, we would store the type `T`, the span of the value `x`, the "scope-span" for /// the scope that contains `x`, the expr `T` evaluated from, and the span of `foo.await`. -#[derive(RustcEncodable, RustcDecodable, Clone, Debug, Eq, Hash, PartialEq, HashStable)] +#[derive(TyEncodable, TyDecodable, Clone, Debug, Eq, Hash, PartialEq, HashStable)] pub struct GeneratorInteriorTypeCause<'tcx> { /// Type of the captured binding. pub ty: Ty<'tcx>, @@ -305,7 +305,7 @@ pub struct GeneratorInteriorTypeCause<'tcx> { pub expr: Option<hir::HirId>, } -#[derive(RustcEncodable, RustcDecodable, Debug)] +#[derive(TyEncodable, TyDecodable, Debug)] pub struct TypeckResults<'tcx> { /// The `HirId::owner` all `ItemLocalId`s in this table are relative to. pub hir_owner: LocalDefId, @@ -728,7 +728,7 @@ rustc_index::newtype_index! { pub type CanonicalUserTypeAnnotations<'tcx> = IndexVec<UserTypeAnnotationIndex, CanonicalUserTypeAnnotation<'tcx>>; -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable, Lift)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable, Lift)] pub struct CanonicalUserTypeAnnotation<'tcx> { pub user_ty: CanonicalUserType<'tcx>, pub span: Span, @@ -787,7 +787,7 @@ impl CanonicalUserType<'tcx> { /// A user-given type annotation attached to a constant. These arise /// from constants that are named via paths, like `Foo::<A>::new` and /// so forth. -#[derive(Copy, Clone, Debug, PartialEq, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, PartialEq, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable, Lift)] pub enum UserType<'tcx> { Ty(Ty<'tcx>), @@ -1333,7 +1333,7 @@ impl<'tcx> TyCtxt<'tcx> { pub fn serialize_query_result_cache<E>(self, encoder: &mut E) -> Result<(), E::Error> where - E: ty::codec::TyEncoder, + E: ty::codec::OpaqueEncoder, { self.queries.on_disk_cache.serialize(self, encoder) } @@ -1420,7 +1420,7 @@ impl<'tcx> TyCtxt<'tcx> { _ => return None, // not a free region }; - let hir_id = self.hir().as_local_hir_id(suitable_region_binding_scope); + let hir_id = self.hir().local_def_id_to_hir_id(suitable_region_binding_scope); let is_impl_item = match self.hir().find(hir_id) { Some(Node::Item(..) | Node::TraitItem(..)) => false, Some(Node::ImplItem(..)) => { @@ -1441,7 +1441,7 @@ impl<'tcx> TyCtxt<'tcx> { &self, scope_def_id: LocalDefId, ) -> Vec<&'tcx hir::Ty<'tcx>> { - let hir_id = self.hir().as_local_hir_id(scope_def_id); + let hir_id = self.hir().local_def_id_to_hir_id(scope_def_id); let hir_output = match self.hir().get(hir_id) { Node::Item(hir::Item { kind: @@ -1486,7 +1486,7 @@ impl<'tcx> TyCtxt<'tcx> { pub fn return_type_impl_trait(&self, scope_def_id: LocalDefId) -> Option<(Ty<'tcx>, Span)> { // HACK: `type_of_def_id()` will fail on these (#55796), so return `None`. - let hir_id = self.hir().as_local_hir_id(scope_def_id); + let hir_id = self.hir().local_def_id_to_hir_id(scope_def_id); match self.hir().get(hir_id) { Node::Item(item) => { match item.kind { diff --git a/src/librustc_middle/ty/error.rs b/src/librustc_middle/ty/error.rs index 30ff5a2d9eb..438da832226 100644 --- a/src/librustc_middle/ty/error.rs +++ b/src/librustc_middle/ty/error.rs @@ -403,7 +403,7 @@ impl<'tcx> TyCtxt<'tcx> { .type_param(p, self) .def_id .as_local() - .map(|id| hir.as_local_hir_id(id)) + .map(|id| hir.local_def_id_to_hir_id(id)) .and_then(|id| self.hir().find(self.hir().get_parent_node(id))) .as_ref() .and_then(|node| node.generics()) @@ -791,10 +791,11 @@ fn foo(&self) -> Self::T { String::new() } body_owner_def_id: DefId, found: Ty<'tcx>, ) -> bool { - let hir_id = match body_owner_def_id.as_local().map(|id| self.hir().as_local_hir_id(id)) { - Some(hir_id) => hir_id, - None => return false, - }; + let hir_id = + match body_owner_def_id.as_local().map(|id| self.hir().local_def_id_to_hir_id(id)) { + Some(hir_id) => hir_id, + None => return false, + }; // When `body_owner` is an `impl` or `trait` item, look in its associated types for // `expected` and point at it. let parent_id = self.hir().get_parent_item(hir_id); diff --git a/src/librustc_middle/ty/fast_reject.rs b/src/librustc_middle/ty/fast_reject.rs index b0fb179b18b..7456020ee9b 100644 --- a/src/librustc_middle/ty/fast_reject.rs +++ b/src/librustc_middle/ty/fast_reject.rs @@ -17,7 +17,7 @@ pub type SimplifiedType = SimplifiedTypeGen<DefId>; /// because we sometimes need to use SimplifiedTypeGen values as stable sorting /// keys (in which case we use a DefPathHash as id-type) but in the general case /// the non-stable but fast to construct DefId-version is the better choice. -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, TyEncodable, TyDecodable)] pub enum SimplifiedTypeGen<D> where D: Copy + Debug + Ord + Eq, diff --git a/src/librustc_middle/ty/instance.rs b/src/librustc_middle/ty/instance.rs index 2def000da64..e6dafd4965b 100644 --- a/src/librustc_middle/ty/instance.rs +++ b/src/librustc_middle/ty/instance.rs @@ -15,14 +15,14 @@ use std::fmt; /// Monomorphization happens on-the-fly and no monomorphized MIR is ever created. Instead, this type /// simply couples a potentially generic `InstanceDef` with some substs, and codegen and const eval /// will do all required substitution as they run. -#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, TyEncodable, TyDecodable)] #[derive(HashStable, Lift)] pub struct Instance<'tcx> { pub def: InstanceDef<'tcx>, pub substs: SubstsRef<'tcx>, } -#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, TyEncodable, TyDecodable, HashStable)] pub enum InstanceDef<'tcx> { /// A user-defined callable item. /// diff --git a/src/librustc_middle/ty/layout.rs b/src/librustc_middle/ty/layout.rs index 5aa94ba3d09..16e65d2cca4 100644 --- a/src/librustc_middle/ty/layout.rs +++ b/src/librustc_middle/ty/layout.rs @@ -165,7 +165,7 @@ pub const FAT_PTR_ADDR: usize = 0; /// - For a slice, this is the length. pub const FAT_PTR_EXTRA: usize = 1; -#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, TyEncodable, TyDecodable)] pub enum LayoutError<'tcx> { Unknown(Ty<'tcx>), SizeOverflow(Ty<'tcx>), diff --git a/src/librustc_middle/ty/list.rs b/src/librustc_middle/ty/list.rs index 92d6dbb5f90..fe390adf89f 100644 --- a/src/librustc_middle/ty/list.rs +++ b/src/librustc_middle/ty/list.rs @@ -76,9 +76,16 @@ impl<T: fmt::Debug> fmt::Debug for List<T> { } } -impl<T: Encodable> Encodable for List<T> { +impl<S: Encoder, T: Encodable<S>> Encodable<S> for List<T> { #[inline] - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + (**self).encode(s) + } +} + +impl<S: Encoder, T: Encodable<S>> Encodable<S> for &List<T> { + #[inline] + fn encode(&self, s: &mut S) -> Result<(), S::Error> { (**self).encode(s) } } diff --git a/src/librustc_middle/ty/mod.rs b/src/librustc_middle/ty/mod.rs index 6798addb8aa..62a62085c66 100644 --- a/src/librustc_middle/ty/mod.rs +++ b/src/librustc_middle/ty/mod.rs @@ -89,12 +89,11 @@ pub use self::query::queries; pub use self::consts::{Const, ConstInt, ConstKind, InferConst}; +pub mod _match; pub mod adjustment; pub mod binding; pub mod cast; -#[macro_use] pub mod codec; -pub mod _match; mod erase_regions; pub mod error; pub mod fast_reject; @@ -171,7 +170,7 @@ pub struct ImplHeader<'tcx> { pub predicates: Vec<Predicate<'tcx>>, } -#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable)] pub enum ImplPolarity { /// `impl Trait for Type` Positive, @@ -316,7 +315,7 @@ impl<'tcx> AssociatedItems<'tcx> { } } -#[derive(Clone, Debug, PartialEq, Eq, Copy, RustcEncodable, RustcDecodable, HashStable, Hash)] +#[derive(Clone, Debug, PartialEq, Eq, Copy, Hash, TyEncodable, TyDecodable, HashStable)] pub enum Visibility { /// Visible everywhere (including in other crates). Public, @@ -403,7 +402,7 @@ impl Visibility { } } -#[derive(Copy, Clone, PartialEq, RustcDecodable, RustcEncodable, HashStable)] +#[derive(Copy, Clone, PartialEq, TyDecodable, TyEncodable, HashStable)] pub enum Variance { Covariant, // T<A> <: T<B> iff A <: B -- e.g., function return type Invariant, // T<A> <: T<B> iff B == A -- e.g., type of mutable cell @@ -652,13 +651,9 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for TyS<'tcx> { #[rustc_diagnostic_item = "Ty"] pub type Ty<'tcx> = &'tcx TyS<'tcx>; -impl<'tcx> rustc_serialize::UseSpecializedEncodable for Ty<'tcx> {} -impl<'tcx> rustc_serialize::UseSpecializedDecodable for Ty<'tcx> {} -impl<'tcx> rustc_serialize::UseSpecializedDecodable for &'tcx List<Ty<'tcx>> {} - pub type CanonicalTy<'tcx> = Canonical<'tcx, Ty<'tcx>>; -#[derive(Clone, Copy, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable, HashStable)] pub struct UpvarPath { pub hir_id: hir::HirId, } @@ -666,13 +661,13 @@ pub struct UpvarPath { /// Upvars do not get their own `NodeId`. Instead, we use the pair of /// the original var ID (that is, the root variable that is referenced /// by the upvar) and the ID of the closure expression. -#[derive(Clone, Copy, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable, HashStable)] pub struct UpvarId { pub var_path: UpvarPath, pub closure_expr_id: LocalDefId, } -#[derive(Clone, PartialEq, Debug, RustcEncodable, RustcDecodable, Copy, HashStable)] +#[derive(Clone, PartialEq, Debug, TyEncodable, TyDecodable, Copy, HashStable)] pub enum BorrowKind { /// Data must be immutable and is aliasable. ImmBorrow, @@ -720,7 +715,7 @@ pub enum BorrowKind { /// Information describing the capture of an upvar. This is computed /// during `typeck`, specifically by `regionck`. -#[derive(PartialEq, Clone, Debug, Copy, RustcEncodable, RustcDecodable, HashStable)] +#[derive(PartialEq, Clone, Debug, Copy, TyEncodable, TyDecodable, HashStable)] pub enum UpvarCapture<'tcx> { /// Upvar is captured by value. This is always true when the /// closure is labeled `move`, but can also be true in other cases @@ -731,7 +726,7 @@ pub enum UpvarCapture<'tcx> { ByRef(UpvarBorrow<'tcx>), } -#[derive(PartialEq, Clone, Copy, RustcEncodable, RustcDecodable, HashStable)] +#[derive(PartialEq, Clone, Copy, TyEncodable, TyDecodable, HashStable)] pub struct UpvarBorrow<'tcx> { /// The kind of borrow: by-ref upvars have access to shared /// immutable borrows, which are not part of the normal language @@ -766,7 +761,7 @@ impl ty::EarlyBoundRegion { } } -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable)] pub enum GenericParamDefKind { Lifetime, Type { @@ -787,7 +782,7 @@ impl GenericParamDefKind { } } -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable)] pub struct GenericParamDef { pub name: Symbol, pub def_id: DefId, @@ -831,7 +826,7 @@ pub struct GenericParamCount { /// /// The ordering of parameters is the same as in `Subst` (excluding child generics): /// `Self` (optionally), `Lifetime` params..., `Type` params... -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable)] pub struct Generics { pub parent: Option<DefId>, pub parent_count: usize, @@ -933,7 +928,7 @@ impl<'tcx> Generics { } /// Bounds on generics. -#[derive(Copy, Clone, Default, Debug, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, Default, Debug, TyEncodable, TyDecodable, HashStable)] pub struct GenericPredicates<'tcx> { pub parent: Option<DefId>, pub predicates: &'tcx [(Predicate<'tcx>, Span)], @@ -1025,9 +1020,6 @@ pub struct Predicate<'tcx> { inner: &'tcx PredicateInner<'tcx>, } -impl rustc_serialize::UseSpecializedEncodable for Predicate<'_> {} -impl rustc_serialize::UseSpecializedDecodable for Predicate<'_> {} - impl<'tcx> PartialEq for Predicate<'tcx> { fn eq(&self, other: &Self) -> bool { // `self.kind` is always interned. @@ -1103,7 +1095,7 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Predicate<'tcx> { } } -#[derive(Clone, Copy, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable)] pub enum PredicateKind<'tcx> { /// `for<'a>: ...` @@ -1111,7 +1103,7 @@ pub enum PredicateKind<'tcx> { Atom(PredicateAtom<'tcx>), } -#[derive(Clone, Copy, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable)] pub enum PredicateAtom<'tcx> { /// Corresponds to `where Foo: Bar<A, B, C>`. `Foo` here would be @@ -1261,7 +1253,7 @@ impl<'tcx> Predicate<'tcx> { } } -#[derive(Clone, Copy, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable)] pub struct TraitPredicate<'tcx> { pub trait_ref: TraitRef<'tcx>, @@ -1286,7 +1278,7 @@ impl<'tcx> PolyTraitPredicate<'tcx> { } } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable)] pub struct OutlivesPredicate<A, B>(pub A, pub B); // `A: B` pub type PolyOutlivesPredicate<A, B> = ty::Binder<OutlivesPredicate<A, B>>; @@ -1295,7 +1287,7 @@ pub type TypeOutlivesPredicate<'tcx> = OutlivesPredicate<Ty<'tcx>, ty::Region<'t pub type PolyRegionOutlivesPredicate<'tcx> = ty::Binder<RegionOutlivesPredicate<'tcx>>; pub type PolyTypeOutlivesPredicate<'tcx> = ty::Binder<TypeOutlivesPredicate<'tcx>>; -#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable)] pub struct SubtypePredicate<'tcx> { pub a_is_expected: bool, @@ -1316,7 +1308,7 @@ pub type PolySubtypePredicate<'tcx> = ty::Binder<SubtypePredicate<'tcx>>; /// equality between arbitrary types. Processing an instance of /// Form #2 eventually yields one of these `ProjectionPredicate` /// instances to normalize the LHS. -#[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable)] pub struct ProjectionPredicate<'tcx> { pub projection_ty: ProjectionTy<'tcx>, @@ -1585,7 +1577,7 @@ impl UniverseIndex { /// basically a name -- distinct bound regions within the same /// universe are just two regions with an unknown relationship to one /// another. -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, PartialOrd, Ord)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable, PartialOrd, Ord)] pub struct Placeholder<T> { pub universe: UniverseIndex, pub name: T, @@ -1635,7 +1627,7 @@ pub type PlaceholderConst = Placeholder<BoundVar>; /// a.foo::<7>(); /// } /// ``` -#[derive(Copy, Clone, Debug, TypeFoldable, Lift, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, TypeFoldable, Lift, TyEncodable, TyDecodable)] #[derive(PartialEq, Eq, PartialOrd, Ord)] #[derive(Hash, HashStable)] pub struct WithOptConstParam<T> { @@ -2106,7 +2098,7 @@ impl<'tcx> VariantDef { } } -#[derive(Copy, Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, TyEncodable, TyDecodable, HashStable)] pub enum VariantDiscr { /// Explicit value for this variant, i.e., `X = 123`. /// The `DefId` corresponds to the embedded constant. @@ -2178,14 +2170,12 @@ impl Hash for AdtDef { } } -impl<'tcx> rustc_serialize::UseSpecializedEncodable for &'tcx AdtDef { - fn default_encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder> Encodable<S> for AdtDef { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { self.did.encode(s) } } -impl<'tcx> rustc_serialize::UseSpecializedDecodable for &'tcx AdtDef {} - impl<'a> HashStable<StableHashingContext<'a>> for AdtDef { fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { thread_local! { @@ -2229,7 +2219,7 @@ impl Into<DataTypeKind> for AdtKind { } bitflags! { - #[derive(RustcEncodable, RustcDecodable, Default, HashStable)] + #[derive(TyEncodable, TyDecodable, Default, HashStable)] pub struct ReprFlags: u8 { const IS_C = 1 << 0; const IS_SIMD = 1 << 1; @@ -2246,7 +2236,7 @@ bitflags! { } /// Represents the repr options provided by the user, -#[derive(Copy, Clone, Debug, Eq, PartialEq, RustcEncodable, RustcDecodable, Default, HashStable)] +#[derive(Copy, Clone, Debug, Eq, PartialEq, TyEncodable, TyDecodable, Default, HashStable)] pub struct ReprOptions { pub int: Option<attr::IntType>, pub align: Option<Align>, @@ -2690,7 +2680,7 @@ impl<'tcx> FieldDef { /// /// You can get the environment type of a closure using /// `tcx.closure_env_ty()`. -#[derive(Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash, Debug, TyEncodable, TyDecodable)] #[derive(HashStable)] pub enum ClosureKind { // Warning: Ordering is significant here! The ordering is chosen @@ -2845,12 +2835,12 @@ impl<'tcx> TyCtxt<'tcx> { pub fn opt_item_name(self, def_id: DefId) -> Option<Ident> { def_id .as_local() - .and_then(|def_id| self.hir().get(self.hir().as_local_hir_id(def_id)).ident()) + .and_then(|def_id| self.hir().get(self.hir().local_def_id_to_hir_id(def_id)).ident()) } pub fn opt_associated_item(self, def_id: DefId) -> Option<&'tcx AssocItem> { let is_associated_item = if let Some(def_id) = def_id.as_local() { - match self.hir().get(self.hir().as_local_hir_id(def_id)) { + match self.hir().get(self.hir().local_def_id_to_hir_id(def_id)) { Node::TraitItem(_) | Node::ImplItem(_) => true, _ => false, } @@ -3009,7 +2999,7 @@ impl<'tcx> TyCtxt<'tcx> { /// Gets the attributes of a definition. pub fn get_attrs(self, did: DefId) -> Attributes<'tcx> { if let Some(did) = did.as_local() { - self.hir().attrs(self.hir().as_local_hir_id(did)) + self.hir().attrs(self.hir().local_def_id_to_hir_id(did)) } else { self.item_attrs(did) } @@ -3048,7 +3038,7 @@ impl<'tcx> TyCtxt<'tcx> { /// with the name of the crate containing the impl. pub fn span_of_impl(self, impl_did: DefId) -> Result<Span, Symbol> { if let Some(impl_did) = impl_did.as_local() { - let hir_id = self.hir().as_local_hir_id(impl_did); + let hir_id = self.hir().local_def_id_to_hir_id(impl_did); Ok(self.hir().span(hir_id)) } else { Err(self.crate_name(impl_did.krate)) @@ -3109,7 +3099,7 @@ pub struct AdtSizedConstraint<'tcx>(pub &'tcx [Ty<'tcx>]); /// Yields the parent function's `DefId` if `def_id` is an `impl Trait` definition. pub fn is_impl_trait_defn(tcx: TyCtxt<'_>, def_id: DefId) -> Option<DefId> { if let Some(def_id) = def_id.as_local() { - if let Node::Item(item) = tcx.hir().get(tcx.hir().as_local_hir_id(def_id)) { + if let Node::Item(item) = tcx.hir().get(tcx.hir().local_def_id_to_hir_id(def_id)) { if let hir::ItemKind::OpaqueTy(ref opaque_ty) = item.kind { return opaque_ty.impl_trait_fn; } @@ -3141,7 +3131,7 @@ pub struct CrateInherentImpls { pub inherent_impls: DefIdMap<Vec<DefId>>, } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, HashStable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, HashStable)] pub struct SymbolName<'tcx> { /// `&str` gives a consistent ordering, which ensures reproducible builds. pub name: &'tcx str, @@ -3166,12 +3156,3 @@ impl<'tcx> fmt::Debug for SymbolName<'tcx> { fmt::Display::fmt(&self.name, fmt) } } - -impl<'tcx> rustc_serialize::UseSpecializedEncodable for SymbolName<'tcx> { - fn default_encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_str(self.name) - } -} - -// The decoding takes place in `decode_symbol_name()`. -impl<'tcx> rustc_serialize::UseSpecializedDecodable for SymbolName<'tcx> {} diff --git a/src/librustc_middle/ty/print/pretty.rs b/src/librustc_middle/ty/print/pretty.rs index 87944db60de..fc444d4cc5b 100644 --- a/src/librustc_middle/ty/print/pretty.rs +++ b/src/librustc_middle/ty/print/pretty.rs @@ -610,7 +610,7 @@ pub trait PrettyPrinter<'tcx>: // FIXME(eddyb) should use `def_span`. if let Some(did) = did.as_local() { - let hir_id = self.tcx().hir().as_local_hir_id(did); + let hir_id = self.tcx().hir().local_def_id_to_hir_id(did); let span = self.tcx().hir().span(hir_id); p!(write("@{}", self.tcx().sess.source_map().span_to_string(span))); @@ -656,7 +656,7 @@ pub trait PrettyPrinter<'tcx>: // FIXME(eddyb) should use `def_span`. if let Some(did) = did.as_local() { - let hir_id = self.tcx().hir().as_local_hir_id(did); + let hir_id = self.tcx().hir().local_def_id_to_hir_id(did); if self.tcx().sess.opts.debugging_opts.span_free_formats { p!(write("@"), print_def_path(did.to_def_id(), substs)); } else { diff --git a/src/librustc_middle/ty/query/on_disk_cache.rs b/src/librustc_middle/ty/query/on_disk_cache.rs index 08b0bfecf49..007b46b1176 100644 --- a/src/librustc_middle/ty/query/on_disk_cache.rs +++ b/src/librustc_middle/ty/query/on_disk_cache.rs @@ -1,28 +1,24 @@ use crate::dep_graph::{DepNodeIndex, SerializedDepNodeIndex}; -use crate::mir::interpret; use crate::mir::interpret::{AllocDecodingSession, AllocDecodingState}; -use crate::ty::codec::{self as ty_codec, TyDecoder, TyEncoder}; +use crate::mir::{self, interpret}; +use crate::ty::codec::{OpaqueEncoder, RefDecodable, TyDecoder, TyEncoder}; use crate::ty::context::TyCtxt; use crate::ty::{self, Ty}; -use rustc_data_structures::fingerprint::Fingerprint; -use rustc_data_structures::fx::{FxHashMap, FxIndexSet}; +use rustc_data_structures::fingerprint::{Fingerprint, FingerprintDecoder, FingerprintEncoder}; +use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet}; use rustc_data_structures::sync::{HashMapExt, Lock, Lrc, OnceCell}; use rustc_data_structures::thin_vec::ThinVec; use rustc_errors::Diagnostic; use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LocalDefId, LOCAL_CRATE}; use rustc_hir::definitions::DefPathHash; use rustc_index::vec::{Idx, IndexVec}; -use rustc_serialize::{ - opaque, Decodable, Decoder, Encodable, Encoder, SpecializedDecoder, SpecializedEncoder, - UseSpecializedDecodable, UseSpecializedEncodable, -}; +use rustc_serialize::{opaque, Decodable, Decoder, Encodable, Encoder}; use rustc_session::{CrateDisambiguator, Session}; use rustc_span::hygiene::{ ExpnDataDecodeMode, ExpnDataEncodeMode, ExpnId, HygieneDecodeContext, HygieneEncodeContext, SyntaxContext, SyntaxContextData, }; use rustc_span::source_map::{SourceMap, StableSourceFileId}; -use rustc_span::symbol::Ident; use rustc_span::CachingSourceMapView; use rustc_span::{BytePos, ExpnData, SourceFile, Span, DUMMY_SP}; use std::mem; @@ -87,7 +83,7 @@ pub struct OnDiskCache<'sess> { } // This type is used only for serialization and deserialization. -#[derive(RustcEncodable, RustcDecodable)] +#[derive(Encodable, Decodable)] struct Footer { file_index_to_stable_id: FxHashMap<SourceFileIndex, StableSourceFileId>, prev_cnums: Vec<(u32, String, CrateDisambiguator)>, @@ -105,10 +101,10 @@ type EncodedQueryResultIndex = Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>; type EncodedDiagnosticsIndex = Vec<(SerializedDepNodeIndex, AbsoluteBytePos)>; type EncodedDiagnostics = Vec<Diagnostic>; -#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Encodable, Decodable)] struct SourceFileIndex(u32); -#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Encodable, Decodable)] struct AbsoluteBytePos(u32); impl AbsoluteBytePos { @@ -182,7 +178,7 @@ impl<'sess> OnDiskCache<'sess> { pub fn serialize<'tcx, E>(&self, tcx: TyCtxt<'tcx>, encoder: &mut E) -> Result<(), E::Error> where - E: TyEncoder, + E: OpaqueEncoder, { // Serializing the `DepGraph` should not modify it. tcx.dep_graph.with_ignore(|| { @@ -333,7 +329,7 @@ impl<'sess> OnDiskCache<'sess> { // Encode the position of the footer as the last 8 bytes of the // file so we know where to look for it. - IntEncodedWithFixedSize(footer_pos).encode(encoder.encoder)?; + IntEncodedWithFixedSize(footer_pos).encode(encoder.encoder.opaque())?; // DO NOT WRITE ANYTHING TO THE ENCODER AFTER THIS POINT! The address // of the footer must be the last thing in the data stream. @@ -380,13 +376,13 @@ impl<'sess> OnDiskCache<'sess> { /// Returns the cached query result if there is something in the cache for /// the given `SerializedDepNodeIndex`; otherwise returns `None`. - pub fn try_load_query_result<T>( + crate fn try_load_query_result<'tcx, T>( &self, - tcx: TyCtxt<'_>, + tcx: TyCtxt<'tcx>, dep_node_index: SerializedDepNodeIndex, ) -> Option<T> where - T: Decodable, + T: for<'a> Decodable<CacheDecoder<'a, 'tcx>>, { self.load_indexed(tcx, dep_node_index, &self.query_result_index, "query result") } @@ -417,7 +413,7 @@ impl<'sess> OnDiskCache<'sess> { debug_tag: &'static str, ) -> Option<T> where - T: Decodable, + T: for<'a> Decodable<CacheDecoder<'a, 'tcx>>, { let pos = index.get(&dep_node_index).cloned()?; @@ -427,14 +423,14 @@ impl<'sess> OnDiskCache<'sess> { }) } - fn with_decoder<'tcx, T, F: FnOnce(&mut CacheDecoder<'sess, 'tcx>) -> T>( + fn with_decoder<'a, 'tcx, T, F: FnOnce(&mut CacheDecoder<'sess, 'tcx>) -> T>( &'sess self, tcx: TyCtxt<'tcx>, pos: AbsoluteBytePos, f: F, ) -> T where - T: Decodable, + T: Decodable<CacheDecoder<'a, 'tcx>>, { let cnum_map = self.cnum_map.get_or_init(|| Self::compute_cnum_map(tcx, &self.prev_cnums[..])); @@ -492,7 +488,7 @@ impl<'sess> OnDiskCache<'sess> { /// A decoder that can read from the incr. comp. cache. It is similar to the one /// we use for crate metadata decoding in that it can rebase spans and eventually /// will also handle things that contain `Ty` instances. -struct CacheDecoder<'a, 'tcx> { +crate struct CacheDecoder<'a, 'tcx> { tcx: TyCtxt<'tcx>, opaque: opaque::Decoder<'a>, source_map: &'a SourceMap, @@ -547,8 +543,8 @@ impl<'a, 'tcx> DecoderWithPosition for CacheDecoder<'a, 'tcx> { // tag matches and the correct amount of bytes was read. fn decode_tagged<D, T, V>(decoder: &mut D, expected_tag: T) -> Result<V, D::Error> where - T: Decodable + Eq + ::std::fmt::Debug, - V: Decodable, + T: Decodable<D> + Eq + ::std::fmt::Debug, + V: Decodable<D>, D: DecoderWithPosition, { let start_pos = decoder.position(); @@ -565,6 +561,8 @@ where } impl<'a, 'tcx> TyDecoder<'tcx> for CacheDecoder<'a, 'tcx> { + const CLEAR_CROSS_CRATE: bool = false; + #[inline] fn tcx(&self) -> TyCtxt<'tcx> { self.tcx @@ -642,14 +640,19 @@ impl<'a, 'tcx> TyDecoder<'tcx> for CacheDecoder<'a, 'tcx> { fn map_encoded_cnum_to_current(&self, cnum: CrateNum) -> CrateNum { self.cnum_map[cnum].unwrap_or_else(|| bug!("could not find new `CrateNum` for {:?}", cnum)) } + + fn decode_alloc_id(&mut self) -> Result<interpret::AllocId, Self::Error> { + let alloc_decoding_session = self.alloc_decoding_session; + alloc_decoding_session.decode_alloc_id(self) + } } -implement_ty_decoder!(CacheDecoder<'a, 'tcx>); +crate::implement_ty_decoder!(CacheDecoder<'a, 'tcx>); -impl<'a, 'tcx> SpecializedDecoder<SyntaxContext> for CacheDecoder<'a, 'tcx> { - fn specialized_decode(&mut self) -> Result<SyntaxContext, Self::Error> { - let syntax_contexts = self.syntax_contexts; - rustc_span::hygiene::decode_syntax_context(self, self.hygiene_context, |this, id| { +impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for SyntaxContext { + fn decode(decoder: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> { + let syntax_contexts = decoder.syntax_contexts; + rustc_span::hygiene::decode_syntax_context(decoder, decoder.hygiene_context, |this, id| { // This closure is invoked if we haven't already decoded the data for the `SyntaxContext` we are deserializing. // We look up the position of the associated `SyntaxData` and decode it. let pos = syntax_contexts.get(&id).unwrap(); @@ -661,12 +664,12 @@ impl<'a, 'tcx> SpecializedDecoder<SyntaxContext> for CacheDecoder<'a, 'tcx> { } } -impl<'a, 'tcx> SpecializedDecoder<ExpnId> for CacheDecoder<'a, 'tcx> { - fn specialized_decode(&mut self) -> Result<ExpnId, Self::Error> { - let expn_data = self.expn_data; +impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for ExpnId { + fn decode(decoder: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> { + let expn_data = decoder.expn_data; rustc_span::hygiene::decode_expn_id( - self, - ExpnDataDecodeMode::incr_comp(self.hygiene_context), + decoder, + ExpnDataDecodeMode::incr_comp(decoder.hygiene_context), |this, index| { // This closure is invoked if we haven't already decoded the data for the `ExpnId` we are deserializing. // We look up the position of the associated `ExpnData` and decode it. @@ -683,16 +686,9 @@ impl<'a, 'tcx> SpecializedDecoder<ExpnId> for CacheDecoder<'a, 'tcx> { } } -impl<'a, 'tcx> SpecializedDecoder<interpret::AllocId> for CacheDecoder<'a, 'tcx> { - fn specialized_decode(&mut self) -> Result<interpret::AllocId, Self::Error> { - let alloc_decoding_session = self.alloc_decoding_session; - alloc_decoding_session.decode_alloc_id(self) - } -} - -impl<'a, 'tcx> SpecializedDecoder<Span> for CacheDecoder<'a, 'tcx> { - fn specialized_decode(&mut self) -> Result<Span, Self::Error> { - let tag: u8 = Decodable::decode(self)?; +impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for Span { + fn decode(decoder: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> { + let tag: u8 = Decodable::decode(decoder)?; if tag == TAG_INVALID_SPAN { return Ok(DUMMY_SP); @@ -700,13 +696,13 @@ impl<'a, 'tcx> SpecializedDecoder<Span> for CacheDecoder<'a, 'tcx> { debug_assert_eq!(tag, TAG_VALID_SPAN); } - let file_lo_index = SourceFileIndex::decode(self)?; - let line_lo = usize::decode(self)?; - let col_lo = BytePos::decode(self)?; - let len = BytePos::decode(self)?; - let ctxt = SyntaxContext::decode(self)?; + let file_lo_index = SourceFileIndex::decode(decoder)?; + let line_lo = usize::decode(decoder)?; + let col_lo = BytePos::decode(decoder)?; + let len = BytePos::decode(decoder)?; + let ctxt = SyntaxContext::decode(decoder)?; - let file_lo = self.file_index_to_file(file_lo_index); + let file_lo = decoder.file_index_to_file(file_lo_index); let lo = file_lo.lines[line_lo - 1] + col_lo; let hi = lo + len; @@ -714,10 +710,10 @@ impl<'a, 'tcx> SpecializedDecoder<Span> for CacheDecoder<'a, 'tcx> { } } -impl<'a, 'tcx> SpecializedDecoder<Ident> for CacheDecoder<'a, 'tcx> { - fn specialized_decode(&mut self) -> Result<Ident, Self::Error> { - // FIXME: Handle hygiene in incremental - bug!("Trying to decode Ident for incremental"); +impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for CrateNum { + fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> { + let cnum = CrateNum::from_u32(u32::decode(d)?); + Ok(d.map_encoded_cnum_to_current(cnum)) } } @@ -725,43 +721,69 @@ impl<'a, 'tcx> SpecializedDecoder<Ident> for CacheDecoder<'a, 'tcx> { // `DefIndex` that is not contained in a `DefId`. Such a case would be problematic // because we would not know how to transform the `DefIndex` to the current // context. -impl<'a, 'tcx> SpecializedDecoder<DefIndex> for CacheDecoder<'a, 'tcx> { - fn specialized_decode(&mut self) -> Result<DefIndex, Self::Error> { - bug!("trying to decode `DefIndex` outside the context of a `DefId`") +impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for DefIndex { + fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<DefIndex, String> { + Err(d.error("trying to decode `DefIndex` outside the context of a `DefId`")) } } // Both the `CrateNum` and the `DefIndex` of a `DefId` can change in between two // compilation sessions. We use the `DefPathHash`, which is stable across // sessions, to map the old `DefId` to the new one. -impl<'a, 'tcx> SpecializedDecoder<DefId> for CacheDecoder<'a, 'tcx> { - #[inline] - fn specialized_decode(&mut self) -> Result<DefId, Self::Error> { +impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for DefId { + fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> { // Load the `DefPathHash` which is was we encoded the `DefId` as. - let def_path_hash = DefPathHash::decode(self)?; + let def_path_hash = DefPathHash::decode(d)?; // Using the `DefPathHash`, we can lookup the new `DefId`. - Ok(self.tcx().def_path_hash_to_def_id.as_ref().unwrap()[&def_path_hash]) + Ok(d.tcx().def_path_hash_to_def_id.as_ref().unwrap()[&def_path_hash]) } } -impl<'a, 'tcx> SpecializedDecoder<LocalDefId> for CacheDecoder<'a, 'tcx> { - #[inline] - fn specialized_decode(&mut self) -> Result<LocalDefId, Self::Error> { - Ok(DefId::decode(self)?.expect_local()) +impl<'a, 'tcx> FingerprintDecoder for CacheDecoder<'a, 'tcx> { + fn decode_fingerprint(&mut self) -> Result<Fingerprint, Self::Error> { + Fingerprint::decode_opaque(&mut self.opaque) } } -impl<'a, 'tcx> SpecializedDecoder<Fingerprint> for CacheDecoder<'a, 'tcx> { - fn specialized_decode(&mut self) -> Result<Fingerprint, Self::Error> { - Fingerprint::decode_opaque(&mut self.opaque) +impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx FxHashSet<LocalDefId> { + fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> { + RefDecodable::decode(d) + } +} + +impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> + for &'tcx IndexVec<mir::Promoted, mir::Body<'tcx>> +{ + fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> { + RefDecodable::decode(d) + } +} + +impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx [(ty::Predicate<'tcx>, Span)] { + fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> { + RefDecodable::decode(d) + } +} + +impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> + for &'tcx [rustc_ast::ast::InlineAsmTemplatePiece] +{ + fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> { + RefDecodable::decode(d) + } +} + +impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for &'tcx [Span] { + fn decode(d: &mut CacheDecoder<'a, 'tcx>) -> Result<Self, String> { + RefDecodable::decode(d) } } //- ENCODING ------------------------------------------------------------------- /// An encoder that can write the incr. comp. cache. -struct CacheEncoder<'a, 'tcx, E: ty_codec::TyEncoder> { +struct CacheEncoder<'a, 'tcx, E: OpaqueEncoder> { tcx: TyCtxt<'tcx>, encoder: &'a mut E, type_shorthands: FxHashMap<Ty<'tcx>, usize>, @@ -774,7 +796,7 @@ struct CacheEncoder<'a, 'tcx, E: ty_codec::TyEncoder> { impl<'a, 'tcx, E> CacheEncoder<'a, 'tcx, E> where - E: 'a + TyEncoder, + E: 'a + OpaqueEncoder, { fn source_file_index(&mut self, source_file: Lrc<SourceFile>) -> SourceFileIndex { self.file_to_file_index[&(&*source_file as *const SourceFile)] @@ -785,7 +807,7 @@ where /// encode the specified tag, then the given value, then the number of /// bytes taken up by tag and value. On decoding, we can then verify that /// we get the expected tag and read the expected number of bytes. - fn encode_tagged<T: Encodable, V: Encodable>( + fn encode_tagged<T: Encodable<Self>, V: Encodable<Self>>( &mut self, tag: T, value: &V, @@ -800,170 +822,111 @@ where } } -impl<'a, 'tcx, E> SpecializedEncoder<interpret::AllocId> for CacheEncoder<'a, 'tcx, E> -where - E: 'a + TyEncoder, -{ - fn specialized_encode(&mut self, alloc_id: &interpret::AllocId) -> Result<(), Self::Error> { - let (index, _) = self.interpret_allocs.insert_full(*alloc_id); - index.encode(self) +impl<'a, 'tcx> FingerprintEncoder for CacheEncoder<'a, 'tcx, rustc_serialize::opaque::Encoder> { + fn encode_fingerprint(&mut self, f: &Fingerprint) -> opaque::EncodeResult { + f.encode_opaque(self.encoder) } } -impl<'a, 'tcx, E> SpecializedEncoder<SyntaxContext> for CacheEncoder<'a, 'tcx, E> +impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for SyntaxContext where - E: 'a + TyEncoder, + E: 'a + OpaqueEncoder, { - fn specialized_encode(&mut self, ctxt: &SyntaxContext) -> Result<(), Self::Error> { - rustc_span::hygiene::raw_encode_syntax_context(*ctxt, self.hygiene_context, self) + fn encode(&self, s: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error> { + rustc_span::hygiene::raw_encode_syntax_context(*self, s.hygiene_context, s) } } -impl<'a, 'tcx, E> SpecializedEncoder<ExpnId> for CacheEncoder<'a, 'tcx, E> +impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for ExpnId where - E: 'a + TyEncoder, + E: 'a + OpaqueEncoder, { - fn specialized_encode(&mut self, expn: &ExpnId) -> Result<(), Self::Error> { + fn encode(&self, s: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error> { rustc_span::hygiene::raw_encode_expn_id( - *expn, - self.hygiene_context, + *self, + s.hygiene_context, ExpnDataEncodeMode::IncrComp, - self, + s, ) } } -impl<'a, 'tcx, E> SpecializedEncoder<Span> for CacheEncoder<'a, 'tcx, E> +impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for Span where - E: 'a + TyEncoder, + E: 'a + OpaqueEncoder, { - fn specialized_encode(&mut self, span: &Span) -> Result<(), Self::Error> { - if *span == DUMMY_SP { - return TAG_INVALID_SPAN.encode(self); + fn encode(&self, s: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error> { + if *self == DUMMY_SP { + return TAG_INVALID_SPAN.encode(s); } - let span_data = span.data(); - let (file_lo, line_lo, col_lo) = - match self.source_map.byte_pos_to_line_and_col(span_data.lo) { - Some(pos) => pos, - None => return TAG_INVALID_SPAN.encode(self), - }; + let span_data = self.data(); + let (file_lo, line_lo, col_lo) = match s.source_map.byte_pos_to_line_and_col(span_data.lo) { + Some(pos) => pos, + None => return TAG_INVALID_SPAN.encode(s), + }; if !file_lo.contains(span_data.hi) { - return TAG_INVALID_SPAN.encode(self); + return TAG_INVALID_SPAN.encode(s); } let len = span_data.hi - span_data.lo; - let source_file_index = self.source_file_index(file_lo); + let source_file_index = s.source_file_index(file_lo); - TAG_VALID_SPAN.encode(self)?; - source_file_index.encode(self)?; - line_lo.encode(self)?; - col_lo.encode(self)?; - len.encode(self)?; - span_data.ctxt.encode(self)?; - Ok(()) + TAG_VALID_SPAN.encode(s)?; + source_file_index.encode(s)?; + line_lo.encode(s)?; + col_lo.encode(s)?; + len.encode(s)?; + span_data.ctxt.encode(s) } } -impl<'a, 'tcx, E> SpecializedEncoder<Ident> for CacheEncoder<'a, 'tcx, E> +impl<'a, 'tcx, E> TyEncoder<'tcx> for CacheEncoder<'a, 'tcx, E> where - E: 'a + ty_codec::TyEncoder, + E: 'a + OpaqueEncoder, { - fn specialized_encode(&mut self, _: &Ident) -> Result<(), Self::Error> { - // We don't currently encode enough information to ensure hygiene works - // with incremental, so panic rather than risk incremental bugs. + const CLEAR_CROSS_CRATE: bool = false; - // FIXME: handle hygiene in incremental. - bug!("trying to encode `Ident` for incremental"); + fn tcx(&self) -> TyCtxt<'tcx> { + self.tcx } -} - -impl<'a, 'tcx, E> ty_codec::TyEncoder for CacheEncoder<'a, 'tcx, E> -where - E: 'a + TyEncoder, -{ - #[inline] fn position(&self) -> usize { - self.encoder.position() + self.encoder.encoder_position() } -} - -impl<'a, 'tcx, E> SpecializedEncoder<CrateNum> for CacheEncoder<'a, 'tcx, E> -where - E: 'a + TyEncoder, -{ - #[inline] - fn specialized_encode(&mut self, cnum: &CrateNum) -> Result<(), Self::Error> { - self.emit_u32(cnum.as_u32()) + fn type_shorthands(&mut self) -> &mut FxHashMap<Ty<'tcx>, usize> { + &mut self.type_shorthands } -} - -impl<'a, 'b, 'c, 'tcx, E> SpecializedEncoder<&'b ty::TyS<'c>> for CacheEncoder<'a, 'tcx, E> -where - E: 'a + TyEncoder, - &'b ty::TyS<'c>: UseSpecializedEncodable, -{ - #[inline] - fn specialized_encode(&mut self, ty: &&'b ty::TyS<'c>) -> Result<(), Self::Error> { - debug_assert!(self.tcx.lift(ty).is_some()); - let ty = unsafe { std::mem::transmute::<&&'b ty::TyS<'c>, &&'tcx ty::TyS<'tcx>>(ty) }; - ty_codec::encode_with_shorthand(self, ty, |encoder| &mut encoder.type_shorthands) - } -} - -impl<'a, 'b, 'tcx, E> SpecializedEncoder<ty::Predicate<'b>> for CacheEncoder<'a, 'tcx, E> -where - E: 'a + TyEncoder, -{ - #[inline] - fn specialized_encode(&mut self, predicate: &ty::Predicate<'b>) -> Result<(), Self::Error> { - debug_assert!(self.tcx.lift(predicate).is_some()); - let predicate = - unsafe { std::mem::transmute::<&ty::Predicate<'b>, &ty::Predicate<'tcx>>(predicate) }; - ty_codec::encode_with_shorthand(self, predicate, |encoder| { - &mut encoder.predicate_shorthands - }) + fn predicate_shorthands(&mut self) -> &mut FxHashMap<ty::Predicate<'tcx>, usize> { + &mut self.predicate_shorthands } -} + fn encode_alloc_id(&mut self, alloc_id: &interpret::AllocId) -> Result<(), Self::Error> { + let (index, _) = self.interpret_allocs.insert_full(*alloc_id); -impl<'a, 'tcx, E> SpecializedEncoder<DefId> for CacheEncoder<'a, 'tcx, E> -where - E: 'a + TyEncoder, -{ - #[inline] - fn specialized_encode(&mut self, id: &DefId) -> Result<(), Self::Error> { - let def_path_hash = self.tcx.def_path_hash(*id); - def_path_hash.encode(self) + index.encode(self) } } -impl<'a, 'tcx, E> SpecializedEncoder<LocalDefId> for CacheEncoder<'a, 'tcx, E> +impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for DefId where - E: 'a + TyEncoder, + E: 'a + OpaqueEncoder, { - #[inline] - fn specialized_encode(&mut self, id: &LocalDefId) -> Result<(), Self::Error> { - id.to_def_id().encode(self) + fn encode(&self, s: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error> { + let def_path_hash = s.tcx.def_path_hash(*self); + def_path_hash.encode(s) } } -impl<'a, 'tcx, E> SpecializedEncoder<DefIndex> for CacheEncoder<'a, 'tcx, E> +impl<'a, 'tcx, E> Encodable<CacheEncoder<'a, 'tcx, E>> for DefIndex where - E: 'a + TyEncoder, + E: 'a + OpaqueEncoder, { - fn specialized_encode(&mut self, _: &DefIndex) -> Result<(), Self::Error> { + fn encode(&self, _: &mut CacheEncoder<'a, 'tcx, E>) -> Result<(), E::Error> { bug!("encoding `DefIndex` without context"); } } -impl<'a, 'tcx> SpecializedEncoder<Fingerprint> for CacheEncoder<'a, 'tcx, opaque::Encoder> { - fn specialized_encode(&mut self, f: &Fingerprint) -> Result<(), Self::Error> { - f.encode_opaque(&mut self.encoder) - } -} - macro_rules! encoder_methods { ($($name:ident($ty:ty);)*) => { #[inline] @@ -975,7 +938,7 @@ macro_rules! encoder_methods { impl<'a, 'tcx, E> Encoder for CacheEncoder<'a, 'tcx, E> where - E: 'a + TyEncoder, + E: 'a + OpaqueEncoder, { type Error = E::Error; @@ -1014,32 +977,29 @@ impl IntEncodedWithFixedSize { pub const ENCODED_SIZE: usize = 8; } -impl UseSpecializedEncodable for IntEncodedWithFixedSize {} -impl UseSpecializedDecodable for IntEncodedWithFixedSize {} - -impl SpecializedEncoder<IntEncodedWithFixedSize> for opaque::Encoder { - fn specialized_encode(&mut self, x: &IntEncodedWithFixedSize) -> Result<(), Self::Error> { - let start_pos = self.position(); +impl Encodable<opaque::Encoder> for IntEncodedWithFixedSize { + fn encode(&self, e: &mut opaque::Encoder) -> Result<(), !> { + let start_pos = e.position(); for i in 0..IntEncodedWithFixedSize::ENCODED_SIZE { - ((x.0 >> (i * 8)) as u8).encode(self)?; + ((self.0 >> (i * 8)) as u8).encode(e)?; } - let end_pos = self.position(); + let end_pos = e.position(); assert_eq!((end_pos - start_pos), IntEncodedWithFixedSize::ENCODED_SIZE); Ok(()) } } -impl<'a> SpecializedDecoder<IntEncodedWithFixedSize> for opaque::Decoder<'a> { - fn specialized_decode(&mut self) -> Result<IntEncodedWithFixedSize, Self::Error> { +impl<'a> Decodable<opaque::Decoder<'a>> for IntEncodedWithFixedSize { + fn decode(decoder: &mut opaque::Decoder<'a>) -> Result<IntEncodedWithFixedSize, String> { let mut value: u64 = 0; - let start_pos = self.position(); + let start_pos = decoder.position(); for i in 0..IntEncodedWithFixedSize::ENCODED_SIZE { - let byte: u8 = Decodable::decode(self)?; + let byte: u8 = Decodable::decode(decoder)?; value |= (byte as u64) << (i * 8); } - let end_pos = self.position(); + let end_pos = decoder.position(); assert_eq!((end_pos - start_pos), IntEncodedWithFixedSize::ENCODED_SIZE); Ok(IntEncodedWithFixedSize(value)) @@ -1053,8 +1013,8 @@ fn encode_query_results<'a, 'tcx, Q, E>( ) -> Result<(), E::Error> where Q: super::QueryDescription<TyCtxt<'tcx>> + super::QueryAccessors<TyCtxt<'tcx>>, - Q::Value: Encodable, - E: 'a + TyEncoder, + Q::Value: Encodable<CacheEncoder<'a, 'tcx, E>>, + E: 'a + OpaqueEncoder, { let _timer = tcx .sess @@ -1066,15 +1026,16 @@ where state.iter_results(|results| { for (key, value, dep_node) in results { - if Q::cache_on_disk(tcx, &key, Some(&value)) { + if Q::cache_on_disk(tcx, &key, Some(value)) { let dep_node = SerializedDepNodeIndex::new(dep_node.index()); // Record position of the cache entry. - query_result_index.push((dep_node, AbsoluteBytePos::new(encoder.position()))); + query_result_index + .push((dep_node, AbsoluteBytePos::new(encoder.encoder.opaque().position()))); // Encode the type check tables with the `SerializedDepNodeIndex` // as tag. - encoder.encode_tagged(dep_node, &value)?; + encoder.encode_tagged(dep_node, value)?; } } Ok(()) diff --git a/src/librustc_middle/ty/query/profiling_support.rs b/src/librustc_middle/ty/query/profiling_support.rs index 0683dc02011..9b1837356e3 100644 --- a/src/librustc_middle/ty/query/profiling_support.rs +++ b/src/librustc_middle/ty/query/profiling_support.rs @@ -1,8 +1,9 @@ use crate::ty::context::TyCtxt; +use crate::ty::WithOptConstParam; use measureme::{StringComponent, StringId}; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::profiling::SelfProfiler; -use rustc_hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE}; +use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE}; use rustc_hir::definitions::DefPathData; use rustc_query_system::query::QueryCache; use rustc_query_system::query::QueryState; @@ -154,6 +155,49 @@ impl SpecIntoSelfProfilingString for DefIndex { } } +impl SpecIntoSelfProfilingString for LocalDefId { + fn spec_to_self_profile_string( + &self, + builder: &mut QueryKeyStringBuilder<'_, '_, '_>, + ) -> StringId { + builder.def_id_to_string_id(DefId { krate: LOCAL_CRATE, index: self.local_def_index }) + } +} + +impl<T: SpecIntoSelfProfilingString> SpecIntoSelfProfilingString for WithOptConstParam<T> { + fn spec_to_self_profile_string( + &self, + builder: &mut QueryKeyStringBuilder<'_, '_, '_>, + ) -> StringId { + // We print `WithOptConstParam` values as tuples to make them shorter + // and more readable, without losing information: + // + // "WithOptConstParam { did: foo::bar, const_param_did: Some(foo::baz) }" + // becomes "(foo::bar, foo::baz)" and + // "WithOptConstParam { did: foo::bar, const_param_did: None }" + // becomes "(foo::bar, _)". + + let did = StringComponent::Ref(self.did.to_self_profile_string(builder)); + + let const_param_did = if let Some(const_param_did) = self.const_param_did { + let const_param_did = builder.def_id_to_string_id(const_param_did); + StringComponent::Ref(const_param_did) + } else { + StringComponent::Value("_") + }; + + let components = [ + StringComponent::Value("("), + did, + StringComponent::Value(", "), + const_param_did, + StringComponent::Value(")"), + ]; + + builder.profiler.alloc_string(&components[..]) + } +} + impl<T0, T1> SpecIntoSelfProfilingString for (T0, T1) where T0: SpecIntoSelfProfilingString, diff --git a/src/librustc_middle/ty/sty.rs b/src/librustc_middle/ty/sty.rs index 310ab4f7235..05cd1ae456b 100644 --- a/src/librustc_middle/ty/sty.rs +++ b/src/librustc_middle/ty/sty.rs @@ -27,14 +27,14 @@ use std::marker::PhantomData; use std::ops::Range; use ty::util::IntTypeExt; -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable, Lift)] pub struct TypeAndMut<'tcx> { pub ty: Ty<'tcx>, pub mutbl: hir::Mutability, } -#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, RustcEncodable, RustcDecodable, Copy)] +#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, TyEncodable, TyDecodable, Copy)] #[derive(HashStable)] /// A "free" region `fr` can be interpreted as "some region /// at least as big as the scope `fr.scope`". @@ -43,7 +43,7 @@ pub struct FreeRegion { pub bound_region: BoundRegion, } -#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, RustcEncodable, RustcDecodable, Copy)] +#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, TyEncodable, TyDecodable, Copy)] #[derive(HashStable)] pub enum BoundRegion { /// An anonymous region parameter for a given fn (&T) @@ -82,7 +82,7 @@ impl BoundRegion { /// N.B., if you change this, you'll probably want to change the corresponding /// AST structure in `librustc_ast/ast.rs` as well. -#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, Debug)] +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable, Debug)] #[derive(HashStable)] #[rustc_diagnostic_item = "TyKind"] pub enum TyKind<'tcx> { @@ -215,7 +215,7 @@ impl TyKind<'tcx> { /// A type that is not publicly constructable. This prevents people from making `TyKind::Error` /// except through `tcx.err*()`. #[derive(Copy, Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)] -#[derive(RustcEncodable, RustcDecodable, HashStable)] +#[derive(TyEncodable, TyDecodable, HashStable)] pub struct DelaySpanBugEmitted(pub(super) ()); // `TyKind` is used a lot. Make sure it doesn't unintentionally get bigger. @@ -622,7 +622,7 @@ impl<'tcx> UpvarSubsts<'tcx> { } } -#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Ord, Eq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Ord, Eq, Hash, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable)] pub enum ExistentialPredicate<'tcx> { /// E.g., `Iterator`. @@ -673,8 +673,6 @@ impl<'tcx> Binder<ExistentialPredicate<'tcx>> { } } -impl<'tcx> rustc_serialize::UseSpecializedDecodable for &'tcx List<ExistentialPredicate<'tcx>> {} - impl<'tcx> List<ExistentialPredicate<'tcx>> { /// Returns the "principal `DefId`" of this set of existential predicates. /// @@ -770,7 +768,7 @@ impl<'tcx> Binder<&'tcx List<ExistentialPredicate<'tcx>>> { /// /// Trait references also appear in object types like `Foo<U>`, but in /// that case the `Self` parameter is absent from the substitutions. -#[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable)] pub struct TraitRef<'tcx> { pub def_id: DefId, @@ -828,7 +826,7 @@ impl<'tcx> PolyTraitRef<'tcx> { /// /// The substitutions don't include the erased `Self`, only trait /// type and lifetime parameters (`[X, Y]` and `['a, 'b]` above). -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable)] pub struct ExistentialTraitRef<'tcx> { pub def_id: DefId, @@ -884,7 +882,7 @@ impl<'tcx> PolyExistentialTraitRef<'tcx> { /// erase, or otherwise "discharge" these bound vars, we change the /// type from `Binder<T>` to just `T` (see /// e.g., `liberate_late_bound_regions`). -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)] pub struct Binder<T>(T); impl<T> Binder<T> { @@ -1016,7 +1014,7 @@ impl<T> Binder<Option<T>> { /// Represents the projection of an associated type. In explicit UFCS /// form this would be written `<T as Trait<..>>::N`. -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable)] pub struct ProjectionTy<'tcx> { /// The parameters of the associated item. @@ -1086,7 +1084,7 @@ impl<'tcx> PolyGenSig<'tcx> { /// - `inputs`: is the list of arguments and their modes. /// - `output`: is the return type. /// - `c_variadic`: indicates whether this is a C-variadic function. -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable)] pub struct FnSig<'tcx> { pub inputs_and_output: &'tcx List<Ty<'tcx>>, @@ -1147,7 +1145,7 @@ impl<'tcx> PolyFnSig<'tcx> { pub type CanonicalPolyFnSig<'tcx> = Canonical<'tcx, Binder<FnSig<'tcx>>>; -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)] #[derive(HashStable)] pub struct ParamTy { pub index: u32, @@ -1172,7 +1170,7 @@ impl<'tcx> ParamTy { } } -#[derive(Copy, Clone, Hash, RustcEncodable, RustcDecodable, Eq, PartialEq, Ord, PartialOrd)] +#[derive(Copy, Clone, Hash, TyEncodable, TyDecodable, Eq, PartialEq, Ord, PartialOrd)] #[derive(HashStable)] pub struct ParamConst { pub index: u32, @@ -1345,7 +1343,7 @@ pub type Region<'tcx> = &'tcx RegionKind; /// [1]: http://smallcultfollowing.com/babysteps/blog/2013/10/29/intermingled-parameter-lists/ /// [2]: http://smallcultfollowing.com/babysteps/blog/2013/11/04/intermingled-parameter-lists/ /// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/traits/hrtb.html -#[derive(Clone, PartialEq, Eq, Hash, Copy, RustcEncodable, RustcDecodable, PartialOrd, Ord)] +#[derive(Clone, PartialEq, Eq, Hash, Copy, TyEncodable, TyDecodable, PartialOrd, Ord)] pub enum RegionKind { /// Region bound in a type or fn declaration which will be /// substituted 'early' -- that is, at the same time when type @@ -1383,32 +1381,30 @@ pub enum RegionKind { ReErased, } -impl<'tcx> rustc_serialize::UseSpecializedDecodable for Region<'tcx> {} - -#[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug, PartialOrd, Ord)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable, Debug, PartialOrd, Ord)] pub struct EarlyBoundRegion { pub def_id: DefId, pub index: u32, pub name: Symbol, } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)] pub struct TyVid { pub index: u32, } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)] pub struct ConstVid<'tcx> { pub index: u32, pub phantom: PhantomData<&'tcx ()>, } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)] pub struct IntVid { pub index: u32, } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)] pub struct FloatVid { pub index: u32, } @@ -1425,7 +1421,7 @@ impl Atom for RegionVid { } } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)] #[derive(HashStable)] pub enum InferTy { TyVar(TyVid), @@ -1444,14 +1440,14 @@ rustc_index::newtype_index! { pub struct BoundVar { .. } } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)] #[derive(HashStable)] pub struct BoundTy { pub var: BoundVar, pub kind: BoundTyKind, } -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)] #[derive(HashStable)] pub enum BoundTyKind { Anon, @@ -1465,7 +1461,7 @@ impl From<BoundVar> for BoundTy { } /// A `ProjectionPredicate` for an `ExistentialTraitRef`. -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable)] pub struct ExistentialProjection<'tcx> { pub item_def_id: DefId, diff --git a/src/librustc_middle/ty/subst.rs b/src/librustc_middle/ty/subst.rs index 866b529f35e..acd58ab7f96 100644 --- a/src/librustc_middle/ty/subst.rs +++ b/src/librustc_middle/ty/subst.rs @@ -1,13 +1,14 @@ // Type substitutions. use crate::infer::canonical::Canonical; +use crate::ty::codec::{TyDecoder, TyEncoder}; use crate::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor}; use crate::ty::sty::{ClosureSubsts, GeneratorSubsts}; use crate::ty::{self, Lift, List, ParamConst, Ty, TyCtxt}; use rustc_hir::def_id::DefId; use rustc_macros::HashStable; -use rustc_serialize::{self, Decodable, Decoder, Encodable, Encoder}; +use rustc_serialize::{self, Decodable, Encodable}; use rustc_span::{Span, DUMMY_SP}; use smallvec::SmallVec; @@ -34,7 +35,7 @@ const TYPE_TAG: usize = 0b00; const REGION_TAG: usize = 0b01; const CONST_TAG: usize = 0b10; -#[derive(Debug, RustcEncodable, RustcDecodable, PartialEq, Eq, PartialOrd, Ord, HashStable)] +#[derive(Debug, TyEncodable, TyDecodable, PartialEq, Eq, PartialOrd, Ord, HashStable)] pub enum GenericArgKind<'tcx> { Lifetime(ty::Region<'tcx>), Type(Ty<'tcx>), @@ -168,14 +169,14 @@ impl<'tcx> TypeFoldable<'tcx> for GenericArg<'tcx> { } } -impl<'tcx> Encodable for GenericArg<'tcx> { - fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> { +impl<'tcx, E: TyEncoder<'tcx>> Encodable<E> for GenericArg<'tcx> { + fn encode(&self, e: &mut E) -> Result<(), E::Error> { self.unpack().encode(e) } } -impl<'tcx> Decodable for GenericArg<'tcx> { - fn decode<D: Decoder>(d: &mut D) -> Result<GenericArg<'tcx>, D::Error> { +impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for GenericArg<'tcx> { + fn decode(d: &mut D) -> Result<GenericArg<'tcx>, D::Error> { Ok(GenericArgKind::decode(d)?.pack()) } } @@ -396,8 +397,6 @@ impl<'tcx> TypeFoldable<'tcx> for SubstsRef<'tcx> { } } -impl<'tcx> rustc_serialize::UseSpecializedDecodable for SubstsRef<'tcx> {} - /////////////////////////////////////////////////////////////////////////// // Public trait `Subst` // @@ -653,7 +652,7 @@ pub type CanonicalUserSubsts<'tcx> = Canonical<'tcx, UserSubsts<'tcx>>; /// Stores the user-given substs to reach some fully qualified path /// (e.g., `<T>::Item` or `<T as Trait>::Item`). -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable, Lift)] pub struct UserSubsts<'tcx> { /// The substitutions for the item as given by the user. @@ -680,7 +679,7 @@ pub struct UserSubsts<'tcx> { /// the impl (with the substs from `UserSubsts`) and apply those to /// the self type, giving `Foo<?A>`. Finally, we unify that with /// the self type here, which contains `?A` to be `&'static u32` -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable)] #[derive(HashStable, TypeFoldable, Lift)] pub struct UserSelfTy<'tcx> { pub impl_def_id: DefId, diff --git a/src/librustc_middle/ty/trait_def.rs b/src/librustc_middle/ty/trait_def.rs index f93cce3f4da..86fe3ac3751 100644 --- a/src/librustc_middle/ty/trait_def.rs +++ b/src/librustc_middle/ty/trait_def.rs @@ -47,7 +47,7 @@ pub struct TraitDef { /// Whether this trait is treated specially by the standard library /// specialization lint. -#[derive(HashStable, PartialEq, Clone, Copy, RustcEncodable, RustcDecodable)] +#[derive(HashStable, PartialEq, Clone, Copy, TyEncodable, TyDecodable)] pub enum TraitSpecializationKind { /// The default. Specializing on this trait is not allowed. None, diff --git a/src/librustc_middle/ty/util.rs b/src/librustc_middle/ty/util.rs index 07221082048..5c5fe9dbd7a 100644 --- a/src/librustc_middle/ty/util.rs +++ b/src/librustc_middle/ty/util.rs @@ -879,7 +879,7 @@ impl<'tcx> ty::TyS<'tcx> { let span = match field .did .as_local() - .map(|id| tcx.hir().as_local_hir_id(id)) + .map(|id| tcx.hir().local_def_id_to_hir_id(id)) .and_then(|id| tcx.hir().find(id)) { Some(hir::Node::Field(field)) => field.ty.span, @@ -1143,7 +1143,7 @@ pub fn needs_drop_components( } } -#[derive(Copy, Clone, Debug, HashStable, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, HashStable, TyEncodable, TyDecodable)] pub struct AlwaysRequiresDrop; /// Normalizes all opaque types in the given value, replacing them diff --git a/src/librustc_mir/Cargo.toml b/src/librustc_mir/Cargo.toml index f05c47e0ed6..2693d29e41c 100644 --- a/src/librustc_mir/Cargo.toml +++ b/src/librustc_mir/Cargo.toml @@ -13,7 +13,7 @@ doctest = false either = "1.5.0" rustc_graphviz = { path = "../librustc_graphviz" } itertools = "0.8" -log = { package = "tracing", version = "0.1" } +tracing = "0.1" log_settings = "0.1.1" polonius-engine = "0.12.0" rustc_middle = { path = "../librustc_middle" } diff --git a/src/librustc_mir/borrow_check/diagnostics/conflict_errors.rs b/src/librustc_mir/borrow_check/diagnostics/conflict_errors.rs index 8e7c97c4a1b..7a50bdfeef6 100644 --- a/src/librustc_mir/borrow_check/diagnostics/conflict_errors.rs +++ b/src/librustc_mir/borrow_check/diagnostics/conflict_errors.rs @@ -263,7 +263,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { let needs_note = match ty.kind { ty::Closure(id, _) => { let tables = self.infcx.tcx.typeck(id.expect_local()); - let hir_id = self.infcx.tcx.hir().as_local_hir_id(id.expect_local()); + let hir_id = self.infcx.tcx.hir().local_def_id_to_hir_id(id.expect_local()); tables.closure_kind_origins().get(hir_id).is_none() } @@ -954,7 +954,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { format!("`{}` would have to be valid for `{}`...", name, region_name), ); - let fn_hir_id = self.infcx.tcx.hir().as_local_hir_id(self.mir_def_id); + let fn_hir_id = self.infcx.tcx.hir().local_def_id_to_hir_id(self.mir_def_id); err.span_label( drop_span, format!( @@ -1863,7 +1863,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { ) -> Option<AnnotatedBorrowFnSignature<'tcx>> { debug!("annotate_fn_sig: did={:?} sig={:?}", did, sig); let is_closure = self.infcx.tcx.is_closure(did); - let fn_hir_id = self.infcx.tcx.hir().as_local_hir_id(did.as_local()?); + let fn_hir_id = self.infcx.tcx.hir().local_def_id_to_hir_id(did.as_local()?); let fn_decl = self.infcx.tcx.hir().fn_decl_by_hir_id(fn_hir_id)?; // We need to work out which arguments to highlight. We do this by looking diff --git a/src/librustc_mir/borrow_check/diagnostics/mod.rs b/src/librustc_mir/borrow_check/diagnostics/mod.rs index ba74ffaa8d6..daffdec2a83 100644 --- a/src/librustc_mir/borrow_check/diagnostics/mod.rs +++ b/src/librustc_mir/borrow_check/diagnostics/mod.rs @@ -104,7 +104,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { debug!("add_moved_or_invoked_closure_note: closure={:?}", closure); if let ty::Closure(did, _) = self.body.local_decls[closure].ty.kind { let did = did.expect_local(); - let hir_id = self.infcx.tcx.hir().as_local_hir_id(did); + let hir_id = self.infcx.tcx.hir().local_def_id_to_hir_id(did); if let Some((span, name)) = self.infcx.tcx.typeck(did).closure_kind_origins().get(hir_id) @@ -127,7 +127,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { if let Some(target) = target { if let ty::Closure(did, _) = self.body.local_decls[target].ty.kind { let did = did.expect_local(); - let hir_id = self.infcx.tcx.hir().as_local_hir_id(did); + let hir_id = self.infcx.tcx.hir().local_def_id_to_hir_id(did); if let Some((span, name)) = self.infcx.tcx.typeck(did).closure_kind_origins().get(hir_id) @@ -937,7 +937,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> { "closure_span: def_id={:?} target_place={:?} places={:?}", def_id, target_place, places ); - let hir_id = self.infcx.tcx.hir().as_local_hir_id(def_id.as_local()?); + let hir_id = self.infcx.tcx.hir().local_def_id_to_hir_id(def_id.as_local()?); let expr = &self.infcx.tcx.hir().expect_expr(hir_id).kind; debug!("closure_span: hir_id={:?} expr={:?}", hir_id, expr); if let hir::ExprKind::Closure(.., body_id, args_span, _) = expr { diff --git a/src/librustc_mir/borrow_check/diagnostics/mutability_errors.rs b/src/librustc_mir/borrow_check/diagnostics/mutability_errors.rs index ef0fe71abec..d26436ff1de 100644 --- a/src/librustc_mir/borrow_check/diagnostics/mutability_errors.rs +++ b/src/librustc_mir/borrow_check/diagnostics/mutability_errors.rs @@ -492,7 +492,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { err.span_label(sp, format!("cannot {}", act)); let hir = self.infcx.tcx.hir(); - let closure_id = hir.as_local_hir_id(self.mir_def_id); + let closure_id = hir.local_def_id_to_hir_id(self.mir_def_id); let fn_call_id = hir.get_parent_node(closure_id); let node = hir.get(fn_call_id); let item_id = hir.enclosing_body_owner(fn_call_id); @@ -691,7 +691,7 @@ fn annotate_struct_field( if let ty::Adt(def, _) = ty.kind { let field = def.all_fields().nth(field.index())?; // Use the HIR types to construct the diagnostic message. - let hir_id = tcx.hir().as_local_hir_id(field.did.as_local()?); + let hir_id = tcx.hir().local_def_id_to_hir_id(field.did.as_local()?); let node = tcx.hir().find(hir_id)?; // Now we're dealing with the actual struct that we're going to suggest a change to, // we can expect a field that is an immutable reference to a type. diff --git a/src/librustc_mir/borrow_check/diagnostics/outlives_suggestion.rs b/src/librustc_mir/borrow_check/diagnostics/outlives_suggestion.rs index 8521f900988..9197a83cdd0 100644 --- a/src/librustc_mir/borrow_check/diagnostics/outlives_suggestion.rs +++ b/src/librustc_mir/borrow_check/diagnostics/outlives_suggestion.rs @@ -3,10 +3,10 @@ use std::collections::BTreeMap; -use log::debug; use rustc_data_structures::fx::FxHashSet; use rustc_errors::DiagnosticBuilder; use rustc_middle::ty::RegionVid; +use tracing::debug; use smallvec::SmallVec; diff --git a/src/librustc_mir/borrow_check/diagnostics/region_name.rs b/src/librustc_mir/borrow_check/diagnostics/region_name.rs index 32195adc60e..2603b1e048d 100644 --- a/src/librustc_mir/borrow_check/diagnostics/region_name.rs +++ b/src/librustc_mir/borrow_check/diagnostics/region_name.rs @@ -266,7 +266,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> { } ty::BoundRegion::BrEnv => { - let mir_hir_id = self.infcx.tcx.hir().as_local_hir_id(self.mir_def_id); + let mir_hir_id = self.infcx.tcx.hir().local_def_id_to_hir_id(self.mir_def_id); let def_ty = self.regioncx.universal_regions().defining_ty; if let DefiningTy::Closure(_, substs) = def_ty { @@ -361,7 +361,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> { &self, argument_index: usize, ) -> Option<&hir::Ty<'tcx>> { - let mir_hir_id = self.infcx.tcx.hir().as_local_hir_id(self.mir_def_id); + let mir_hir_id = self.infcx.tcx.hir().local_def_id_to_hir_id(self.mir_def_id); let fn_decl = self.infcx.tcx.hir().fn_decl_by_hir_id(mir_hir_id)?; let argument_hir_ty: &hir::Ty<'_> = fn_decl.inputs.get(argument_index)?; match argument_hir_ty.kind { @@ -648,7 +648,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> { highlight.highlighting_region_vid(fr, *self.next_region_name.try_borrow().unwrap()); let type_name = self.infcx.extract_type_name(&return_ty, Some(highlight)).0; - let mir_hir_id = tcx.hir().as_local_hir_id(self.mir_def_id); + let mir_hir_id = tcx.hir().local_def_id_to_hir_id(self.mir_def_id); let (return_span, mir_description) = match tcx.hir().get(mir_hir_id) { hir::Node::Expr(hir::Expr { @@ -700,7 +700,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> { highlight.highlighting_region_vid(fr, *self.next_region_name.try_borrow().unwrap()); let type_name = self.infcx.extract_type_name(&yield_ty, Some(highlight)).0; - let mir_hir_id = tcx.hir().as_local_hir_id(self.mir_def_id); + let mir_hir_id = tcx.hir().local_def_id_to_hir_id(self.mir_def_id); let yield_span = match tcx.hir().get(mir_hir_id) { hir::Node::Expr(hir::Expr { diff --git a/src/librustc_mir/borrow_check/mod.rs b/src/librustc_mir/borrow_check/mod.rs index 6e211b42a05..f7031b2a598 100644 --- a/src/librustc_mir/borrow_check/mod.rs +++ b/src/librustc_mir/borrow_check/mod.rs @@ -129,7 +129,7 @@ fn do_mir_borrowck<'a, 'tcx>( let tcx = infcx.tcx; let param_env = tcx.param_env(def.did); - let id = tcx.hir().as_local_hir_id(def.did); + let id = tcx.hir().local_def_id_to_hir_id(def.did); let mut local_names = IndexVec::from_elem(None, &input_body.local_decls); for var_debug_info in &input_body.var_debug_info { diff --git a/src/librustc_mir/borrow_check/universal_regions.rs b/src/librustc_mir/borrow_check/universal_regions.rs index c5aa5c5ebc7..cd6b75cf556 100644 --- a/src/librustc_mir/borrow_check/universal_regions.rs +++ b/src/librustc_mir/borrow_check/universal_regions.rs @@ -231,7 +231,7 @@ impl<'tcx> UniversalRegions<'tcx> { param_env: ty::ParamEnv<'tcx>, ) -> Self { let tcx = infcx.tcx; - let mir_hir_id = tcx.hir().as_local_hir_id(mir_def.did); + let mir_hir_id = tcx.hir().local_def_id_to_hir_id(mir_def.did); UniversalRegionsBuilder { infcx, mir_def, mir_hir_id, param_env }.build() } diff --git a/src/librustc_mir/const_eval/eval_queries.rs b/src/librustc_mir/const_eval/eval_queries.rs index 7fbe5c409d3..291b42c12d7 100644 --- a/src/librustc_mir/const_eval/eval_queries.rs +++ b/src/librustc_mir/const_eval/eval_queries.rs @@ -57,6 +57,12 @@ fn eval_body_using_ecx<'mir, 'tcx>( ecx.run()?; // Intern the result + // FIXME: since the DefId of a promoted is the DefId of its owner, this + // means that promoteds in statics are actually interned like statics! + // However, this is also currently crucial because we promote mutable + // non-empty slices in statics to extend their lifetime, and this + // ensures that they are put into a mutable allocation. + // For other kinds of promoteds in statics (like array initializers), this is rather silly. let intern_kind = match tcx.static_mutability(cid.instance.def_id()) { Some(m) => InternKind::Static(m), None if cid.promoted.is_some() => InternKind::Promoted, @@ -347,7 +353,7 @@ pub fn const_eval_raw_provider<'tcx>( // validation thus preventing such a hard error from being a backwards // compatibility hazard DefKind::Const | DefKind::AssocConst => { - let hir_id = tcx.hir().as_local_hir_id(def.did); + let hir_id = tcx.hir().local_def_id_to_hir_id(def.did); err.report_as_lint( tcx.at(tcx.def_span(def.did)), "any use of this value will cause an error", @@ -370,7 +376,7 @@ pub fn const_eval_raw_provider<'tcx>( err.report_as_lint( tcx.at(span), "reaching this expression at runtime will panic or abort", - tcx.hir().as_local_hir_id(def.did), + tcx.hir().local_def_id_to_hir_id(def.did), Some(err.span), ) } diff --git a/src/librustc_mir/const_eval/fn_queries.rs b/src/librustc_mir/const_eval/fn_queries.rs index 70ddd79ee40..9ef63b3322d 100644 --- a/src/librustc_mir/const_eval/fn_queries.rs +++ b/src/librustc_mir/const_eval/fn_queries.rs @@ -90,7 +90,7 @@ pub fn is_parent_const_impl_raw(tcx: TyCtxt<'_>, hir_id: hir::HirId) -> bool { /// Checks whether the function has a `const` modifier or, in case it is an intrinsic, whether /// said intrinsic has a `rustc_const_{un,}stable` attribute. fn is_const_fn_raw(tcx: TyCtxt<'_>, def_id: DefId) -> bool { - let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let node = tcx.hir().get(hir_id); diff --git a/src/librustc_mir/const_eval/machine.rs b/src/librustc_mir/const_eval/machine.rs index 3a753a0edb6..2d0e68d5894 100644 --- a/src/librustc_mir/const_eval/machine.rs +++ b/src/librustc_mir/const_eval/machine.rs @@ -301,12 +301,16 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir, Ok(()) } - fn after_stack_push(ecx: &mut InterpCx<'mir, 'tcx, Self>) -> InterpResult<'tcx> { - // Enforce stack size limit. - if !ecx.tcx.sess.recursion_limit().value_within_limit(ecx.stack().len()) { + #[inline(always)] + fn init_frame_extra( + ecx: &mut InterpCx<'mir, 'tcx, Self>, + frame: Frame<'mir, 'tcx>, + ) -> InterpResult<'tcx, Frame<'mir, 'tcx>> { + // Enforce stack size limit. Add 1 because this is run before the new frame is pushed. + if !ecx.tcx.sess.recursion_limit().value_within_limit(ecx.stack().len() + 1) { throw_exhaust!(StackFrameLimitReached) } else { - Ok(()) + Ok(frame) } } diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs index bcf2899b439..525da87463a 100644 --- a/src/librustc_mir/interpret/eval_context.rs +++ b/src/librustc_mir/interpret/eval_context.rs @@ -16,7 +16,7 @@ use rustc_middle::ty::layout::{self, TyAndLayout}; use rustc_middle::ty::{ self, query::TyCtxtAt, subst::SubstsRef, ParamEnv, Ty, TyCtxt, TypeFoldable, }; -use rustc_span::{source_map::DUMMY_SP, Pos, Span}; +use rustc_span::{Pos, Span}; use rustc_target::abi::{Align, HasDataLayout, LayoutOf, Size, TargetDataLayout}; use super::{ @@ -83,9 +83,11 @@ pub struct Frame<'mir, 'tcx, Tag = (), Extra = ()> { //////////////////////////////////////////////////////////////////////////////// // Current position within the function //////////////////////////////////////////////////////////////////////////////// - /// If this is `None`, we are unwinding and this function doesn't need any clean-up. - /// Just continue the same as with `Resume`. - pub loc: Option<mir::Location>, + /// If this is `Err`, we are not currently executing any particular statement in + /// this frame (can happen e.g. during frame initialization, and during unwinding on + /// frames without cleanup code). + /// We basically abuse `Result` as `Either`. + pub(super) loc: Result<mir::Location, Span>, } /// What we store about a frame in an interpreter backtrace. @@ -189,7 +191,14 @@ impl<'mir, 'tcx, Tag> Frame<'mir, 'tcx, Tag> { impl<'mir, 'tcx, Tag, Extra> Frame<'mir, 'tcx, Tag, Extra> { /// Return the `SourceInfo` of the current instruction. pub fn current_source_info(&self) -> Option<&mir::SourceInfo> { - self.loc.map(|loc| self.body.source_info(loc)) + self.loc.ok().map(|loc| self.body.source_info(loc)) + } + + pub fn current_span(&self) -> Span { + match self.loc { + Ok(loc) => self.body.source_info(loc).span, + Err(span) => span, + } } } @@ -324,11 +333,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { #[inline(always)] pub fn cur_span(&self) -> Span { - self.stack() - .last() - .and_then(|f| f.current_source_info()) - .map(|si| si.span) - .unwrap_or(self.tcx.span) + self.stack().last().map(|f| f.current_span()).unwrap_or(self.tcx.span) } #[inline(always)] @@ -640,7 +645,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { // first push a stack frame so we have access to the local substs let pre_frame = Frame { body, - loc: Some(mir::Location::START), + loc: Err(body.span), // Span used for errors caused during preamble. return_to_block, return_place, // empty local array, we fill it in below, after we are inside the stack frame and @@ -654,9 +659,15 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { // Make sure all the constants required by this frame evaluate successfully (post-monomorphization check). for const_ in &body.required_consts { + let span = const_.span; let const_ = self.subst_from_current_frame_and_normalize_erasing_regions(const_.literal); - self.const_to_op(const_, None)?; + self.const_to_op(const_, None).map_err(|err| { + // If there was an error, set the span of the current frame to this constant. + // Avoiding doing this when evaluation succeeds. + self.frame_mut().loc = Err(span); + err + })?; } // Locals are initially uninitialized. @@ -683,8 +694,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { } // done self.frame_mut().locals = locals; - M::after_stack_push(self)?; + self.frame_mut().loc = Ok(mir::Location::START); info!("ENTERING({}) {}", self.frame_idx(), self.frame().instance); Ok(()) @@ -693,7 +704,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { /// Jump to the given block. #[inline] pub fn go_to_block(&mut self, target: mir::BasicBlock) { - self.frame_mut().loc = Some(mir::Location { block: target, statement_index: 0 }); + self.frame_mut().loc = Ok(mir::Location { block: target, statement_index: 0 }); } /// *Return* to the given `target` basic block. @@ -715,7 +726,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { /// If `target` is `None`, that indicates the function does not need cleanup during /// unwinding, and we will just keep propagating that upwards. pub fn unwind_to_block(&mut self, target: Option<mir::BasicBlock>) { - self.frame_mut().loc = target.map(|block| mir::Location { block, statement_index: 0 }); + self.frame_mut().loc = match target { + Some(block) => Ok(mir::Location { block, statement_index: 0 }), + None => Err(self.frame_mut().body.span), + }; } /// Pops the current frame from the stack, deallocating the @@ -743,8 +757,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { assert_eq!( unwinding, match self.frame().loc { - None => true, - Some(loc) => self.body().basic_blocks()[loc.block].is_cleanup, + Ok(loc) => self.body().basic_blocks()[loc.block].is_cleanup, + Err(_) => true, } ); @@ -920,14 +934,13 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { pub fn generate_stacktrace(&self) -> Vec<FrameInfo<'tcx>> { let mut frames = Vec::new(); for frame in self.stack().iter().rev() { - let source_info = frame.current_source_info(); - let lint_root = source_info.and_then(|source_info| { + let lint_root = frame.current_source_info().and_then(|source_info| { match &frame.body.source_scopes[source_info.scope].local_data { mir::ClearCrossCrate::Set(data) => Some(data.lint_root), mir::ClearCrossCrate::Clear => None, } }); - let span = source_info.map_or(DUMMY_SP, |source_info| source_info.span); + let span = frame.current_span(); frames.push(FrameInfo { span, instance: frame.instance, lint_root }); } diff --git a/src/librustc_mir/interpret/intern.rs b/src/librustc_mir/interpret/intern.rs index dffbc969c21..6c8ee72bc66 100644 --- a/src/librustc_mir/interpret/intern.rs +++ b/src/librustc_mir/interpret/intern.rs @@ -312,7 +312,8 @@ pub fn intern_const_alloc_recursive<M: CompileTimeMachine<'mir, 'tcx>>( let tcx = ecx.tcx; let base_intern_mode = match intern_kind { InternKind::Static(mutbl) => InternMode::Static(mutbl), - // FIXME: what about array lengths, array initializers? + // `Constant` includes array lengths. + // `Promoted` includes non-`Copy` array initializers and `rustc_args_required_const` arguments. InternKind::Constant | InternKind::Promoted => InternMode::ConstBase, }; diff --git a/src/librustc_mir/interpret/intrinsics/caller_location.rs b/src/librustc_mir/interpret/intrinsics/caller_location.rs index 9adef8c43c7..fb3a670714b 100644 --- a/src/librustc_mir/interpret/intrinsics/caller_location.rs +++ b/src/librustc_mir/interpret/intrinsics/caller_location.rs @@ -30,8 +30,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { // Assert that there is always such a frame. .unwrap(); // Assert that the frame we look at is actually executing code currently - // (`current_source_info` is None when we are unwinding and the frame does - // not require cleanup). + // (`loc` is `Err` when we are unwinding and the frame does not require cleanup). let loc = frame.loc.unwrap(); // If this is a `Call` terminator, use the `fn_span` instead. let block = &frame.body.basic_blocks()[loc.block]; diff --git a/src/librustc_mir/interpret/machine.rs b/src/librustc_mir/interpret/machine.rs index 634f3c96e6c..5cab4ba37e3 100644 --- a/src/librustc_mir/interpret/machine.rs +++ b/src/librustc_mir/interpret/machine.rs @@ -409,12 +409,4 @@ pub macro compile_time_machine(<$mir: lifetime, $tcx: lifetime>) { ) -> Self::PointerTag { () } - - #[inline(always)] - fn init_frame_extra( - _ecx: &mut InterpCx<$mir, $tcx, Self>, - frame: Frame<$mir, $tcx>, - ) -> InterpResult<$tcx, Frame<$mir, $tcx>> { - Ok(frame) - } } diff --git a/src/librustc_mir/interpret/step.rs b/src/librustc_mir/interpret/step.rs index 93624c32d30..adecee3f7cb 100644 --- a/src/librustc_mir/interpret/step.rs +++ b/src/librustc_mir/interpret/step.rs @@ -47,8 +47,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { } let loc = match self.frame().loc { - Some(loc) => loc, - None => { + Ok(loc) => loc, + Err(_) => { // We are unwinding and this fn has no cleanup code. // Just go on unwinding. trace!("unwinding: skipping frame"); @@ -283,7 +283,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { self.eval_terminator(terminator)?; if !self.stack().is_empty() { - if let Some(loc) = self.frame().loc { + if let Ok(loc) = self.frame().loc { info!("// executing {:?}", loc.block); } } diff --git a/src/librustc_mir/lib.rs b/src/librustc_mir/lib.rs index 4e7142a93ae..3118e7ac3ab 100644 --- a/src/librustc_mir/lib.rs +++ b/src/librustc_mir/lib.rs @@ -30,7 +30,7 @@ Rust MIR: a lowered representation of Rust. #![recursion_limit = "256"] #[macro_use] -extern crate log; +extern crate tracing; #[macro_use] extern crate rustc_middle; diff --git a/src/librustc_mir/monomorphize/polymorphize.rs b/src/librustc_mir/monomorphize/polymorphize.rs index fc9f7f1af62..d946c1947c2 100644 --- a/src/librustc_mir/monomorphize/polymorphize.rs +++ b/src/librustc_mir/monomorphize/polymorphize.rs @@ -69,8 +69,7 @@ fn unused_generic_params(tcx: TyCtxt<'_>, def_id: DefId) -> FiniteBitSet<u32> { // Visit MIR and accumululate used generic parameters. let body = tcx.optimized_mir(def_id); - let mut vis = - UsedGenericParametersVisitor { tcx, def_id, unused_parameters: &mut unused_parameters }; + let mut vis = MarkUsedGenericParams { tcx, def_id, unused_parameters: &mut unused_parameters }; vis.visit_body(body); debug!("unused_generic_params: (after visitor) unused_parameters={:?}", unused_parameters); @@ -120,45 +119,101 @@ fn mark_used_by_predicates<'tcx>( def_id: DefId, unused_parameters: &mut FiniteBitSet<u32>, ) { - let def_id = tcx.closure_base_def_id(def_id); - - let is_self_ty_used = |unused_parameters: &mut FiniteBitSet<u32>, self_ty: Ty<'tcx>| { - debug!("unused_generic_params: self_ty={:?}", self_ty); - if let ty::Param(param) = self_ty.kind { - !unused_parameters.contains(param.index).unwrap_or(false) - } else { - false - } + let is_ty_used = |unused_parameters: &FiniteBitSet<u32>, ty: Ty<'tcx>| -> bool { + let mut vis = IsUsedGenericParams { unused_parameters }; + ty.visit_with(&mut vis) }; let mark_ty = |unused_parameters: &mut FiniteBitSet<u32>, ty: Ty<'tcx>| { - let mut vis = UsedGenericParametersVisitor { tcx, def_id, unused_parameters }; + let mut vis = MarkUsedGenericParams { tcx, def_id, unused_parameters }; ty.visit_with(&mut vis); }; + let def_id = tcx.closure_base_def_id(def_id); let predicates = tcx.explicit_predicates_of(def_id); - debug!("mark_parameters_used_in_predicates: predicates_of={:?}", predicates); - for (predicate, _) in predicates.predicates { - match predicate.skip_binders() { - ty::PredicateAtom::Trait(predicate, ..) => { - let trait_ref = predicate.trait_ref; - if is_self_ty_used(unused_parameters, trait_ref.self_ty()) { + debug!("mark_used_by_predicates: predicates_of={:?}", predicates); + + let mut current_unused_parameters = FiniteBitSet::new_empty(); + // Run to a fixed point to support `where T: Trait<U>, U: Trait<V>`, starting with an empty + // bit set so that this is skipped if all parameters are already used. + while current_unused_parameters != *unused_parameters { + debug!( + "mark_used_by_predicates: current_unused_parameters={:?} = unused_parameters={:?}", + current_unused_parameters, unused_parameters + ); + current_unused_parameters = *unused_parameters; + + for (predicate, _) in predicates.predicates { + match predicate.skip_binders() { + ty::PredicateAtom::Trait(predicate, ..) => { + let trait_ref = predicate.trait_ref; + debug!("mark_used_by_predicates: (trait) trait_ref={:?}", trait_ref); + + // Consider `T` used if `I` is used in predicates of the form + // `I: Iterator<Item = T>` + debug!("mark_used_by_predicates: checking self"); + if is_ty_used(unused_parameters, trait_ref.self_ty()) { + debug!("mark_used_by_predicates: used!"); + for ty in trait_ref.substs.types() { + mark_ty(unused_parameters, ty); + } + + // No need to check for a type being used in the substs if `self_ty` was + // used. + continue; + } + + // Consider `I` used if `T` is used in predicates of the form + // `I: Iterator<Item = &'a (T, E)>` (see rust-lang/rust#75326) + debug!("mark_used_by_predicates: checking substs"); for ty in trait_ref.substs.types() { - debug!("unused_generic_params: (trait) ty={:?}", ty); - mark_ty(unused_parameters, ty); + if is_ty_used(unused_parameters, ty) { + debug!("mark_used_by_predicates: used!"); + mark_ty(unused_parameters, trait_ref.self_ty()); + } } } - } - ty::PredicateAtom::Projection(proj, ..) => { - let self_ty = proj.projection_ty.self_ty(); - if is_self_ty_used(unused_parameters, self_ty) { - debug!("unused_generic_params: (projection ty={:?}", proj.ty); - mark_ty(unused_parameters, proj.ty); + ty::PredicateAtom::Projection(proj, ..) => { + let self_ty = proj.projection_ty.self_ty(); + debug!( + "mark_used_by_predicates: (projection) self_ty={:?} proj.ty={:?}", + self_ty, proj.ty + ); + + // Consider `T` used if `I` is used in predicates of the form + // `<I as Iterator>::Item = T` + debug!("mark_used_by_predicates: checking self"); + if is_ty_used(unused_parameters, self_ty) { + debug!("mark_used_by_predicates: used!"); + mark_ty(unused_parameters, proj.ty); + + // No need to check for projection type being used if `self_ty` was used. + continue; + } + + // Consider `I` used if `T` is used in predicates of the form + // `<I as Iterator>::Item = &'a (T, E)` (see rust-lang/rust#75326) + debug!("mark_used_by_predicates: checking projection ty"); + if is_ty_used(unused_parameters, proj.ty) { + debug!("mark_used_by_predicates: used!"); + mark_ty(unused_parameters, self_ty); + } } + ty::PredicateAtom::RegionOutlives(..) + | ty::PredicateAtom::TypeOutlives(..) + | ty::PredicateAtom::WellFormed(..) + | ty::PredicateAtom::ObjectSafe(..) + | ty::PredicateAtom::ClosureKind(..) + | ty::PredicateAtom::Subtype(..) + | ty::PredicateAtom::ConstEvaluatable(..) + | ty::PredicateAtom::ConstEquate(..) => (), } - _ => (), } } + + if let Some(parent) = predicates.parent { + mark_used_by_predicates(tcx, parent, unused_parameters); + } } /// Emit errors for the function annotated by `#[rustc_polymorphize_error]`, labelling each generic @@ -204,13 +259,13 @@ fn emit_unused_generic_params_error<'tcx>( } /// Visitor used to aggregate generic parameter uses. -struct UsedGenericParametersVisitor<'a, 'tcx> { +struct MarkUsedGenericParams<'a, 'tcx> { tcx: TyCtxt<'tcx>, def_id: DefId, unused_parameters: &'a mut FiniteBitSet<u32>, } -impl<'a, 'tcx> UsedGenericParametersVisitor<'a, 'tcx> { +impl<'a, 'tcx> MarkUsedGenericParams<'a, 'tcx> { /// Invoke `unused_generic_params` on a body contained within the current item (e.g. /// a closure, generator or constant). fn visit_child_body(&mut self, def_id: DefId, substs: SubstsRef<'tcx>) { @@ -229,7 +284,7 @@ impl<'a, 'tcx> UsedGenericParametersVisitor<'a, 'tcx> { } } -impl<'a, 'tcx> Visitor<'tcx> for UsedGenericParametersVisitor<'a, 'tcx> { +impl<'a, 'tcx> Visitor<'tcx> for MarkUsedGenericParams<'a, 'tcx> { fn visit_local_decl(&mut self, local: Local, local_decl: &LocalDecl<'tcx>) { debug!("visit_local_decl: local_decl={:?}", local_decl); if local == Local::from_usize(1) { @@ -256,7 +311,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UsedGenericParametersVisitor<'a, 'tcx> { } } -impl<'a, 'tcx> TypeVisitor<'tcx> for UsedGenericParametersVisitor<'a, 'tcx> { +impl<'a, 'tcx> TypeVisitor<'tcx> for MarkUsedGenericParams<'a, 'tcx> { fn visit_const(&mut self, c: &'tcx Const<'tcx>) -> bool { debug!("visit_const: c={:?}", c); if !c.has_param_types_or_consts() { @@ -318,3 +373,36 @@ impl<'a, 'tcx> TypeVisitor<'tcx> for UsedGenericParametersVisitor<'a, 'tcx> { } } } + +/// Visitor used to check if a generic parameter is used. +struct IsUsedGenericParams<'a> { + unused_parameters: &'a FiniteBitSet<u32>, +} + +impl<'a, 'tcx> TypeVisitor<'tcx> for IsUsedGenericParams<'a> { + fn visit_const(&mut self, c: &'tcx Const<'tcx>) -> bool { + debug!("visit_const: c={:?}", c); + if !c.has_param_types_or_consts() { + return false; + } + + match c.val { + ty::ConstKind::Param(param) => { + !self.unused_parameters.contains(param.index).unwrap_or(false) + } + _ => c.super_visit_with(self), + } + } + + fn visit_ty(&mut self, ty: Ty<'tcx>) -> bool { + debug!("visit_ty: ty={:?}", ty); + if !ty.has_param_types_or_consts() { + return false; + } + + match ty.kind { + ty::Param(param) => !self.unused_parameters.contains(param.index).unwrap_or(false), + _ => ty.super_visit_with(self), + } + } +} diff --git a/src/librustc_mir/transform/add_retag.rs b/src/librustc_mir/transform/add_retag.rs index baa3e5e1581..324289166b9 100644 --- a/src/librustc_mir/transform/add_retag.rs +++ b/src/librustc_mir/transform/add_retag.rs @@ -86,12 +86,11 @@ impl<'tcx> MirPass<'tcx> for AddRetag { .skip(1) .take(arg_count) .map(|(local, _)| Place::from(local)) - .filter(needs_retag) - .collect::<Vec<_>>(); + .filter(needs_retag); // Emit their retags. basic_blocks[START_BLOCK].statements.splice( 0..0, - places.into_iter().map(|place| Statement { + places.map(|place| Statement { source_info, kind: StatementKind::Retag(RetagKind::FnEntry, box (place)), }), @@ -101,29 +100,24 @@ impl<'tcx> MirPass<'tcx> for AddRetag { // PART 2 // Retag return values of functions. Also escape-to-raw the argument of `drop`. // We collect the return destinations because we cannot mutate while iterating. - let mut returns: Vec<(SourceInfo, Place<'tcx>, BasicBlock)> = Vec::new(); - for block_data in basic_blocks.iter_mut() { - match block_data.terminator().kind { - TerminatorKind::Call { ref destination, .. } => { - // Remember the return destination for later - if let Some(ref destination) = destination { - if needs_retag(&destination.0) { - returns.push(( - block_data.terminator().source_info, - destination.0, - destination.1, - )); - } + let returns = basic_blocks + .iter_mut() + .filter_map(|block_data| { + match block_data.terminator().kind { + TerminatorKind::Call { destination: Some(ref destination), .. } + if needs_retag(&destination.0) => + { + // Remember the return destination for later + Some((block_data.terminator().source_info, destination.0, destination.1)) } - } - TerminatorKind::Drop { .. } | TerminatorKind::DropAndReplace { .. } => { + // `Drop` is also a call, but it doesn't return anything so we are good. - } - _ => { + TerminatorKind::Drop { .. } | TerminatorKind::DropAndReplace { .. } => None, // Not a block ending in a Call -> ignore. + _ => None, } - } - } + }) + .collect::<Vec<_>>(); // Now we go over the returns we collected to retag the return values. for (source_info, dest_place, dest_block) in returns { basic_blocks[dest_block].statements.insert( diff --git a/src/librustc_mir/transform/check_consts/validation.rs b/src/librustc_mir/transform/check_consts/validation.rs index f64c72e7b36..526c896df09 100644 --- a/src/librustc_mir/transform/check_consts/validation.rs +++ b/src/librustc_mir/transform/check_consts/validation.rs @@ -215,7 +215,7 @@ impl Validator<'mir, 'tcx> { && !tcx.is_thread_local_static(def_id.to_def_id()); if should_check_for_sync { - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); check_return_ty_is_sync(tcx, &body, hir_id); } } diff --git a/src/librustc_mir/transform/check_unsafety.rs b/src/librustc_mir/transform/check_unsafety.rs index 9c06e173bcd..d2a5616b8ed 100644 --- a/src/librustc_mir/transform/check_unsafety.rs +++ b/src/librustc_mir/transform/check_unsafety.rs @@ -483,7 +483,7 @@ fn check_unused_unsafe( used_unsafe: &FxHashSet<hir::HirId>, unsafe_blocks: &mut Vec<(hir::HirId, bool)>, ) { - let body_id = tcx.hir().maybe_body_owned_by(tcx.hir().as_local_hir_id(def_id)); + let body_id = tcx.hir().maybe_body_owned_by(tcx.hir().local_def_id_to_hir_id(def_id)); let body_id = match body_id { Some(body) => body, @@ -511,7 +511,7 @@ fn unsafety_check_result<'tcx>( let param_env = tcx.param_env(def.did); - let id = tcx.hir().as_local_hir_id(def.did); + let id = tcx.hir().local_def_id_to_hir_id(def.did); let (const_context, min_const_fn) = match tcx.hir().body_owner_kind(id) { hir::BodyOwnerKind::Closure => (false, false), hir::BodyOwnerKind::Fn => { @@ -532,7 +532,7 @@ fn unsafety_check_result<'tcx>( } fn unsafe_derive_on_repr_packed(tcx: TyCtxt<'_>, def_id: LocalDefId) { - let lint_hir_id = tcx.hir().as_local_hir_id(def_id); + let lint_hir_id = tcx.hir().local_def_id_to_hir_id(def_id); tcx.struct_span_lint_hir(SAFE_PACKED_BORROWS, lint_hir_id, tcx.def_span(def_id), |lint| { // FIXME: when we make this a hard error, this should have its diff --git a/src/librustc_mir/transform/const_prop.rs b/src/librustc_mir/transform/const_prop.rs index 6cf296f2a3f..7e8a94f181f 100644 --- a/src/librustc_mir/transform/const_prop.rs +++ b/src/librustc_mir/transform/const_prop.rs @@ -67,7 +67,7 @@ impl<'tcx> MirPass<'tcx> for ConstProp { } use rustc_middle::hir::map::blocks::FnLikeNode; - let hir_id = tcx.hir().as_local_hir_id(source.def_id().expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(source.def_id().expect_local()); let is_fn_like = FnLikeNode::from_node(tcx.hir().get(hir_id)).is_some(); let is_assoc_const = tcx.def_kind(source.def_id()) == DefKind::AssocConst; @@ -282,6 +282,14 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for ConstPropMachine<'mir, 'tcx> } #[inline(always)] + fn init_frame_extra( + _ecx: &mut InterpCx<'mir, 'tcx, Self>, + frame: Frame<'mir, 'tcx>, + ) -> InterpResult<'tcx, Frame<'mir, 'tcx>> { + Ok(frame) + } + + #[inline(always)] fn stack( ecx: &'a InterpCx<'mir, 'tcx, Self>, ) -> &'a [Frame<'mir, 'tcx, Self::PointerTag, Self::FrameExtra>] { diff --git a/src/librustc_mir/transform/deaggregator.rs b/src/librustc_mir/transform/deaggregator.rs index 2de701284e3..66989a90244 100644 --- a/src/librustc_mir/transform/deaggregator.rs +++ b/src/librustc_mir/transform/deaggregator.rs @@ -12,26 +12,24 @@ impl<'tcx> MirPass<'tcx> for Deaggregator { for bb in basic_blocks { bb.expand_statements(|stmt| { // FIXME(eddyb) don't match twice on `stmt.kind` (post-NLL). - if let StatementKind::Assign(box (_, ref rhs)) = stmt.kind { - if let Rvalue::Aggregate(ref kind, _) = *rhs { - // FIXME(#48193) Deaggregate arrays when it's cheaper to do so. - if let AggregateKind::Array(_) = **kind { - return None; - } - } else { + match stmt.kind { + // FIXME(#48193) Deaggregate arrays when it's cheaper to do so. + StatementKind::Assign(box ( + _, + Rvalue::Aggregate(box AggregateKind::Array(_), _), + )) => { return None; } - } else { - return None; + StatementKind::Assign(box (_, Rvalue::Aggregate(_, _))) => {} + _ => return None, } let stmt = stmt.replace_nop(); let source_info = stmt.source_info; let (lhs, kind, operands) = match stmt.kind { - StatementKind::Assign(box (lhs, rvalue)) => match rvalue { - Rvalue::Aggregate(kind, operands) => (lhs, kind, operands), - _ => bug!(), - }, + StatementKind::Assign(box (lhs, Rvalue::Aggregate(kind, operands))) => { + (lhs, kind, operands) + } _ => bug!(), }; diff --git a/src/librustc_mir/transform/inline.rs b/src/librustc_mir/transform/inline.rs index 92ea162e419..315d4fa9d47 100644 --- a/src/librustc_mir/transform/inline.rs +++ b/src/librustc_mir/transform/inline.rs @@ -75,7 +75,7 @@ impl Inliner<'tcx> { let param_env = self.tcx.param_env_reveal_all_normalized(self.source.def_id()); // Only do inlining into fn bodies. - let id = self.tcx.hir().as_local_hir_id(self.source.def_id().expect_local()); + let id = self.tcx.hir().local_def_id_to_hir_id(self.source.def_id().expect_local()); if self.tcx.hir().body_owner_kind(id).is_fn_or_closure() && self.source.promoted.is_none() { for (bb, bb_data) in caller_body.basic_blocks().iter_enumerated() { if let Some(callsite) = @@ -101,9 +101,9 @@ impl Inliner<'tcx> { } let callee_body = if let Some(callee_def_id) = callsite.callee.as_local() { - let callee_hir_id = self.tcx.hir().as_local_hir_id(callee_def_id); + let callee_hir_id = self.tcx.hir().local_def_id_to_hir_id(callee_def_id); let self_hir_id = - self.tcx.hir().as_local_hir_id(self.source.def_id().expect_local()); + self.tcx.hir().local_def_id_to_hir_id(self.source.def_id().expect_local()); // Avoid a cycle here by only using `optimized_mir` only if we have // a lower `HirId` than the callee. This ensures that the callee will // not inline us. This trick only works without incremental compilation. diff --git a/src/librustc_mir/transform/instrument_coverage.rs b/src/librustc_mir/transform/instrument_coverage.rs index 5b2954dd5b0..500d66ece06 100644 --- a/src/librustc_mir/transform/instrument_coverage.rs +++ b/src/librustc_mir/transform/instrument_coverage.rs @@ -295,6 +295,21 @@ impl<'a, 'tcx> Instrumentor<'a, 'tcx> { let (file_name, start_line, start_col, end_line, end_col) = self.code_region(&span); + // FIXME(richkadel): Note that `const_str()` results in the creation of an `Allocation` to + // hold one copy of each unique filename. It looks like that `Allocation` may translate into + // the creation of an `@alloc` in LLVM IR that is never actually used by runtime code. + // + // Example LLVM IR: + // + // @alloc4 = private unnamed_addr constant <{ [43 x i8] }> \ + // <{ [43 x i8] c"C:\\msys64\\home\\richkadel\\rust\\rust_basic.rs" }>, align 1 + // + // Can I flag the alloc as something not to be added to codegen? Or somehow remove it before + // it gets added to the LLVM IR? Do we need some kind of reference counting to know it's + // not used by any runtime code? + // + // This question is moot if I convert the Call Terminators to Statements, I believe: + // https://rust-lang.zulipchat.com/#narrow/stream/233931-t-compiler.2Fmajor-changes/topic/Implement.20LLVM-compatible.20source-based.20cod.20compiler-team.23278/near/206731748 args.push(self.const_str(&file_name, inject_at)); args.push(self.const_u32(start_line, inject_at)); args.push(self.const_u32(start_col, inject_at)); diff --git a/src/librustc_mir/transform/match_branches.rs b/src/librustc_mir/transform/match_branches.rs new file mode 100644 index 00000000000..c1d574d6ef2 --- /dev/null +++ b/src/librustc_mir/transform/match_branches.rs @@ -0,0 +1,135 @@ +use crate::transform::{MirPass, MirSource}; +use rustc_middle::mir::*; +use rustc_middle::ty::TyCtxt; + +pub struct MatchBranchSimplification; + +/// If a source block is found that switches between two blocks that are exactly +/// the same modulo const bool assignments (e.g., one assigns true another false +/// to the same place), merge a target block statements into the source block, +/// using Eq / Ne comparison with switch value where const bools value differ. +/// +/// For example: +/// +/// ```rust +/// bb0: { +/// switchInt(move _3) -> [42_isize: bb1, otherwise: bb2]; +/// } +/// +/// bb1: { +/// _2 = const true; +/// goto -> bb3; +/// } +/// +/// bb2: { +/// _2 = const false; +/// goto -> bb3; +/// } +/// ``` +/// +/// into: +/// +/// ```rust +/// bb0: { +/// _2 = Eq(move _3, const 42_isize); +/// goto -> bb3; +/// } +/// ``` + +impl<'tcx> MirPass<'tcx> for MatchBranchSimplification { + fn run_pass(&self, tcx: TyCtxt<'tcx>, src: MirSource<'tcx>, body: &mut Body<'tcx>) { + let param_env = tcx.param_env(src.def_id()); + let bbs = body.basic_blocks_mut(); + 'outer: for bb_idx in bbs.indices() { + let (discr, val, switch_ty, first, second) = match bbs[bb_idx].terminator().kind { + TerminatorKind::SwitchInt { + discr: Operand::Copy(ref place) | Operand::Move(ref place), + switch_ty, + ref targets, + ref values, + .. + } if targets.len() == 2 && values.len() == 1 && targets[0] != targets[1] => { + (place, values[0], switch_ty, targets[0], targets[1]) + } + // Only optimize switch int statements + _ => continue, + }; + + // Check that destinations are identical, and if not, then don't optimize this block + if &bbs[first].terminator().kind != &bbs[second].terminator().kind { + continue; + } + + // Check that blocks are assignments of consts to the same place or same statement, + // and match up 1-1, if not don't optimize this block. + let first_stmts = &bbs[first].statements; + let scnd_stmts = &bbs[second].statements; + if first_stmts.len() != scnd_stmts.len() { + continue; + } + for (f, s) in first_stmts.iter().zip(scnd_stmts.iter()) { + match (&f.kind, &s.kind) { + // If two statements are exactly the same, we can optimize. + (f_s, s_s) if f_s == s_s => {} + + // If two statements are const bool assignments to the same place, we can optimize. + ( + StatementKind::Assign(box (lhs_f, Rvalue::Use(Operand::Constant(f_c)))), + StatementKind::Assign(box (lhs_s, Rvalue::Use(Operand::Constant(s_c)))), + ) if lhs_f == lhs_s + && f_c.literal.ty.is_bool() + && s_c.literal.ty.is_bool() + && f_c.literal.try_eval_bool(tcx, param_env).is_some() + && s_c.literal.try_eval_bool(tcx, param_env).is_some() => {} + + // Otherwise we cannot optimize. Try another block. + _ => continue 'outer, + } + } + // Take ownership of items now that we know we can optimize. + let discr = discr.clone(); + + // We already checked that first and second are different blocks, + // and bb_idx has a different terminator from both of them. + let (from, first, second) = bbs.pick3_mut(bb_idx, first, second); + + let new_stmts = first.statements.iter().zip(second.statements.iter()).map(|(f, s)| { + match (&f.kind, &s.kind) { + (f_s, s_s) if f_s == s_s => (*f).clone(), + + ( + StatementKind::Assign(box (lhs, Rvalue::Use(Operand::Constant(f_c)))), + StatementKind::Assign(box (_, Rvalue::Use(Operand::Constant(s_c)))), + ) => { + // From earlier loop we know that we are dealing with bool constants only: + let f_b = f_c.literal.try_eval_bool(tcx, param_env).unwrap(); + let s_b = s_c.literal.try_eval_bool(tcx, param_env).unwrap(); + if f_b == s_b { + // Same value in both blocks. Use statement as is. + (*f).clone() + } else { + // Different value between blocks. Make value conditional on switch condition. + let size = tcx.layout_of(param_env.and(switch_ty)).unwrap().size; + let const_cmp = Operand::const_from_scalar( + tcx, + switch_ty, + crate::interpret::Scalar::from_uint(val, size), + rustc_span::DUMMY_SP, + ); + let op = if f_b { BinOp::Eq } else { BinOp::Ne }; + let rhs = Rvalue::BinaryOp(op, Operand::Copy(discr.clone()), const_cmp); + Statement { + source_info: f.source_info, + kind: StatementKind::Assign(box (*lhs, rhs)), + } + } + } + + _ => unreachable!(), + } + }); + from.statements.extend(new_stmts); + from.terminator_mut().kind = first.terminator().kind.clone(); + } + } +} diff --git a/src/librustc_mir/transform/mod.rs b/src/librustc_mir/transform/mod.rs index 3803ee78fd4..4f26f3bb459 100644 --- a/src/librustc_mir/transform/mod.rs +++ b/src/librustc_mir/transform/mod.rs @@ -29,6 +29,7 @@ pub mod generator; pub mod inline; pub mod instcombine; pub mod instrument_coverage; +pub mod match_branches; pub mod no_landing_pads; pub mod nrvo; pub mod promote_consts; @@ -440,6 +441,7 @@ fn run_optimization_passes<'tcx>( // with async primitives. &generator::StateTransform, &instcombine::InstCombine, + &match_branches::MatchBranchSimplification, &const_prop::ConstProp, &simplify_branches::SimplifyBranches::new("after-const-prop"), &simplify_try::SimplifyArmIdentity, diff --git a/src/librustc_mir/transform/promote_consts.rs b/src/librustc_mir/transform/promote_consts.rs index c0564105701..94637bae44a 100644 --- a/src/librustc_mir/transform/promote_consts.rs +++ b/src/librustc_mir/transform/promote_consts.rs @@ -101,7 +101,7 @@ impl TempState { /// of a larger candidate. #[derive(Copy, Clone, PartialEq, Eq, Debug)] pub enum Candidate { - /// Borrow of a constant temporary. + /// Borrow of a constant temporary, candidate for lifetime extension. Ref(Location), /// Promotion of the `x` in `[x; 32]`. diff --git a/src/librustc_mir/transform/qualify_min_const_fn.rs b/src/librustc_mir/transform/qualify_min_const_fn.rs index dfd01e27d57..7abb09885ff 100644 --- a/src/librustc_mir/transform/qualify_min_const_fn.rs +++ b/src/librustc_mir/transform/qualify_min_const_fn.rs @@ -14,7 +14,7 @@ type McfResult = Result<(), (Span, Cow<'static, str>)>; pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, def_id: DefId, body: &'a Body<'tcx>) -> McfResult { // Prevent const trait methods from being annotated as `stable`. if tcx.features().staged_api { - let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); if crate::const_eval::is_parent_const_impl_raw(tcx, hir_id) { return Err((body.span, "trait methods cannot be stable const fn".into())); } diff --git a/src/librustc_mir/transform/simplify_try.rs b/src/librustc_mir/transform/simplify_try.rs index 02896d7de35..84082edd193 100644 --- a/src/librustc_mir/transform/simplify_try.rs +++ b/src/librustc_mir/transform/simplify_try.rs @@ -246,12 +246,14 @@ fn get_arm_identity_info<'a, 'tcx>( tmp_assigned_vars.insert(*r); } - let mut dbg_info_to_adjust = Vec::new(); - for (i, var_info) in debug_info.iter().enumerate() { - if tmp_assigned_vars.contains(var_info.place.local) { - dbg_info_to_adjust.push(i); - } - } + let dbg_info_to_adjust: Vec<_> = + debug_info + .iter() + .enumerate() + .filter_map(|(i, var_info)| { + if tmp_assigned_vars.contains(var_info.place.local) { Some(i) } else { None } + }) + .collect(); Some(ArmIdentityInfo { local_temp_0: local_tmp_s0, @@ -461,14 +463,14 @@ fn match_get_variant_field<'tcx>( stmt: &Statement<'tcx>, ) -> Option<(Local, Local, VarField<'tcx>, &'tcx List<PlaceElem<'tcx>>)> { match &stmt.kind { - StatementKind::Assign(box (place_into, rvalue_from)) => match rvalue_from { - Rvalue::Use(Operand::Copy(pf) | Operand::Move(pf)) => { - let local_into = place_into.as_local()?; - let (local_from, vf) = match_variant_field_place(*pf)?; - Some((local_into, local_from, vf, pf.projection)) - } - _ => None, - }, + StatementKind::Assign(box ( + place_into, + Rvalue::Use(Operand::Copy(pf) | Operand::Move(pf)), + )) => { + let local_into = place_into.as_local()?; + let (local_from, vf) = match_variant_field_place(*pf)?; + Some((local_into, local_from, vf, pf.projection)) + } _ => None, } } @@ -479,14 +481,11 @@ fn match_get_variant_field<'tcx>( /// ``` fn match_set_variant_field<'tcx>(stmt: &Statement<'tcx>) -> Option<(Local, Local, VarField<'tcx>)> { match &stmt.kind { - StatementKind::Assign(box (place_from, rvalue_into)) => match rvalue_into { - Rvalue::Use(Operand::Move(place_into)) => { - let local_into = place_into.as_local()?; - let (local_from, vf) = match_variant_field_place(*place_from)?; - Some((local_into, local_from, vf)) - } - _ => None, - }, + StatementKind::Assign(box (place_from, Rvalue::Use(Operand::Move(place_into)))) => { + let local_into = place_into.as_local()?; + let (local_from, vf) = match_variant_field_place(*place_from)?; + Some((local_into, local_from, vf)) + } _ => None, } } diff --git a/src/librustc_mir/transform/uninhabited_enum_branching.rs b/src/librustc_mir/transform/uninhabited_enum_branching.rs index e3b182b8849..4cca4d223c0 100644 --- a/src/librustc_mir/transform/uninhabited_enum_branching.rs +++ b/src/librustc_mir/transform/uninhabited_enum_branching.rs @@ -99,26 +99,18 @@ impl<'tcx> MirPass<'tcx> for UninhabitedEnumBranching { if let TerminatorKind::SwitchInt { values, targets, .. } = &mut body.basic_blocks_mut()[bb].terminator_mut().kind { - let vals = &*values; - let zipped = vals.iter().zip(targets.iter()); - - let mut matched_values = Vec::with_capacity(allowed_variants.len()); - let mut matched_targets = Vec::with_capacity(allowed_variants.len() + 1); - - for (val, target) in zipped { - if allowed_variants.contains(val) { - matched_values.push(*val); - matched_targets.push(*target); - } else { - trace!("eliminating {:?} -> {:?}", val, target); - } - } - - // handle the "otherwise" branch - matched_targets.push(targets.pop().unwrap()); - - *values = matched_values.into(); - *targets = matched_targets; + // take otherwise out early + let otherwise = targets.pop().unwrap(); + assert_eq!(targets.len(), values.len()); + let mut i = 0; + targets.retain(|_| { + let keep = allowed_variants.contains(&values[i]); + i += 1; + keep + }); + targets.push(otherwise); + + values.to_mut().retain(|var| allowed_variants.contains(var)); } else { unreachable!() } diff --git a/src/librustc_mir/transform/unreachable_prop.rs b/src/librustc_mir/transform/unreachable_prop.rs index d9f2259030f..fa362c66fb2 100644 --- a/src/librustc_mir/transform/unreachable_prop.rs +++ b/src/librustc_mir/transform/unreachable_prop.rs @@ -67,18 +67,13 @@ fn remove_successors<F>( where F: Fn(BasicBlock) -> bool, { - match *terminator_kind { - TerminatorKind::Goto { target } if predicate(target) => Some(TerminatorKind::Unreachable), + let terminator = match *terminator_kind { + TerminatorKind::Goto { target } if predicate(target) => TerminatorKind::Unreachable, TerminatorKind::SwitchInt { ref discr, switch_ty, ref values, ref targets } => { let original_targets_len = targets.len(); let (otherwise, targets) = targets.split_last().unwrap(); - let retained = values - .iter() - .zip(targets.iter()) - .filter(|(_, &t)| !predicate(t)) - .collect::<Vec<_>>(); - let mut values = retained.iter().map(|&(v, _)| *v).collect::<Vec<_>>(); - let mut targets = retained.iter().map(|&(_, d)| *d).collect::<Vec<_>>(); + let (mut values, mut targets): (Vec<_>, Vec<_>) = + values.iter().zip(targets.iter()).filter(|(_, &t)| !predicate(t)).unzip(); if !predicate(*otherwise) { targets.push(*otherwise); @@ -89,20 +84,21 @@ where let retained_targets_len = targets.len(); if targets.is_empty() { - Some(TerminatorKind::Unreachable) + TerminatorKind::Unreachable } else if targets.len() == 1 { - Some(TerminatorKind::Goto { target: targets[0] }) + TerminatorKind::Goto { target: targets[0] } } else if original_targets_len != retained_targets_len { - Some(TerminatorKind::SwitchInt { + TerminatorKind::SwitchInt { discr: discr.clone(), switch_ty, values: Cow::from(values), targets, - }) + } } else { - None + return None; } } - _ => None, - } + _ => return None, + }; + Some(terminator) } diff --git a/src/librustc_mir_build/Cargo.toml b/src/librustc_mir_build/Cargo.toml index 96059fa43e5..97621f205fb 100644 --- a/src/librustc_mir_build/Cargo.toml +++ b/src/librustc_mir_build/Cargo.toml @@ -11,7 +11,7 @@ doctest = false [dependencies] rustc_arena = { path = "../librustc_arena" } -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc_middle = { path = "../librustc_middle" } rustc_apfloat = { path = "../librustc_apfloat" } rustc_attr = { path = "../librustc_attr" } diff --git a/src/librustc_mir_build/build/mod.rs b/src/librustc_mir_build/build/mod.rs index f3f3c3e33a4..0c3f6fee665 100644 --- a/src/librustc_mir_build/build/mod.rs +++ b/src/librustc_mir_build/build/mod.rs @@ -10,7 +10,6 @@ use rustc_hir::lang_items; use rustc_hir::{GeneratorKind, HirIdMap, Node}; use rustc_index::vec::{Idx, IndexVec}; use rustc_infer::infer::TyCtxtInferExt; -use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags; use rustc_middle::middle::region; use rustc_middle::mir::*; use rustc_middle::ty::subst::Subst; @@ -35,7 +34,7 @@ crate fn mir_built<'tcx>( /// Construct the MIR for a given `DefId`. fn mir_build(tcx: TyCtxt<'_>, def: ty::WithOptConstParam<LocalDefId>) -> Body<'_> { - let id = tcx.hir().as_local_hir_id(def.did); + let id = tcx.hir().local_def_id_to_hir_id(def.did); // Figure out what primary body this item has. let (body_id, return_ty_span) = match tcx.hir().get(id) { @@ -798,22 +797,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { argument_scope: region::Scope, ast_body: &'tcx hir::Expr<'tcx>, ) -> BlockAnd<()> { - let tcx = self.hir.tcx(); - let attrs = tcx.codegen_fn_attrs(fn_def_id); - let naked = attrs.flags.contains(CodegenFnAttrFlags::NAKED); - // Allocate locals for the function arguments for &ArgInfo(ty, _, arg_opt, _) in arguments.iter() { let source_info = SourceInfo::outermost(arg_opt.map_or(self.fn_span, |arg| arg.pat.span)); let arg_local = self.local_decls.push(LocalDecl::with_source_info(ty, source_info)); - // Emit function argument debuginfo only for non-naked functions. - // See: https://github.com/rust-lang/rust/issues/42779 - if naked { - continue; - } - // If this is a simple binding pattern, give debuginfo a nice name. if let Some(arg) = arg_opt { if let Some(ident) = arg.pat.simple_ident() { @@ -826,6 +815,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> { } } + let tcx = self.hir.tcx(); let tcx_hir = tcx.hir(); let hir_typeck_results = self.hir.typeck_results(); diff --git a/src/librustc_mir_build/lib.rs b/src/librustc_mir_build/lib.rs index 30545558933..313bb979a51 100644 --- a/src/librustc_mir_build/lib.rs +++ b/src/librustc_mir_build/lib.rs @@ -12,7 +12,7 @@ #![recursion_limit = "256"] #[macro_use] -extern crate log; +extern crate tracing; #[macro_use] extern crate rustc_middle; diff --git a/src/librustc_mir_build/lints.rs b/src/librustc_mir_build/lints.rs index ac5d128a1ba..662b6c77357 100644 --- a/src/librustc_mir_build/lints.rs +++ b/src/librustc_mir_build/lints.rs @@ -11,7 +11,7 @@ use rustc_session::lint::builtin::UNCONDITIONAL_RECURSION; use rustc_span::Span; crate fn check<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, def_id: LocalDefId) { - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); if let Some(fn_like_node) = FnLikeNode::from_node(tcx.hir().get(hir_id)) { if let FnKind::Closure(_) = fn_like_node.kind() { @@ -37,7 +37,7 @@ crate fn check<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, def_id: LocalDefId) { vis.reachable_recursive_calls.sort(); - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let sp = tcx.sess.source_map().guess_head_span(tcx.hir().span(hir_id)); tcx.struct_span_lint_hir(UNCONDITIONAL_RECURSION, hir_id, sp, |lint| { let mut db = lint.build("function cannot return without recursing"); diff --git a/src/librustc_mir_build/thir/cx/expr.rs b/src/librustc_mir_build/thir/cx/expr.rs index ea41a66b3e4..c51c3bcf562 100644 --- a/src/librustc_mir_build/thir/cx/expr.rs +++ b/src/librustc_mir_build/thir/cx/expr.rs @@ -781,7 +781,7 @@ fn convert_path_expr<'a, 'tcx>( } Res::Def(DefKind::ConstParam, def_id) => { - let hir_id = cx.tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let item_id = cx.tcx.hir().get_parent_node(hir_id); let item_def_id = cx.tcx.hir().local_def_id(item_id); let generics = cx.tcx.generics_of(item_def_id); diff --git a/src/librustc_mir_build/thir/pattern/check_match.rs b/src/librustc_mir_build/thir/pattern/check_match.rs index 744f319205f..1687286093d 100644 --- a/src/librustc_mir_build/thir/pattern/check_match.rs +++ b/src/librustc_mir_build/thir/pattern/check_match.rs @@ -23,7 +23,7 @@ use std::slice; crate fn check_match(tcx: TyCtxt<'_>, def_id: DefId) { let body_id = match def_id.as_local() { None => return, - Some(id) => tcx.hir().body_owned_by(tcx.hir().as_local_hir_id(id)), + Some(id) => tcx.hir().body_owned_by(tcx.hir().local_def_id_to_hir_id(id)), }; let mut visitor = MatchVisitor { diff --git a/src/librustc_parse/Cargo.toml b/src/librustc_parse/Cargo.toml index 25144bd610d..31d858849af 100644 --- a/src/librustc_parse/Cargo.toml +++ b/src/librustc_parse/Cargo.toml @@ -11,7 +11,7 @@ doctest = false [dependencies] bitflags = "1.0" -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc_ast_pretty = { path = "../librustc_ast_pretty" } rustc_data_structures = { path = "../librustc_data_structures" } rustc_feature = { path = "../librustc_feature" } diff --git a/src/librustc_parse/lexer/mod.rs b/src/librustc_parse/lexer/mod.rs index c3a79660eb9..675cfa41f10 100644 --- a/src/librustc_parse/lexer/mod.rs +++ b/src/librustc_parse/lexer/mod.rs @@ -8,8 +8,8 @@ use rustc_session::parse::ParseSess; use rustc_span::symbol::{sym, Symbol}; use rustc_span::{BytePos, Pos, Span}; -use log::debug; use std::char; +use tracing::debug; mod tokentrees; mod unescape_error_reporting; diff --git a/src/librustc_parse/lexer/unescape_error_reporting.rs b/src/librustc_parse/lexer/unescape_error_reporting.rs index d41775a143a..6f249f491a6 100644 --- a/src/librustc_parse/lexer/unescape_error_reporting.rs +++ b/src/librustc_parse/lexer/unescape_error_reporting.rs @@ -18,7 +18,7 @@ pub(crate) fn emit_unescape_error( range: Range<usize>, error: EscapeError, ) { - log::debug!( + tracing::debug!( "emit_unescape_error: {:?}, {:?}, {:?}, {:?}, {:?}", lit, span_with_quotes, diff --git a/src/librustc_parse/lib.rs b/src/librustc_parse/lib.rs index 723e4333790..829e1a97b10 100644 --- a/src/librustc_parse/lib.rs +++ b/src/librustc_parse/lib.rs @@ -20,7 +20,7 @@ use std::mem; use std::path::Path; use std::str; -use log::{debug, info}; +use tracing::{debug, info}; pub const MACRO_ARGUMENTS: Option<&'static str> = Some("macro arguments"); diff --git a/src/librustc_parse/parser/attr.rs b/src/librustc_parse/parser/attr.rs index b6a8ee71beb..c942394fa7c 100644 --- a/src/librustc_parse/parser/attr.rs +++ b/src/librustc_parse/parser/attr.rs @@ -6,7 +6,7 @@ use rustc_ast_pretty::pprust; use rustc_errors::{error_code, PResult}; use rustc_span::Span; -use log::debug; +use tracing::debug; #[derive(Debug)] pub(super) enum InnerAttrPolicy<'a> { diff --git a/src/librustc_parse/parser/diagnostics.rs b/src/librustc_parse/parser/diagnostics.rs index 2854356ab0f..27e1bb01d52 100644 --- a/src/librustc_parse/parser/diagnostics.rs +++ b/src/librustc_parse/parser/diagnostics.rs @@ -16,7 +16,7 @@ use rustc_span::source_map::Spanned; use rustc_span::symbol::{kw, Ident}; use rustc_span::{MultiSpan, Span, SpanSnippetError, DUMMY_SP}; -use log::{debug, trace}; +use tracing::{debug, trace}; const TURBOFISH: &str = "use `::<...>` instead of `<...>` to specify type arguments"; diff --git a/src/librustc_parse/parser/expr.rs b/src/librustc_parse/parser/expr.rs index 9b99eb2e0bd..0ceb588b3af 100644 --- a/src/librustc_parse/parser/expr.rs +++ b/src/librustc_parse/parser/expr.rs @@ -4,7 +4,6 @@ use super::{BlockMode, Parser, PathStyle, Restrictions, TokenType}; use super::{SemiColonMode, SeqSep, TokenExpectType}; use crate::maybe_recover_from_interpolated_ty_qpath; -use log::debug; use rustc_ast::ast::{self, AttrStyle, AttrVec, CaptureBy, Field, Lit, UnOp, DUMMY_NODE_ID}; use rustc_ast::ast::{AnonConst, BinOp, BinOpKind, FnDecl, FnRetTy, MacCall, Param, Ty, TyKind}; use rustc_ast::ast::{Arm, Async, BlockCheckMode, Expr, ExprKind, Label, Movability, RangeLimits}; @@ -18,6 +17,7 @@ use rustc_errors::{Applicability, DiagnosticBuilder, PResult}; use rustc_span::source_map::{self, Span, Spanned}; use rustc_span::symbol::{kw, sym, Ident, Symbol}; use std::mem; +use tracing::debug; /// Possibly accepts an `token::Interpolated` expression (a pre-parsed expression /// dropped into the token stream, which happens while parsing the result of @@ -318,11 +318,18 @@ impl<'a> Parser<'a> { // want to keep their span info to improve diagnostics in these cases in a later stage. (true, Some(AssocOp::Multiply)) | // `{ 42 } *foo = bar;` or `{ 42 } * 3` (true, Some(AssocOp::Subtract)) | // `{ 42 } -5` - (true, Some(AssocOp::LAnd)) | // `{ 42 } &&x` (#61475) (true, Some(AssocOp::Add)) // `{ 42 } + 42 // If the next token is a keyword, then the tokens above *are* unambiguously incorrect: // `if x { a } else { b } && if y { c } else { d }` - if !self.look_ahead(1, |t| t.is_reserved_ident()) => { + if !self.look_ahead(1, |t| t.is_used_keyword()) => { + // These cases are ambiguous and can't be identified in the parser alone. + let sp = self.sess.source_map().start_point(self.token.span); + self.sess.ambiguous_block_expr_parse.borrow_mut().insert(sp, lhs.span); + false + } + (true, Some(AssocOp::LAnd)) => { + // `{ 42 } &&x` (#61475) or `{ 42 } && if x { 1 } else { 0 }`. Separated from the + // above due to #74233. // These cases are ambiguous and can't be identified in the parser alone. let sp = self.sess.source_map().start_point(self.token.span); self.sess.ambiguous_block_expr_parse.borrow_mut().insert(sp, lhs.span); diff --git a/src/librustc_parse/parser/item.rs b/src/librustc_parse/parser/item.rs index 10d214e52ab..ce2dd15ab26 100644 --- a/src/librustc_parse/parser/item.rs +++ b/src/librustc_parse/parser/item.rs @@ -20,9 +20,9 @@ use rustc_span::edition::Edition; use rustc_span::source_map::{self, Span}; use rustc_span::symbol::{kw, sym, Ident, Symbol}; -use log::debug; use std::convert::TryFrom; use std::mem; +use tracing::debug; impl<'a> Parser<'a> { /// Parses a source module as a crate. This is the main entry point for the parser. @@ -1313,7 +1313,7 @@ impl<'a> Parser<'a> { vis: Visibility, attrs: Vec<Attribute>, ) -> PResult<'a, StructField> { - let name = self.parse_ident()?; + let name = self.parse_ident_common(false)?; self.expect(&token::Colon)?; let ty = self.parse_ty()?; Ok(StructField { diff --git a/src/librustc_parse/parser/mod.rs b/src/librustc_parse/parser/mod.rs index b33ae4bed82..a30131e4f7a 100644 --- a/src/librustc_parse/parser/mod.rs +++ b/src/librustc_parse/parser/mod.rs @@ -13,7 +13,6 @@ use crate::lexer::UnmatchedBrace; use diagnostics::Error; pub use path::PathStyle; -use log::debug; use rustc_ast::ast::DUMMY_NODE_ID; use rustc_ast::ast::{self, AttrStyle, AttrVec, Const, CrateSugar, Extern, Unsafe}; use rustc_ast::ast::{ @@ -27,6 +26,7 @@ use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, FatalError use rustc_session::parse::ParseSess; use rustc_span::source_map::{respan, Span, DUMMY_SP}; use rustc_span::symbol::{kw, sym, Ident, Symbol}; +use tracing::debug; use std::{cmp, mem, slice}; diff --git a/src/librustc_parse/parser/path.rs b/src/librustc_parse/parser/path.rs index d4e44c54b12..0f2b46f7e16 100644 --- a/src/librustc_parse/parser/path.rs +++ b/src/librustc_parse/parser/path.rs @@ -10,8 +10,8 @@ use rustc_errors::{pluralize, Applicability, PResult}; use rustc_span::source_map::{BytePos, Span}; use rustc_span::symbol::{kw, sym, Ident}; -use log::debug; use std::mem; +use tracing::debug; /// Specifies how to parse a path. #[derive(Copy, Clone, PartialEq)] diff --git a/src/librustc_passes/Cargo.toml b/src/librustc_passes/Cargo.toml index d9fa435e3ad..db481c0d0d4 100644 --- a/src/librustc_passes/Cargo.toml +++ b/src/librustc_passes/Cargo.toml @@ -9,7 +9,7 @@ name = "rustc_passes" path = "lib.rs" [dependencies] -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc_middle = { path = "../librustc_middle" } rustc_attr = { path = "../librustc_attr" } rustc_data_structures = { path = "../librustc_data_structures" } diff --git a/src/librustc_passes/dead.rs b/src/librustc_passes/dead.rs index 0e5298acc2c..29939c7cfaf 100644 --- a/src/librustc_passes/dead.rs +++ b/src/librustc_passes/dead.rs @@ -62,7 +62,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> { fn check_def_id(&mut self, def_id: DefId) { if let Some(def_id) = def_id.as_local() { - let hir_id = self.tcx.hir().as_local_hir_id(def_id); + let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); if should_explore(self.tcx, hir_id) || self.struct_constructors.contains_key(&hir_id) { self.worklist.push(hir_id); } @@ -72,7 +72,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> { fn insert_def_id(&mut self, def_id: DefId) { if let Some(def_id) = def_id.as_local() { - let hir_id = self.tcx.hir().as_local_hir_id(def_id); + let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); debug_assert!(!should_explore(self.tcx, hir_id)); self.live_symbols.insert(hir_id); } @@ -461,7 +461,7 @@ fn create_and_seed_worklist<'tcx>( ) .chain( // Seed entry point - tcx.entry_fn(LOCAL_CRATE).map(|(def_id, _)| tcx.hir().as_local_hir_id(def_id)), + tcx.entry_fn(LOCAL_CRATE).map(|(def_id, _)| tcx.hir().local_def_id_to_hir_id(def_id)), ) .collect::<Vec<_>>(); @@ -546,7 +546,7 @@ impl DeadVisitor<'tcx> { for &impl_did in inherent_impls.iter() { for &item_did in &self.tcx.associated_item_def_ids(impl_did)[..] { if let Some(did) = item_did.as_local() { - let item_hir_id = self.tcx.hir().as_local_hir_id(did); + let item_hir_id = self.tcx.hir().local_def_id_to_hir_id(did); if self.live_symbols.contains(&item_hir_id) { return true; } diff --git a/src/librustc_passes/lib.rs b/src/librustc_passes/lib.rs index 95b236ba1c9..be4c542ec3a 100644 --- a/src/librustc_passes/lib.rs +++ b/src/librustc_passes/lib.rs @@ -13,7 +13,7 @@ #[macro_use] extern crate rustc_middle; #[macro_use] -extern crate log; +extern crate tracing; use rustc_middle::ty::query::Providers; diff --git a/src/librustc_passes/reachable.rs b/src/librustc_passes/reachable.rs index c71dbdf515a..18fa4ada4da 100644 --- a/src/librustc_passes/reachable.rs +++ b/src/librustc_passes/reachable.rs @@ -53,7 +53,7 @@ fn method_might_be_inlined( return true; } } - match tcx.hir().find(tcx.hir().as_local_hir_id(impl_src)) { + match tcx.hir().find(tcx.hir().local_def_id_to_hir_id(impl_src)) { Some(Node::Item(item)) => item_might_be_inlined(tcx, &item, codegen_fn_attrs), Some(..) | None => span_bug!(impl_item.span, "impl did is not an item"), } @@ -106,7 +106,9 @@ impl<'tcx> Visitor<'tcx> for ReachableContext<'tcx> { } Some(res) => { if let Some((hir_id, def_id)) = res.opt_def_id().and_then(|def_id| { - def_id.as_local().map(|def_id| (self.tcx.hir().as_local_hir_id(def_id), def_id)) + def_id + .as_local() + .map(|def_id| (self.tcx.hir().local_def_id_to_hir_id(def_id), def_id)) }) { if self.def_id_represents_local_inlined_item(def_id.to_def_id()) { self.worklist.push(hir_id); @@ -149,7 +151,7 @@ impl<'tcx> ReachableContext<'tcx> { // eligible for inlining and false otherwise. fn def_id_represents_local_inlined_item(&self, def_id: DefId) -> bool { let hir_id = match def_id.as_local() { - Some(def_id) => self.tcx.hir().as_local_hir_id(def_id), + Some(def_id) => self.tcx.hir().local_def_id_to_hir_id(def_id), None => { return false; } @@ -181,7 +183,7 @@ impl<'tcx> ReachableContext<'tcx> { // Check the impl. If the generics on the self // type of the impl require inlining, this method // does too. - let impl_hir_id = self.tcx.hir().as_local_hir_id(impl_did); + let impl_hir_id = self.tcx.hir().local_def_id_to_hir_id(impl_did); match self.tcx.hir().expect_item(impl_hir_id).kind { hir::ItemKind::Impl { .. } => { let generics = self.tcx.generics_of(impl_did); @@ -366,10 +368,10 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CollectPrivateImplItemsVisitor<'a, 'tcx // FIXME(#53488) remove `let` let tcx = self.tcx; - self.worklist.extend( - tcx.provided_trait_methods(trait_def_id) - .map(|assoc| tcx.hir().as_local_hir_id(assoc.def_id.expect_local())), - ); + self.worklist + .extend(tcx.provided_trait_methods(trait_def_id).map(|assoc| { + tcx.hir().local_def_id_to_hir_id(assoc.def_id.expect_local()) + })); } } } @@ -406,7 +408,7 @@ fn reachable_set<'tcx>(tcx: TyCtxt<'tcx>, crate_num: CrateNum) -> &'tcx HirIdSet reachable_context.worklist.extend(access_levels.map.iter().map(|(id, _)| *id)); for item in tcx.lang_items().items().iter() { if let Some(did) = *item { - if let Some(hir_id) = did.as_local().map(|did| tcx.hir().as_local_hir_id(did)) { + if let Some(hir_id) = did.as_local().map(|did| tcx.hir().local_def_id_to_hir_id(did)) { reachable_context.worklist.push(hir_id); } } diff --git a/src/librustc_passes/region.rs b/src/librustc_passes/region.rs index b2a89651881..1af79abe4b9 100644 --- a/src/librustc_passes/region.rs +++ b/src/librustc_passes/region.rs @@ -807,7 +807,7 @@ fn region_scope_tree(tcx: TyCtxt<'_>, def_id: DefId) -> &ScopeTree { return tcx.region_scope_tree(closure_base_def_id); } - let id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let scope_tree = if let Some(body_id) = tcx.hir().maybe_body_owned_by(id) { let mut visitor = RegionResolutionVisitor { tcx, diff --git a/src/librustc_passes/upvars.rs b/src/librustc_passes/upvars.rs index 3aed4942563..91b8ae07637 100644 --- a/src/librustc_passes/upvars.rs +++ b/src/librustc_passes/upvars.rs @@ -15,7 +15,7 @@ pub fn provide(providers: &mut Providers) { return None; } - let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let body = tcx.hir().body(tcx.hir().maybe_body_owned_by(hir_id)?); let mut local_collector = LocalCollector::default(); diff --git a/src/librustc_privacy/Cargo.toml b/src/librustc_privacy/Cargo.toml index 6f543e71b42..3641f0f8a31 100644 --- a/src/librustc_privacy/Cargo.toml +++ b/src/librustc_privacy/Cargo.toml @@ -17,4 +17,4 @@ rustc_typeck = { path = "../librustc_typeck" } rustc_session = { path = "../librustc_session" } rustc_span = { path = "../librustc_span" } rustc_data_structures = { path = "../librustc_data_structures" } -log = { package = "tracing", version = "0.1" } +tracing = "0.1" diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 3ba5acd00a0..a3f2668691f 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -226,7 +226,7 @@ fn def_id_visibility<'tcx>( tcx: TyCtxt<'tcx>, def_id: DefId, ) -> (ty::Visibility, Span, &'static str) { - match def_id.as_local().map(|def_id| tcx.hir().as_local_hir_id(def_id)) { + match def_id.as_local().map(|def_id| tcx.hir().local_def_id_to_hir_id(def_id)) { Some(hir_id) => { let vis = match tcx.hir().get(hir_id) { Node::Item(item) => &item.vis, @@ -431,7 +431,7 @@ impl VisibilityLike for Option<AccessLevel> { fn new_min(find: &FindMin<'_, '_, Self>, def_id: DefId) -> Self { cmp::min( if let Some(def_id) = def_id.as_local() { - let hir_id = find.tcx.hir().as_local_hir_id(def_id); + let hir_id = find.tcx.hir().local_def_id_to_hir_id(def_id); find.access_levels.map.get(&hir_id).cloned() } else { Self::MAX @@ -533,7 +533,7 @@ impl EmbargoVisitor<'tcx> { if let Res::Def(def_kind, def_id) = export.res { let vis = def_id_visibility(self.tcx, def_id).0; if let Some(def_id) = def_id.as_local() { - let hir_id = self.tcx.hir().as_local_hir_id(def_id); + let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); self.update_macro_reachable_def(hir_id, def_kind, vis, defining_mod); } } @@ -650,7 +650,7 @@ impl EmbargoVisitor<'tcx> { // there will be no corresponding item. .filter(|def_id| def_id.index != CRATE_DEF_INDEX || def_id.krate != LOCAL_CRATE) .and_then(|def_id| { - def_id.as_local().map(|def_id| self.tcx.hir().as_local_hir_id(def_id)) + def_id.as_local().map(|def_id| self.tcx.hir().local_def_id_to_hir_id(def_id)) }) .map(|module_hir_id| self.tcx.hir().expect_item(module_hir_id)) { @@ -913,7 +913,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { if export.vis == ty::Visibility::Public { if let Some(def_id) = export.res.opt_def_id() { if let Some(def_id) = def_id.as_local() { - let hir_id = self.tcx.hir().as_local_hir_id(def_id); + let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); self.update(hir_id, Some(AccessLevel::Exported)); } } @@ -1004,7 +1004,7 @@ impl DefIdVisitor<'tcx> for ReachEverythingInTheInterfaceVisitor<'_, 'tcx> { } fn visit_def_id(&mut self, def_id: DefId, _kind: &str, _descr: &dyn fmt::Display) -> bool { if let Some(def_id) = def_id.as_local() { - let hir_id = self.ev.tcx.hir().as_local_hir_id(def_id); + let hir_id = self.ev.tcx.hir().local_def_id_to_hir_id(def_id); if let ((ty::Visibility::Public, ..), _) | (_, Some(AccessLevel::ReachableFromImplTrait)) = (def_id_visibility(self.tcx(), def_id.to_def_id()), self.access_level) @@ -1437,7 +1437,7 @@ impl<'a, 'tcx> ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> { if let Some(did) = did.as_local() { // .. and it corresponds to a private type in the AST (this returns // `None` for type parameters). - match self.tcx.hir().find(self.tcx.hir().as_local_hir_id(did)) { + match self.tcx.hir().find(self.tcx.hir().local_def_id_to_hir_id(did)) { Some(Node::Item(ref item)) => !item.vis.node.is_pub(), Some(_) | None => false, } @@ -1556,7 +1556,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> { let did = tr.path.res.def_id(); if let Some(did) = did.as_local() { - self.trait_is_public(self.tcx.hir().as_local_hir_id(did)) + self.trait_is_public(self.tcx.hir().local_def_id_to_hir_id(did)) } else { true // external traits must be public } @@ -1815,7 +1815,7 @@ impl SearchInterfaceForPrivateItemsVisitor<'tcx> { } let hir_id = match def_id.as_local() { - Some(def_id) => self.tcx.hir().as_local_hir_id(def_id), + Some(def_id) => self.tcx.hir().local_def_id_to_hir_id(def_id), None => return false, }; @@ -1853,7 +1853,7 @@ impl SearchInterfaceForPrivateItemsVisitor<'tcx> { let ret = self.required_visibility == ty::Visibility::Public && self.tcx.is_private_dep(item_id.krate); - log::debug!("leaks_private_dep(item_id={:?})={}", item_id, ret); + tracing::debug!("leaks_private_dep(item_id={:?})={}", item_id, ret); ret } } diff --git a/src/librustc_query_system/Cargo.toml b/src/librustc_query_system/Cargo.toml index 64af9c5f1a1..1e89d379cb7 100644 --- a/src/librustc_query_system/Cargo.toml +++ b/src/librustc_query_system/Cargo.toml @@ -11,10 +11,11 @@ doctest = false [dependencies] rustc_arena = { path = "../librustc_arena" } -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc-rayon-core = "0.3.0" rustc_data_structures = { path = "../librustc_data_structures" } rustc_errors = { path = "../librustc_errors" } +rustc_macros = { path = "../librustc_macros" } rustc_index = { path = "../librustc_index" } rustc_serialize = { path = "../librustc_serialize" } rustc_span = { path = "../librustc_span" } diff --git a/src/librustc_query_system/dep_graph/dep_node.rs b/src/librustc_query_system/dep_graph/dep_node.rs index 002b0f9c165..e302784cc3e 100644 --- a/src/librustc_query_system/dep_graph/dep_node.rs +++ b/src/librustc_query_system/dep_graph/dep_node.rs @@ -50,7 +50,7 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use std::fmt; use std::hash::Hash; -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Encodable, Decodable)] pub struct DepNode<K> { pub kind: K, pub hash: Fingerprint, @@ -152,7 +152,8 @@ impl<Ctxt: DepContext> DepNodeParams<Ctxt> for () { /// some independent path or string that persists between runs without /// the need to be mapped or unmapped. (This ensures we can serialize /// them even in the absence of a tcx.) -#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Encodable, Decodable)] pub struct WorkProductId { hash: Fingerprint, } diff --git a/src/librustc_query_system/dep_graph/graph.rs b/src/librustc_query_system/dep_graph/graph.rs index 04a45090b72..d70306b4869 100644 --- a/src/librustc_query_system/dep_graph/graph.rs +++ b/src/librustc_query_system/dep_graph/graph.rs @@ -857,7 +857,7 @@ impl<K: DepKind> DepGraph<K> { /// may be added -- for example, new monomorphizations -- even if /// nothing in P changed!). We will compare that hash against the /// previous hash. If it matches up, we can reuse the object file. -#[derive(Clone, Debug, RustcEncodable, RustcDecodable)] +#[derive(Clone, Debug, Encodable, Decodable)] pub struct WorkProduct { pub cgu_name: String, /// Saved file associated with this CGU. diff --git a/src/librustc_query_system/dep_graph/prev.rs b/src/librustc_query_system/dep_graph/prev.rs index 5cba64cac4b..29357ce9449 100644 --- a/src/librustc_query_system/dep_graph/prev.rs +++ b/src/librustc_query_system/dep_graph/prev.rs @@ -3,7 +3,7 @@ use super::{DepKind, DepNode}; use rustc_data_structures::fingerprint::Fingerprint; use rustc_data_structures::fx::FxHashMap; -#[derive(Debug, RustcEncodable, RustcDecodable)] +#[derive(Debug, Encodable, Decodable)] pub struct PreviousDepGraph<K: DepKind> { data: SerializedDepGraph<K>, index: FxHashMap<DepNode<K>, SerializedDepNodeIndex>, diff --git a/src/librustc_query_system/dep_graph/serialized.rs b/src/librustc_query_system/dep_graph/serialized.rs index 4a89da23ea6..932c6d2a2f1 100644 --- a/src/librustc_query_system/dep_graph/serialized.rs +++ b/src/librustc_query_system/dep_graph/serialized.rs @@ -9,7 +9,7 @@ rustc_index::newtype_index! { } /// Data for use when recompiling the **current crate**. -#[derive(Debug, RustcEncodable, RustcDecodable)] +#[derive(Debug, Encodable, Decodable)] pub struct SerializedDepGraph<K: DepKind> { /// The set of all DepNodes in the graph pub nodes: IndexVec<SerializedDepNodeIndex, DepNode<K>>, diff --git a/src/librustc_query_system/lib.rs b/src/librustc_query_system/lib.rs index 4bbba7befe9..26b76a9c006 100644 --- a/src/librustc_query_system/lib.rs +++ b/src/librustc_query_system/lib.rs @@ -7,9 +7,11 @@ #![feature(stmt_expr_attributes)] #[macro_use] -extern crate log; +extern crate tracing; #[macro_use] extern crate rustc_data_structures; +#[macro_use] +extern crate rustc_macros; pub mod cache; pub mod dep_graph; diff --git a/src/librustc_query_system/query/caches.rs b/src/librustc_query_system/query/caches.rs index f0beec0a177..1839e1af45e 100644 --- a/src/librustc_query_system/query/caches.rs +++ b/src/librustc_query_system/query/caches.rs @@ -43,9 +43,8 @@ pub trait QueryCache: QueryStorage { OnHit: FnOnce(&Self::Stored, DepNodeIndex) -> R, OnMiss: FnOnce(Self::Key, QueryLookup<'_, CTX, Self::Key, Self::Sharded>) -> R; - fn complete<CTX: QueryContext>( + fn complete( &self, - tcx: CTX, lock_sharded_storage: &mut Self::Sharded, key: Self::Key, value: Self::Value, @@ -112,9 +111,8 @@ impl<K: Eq + Hash, V: Clone> QueryCache for DefaultCache<K, V> { } #[inline] - fn complete<CTX: QueryContext>( + fn complete( &self, - _: CTX, lock_sharded_storage: &mut Self::Sharded, key: K, value: V, @@ -195,9 +193,8 @@ impl<'tcx, K: Eq + Hash, V: 'tcx> QueryCache for ArenaCache<'tcx, K, V> { } #[inline] - fn complete<CTX: QueryContext>( + fn complete( &self, - _: CTX, lock_sharded_storage: &mut Self::Sharded, key: K, value: V, diff --git a/src/librustc_query_system/query/plumbing.rs b/src/librustc_query_system/query/plumbing.rs index cc7d0a15703..ae042cc8081 100644 --- a/src/librustc_query_system/query/plumbing.rs +++ b/src/librustc_query_system/query/plumbing.rs @@ -264,7 +264,7 @@ where /// Completes the query by updating the query cache with the `result`, /// signals the waiter and forgets the JobOwner, so it won't poison the query #[inline(always)] - fn complete(self, tcx: CTX, result: C::Value, dep_node_index: DepNodeIndex) -> C::Stored { + fn complete(self, result: C::Value, dep_node_index: DepNodeIndex) -> C::Stored { // We can move out of `self` here because we `mem::forget` it below let key = unsafe { ptr::read(&self.key) }; let state = self.state; @@ -278,7 +278,7 @@ where QueryResult::Started(job) => job, QueryResult::Poisoned => panic!(), }; - let result = state.cache.complete(tcx, &mut lock.cache, key, result, dep_node_index); + let result = state.cache.complete(&mut lock.cache, key, result, dep_node_index); (job, result) }; @@ -432,7 +432,7 @@ where tcx.store_diagnostics_for_anon_node(dep_node_index, diagnostics); } - return job.complete(tcx, result, dep_node_index); + return job.complete(result, dep_node_index); } let dep_node = query.to_dep_node(tcx, &key); @@ -458,7 +458,7 @@ where }) }); if let Some((result, dep_node_index)) = loaded { - return job.complete(tcx, result, dep_node_index); + return job.complete(result, dep_node_index); } } @@ -609,7 +609,7 @@ where } } - let result = job.complete(tcx, result, dep_node_index); + let result = job.complete(result, dep_node_index); (result, dep_node_index) } diff --git a/src/librustc_resolve/Cargo.toml b/src/librustc_resolve/Cargo.toml index 1cb49132ead..e5260866f29 100644 --- a/src/librustc_resolve/Cargo.toml +++ b/src/librustc_resolve/Cargo.toml @@ -12,7 +12,7 @@ doctest = false [dependencies] bitflags = "1.2.1" -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc_ast = { path = "../librustc_ast" } rustc_arena = { path = "../librustc_arena" } rustc_middle = { path = "../librustc_middle" } diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 11c7793b3ad..ddc16d18952 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -37,9 +37,9 @@ use rustc_span::source_map::{respan, Spanned}; use rustc_span::symbol::{kw, sym, Ident, Symbol}; use rustc_span::Span; -use log::debug; use std::cell::Cell; use std::ptr; +use tracing::debug; type Res = def::Res<NodeId>; diff --git a/src/librustc_resolve/def_collector.rs b/src/librustc_resolve/def_collector.rs index 32af920020c..7dbf51aab28 100644 --- a/src/librustc_resolve/def_collector.rs +++ b/src/librustc_resolve/def_collector.rs @@ -1,5 +1,4 @@ use crate::Resolver; -use log::debug; use rustc_ast::ast::*; use rustc_ast::token::{self, Token}; use rustc_ast::visit::{self, FnKind}; @@ -11,6 +10,7 @@ use rustc_hir::definitions::*; use rustc_span::hygiene::ExpnId; use rustc_span::symbol::{kw, sym}; use rustc_span::Span; +use tracing::debug; crate fn collect_definitions( resolver: &mut Resolver<'_>, diff --git a/src/librustc_resolve/diagnostics.rs b/src/librustc_resolve/diagnostics.rs index de92204a7c2..1e5e937db66 100644 --- a/src/librustc_resolve/diagnostics.rs +++ b/src/librustc_resolve/diagnostics.rs @@ -1,7 +1,6 @@ use std::cmp::Reverse; use std::ptr; -use log::debug; use rustc_ast::ast::{self, Path}; use rustc_ast::util::lev_distance::find_best_match_for_name; use rustc_ast_pretty::pprust; @@ -18,6 +17,7 @@ use rustc_span::hygiene::MacroKind; use rustc_span::source_map::SourceMap; use rustc_span::symbol::{kw, sym, Ident, Symbol}; use rustc_span::{BytePos, MultiSpan, Span}; +use tracing::debug; use crate::imports::{Import, ImportKind, ImportResolver}; use crate::path_names_to_string; diff --git a/src/librustc_resolve/imports.rs b/src/librustc_resolve/imports.rs index d3f45f962a0..ef51a1c73af 100644 --- a/src/librustc_resolve/imports.rs +++ b/src/librustc_resolve/imports.rs @@ -28,7 +28,7 @@ use rustc_span::hygiene::ExpnId; use rustc_span::symbol::{kw, Ident, Symbol}; use rustc_span::{MultiSpan, Span}; -use log::*; +use tracing::*; use std::cell::Cell; use std::{mem, ptr}; diff --git a/src/librustc_resolve/late.rs b/src/librustc_resolve/late.rs index 7ecfe2554ec..2f63257a982 100644 --- a/src/librustc_resolve/late.rs +++ b/src/librustc_resolve/late.rs @@ -29,10 +29,10 @@ use rustc_span::symbol::{kw, sym, Ident, Symbol}; use rustc_span::Span; use smallvec::{smallvec, SmallVec}; -use log::debug; use rustc_span::source_map::{respan, Spanned}; use std::collections::BTreeSet; use std::mem::{replace, take}; +use tracing::debug; mod diagnostics; crate mod lifetimes; @@ -1732,7 +1732,12 @@ impl<'a, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> { source: PathSource<'ast>, crate_lint: CrateLint, ) -> PartialRes { - log::debug!("smart_resolve_path_fragment(id={:?},qself={:?},path={:?}", id, qself, path); + tracing::debug!( + "smart_resolve_path_fragment(id={:?},qself={:?},path={:?}", + id, + qself, + path + ); let ns = source.namespace(); let is_expected = &|res| source.is_expected(res); diff --git a/src/librustc_resolve/late/diagnostics.rs b/src/librustc_resolve/late/diagnostics.rs index c57c0e51941..2e606beca26 100644 --- a/src/librustc_resolve/late/diagnostics.rs +++ b/src/librustc_resolve/late/diagnostics.rs @@ -7,6 +7,7 @@ use crate::{PathResult, PathSource, Segment}; use rustc_ast::ast::{self, Expr, ExprKind, Item, ItemKind, NodeId, Path, Ty, TyKind}; use rustc_ast::util::lev_distance::find_best_match_for_name; +use rustc_ast::visit::FnKind; use rustc_data_structures::fx::FxHashSet; use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticBuilder}; use rustc_hir as hir; @@ -16,10 +17,10 @@ use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX, LOCAL_CRATE}; use rustc_hir::PrimTy; use rustc_session::config::nightly_options; use rustc_span::hygiene::MacroKind; -use rustc_span::symbol::{kw, sym, Ident}; -use rustc_span::{BytePos, Span}; +use rustc_span::symbol::{kw, sym, Ident, Symbol}; +use rustc_span::{BytePos, Span, DUMMY_SP}; -use log::debug; +use tracing::debug; type Res = def::Res<ast::NodeId>; @@ -33,6 +34,7 @@ enum AssocSuggestion { crate enum MissingLifetimeSpot<'tcx> { Generics(&'tcx hir::Generics<'tcx>), HigherRanked { span: Span, span_type: ForLifetimeSpanType }, + Static, } crate enum ForLifetimeSpanType { @@ -174,16 +176,40 @@ impl<'a> LateResolutionVisitor<'a, '_, '_> { let code = source.error_code(res.is_some()); let mut err = self.r.session.struct_span_err_with_code(base_span, &base_msg, code); + let is_assoc_fn = self.self_type_is_available(span); // Emit help message for fake-self from other languages (e.g., `this` in Javascript). - if ["this", "my"].contains(&&*item_str.as_str()) - && self.self_value_is_available(path[0].ident.span, span) - { + if ["this", "my"].contains(&&*item_str.as_str()) && is_assoc_fn { err.span_suggestion_short( span, "you might have meant to use `self` here instead", "self".to_string(), Applicability::MaybeIncorrect, ); + if !self.self_value_is_available(path[0].ident.span, span) { + if let Some((FnKind::Fn(_, _, sig, ..), fn_span)) = + &self.diagnostic_metadata.current_function + { + let (span, sugg) = if let Some(param) = sig.decl.inputs.get(0) { + (param.span.shrink_to_lo(), "&self, ") + } else { + ( + self.r + .session + .source_map() + .span_through_char(*fn_span, '(') + .shrink_to_hi(), + "&self", + ) + }; + err.span_suggestion_verbose( + span, + "if you meant to use `self`, you are also missing a `self` receiver \ + argument", + sugg.to_string(), + Applicability::MaybeIncorrect, + ); + } + } } // Emit special messages for unresolved `Self` and `self`. @@ -212,7 +238,38 @@ impl<'a> LateResolutionVisitor<'a, '_, '_> { if fn_kind.decl().inputs.get(0).map(|p| p.is_self()).unwrap_or(false) { err.span_label(*span, "this function has a `self` parameter, but a macro invocation can only access identifiers it receives from parameters"); } else { - err.span_label(*span, "this function doesn't have a `self` parameter"); + let doesnt = if is_assoc_fn { + let (span, sugg) = fn_kind + .decl() + .inputs + .get(0) + .map(|p| (p.span.shrink_to_lo(), "&self, ")) + .unwrap_or_else(|| { + ( + self.r + .session + .source_map() + .span_through_char(*span, '(') + .shrink_to_hi(), + "&self", + ) + }); + err.span_suggestion_verbose( + span, + "add a `self` receiver parameter to make the associated `fn` a method", + sugg.to_string(), + Applicability::MaybeIncorrect, + ); + "doesn't" + } else { + "can't" + }; + if let Some(ident) = fn_kind.ident() { + err.span_label( + ident.span, + &format!("this function {} have a `self` parameter", doesnt), + ); + } } } return (err, Vec::new()); @@ -701,7 +758,16 @@ impl<'a> LateResolutionVisitor<'a, '_, '_> { if let Some(span) = self.def_span(def_id) { err.span_label(span, &format!("`{}` defined here", path_str)); } - err.span_label(span, format!("did you mean `{}( /* fields */ )`?", path_str)); + let fields = + self.r.field_names.get(&def_id).map_or("/* fields */".to_string(), |fields| { + vec!["_"; fields.len()].join(", ") + }); + err.span_suggestion( + span, + "use the tuple variant pattern syntax instead", + format!("{}({})", path_str, fields), + Applicability::HasPlaceholders, + ); } (Res::SelfTy(..), _) if ns == ValueNS => { err.span_label(span, fallback_label); @@ -1186,6 +1252,7 @@ impl<'tcx> LifetimeContext<'_, 'tcx> { https://doc.rust-lang.org/nomicon/hrtb.html", ); } + _ => {} } } if nightly_options::is_nightly_build() @@ -1244,7 +1311,8 @@ impl<'tcx> LifetimeContext<'_, 'tcx> { err: &mut DiagnosticBuilder<'_>, span: Span, count: usize, - lifetime_names: &FxHashSet<Ident>, + lifetime_names: &FxHashSet<Symbol>, + lifetime_spans: Vec<Span>, params: &[ElisionFailureInfo], ) { let snippet = self.tcx.sess.source_map().span_to_snippet(span).ok(); @@ -1258,11 +1326,60 @@ impl<'tcx> LifetimeContext<'_, 'tcx> { ), ); - let suggest_existing = |err: &mut DiagnosticBuilder<'_>, sugg| { + let suggest_existing = |err: &mut DiagnosticBuilder<'_>, + name: &str, + formatter: &dyn Fn(&str) -> String| { + if let Some(MissingLifetimeSpot::HigherRanked { span: for_span, span_type }) = + self.missing_named_lifetime_spots.iter().rev().next() + { + // When we have `struct S<'a>(&'a dyn Fn(&X) -> &X);` we want to not only suggest + // using `'a`, but also introduce the concept of HRLTs by suggesting + // `struct S<'a>(&'a dyn for<'b> Fn(&X) -> &'b X);`. (#72404) + let mut introduce_suggestion = vec![]; + + let a_to_z_repeat_n = |n| { + (b'a'..=b'z').map(move |c| { + let mut s = '\''.to_string(); + s.extend(std::iter::repeat(char::from(c)).take(n)); + s + }) + }; + + // If all single char lifetime names are present, we wrap around and double the chars. + let lt_name = (1..) + .flat_map(a_to_z_repeat_n) + .find(|lt| !lifetime_names.contains(&Symbol::intern(<))) + .unwrap(); + let msg = format!( + "consider making the {} lifetime-generic with a new `{}` lifetime", + span_type.descr(), + lt_name, + ); + err.note( + "for more information on higher-ranked polymorphism, visit \ + https://doc.rust-lang.org/nomicon/hrtb.html", + ); + let for_sugg = span_type.suggestion(<_name); + for param in params { + if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(param.span) { + if snippet.starts_with('&') && !snippet.starts_with("&'") { + introduce_suggestion + .push((param.span, format!("&{} {}", lt_name, &snippet[1..]))); + } else if snippet.starts_with("&'_ ") { + introduce_suggestion + .push((param.span, format!("&{} {}", lt_name, &snippet[4..]))); + } + } + } + introduce_suggestion.push((*for_span, for_sugg.to_string())); + introduce_suggestion.push((span, formatter(<_name))); + err.multipart_suggestion(&msg, introduce_suggestion, Applicability::MaybeIncorrect); + } + err.span_suggestion_verbose( span, &format!("consider using the `{}` lifetime", lifetime_names.iter().next().unwrap()), - sugg, + formatter(name), Applicability::MaybeIncorrect, ); }; @@ -1273,6 +1390,15 @@ impl<'tcx> LifetimeContext<'_, 'tcx> { let should_break; introduce_suggestion.push(match missing { MissingLifetimeSpot::Generics(generics) => { + if generics.span == DUMMY_SP { + // Account for malformed generics in the HIR. This shouldn't happen, + // but if we make a mistake elsewhere, mainly by keeping something in + // `missing_named_lifetime_spots` that we shouldn't, like associated + // `const`s or making a mistake in the AST lowering we would provide + // non-sensical suggestions. Guard against that by skipping these. + // (#74264) + continue; + } msg = "consider introducing a named lifetime parameter".to_string(); should_break = true; if let Some(param) = generics.params.iter().find(|p| match p.kind { @@ -1299,6 +1425,42 @@ impl<'tcx> LifetimeContext<'_, 'tcx> { ); (*span, span_type.suggestion("'a")) } + MissingLifetimeSpot::Static => { + let (span, sugg) = match snippet.as_deref() { + Some("&") => (span.shrink_to_hi(), "'static ".to_owned()), + Some("'_") => (span, "'static".to_owned()), + Some(snippet) if !snippet.ends_with('>') => { + if snippet == "" { + ( + span, + std::iter::repeat("'static") + .take(count) + .collect::<Vec<_>>() + .join(", "), + ) + } else { + ( + span.shrink_to_hi(), + format!( + "<{}>", + std::iter::repeat("'static") + .take(count) + .collect::<Vec<_>>() + .join(", ") + ), + ) + } + } + _ => continue, + }; + err.span_suggestion_verbose( + span, + "consider using the `'static` lifetime", + sugg.to_string(), + Applicability::MaybeIncorrect, + ); + continue; + } }); for param in params { if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(param.span) { @@ -1319,19 +1481,19 @@ impl<'tcx> LifetimeContext<'_, 'tcx> { } }; - match (lifetime_names.len(), lifetime_names.iter().next(), snippet.as_deref()) { - (1, Some(name), Some("&")) => { - suggest_existing(err, format!("&{} ", name)); + let lifetime_names: Vec<_> = lifetime_names.into_iter().collect(); + match (&lifetime_names[..], snippet.as_deref()) { + ([name], Some("&")) => { + suggest_existing(err, &name.as_str()[..], &|name| format!("&{} ", name)); } - (1, Some(name), Some("'_")) => { - suggest_existing(err, name.to_string()); + ([name], Some("'_")) => { + suggest_existing(err, &name.as_str()[..], &|n| n.to_string()); } - (1, Some(name), Some("")) => { - suggest_existing(err, format!("{}, ", name).repeat(count)); + ([name], Some("")) => { + suggest_existing(err, &name.as_str()[..], &|n| format!("{}, ", n).repeat(count)); } - (1, Some(name), Some(snippet)) if !snippet.ends_with('>') => { - suggest_existing( - err, + ([name], Some(snippet)) if !snippet.ends_with('>') => { + let f = |name: &str| { format!( "{}<{}>", snippet, @@ -1339,21 +1501,37 @@ impl<'tcx> LifetimeContext<'_, 'tcx> { .take(count) .collect::<Vec<_>>() .join(", ") - ), - ); + ) + }; + suggest_existing(err, &name.as_str()[..], &f); } - (0, _, Some("&")) if count == 1 => { + ([], Some("&")) if count == 1 => { suggest_new(err, "&'a "); } - (0, _, Some("'_")) if count == 1 => { + ([], Some("'_")) if count == 1 => { suggest_new(err, "'a"); } - (0, _, Some(snippet)) if !snippet.ends_with('>') && count == 1 => { - suggest_new(err, &format!("{}<'a>", snippet)); + ([], Some(snippet)) if !snippet.ends_with('>') => { + if snippet == "" { + // This happens when we have `type Bar<'a> = Foo<T>` where we point at the space + // before `T`. We will suggest `type Bar<'a> = Foo<'a, T>`. + suggest_new( + err, + &std::iter::repeat("'a, ").take(count).collect::<Vec<_>>().join(""), + ); + } else { + suggest_new( + err, + &format!( + "{}<{}>", + snippet, + std::iter::repeat("'a").take(count).collect::<Vec<_>>().join(", ") + ), + ); + } } - (n, ..) if n > 1 => { - let spans: Vec<Span> = lifetime_names.iter().map(|lt| lt.span).collect(); - err.span_note(spans, "these named lifetimes are available to use"); + (lts, ..) if lts.len() > 1 => { + err.span_note(lifetime_spans, "these named lifetimes are available to use"); if Some("") == snippet.as_deref() { // This happens when we have `Foo<T>` where we point at the space before `T`, // but this can be confusing so we give a suggestion with placeholders. diff --git a/src/librustc_resolve/late/lifetimes.rs b/src/librustc_resolve/late/lifetimes.rs index 0b881b089de..e2f0d388f7e 100644 --- a/src/librustc_resolve/late/lifetimes.rs +++ b/src/librustc_resolve/late/lifetimes.rs @@ -26,7 +26,7 @@ use std::borrow::Cow; use std::cell::Cell; use std::mem::take; -use log::debug; +use tracing::debug; // This counts the no of times a lifetime is used #[derive(Clone, Copy, Debug)] @@ -607,7 +607,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { let def = self.map.defs.get(&lifetime.hir_id).cloned(); if let Some(Region::LateBound(_, def_id, _)) = def { if let Some(def_id) = def_id.as_local() { - let hir_id = self.tcx.hir().as_local_hir_id(def_id); + let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); // Ensure that the parent of the def is an item, not HRTB let parent_id = self.tcx.hir().get_parent_node(hir_id); let parent_impl_id = hir::ImplItemId { hir_id: parent_id }; @@ -711,9 +711,9 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem<'tcx>) { use self::hir::TraitItemKind::*; - self.missing_named_lifetime_spots.push((&trait_item.generics).into()); match trait_item.kind { Fn(ref sig, _) => { + self.missing_named_lifetime_spots.push((&trait_item.generics).into()); let tcx = self.tcx; self.visit_early_late( Some(tcx.hir().get_parent_item(trait_item.hir_id)), @@ -721,8 +721,10 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { &trait_item.generics, |this| intravisit::walk_trait_item(this, trait_item), ); + self.missing_named_lifetime_spots.pop(); } Type(bounds, ref ty) => { + self.missing_named_lifetime_spots.push((&trait_item.generics).into()); let generics = &trait_item.generics; let mut index = self.next_early_index(); debug!("visit_ty: index = {}", index); @@ -757,31 +759,35 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { this.visit_ty(ty); } }); + self.missing_named_lifetime_spots.pop(); } Const(_, _) => { // Only methods and types support generics. assert!(trait_item.generics.params.is_empty()); + self.missing_named_lifetime_spots.push(MissingLifetimeSpot::Static); intravisit::walk_trait_item(self, trait_item); + self.missing_named_lifetime_spots.pop(); } } - self.missing_named_lifetime_spots.pop(); } fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) { use self::hir::ImplItemKind::*; - self.missing_named_lifetime_spots.push((&impl_item.generics).into()); match impl_item.kind { Fn(ref sig, _) => { + self.missing_named_lifetime_spots.push((&impl_item.generics).into()); let tcx = self.tcx; self.visit_early_late( Some(tcx.hir().get_parent_item(impl_item.hir_id)), &sig.decl, &impl_item.generics, |this| intravisit::walk_impl_item(this, impl_item), - ) + ); + self.missing_named_lifetime_spots.pop(); } TyAlias(ref ty) => { let generics = &impl_item.generics; + self.missing_named_lifetime_spots.push(generics.into()); let mut index = self.next_early_index(); let mut non_lifetime_count = 0; debug!("visit_ty: index = {}", index); @@ -810,14 +816,16 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { this.visit_generics(generics); this.visit_ty(ty); }); + self.missing_named_lifetime_spots.pop(); } Const(_, _) => { // Only methods and types support generics. assert!(impl_item.generics.params.is_empty()); + self.missing_named_lifetime_spots.push(MissingLifetimeSpot::Static); intravisit::walk_impl_item(self, impl_item); + self.missing_named_lifetime_spots.pop(); } } - self.missing_named_lifetime_spots.pop(); } fn visit_lifetime(&mut self, lifetime_ref: &'tcx hir::Lifetime) { @@ -1146,7 +1154,8 @@ fn extract_labels(ctxt: &mut LifetimeContext<'_, '_>, body: &hir::Body<'_>) { if let Some(def) = lifetimes.get(&hir::ParamName::Plain(label.normalize_to_macros_2_0())) { - let hir_id = tcx.hir().as_local_hir_id(def.id().unwrap().expect_local()); + let hir_id = + tcx.hir().local_def_id_to_hir_id(def.id().unwrap().expect_local()); signal_shadowing_problem( tcx, @@ -1517,7 +1526,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { match lifetimeuseset { Some(LifetimeUseSet::One(lifetime)) => { - let hir_id = self.tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); debug!("hir id first={:?}", hir_id); if let Some((id, span, name)) = match self.tcx.hir().get(hir_id) { Node::Lifetime(hir_lifetime) => Some(( @@ -1537,7 +1546,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { if let Some(parent_def_id) = self.tcx.parent(def_id) { if let Some(def_id) = parent_def_id.as_local() { - let parent_hir_id = self.tcx.hir().as_local_hir_id(def_id); + let parent_hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); // lifetimes in `derive` expansions don't count (Issue #53738) if self.tcx.hir().attrs(parent_hir_id).iter().any(|attr| { self.tcx.sess.check_name(attr, sym::automatically_derived) @@ -1575,7 +1584,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { debug!("not one use lifetime"); } None => { - let hir_id = self.tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); if let Some((id, span, name)) = match self.tcx.hir().get(hir_id) { Node::Lifetime(hir_lifetime) => Some(( hir_lifetime.hir_id, @@ -1931,7 +1940,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { let map = &self.map; let unsubst = if let Some(def_id) = def_id.as_local() { - let id = self.tcx.hir().as_local_hir_id(def_id); + let id = self.tcx.hir().local_def_id_to_hir_id(def_id); &map.object_lifetime_defaults[&id] } else { let tcx = self.tcx; @@ -2315,6 +2324,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { let mut late_depth = 0; let mut scope = self.scope; let mut lifetime_names = FxHashSet::default(); + let mut lifetime_spans = vec![]; let error = loop { match *scope { // Do not assign any resolution, it will be inferred. @@ -2326,7 +2336,8 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { // collect named lifetimes for suggestions for name in lifetimes.keys() { if let hir::ParamName::Plain(name) = name { - lifetime_names.insert(*name); + lifetime_names.insert(name.name); + lifetime_spans.push(name.span); } } late_depth += 1; @@ -2344,12 +2355,24 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { } Elide::Exact(l) => l.shifted(late_depth), Elide::Error(ref e) => { - if let Scope::Binder { ref lifetimes, .. } = s { - // collect named lifetimes for suggestions - for name in lifetimes.keys() { - if let hir::ParamName::Plain(name) = name { - lifetime_names.insert(*name); + let mut scope = s; + loop { + match scope { + Scope::Binder { ref lifetimes, s, .. } => { + // Collect named lifetimes for suggestions. + for name in lifetimes.keys() { + if let hir::ParamName::Plain(name) = name { + lifetime_names.insert(name.name); + lifetime_spans.push(name.span); + } + } + scope = s; + } + Scope::ObjectLifetimeDefault { ref s, .. } + | Scope::Elision { ref s, .. } => { + scope = s; } + _ => break, } } break Some(e); @@ -2373,7 +2396,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { if let Some(params) = error { // If there's no lifetime available, suggest `'static`. if self.report_elision_failure(&mut err, params) && lifetime_names.is_empty() { - lifetime_names.insert(Ident::with_dummy_span(kw::StaticLifetime)); + lifetime_names.insert(kw::StaticLifetime); } } self.add_missing_lifetime_specifiers_label( @@ -2381,6 +2404,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { span, lifetime_refs.len(), &lifetime_names, + lifetime_spans, error.map(|p| &p[..]).unwrap_or(&[]), ); err.emit(); @@ -2614,7 +2638,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { Scope::Binder { ref lifetimes, s, .. } => { if let Some(&def) = lifetimes.get(¶m.name.normalize_to_macros_2_0()) { let hir_id = - self.tcx.hir().as_local_hir_id(def.id().unwrap().expect_local()); + self.tcx.hir().local_def_id_to_hir_id(def.id().unwrap().expect_local()); signal_shadowing_problem( self.tcx, diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 79f5a27bb28..339a5ae6675 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -54,10 +54,10 @@ use rustc_span::source_map::Spanned; use rustc_span::symbol::{kw, sym, Ident, Symbol}; use rustc_span::{Span, DUMMY_SP}; -use log::debug; use std::cell::{Cell, RefCell}; use std::collections::BTreeSet; use std::{cmp, fmt, iter, ptr}; +use tracing::debug; use diagnostics::{extend_span_to_previous_binding, find_span_of_binding_until_next_binding}; use diagnostics::{ImportSuggestion, LabelSuggestion, Suggestion}; diff --git a/src/librustc_save_analysis/Cargo.toml b/src/librustc_save_analysis/Cargo.toml index 7a5ae0ace3a..3c2edc1fa55 100644 --- a/src/librustc_save_analysis/Cargo.toml +++ b/src/librustc_save_analysis/Cargo.toml @@ -9,7 +9,7 @@ name = "rustc_save_analysis" path = "lib.rs" [dependencies] -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc_middle = { path = "../librustc_middle" } rustc_ast = { path = "../librustc_ast" } rustc_ast_pretty = { path = "../librustc_ast_pretty" } diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs index 5aa676e3fce..f33d2f46aa2 100644 --- a/src/librustc_save_analysis/dump_visitor.rs +++ b/src/librustc_save_analysis/dump_visitor.rs @@ -45,7 +45,7 @@ use rls_data::{ RefKind, Relation, RelationKind, SpanData, }; -use log::{debug, error}; +use tracing::{debug, error}; macro_rules! down_cast_data { ($id:ident, $kind:ident, $sp:expr) => { diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs index 6469971fce8..ca98ada4e57 100644 --- a/src/librustc_save_analysis/lib.rs +++ b/src/librustc_save_analysis/lib.rs @@ -45,7 +45,7 @@ use rls_data::{ RefKind, Relation, RelationKind, SpanData, }; -use log::{debug, error, info}; +use tracing::{debug, error, info}; pub struct SaveContext<'tcx> { tcx: TyCtxt<'tcx>, diff --git a/src/librustc_serialize/Cargo.toml b/src/librustc_serialize/Cargo.toml index 84206df50cc..939e6a59ba0 100644 --- a/src/librustc_serialize/Cargo.toml +++ b/src/librustc_serialize/Cargo.toml @@ -11,3 +11,6 @@ path = "lib.rs" [dependencies] indexmap = "1" smallvec = { version = "1.0", features = ["union", "may_dangle"] } + +[dev-dependencies] +rustc_macros = { path = "../librustc_macros" } diff --git a/src/librustc_serialize/collection_impls.rs b/src/librustc_serialize/collection_impls.rs index c602de37b14..3d274cb0150 100644 --- a/src/librustc_serialize/collection_impls.rs +++ b/src/librustc_serialize/collection_impls.rs @@ -9,8 +9,8 @@ use std::sync::Arc; use smallvec::{Array, SmallVec}; -impl<A: Array<Item: Encodable>> Encodable for SmallVec<A> { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, A: Array<Item: Encodable<S>>> Encodable<S> for SmallVec<A> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_seq(self.len(), |s| { for (i, e) in self.iter().enumerate() { s.emit_seq_elt(i, |s| e.encode(s))?; @@ -20,8 +20,8 @@ impl<A: Array<Item: Encodable>> Encodable for SmallVec<A> { } } -impl<A: Array<Item: Decodable>> Decodable for SmallVec<A> { - fn decode<D: Decoder>(d: &mut D) -> Result<SmallVec<A>, D::Error> { +impl<D: Decoder, A: Array<Item: Decodable<D>>> Decodable<D> for SmallVec<A> { + fn decode(d: &mut D) -> Result<SmallVec<A>, D::Error> { d.read_seq(|d, len| { let mut vec = SmallVec::with_capacity(len); // FIXME(#48994) - could just be collected into a Result<SmallVec, D::Error> @@ -33,8 +33,8 @@ impl<A: Array<Item: Decodable>> Decodable for SmallVec<A> { } } -impl<T: Encodable> Encodable for LinkedList<T> { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, T: Encodable<S>> Encodable<S> for LinkedList<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_seq(self.len(), |s| { for (i, e) in self.iter().enumerate() { s.emit_seq_elt(i, |s| e.encode(s))?; @@ -44,8 +44,8 @@ impl<T: Encodable> Encodable for LinkedList<T> { } } -impl<T: Decodable> Decodable for LinkedList<T> { - fn decode<D: Decoder>(d: &mut D) -> Result<LinkedList<T>, D::Error> { +impl<D: Decoder, T: Decodable<D>> Decodable<D> for LinkedList<T> { + fn decode(d: &mut D) -> Result<LinkedList<T>, D::Error> { d.read_seq(|d, len| { let mut list = LinkedList::new(); for i in 0..len { @@ -56,8 +56,8 @@ impl<T: Decodable> Decodable for LinkedList<T> { } } -impl<T: Encodable> Encodable for VecDeque<T> { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, T: Encodable<S>> Encodable<S> for VecDeque<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_seq(self.len(), |s| { for (i, e) in self.iter().enumerate() { s.emit_seq_elt(i, |s| e.encode(s))?; @@ -67,8 +67,8 @@ impl<T: Encodable> Encodable for VecDeque<T> { } } -impl<T: Decodable> Decodable for VecDeque<T> { - fn decode<D: Decoder>(d: &mut D) -> Result<VecDeque<T>, D::Error> { +impl<D: Decoder, T: Decodable<D>> Decodable<D> for VecDeque<T> { + fn decode(d: &mut D) -> Result<VecDeque<T>, D::Error> { d.read_seq(|d, len| { let mut deque: VecDeque<T> = VecDeque::with_capacity(len); for i in 0..len { @@ -79,30 +79,28 @@ impl<T: Decodable> Decodable for VecDeque<T> { } } -impl<K, V> Encodable for BTreeMap<K, V> +impl<S: Encoder, K, V> Encodable<S> for BTreeMap<K, V> where - K: Encodable + PartialEq + Ord, - V: Encodable, + K: Encodable<S> + PartialEq + Ord, + V: Encodable<S>, { - fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> { + fn encode(&self, e: &mut S) -> Result<(), S::Error> { e.emit_map(self.len(), |e| { - let mut i = 0; - for (key, val) in self { + for (i, (key, val)) in self.iter().enumerate() { e.emit_map_elt_key(i, |e| key.encode(e))?; e.emit_map_elt_val(i, |e| val.encode(e))?; - i += 1; } Ok(()) }) } } -impl<K, V> Decodable for BTreeMap<K, V> +impl<D: Decoder, K, V> Decodable<D> for BTreeMap<K, V> where - K: Decodable + PartialEq + Ord, - V: Decodable, + K: Decodable<D> + PartialEq + Ord, + V: Decodable<D>, { - fn decode<D: Decoder>(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> { + fn decode(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> { d.read_map(|d, len| { let mut map = BTreeMap::new(); for i in 0..len { @@ -115,27 +113,25 @@ where } } -impl<T> Encodable for BTreeSet<T> +impl<S: Encoder, T> Encodable<S> for BTreeSet<T> where - T: Encodable + PartialEq + Ord, + T: Encodable<S> + PartialEq + Ord, { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_seq(self.len(), |s| { - let mut i = 0; - for e in self { + for (i, e) in self.iter().enumerate() { s.emit_seq_elt(i, |s| e.encode(s))?; - i += 1; } Ok(()) }) } } -impl<T> Decodable for BTreeSet<T> +impl<D: Decoder, T> Decodable<D> for BTreeSet<T> where - T: Decodable + PartialEq + Ord, + T: Decodable<D> + PartialEq + Ord, { - fn decode<D: Decoder>(d: &mut D) -> Result<BTreeSet<T>, D::Error> { + fn decode(d: &mut D) -> Result<BTreeSet<T>, D::Error> { d.read_seq(|d, len| { let mut set = BTreeSet::new(); for i in 0..len { @@ -146,32 +142,30 @@ where } } -impl<K, V, S> Encodable for HashMap<K, V, S> +impl<E: Encoder, K, V, S> Encodable<E> for HashMap<K, V, S> where - K: Encodable + Eq, - V: Encodable, + K: Encodable<E> + Eq, + V: Encodable<E>, S: BuildHasher, { - fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> { + fn encode(&self, e: &mut E) -> Result<(), E::Error> { e.emit_map(self.len(), |e| { - let mut i = 0; - for (key, val) in self { + for (i, (key, val)) in self.iter().enumerate() { e.emit_map_elt_key(i, |e| key.encode(e))?; e.emit_map_elt_val(i, |e| val.encode(e))?; - i += 1; } Ok(()) }) } } -impl<K, V, S> Decodable for HashMap<K, V, S> +impl<D: Decoder, K, V, S> Decodable<D> for HashMap<K, V, S> where - K: Decodable + Hash + Eq, - V: Decodable, + K: Decodable<D> + Hash + Eq, + V: Decodable<D>, S: BuildHasher + Default, { - fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V, S>, D::Error> { + fn decode(d: &mut D) -> Result<HashMap<K, V, S>, D::Error> { d.read_map(|d, len| { let state = Default::default(); let mut map = HashMap::with_capacity_and_hasher(len, state); @@ -185,29 +179,37 @@ where } } -impl<T, S> Encodable for HashSet<T, S> +impl<E: Encoder, T, S> Encodable<E> for HashSet<T, S> where - T: Encodable + Eq, + T: Encodable<E> + Eq, S: BuildHasher, { - fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> { + fn encode(&self, s: &mut E) -> Result<(), E::Error> { s.emit_seq(self.len(), |s| { - let mut i = 0; - for e in self { + for (i, e) in self.iter().enumerate() { s.emit_seq_elt(i, |s| e.encode(s))?; - i += 1; } Ok(()) }) } } -impl<T, S> Decodable for HashSet<T, S> +impl<E: Encoder, T, S> Encodable<E> for &HashSet<T, S> where - T: Decodable + Hash + Eq, + T: Encodable<E> + Eq, + S: BuildHasher, +{ + fn encode(&self, s: &mut E) -> Result<(), E::Error> { + (**self).encode(s) + } +} + +impl<D: Decoder, T, S> Decodable<D> for HashSet<T, S> +where + T: Decodable<D> + Hash + Eq, S: BuildHasher + Default, { - fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, S>, D::Error> { + fn decode(d: &mut D) -> Result<HashSet<T, S>, D::Error> { d.read_seq(|d, len| { let state = Default::default(); let mut set = HashSet::with_capacity_and_hasher(len, state); @@ -219,32 +221,30 @@ where } } -impl<K, V, S> Encodable for indexmap::IndexMap<K, V, S> +impl<E: Encoder, K, V, S> Encodable<E> for indexmap::IndexMap<K, V, S> where - K: Encodable + Hash + Eq, - V: Encodable, + K: Encodable<E> + Hash + Eq, + V: Encodable<E>, S: BuildHasher, { - fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> { + fn encode(&self, e: &mut E) -> Result<(), E::Error> { e.emit_map(self.len(), |e| { - let mut i = 0; - for (key, val) in self { + for (i, (key, val)) in self.iter().enumerate() { e.emit_map_elt_key(i, |e| key.encode(e))?; e.emit_map_elt_val(i, |e| val.encode(e))?; - i += 1; } Ok(()) }) } } -impl<K, V, S> Decodable for indexmap::IndexMap<K, V, S> +impl<D: Decoder, K, V, S> Decodable<D> for indexmap::IndexMap<K, V, S> where - K: Decodable + Hash + Eq, - V: Decodable, + K: Decodable<D> + Hash + Eq, + V: Decodable<D>, S: BuildHasher + Default, { - fn decode<D: Decoder>(d: &mut D) -> Result<indexmap::IndexMap<K, V, S>, D::Error> { + fn decode(d: &mut D) -> Result<indexmap::IndexMap<K, V, S>, D::Error> { d.read_map(|d, len| { let state = Default::default(); let mut map = indexmap::IndexMap::with_capacity_and_hasher(len, state); @@ -258,29 +258,27 @@ where } } -impl<T, S> Encodable for indexmap::IndexSet<T, S> +impl<E: Encoder, T, S> Encodable<E> for indexmap::IndexSet<T, S> where - T: Encodable + Hash + Eq, + T: Encodable<E> + Hash + Eq, S: BuildHasher, { - fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> { + fn encode(&self, s: &mut E) -> Result<(), E::Error> { s.emit_seq(self.len(), |s| { - let mut i = 0; - for e in self { + for (i, e) in self.iter().enumerate() { s.emit_seq_elt(i, |s| e.encode(s))?; - i += 1; } Ok(()) }) } } -impl<T, S> Decodable for indexmap::IndexSet<T, S> +impl<D: Decoder, T, S> Decodable<D> for indexmap::IndexSet<T, S> where - T: Decodable + Hash + Eq, + T: Decodable<D> + Hash + Eq, S: BuildHasher + Default, { - fn decode<D: Decoder>(d: &mut D) -> Result<indexmap::IndexSet<T, S>, D::Error> { + fn decode(d: &mut D) -> Result<indexmap::IndexSet<T, S>, D::Error> { d.read_seq(|d, len| { let state = Default::default(); let mut set = indexmap::IndexSet::with_capacity_and_hasher(len, state); @@ -292,8 +290,8 @@ where } } -impl<T: Encodable> Encodable for Rc<[T]> { - fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> { +impl<E: Encoder, T: Encodable<E>> Encodable<E> for Rc<[T]> { + fn encode(&self, s: &mut E) -> Result<(), E::Error> { s.emit_seq(self.len(), |s| { for (index, e) in self.iter().enumerate() { s.emit_seq_elt(index, |s| e.encode(s))?; @@ -303,8 +301,8 @@ impl<T: Encodable> Encodable for Rc<[T]> { } } -impl<T: Decodable> Decodable for Rc<[T]> { - fn decode<D: Decoder>(d: &mut D) -> Result<Rc<[T]>, D::Error> { +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Rc<[T]> { + fn decode(d: &mut D) -> Result<Rc<[T]>, D::Error> { d.read_seq(|d, len| { let mut vec = Vec::with_capacity(len); for index in 0..len { @@ -315,8 +313,8 @@ impl<T: Decodable> Decodable for Rc<[T]> { } } -impl<T: Encodable> Encodable for Arc<[T]> { - fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> { +impl<E: Encoder, T: Encodable<E>> Encodable<E> for Arc<[T]> { + fn encode(&self, s: &mut E) -> Result<(), E::Error> { s.emit_seq(self.len(), |s| { for (index, e) in self.iter().enumerate() { s.emit_seq_elt(index, |s| e.encode(s))?; @@ -326,8 +324,8 @@ impl<T: Encodable> Encodable for Arc<[T]> { } } -impl<T: Decodable> Decodable for Arc<[T]> { - fn decode<D: Decoder>(d: &mut D) -> Result<Arc<[T]>, D::Error> { +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Arc<[T]> { + fn decode(d: &mut D) -> Result<Arc<[T]>, D::Error> { d.read_seq(|d, len| { let mut vec = Vec::with_capacity(len); for index in 0..len { diff --git a/src/librustc_serialize/json.rs b/src/librustc_serialize/json.rs index 820ebdc9baa..6c8965aa2e3 100644 --- a/src/librustc_serialize/json.rs +++ b/src/librustc_serialize/json.rs @@ -47,17 +47,17 @@ //! //! Rust provides a mechanism for low boilerplate encoding & decoding of values to and from JSON via //! the serialization API. -//! To be able to encode a piece of data, it must implement the `serialize::RustcEncodable` trait. -//! To be able to decode a piece of data, it must implement the `serialize::RustcDecodable` trait. +//! To be able to encode a piece of data, it must implement the `serialize::Encodable` trait. +//! To be able to decode a piece of data, it must implement the `serialize::Decodable` trait. //! The Rust compiler provides an annotation to automatically generate the code for these traits: -//! `#[derive(RustcDecodable, RustcEncodable)]` +//! `#[derive(Decodable, Encodable)]` //! //! The JSON API provides an enum `json::Json` and a trait `ToJson` to encode objects. //! The `ToJson` trait provides a `to_json` method to convert an object into a `json::Json` value. //! A `json::Json` value can be encoded as a string or buffer using the functions described above. //! You can also use the `json::Encoder` object, which implements the `Encoder` trait. //! -//! When using `ToJson` the `RustcEncodable` trait implementation is not mandatory. +//! When using `ToJson` the `Encodable` trait implementation is not mandatory. //! //! # Examples of use //! @@ -68,29 +68,28 @@ //! //! ```rust //! # #![feature(rustc_private)] +//! use rustc_macros::{Decodable, Encodable}; //! use rustc_serialize::json; //! //! // Automatically generate `Decodable` and `Encodable` trait implementations -//! #[derive(RustcDecodable, RustcEncodable)] +//! #[derive(Decodable, Encodable)] //! pub struct TestStruct { //! data_int: u8, //! data_str: String, //! data_vector: Vec<u8>, //! } //! -//! fn main() { -//! let object = TestStruct { -//! data_int: 1, -//! data_str: "homura".to_string(), -//! data_vector: vec![2,3,4,5], -//! }; +//! let object = TestStruct { +//! data_int: 1, +//! data_str: "homura".to_string(), +//! data_vector: vec![2,3,4,5], +//! }; //! -//! // Serialize using `json::encode` -//! let encoded = json::encode(&object).unwrap(); +//! // Serialize using `json::encode` +//! let encoded = json::encode(&object).unwrap(); //! -//! // Deserialize using `json::decode` -//! let decoded: TestStruct = json::decode(&encoded[..]).unwrap(); -//! } +//! // Deserialize using `json::decode` +//! let decoded: TestStruct = json::decode(&encoded[..]).unwrap(); //! ``` //! //! ## Using the `ToJson` trait @@ -102,6 +101,7 @@ //! //! ```rust //! # #![feature(rustc_private)] +//! use rustc_macros::Encodable; //! use rustc_serialize::json::{self, ToJson, Json}; //! //! // A custom data structure @@ -117,35 +117,34 @@ //! } //! } //! -//! // Only generate `RustcEncodable` trait implementation -//! #[derive(RustcEncodable)] +//! // Only generate `Encodable` trait implementation +//! #[derive(Encodable)] //! pub struct ComplexNumRecord { //! uid: u8, //! dsc: String, //! val: Json, //! } //! -//! fn main() { -//! let num = ComplexNum { a: 0.0001, b: 12.539 }; -//! let data: String = json::encode(&ComplexNumRecord{ -//! uid: 1, -//! dsc: "test".to_string(), -//! val: num.to_json(), -//! }).unwrap(); -//! println!("data: {}", data); -//! // data: {"uid":1,"dsc":"test","val":"0.0001+12.539i"}; -//! } +//! let num = ComplexNum { a: 0.0001, b: 12.539 }; +//! let data: String = json::encode(&ComplexNumRecord{ +//! uid: 1, +//! dsc: "test".to_string(), +//! val: num.to_json(), +//! }).unwrap(); +//! println!("data: {}", data); +//! // data: {"uid":1,"dsc":"test","val":"0.0001+12.539i"}; //! ``` //! //! ### Verbose example of `ToJson` usage //! //! ```rust //! # #![feature(rustc_private)] +//! use rustc_macros::Decodable; //! use std::collections::BTreeMap; //! use rustc_serialize::json::{self, Json, ToJson}; //! -//! // Only generate `RustcDecodable` trait implementation -//! #[derive(RustcDecodable)] +//! // Only generate `Decodable` trait implementation +//! #[derive(Decodable)] //! pub struct TestStruct { //! data_int: u8, //! data_str: String, @@ -164,19 +163,17 @@ //! } //! } //! -//! fn main() { -//! // Serialize using `ToJson` -//! let input_data = TestStruct { -//! data_int: 1, -//! data_str: "madoka".to_string(), -//! data_vector: vec![2,3,4,5], -//! }; -//! let json_obj: Json = input_data.to_json(); -//! let json_str: String = json_obj.to_string(); +//! // Serialize using `ToJson` +//! let input_data = TestStruct { +//! data_int: 1, +//! data_str: "madoka".to_string(), +//! data_vector: vec![2,3,4,5], +//! }; +//! let json_obj: Json = input_data.to_json(); +//! let json_str: String = json_obj.to_string(); //! -//! // Deserialize like before -//! let decoded: TestStruct = json::decode(&json_str).unwrap(); -//! } +//! // Deserialize like before +//! let decoded: TestStruct = json::decode(&json_str).unwrap(); //! ``` use self::DecoderError::*; @@ -298,7 +295,7 @@ pub fn error_str(error: ErrorCode) -> &'static str { } /// Shortcut function to decode a JSON `&str` into an object -pub fn decode<T: crate::Decodable>(s: &str) -> DecodeResult<T> { +pub fn decode<T: crate::Decodable<Decoder>>(s: &str) -> DecodeResult<T> { let json = match from_str(s) { Ok(x) => x, Err(e) => return Err(ParseError(e)), @@ -309,7 +306,9 @@ pub fn decode<T: crate::Decodable>(s: &str) -> DecodeResult<T> { } /// Shortcut function to encode a `T` into a JSON `String` -pub fn encode<T: crate::Encodable>(object: &T) -> Result<string::String, EncoderError> { +pub fn encode<T: for<'r> crate::Encodable<Encoder<'r>>>( + object: &T, +) -> Result<string::String, EncoderError> { let mut s = String::new(); { let mut encoder = Encoder::new(&mut s); @@ -1150,8 +1149,8 @@ impl<'a> crate::Encoder for PrettyEncoder<'a> { } } -impl Encodable for Json { - fn encode<E: crate::Encoder>(&self, e: &mut E) -> Result<(), E::Error> { +impl<E: crate::Encoder> Encodable<E> for Json { + fn encode(&self, e: &mut E) -> Result<(), E::Error> { match *self { Json::I64(v) => v.encode(e), Json::U64(v) => v.encode(e), @@ -1269,34 +1268,22 @@ impl Json { /// Returns `true` if the Json value is a `Number`. pub fn is_number(&self) -> bool { - match *self { - Json::I64(_) | Json::U64(_) | Json::F64(_) => true, - _ => false, - } + matches!(*self, Json::I64(_) | Json::U64(_) | Json::F64(_)) } /// Returns `true` if the Json value is a `i64`. pub fn is_i64(&self) -> bool { - match *self { - Json::I64(_) => true, - _ => false, - } + matches!(*self, Json::I64(_)) } /// Returns `true` if the Json value is a `u64`. pub fn is_u64(&self) -> bool { - match *self { - Json::U64(_) => true, - _ => false, - } + matches!(*self, Json::U64(_)) } /// Returns `true` if the Json value is a `f64`. pub fn is_f64(&self) -> bool { - match *self { - Json::F64(_) => true, - _ => false, - } + matches!(*self, Json::F64(_)) } /// If the Json value is a number, returns or cast it to a `i64`; @@ -1416,6 +1403,7 @@ enum ParserState { /// structure of the JSON stream. /// /// An example is `foo.bar[3].x`. +#[derive(Default)] pub struct Stack { stack: Vec<InternalStackElement>, str_buffer: Vec<u8>, @@ -1442,7 +1430,7 @@ enum InternalStackElement { impl Stack { pub fn new() -> Stack { - Stack { stack: Vec::new(), str_buffer: Vec::new() } + Self::default() } /// Returns The number of elements in the Stack. @@ -1547,10 +1535,7 @@ impl Stack { // Used by Parser to test whether the top-most element is an index. fn last_is_index(&self) -> bool { - match self.stack.last() { - Some(InternalIndex(_)) => true, - _ => false, - } + matches!(self.stack.last(), Some(InternalIndex(_))) } // Used by Parser to increment the index of the top-most element. @@ -2747,7 +2732,7 @@ impl<'a> fmt::Display for PrettyJson<'a> { } } -impl<'a, T: Encodable> fmt::Display for AsJson<'a, T> { +impl<'a, T: for<'r> Encodable<Encoder<'r>>> fmt::Display for AsJson<'a, T> { /// Encodes a json value into a string fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut shim = FormatShim { inner: f }; @@ -2767,7 +2752,7 @@ impl<'a, T> AsPrettyJson<'a, T> { } } -impl<'a, T: Encodable> fmt::Display for AsPrettyJson<'a, T> { +impl<'a, T: for<'x> Encodable<PrettyEncoder<'x>>> fmt::Display for AsPrettyJson<'a, T> { /// Encodes a json value into a string fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut shim = FormatShim { inner: f }; diff --git a/src/librustc_serialize/lib.rs b/src/librustc_serialize/lib.rs index 3dc3e783820..265b3b95e95 100644 --- a/src/librustc_serialize/lib.rs +++ b/src/librustc_serialize/lib.rs @@ -10,7 +10,6 @@ Core encoding and decoding interfaces. test(attr(allow(unused_variables), deny(warnings))) )] #![feature(box_syntax)] -#![feature(min_specialization)] #![feature(never_type)] #![feature(nll)] #![feature(associated_type_bounds)] @@ -19,9 +18,6 @@ Core encoding and decoding interfaces. pub use self::serialize::{Decodable, Decoder, Encodable, Encoder}; -pub use self::serialize::{SpecializationError, SpecializedDecoder, SpecializedEncoder}; -pub use self::serialize::{UseSpecializedDecodable, UseSpecializedEncodable}; - mod collection_impls; mod serialize; diff --git a/src/librustc_serialize/opaque.rs b/src/librustc_serialize/opaque.rs index 39f3abb7527..fa4423e261d 100644 --- a/src/librustc_serialize/opaque.rs +++ b/src/librustc_serialize/opaque.rs @@ -118,13 +118,13 @@ impl serialize::Encoder for Encoder { #[inline] fn emit_f64(&mut self, v: f64) -> EncodeResult { - let as_u64: u64 = unsafe { ::std::mem::transmute(v) }; + let as_u64: u64 = v.to_bits(); self.emit_u64(as_u64) } #[inline] fn emit_f32(&mut self, v: f32) -> EncodeResult { - let as_u32: u32 = unsafe { ::std::mem::transmute(v) }; + let as_u32: u32 = v.to_bits(); self.emit_u32(as_u32) } diff --git a/src/librustc_serialize/serialize.rs b/src/librustc_serialize/serialize.rs index 29c5737ad89..c0e23b89a60 100644 --- a/src/librustc_serialize/serialize.rs +++ b/src/librustc_serialize/serialize.rs @@ -4,7 +4,6 @@ Core encoding and decoding interfaces. */ -use std::any; use std::borrow::Cow; use std::cell::{Cell, RefCell}; use std::marker::PhantomData; @@ -380,282 +379,155 @@ pub trait Decoder { fn error(&mut self, err: &str) -> Self::Error; } -pub trait Encodable { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error>; -} - -pub trait Decodable: Sized { - fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error>; -} - -impl Encodable for usize { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_usize(*self) - } -} - -impl Decodable for usize { - fn decode<D: Decoder>(d: &mut D) -> Result<usize, D::Error> { - d.read_usize() - } -} - -impl Encodable for u8 { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_u8(*self) - } -} - -impl Decodable for u8 { - fn decode<D: Decoder>(d: &mut D) -> Result<u8, D::Error> { - d.read_u8() - } -} - -impl Encodable for u16 { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_u16(*self) - } -} - -impl Decodable for u16 { - fn decode<D: Decoder>(d: &mut D) -> Result<u16, D::Error> { - d.read_u16() - } -} - -impl Encodable for u32 { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_u32(*self) - } +/// Trait for types that can be serialized +/// +/// This can be implemented using the `Encodable`, `TyEncodable` and +/// `MetadataEncodable` macros. +/// +/// * `Encodable` should be used in crates that don't depend on +/// `rustc_middle`. +/// * `MetadataEncodable` is used in `rustc_metadata` for types that contain +/// `rustc_metadata::rmeta::Lazy`. +/// * `TyEncodable` should be used for types that are only serialized in crate +/// metadata or the incremental cache. This is most types in `rustc_middle`. +pub trait Encodable<S: Encoder> { + fn encode(&self, s: &mut S) -> Result<(), S::Error>; } -impl Decodable for u32 { - fn decode<D: Decoder>(d: &mut D) -> Result<u32, D::Error> { - d.read_u32() - } -} +/// Trait for types that can be deserialized +/// +/// This can be implemented using the `Decodable`, `TyDecodable` and +/// `MetadataDecodable` macros. +/// +/// * `Decodable` should be used in crates that don't depend on +/// `rustc_middle`. +/// * `MetadataDecodable` is used in `rustc_metadata` for types that contain +/// `rustc_metadata::rmeta::Lazy`. +/// * `TyDecodable` should be used for types that are only serialized in crate +/// metadata or the incremental cache. This is most types in `rustc_middle`. +pub trait Decodable<D: Decoder>: Sized { + fn decode(d: &mut D) -> Result<Self, D::Error>; +} + +macro_rules! direct_serialize_impls { + ($($ty:ident $emit_method:ident $read_method:ident),*) => { + $( + impl<S: Encoder> Encodable<S> for $ty { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.$emit_method(*self) + } + } -impl Encodable for ::std::num::NonZeroU32 { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { + impl<D: Decoder> Decodable<D> for $ty { + fn decode(d: &mut D) -> Result<$ty, D::Error> { + d.$read_method() + } + } + )* + } +} + +direct_serialize_impls! { + usize emit_usize read_usize, + u8 emit_u8 read_u8, + u16 emit_u16 read_u16, + u32 emit_u32 read_u32, + u64 emit_u64 read_u64, + u128 emit_u128 read_u128, + isize emit_isize read_isize, + i8 emit_i8 read_i8, + i16 emit_i16 read_i16, + i32 emit_i32 read_i32, + i64 emit_i64 read_i64, + i128 emit_i128 read_i128, + f32 emit_f32 read_f32, + f64 emit_f64 read_f64, + bool emit_bool read_bool, + char emit_char read_char +} + +impl<S: Encoder> Encodable<S> for ::std::num::NonZeroU32 { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_u32(self.get()) } } -impl Decodable for ::std::num::NonZeroU32 { - fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error> { +impl<D: Decoder> Decodable<D> for ::std::num::NonZeroU32 { + fn decode(d: &mut D) -> Result<Self, D::Error> { d.read_u32().map(|d| ::std::num::NonZeroU32::new(d).unwrap()) } } -impl Encodable for u64 { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_u64(*self) - } -} - -impl Decodable for u64 { - fn decode<D: Decoder>(d: &mut D) -> Result<u64, D::Error> { - d.read_u64() - } -} - -impl Encodable for u128 { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_u128(*self) - } -} - -impl Decodable for u128 { - fn decode<D: Decoder>(d: &mut D) -> Result<u128, D::Error> { - d.read_u128() - } -} - -impl Encodable for isize { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_isize(*self) - } -} - -impl Decodable for isize { - fn decode<D: Decoder>(d: &mut D) -> Result<isize, D::Error> { - d.read_isize() - } -} - -impl Encodable for i8 { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_i8(*self) - } -} - -impl Decodable for i8 { - fn decode<D: Decoder>(d: &mut D) -> Result<i8, D::Error> { - d.read_i8() - } -} - -impl Encodable for i16 { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_i16(*self) - } -} - -impl Decodable for i16 { - fn decode<D: Decoder>(d: &mut D) -> Result<i16, D::Error> { - d.read_i16() - } -} - -impl Encodable for i32 { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_i32(*self) - } -} - -impl Decodable for i32 { - fn decode<D: Decoder>(d: &mut D) -> Result<i32, D::Error> { - d.read_i32() - } -} - -impl Encodable for i64 { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_i64(*self) - } -} - -impl Decodable for i64 { - fn decode<D: Decoder>(d: &mut D) -> Result<i64, D::Error> { - d.read_i64() - } -} - -impl Encodable for i128 { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_i128(*self) - } -} - -impl Decodable for i128 { - fn decode<D: Decoder>(d: &mut D) -> Result<i128, D::Error> { - d.read_i128() +impl<S: Encoder> Encodable<S> for str { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { + s.emit_str(self) } } -impl Encodable for str { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder> Encodable<S> for &str { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_str(self) } } -impl Encodable for String { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder> Encodable<S> for String { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_str(&self[..]) } } -impl Decodable for String { - fn decode<D: Decoder>(d: &mut D) -> Result<String, D::Error> { +impl<D: Decoder> Decodable<D> for String { + fn decode(d: &mut D) -> Result<String, D::Error> { Ok(d.read_str()?.into_owned()) } } -impl Encodable for f32 { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_f32(*self) - } -} - -impl Decodable for f32 { - fn decode<D: Decoder>(d: &mut D) -> Result<f32, D::Error> { - d.read_f32() - } -} - -impl Encodable for f64 { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_f64(*self) - } -} - -impl Decodable for f64 { - fn decode<D: Decoder>(d: &mut D) -> Result<f64, D::Error> { - d.read_f64() - } -} - -impl Encodable for bool { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_bool(*self) - } -} - -impl Decodable for bool { - fn decode<D: Decoder>(d: &mut D) -> Result<bool, D::Error> { - d.read_bool() - } -} - -impl Encodable for char { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_char(*self) - } -} - -impl Decodable for char { - fn decode<D: Decoder>(d: &mut D) -> Result<char, D::Error> { - d.read_char() - } -} - -impl Encodable for () { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder> Encodable<S> for () { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_unit() } } -impl Decodable for () { - fn decode<D: Decoder>(d: &mut D) -> Result<(), D::Error> { +impl<D: Decoder> Decodable<D> for () { + fn decode(d: &mut D) -> Result<(), D::Error> { d.read_nil() } } -impl<T> Encodable for PhantomData<T> { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, T> Encodable<S> for PhantomData<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_unit() } } -impl<T> Decodable for PhantomData<T> { - fn decode<D: Decoder>(d: &mut D) -> Result<PhantomData<T>, D::Error> { +impl<D: Decoder, T> Decodable<D> for PhantomData<T> { + fn decode(d: &mut D) -> Result<PhantomData<T>, D::Error> { d.read_nil()?; Ok(PhantomData) } } -impl<T: Decodable> Decodable for Box<[T]> { - fn decode<D: Decoder>(d: &mut D) -> Result<Box<[T]>, D::Error> { +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Box<[T]> { + fn decode(d: &mut D) -> Result<Box<[T]>, D::Error> { let v: Vec<T> = Decodable::decode(d)?; Ok(v.into_boxed_slice()) } } -impl<T: Encodable> Encodable for Rc<T> { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, T: Encodable<S>> Encodable<S> for Rc<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { (**self).encode(s) } } -impl<T: Decodable> Decodable for Rc<T> { - fn decode<D: Decoder>(d: &mut D) -> Result<Rc<T>, D::Error> { +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Rc<T> { + fn decode(d: &mut D) -> Result<Rc<T>, D::Error> { Ok(Rc::new(Decodable::decode(d)?)) } } -impl<T: Encodable> Encodable for [T] { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, T: Encodable<S>> Encodable<S> for [T] { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_seq(self.len(), |s| { for (i, e) in self.iter().enumerate() { s.emit_seq_elt(i, |s| e.encode(s))? @@ -665,8 +537,8 @@ impl<T: Encodable> Encodable for [T] { } } -impl<T: Encodable> Encodable for Vec<T> { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, T: Encodable<S>> Encodable<S> for Vec<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_seq(self.len(), |s| { for (i, e) in self.iter().enumerate() { s.emit_seq_elt(i, |s| e.encode(s))? @@ -676,8 +548,8 @@ impl<T: Encodable> Encodable for Vec<T> { } } -impl<T: Decodable> Decodable for Vec<T> { - fn decode<D: Decoder>(d: &mut D) -> Result<Vec<T>, D::Error> { +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Vec<T> { + fn decode(d: &mut D) -> Result<Vec<T>, D::Error> { d.read_seq(|d, len| { let mut v = Vec::with_capacity(len); for i in 0..len { @@ -688,8 +560,8 @@ impl<T: Decodable> Decodable for Vec<T> { } } -impl Encodable for [u8; 20] { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder> Encodable<S> for [u8; 20] { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_seq(self.len(), |s| { for (i, e) in self.iter().enumerate() { s.emit_seq_elt(i, |s| e.encode(s))? @@ -699,8 +571,8 @@ impl Encodable for [u8; 20] { } } -impl Decodable for [u8; 20] { - fn decode<D: Decoder>(d: &mut D) -> Result<[u8; 20], D::Error> { +impl<D: Decoder> Decodable<D> for [u8; 20] { + fn decode(d: &mut D) -> Result<[u8; 20], D::Error> { d.read_seq(|d, len| { assert!(len == 20); let mut v = [0u8; 20]; @@ -712,11 +584,11 @@ impl Decodable for [u8; 20] { } } -impl<'a, T: Encodable> Encodable for Cow<'a, [T]> +impl<'a, S: Encoder, T: Encodable<S>> Encodable<S> for Cow<'a, [T]> where [T]: ToOwned<Owned = Vec<T>>, { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_seq(self.len(), |s| { for (i, e) in self.iter().enumerate() { s.emit_seq_elt(i, |s| e.encode(s))? @@ -726,11 +598,11 @@ where } } -impl<T: Decodable + ToOwned> Decodable for Cow<'static, [T]> +impl<D: Decoder, T: Decodable<D> + ToOwned> Decodable<D> for Cow<'static, [T]> where [T]: ToOwned<Owned = Vec<T>>, { - fn decode<D: Decoder>(d: &mut D) -> Result<Cow<'static, [T]>, D::Error> { + fn decode(d: &mut D) -> Result<Cow<'static, [T]>, D::Error> { d.read_seq(|d, len| { let mut v = Vec::with_capacity(len); for i in 0..len { @@ -741,8 +613,8 @@ where } } -impl<T: Encodable> Encodable for Option<T> { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, T: Encodable<S>> Encodable<S> for Option<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_option(|s| match *self { None => s.emit_option_none(), Some(ref v) => s.emit_option_some(|s| v.encode(s)), @@ -750,14 +622,14 @@ impl<T: Encodable> Encodable for Option<T> { } } -impl<T: Decodable> Decodable for Option<T> { - fn decode<D: Decoder>(d: &mut D) -> Result<Option<T>, D::Error> { +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Option<T> { + fn decode(d: &mut D) -> Result<Option<T>, D::Error> { d.read_option(|d, b| if b { Ok(Some(Decodable::decode(d)?)) } else { Ok(None) }) } } -impl<T1: Encodable, T2: Encodable> Encodable for Result<T1, T2> { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, T1: Encodable<S>, T2: Encodable<S>> Encodable<S> for Result<T1, T2> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_enum("Result", |s| match *self { Ok(ref v) => { s.emit_enum_variant("Ok", 0, 1, |s| s.emit_enum_variant_arg(0, |s| v.encode(s))) @@ -769,8 +641,8 @@ impl<T1: Encodable, T2: Encodable> Encodable for Result<T1, T2> { } } -impl<T1: Decodable, T2: Decodable> Decodable for Result<T1, T2> { - fn decode<D: Decoder>(d: &mut D) -> Result<Result<T1, T2>, D::Error> { +impl<D: Decoder, T1: Decodable<D>, T2: Decodable<D>> Decodable<D> for Result<T1, T2> { + fn decode(d: &mut D) -> Result<Result<T1, T2>, D::Error> { d.read_enum("Result", |d| { d.read_enum_variant(&["Ok", "Err"], |d, disr| match disr { 0 => Ok(Ok(d.read_enum_variant_arg(0, |d| T1::decode(d))?)), @@ -806,9 +678,9 @@ macro_rules! count { macro_rules! tuple { () => (); ( $($name:ident,)+ ) => ( - impl<$($name:Decodable),+> Decodable for ($($name,)+) { + impl<D: Decoder, $($name: Decodable<D>),+> Decodable<D> for ($($name,)+) { #[allow(non_snake_case)] - fn decode<D: Decoder>(d: &mut D) -> Result<($($name,)+), D::Error> { + fn decode(d: &mut D) -> Result<($($name,)+), D::Error> { let len: usize = count!($($name)+); d.read_tuple(len, |d| { let mut i = 0; @@ -819,9 +691,9 @@ macro_rules! tuple { }) } } - impl<$($name:Encodable),+> Encodable for ($($name,)+) { + impl<S: Encoder, $($name: Encodable<S>),+> Encodable<S> for ($($name,)+) { #[allow(non_snake_case)] - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { let ($(ref $name,)+) = *self; let mut n = 0; $(let $name = $name; n += 1;)+ @@ -838,33 +710,33 @@ macro_rules! tuple { tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, } -impl Encodable for path::Path { - fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> { +impl<S: Encoder> Encodable<S> for path::Path { + fn encode(&self, e: &mut S) -> Result<(), S::Error> { self.to_str().unwrap().encode(e) } } -impl Encodable for path::PathBuf { - fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> { +impl<S: Encoder> Encodable<S> for path::PathBuf { + fn encode(&self, e: &mut S) -> Result<(), S::Error> { path::Path::encode(self, e) } } -impl Decodable for path::PathBuf { - fn decode<D: Decoder>(d: &mut D) -> Result<path::PathBuf, D::Error> { +impl<D: Decoder> Decodable<D> for path::PathBuf { + fn decode(d: &mut D) -> Result<path::PathBuf, D::Error> { let bytes: String = Decodable::decode(d)?; Ok(path::PathBuf::from(bytes)) } } -impl<T: Encodable + Copy> Encodable for Cell<T> { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, T: Encodable<S> + Copy> Encodable<S> for Cell<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { self.get().encode(s) } } -impl<T: Decodable + Copy> Decodable for Cell<T> { - fn decode<D: Decoder>(d: &mut D) -> Result<Cell<T>, D::Error> { +impl<D: Decoder, T: Decodable<D> + Copy> Decodable<D> for Cell<T> { + fn decode(d: &mut D) -> Result<Cell<T>, D::Error> { Ok(Cell::new(Decodable::decode(d)?)) } } @@ -874,136 +746,37 @@ impl<T: Decodable + Copy> Decodable for Cell<T> { // `encoder.error("attempting to Encode borrowed RefCell")` // from `encode` when `try_borrow` returns `None`. -impl<T: Encodable> Encodable for RefCell<T> { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, T: Encodable<S>> Encodable<S> for RefCell<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { self.borrow().encode(s) } } -impl<T: Decodable> Decodable for RefCell<T> { - fn decode<D: Decoder>(d: &mut D) -> Result<RefCell<T>, D::Error> { +impl<D: Decoder, T: Decodable<D>> Decodable<D> for RefCell<T> { + fn decode(d: &mut D) -> Result<RefCell<T>, D::Error> { Ok(RefCell::new(Decodable::decode(d)?)) } } -impl<T: Encodable> Encodable for Arc<T> { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, T: Encodable<S>> Encodable<S> for Arc<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { (**self).encode(s) } } -impl<T: Decodable> Decodable for Arc<T> { - fn decode<D: Decoder>(d: &mut D) -> Result<Arc<T>, D::Error> { +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Arc<T> { + fn decode(d: &mut D) -> Result<Arc<T>, D::Error> { Ok(Arc::new(Decodable::decode(d)?)) } } -// ___________________________________________________________________________ -// Specialization-based interface for multi-dispatch Encodable/Decodable. - -/// Implement this trait on your `{Encodable,Decodable}::Error` types -/// to override the default panic behavior for missing specializations. -pub trait SpecializationError { - /// Creates an error for a missing method specialization. - /// Defaults to panicking with type, trait & method names. - /// `S` is the encoder/decoder state type, - /// `T` is the type being encoded/decoded, and - /// the arguments are the names of the trait - /// and method that should've been overridden. - fn not_found<S, T: ?Sized>(trait_name: &'static str, method_name: &'static str) -> Self; -} - -impl<E> SpecializationError for E { - default fn not_found<S, T: ?Sized>(trait_name: &'static str, method_name: &'static str) -> E { - panic!( - "missing specialization: `<{} as {}<{}>>::{}` not overridden", - any::type_name::<S>(), - trait_name, - any::type_name::<T>(), - method_name - ); - } -} - -/// Implement this trait on encoders, with `T` being the type -/// you want to encode (employing `UseSpecializedEncodable`), -/// using a strategy specific to the encoder. -pub trait SpecializedEncoder<T: ?Sized + UseSpecializedEncodable>: Encoder { - /// Encode the value in a manner specific to this encoder state. - fn specialized_encode(&mut self, value: &T) -> Result<(), Self::Error>; -} - -impl<E: Encoder, T: ?Sized + UseSpecializedEncodable> SpecializedEncoder<T> for E { - default fn specialized_encode(&mut self, value: &T) -> Result<(), E::Error> { - value.default_encode(self) - } -} - -/// Implement this trait on decoders, with `T` being the type -/// you want to decode (employing `UseSpecializedDecodable`), -/// using a strategy specific to the decoder. -pub trait SpecializedDecoder<T: UseSpecializedDecodable>: Decoder { - /// Decode a value in a manner specific to this decoder state. - fn specialized_decode(&mut self) -> Result<T, Self::Error>; -} - -impl<D: Decoder, T: UseSpecializedDecodable> SpecializedDecoder<T> for D { - default fn specialized_decode(&mut self) -> Result<T, D::Error> { - T::default_decode(self) - } -} - -/// Implement this trait on your type to get an `Encodable` -/// implementation which goes through `SpecializedEncoder`. -pub trait UseSpecializedEncodable { - /// Defaults to returning an error (see `SpecializationError`). - fn default_encode<E: Encoder>(&self, _: &mut E) -> Result<(), E::Error> { - Err(E::Error::not_found::<E, Self>("SpecializedEncoder", "specialized_encode")) - } -} - -impl<T: ?Sized + UseSpecializedEncodable> Encodable for T { - default fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> { - E::specialized_encode(e, self) - } -} - -/// Implement this trait on your type to get an `Decodable` -/// implementation which goes through `SpecializedDecoder`. -pub trait UseSpecializedDecodable: Sized { - /// Defaults to returning an error (see `SpecializationError`). - fn default_decode<D: Decoder>(_: &mut D) -> Result<Self, D::Error> { - Err(D::Error::not_found::<D, Self>("SpecializedDecoder", "specialized_decode")) - } -} - -impl<T: UseSpecializedDecodable> Decodable for T { - default fn decode<D: Decoder>(d: &mut D) -> Result<T, D::Error> { - D::specialized_decode(d) - } -} - -// Can't avoid specialization for &T and Box<T> impls, -// as proxy impls on them are blankets that conflict -// with the Encodable and Decodable impls above, -// which only have `default` on their methods -// for this exact reason. -// May be fixable in a simpler fashion via the -// more complex lattice model for specialization. -impl<'a, T: ?Sized + Encodable> UseSpecializedEncodable for &'a T { - fn default_encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - (**self).encode(s) - } -} -impl<T: ?Sized + Encodable> UseSpecializedEncodable for Box<T> { - fn default_encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder, T: ?Sized + Encodable<S>> Encodable<S> for Box<T> { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { (**self).encode(s) } } -impl<T: Decodable> UseSpecializedDecodable for Box<T> { - fn default_decode<D: Decoder>(d: &mut D) -> Result<Box<T>, D::Error> { +impl<D: Decoder, T: Decodable<D>> Decodable<D> for Box<T> { + fn decode(d: &mut D) -> Result<Box<T>, D::Error> { Ok(box Decodable::decode(d)?) } } -impl<'a, T: Decodable> UseSpecializedDecodable for &'a T {} -impl<'a, T: Decodable> UseSpecializedDecodable for &'a [T] {} diff --git a/src/librustc_serialize/tests/json.rs b/src/librustc_serialize/tests/json.rs index 59c481edbca..e3a823127d9 100644 --- a/src/librustc_serialize/tests/json.rs +++ b/src/librustc_serialize/tests/json.rs @@ -9,6 +9,7 @@ use json::{ from_str, DecodeResult, Decoder, DecoderError, Encoder, EncoderError, Json, JsonEvent, Parser, StackElement, }; +use rustc_macros::{Decodable, Encodable}; use rustc_serialize::json; use rustc_serialize::{Decodable, Encodable}; @@ -17,7 +18,7 @@ use std::io::prelude::*; use std::string; use Animal::*; -#[derive(RustcDecodable, Eq, PartialEq, Debug)] +#[derive(Decodable, Eq, PartialEq, Debug)] struct OptionData { opt: Option<usize>, } @@ -48,20 +49,20 @@ fn test_decode_option_malformed() { ); } -#[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)] +#[derive(PartialEq, Encodable, Decodable, Debug)] enum Animal { Dog, Frog(string::String, isize), } -#[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)] +#[derive(PartialEq, Encodable, Decodable, Debug)] struct Inner { a: (), b: usize, c: Vec<string::String>, } -#[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)] +#[derive(PartialEq, Encodable, Decodable, Debug)] struct Outer { inner: Vec<Inner>, } @@ -568,7 +569,7 @@ fn test_decode_struct() { ); } -#[derive(RustcDecodable)] +#[derive(Decodable)] struct FloatStruct { f: f64, a: Vec<f64>, @@ -616,7 +617,7 @@ fn test_multiline_errors() { assert_eq!(from_str("{\n \"foo\":\n \"bar\""), Err(SyntaxError(EOFWhileParsingObject, 3, 8))); } -#[derive(RustcDecodable)] +#[derive(Decodable)] #[allow(dead_code)] struct DecodeStruct { x: f64, @@ -624,12 +625,12 @@ struct DecodeStruct { z: string::String, w: Vec<DecodeStruct>, } -#[derive(RustcDecodable)] +#[derive(Decodable)] enum DecodeEnum { A(f64), B(string::String), } -fn check_err<T: Decodable>(to_parse: &'static str, expected: DecoderError) { +fn check_err<T: Decodable<Decoder>>(to_parse: &'static str, expected: DecoderError) { let res: DecodeResult<T> = match from_str(to_parse) { Err(e) => Err(ParseError(e)), Ok(json) => Decodable::decode(&mut Decoder::new(json)), @@ -933,7 +934,7 @@ fn test_prettyencoder_indent_level_param() { #[test] fn test_hashmap_with_enum_key() { use std::collections::HashMap; - #[derive(RustcEncodable, Eq, Hash, PartialEq, RustcDecodable, Debug)] + #[derive(Encodable, Eq, Hash, PartialEq, Decodable, Debug)] enum Enum { Foo, #[allow(dead_code)] @@ -1254,7 +1255,7 @@ fn test_to_json() { #[test] fn test_encode_hashmap_with_arbitrary_key() { use std::collections::HashMap; - #[derive(PartialEq, Eq, Hash, RustcEncodable)] + #[derive(PartialEq, Eq, Hash, Encodable)] struct ArbitraryType(usize); let mut hm: HashMap<ArbitraryType, bool> = HashMap::new(); hm.insert(ArbitraryType(1), true); diff --git a/src/librustc_serialize/tests/opaque.rs b/src/librustc_serialize/tests/opaque.rs index c8273917007..13b3676a56c 100644 --- a/src/librustc_serialize/tests/opaque.rs +++ b/src/librustc_serialize/tests/opaque.rs @@ -1,10 +1,11 @@ #![allow(rustc::internal)] +use rustc_macros::{Decodable, Encodable}; use rustc_serialize::opaque::{Decoder, Encoder}; use rustc_serialize::{Decodable, Encodable}; use std::fmt::Debug; -#[derive(PartialEq, Clone, Debug, RustcEncodable, RustcDecodable)] +#[derive(PartialEq, Clone, Debug, Encodable, Decodable)] struct Struct { a: (), b: u8, @@ -27,11 +28,13 @@ struct Struct { q: Option<u32>, } -fn check_round_trip<T: Encodable + Decodable + PartialEq + Debug>(values: Vec<T>) { +fn check_round_trip<T: Encodable<Encoder> + for<'a> Decodable<Decoder<'a>> + PartialEq + Debug>( + values: Vec<T>, +) { let mut encoder = Encoder::new(Vec::new()); for value in &values { - Encodable::encode(&value, &mut encoder).unwrap(); + Encodable::encode(value, &mut encoder).unwrap(); } let data = encoder.into_inner(); @@ -225,7 +228,7 @@ fn test_struct() { }]); } -#[derive(PartialEq, Clone, Debug, RustcEncodable, RustcDecodable)] +#[derive(PartialEq, Clone, Debug, Encodable, Decodable)] enum Enum { Variant1, Variant2(usize, f32), diff --git a/src/librustc_session/Cargo.toml b/src/librustc_session/Cargo.toml index 35c227df850..208bba1d962 100644 --- a/src/librustc_session/Cargo.toml +++ b/src/librustc_session/Cargo.toml @@ -11,7 +11,8 @@ path = "lib.rs" [dependencies] bitflags = "1.2.1" getopts = "0.2" -log = { package = "tracing", version = "0.1" } +rustc_macros = { path = "../librustc_macros" } +tracing = "0.1" rustc_errors = { path = "../librustc_errors" } rustc_feature = { path = "../librustc_feature" } rustc_target = { path = "../librustc_target" } diff --git a/src/librustc_session/cgu_reuse_tracker.rs b/src/librustc_session/cgu_reuse_tracker.rs index ace23361122..0eec12aa03f 100644 --- a/src/librustc_session/cgu_reuse_tracker.rs +++ b/src/librustc_session/cgu_reuse_tracker.rs @@ -2,10 +2,10 @@ //! compilation. This is used for incremental compilation tests and debug //! output. -use log::debug; use rustc_data_structures::fx::FxHashMap; use rustc_span::{Span, Symbol}; use std::sync::{Arc, Mutex}; +use tracing::debug; #[derive(Copy, Clone, Debug, PartialEq, PartialOrd)] pub enum CguReuse { diff --git a/src/librustc_session/config.rs b/src/librustc_session/config.rs index 9fcdd46539c..1808a0ca59b 100644 --- a/src/librustc_session/config.rs +++ b/src/librustc_session/config.rs @@ -39,7 +39,7 @@ pub struct Config { } bitflags! { - #[derive(Default, RustcEncodable, RustcDecodable)] + #[derive(Default, Encodable, Decodable)] pub struct SanitizerSet: u8 { const ADDRESS = 1 << 0; const LEAK = 1 << 1; @@ -194,7 +194,8 @@ impl SwitchWithOptPath { } } -#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[derive(Encodable, Decodable)] pub enum SymbolManglingVersion { Legacy, V0, @@ -209,7 +210,8 @@ pub enum DebugInfo { Full, } -#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)] +#[derive(Encodable, Decodable)] pub enum OutputType { Bitcode, Assembly, @@ -672,7 +674,7 @@ pub enum EntryFnType { impl_stable_hash_via_hash!(EntryFnType); -#[derive(Copy, PartialEq, PartialOrd, Clone, Ord, Eq, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Copy, PartialEq, PartialOrd, Clone, Ord, Eq, Hash, Debug, Encodable, Decodable)] pub enum CrateType { Executable, Dylib, @@ -1876,7 +1878,7 @@ fn parse_pretty( } } }; - log::debug!("got unpretty option: {:?}", first); + tracing::debug!("got unpretty option: {:?}", first); first } } diff --git a/src/librustc_session/filesearch.rs b/src/librustc_session/filesearch.rs index 8fe71b71cae..284fca652ec 100644 --- a/src/librustc_session/filesearch.rs +++ b/src/librustc_session/filesearch.rs @@ -8,8 +8,8 @@ use std::fs; use std::path::{Path, PathBuf}; use crate::search_paths::{PathKind, SearchPath, SearchPathFile}; -use log::debug; use rustc_fs_util::fix_windows_verbatim_for_gcc; +use tracing::debug; #[derive(Copy, Clone)] pub enum FileMatch { diff --git a/src/librustc_session/lib.rs b/src/librustc_session/lib.rs index be9d2e7be27..c2ea141a06f 100644 --- a/src/librustc_session/lib.rs +++ b/src/librustc_session/lib.rs @@ -3,6 +3,8 @@ #[macro_use] extern crate bitflags; +#[macro_use] +extern crate rustc_macros; pub mod cgu_reuse_tracker; pub mod utils; diff --git a/src/librustc_session/search_paths.rs b/src/librustc_session/search_paths.rs index 4ff06acaa1f..e12364b7dac 100644 --- a/src/librustc_session/search_paths.rs +++ b/src/librustc_session/search_paths.rs @@ -33,7 +33,7 @@ impl SearchPathFile { } } -#[derive(PartialEq, Clone, Copy, Debug, Hash, Eq, RustcEncodable, RustcDecodable)] +#[derive(PartialEq, Clone, Copy, Debug, Hash, Eq, Encodable, Decodable)] pub enum PathKind { Native, Crate, diff --git a/src/librustc_session/session.rs b/src/librustc_session/session.rs index 9191f7e8d76..66dbe53bac3 100644 --- a/src/librustc_session/session.rs +++ b/src/librustc_session/session.rs @@ -1453,14 +1453,19 @@ fn validate_commandline_args_with_session_available(sess: &Session) { "aarch64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-fuchsia", + "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu", ]; const LSAN_SUPPORTED_TARGETS: &[&str] = &["aarch64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-unknown-linux-gnu"]; const MSAN_SUPPORTED_TARGETS: &[&str] = - &["aarch64-unknown-linux-gnu", "x86_64-unknown-linux-gnu"]; - const TSAN_SUPPORTED_TARGETS: &[&str] = - &["aarch64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-unknown-linux-gnu"]; + &["aarch64-unknown-linux-gnu", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"]; + const TSAN_SUPPORTED_TARGETS: &[&str] = &[ + "aarch64-unknown-linux-gnu", + "x86_64-apple-darwin", + "x86_64-unknown-freebsd", + "x86_64-unknown-linux-gnu", + ]; // Sanitizers can only be used on some tested platforms. for s in sess.opts.debugging_opts.sanitizer { diff --git a/src/librustc_session/utils.rs b/src/librustc_session/utils.rs index b97308c22cb..15447c01d1e 100644 --- a/src/librustc_session/utils.rs +++ b/src/librustc_session/utils.rs @@ -10,7 +10,7 @@ impl Session { } } -#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Encodable, Decodable)] pub enum NativeLibKind { /// Static library (e.g. `libfoo.a` on Linux or `foo.lib` on Windows/MSVC) included /// when linking a final binary, but not when archiving an rlib. diff --git a/src/librustc_span/Cargo.toml b/src/librustc_span/Cargo.toml index 2db417ce0e1..dd4928d4e32 100644 --- a/src/librustc_span/Cargo.toml +++ b/src/librustc_span/Cargo.toml @@ -18,6 +18,6 @@ rustc_arena = { path = "../librustc_arena" } scoped-tls = "1.0" unicode-width = "0.1.4" cfg-if = "0.1.2" -log = { package = "tracing", version = "0.1" } +tracing = "0.1" sha-1 = "0.8" md-5 = "0.8" diff --git a/src/librustc_span/def_id.rs b/src/librustc_span/def_id.rs index a874f81868f..aae778217d3 100644 --- a/src/librustc_span/def_id.rs +++ b/src/librustc_span/def_id.rs @@ -4,7 +4,7 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_data_structures::AtomicRef; use rustc_index::vec::Idx; use rustc_macros::HashStable_Generic; -use rustc_serialize::{Decoder, Encoder}; +use rustc_serialize::{Decodable, Decoder, Encodable, Encoder}; use std::borrow::Borrow; use std::fmt; @@ -84,13 +84,14 @@ impl fmt::Display for CrateNum { /// As a local identifier, a `CrateNum` is only meaningful within its context, e.g. within a tcx. /// Therefore, make sure to include the context when encode a `CrateNum`. -impl rustc_serialize::UseSpecializedEncodable for CrateNum { - fn default_encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> { - e.emit_u32(self.as_u32()) +impl<E: Encoder> Encodable<E> for CrateNum { + default fn encode(&self, s: &mut E) -> Result<(), E::Error> { + s.emit_u32(self.as_u32()) } } -impl rustc_serialize::UseSpecializedDecodable for CrateNum { - fn default_decode<D: Decoder>(d: &mut D) -> Result<CrateNum, D::Error> { + +impl<D: Decoder> Decodable<D> for CrateNum { + default fn decode(d: &mut D) -> Result<CrateNum, D::Error> { Ok(CrateNum::from_u32(d.read_u32()?)) } } @@ -104,8 +105,8 @@ impl ::std::fmt::Debug for CrateNum { } } -#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Debug, RustcEncodable, RustcDecodable)] -#[derive(HashStable_Generic)] +#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Debug)] +#[derive(HashStable_Generic, Encodable, Decodable)] pub struct DefPathHash(pub Fingerprint); impl Borrow<Fingerprint> for DefPathHash { @@ -120,16 +121,26 @@ rustc_index::newtype_index! { /// particular definition. It should really be considered an interned /// shorthand for a particular DefPath. pub struct DefIndex { - DEBUG_FORMAT = "DefIndex({})", + ENCODABLE = custom // (only encodable in metadata) + DEBUG_FORMAT = "DefIndex({})", /// The crate root is always assigned index 0 by the AST Map code, /// thanks to `NodeCollector::new`. const CRATE_DEF_INDEX = 0, } } -impl rustc_serialize::UseSpecializedEncodable for DefIndex {} -impl rustc_serialize::UseSpecializedDecodable for DefIndex {} +impl<E: Encoder> Encodable<E> for DefIndex { + default fn encode(&self, _: &mut E) -> Result<(), E::Error> { + panic!("cannot encode `DefIndex` with `{}`", std::any::type_name::<E>()); + } +} + +impl<D: Decoder> Decodable<D> for DefIndex { + default fn decode(_: &mut D) -> Result<DefIndex, D::Error> { + panic!("cannot decode `DefIndex` with `{}`", std::any::type_name::<D>()); + } +} /// A `DefId` identifies a particular *definition*, by combining a crate /// index and a def index. @@ -168,19 +179,24 @@ impl DefId { } } -impl rustc_serialize::UseSpecializedEncodable for DefId { - fn default_encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - let krate = u64::from(self.krate.as_u32()); - let index = u64::from(self.index.as_u32()); - s.emit_u64((krate << 32) | index) +impl<E: Encoder> Encodable<E> for DefId { + default fn encode(&self, s: &mut E) -> Result<(), E::Error> { + s.emit_struct("DefId", 2, |s| { + s.emit_struct_field("krate", 0, |s| self.krate.encode(s))?; + + s.emit_struct_field("index", 1, |s| self.index.encode(s)) + }) } } -impl rustc_serialize::UseSpecializedDecodable for DefId { - fn default_decode<D: Decoder>(d: &mut D) -> Result<DefId, D::Error> { - let def_id = d.read_u64()?; - let krate = CrateNum::from_u32((def_id >> 32) as u32); - let index = DefIndex::from_u32((def_id & 0xffffffff) as u32); - Ok(DefId { krate, index }) + +impl<D: Decoder> Decodable<D> for DefId { + default fn decode(d: &mut D) -> Result<DefId, D::Error> { + d.read_struct("DefId", 2, |d| { + Ok(DefId { + krate: d.read_struct_field("krate", 0, Decodable::decode)?, + index: d.read_struct_field("index", 1, Decodable::decode)?, + }) + }) } } @@ -239,8 +255,17 @@ impl fmt::Debug for LocalDefId { } } -impl rustc_serialize::UseSpecializedEncodable for LocalDefId {} -impl rustc_serialize::UseSpecializedDecodable for LocalDefId {} +impl<E: Encoder> Encodable<E> for LocalDefId { + fn encode(&self, s: &mut E) -> Result<(), E::Error> { + self.to_def_id().encode(s) + } +} + +impl<D: Decoder> Decodable<D> for LocalDefId { + fn decode(d: &mut D) -> Result<LocalDefId, D::Error> { + DefId::decode(d).map(|d| d.expect_local()) + } +} impl<CTX: HashStableContext> HashStable<CTX> for DefId { fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) { diff --git a/src/librustc_span/edition.rs b/src/librustc_span/edition.rs index b1ac7f04321..4d0c92f51d7 100644 --- a/src/librustc_span/edition.rs +++ b/src/librustc_span/edition.rs @@ -5,7 +5,7 @@ use std::str::FromStr; use rustc_macros::HashStable_Generic; /// The edition of the compiler (RFC 2052) -#[derive(Clone, Copy, Hash, PartialEq, PartialOrd, Debug, RustcEncodable, RustcDecodable, Eq)] +#[derive(Clone, Copy, Hash, PartialEq, PartialOrd, Debug, Encodable, Decodable, Eq)] #[derive(HashStable_Generic)] pub enum Edition { // editions must be kept in order, oldest to newest diff --git a/src/librustc_span/hygiene.rs b/src/librustc_span/hygiene.rs index f52b2195c2f..942c6648340 100644 --- a/src/librustc_span/hygiene.rs +++ b/src/librustc_span/hygiene.rs @@ -30,20 +30,18 @@ use crate::SESSION_GLOBALS; use crate::{Span, DUMMY_SP}; use crate::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE}; -use log::*; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_data_structures::sync::{Lock, Lrc}; use rustc_macros::HashStable_Generic; -use rustc_serialize::{ - Decodable, Decoder, Encodable, Encoder, UseSpecializedDecodable, UseSpecializedEncodable, -}; +use rustc_serialize::{Decodable, Decoder, Encodable, Encoder}; use std::fmt; +use tracing::*; /// A `SyntaxContext` represents a chain of pairs `(ExpnId, Transparency)` named "marks". #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct SyntaxContext(u32); -#[derive(Debug, RustcEncodable, RustcDecodable, Clone)] +#[derive(Debug, Encodable, Decodable, Clone)] pub struct SyntaxContextData { outer_expn: ExpnId, outer_transparency: Transparency, @@ -62,7 +60,7 @@ pub struct ExpnId(u32); /// A property of a macro expansion that determines how identifiers /// produced by that expansion are resolved. -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Hash, Debug, Encodable, Decodable)] #[derive(HashStable_Generic)] pub enum Transparency { /// Identifier produced by a transparent expansion is always resolved at call-site. @@ -664,7 +662,7 @@ impl Span { /// A subset of properties from both macro definition and macro call available through global data. /// Avoid using this if you have access to the original definition or call structures. -#[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Clone, Debug, Encodable, Decodable, HashStable_Generic)] pub struct ExpnData { // --- The part unique to each expansion. /// The kind of this expansion - macro or compiler desugaring. @@ -766,7 +764,7 @@ impl ExpnData { } /// Expansion kind. -#[derive(Clone, Debug, PartialEq, RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Clone, Debug, PartialEq, Encodable, Decodable, HashStable_Generic)] pub enum ExpnKind { /// No expansion, aka root expansion. Only `ExpnId::root()` has this kind. Root, @@ -794,7 +792,7 @@ impl ExpnKind { } /// The kind of macro invocation or definition. -#[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, Hash, Debug)] #[derive(HashStable_Generic)] pub enum MacroKind { /// A bang macro `foo!()`. @@ -830,7 +828,7 @@ impl MacroKind { } /// The kind of AST transform. -#[derive(Clone, Copy, Debug, PartialEq, RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Clone, Copy, Debug, PartialEq, Encodable, Decodable, HashStable_Generic)] pub enum AstPass { StdImports, TestHarness, @@ -848,7 +846,7 @@ impl AstPass { } /// The kind of compiler desugaring. -#[derive(Clone, Copy, PartialEq, Debug, RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Clone, Copy, PartialEq, Debug, Encodable, Decodable, HashStable_Generic)] pub enum DesugaringKind { /// We desugar `if c { i } else { e }` to `match $ExprKind::Use(c) { true => i, _ => e }`. /// However, we do not want to blame `c` for unreachability but rather say that `i` @@ -867,7 +865,7 @@ pub enum DesugaringKind { } /// A location in the desugaring of a `for` loop -#[derive(Clone, Copy, PartialEq, Debug, RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Clone, Copy, PartialEq, Debug, Encodable, Decodable, HashStable_Generic)] pub enum ForLoopLoc { Head, IntoIter, @@ -888,9 +886,6 @@ impl DesugaringKind { } } -impl UseSpecializedEncodable for ExpnId {} -impl UseSpecializedDecodable for ExpnId {} - #[derive(Default)] pub struct HygieneEncodeContext { /// All `SyntaxContexts` for which we have written `SyntaxContextData` into crate metadata. @@ -1137,6 +1132,7 @@ pub fn for_all_expns_in<E, F: FnMut(u32, ExpnId, &ExpnData) -> Result<(), E>>( } Ok(()) } + pub fn for_all_data<E, F: FnMut((u32, SyntaxContext, &SyntaxContextData)) -> Result<(), E>>( mut f: F, ) -> Result<(), E> { @@ -1147,6 +1143,18 @@ pub fn for_all_data<E, F: FnMut((u32, SyntaxContext, &SyntaxContextData)) -> Res Ok(()) } +impl<E: Encoder> Encodable<E> for ExpnId { + default fn encode(&self, _: &mut E) -> Result<(), E::Error> { + panic!("cannot encode `ExpnId` with `{}`", std::any::type_name::<E>()); + } +} + +impl<D: Decoder> Decodable<D> for ExpnId { + default fn decode(_: &mut D) -> Result<Self, D::Error> { + panic!("cannot decode `ExpnId` with `{}`", std::any::type_name::<D>()); + } +} + pub fn for_all_expn_data<E, F: FnMut(u32, &ExpnData) -> Result<(), E>>(mut f: F) -> Result<(), E> { let all_data = HygieneData::with(|data| data.expn_data.clone()); for (i, data) in all_data.into_iter().enumerate() { @@ -1218,5 +1226,14 @@ impl<'a> ExpnDataDecodeMode<'a, Box<dyn FnOnce(CrateNum) -> &'a HygieneDecodeCon } } -impl UseSpecializedEncodable for SyntaxContext {} -impl UseSpecializedDecodable for SyntaxContext {} +impl<E: Encoder> Encodable<E> for SyntaxContext { + default fn encode(&self, _: &mut E) -> Result<(), E::Error> { + panic!("cannot encode `SyntaxContext` with `{}`", std::any::type_name::<E>()); + } +} + +impl<D: Decoder> Decodable<D> for SyntaxContext { + default fn decode(_: &mut D) -> Result<Self, D::Error> { + panic!("cannot decode `SyntaxContext` with `{}`", std::any::type_name::<D>()); + } +} diff --git a/src/librustc_span/lib.rs b/src/librustc_span/lib.rs index 697d88ad063..c654dade2ab 100644 --- a/src/librustc_span/lib.rs +++ b/src/librustc_span/lib.rs @@ -15,8 +15,7 @@ #![feature(option_expect_none)] #![feature(refcell_take)] -// FIXME(#56935): Work around ICEs during cross-compilation. -#[allow(unused)] +#[macro_use] extern crate rustc_macros; use rustc_data_structures::AtomicRef; @@ -105,8 +104,8 @@ scoped_tls::scoped_thread_local!(pub static SESSION_GLOBALS: SessionGlobals); // // FIXME: We should use this enum or something like it to get rid of the // use of magic `/rust/1.x/...` paths across the board. -#[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Hash, RustcDecodable, RustcEncodable)] -#[derive(HashStable_Generic)] +#[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Hash)] +#[derive(HashStable_Generic, Decodable, Encodable)] pub enum RealFileName { Named(PathBuf), /// For de-virtualized paths (namely paths into libstd that have been mapped @@ -152,8 +151,8 @@ impl RealFileName { } /// Differentiates between real files and common virtual files. -#[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Hash, RustcDecodable, RustcEncodable)] -#[derive(HashStable_Generic)] +#[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Hash)] +#[derive(HashStable_Generic, Decodable, Encodable)] pub enum FileName { Real(RealFileName), /// Call to `quote!`. @@ -333,7 +332,7 @@ impl Ord for Span { /// the error, and would be rendered with `^^^`. /// - They can have a *label*. In this case, the label is written next /// to the mark in the snippet when we render. -#[derive(Clone, Debug, Hash, PartialEq, Eq, RustcEncodable, RustcDecodable)] +#[derive(Clone, Debug, Hash, PartialEq, Eq, Encodable, Decodable)] pub struct MultiSpan { primary_spans: Vec<Span>, span_labels: Vec<(Span, String)>, @@ -698,23 +697,22 @@ impl Default for Span { } } -impl rustc_serialize::UseSpecializedEncodable for Span { - fn default_encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<E: Encoder> Encodable<E> for Span { + default fn encode(&self, s: &mut E) -> Result<(), E::Error> { let span = self.data(); s.emit_struct("Span", 2, |s| { s.emit_struct_field("lo", 0, |s| span.lo.encode(s))?; - s.emit_struct_field("hi", 1, |s| span.hi.encode(s)) }) } } - -impl rustc_serialize::UseSpecializedDecodable for Span { - fn default_decode<D: Decoder>(d: &mut D) -> Result<Span, D::Error> { - d.read_struct("Span", 2, |d| { +impl<D: Decoder> Decodable<D> for Span { + default fn decode(s: &mut D) -> Result<Span, D::Error> { + s.read_struct("Span", 2, |d| { let lo = d.read_struct_field("lo", 0, Decodable::decode)?; let hi = d.read_struct_field("hi", 1, Decodable::decode)?; - Ok(Span::with_root_ctxt(lo, hi)) + + Ok(Span::new(lo, hi, SyntaxContext::root())) }) } } @@ -889,7 +887,7 @@ impl From<Vec<Span>> for MultiSpan { } /// Identifies an offset of a multi-byte character in a `SourceFile`. -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Eq, PartialEq, Debug)] +#[derive(Copy, Clone, Encodable, Decodable, Eq, PartialEq, Debug)] pub struct MultiByteChar { /// The absolute offset of the character in the `SourceMap`. pub pos: BytePos, @@ -898,7 +896,7 @@ pub struct MultiByteChar { } /// Identifies an offset of a non-narrow character in a `SourceFile`. -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Eq, PartialEq, Debug)] +#[derive(Copy, Clone, Encodable, Decodable, Eq, PartialEq, Debug)] pub enum NonNarrowChar { /// Represents a zero-width character. ZeroWidth(BytePos), @@ -960,7 +958,7 @@ impl Sub<BytePos> for NonNarrowChar { } /// Identifies an offset of a character that was normalized away from `SourceFile`. -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Eq, PartialEq, Debug)] +#[derive(Copy, Clone, Encodable, Decodable, Eq, PartialEq, Debug)] pub struct NormalizedPos { /// The absolute offset of the character in the `SourceMap`. pub pos: BytePos, @@ -1012,7 +1010,7 @@ impl ExternalSource { #[derive(Debug)] pub struct OffsetOverflowError; -#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Encodable, Decodable)] pub enum SourceFileHashAlgorithm { Md5, Sha1, @@ -1033,8 +1031,8 @@ impl FromStr for SourceFileHashAlgorithm { rustc_data_structures::impl_stable_hash_via_hash!(SourceFileHashAlgorithm); /// The hash of the on-disk source file used for debug info. -#[derive(Copy, Clone, PartialEq, Eq, Debug, RustcEncodable, RustcDecodable)] -#[derive(HashStable_Generic)] +#[derive(Copy, Clone, PartialEq, Eq, Debug)] +#[derive(HashStable_Generic, Encodable, Decodable)] pub struct SourceFileHash { pub kind: SourceFileHashAlgorithm, value: [u8; 20], @@ -1113,8 +1111,8 @@ pub struct SourceFile { pub cnum: CrateNum, } -impl Encodable for SourceFile { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder> Encodable<S> for SourceFile { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_struct("SourceFile", 8, |s| { s.emit_struct_field("name", 0, |s| self.name.encode(s))?; s.emit_struct_field("name_was_remapped", 1, |s| self.name_was_remapped.encode(s))?; @@ -1183,8 +1181,8 @@ impl Encodable for SourceFile { } } -impl Decodable for SourceFile { - fn decode<D: Decoder>(d: &mut D) -> Result<SourceFile, D::Error> { +impl<D: Decoder> Decodable<D> for SourceFile { + fn decode(d: &mut D) -> Result<SourceFile, D::Error> { d.read_struct("SourceFile", 8, |d| { let name: FileName = d.read_struct_field("name", 0, |d| Decodable::decode(d))?; let name_was_remapped: bool = @@ -1585,14 +1583,14 @@ impl Sub for BytePos { } } -impl Encodable for BytePos { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: rustc_serialize::Encoder> Encodable<S> for BytePos { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { s.emit_u32(self.0) } } -impl Decodable for BytePos { - fn decode<D: Decoder>(d: &mut D) -> Result<BytePos, D::Error> { +impl<D: rustc_serialize::Decoder> Decodable<D> for BytePos { + fn decode(d: &mut D) -> Result<BytePos, D::Error> { Ok(BytePos(d.read_u32()?)) } } diff --git a/src/librustc_span/source_map.rs b/src/librustc_span/source_map.rs index e062c7766e7..7c656db22ed 100644 --- a/src/librustc_span/source_map.rs +++ b/src/librustc_span/source_map.rs @@ -19,9 +19,9 @@ use std::hash::Hash; use std::path::{Path, PathBuf}; use std::sync::atomic::Ordering; -use log::debug; use std::fs; use std::io; +use tracing::debug; #[cfg(test)] mod tests; @@ -75,7 +75,7 @@ pub mod monotonic { impl<T> !DerefMut for MonotonicVec<T> {} } -#[derive(Clone, RustcEncodable, RustcDecodable, Debug, Copy, HashStable_Generic)] +#[derive(Clone, Encodable, Decodable, Debug, Copy, HashStable_Generic)] pub struct Spanned<T> { pub node: T, pub span: Span, @@ -118,7 +118,7 @@ impl FileLoader for RealFileLoader { // This is a `SourceFile` identifier that is used to correlate `SourceFile`s between // subsequent compilation sessions (which is something we need to do during // incremental compilation). -#[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, Encodable, Decodable, Debug)] pub struct StableSourceFileId(u128); // FIXME: we need a more globally consistent approach to the problem solved by diff --git a/src/librustc_span/symbol.rs b/src/librustc_span/symbol.rs index caa6de09664..7843c04f255 100644 --- a/src/librustc_span/symbol.rs +++ b/src/librustc_span/symbol.rs @@ -5,9 +5,8 @@ use rustc_arena::DroplessArena; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey}; -use rustc_macros::{symbols, HashStable_Generic}; +use rustc_macros::HashStable_Generic; use rustc_serialize::{Decodable, Decoder, Encodable, Encoder}; -use rustc_serialize::{UseSpecializedDecodable, UseSpecializedEncodable}; use std::cmp::{Ord, PartialEq, PartialOrd}; use std::fmt; @@ -1192,7 +1191,7 @@ symbols! { } } -#[derive(Copy, Clone, Eq, HashStable_Generic)] +#[derive(Copy, Clone, Eq, HashStable_Generic, Encodable, Decodable)] pub struct Ident { pub name: Symbol, pub span: Span, @@ -1289,26 +1288,6 @@ impl fmt::Display for Ident { } } -impl UseSpecializedEncodable for Ident { - fn default_encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { - s.emit_struct("Ident", 2, |s| { - s.emit_struct_field("name", 0, |s| self.name.encode(s))?; - s.emit_struct_field("span", 1, |s| self.span.encode(s)) - }) - } -} - -impl UseSpecializedDecodable for Ident { - fn default_decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error> { - d.read_struct("Ident", 2, |d| { - Ok(Ident { - name: d.read_struct_field("name", 0, Decodable::decode)?, - span: d.read_struct_field("span", 1, Decodable::decode)?, - }) - }) - } -} - /// This is the most general way to print identifiers. /// AST pretty-printer is used as a fallback for turning AST structures into token streams for /// proc macros. Additionally, proc macros may stringify their input and expect it survive the @@ -1452,15 +1431,15 @@ impl fmt::Display for Symbol { } } -impl Encodable for Symbol { - fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> { +impl<S: Encoder> Encodable<S> for Symbol { + fn encode(&self, s: &mut S) -> Result<(), S::Error> { self.with(|string| s.emit_str(string)) } } -impl Decodable for Symbol { +impl<D: Decoder> Decodable<D> for Symbol { #[inline] - fn decode<D: Decoder>(d: &mut D) -> Result<Symbol, D::Error> { + fn decode(d: &mut D) -> Result<Symbol, D::Error> { Ok(Symbol::intern(&d.read_str()?)) } } @@ -1549,7 +1528,7 @@ pub mod sym { use super::Symbol; use std::convert::TryInto; - symbols!(); + define_symbols!(); // Used from a macro in `librustc_feature/accepted.rs` pub use super::kw::MacroRules as macro_rules; diff --git a/src/librustc_symbol_mangling/Cargo.toml b/src/librustc_symbol_mangling/Cargo.toml index 757d86bd95a..b44c0e4e027 100644 --- a/src/librustc_symbol_mangling/Cargo.toml +++ b/src/librustc_symbol_mangling/Cargo.toml @@ -10,7 +10,7 @@ path = "lib.rs" doctest = false [dependencies] -log = { package = "tracing", version = "0.1" } +tracing = "0.1" punycode = "0.4.0" rustc-demangle = "0.1.16" diff --git a/src/librustc_symbol_mangling/legacy.rs b/src/librustc_symbol_mangling/legacy.rs index 90c89ea6b0a..2ae13b501e9 100644 --- a/src/librustc_symbol_mangling/legacy.rs +++ b/src/librustc_symbol_mangling/legacy.rs @@ -8,7 +8,7 @@ use rustc_middle::ty::subst::{GenericArg, GenericArgKind}; use rustc_middle::ty::{self, Instance, Ty, TyCtxt, TypeFoldable}; use rustc_middle::util::common::record_time; -use log::debug; +use tracing::debug; use std::fmt::{self, Write}; use std::mem::{self, discriminant}; diff --git a/src/librustc_symbol_mangling/lib.rs b/src/librustc_symbol_mangling/lib.rs index 2579cf53d3d..296b40c4e39 100644 --- a/src/librustc_symbol_mangling/lib.rs +++ b/src/librustc_symbol_mangling/lib.rs @@ -106,7 +106,7 @@ use rustc_middle::ty::subst::SubstsRef; use rustc_middle::ty::{self, Instance, TyCtxt}; use rustc_session::config::SymbolManglingVersion; -use log::debug; +use tracing::debug; mod legacy; mod v0; @@ -173,7 +173,7 @@ fn compute_symbol_name( let disambiguator = tcx.sess.local_crate_disambiguator(); return tcx.sess.generate_proc_macro_decls_symbol(disambiguator); } - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); match tcx.hir().get(hir_id) { Node::ForeignItem(_) => true, _ => false, diff --git a/src/librustc_target/Cargo.toml b/src/librustc_target/Cargo.toml index 21796e84985..d2b50f44e43 100644 --- a/src/librustc_target/Cargo.toml +++ b/src/librustc_target/Cargo.toml @@ -10,7 +10,7 @@ path = "lib.rs" [dependencies] bitflags = "1.2.1" -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc_data_structures = { path = "../librustc_data_structures" } rustc_macros = { path = "../librustc_macros" } rustc_serialize = { path = "../librustc_serialize" } diff --git a/src/librustc_target/abi/mod.rs b/src/librustc_target/abi/mod.rs index b3e5f5c0c74..4b565dd246f 100644 --- a/src/librustc_target/abi/mod.rs +++ b/src/librustc_target/abi/mod.rs @@ -235,7 +235,7 @@ pub enum Endian { } /// Size of a type in bytes. -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Encodable, Decodable)] #[derive(HashStable_Generic)] pub struct Size { raw: u64, @@ -358,7 +358,7 @@ impl AddAssign for Size { } /// Alignment of a type in bytes (always a power of two). -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Encodable, Decodable)] #[derive(HashStable_Generic)] pub struct Align { pow2: u8, @@ -415,7 +415,7 @@ impl Align { } /// A pair of alignments, ABI-mandated and preferred. -#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Encodable, Decodable)] #[derive(HashStable_Generic)] pub struct AbiAndPrefAlign { pub abi: Align, diff --git a/src/librustc_target/asm/mod.rs b/src/librustc_target/asm/mod.rs index ccec17817d3..c22644bf813 100644 --- a/src/librustc_target/asm/mod.rs +++ b/src/librustc_target/asm/mod.rs @@ -13,7 +13,7 @@ macro_rules! def_reg_class { $class:ident, )* }) => { - #[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, Eq, PartialEq, Hash, HashStable_Generic)] + #[derive(Copy, Clone, Encodable, Decodable, Debug, Eq, PartialEq, Hash, HashStable_Generic)] #[allow(non_camel_case_types)] pub enum $arch_regclass { $($class,)* @@ -62,7 +62,7 @@ macro_rules! def_regs { )* }) => { #[allow(unreachable_code)] - #[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, Eq, PartialEq, Hash, HashStable_Generic)] + #[derive(Copy, Clone, Encodable, Decodable, Debug, Eq, PartialEq, Hash, HashStable_Generic)] #[allow(non_camel_case_types)] pub enum $arch_reg { $($reg,)* @@ -163,7 +163,7 @@ pub use nvptx::{NvptxInlineAsmReg, NvptxInlineAsmRegClass}; pub use riscv::{RiscVInlineAsmReg, RiscVInlineAsmRegClass}; pub use x86::{X86InlineAsmReg, X86InlineAsmRegClass}; -#[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, Eq, PartialEq, Hash)] +#[derive(Copy, Clone, Encodable, Decodable, Debug, Eq, PartialEq, Hash)] pub enum InlineAsmArch { X86, X86_64, @@ -193,17 +193,7 @@ impl FromStr for InlineAsmArch { } } -#[derive( - Copy, - Clone, - RustcEncodable, - RustcDecodable, - Debug, - Eq, - PartialEq, - Hash, - HashStable_Generic -)] +#[derive(Copy, Clone, Encodable, Decodable, Debug, Eq, PartialEq, Hash, HashStable_Generic)] pub enum InlineAsmReg { X86(X86InlineAsmReg), Arm(ArmInlineAsmReg), @@ -293,17 +283,7 @@ impl InlineAsmReg { } } -#[derive( - Copy, - Clone, - RustcEncodable, - RustcDecodable, - Debug, - Eq, - PartialEq, - Hash, - HashStable_Generic -)] +#[derive(Copy, Clone, Encodable, Decodable, Debug, Eq, PartialEq, Hash, HashStable_Generic)] pub enum InlineAsmRegClass { X86(X86InlineAsmRegClass), Arm(ArmInlineAsmRegClass), @@ -429,17 +409,7 @@ impl InlineAsmRegClass { } } -#[derive( - Copy, - Clone, - RustcEncodable, - RustcDecodable, - Debug, - Eq, - PartialEq, - Hash, - HashStable_Generic -)] +#[derive(Copy, Clone, Encodable, Decodable, Debug, Eq, PartialEq, Hash, HashStable_Generic)] pub enum InlineAsmRegOrRegClass { Reg(InlineAsmReg), RegClass(InlineAsmRegClass), diff --git a/src/librustc_target/lib.rs b/src/librustc_target/lib.rs index 1d0dc660ee6..5788e1e8385 100644 --- a/src/librustc_target/lib.rs +++ b/src/librustc_target/lib.rs @@ -16,12 +16,11 @@ #![feature(associated_type_bounds)] #![feature(exhaustive_patterns)] -// FIXME(#56935): Work around ICEs during cross-compilation. -#[allow(unused)] +#[macro_use] extern crate rustc_macros; #[macro_use] -extern crate log; +extern crate tracing; pub mod abi; pub mod asm; diff --git a/src/librustc_target/spec/abi.rs b/src/librustc_target/spec/abi.rs index a5c874bb4ac..1e45739ca22 100644 --- a/src/librustc_target/spec/abi.rs +++ b/src/librustc_target/spec/abi.rs @@ -5,8 +5,8 @@ use rustc_macros::HashStable_Generic; #[cfg(test)] mod tests; -#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, Clone, Copy, Debug)] -#[derive(HashStable_Generic)] +#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Debug)] +#[derive(HashStable_Generic, Encodable, Decodable)] pub enum Abi { // N.B., this ordering MUST match the AbiDatas array below. // (This is ensured by the test indices_are_correct().) diff --git a/src/librustc_target/spec/i686_pc_windows_gnu.rs b/src/librustc_target/spec/i686_pc_windows_gnu.rs index d12afe5a40b..33c9008bb14 100644 --- a/src/librustc_target/spec/i686_pc_windows_gnu.rs +++ b/src/librustc_target/spec/i686_pc_windows_gnu.rs @@ -1,8 +1,10 @@ -use crate::spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::windows_gnu_base::opts(); base.cpu = "pentium4".to_string(); + base.pre_link_args + .insert(LinkerFlavor::Lld(LldFlavor::Ld), vec!["-m".to_string(), "i386pe".to_string()]); base.max_atomic_width = Some(64); base.eliminate_frame_pointer = false; // Required for backtraces base.linker = Some("i686-w64-mingw32-gcc".to_string()); diff --git a/src/librustc_target/spec/i686_uwp_windows_gnu.rs b/src/librustc_target/spec/i686_uwp_windows_gnu.rs index 4e582fb8c63..1c6d2e061bc 100644 --- a/src/librustc_target/spec/i686_uwp_windows_gnu.rs +++ b/src/librustc_target/spec/i686_uwp_windows_gnu.rs @@ -1,8 +1,10 @@ -use crate::spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::windows_uwp_gnu_base::opts(); base.cpu = "pentium4".to_string(); + base.pre_link_args + .insert(LinkerFlavor::Lld(LldFlavor::Ld), vec!["-m".to_string(), "i386pe".to_string()]); base.max_atomic_width = Some(64); base.eliminate_frame_pointer = false; // Required for backtraces diff --git a/src/librustc_target/spec/mod.rs b/src/librustc_target/spec/mod.rs index 961a438fd23..fa29ff3f8d8 100644 --- a/src/librustc_target/spec/mod.rs +++ b/src/librustc_target/spec/mod.rs @@ -161,7 +161,7 @@ flavor_mappings! { ((LinkerFlavor::Lld(LldFlavor::Link)), "lld-link"), } -#[derive(Clone, Copy, Debug, PartialEq, Hash, RustcEncodable, RustcDecodable, HashStable_Generic)] +#[derive(Clone, Copy, Debug, PartialEq, Hash, Encodable, Decodable, HashStable_Generic)] pub enum PanicStrategy { Unwind, Abort, @@ -185,7 +185,7 @@ impl ToJson for PanicStrategy { } } -#[derive(Clone, Copy, Debug, PartialEq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, Debug, PartialEq, Hash, Encodable, Decodable)] pub enum RelroLevel { Full, Partial, @@ -229,7 +229,7 @@ impl ToJson for RelroLevel { } } -#[derive(Clone, Copy, Debug, PartialEq, Hash, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, Debug, PartialEq, Hash, Encodable, Decodable)] pub enum MergeFunctions { Disabled, Trampolines, @@ -1734,7 +1734,7 @@ impl ToJson for Target { } /// Either a target triple string or a path to a JSON file. -#[derive(PartialEq, Clone, Debug, Hash, RustcEncodable, RustcDecodable)] +#[derive(PartialEq, Clone, Debug, Hash, Encodable, Decodable)] pub enum TargetTriple { TargetTriple(String), TargetPath(PathBuf), diff --git a/src/librustc_target/spec/windows_gnu_base.rs b/src/librustc_target/spec/windows_gnu_base.rs index 69236e98e58..a864918655f 100644 --- a/src/librustc_target/spec/windows_gnu_base.rs +++ b/src/librustc_target/spec/windows_gnu_base.rs @@ -1,5 +1,5 @@ use crate::spec::crt_objects::{self, CrtObjectsFallback}; -use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions}; +use crate::spec::{LinkArgs, LinkerFlavor, LldFlavor, TargetOptions}; pub fn opts() -> TargetOptions { let mut pre_link_args = LinkArgs::new(); @@ -19,51 +19,48 @@ pub fn opts() -> TargetOptions { let mut late_link_args_static = LinkArgs::new(); // Order of `late_link_args*` was found through trial and error to work with various // mingw-w64 versions (not tested on the CI). It's expected to change from time to time. - late_link_args.insert( - LinkerFlavor::Gcc, - vec![ - "-lmsvcrt".to_string(), - "-lmingwex".to_string(), - "-lmingw32".to_string(), - // mingw's msvcrt is a weird hybrid import library and static library. - // And it seems that the linker fails to use import symbols from msvcrt - // that are required from functions in msvcrt in certain cases. For example - // `_fmode` that is used by an implementation of `__p__fmode` in x86_64. - // The library is purposely listed twice to fix that. - // - // See https://github.com/rust-lang/rust/pull/47483 for some more details. - "-lmsvcrt".to_string(), - "-luser32".to_string(), - "-lkernel32".to_string(), - ], - ); - late_link_args_dynamic.insert( - LinkerFlavor::Gcc, - vec![ - // If any of our crates are dynamically linked then we need to use - // the shared libgcc_s-dw2-1.dll. This is required to support - // unwinding across DLL boundaries. - "-lgcc_s".to_string(), - "-lgcc".to_string(), - "-lkernel32".to_string(), - ], - ); - late_link_args_static.insert( - LinkerFlavor::Gcc, - vec![ - // If all of our crates are statically linked then we can get away - // with statically linking the libgcc unwinding code. This allows - // binaries to be redistributed without the libgcc_s-dw2-1.dll - // dependency, but unfortunately break unwinding across DLL - // boundaries when unwinding across FFI boundaries. - "-lgcc_eh".to_string(), - "-l:libpthread.a".to_string(), - "-lgcc".to_string(), - // libpthread depends on libmsvcrt, so we need to link it *again*. - "-lmsvcrt".to_string(), - "-lkernel32".to_string(), - ], - ); + let mingw_libs = vec![ + "-lmsvcrt".to_string(), + "-lmingwex".to_string(), + "-lmingw32".to_string(), + // mingw's msvcrt is a weird hybrid import library and static library. + // And it seems that the linker fails to use import symbols from msvcrt + // that are required from functions in msvcrt in certain cases. For example + // `_fmode` that is used by an implementation of `__p__fmode` in x86_64. + // The library is purposely listed twice to fix that. + // + // See https://github.com/rust-lang/rust/pull/47483 for some more details. + "-lmsvcrt".to_string(), + "-luser32".to_string(), + "-lkernel32".to_string(), + ]; + late_link_args.insert(LinkerFlavor::Gcc, mingw_libs.clone()); + late_link_args.insert(LinkerFlavor::Lld(LldFlavor::Ld), mingw_libs); + let dynamic_unwind_libs = vec![ + // If any of our crates are dynamically linked then we need to use + // the shared libgcc_s-dw2-1.dll. This is required to support + // unwinding across DLL boundaries. + "-lgcc_s".to_string(), + "-lgcc".to_string(), + "-lkernel32".to_string(), + ]; + late_link_args_dynamic.insert(LinkerFlavor::Gcc, dynamic_unwind_libs.clone()); + late_link_args_dynamic.insert(LinkerFlavor::Lld(LldFlavor::Ld), dynamic_unwind_libs); + let static_unwind_libs = vec![ + // If all of our crates are statically linked then we can get away + // with statically linking the libgcc unwinding code. This allows + // binaries to be redistributed without the libgcc_s-dw2-1.dll + // dependency, but unfortunately break unwinding across DLL + // boundaries when unwinding across FFI boundaries. + "-lgcc_eh".to_string(), + "-l:libpthread.a".to_string(), + "-lgcc".to_string(), + // libpthread depends on libmsvcrt, so we need to link it *again*. + "-lmsvcrt".to_string(), + "-lkernel32".to_string(), + ]; + late_link_args_static.insert(LinkerFlavor::Gcc, static_unwind_libs.clone()); + late_link_args_static.insert(LinkerFlavor::Lld(LldFlavor::Ld), static_unwind_libs); TargetOptions { // FIXME(#13846) this should be enabled for windows diff --git a/src/librustc_target/spec/windows_uwp_gnu_base.rs b/src/librustc_target/spec/windows_uwp_gnu_base.rs index e12a37144da..fd55a0fc6a1 100644 --- a/src/librustc_target/spec/windows_uwp_gnu_base.rs +++ b/src/librustc_target/spec/windows_uwp_gnu_base.rs @@ -1,4 +1,4 @@ -use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions}; +use crate::spec::{LinkArgs, LinkerFlavor, LldFlavor, TargetOptions}; pub fn opts() -> TargetOptions { let base = super::windows_gnu_base::opts(); @@ -8,22 +8,21 @@ pub fn opts() -> TargetOptions { let mut late_link_args = LinkArgs::new(); let late_link_args_dynamic = LinkArgs::new(); let late_link_args_static = LinkArgs::new(); - late_link_args.insert( - LinkerFlavor::Gcc, - vec![ - //"-lwinstorecompat".to_string(), - //"-lmingwex".to_string(), - //"-lwinstorecompat".to_string(), - "-lwinstorecompat".to_string(), - "-lruntimeobject".to_string(), - "-lsynchronization".to_string(), - "-lvcruntime140_app".to_string(), - "-lucrt".to_string(), - "-lwindowsapp".to_string(), - "-lmingwex".to_string(), - "-lmingw32".to_string(), - ], - ); + let mingw_libs = vec![ + //"-lwinstorecompat".to_string(), + //"-lmingwex".to_string(), + //"-lwinstorecompat".to_string(), + "-lwinstorecompat".to_string(), + "-lruntimeobject".to_string(), + "-lsynchronization".to_string(), + "-lvcruntime140_app".to_string(), + "-lucrt".to_string(), + "-lwindowsapp".to_string(), + "-lmingwex".to_string(), + "-lmingw32".to_string(), + ]; + late_link_args.insert(LinkerFlavor::Gcc, mingw_libs.clone()); + late_link_args.insert(LinkerFlavor::Lld(LldFlavor::Ld), mingw_libs.clone()); TargetOptions { executables: false, diff --git a/src/librustc_target/spec/x86_64_pc_windows_gnu.rs b/src/librustc_target/spec/x86_64_pc_windows_gnu.rs index eb97fa56814..99af483f1d4 100644 --- a/src/librustc_target/spec/x86_64_pc_windows_gnu.rs +++ b/src/librustc_target/spec/x86_64_pc_windows_gnu.rs @@ -1,9 +1,11 @@ -use crate::spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::windows_gnu_base::opts(); base.cpu = "x86-64".to_string(); base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m64".to_string()); + base.pre_link_args + .insert(LinkerFlavor::Lld(LldFlavor::Ld), vec!["-m".to_string(), "i386pep".to_string()]); base.max_atomic_width = Some(64); base.linker = Some("x86_64-w64-mingw32-gcc".to_string()); diff --git a/src/librustc_target/spec/x86_64_uwp_windows_gnu.rs b/src/librustc_target/spec/x86_64_uwp_windows_gnu.rs index ad6002f6b89..3bd18f23f6f 100644 --- a/src/librustc_target/spec/x86_64_uwp_windows_gnu.rs +++ b/src/librustc_target/spec/x86_64_uwp_windows_gnu.rs @@ -1,9 +1,11 @@ -use crate::spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::windows_uwp_gnu_base::opts(); base.cpu = "x86-64".to_string(); base.pre_link_args.get_mut(&LinkerFlavor::Gcc).unwrap().push("-m64".to_string()); + base.pre_link_args + .insert(LinkerFlavor::Lld(LldFlavor::Ld), vec!["-m".to_string(), "i386pep".to_string()]); base.max_atomic_width = Some(64); Ok(Target { diff --git a/src/librustc_trait_selection/Cargo.toml b/src/librustc_trait_selection/Cargo.toml index c43fe3f2c0c..444023baa69 100644 --- a/src/librustc_trait_selection/Cargo.toml +++ b/src/librustc_trait_selection/Cargo.toml @@ -11,7 +11,7 @@ doctest = false [dependencies] rustc_parse_format = { path = "../librustc_parse_format" } -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc_attr = { path = "../librustc_attr" } rustc_middle = { path = "../librustc_middle" } rustc_ast = { path = "../librustc_ast" } diff --git a/src/librustc_trait_selection/lib.rs b/src/librustc_trait_selection/lib.rs index 4692fa04ed5..b5882df4729 100644 --- a/src/librustc_trait_selection/lib.rs +++ b/src/librustc_trait_selection/lib.rs @@ -24,7 +24,7 @@ extern crate rustc_macros; #[macro_use] extern crate rustc_data_structures; #[macro_use] -extern crate log; +extern crate tracing; #[macro_use] extern crate rustc_middle; diff --git a/src/librustc_trait_selection/opaque_types.rs b/src/librustc_trait_selection/opaque_types.rs index b84ad93341e..379c976df69 100644 --- a/src/librustc_trait_selection/opaque_types.rs +++ b/src/librustc_trait_selection/opaque_types.rs @@ -1039,7 +1039,7 @@ impl<'a, 'tcx> Instantiator<'a, 'tcx> { // } // ``` if let Some(def_id) = def_id.as_local() { - let opaque_hir_id = tcx.hir().as_local_hir_id(def_id); + let opaque_hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let parent_def_id = self.parent_def_id; let def_scope_default = || { let opaque_parent_hir_id = tcx.hir().get_parent_item(opaque_hir_id); @@ -1205,7 +1205,7 @@ pub fn may_define_opaque_type( def_id: LocalDefId, opaque_hir_id: hir::HirId, ) -> bool { - let mut hir_id = tcx.hir().as_local_hir_id(def_id); + let mut hir_id = tcx.hir().local_def_id_to_hir_id(def_id); // Named opaque types can be defined by any siblings or children of siblings. let scope = tcx.hir().get_defining_scope(opaque_hir_id); diff --git a/src/librustc_trait_selection/traits/chalk_fulfill.rs b/src/librustc_trait_selection/traits/chalk_fulfill.rs index a75240042ad..0097097707f 100644 --- a/src/librustc_trait_selection/traits/chalk_fulfill.rs +++ b/src/librustc_trait_selection/traits/chalk_fulfill.rs @@ -41,7 +41,7 @@ fn environment<'tcx>( let clauses = predicates.into_iter().map(ChalkEnvironmentClause::Predicate); - let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let node = tcx.hir().get(hir_id); enum NodeKind { diff --git a/src/librustc_trait_selection/traits/error_reporting/mod.rs b/src/librustc_trait_selection/traits/error_reporting/mod.rs index 349fa68a4da..e597843e6ce 100644 --- a/src/librustc_trait_selection/traits/error_reporting/mod.rs +++ b/src/librustc_trait_selection/traits/error_reporting/mod.rs @@ -568,7 +568,8 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { self.tcx.sess.source_map().guess_head_span( self.tcx.hir().span_if_local(closure_def_id).unwrap(), ); - let hir_id = self.tcx.hir().as_local_hir_id(closure_def_id.expect_local()); + let hir_id = + self.tcx.hir().local_def_id_to_hir_id(closure_def_id.expect_local()); let mut err = struct_span_err!( self.tcx.sess, closure_span, diff --git a/src/librustc_trait_selection/traits/error_reporting/suggestions.rs b/src/librustc_trait_selection/traits/error_reporting/suggestions.rs index e29e740f136..7513ff6b37e 100644 --- a/src/librustc_trait_selection/traits/error_reporting/suggestions.rs +++ b/src/librustc_trait_selection/traits/error_reporting/suggestions.rs @@ -535,7 +535,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { }; let hir = self.tcx.hir(); - let hir_id = hir.as_local_hir_id(def_id.as_local()?); + let hir_id = hir.local_def_id_to_hir_id(def_id.as_local()?); let parent_node = hir.get_parent_node(hir_id); match hir.find(parent_node) { Some(hir::Node::Stmt(hir::Stmt { kind: hir::StmtKind::Local(local), .. })) => { @@ -1383,7 +1383,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { let generator_body = generator_did .as_local() - .map(|def_id| hir.as_local_hir_id(def_id)) + .map(|def_id| hir.local_def_id_to_hir_id(def_id)) .and_then(|hir_id| hir.maybe_body_owned_by(hir_id)) .map(|body_id| hir.body(body_id)); let mut visitor = AwaitsVisitor::default(); @@ -1535,7 +1535,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { .tcx .parent(generator_did) .and_then(|parent_did| parent_did.as_local()) - .map(|parent_did| hir.as_local_hir_id(parent_did)) + .map(|parent_did| hir.local_def_id_to_hir_id(parent_did)) .and_then(|parent_hir_id| hir.opt_name(parent_hir_id)) .map(|name| { format!("future returned by `{}` is not {}", name, trait_name) diff --git a/src/librustc_trait_selection/traits/project.rs b/src/librustc_trait_selection/traits/project.rs index 717b7e2fe57..316181ce7d4 100644 --- a/src/librustc_trait_selection/traits/project.rs +++ b/src/librustc_trait_selection/traits/project.rs @@ -324,8 +324,7 @@ impl<'a, 'b, 'tcx> TypeFolder<'tcx> for AssocTypeNormalizer<'a, 'b, 'tcx> { let ty = ty.super_fold_with(self); match ty.kind { - ty::Opaque(def_id, substs) if !substs.has_escaping_bound_vars() => { - // (*) + ty::Opaque(def_id, substs) => { // Only normalize `impl Trait` after type-checking, usually in codegen. match self.param_env.reveal() { Reveal::UserFacing => ty, @@ -353,9 +352,7 @@ impl<'a, 'b, 'tcx> TypeFolder<'tcx> for AssocTypeNormalizer<'a, 'b, 'tcx> { } ty::Projection(ref data) if !data.has_escaping_bound_vars() => { - // (*) - - // (*) This is kind of hacky -- we need to be able to + // This is kind of hacky -- we need to be able to // handle normalization within binders because // otherwise we wind up a need to normalize when doing // trait matching (since you can have a trait diff --git a/src/librustc_trait_selection/traits/query/normalize.rs b/src/librustc_trait_selection/traits/query/normalize.rs index 59fa4c1598d..93652329305 100644 --- a/src/librustc_trait_selection/traits/query/normalize.rs +++ b/src/librustc_trait_selection/traits/query/normalize.rs @@ -101,8 +101,7 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> { let ty = ty.super_fold_with(self); match ty.kind { - ty::Opaque(def_id, substs) if !substs.has_escaping_bound_vars() => { - // (*) + ty::Opaque(def_id, substs) => { // Only normalize `impl Trait` after type-checking, usually in codegen. match self.param_env.reveal() { Reveal::UserFacing => ty, @@ -140,8 +139,7 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> { } ty::Projection(ref data) if !data.has_escaping_bound_vars() => { - // (*) - // (*) This is kind of hacky -- we need to be able to + // This is kind of hacky -- we need to be able to // handle normalization within binders because // otherwise we wind up a need to normalize when doing // trait matching (since you can have a trait diff --git a/src/librustc_trait_selection/traits/specialize/mod.rs b/src/librustc_trait_selection/traits/specialize/mod.rs index 9b737d46417..4d81a3baa0e 100644 --- a/src/librustc_trait_selection/traits/specialize/mod.rs +++ b/src/librustc_trait_selection/traits/specialize/mod.rs @@ -451,7 +451,7 @@ fn report_conflicting_impls( }; tcx.struct_span_lint_hir( lint, - tcx.hir().as_local_hir_id(impl_def_id), + tcx.hir().local_def_id_to_hir_id(impl_def_id), impl_span, decorate, ) diff --git a/src/librustc_traits/Cargo.toml b/src/librustc_traits/Cargo.toml index f8487982e3d..f5545f56293 100644 --- a/src/librustc_traits/Cargo.toml +++ b/src/librustc_traits/Cargo.toml @@ -9,7 +9,7 @@ name = "rustc_traits" path = "lib.rs" [dependencies] -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc_middle = { path = "../librustc_middle" } rustc_data_structures = { path = "../librustc_data_structures" } rustc_hir = { path = "../librustc_hir" } diff --git a/src/librustc_traits/lib.rs b/src/librustc_traits/lib.rs index b8e23760ba5..6fea4732dda 100644 --- a/src/librustc_traits/lib.rs +++ b/src/librustc_traits/lib.rs @@ -8,7 +8,7 @@ #![recursion_limit = "256"] #[macro_use] -extern crate log; +extern crate tracing; #[macro_use] extern crate rustc_middle; diff --git a/src/librustc_ty/Cargo.toml b/src/librustc_ty/Cargo.toml index 6cdb3530002..adc9740c2c1 100644 --- a/src/librustc_ty/Cargo.toml +++ b/src/librustc_ty/Cargo.toml @@ -9,7 +9,7 @@ name = "rustc_ty" path = "lib.rs" [dependencies] -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc_middle = { path = "../librustc_middle" } rustc_data_structures = { path = "../librustc_data_structures" } rustc_errors = { path = "../librustc_errors" } diff --git a/src/librustc_ty/instance.rs b/src/librustc_ty/instance.rs index 1e0c4055af3..d0bd88af1ff 100644 --- a/src/librustc_ty/instance.rs +++ b/src/librustc_ty/instance.rs @@ -8,7 +8,7 @@ use rustc_target::spec::abi::Abi; use rustc_trait_selection::traits; use traits::{translate_substs, Reveal}; -use log::debug; +use tracing::debug; fn resolve_instance<'tcx>( tcx: TyCtxt<'tcx>, diff --git a/src/librustc_ty/lib.rs b/src/librustc_ty/lib.rs index 8f3b20c7aaf..6e9042d1ba7 100644 --- a/src/librustc_ty/lib.rs +++ b/src/librustc_ty/lib.rs @@ -12,7 +12,7 @@ #[macro_use] extern crate rustc_middle; #[macro_use] -extern crate log; +extern crate tracing; use rustc_middle::ty::query::Providers; diff --git a/src/librustc_ty/ty.rs b/src/librustc_ty/ty.rs index b31f9f3c7b1..0f1dee7e2e0 100644 --- a/src/librustc_ty/ty.rs +++ b/src/librustc_ty/ty.rs @@ -126,7 +126,7 @@ fn associated_item_from_impl_item_ref( } fn associated_item(tcx: TyCtxt<'_>, def_id: DefId) -> ty::AssocItem { - let id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let parent_id = tcx.hir().get_parent_item(id); let parent_def_id = tcx.hir().local_def_id(parent_id); let parent_item = tcx.hir().expect_item(parent_id); @@ -164,7 +164,7 @@ fn associated_item(tcx: TyCtxt<'_>, def_id: DefId) -> ty::AssocItem { } fn impl_defaultness(tcx: TyCtxt<'_>, def_id: DefId) -> hir::Defaultness { - let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let item = tcx.hir().expect_item(hir_id); if let hir::ItemKind::Impl { defaultness, .. } = item.kind { defaultness @@ -198,7 +198,7 @@ fn adt_sized_constraint(tcx: TyCtxt<'_>, def_id: DefId) -> ty::AdtSizedConstrain } fn associated_item_def_ids(tcx: TyCtxt<'_>, def_id: DefId) -> &[DefId] { - let id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let item = tcx.hir().expect_item(id); match item.kind { hir::ItemKind::Trait(.., ref trait_item_refs) => tcx.arena.alloc_from_iter( @@ -268,7 +268,7 @@ fn param_env(tcx: TyCtxt<'_>, def_id: DefId) -> ty::ParamEnv<'_> { let body_id = def_id .as_local() - .map(|def_id| tcx.hir().as_local_hir_id(def_id)) + .map(|def_id| tcx.hir().local_def_id_to_hir_id(def_id)) .map_or(hir::CRATE_HIR_ID, |id| { tcx.hir().maybe_body_owned_by(id).map_or(id, |body| body.hir_id) }); @@ -360,7 +360,7 @@ fn issue33140_self_ty(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Ty<'_>> { /// Check if a function is async. fn asyncness(tcx: TyCtxt<'_>, def_id: DefId) -> hir::IsAsync { - let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let node = tcx.hir().get(hir_id); diff --git a/src/librustc_typeck/Cargo.toml b/src/librustc_typeck/Cargo.toml index 963deda162d..82c6ac7a0cd 100644 --- a/src/librustc_typeck/Cargo.toml +++ b/src/librustc_typeck/Cargo.toml @@ -12,7 +12,7 @@ doctest = false [dependencies] rustc_arena = { path = "../librustc_arena" } -log = { package = "tracing", version = "0.1" } +tracing = "0.1" rustc_middle = { path = "../librustc_middle" } rustc_attr = { path = "../librustc_attr" } rustc_data_structures = { path = "../librustc_data_structures" } diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 342f8b61069..5170a060c5f 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -170,7 +170,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { def: Option<&ty::GenericParamDef>, ) -> ty::Region<'tcx> { let tcx = self.tcx(); - let lifetime_name = |def_id| tcx.hir().name(tcx.hir().as_local_hir_id(def_id)); + let lifetime_name = |def_id| tcx.hir().name(tcx.hir().local_def_id_to_hir_id(def_id)); let r = match tcx.named_region(lifetime.hir_id) { Some(rl::Region::Static) => tcx.lifetimes.re_static, @@ -1623,6 +1623,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { span: Span, trait_bounds: &[hir::PolyTraitRef<'_>], lifetime: &hir::Lifetime, + borrowed: bool, ) -> Ty<'tcx> { let tcx = self.tcx(); @@ -1851,15 +1852,20 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { self.ast_region_to_region(lifetime, None) } else { self.re_infer(None, span).unwrap_or_else(|| { - // FIXME: these can be redundant with E0106, but not always. - struct_span_err!( + let mut err = struct_span_err!( tcx.sess, span, E0228, "the lifetime bound for this object type cannot be deduced \ from context; please supply an explicit bound" - ) - .emit(); + ); + if borrowed { + // We will have already emitted an error E0106 complaining about a + // missing named lifetime in `&dyn Trait`, so we elide this one. + err.delay_as_bug(); + } else { + err.emit(); + } tcx.lifetimes.re_static }) } @@ -2113,7 +2119,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { debug!("find_bound_for_assoc_item: predicates={:#?}", predicates); - let param_hir_id = tcx.hir().as_local_hir_id(ty_param_def_id); + let param_hir_id = tcx.hir().local_def_id_to_hir_id(ty_param_def_id); let param_name = tcx.hir().ty_param_name(param_hir_id); self.one_bound_for_assoc_type( || { @@ -2497,7 +2503,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { let parent_def_id = def_id .and_then(|def_id| { - def_id.as_local().map(|def_id| tcx.hir().as_local_hir_id(def_id)) + def_id.as_local().map(|def_id| tcx.hir().local_def_id_to_hir_id(def_id)) }) .map(|hir_id| tcx.hir().get_parent_did(hir_id).to_def_id()); @@ -2833,7 +2839,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { assert_eq!(opt_self_ty, None); self.prohibit_generics(path.segments); - let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let item_id = tcx.hir().get_parent_node(hir_id); let item_def_id = tcx.hir().local_def_id(item_id); let generics = tcx.generics_of(item_def_id); @@ -2887,6 +2893,12 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { /// Parses the programmer's textual representation of a type into our /// internal notion of a type. pub fn ast_ty_to_ty(&self, ast_ty: &hir::Ty<'_>) -> Ty<'tcx> { + self.ast_ty_to_ty_inner(ast_ty, false) + } + + /// Turns a `hir::Ty` into a `Ty`. For diagnostics' purposes we keep track of whether trait + /// objects are borrowed like `&dyn Trait` to avoid emitting redundant errors. + fn ast_ty_to_ty_inner(&self, ast_ty: &hir::Ty<'_>, borrowed: bool) -> Ty<'tcx> { debug!("ast_ty_to_ty(id={:?}, ast_ty={:?} ty_ty={:?})", ast_ty.hir_id, ast_ty, ast_ty.kind); let tcx = self.tcx(); @@ -2899,7 +2911,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { hir::TyKind::Rptr(ref region, ref mt) => { let r = self.ast_region_to_region(region, None); debug!("ast_ty_to_ty: r={:?}", r); - let t = self.ast_ty_to_ty(&mt.ty); + let t = self.ast_ty_to_ty_inner(&mt.ty, true); tcx.mk_ref(r, ty::TypeAndMut { ty: t, mutbl: mt.mutbl }) } hir::TyKind::Never => tcx.types.never, @@ -2917,7 +2929,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { )) } hir::TyKind::TraitObject(ref bounds, ref lifetime) => { - self.conv_object_ty_poly_trait_ref(ast_ty.span, bounds, lifetime) + self.conv_object_ty_poly_trait_ref(ast_ty.span, bounds, lifetime, borrowed) } hir::TyKind::Path(hir::QPath::Resolved(ref maybe_qself, ref path)) => { debug!("ast_ty_to_ty: maybe_qself={:?} path={:?}", maybe_qself, path); diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs index db8cdfc5b20..f0802c45ae0 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -1502,7 +1502,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> { let ty = AstConv::ast_ty_to_ty(fcx, ty); // Get the `impl Trait`'s `DefId`. if let ty::Opaque(def_id, _) = ty.kind { - let hir_id = fcx.tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = fcx.tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); // Get the `impl Trait`'s `Item` so that we can get its trait bounds and // get the `Trait`'s `DefId`. if let hir::ItemKind::OpaqueTy(hir::OpaqueTy { bounds, .. }) = diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs index b739e2fe1fb..7adcd7b472e 100644 --- a/src/librustc_typeck/check/compare_method.rs +++ b/src/librustc_typeck/check/compare_method.rs @@ -77,7 +77,7 @@ fn compare_predicate_entailment<'tcx>( // This node-id should be used for the `body_id` field on each // `ObligationCause` (and the `FnCtxt`). This is what // `regionck_item` expects. - let impl_m_hir_id = tcx.hir().as_local_hir_id(impl_m.def_id.expect_local()); + let impl_m_hir_id = tcx.hir().local_def_id_to_hir_id(impl_m.def_id.expect_local()); // We sometimes modify the span further down. let mut cause = ObligationCause::new( @@ -401,7 +401,7 @@ fn extract_spans_for_error_reporting<'a, 'tcx>( trait_sig: ty::FnSig<'tcx>, ) -> (Span, Option<Span>) { let tcx = infcx.tcx; - let impl_m_hir_id = tcx.hir().as_local_hir_id(impl_m.def_id.expect_local()); + let impl_m_hir_id = tcx.hir().local_def_id_to_hir_id(impl_m.def_id.expect_local()); let (impl_m_output, impl_m_iter) = match tcx.hir().expect_impl_item(impl_m_hir_id).kind { ImplItemKind::Fn(ref impl_m_sig, _) => { (&impl_m_sig.decl.output, impl_m_sig.decl.inputs.iter()) @@ -412,7 +412,7 @@ fn extract_spans_for_error_reporting<'a, 'tcx>( match *terr { TypeError::Mutability => { if let Some(def_id) = trait_m.def_id.as_local() { - let trait_m_hir_id = tcx.hir().as_local_hir_id(def_id); + let trait_m_hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let trait_m_iter = match tcx.hir().expect_trait_item(trait_m_hir_id).kind { TraitItemKind::Fn(ref trait_m_sig, _) => trait_m_sig.decl.inputs.iter(), _ => bug!("{:?} is not a TraitItemKind::Fn", trait_m), @@ -440,7 +440,7 @@ fn extract_spans_for_error_reporting<'a, 'tcx>( } TypeError::Sorts(ExpectedFound { .. }) => { if let Some(def_id) = trait_m.def_id.as_local() { - let trait_m_hir_id = tcx.hir().as_local_hir_id(def_id); + let trait_m_hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let (trait_m_output, trait_m_iter) = match tcx.hir().expect_trait_item(trait_m_hir_id).kind { TraitItemKind::Fn(ref trait_m_sig, _) => { @@ -589,7 +589,7 @@ fn compare_number_of_generics<'tcx>( err_occurred = true; let (trait_spans, impl_trait_spans) = if let Some(def_id) = trait_.def_id.as_local() { - let trait_hir_id = tcx.hir().as_local_hir_id(def_id); + let trait_hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let trait_item = tcx.hir().expect_trait_item(trait_hir_id); if trait_item.generics.params.is_empty() { (Some(vec![trait_item.generics.span]), vec![]) @@ -614,7 +614,7 @@ fn compare_number_of_generics<'tcx>( (trait_span.map(|s| vec![s]), vec![]) }; - let impl_hir_id = tcx.hir().as_local_hir_id(impl_.def_id.expect_local()); + let impl_hir_id = tcx.hir().local_def_id_to_hir_id(impl_.def_id.expect_local()); let impl_item = tcx.hir().expect_impl_item(impl_hir_id); let impl_item_impl_trait_spans: Vec<Span> = impl_item .generics @@ -706,7 +706,7 @@ fn compare_number_of_method_arguments<'tcx>( let impl_number_args = impl_m_fty.inputs().skip_binder().len(); if trait_number_args != impl_number_args { let trait_span = if let Some(def_id) = trait_m.def_id.as_local() { - let trait_id = tcx.hir().as_local_hir_id(def_id); + let trait_id = tcx.hir().local_def_id_to_hir_id(def_id); match tcx.hir().expect_trait_item(trait_id).kind { TraitItemKind::Fn(ref trait_m_sig, _) => { let pos = if trait_number_args > 0 { trait_number_args - 1 } else { 0 }; @@ -729,7 +729,7 @@ fn compare_number_of_method_arguments<'tcx>( } else { trait_item_span }; - let impl_m_hir_id = tcx.hir().as_local_hir_id(impl_m.def_id.expect_local()); + let impl_m_hir_id = tcx.hir().local_def_id_to_hir_id(impl_m.def_id.expect_local()); let impl_span = match tcx.hir().expect_impl_item(impl_m_hir_id).kind { ImplItemKind::Fn(ref impl_m_sig, _) => { let pos = if impl_number_args > 0 { impl_number_args - 1 } else { 0 }; @@ -811,7 +811,7 @@ fn compare_synthetic_generics<'tcx>( impl_m_type_params.zip(trait_m_type_params) { if impl_synthetic != trait_synthetic { - let impl_hir_id = tcx.hir().as_local_hir_id(impl_def_id.expect_local()); + let impl_hir_id = tcx.hir().local_def_id_to_hir_id(impl_def_id.expect_local()); let impl_span = tcx.hir().span(impl_hir_id); let trait_span = tcx.def_span(trait_def_id); let mut err = struct_span_err!( @@ -832,10 +832,10 @@ fn compare_synthetic_generics<'tcx>( // FIXME: this is obviously suboptimal since the name can already be used // as another generic argument let new_name = tcx.sess.source_map().span_to_snippet(trait_span).ok()?; - let trait_m = tcx.hir().as_local_hir_id(trait_m.def_id.as_local()?); + let trait_m = tcx.hir().local_def_id_to_hir_id(trait_m.def_id.as_local()?); let trait_m = tcx.hir().trait_item(hir::TraitItemId { hir_id: trait_m }); - let impl_m = tcx.hir().as_local_hir_id(impl_m.def_id.as_local()?); + let impl_m = tcx.hir().local_def_id_to_hir_id(impl_m.def_id.as_local()?); let impl_m = tcx.hir().impl_item(hir::ImplItemId { hir_id: impl_m }); // in case there are no generics, take the spot between the function name @@ -869,7 +869,7 @@ fn compare_synthetic_generics<'tcx>( (None, Some(hir::SyntheticTyParamKind::ImplTrait)) => { err.span_label(impl_span, "expected `impl Trait`, found generic parameter"); (|| { - let impl_m = tcx.hir().as_local_hir_id(impl_m.def_id.as_local()?); + let impl_m = tcx.hir().local_def_id_to_hir_id(impl_m.def_id.as_local()?); let impl_m = tcx.hir().impl_item(hir::ImplItemId { hir_id: impl_m }); let input_tys = match impl_m.kind { hir::ImplItemKind::Fn(ref sig, _) => sig.decl.inputs, @@ -962,7 +962,7 @@ crate fn compare_const_impl<'tcx>( // Create a parameter environment that represents the implementation's // method. - let impl_c_hir_id = tcx.hir().as_local_hir_id(impl_c.def_id.expect_local()); + let impl_c_hir_id = tcx.hir().local_def_id_to_hir_id(impl_c.def_id.expect_local()); // Compute placeholder form of impl and trait const tys. let impl_ty = tcx.type_of(impl_c.def_id); @@ -1011,7 +1011,7 @@ crate fn compare_const_impl<'tcx>( ); let trait_c_hir_id = - trait_c.def_id.as_local().map(|def_id| tcx.hir().as_local_hir_id(def_id)); + trait_c.def_id.as_local().map(|def_id| tcx.hir().local_def_id_to_hir_id(def_id)); let trait_c_span = trait_c_hir_id.map(|trait_c_hir_id| { // Add a label to the Span containing just the type of the const match tcx.hir().expect_trait_item(trait_c_hir_id).kind { @@ -1101,7 +1101,7 @@ fn compare_type_predicate_entailment<'tcx>( // This `HirId` should be used for the `body_id` field on each // `ObligationCause` (and the `FnCtxt`). This is what // `regionck_item` expects. - let impl_ty_hir_id = tcx.hir().as_local_hir_id(impl_ty.def_id.expect_local()); + let impl_ty_hir_id = tcx.hir().local_def_id_to_hir_id(impl_ty.def_id.expect_local()); let cause = ObligationCause::new( impl_ty_span, impl_ty_hir_id, @@ -1240,7 +1240,7 @@ fn compare_projection_bounds<'tcx>( let infcx = &inh.infcx; let mut selcx = traits::SelectionContext::new(&infcx); - let impl_ty_hir_id = tcx.hir().as_local_hir_id(impl_ty.def_id.expect_local()); + let impl_ty_hir_id = tcx.hir().local_def_id_to_hir_id(impl_ty.def_id.expect_local()); let normalize_cause = traits::ObligationCause::misc(impl_ty_span, impl_ty_hir_id); let cause = ObligationCause::new( impl_ty_span, diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs index 258c5b77df2..4ea76a4a9e2 100644 --- a/src/librustc_typeck/check/demand.rs +++ b/src/librustc_typeck/check/demand.rs @@ -34,6 +34,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } self.suggest_boxing_when_appropriate(err, expr, expected, expr_ty); self.suggest_missing_await(err, expr, expected, expr_ty); + self.suggest_missing_parentheses(err, expr); self.note_need_for_fn_pointer(err, expected, expr_ty); } diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs index 9ef91641916..434886538fb 100644 --- a/src/librustc_typeck/check/dropck.rs +++ b/src/librustc_typeck/check/dropck.rs @@ -70,7 +70,7 @@ fn ensure_drop_params_and_item_params_correspond<'tcx>( drop_impl_ty: Ty<'tcx>, self_type_did: DefId, ) -> Result<(), ErrorReported> { - let drop_impl_hir_id = tcx.hir().as_local_hir_id(drop_impl_did); + let drop_impl_hir_id = tcx.hir().local_def_id_to_hir_id(drop_impl_did); // check that the impl type can be made to match the trait type. @@ -183,7 +183,7 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>( // absent. So we report an error that the Drop impl injected a // predicate that is not present on the struct definition. - let self_type_hir_id = tcx.hir().as_local_hir_id(self_type_did); + let self_type_hir_id = tcx.hir().local_def_id_to_hir_id(self_type_did); // We can assume the predicates attached to struct/enum definition // hold. diff --git a/src/librustc_typeck/check/expr.rs b/src/librustc_typeck/check/expr.rs index e7eaca62bdd..e88f13a1f3a 100644 --- a/src/librustc_typeck/check/expr.rs +++ b/src/librustc_typeck/check/expr.rs @@ -1606,7 +1606,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } let param_def_id = generic_param.def_id; let param_hir_id = match param_def_id.as_local() { - Some(x) => self.tcx.hir().as_local_hir_id(x), + Some(x) => self.tcx.hir().local_def_id_to_hir_id(x), None => return, }; let param_span = self.tcx.hir().span(param_hir_id); diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 106df847a05..9078dc40041 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -649,6 +649,10 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> { self.assemble_inherent_impl_for_primitive(lang_def_id); } } + ty::Array(_, _) => { + let lang_def_id = lang_items.array_impl(); + self.assemble_inherent_impl_for_primitive(lang_def_id); + } ty::RawPtr(ty::TypeAndMut { ty: _, mutbl }) => { let (lang_def_id1, lang_def_id2) = match mutbl { hir::Mutability::Not => { diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index e69102d1995..e941c844a6d 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -579,7 +579,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { { if let ty::Adt(def, _) = p.trait_ref.self_ty().kind { let node = def.did.as_local().map(|def_id| { - self.tcx.hir().get(self.tcx.hir().as_local_hir_id(def_id)) + self.tcx + .hir() + .get(self.tcx.hir().local_def_id_to_hir_id(def_id)) }); if let Some(hir::Node::Item(hir::Item { kind, .. })) = node { if let Some(g) = kind.generics() { @@ -859,7 +861,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { candidates: Vec<DefId>, ) { let module_did = self.tcx.parent_module(self.body_id); - let module_id = self.tcx.hir().as_local_hir_id(module_did); + let module_id = self.tcx.hir().local_def_id_to_hir_id(module_did); let krate = self.tcx.hir().krate(); let (span, found_use) = UsePlacementFinder::check(self.tcx, krate, module_id); if let Some(span) = span { @@ -975,7 +977,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let id = item .def_id .as_local() - .map(|def_id| self.tcx.hir().as_local_hir_id(def_id)); + .map(|def_id| self.tcx.hir().local_def_id_to_hir_id(def_id)); if let Some(hir::Node::TraitItem(hir::TraitItem { kind: hir::TraitItemKind::Fn(fn_sig, method), .. @@ -1062,7 +1064,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { let type_param = generics.type_param(param, self.tcx); let hir = &self.tcx.hir(); if let Some(def_id) = type_param.def_id.as_local() { - let id = hir.as_local_hir_id(def_id); + let id = hir.local_def_id_to_hir_id(def_id); // Get the `hir::Param` to verify whether it already has any bounds. // We do this to avoid suggesting code that ends up as `T: FooBar`, // instead we suggest `T: Foo + Bar` in that case. diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index a40b6860f77..a625b5ea405 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -974,7 +974,7 @@ fn typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &ty::TypeckResults<'tc /// Currently only used for type inference of `static`s and `const`s to avoid type cycle errors. fn diagnostic_only_typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &ty::TypeckResults<'tcx> { let fallback = move || { - let span = tcx.hir().span(tcx.hir().as_local_hir_id(def_id)); + let span = tcx.hir().span(tcx.hir().local_def_id_to_hir_id(def_id)); tcx.ty_error_with_message(span, "diagnostic only typeck table used") }; typeck_with_fallback(tcx, def_id, fallback) @@ -992,7 +992,7 @@ fn typeck_with_fallback<'tcx>( return tcx.typeck(outer_def_id); } - let id = tcx.hir().as_local_hir_id(def_id); + let id = tcx.hir().local_def_id_to_hir_id(def_id); let span = tcx.hir().span(id); // Figure out what primary body this item has. @@ -1333,7 +1333,7 @@ fn check_fn<'a, 'tcx>( } let outer_def_id = tcx.closure_base_def_id(hir.local_def_id(fn_id).to_def_id()).expect_local(); - let outer_hir_id = hir.as_local_hir_id(outer_def_id); + let outer_hir_id = hir.local_def_id_to_hir_id(outer_def_id); GatherLocalsVisitor { fcx: &fcx, parent_id: outer_hir_id }.visit_body(body); // C-variadic fns also have a `VaList` input that's not listed in `fn_sig` @@ -1444,7 +1444,7 @@ fn check_fn<'a, 'tcx>( // Check that the main return type implements the termination trait. if let Some(term_id) = tcx.lang_items().termination() { if let Some((def_id, EntryFnType::Main)) = tcx.entry_fn(LOCAL_CRATE) { - let main_id = hir.as_local_hir_id(def_id); + let main_id = hir.local_def_id_to_hir_id(def_id); if main_id == fn_id { let substs = tcx.mk_substs_trait(declared_ret_ty, &[]); let trait_ref = ty::TraitRef::new(term_id, substs); @@ -1622,7 +1622,7 @@ fn check_opaque<'tcx>( /// Checks that an opaque type does not use `Self` or `T::Foo` projections that would result /// in "inheriting lifetimes". fn check_opaque_for_inheriting_lifetimes(tcx: TyCtxt<'tcx>, def_id: LocalDefId, span: Span) { - let item = tcx.hir().expect_item(tcx.hir().as_local_hir_id(def_id)); + let item = tcx.hir().expect_item(tcx.hir().local_def_id_to_hir_id(def_id)); debug!( "check_opaque_for_inheriting_lifetimes: def_id={:?} span={:?} item={:?}", def_id, span, item @@ -1729,7 +1729,7 @@ fn get_owner_return_paths( tcx: TyCtxt<'tcx>, def_id: LocalDefId, ) -> Option<(hir::HirId, ReturnsVisitor<'tcx>)> { - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let id = tcx.hir().get_parent_item(hir_id); tcx.hir() .find(id) @@ -1833,7 +1833,7 @@ fn binding_opaque_type_cycle_error( let mut err = struct_span_err!(tcx.sess, span, E0720, "cannot resolve opaque type"); err.span_label(span, "cannot resolve opaque type"); // Find the the owner that declared this `impl Trait` type. - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let mut prev_hir_id = hir_id; let mut hir_id = tcx.hir().get_parent_node(hir_id); while let Some(node) = tcx.hir().find(hir_id) { @@ -1858,7 +1858,7 @@ fn binding_opaque_type_cycle_error( source: hir::LocalSource::Normal, .. }) => { - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let typeck_results = tcx.typeck(tcx.hir().local_def_id(tcx.hir().get_parent_item(hir_id))); if let Some(ty) = typeck_results.node_type_opt(expr.hir_id) { @@ -2874,7 +2874,7 @@ pub fn check_enum<'tcx>( // Check for duplicate discriminant values if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) { let variant_did = def.variants[VariantIdx::new(i)].def_id; - let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did.expect_local()); + let variant_i_hir_id = tcx.hir().local_def_id_to_hir_id(variant_did.expect_local()); let variant_i = tcx.hir().expect_variant(variant_i_hir_id); let i_span = match variant_i.disr_expr { Some(ref expr) => tcx.hir().span(expr.hir_id), @@ -2935,7 +2935,7 @@ impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> { fn get_type_parameter_bounds(&self, _: Span, def_id: DefId) -> ty::GenericPredicates<'tcx> { let tcx = self.tcx; - let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let item_id = tcx.hir().ty_param_owner(hir_id); let item_def_id = tcx.hir().local_def_id(item_id); let generics = tcx.generics_of(item_def_id); @@ -5401,6 +5401,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } } + fn suggest_missing_parentheses(&self, err: &mut DiagnosticBuilder<'_>, expr: &hir::Expr<'_>) { + let sp = self.tcx.sess.source_map().start_point(expr.span); + if let Some(sp) = self.tcx.sess.parse_sess.ambiguous_block_expr_parse.borrow().get(&sp) { + // `{ 42 } &&x` (#61475) or `{ 42 } && if x { 1 } else { 0 }` + self.tcx.sess.parse_sess.expr_parentheses_needed(err, *sp, None); + } + } + fn note_need_for_fn_pointer( &self, err: &mut DiagnosticBuilder<'_>, diff --git a/src/librustc_typeck/check/op.rs b/src/librustc_typeck/check/op.rs index fd516c88ec6..66fb01a54f5 100644 --- a/src/librustc_typeck/check/op.rs +++ b/src/librustc_typeck/check/op.rs @@ -933,7 +933,7 @@ fn suggest_constraining_param( let param_def_id = generics.type_param(&p, tcx).def_id; if let Some(generics) = param_def_id .as_local() - .map(|id| hir.as_local_hir_id(id)) + .map(|id| hir.local_def_id_to_hir_id(id)) .and_then(|id| hir.find(hir.get_parent_item(id))) .as_ref() .and_then(|node| node.generics()) diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index 50d9a1ebd2c..2bde5d2c78c 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -71,7 +71,7 @@ impl<'tcx> CheckWfFcxBuilder<'tcx> { /// not included it frequently leads to confusing errors in fn bodies. So it's better to check /// the types first. pub fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: LocalDefId) { - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let item = tcx.hir().expect_item(hir_id); debug!( @@ -190,7 +190,7 @@ pub fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: LocalDefId) { } pub fn check_trait_item(tcx: TyCtxt<'_>, def_id: LocalDefId) { - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let trait_item = tcx.hir().expect_trait_item(hir_id); let method_sig = match trait_item.kind { @@ -264,7 +264,7 @@ fn check_object_unsafe_self_trait_by_name(tcx: TyCtxt<'_>, item: &hir::TraitItem } pub fn check_impl_item(tcx: TyCtxt<'_>, def_id: LocalDefId) { - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let impl_item = tcx.hir().expect_impl_item(hir_id); let method_sig = match impl_item.kind { @@ -902,7 +902,7 @@ fn check_opaque_types<'fcx, 'tcx>( let generics = tcx.generics_of(def_id); let opaque_hir_id = if let Some(local_id) = def_id.as_local() { - tcx.hir().as_local_hir_id(local_id) + tcx.hir().local_def_id_to_hir_id(local_id) } else { // Opaque types from other crates won't have defining uses in this crate. return ty; diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs index 82ee48f0b53..50e2d6a94bb 100644 --- a/src/librustc_typeck/check/writeback.rs +++ b/src/librustc_typeck/check/writeback.rs @@ -433,7 +433,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { fn visit_opaque_types(&mut self, span: Span) { for (&def_id, opaque_defn) in self.fcx.opaque_types.borrow().iter() { - let hir_id = self.tcx().hir().as_local_hir_id(def_id.expect_local()); + let hir_id = self.tcx().hir().local_def_id_to_hir_id(def_id.expect_local()); let instantiated_ty = self.resolve(&opaque_defn.concrete_ty, &hir_id); debug_assert!(!instantiated_ty.has_escaping_bound_vars()); diff --git a/src/librustc_typeck/check_unused.rs b/src/librustc_typeck/check_unused.rs index 81daf064bb3..4fda8932e21 100644 --- a/src/librustc_typeck/check_unused.rs +++ b/src/librustc_typeck/check_unused.rs @@ -88,7 +88,7 @@ fn unused_crates_lint(tcx: TyCtxt<'_>) { // Note that if we carry through to the `extern_mod_stmt_cnum` query // below it'll cause a panic because `def_id` is actually bogus at this // point in time otherwise. - if tcx.hir().find(tcx.hir().as_local_hir_id(def_id)).is_none() { + if tcx.hir().find(tcx.hir().local_def_id_to_hir_id(def_id)).is_none() { return false; } true @@ -113,7 +113,7 @@ fn unused_crates_lint(tcx: TyCtxt<'_>) { for extern_crate in &crates_to_lint { let def_id = extern_crate.def_id.expect_local(); - let id = tcx.hir().as_local_hir_id(def_id); + let id = tcx.hir().local_def_id_to_hir_id(def_id); let item = tcx.hir().expect_item(id); // If the crate is fully unused, we suggest removing it altogether. diff --git a/src/librustc_typeck/coherence/builtin.rs b/src/librustc_typeck/coherence/builtin.rs index 8c6161a6264..56a737964c0 100644 --- a/src/librustc_typeck/coherence/builtin.rs +++ b/src/librustc_typeck/coherence/builtin.rs @@ -54,7 +54,7 @@ fn visit_implementation_of_drop(tcx: TyCtxt<'_>, impl_did: LocalDefId) { return; } - let impl_hir_id = tcx.hir().as_local_hir_id(impl_did); + let impl_hir_id = tcx.hir().local_def_id_to_hir_id(impl_did); let sp = match tcx.hir().expect_item(impl_hir_id).kind { ItemKind::Impl { self_ty, .. } => self_ty.span, _ => bug!("expected Drop impl item"), @@ -73,7 +73,7 @@ fn visit_implementation_of_drop(tcx: TyCtxt<'_>, impl_did: LocalDefId) { fn visit_implementation_of_copy(tcx: TyCtxt<'_>, impl_did: LocalDefId) { debug!("visit_implementation_of_copy: impl_did={:?}", impl_did); - let impl_hir_id = tcx.hir().as_local_hir_id(impl_did); + let impl_hir_id = tcx.hir().local_def_id_to_hir_id(impl_did); let self_type = tcx.type_of(impl_did); debug!("visit_implementation_of_copy: self_type={:?} (bound)", self_type); @@ -146,7 +146,7 @@ fn visit_implementation_of_coerce_unsized(tcx: TyCtxt<'tcx>, impl_did: LocalDefI fn visit_implementation_of_dispatch_from_dyn(tcx: TyCtxt<'_>, impl_did: LocalDefId) { debug!("visit_implementation_of_dispatch_from_dyn: impl_did={:?}", impl_did); - let impl_hir_id = tcx.hir().as_local_hir_id(impl_did); + let impl_hir_id = tcx.hir().local_def_id_to_hir_id(impl_did); let span = tcx.hir().span(impl_hir_id); let dispatch_from_dyn_trait = tcx.require_lang_item(DispatchFromDynTraitLangItem, Some(span)); @@ -315,7 +315,7 @@ pub fn coerce_unsized_info(tcx: TyCtxt<'tcx>, impl_did: DefId) -> CoerceUnsizedI debug!("compute_coerce_unsized_info(impl_did={:?})", impl_did); // this provider should only get invoked for local def-ids - let impl_hir_id = tcx.hir().as_local_hir_id(impl_did.expect_local()); + let impl_hir_id = tcx.hir().local_def_id_to_hir_id(impl_did.expect_local()); let span = tcx.hir().span(impl_hir_id); let coerce_unsized_trait = tcx.require_lang_item(CoerceUnsizedTraitLangItem, Some(span)); diff --git a/src/librustc_typeck/coherence/inherent_impls.rs b/src/librustc_typeck/coherence/inherent_impls.rs index 93ee87f6c57..cd7429f166f 100644 --- a/src/librustc_typeck/coherence/inherent_impls.rs +++ b/src/librustc_typeck/coherence/inherent_impls.rs @@ -112,6 +112,16 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { item.span, ); } + ty::Array(_, _) => { + self.check_primitive_impl( + def_id, + lang_items.array_impl(), + None, + "array", + "[T; N]", + item.span, + ); + } ty::RawPtr(ty::TypeAndMut { ty: inner, mutbl: hir::Mutability::Not }) if matches!(inner.kind, ty::Slice(_)) => { diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index b47ef346004..da1f3ea62f2 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -275,7 +275,7 @@ impl ItemCtxt<'tcx> { } pub fn hir_id(&self) -> hir::HirId { - self.tcx.hir().as_local_hir_id(self.item_def_id.expect_local()) + self.tcx.hir().local_def_id_to_hir_id(self.item_def_id.expect_local()) } pub fn node(&self) -> hir::Node<'tcx> { @@ -490,7 +490,7 @@ fn type_param_predicates( // written inline like `<T: Foo>` or in a where-clause like // `where T: Foo`. - let param_id = tcx.hir().as_local_hir_id(def_id); + let param_id = tcx.hir().local_def_id_to_hir_id(def_id); let param_owner = tcx.hir().ty_param_owner(param_id); let param_owner_def_id = tcx.hir().local_def_id(param_owner); let generics = tcx.generics_of(param_owner_def_id); @@ -512,7 +512,7 @@ fn type_param_predicates( .unwrap_or_default(); let mut extend = None; - let item_hir_id = tcx.hir().as_local_hir_id(item_def_id.expect_local()); + let item_hir_id = tcx.hir().local_def_id_to_hir_id(item_def_id.expect_local()); let ast_generics = match tcx.hir().get(item_hir_id) { Node::TraitItem(item) => &item.generics, @@ -824,7 +824,7 @@ fn convert_variant( parent_did: LocalDefId, ) -> ty::VariantDef { let mut seen_fields: FxHashMap<Ident, Span> = Default::default(); - let hir_id = tcx.hir().as_local_hir_id(variant_did.unwrap_or(parent_did)); + let hir_id = tcx.hir().local_def_id_to_hir_id(variant_did.unwrap_or(parent_did)); let fields = def .fields() .iter() @@ -878,7 +878,7 @@ fn adt_def(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::AdtDef { use rustc_hir::*; let def_id = def_id.expect_local(); - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let item = match tcx.hir().get(hir_id) { Node::Item(item) => item, _ => bug!(), @@ -965,7 +965,7 @@ fn adt_def(tcx: TyCtxt<'_>, def_id: DefId) -> &ty::AdtDef { /// the transitive super-predicates are converted. fn super_predicates_of(tcx: TyCtxt<'_>, trait_def_id: DefId) -> ty::GenericPredicates<'_> { debug!("super_predicates(trait_def_id={:?})", trait_def_id); - let trait_hir_id = tcx.hir().as_local_hir_id(trait_def_id.expect_local()); + let trait_hir_id = tcx.hir().local_def_id_to_hir_id(trait_def_id.expect_local()); let item = match tcx.hir().get(trait_hir_id) { Node::Item(item) => item, @@ -1016,7 +1016,7 @@ fn super_predicates_of(tcx: TyCtxt<'_>, trait_def_id: DefId) -> ty::GenericPredi } fn trait_def(tcx: TyCtxt<'_>, def_id: DefId) -> ty::TraitDef { - let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let item = tcx.hir().expect_item(hir_id); let (is_auto, unsafety) = match item.kind { @@ -1194,7 +1194,7 @@ impl<'v> Visitor<'v> for AnonConstInParamListDetector { fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics { use rustc_hir::*; - let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let node = tcx.hir().get(hir_id); let parent_def_id = match node { @@ -1499,7 +1499,7 @@ fn fn_sig(tcx: TyCtxt<'_>, def_id: DefId) -> ty::PolyFnSig<'_> { use rustc_hir::*; let def_id = def_id.expect_local(); - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let icx = ItemCtxt::new(tcx, def_id.to_def_id()); @@ -1597,7 +1597,7 @@ fn fn_sig(tcx: TyCtxt<'_>, def_id: DefId) -> ty::PolyFnSig<'_> { fn impl_trait_ref(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::TraitRef<'_>> { let icx = ItemCtxt::new(tcx, def_id); - let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); match tcx.hir().expect_item(hir_id).kind { hir::ItemKind::Impl { ref of_trait, .. } => of_trait.as_ref().map(|ast_trait_ref| { let selfty = tcx.type_of(def_id); @@ -1608,7 +1608,7 @@ fn impl_trait_ref(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::TraitRef<'_>> { } fn impl_polarity(tcx: TyCtxt<'_>, def_id: DefId) -> ty::ImplPolarity { - let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let is_rustc_reservation = tcx.has_attr(def_id, sym::rustc_reservation_impl); let item = tcx.hir().expect_item(hir_id); match &item.kind { @@ -1738,7 +1738,7 @@ fn explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicat } } - let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); let node = tcx.hir().get(hir_id); let mut is_trait = None; @@ -2590,7 +2590,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, id: DefId) -> CodegenFnAttrs { if !codegen_fn_attrs.no_sanitize.is_empty() { if codegen_fn_attrs.inline == InlineAttr::Always { if let (Some(no_sanitize_span), Some(inline_span)) = (no_sanitize_span, inline_span) { - let hir_id = tcx.hir().as_local_hir_id(id.expect_local()); + let hir_id = tcx.hir().local_def_id_to_hir_id(id.expect_local()); tcx.struct_span_lint_hir( lint::builtin::INLINE_NO_SANITIZE, hir_id, @@ -2718,7 +2718,7 @@ fn check_target_feature_safe_fn(tcx: TyCtxt<'_>, id: DefId, attr_span: Span) { /// Checks the function annotated with `#[target_feature]` is not a safe /// trait method implementation, reporting an error if it is. fn check_target_feature_trait_unsafe(tcx: TyCtxt<'_>, id: LocalDefId, attr_span: Span) { - let hir_id = tcx.hir().as_local_hir_id(id); + let hir_id = tcx.hir().local_def_id_to_hir_id(id); let node = tcx.hir().get(hir_id); if let Node::ImplItem(hir::ImplItem { kind: hir::ImplItemKind::Fn(..), .. }) = node { let parent_id = tcx.hir().get_parent_item(hir_id); diff --git a/src/librustc_typeck/collect/type_of.rs b/src/librustc_typeck/collect/type_of.rs index 17444c6d0ac..f1478c8c952 100644 --- a/src/librustc_typeck/collect/type_of.rs +++ b/src/librustc_typeck/collect/type_of.rs @@ -23,7 +23,7 @@ use super::{bad_placeholder_type, is_suggestable_infer_ty}; pub(super) fn opt_const_param_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<DefId> { use hir::*; - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); if let Node::AnonConst(_) = tcx.hir().get(hir_id) { let parent_node_id = tcx.hir().get_parent_node(hir_id); @@ -138,7 +138,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { let def_id = def_id.expect_local(); use rustc_hir::*; - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let icx = ItemCtxt::new(tcx, def_id.to_def_id()); @@ -564,7 +564,7 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Ty<'_> { } } - let hir_id = tcx.hir().as_local_hir_id(def_id); + let hir_id = tcx.hir().local_def_id_to_hir_id(def_id); let scope = tcx.hir().get_defining_scope(hir_id); let mut locator = ConstraintLocator { def_id: def_id.to_def_id(), tcx, found: None }; @@ -617,7 +617,7 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Ty<'_> { /// by the time we borrow check, and it's not clear how we should handle /// those. fn let_position_impl_trait_type(tcx: TyCtxt<'_>, opaque_ty_id: LocalDefId) -> Ty<'_> { - let scope = tcx.hir().get_defining_scope(tcx.hir().as_local_hir_id(opaque_ty_id)); + let scope = tcx.hir().get_defining_scope(tcx.hir().local_def_id_to_hir_id(opaque_ty_id)); let scope_def_id = tcx.hir().local_def_id(scope); let opaque_ty_def_id = opaque_ty_id.to_def_id(); @@ -653,7 +653,7 @@ fn let_position_impl_trait_type(tcx: TyCtxt<'_>, opaque_ty_id: LocalDefId) -> Ty if concrete_ty.has_erased_regions() { // FIXME(impl_trait_in_bindings) Handle this case. tcx.sess.span_fatal( - tcx.hir().span(tcx.hir().as_local_hir_id(opaque_ty_id)), + tcx.hir().span(tcx.hir().local_def_id_to_hir_id(opaque_ty_id)), "lifetimes in impl Trait types in bindings are not currently supported", ); } diff --git a/src/librustc_typeck/impl_wf_check/min_specialization.rs b/src/librustc_typeck/impl_wf_check/min_specialization.rs index 8257c6ce925..3746e5778aa 100644 --- a/src/librustc_typeck/impl_wf_check/min_specialization.rs +++ b/src/librustc_typeck/impl_wf_check/min_specialization.rs @@ -336,7 +336,7 @@ fn check_predicates<'tcx>( if let Some(obligations) = wf::obligations( infcx, tcx.param_env(impl1_def_id), - tcx.hir().as_local_hir_id(impl1_def_id), + tcx.hir().local_def_id_to_hir_id(impl1_def_id), arg, span, ) { diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index 49843fa43dd..42482531725 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -69,7 +69,7 @@ This API is completely unstable and subject to change. #![recursion_limit = "256"] #[macro_use] -extern crate log; +extern crate tracing; #[macro_use] extern crate rustc_middle; @@ -153,7 +153,7 @@ fn require_same_types<'tcx>( } fn check_main_fn_ty(tcx: TyCtxt<'_>, main_def_id: LocalDefId) { - let main_id = tcx.hir().as_local_hir_id(main_def_id); + let main_id = tcx.hir().local_def_id_to_hir_id(main_def_id); let main_span = tcx.def_span(main_def_id); let main_t = tcx.type_of(main_def_id); match main_t.kind { @@ -249,7 +249,7 @@ fn check_main_fn_ty(tcx: TyCtxt<'_>, main_def_id: LocalDefId) { } fn check_start_fn_ty(tcx: TyCtxt<'_>, start_def_id: LocalDefId) { - let start_id = tcx.hir().as_local_hir_id(start_def_id); + let start_id = tcx.hir().local_def_id_to_hir_id(start_def_id); let start_span = tcx.def_span(start_def_id); let start_t = tcx.type_of(start_def_id); match start_t.kind { diff --git a/src/librustc_typeck/outlives/implicit_infer.rs b/src/librustc_typeck/outlives/implicit_infer.rs index 15c72f8704f..762d4216f70 100644 --- a/src/librustc_typeck/outlives/implicit_infer.rs +++ b/src/librustc_typeck/outlives/implicit_infer.rs @@ -57,7 +57,7 @@ impl<'cx, 'tcx> ItemLikeVisitor<'tcx> for InferVisitor<'cx, 'tcx> { debug!("InferVisitor::visit_item(item={:?})", item_did); - let hir_id = self.tcx.hir().as_local_hir_id(item_did); + let hir_id = self.tcx.hir().local_def_id_to_hir_id(item_did); let item = match self.tcx.hir().get(hir_id) { Node::Item(item) => item, _ => bug!(), diff --git a/src/librustc_typeck/outlives/mod.rs b/src/librustc_typeck/outlives/mod.rs index 5dc7ac9fa0d..94926f480e2 100644 --- a/src/librustc_typeck/outlives/mod.rs +++ b/src/librustc_typeck/outlives/mod.rs @@ -18,7 +18,7 @@ pub fn provide(providers: &mut Providers) { } fn inferred_outlives_of(tcx: TyCtxt<'_>, item_def_id: DefId) -> &[(ty::Predicate<'_>, Span)] { - let id = tcx.hir().as_local_hir_id(item_def_id.expect_local()); + let id = tcx.hir().local_def_id_to_hir_id(item_def_id.expect_local()); match tcx.hir().get(id) { Node::Item(item) => match item.kind { diff --git a/src/librustc_typeck/variance/constraints.rs b/src/librustc_typeck/variance/constraints.rs index b810c9824ce..535530a2ed4 100644 --- a/src/librustc_typeck/variance/constraints.rs +++ b/src/librustc_typeck/variance/constraints.rs @@ -137,7 +137,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { return; } - let id = tcx.hir().as_local_hir_id(def_id); + let id = tcx.hir().local_def_id_to_hir_id(def_id); let inferred_start = self.terms_cx.inferred_starts[&id]; let current_item = &CurrentItem { inferred_start }; match tcx.type_of(def_id).kind { @@ -375,7 +375,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> { } let (local, remote) = if let Some(def_id) = def_id.as_local() { - let id = self.tcx().hir().as_local_hir_id(def_id); + let id = self.tcx().hir().local_def_id_to_hir_id(def_id); (Some(self.terms_cx.inferred_starts[&id]), None) } else { (None, Some(self.tcx().variances_of(def_id))) diff --git a/src/librustc_typeck/variance/mod.rs b/src/librustc_typeck/variance/mod.rs index b307363dc3a..a893f69c48a 100644 --- a/src/librustc_typeck/variance/mod.rs +++ b/src/librustc_typeck/variance/mod.rs @@ -39,7 +39,7 @@ fn crate_variances(tcx: TyCtxt<'_>, crate_num: CrateNum) -> CrateVariancesMap<'_ } fn variances_of(tcx: TyCtxt<'_>, item_def_id: DefId) -> &[ty::Variance] { - let id = tcx.hir().as_local_hir_id(item_def_id.expect_local()); + let id = tcx.hir().local_def_id_to_hir_id(item_def_id.expect_local()); let unsupported = || { // Variance not relevant. span_bug!(tcx.hir().span(id), "asked to compute variance for wrong kind of item") diff --git a/src/librustc_typeck/variance/terms.rs b/src/librustc_typeck/variance/terms.rs index 6e15485756d..f61a783de69 100644 --- a/src/librustc_typeck/variance/terms.rs +++ b/src/librustc_typeck/variance/terms.rs @@ -94,7 +94,9 @@ fn lang_items(tcx: TyCtxt<'_>) -> Vec<(hir::HirId, Vec<ty::Variance>)> { all.into_iter() // iterating over (Option<DefId>, Variance) .filter(|&(ref d, _)| d.is_some()) .map(|(d, v)| (d.unwrap(), v)) // (DefId, Variance) - .filter_map(|(d, v)| d.as_local().map(|d| tcx.hir().as_local_hir_id(d)).map(|n| (n, v))) // (HirId, Variance) + .filter_map(|(d, v)| { + d.as_local().map(|d| tcx.hir().local_def_id_to_hir_id(d)).map(|n| (n, v)) + }) // (HirId, Variance) .collect() } diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index 1f576a17dd9..cb7c62e3a5a 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -356,7 +356,7 @@ pub fn build_impl( } let for_ = if let Some(did) = did.as_local() { - let hir_id = tcx.hir().as_local_hir_id(did); + let hir_id = tcx.hir().local_def_id_to_hir_id(did); match tcx.hir().expect_item(hir_id).kind { hir::ItemKind::Impl { self_ty, .. } => self_ty.clean(cx), _ => panic!("did given to build_impl was not an impl"), @@ -377,7 +377,7 @@ pub fn build_impl( let predicates = tcx.explicit_predicates_of(did); let (trait_items, generics) = if let Some(did) = did.as_local() { - let hir_id = tcx.hir().as_local_hir_id(did); + let hir_id = tcx.hir().local_def_id_to_hir_id(did); match tcx.hir().expect_item(hir_id).kind { hir::ItemKind::Impl { ref generics, ref items, .. } => ( items.iter().map(|item| tcx.hir().impl_item(item.id).clean(cx)).collect::<Vec<_>>(), @@ -500,7 +500,7 @@ fn build_module(cx: &DocContext<'_>, did: DefId, visited: &mut FxHashSet<DefId>) pub fn print_inlined_const(cx: &DocContext<'_>, did: DefId) -> String { if let Some(did) = did.as_local() { - let hir_id = cx.tcx.hir().as_local_hir_id(did); + let hir_id = cx.tcx.hir().local_def_id_to_hir_id(did); rustc_hir_pretty::id_to_string(&cx.tcx.hir(), hir_id) } else { cx.tcx.rendered_const(did) @@ -513,7 +513,7 @@ fn build_const(cx: &DocContext<'_>, did: DefId) -> clean::Constant { expr: print_inlined_const(cx, did), value: clean::utils::print_evaluated_const(cx, did), is_literal: did.as_local().map_or(false, |did| { - clean::utils::is_literal_expr(cx, cx.tcx.hir().as_local_hir_id(did)) + clean::utils::is_literal_expr(cx, cx.tcx.hir().local_def_id_to_hir_id(did)) }), } } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 801d06e6101..3ad357e583c 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1382,7 +1382,7 @@ impl Clean<Type> for hir::Ty<'_> { if let Res::Def(DefKind::TyAlias, def_id) = path.res { // Substitute private type aliases if let Some(def_id) = def_id.as_local() { - let hir_id = cx.tcx.hir().as_local_hir_id(def_id); + let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def_id); if !cx.renderinfo.borrow().access_levels.is_exported(def_id.to_def_id()) { alias = Some(&cx.tcx.hir().expect_item(hir_id).kind); } diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs index c22538f21f6..a7d03fcabf5 100644 --- a/src/librustdoc/clean/utils.rs +++ b/src/librustdoc/clean/utils.rs @@ -388,7 +388,7 @@ pub fn build_deref_target_impls(cx: &DocContext<'_>, items: &[Item], ret: &mut V Bool => tcx.lang_items().bool_impl(), Str => tcx.lang_items().str_impl(), Slice => tcx.lang_items().slice_impl(), - Array => tcx.lang_items().slice_impl(), + Array => tcx.lang_items().array_impl(), Tuple => None, Unit => None, RawPointer => tcx.lang_items().const_ptr_impl(), @@ -471,7 +471,7 @@ pub fn print_const(cx: &DocContext<'_>, n: &'tcx ty::Const<'_>) -> String { match n.val { ty::ConstKind::Unevaluated(def, _, promoted) => { let mut s = if let Some(def) = def.as_local() { - let hir_id = cx.tcx.hir().as_local_hir_id(def.did); + let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def.did); print_const_expr(cx, cx.tcx.hir().body_owned_by(hir_id)) } else { inline::print_inlined_const(cx, def.did) diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index b13acaae1bf..c21fd8da0ed 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -143,13 +143,13 @@ impl<'tcx> DocContext<'tcx> { def_id } - /// Like the function of the same name on the HIR map, but skips calling it on fake DefIds. + /// Like `hir().local_def_id_to_hir_id()`, but skips calling it on fake DefIds. /// (This avoids a slice-index-out-of-bounds panic.) pub fn as_local_hir_id(&self, def_id: DefId) -> Option<HirId> { if self.all_fake_def_ids.borrow().contains(&def_id) { None } else { - def_id.as_local().map(|def_id| self.tcx.hir().as_local_hir_id(def_id)) + def_id.as_local().map(|def_id| self.tcx.hir().local_def_id_to_hir_id(def_id)) } } @@ -400,7 +400,7 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt } let hir = tcx.hir(); - let body = hir.body(hir.body_owned_by(hir.as_local_hir_id(def_id))); + let body = hir.body(hir.body_owned_by(hir.local_def_id_to_hir_id(def_id))); debug!("visiting body for {:?}", def_id); EmitIgnoredResolutionErrors::new(tcx).visit_body(body); (rustc_interface::DEFAULT_QUERY_PROVIDERS.typeck)(tcx, def_id) diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs index 4cfd81ffbce..b2589e5b806 100644 --- a/src/librustdoc/html/markdown.rs +++ b/src/librustdoc/html/markdown.rs @@ -655,7 +655,7 @@ impl<'a, 'b> ExtraInfo<'a, 'b> { (Some(h), _) => h, (None, Some(item_did)) => { match item_did.as_local() { - Some(item_did) => self.tcx.hir().as_local_hir_id(item_did), + Some(item_did) => self.tcx.hir().local_def_id_to_hir_id(item_did), None => { // If non-local, no need to check anything. return; diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs index 062bd61a7d0..f7fc3579d67 100644 --- a/src/librustdoc/passes/collect_intra_doc_links.rs +++ b/src/librustdoc/passes/collect_intra_doc_links.rs @@ -813,8 +813,8 @@ impl<'a, 'tcx> DocFolder for LinkCollector<'a, 'tcx> { { use rustc_hir::def_id::LOCAL_CRATE; - let hir_src = self.cx.tcx.hir().as_local_hir_id(src_id); - let hir_dst = self.cx.tcx.hir().as_local_hir_id(dst_id); + let hir_src = self.cx.tcx.hir().local_def_id_to_hir_id(src_id); + let hir_dst = self.cx.tcx.hir().local_def_id_to_hir_id(dst_id); if self.cx.tcx.privacy_access_levels(LOCAL_CRATE).is_exported(hir_src) && !self.cx.tcx.privacy_access_levels(LOCAL_CRATE).is_exported(hir_dst) diff --git a/src/librustdoc/passes/collect_trait_impls.rs b/src/librustdoc/passes/collect_trait_impls.rs index 3000afde0c2..a40b45f9a7e 100644 --- a/src/librustdoc/passes/collect_trait_impls.rs +++ b/src/librustdoc/passes/collect_trait_impls.rs @@ -55,6 +55,7 @@ pub fn collect_trait_impls(krate: Crate, cx: &DocContext<'_>) -> Crate { lang_items.bool_impl(), lang_items.char_impl(), lang_items.str_impl(), + lang_items.array_impl(), lang_items.slice_impl(), lang_items.slice_u8_impl(), lang_items.str_alloc_impl(), diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index cf57ffd0b4b..be80193db8c 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -323,7 +323,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { } let res_hir_id = match res_did.as_local() { - Some(n) => tcx.hir().as_local_hir_id(n), + Some(n) => tcx.hir().local_def_id_to_hir_id(n), None => return false, }; diff --git a/src/rustllvm/ArchiveWrapper.cpp b/src/rustllvm/ArchiveWrapper.cpp index 93704638f83..9ce614fda57 100644 --- a/src/rustllvm/ArchiveWrapper.cpp +++ b/src/rustllvm/ArchiveWrapper.cpp @@ -35,7 +35,6 @@ struct RustArchiveIterator { }; enum class LLVMRustArchiveKind { - Other, GNU, BSD, DARWIN, diff --git a/src/rustllvm/CoverageMappingWrapper.cpp b/src/rustllvm/CoverageMappingWrapper.cpp index 7c8481540aa..4d15e31df15 100644 --- a/src/rustllvm/CoverageMappingWrapper.cpp +++ b/src/rustllvm/CoverageMappingWrapper.cpp @@ -38,6 +38,11 @@ extern "C" void LLVMRustCoverageWriteMappingToBuffer( CoverageMappingWriter.write(OS); } +extern "C" LLVMValueRef LLVMRustCoverageCreatePGOFuncNameVar(LLVMValueRef F, const char *FuncName) { + StringRef FuncNameRef(FuncName); + return wrap(createPGOFuncNameVar(*cast<Function>(unwrap(F)), FuncNameRef)); +} + extern "C" uint64_t LLVMRustCoverageComputeHash(const char *Name) { StringRef NameRef(Name); return IndexedInstrProf::ComputeHash(NameRef); diff --git a/src/rustllvm/PassWrapper.cpp b/src/rustllvm/PassWrapper.cpp index 41b14714842..76fe5e7f769 100644 --- a/src/rustllvm/PassWrapper.cpp +++ b/src/rustllvm/PassWrapper.cpp @@ -311,7 +311,6 @@ static Optional<CodeModel::Model> fromRust(LLVMRustCodeModel Model) { } enum class LLVMRustCodeGenOptLevel { - Other, None, Less, Default, @@ -597,7 +596,6 @@ extern "C" void LLVMRustSetLLVMOptions(int Argc, char **Argv) { } enum class LLVMRustFileType { - Other, AssemblyFile, ObjectFile, }; diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp index 667bf4a2ded..9d90b0dfe07 100644 --- a/src/rustllvm/RustWrapper.cpp +++ b/src/rustllvm/RustWrapper.cpp @@ -366,7 +366,6 @@ LLVMRustBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Target, } enum class LLVMRustSynchronizationScope { - Other, SingleThread, CrossThread, }; @@ -389,7 +388,6 @@ LLVMRustBuildAtomicFence(LLVMBuilderRef B, LLVMAtomicOrdering Order, } enum class LLVMRustAsmDialect { - Other, Att, Intel, }; diff --git a/src/test/codegen/naked-functions.rs b/src/test/codegen/naked-functions.rs index 758c6c4da92..493c1b9f0ba 100644 --- a/src/test/codegen/naked-functions.rs +++ b/src/test/codegen/naked-functions.rs @@ -18,7 +18,7 @@ pub fn naked_empty() { // CHECK-NEXT: define void @naked_with_args(i{{[0-9]+( %0)?}}) pub fn naked_with_args(a: isize) { // CHECK-NEXT: {{.+}}: - // CHECK-NEXT: %_1 = alloca i{{[0-9]+}} + // CHECK-NEXT: %a = alloca i{{[0-9]+}} &a; // keep variable in an alloca // CHECK: ret void } @@ -39,7 +39,7 @@ pub fn naked_with_return() -> isize { #[naked] pub fn naked_with_args_and_return(a: isize) -> isize { // CHECK-NEXT: {{.+}}: - // CHECK-NEXT: %_1 = alloca i{{[0-9]+}} + // CHECK-NEXT: %a = alloca i{{[0-9]+}} &a; // keep variable in an alloca // CHECK: ret i{{[0-9]+}} %{{[0-9]+}} a diff --git a/src/test/debuginfo/function-arguments-naked.rs b/src/test/debuginfo/function-arguments-naked.rs deleted file mode 100644 index 5f3a1eb44e4..00000000000 --- a/src/test/debuginfo/function-arguments-naked.rs +++ /dev/null @@ -1,42 +0,0 @@ -// min-lldb-version: 310 - -// We have to ignore android because of this issue: -// https://github.com/rust-lang/rust/issues/74847 -// ignore-android -// -// We need to use inline assembly, so just use one platform -// only-x86_64 - -// compile-flags:-g - -// === GDB TESTS =================================================================================== - -// gdb-command:run - -// gdb-command:info args -// gdb-check:No arguments. -// gdb-command:continue - -// === LLDB TESTS ================================================================================== - -// lldb-command:run - -// lldb-command:frame variable -// lldbg-check:(unsigned long) = 111 (unsigned long) = 222 -// lldbr-check:(unsigned long) = 111 (unsigned long) = 222 -// lldb-command:continue - - -#![feature(asm)] -#![feature(naked_functions)] -#![feature(omit_gdb_pretty_printer_section)] -#![omit_gdb_pretty_printer_section] - -fn main() { - naked(111, 222); -} - -#[naked] -extern "C" fn naked(x: usize, y: usize) { - unsafe { asm!("ret"); } // #break -} diff --git a/src/test/mir-opt/matches_reduce_branches.bar.MatchBranchSimplification.diff.32bit b/src/test/mir-opt/matches_reduce_branches.bar.MatchBranchSimplification.diff.32bit new file mode 100644 index 00000000000..968890e3a29 --- /dev/null +++ b/src/test/mir-opt/matches_reduce_branches.bar.MatchBranchSimplification.diff.32bit @@ -0,0 +1,156 @@ +- // MIR for `bar` before MatchBranchSimplification ++ // MIR for `bar` after MatchBranchSimplification + + fn bar(_1: i32) -> (bool, bool, bool, bool) { + debug i => _1; // in scope 0 at $DIR/matches_reduce_branches.rs:11:8: 11:9 + let mut _0: (bool, bool, bool, bool); // return place in scope 0 at $DIR/matches_reduce_branches.rs:11:19: 11:43 + let _2: bool; // in scope 0 at $DIR/matches_reduce_branches.rs:12:9: 12:10 + let _6: (); // in scope 0 at $DIR/matches_reduce_branches.rs:17:5: 32:6 + let mut _7: bool; // in scope 0 at $DIR/matches_reduce_branches.rs:34:6: 34:7 + let mut _8: bool; // in scope 0 at $DIR/matches_reduce_branches.rs:34:9: 34:10 + let mut _9: bool; // in scope 0 at $DIR/matches_reduce_branches.rs:34:12: 34:13 + let mut _10: bool; // in scope 0 at $DIR/matches_reduce_branches.rs:34:15: 34:16 + scope 1 { + debug a => _2; // in scope 1 at $DIR/matches_reduce_branches.rs:12:9: 12:10 + let _3: bool; // in scope 1 at $DIR/matches_reduce_branches.rs:13:9: 13:10 + scope 2 { + debug b => _3; // in scope 2 at $DIR/matches_reduce_branches.rs:13:9: 13:10 + let _4: bool; // in scope 2 at $DIR/matches_reduce_branches.rs:14:9: 14:10 + scope 3 { + debug c => _4; // in scope 3 at $DIR/matches_reduce_branches.rs:14:9: 14:10 + let _5: bool; // in scope 3 at $DIR/matches_reduce_branches.rs:15:9: 15:10 + scope 4 { + debug d => _5; // in scope 4 at $DIR/matches_reduce_branches.rs:15:9: 15:10 + } + } + } + } + + bb0: { + StorageLive(_2); // scope 0 at $DIR/matches_reduce_branches.rs:12:9: 12:10 + StorageLive(_3); // scope 1 at $DIR/matches_reduce_branches.rs:13:9: 13:10 + StorageLive(_4); // scope 2 at $DIR/matches_reduce_branches.rs:14:9: 14:10 + StorageLive(_5); // scope 3 at $DIR/matches_reduce_branches.rs:15:9: 15:10 + StorageLive(_6); // scope 4 at $DIR/matches_reduce_branches.rs:17:5: 32:6 +- switchInt(_1) -> [7_i32: bb2, otherwise: bb1]; // scope 4 at $DIR/matches_reduce_branches.rs:18:9: 18:10 ++ _2 = Ne(_1, const 7_i32); // scope 4 at $DIR/matches_reduce_branches.rs:19:13: 19:22 ++ // ty::Const ++ // + ty: i32 ++ // + val: Value(Scalar(0x00000007)) ++ // mir::Constant ++ // + span: $DIR/matches_reduce_branches.rs:1:1: 1:1 ++ // + literal: Const { ty: i32, val: Value(Scalar(0x00000007)) } ++ _3 = Eq(_1, const 7_i32); // scope 4 at $DIR/matches_reduce_branches.rs:20:13: 20:21 ++ // ty::Const ++ // + ty: i32 ++ // + val: Value(Scalar(0x00000007)) ++ // mir::Constant ++ // + span: $DIR/matches_reduce_branches.rs:1:1: 1:1 ++ // + literal: Const { ty: i32, val: Value(Scalar(0x00000007)) } ++ _4 = const false; // scope 4 at $DIR/matches_reduce_branches.rs:21:13: 21:22 ++ // ty::Const ++ // + ty: bool ++ // + val: Value(Scalar(0x00)) ++ // mir::Constant ++ // + span: $DIR/matches_reduce_branches.rs:21:17: 21:22 ++ // + literal: Const { ty: bool, val: Value(Scalar(0x00)) } ++ _5 = const true; // scope 4 at $DIR/matches_reduce_branches.rs:22:13: 22:21 ++ // ty::Const ++ // + ty: bool ++ // + val: Value(Scalar(0x01)) ++ // mir::Constant ++ // + span: $DIR/matches_reduce_branches.rs:22:17: 22:21 ++ // + literal: Const { ty: bool, val: Value(Scalar(0x01)) } ++ goto -> bb3; // scope 4 at $DIR/matches_reduce_branches.rs:18:9: 18:10 + } + + bb1: { + _2 = const true; // scope 4 at $DIR/matches_reduce_branches.rs:26:13: 26:21 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x01)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:26:17: 26:21 + // + literal: Const { ty: bool, val: Value(Scalar(0x01)) } + _3 = const false; // scope 4 at $DIR/matches_reduce_branches.rs:27:13: 27:22 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x00)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:27:17: 27:22 + // + literal: Const { ty: bool, val: Value(Scalar(0x00)) } + _4 = const false; // scope 4 at $DIR/matches_reduce_branches.rs:28:13: 28:22 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x00)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:28:17: 28:22 + // + literal: Const { ty: bool, val: Value(Scalar(0x00)) } + _5 = const true; // scope 4 at $DIR/matches_reduce_branches.rs:29:13: 29:21 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x01)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:29:17: 29:21 + // + literal: Const { ty: bool, val: Value(Scalar(0x01)) } + goto -> bb3; // scope 4 at $DIR/matches_reduce_branches.rs:17:5: 32:6 + } + + bb2: { + _2 = const false; // scope 4 at $DIR/matches_reduce_branches.rs:19:13: 19:22 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x00)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:19:17: 19:22 + // + literal: Const { ty: bool, val: Value(Scalar(0x00)) } + _3 = const true; // scope 4 at $DIR/matches_reduce_branches.rs:20:13: 20:21 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x01)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:20:17: 20:21 + // + literal: Const { ty: bool, val: Value(Scalar(0x01)) } + _4 = const false; // scope 4 at $DIR/matches_reduce_branches.rs:21:13: 21:22 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x00)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:21:17: 21:22 + // + literal: Const { ty: bool, val: Value(Scalar(0x00)) } + _5 = const true; // scope 4 at $DIR/matches_reduce_branches.rs:22:13: 22:21 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x01)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:22:17: 22:21 + // + literal: Const { ty: bool, val: Value(Scalar(0x01)) } + goto -> bb3; // scope 4 at $DIR/matches_reduce_branches.rs:17:5: 32:6 + } + + bb3: { + StorageDead(_6); // scope 4 at $DIR/matches_reduce_branches.rs:32:6: 32:7 + StorageLive(_7); // scope 4 at $DIR/matches_reduce_branches.rs:34:6: 34:7 + _7 = _2; // scope 4 at $DIR/matches_reduce_branches.rs:34:6: 34:7 + StorageLive(_8); // scope 4 at $DIR/matches_reduce_branches.rs:34:9: 34:10 + _8 = _3; // scope 4 at $DIR/matches_reduce_branches.rs:34:9: 34:10 + StorageLive(_9); // scope 4 at $DIR/matches_reduce_branches.rs:34:12: 34:13 + _9 = _4; // scope 4 at $DIR/matches_reduce_branches.rs:34:12: 34:13 + StorageLive(_10); // scope 4 at $DIR/matches_reduce_branches.rs:34:15: 34:16 + _10 = _5; // scope 4 at $DIR/matches_reduce_branches.rs:34:15: 34:16 + (_0.0: bool) = move _7; // scope 4 at $DIR/matches_reduce_branches.rs:34:5: 34:17 + (_0.1: bool) = move _8; // scope 4 at $DIR/matches_reduce_branches.rs:34:5: 34:17 + (_0.2: bool) = move _9; // scope 4 at $DIR/matches_reduce_branches.rs:34:5: 34:17 + (_0.3: bool) = move _10; // scope 4 at $DIR/matches_reduce_branches.rs:34:5: 34:17 + StorageDead(_10); // scope 4 at $DIR/matches_reduce_branches.rs:34:16: 34:17 + StorageDead(_9); // scope 4 at $DIR/matches_reduce_branches.rs:34:16: 34:17 + StorageDead(_8); // scope 4 at $DIR/matches_reduce_branches.rs:34:16: 34:17 + StorageDead(_7); // scope 4 at $DIR/matches_reduce_branches.rs:34:16: 34:17 + StorageDead(_5); // scope 3 at $DIR/matches_reduce_branches.rs:35:1: 35:2 + StorageDead(_4); // scope 2 at $DIR/matches_reduce_branches.rs:35:1: 35:2 + StorageDead(_3); // scope 1 at $DIR/matches_reduce_branches.rs:35:1: 35:2 + StorageDead(_2); // scope 0 at $DIR/matches_reduce_branches.rs:35:1: 35:2 + return; // scope 0 at $DIR/matches_reduce_branches.rs:35:2: 35:2 + } + } + diff --git a/src/test/mir-opt/matches_reduce_branches.bar.MatchBranchSimplification.diff.64bit b/src/test/mir-opt/matches_reduce_branches.bar.MatchBranchSimplification.diff.64bit new file mode 100644 index 00000000000..968890e3a29 --- /dev/null +++ b/src/test/mir-opt/matches_reduce_branches.bar.MatchBranchSimplification.diff.64bit @@ -0,0 +1,156 @@ +- // MIR for `bar` before MatchBranchSimplification ++ // MIR for `bar` after MatchBranchSimplification + + fn bar(_1: i32) -> (bool, bool, bool, bool) { + debug i => _1; // in scope 0 at $DIR/matches_reduce_branches.rs:11:8: 11:9 + let mut _0: (bool, bool, bool, bool); // return place in scope 0 at $DIR/matches_reduce_branches.rs:11:19: 11:43 + let _2: bool; // in scope 0 at $DIR/matches_reduce_branches.rs:12:9: 12:10 + let _6: (); // in scope 0 at $DIR/matches_reduce_branches.rs:17:5: 32:6 + let mut _7: bool; // in scope 0 at $DIR/matches_reduce_branches.rs:34:6: 34:7 + let mut _8: bool; // in scope 0 at $DIR/matches_reduce_branches.rs:34:9: 34:10 + let mut _9: bool; // in scope 0 at $DIR/matches_reduce_branches.rs:34:12: 34:13 + let mut _10: bool; // in scope 0 at $DIR/matches_reduce_branches.rs:34:15: 34:16 + scope 1 { + debug a => _2; // in scope 1 at $DIR/matches_reduce_branches.rs:12:9: 12:10 + let _3: bool; // in scope 1 at $DIR/matches_reduce_branches.rs:13:9: 13:10 + scope 2 { + debug b => _3; // in scope 2 at $DIR/matches_reduce_branches.rs:13:9: 13:10 + let _4: bool; // in scope 2 at $DIR/matches_reduce_branches.rs:14:9: 14:10 + scope 3 { + debug c => _4; // in scope 3 at $DIR/matches_reduce_branches.rs:14:9: 14:10 + let _5: bool; // in scope 3 at $DIR/matches_reduce_branches.rs:15:9: 15:10 + scope 4 { + debug d => _5; // in scope 4 at $DIR/matches_reduce_branches.rs:15:9: 15:10 + } + } + } + } + + bb0: { + StorageLive(_2); // scope 0 at $DIR/matches_reduce_branches.rs:12:9: 12:10 + StorageLive(_3); // scope 1 at $DIR/matches_reduce_branches.rs:13:9: 13:10 + StorageLive(_4); // scope 2 at $DIR/matches_reduce_branches.rs:14:9: 14:10 + StorageLive(_5); // scope 3 at $DIR/matches_reduce_branches.rs:15:9: 15:10 + StorageLive(_6); // scope 4 at $DIR/matches_reduce_branches.rs:17:5: 32:6 +- switchInt(_1) -> [7_i32: bb2, otherwise: bb1]; // scope 4 at $DIR/matches_reduce_branches.rs:18:9: 18:10 ++ _2 = Ne(_1, const 7_i32); // scope 4 at $DIR/matches_reduce_branches.rs:19:13: 19:22 ++ // ty::Const ++ // + ty: i32 ++ // + val: Value(Scalar(0x00000007)) ++ // mir::Constant ++ // + span: $DIR/matches_reduce_branches.rs:1:1: 1:1 ++ // + literal: Const { ty: i32, val: Value(Scalar(0x00000007)) } ++ _3 = Eq(_1, const 7_i32); // scope 4 at $DIR/matches_reduce_branches.rs:20:13: 20:21 ++ // ty::Const ++ // + ty: i32 ++ // + val: Value(Scalar(0x00000007)) ++ // mir::Constant ++ // + span: $DIR/matches_reduce_branches.rs:1:1: 1:1 ++ // + literal: Const { ty: i32, val: Value(Scalar(0x00000007)) } ++ _4 = const false; // scope 4 at $DIR/matches_reduce_branches.rs:21:13: 21:22 ++ // ty::Const ++ // + ty: bool ++ // + val: Value(Scalar(0x00)) ++ // mir::Constant ++ // + span: $DIR/matches_reduce_branches.rs:21:17: 21:22 ++ // + literal: Const { ty: bool, val: Value(Scalar(0x00)) } ++ _5 = const true; // scope 4 at $DIR/matches_reduce_branches.rs:22:13: 22:21 ++ // ty::Const ++ // + ty: bool ++ // + val: Value(Scalar(0x01)) ++ // mir::Constant ++ // + span: $DIR/matches_reduce_branches.rs:22:17: 22:21 ++ // + literal: Const { ty: bool, val: Value(Scalar(0x01)) } ++ goto -> bb3; // scope 4 at $DIR/matches_reduce_branches.rs:18:9: 18:10 + } + + bb1: { + _2 = const true; // scope 4 at $DIR/matches_reduce_branches.rs:26:13: 26:21 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x01)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:26:17: 26:21 + // + literal: Const { ty: bool, val: Value(Scalar(0x01)) } + _3 = const false; // scope 4 at $DIR/matches_reduce_branches.rs:27:13: 27:22 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x00)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:27:17: 27:22 + // + literal: Const { ty: bool, val: Value(Scalar(0x00)) } + _4 = const false; // scope 4 at $DIR/matches_reduce_branches.rs:28:13: 28:22 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x00)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:28:17: 28:22 + // + literal: Const { ty: bool, val: Value(Scalar(0x00)) } + _5 = const true; // scope 4 at $DIR/matches_reduce_branches.rs:29:13: 29:21 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x01)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:29:17: 29:21 + // + literal: Const { ty: bool, val: Value(Scalar(0x01)) } + goto -> bb3; // scope 4 at $DIR/matches_reduce_branches.rs:17:5: 32:6 + } + + bb2: { + _2 = const false; // scope 4 at $DIR/matches_reduce_branches.rs:19:13: 19:22 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x00)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:19:17: 19:22 + // + literal: Const { ty: bool, val: Value(Scalar(0x00)) } + _3 = const true; // scope 4 at $DIR/matches_reduce_branches.rs:20:13: 20:21 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x01)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:20:17: 20:21 + // + literal: Const { ty: bool, val: Value(Scalar(0x01)) } + _4 = const false; // scope 4 at $DIR/matches_reduce_branches.rs:21:13: 21:22 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x00)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:21:17: 21:22 + // + literal: Const { ty: bool, val: Value(Scalar(0x00)) } + _5 = const true; // scope 4 at $DIR/matches_reduce_branches.rs:22:13: 22:21 + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x01)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:22:17: 22:21 + // + literal: Const { ty: bool, val: Value(Scalar(0x01)) } + goto -> bb3; // scope 4 at $DIR/matches_reduce_branches.rs:17:5: 32:6 + } + + bb3: { + StorageDead(_6); // scope 4 at $DIR/matches_reduce_branches.rs:32:6: 32:7 + StorageLive(_7); // scope 4 at $DIR/matches_reduce_branches.rs:34:6: 34:7 + _7 = _2; // scope 4 at $DIR/matches_reduce_branches.rs:34:6: 34:7 + StorageLive(_8); // scope 4 at $DIR/matches_reduce_branches.rs:34:9: 34:10 + _8 = _3; // scope 4 at $DIR/matches_reduce_branches.rs:34:9: 34:10 + StorageLive(_9); // scope 4 at $DIR/matches_reduce_branches.rs:34:12: 34:13 + _9 = _4; // scope 4 at $DIR/matches_reduce_branches.rs:34:12: 34:13 + StorageLive(_10); // scope 4 at $DIR/matches_reduce_branches.rs:34:15: 34:16 + _10 = _5; // scope 4 at $DIR/matches_reduce_branches.rs:34:15: 34:16 + (_0.0: bool) = move _7; // scope 4 at $DIR/matches_reduce_branches.rs:34:5: 34:17 + (_0.1: bool) = move _8; // scope 4 at $DIR/matches_reduce_branches.rs:34:5: 34:17 + (_0.2: bool) = move _9; // scope 4 at $DIR/matches_reduce_branches.rs:34:5: 34:17 + (_0.3: bool) = move _10; // scope 4 at $DIR/matches_reduce_branches.rs:34:5: 34:17 + StorageDead(_10); // scope 4 at $DIR/matches_reduce_branches.rs:34:16: 34:17 + StorageDead(_9); // scope 4 at $DIR/matches_reduce_branches.rs:34:16: 34:17 + StorageDead(_8); // scope 4 at $DIR/matches_reduce_branches.rs:34:16: 34:17 + StorageDead(_7); // scope 4 at $DIR/matches_reduce_branches.rs:34:16: 34:17 + StorageDead(_5); // scope 3 at $DIR/matches_reduce_branches.rs:35:1: 35:2 + StorageDead(_4); // scope 2 at $DIR/matches_reduce_branches.rs:35:1: 35:2 + StorageDead(_3); // scope 1 at $DIR/matches_reduce_branches.rs:35:1: 35:2 + StorageDead(_2); // scope 0 at $DIR/matches_reduce_branches.rs:35:1: 35:2 + return; // scope 0 at $DIR/matches_reduce_branches.rs:35:2: 35:2 + } + } + diff --git a/src/test/mir-opt/matches_reduce_branches.foo.MatchBranchSimplification.diff.32bit b/src/test/mir-opt/matches_reduce_branches.foo.MatchBranchSimplification.diff.32bit new file mode 100644 index 00000000000..a33db001f44 --- /dev/null +++ b/src/test/mir-opt/matches_reduce_branches.foo.MatchBranchSimplification.diff.32bit @@ -0,0 +1,66 @@ +- // MIR for `foo` before MatchBranchSimplification ++ // MIR for `foo` after MatchBranchSimplification + + fn foo(_1: std::option::Option<()>) -> () { + debug bar => _1; // in scope 0 at $DIR/matches_reduce_branches.rs:5:8: 5:11 + let mut _0: (); // return place in scope 0 at $DIR/matches_reduce_branches.rs:5:25: 5:25 + let mut _2: bool; // in scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + let mut _3: isize; // in scope 0 at $DIR/matches_reduce_branches.rs:6:22: 6:26 + + bb0: { + StorageLive(_2); // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + _3 = discriminant(_1); // scope 0 at $DIR/matches_reduce_branches.rs:6:22: 6:26 +- switchInt(move _3) -> [0_isize: bb2, otherwise: bb1]; // scope 0 at $DIR/matches_reduce_branches.rs:6:22: 6:26 ++ _2 = Eq(_3, const 0_isize); // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL ++ // ty::Const ++ // + ty: isize ++ // + val: Value(Scalar(0x00000000)) ++ // mir::Constant ++ // + span: $DIR/matches_reduce_branches.rs:1:1: 1:1 ++ // + literal: Const { ty: isize, val: Value(Scalar(0x00000000)) } ++ goto -> bb3; // scope 0 at $DIR/matches_reduce_branches.rs:6:22: 6:26 + } + + bb1: { + _2 = const false; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x00)) + // mir::Constant + // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL + // + literal: Const { ty: bool, val: Value(Scalar(0x00)) } + goto -> bb3; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + } + + bb2: { + _2 = const true; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x01)) + // mir::Constant + // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL + // + literal: Const { ty: bool, val: Value(Scalar(0x01)) } + goto -> bb3; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + } + + bb3: { + switchInt(_2) -> [false: bb4, otherwise: bb5]; // scope 0 at $DIR/matches_reduce_branches.rs:6:5: 8:6 + } + + bb4: { + _0 = const (); // scope 0 at $DIR/matches_reduce_branches.rs:6:5: 8:6 + // ty::Const + // + ty: () + // + val: Value(Scalar(<ZST>)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:6:5: 8:6 + // + literal: Const { ty: (), val: Value(Scalar(<ZST>)) } + goto -> bb5; // scope 0 at $DIR/matches_reduce_branches.rs:6:5: 8:6 + } + + bb5: { + StorageDead(_2); // scope 0 at $DIR/matches_reduce_branches.rs:9:1: 9:2 + return; // scope 0 at $DIR/matches_reduce_branches.rs:9:2: 9:2 + } + } + diff --git a/src/test/mir-opt/matches_reduce_branches.foo.MatchBranchSimplification.diff.64bit b/src/test/mir-opt/matches_reduce_branches.foo.MatchBranchSimplification.diff.64bit new file mode 100644 index 00000000000..3eb5b01fbf4 --- /dev/null +++ b/src/test/mir-opt/matches_reduce_branches.foo.MatchBranchSimplification.diff.64bit @@ -0,0 +1,66 @@ +- // MIR for `foo` before MatchBranchSimplification ++ // MIR for `foo` after MatchBranchSimplification + + fn foo(_1: std::option::Option<()>) -> () { + debug bar => _1; // in scope 0 at $DIR/matches_reduce_branches.rs:5:8: 5:11 + let mut _0: (); // return place in scope 0 at $DIR/matches_reduce_branches.rs:5:25: 5:25 + let mut _2: bool; // in scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + let mut _3: isize; // in scope 0 at $DIR/matches_reduce_branches.rs:6:22: 6:26 + + bb0: { + StorageLive(_2); // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + _3 = discriminant(_1); // scope 0 at $DIR/matches_reduce_branches.rs:6:22: 6:26 +- switchInt(move _3) -> [0_isize: bb2, otherwise: bb1]; // scope 0 at $DIR/matches_reduce_branches.rs:6:22: 6:26 ++ _2 = Eq(_3, const 0_isize); // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL ++ // ty::Const ++ // + ty: isize ++ // + val: Value(Scalar(0x0000000000000000)) ++ // mir::Constant ++ // + span: $DIR/matches_reduce_branches.rs:1:1: 1:1 ++ // + literal: Const { ty: isize, val: Value(Scalar(0x0000000000000000)) } ++ goto -> bb3; // scope 0 at $DIR/matches_reduce_branches.rs:6:22: 6:26 + } + + bb1: { + _2 = const false; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x00)) + // mir::Constant + // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL + // + literal: Const { ty: bool, val: Value(Scalar(0x00)) } + goto -> bb3; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + } + + bb2: { + _2 = const true; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + // ty::Const + // + ty: bool + // + val: Value(Scalar(0x01)) + // mir::Constant + // + span: $SRC_DIR/core/src/macros/mod.rs:LL:COL + // + literal: Const { ty: bool, val: Value(Scalar(0x01)) } + goto -> bb3; // scope 0 at $SRC_DIR/core/src/macros/mod.rs:LL:COL + } + + bb3: { + switchInt(_2) -> [false: bb4, otherwise: bb5]; // scope 0 at $DIR/matches_reduce_branches.rs:6:5: 8:6 + } + + bb4: { + _0 = const (); // scope 0 at $DIR/matches_reduce_branches.rs:6:5: 8:6 + // ty::Const + // + ty: () + // + val: Value(Scalar(<ZST>)) + // mir::Constant + // + span: $DIR/matches_reduce_branches.rs:6:5: 8:6 + // + literal: Const { ty: (), val: Value(Scalar(<ZST>)) } + goto -> bb5; // scope 0 at $DIR/matches_reduce_branches.rs:6:5: 8:6 + } + + bb5: { + StorageDead(_2); // scope 0 at $DIR/matches_reduce_branches.rs:9:1: 9:2 + return; // scope 0 at $DIR/matches_reduce_branches.rs:9:2: 9:2 + } + } + diff --git a/src/test/mir-opt/matches_reduce_branches.rs b/src/test/mir-opt/matches_reduce_branches.rs new file mode 100644 index 00000000000..ebc88d2fbd1 --- /dev/null +++ b/src/test/mir-opt/matches_reduce_branches.rs @@ -0,0 +1,42 @@ +// EMIT_MIR_FOR_EACH_BIT_WIDTH +// EMIT_MIR matches_reduce_branches.foo.MatchBranchSimplification.diff +// EMIT_MIR matches_reduce_branches.bar.MatchBranchSimplification.diff + +fn foo(bar: Option<()>) { + if matches!(bar, None) { + () + } +} + +fn bar(i: i32) -> (bool, bool, bool, bool) { + let a; + let b; + let c; + let d; + + match i { + 7 => { + a = false; + b = true; + c = false; + d = true; + () + } + _ => { + a = true; + b = false; + c = false; + d = true; + () + } + }; + + (a, b, c, d) +} + + +fn main() { + let _ = foo(None); + let _ = foo(Some(())); + let _ = bar(0); +} diff --git a/src/test/mir-opt/matches_u8.exhaustive_match.MatchBranchSimplification.diff.32bit b/src/test/mir-opt/matches_u8.exhaustive_match.MatchBranchSimplification.diff.32bit new file mode 100644 index 00000000000..c41bd999dc9 --- /dev/null +++ b/src/test/mir-opt/matches_u8.exhaustive_match.MatchBranchSimplification.diff.32bit @@ -0,0 +1,40 @@ +- // MIR for `exhaustive_match` before MatchBranchSimplification ++ // MIR for `exhaustive_match` after MatchBranchSimplification + + fn exhaustive_match(_1: E) -> u8 { + debug e => _1; // in scope 0 at $DIR/matches_u8.rs:11:25: 11:26 + let mut _0: u8; // return place in scope 0 at $DIR/matches_u8.rs:11:34: 11:36 + let mut _2: isize; // in scope 0 at $DIR/matches_u8.rs:13:9: 13:13 + + bb0: { + _2 = discriminant(_1); // scope 0 at $DIR/matches_u8.rs:13:9: 13:13 + switchInt(move _2) -> [0_isize: bb2, otherwise: bb1]; // scope 0 at $DIR/matches_u8.rs:13:9: 13:13 + } + + bb1: { + _0 = const 1_u8; // scope 0 at $DIR/matches_u8.rs:14:17: 14:18 + // ty::Const + // + ty: u8 + // + val: Value(Scalar(0x01)) + // mir::Constant + // + span: $DIR/matches_u8.rs:14:17: 14:18 + // + literal: Const { ty: u8, val: Value(Scalar(0x01)) } + goto -> bb3; // scope 0 at $DIR/matches_u8.rs:12:5: 15:6 + } + + bb2: { + _0 = const 0_u8; // scope 0 at $DIR/matches_u8.rs:13:17: 13:18 + // ty::Const + // + ty: u8 + // + val: Value(Scalar(0x00)) + // mir::Constant + // + span: $DIR/matches_u8.rs:13:17: 13:18 + // + literal: Const { ty: u8, val: Value(Scalar(0x00)) } + goto -> bb3; // scope 0 at $DIR/matches_u8.rs:12:5: 15:6 + } + + bb3: { + return; // scope 0 at $DIR/matches_u8.rs:16:2: 16:2 + } + } + diff --git a/src/test/mir-opt/matches_u8.exhaustive_match.MatchBranchSimplification.diff.64bit b/src/test/mir-opt/matches_u8.exhaustive_match.MatchBranchSimplification.diff.64bit new file mode 100644 index 00000000000..c41bd999dc9 --- /dev/null +++ b/src/test/mir-opt/matches_u8.exhaustive_match.MatchBranchSimplification.diff.64bit @@ -0,0 +1,40 @@ +- // MIR for `exhaustive_match` before MatchBranchSimplification ++ // MIR for `exhaustive_match` after MatchBranchSimplification + + fn exhaustive_match(_1: E) -> u8 { + debug e => _1; // in scope 0 at $DIR/matches_u8.rs:11:25: 11:26 + let mut _0: u8; // return place in scope 0 at $DIR/matches_u8.rs:11:34: 11:36 + let mut _2: isize; // in scope 0 at $DIR/matches_u8.rs:13:9: 13:13 + + bb0: { + _2 = discriminant(_1); // scope 0 at $DIR/matches_u8.rs:13:9: 13:13 + switchInt(move _2) -> [0_isize: bb2, otherwise: bb1]; // scope 0 at $DIR/matches_u8.rs:13:9: 13:13 + } + + bb1: { + _0 = const 1_u8; // scope 0 at $DIR/matches_u8.rs:14:17: 14:18 + // ty::Const + // + ty: u8 + // + val: Value(Scalar(0x01)) + // mir::Constant + // + span: $DIR/matches_u8.rs:14:17: 14:18 + // + literal: Const { ty: u8, val: Value(Scalar(0x01)) } + goto -> bb3; // scope 0 at $DIR/matches_u8.rs:12:5: 15:6 + } + + bb2: { + _0 = const 0_u8; // scope 0 at $DIR/matches_u8.rs:13:17: 13:18 + // ty::Const + // + ty: u8 + // + val: Value(Scalar(0x00)) + // mir::Constant + // + span: $DIR/matches_u8.rs:13:17: 13:18 + // + literal: Const { ty: u8, val: Value(Scalar(0x00)) } + goto -> bb3; // scope 0 at $DIR/matches_u8.rs:12:5: 15:6 + } + + bb3: { + return; // scope 0 at $DIR/matches_u8.rs:16:2: 16:2 + } + } + diff --git a/src/test/mir-opt/matches_u8.exhaustive_match_i8.MatchBranchSimplification.diff.32bit b/src/test/mir-opt/matches_u8.exhaustive_match_i8.MatchBranchSimplification.diff.32bit new file mode 100644 index 00000000000..2c4bbc8095e --- /dev/null +++ b/src/test/mir-opt/matches_u8.exhaustive_match_i8.MatchBranchSimplification.diff.32bit @@ -0,0 +1,40 @@ +- // MIR for `exhaustive_match_i8` before MatchBranchSimplification ++ // MIR for `exhaustive_match_i8` after MatchBranchSimplification + + fn exhaustive_match_i8(_1: E) -> i8 { + debug e => _1; // in scope 0 at $DIR/matches_u8.rs:19:28: 19:29 + let mut _0: i8; // return place in scope 0 at $DIR/matches_u8.rs:19:37: 19:39 + let mut _2: isize; // in scope 0 at $DIR/matches_u8.rs:21:9: 21:13 + + bb0: { + _2 = discriminant(_1); // scope 0 at $DIR/matches_u8.rs:21:9: 21:13 + switchInt(move _2) -> [0_isize: bb2, otherwise: bb1]; // scope 0 at $DIR/matches_u8.rs:21:9: 21:13 + } + + bb1: { + _0 = const 1_i8; // scope 0 at $DIR/matches_u8.rs:22:17: 22:18 + // ty::Const + // + ty: i8 + // + val: Value(Scalar(0x01)) + // mir::Constant + // + span: $DIR/matches_u8.rs:22:17: 22:18 + // + literal: Const { ty: i8, val: Value(Scalar(0x01)) } + goto -> bb3; // scope 0 at $DIR/matches_u8.rs:20:5: 23:6 + } + + bb2: { + _0 = const 0_i8; // scope 0 at $DIR/matches_u8.rs:21:17: 21:18 + // ty::Const + // + ty: i8 + // + val: Value(Scalar(0x00)) + // mir::Constant + // + span: $DIR/matches_u8.rs:21:17: 21:18 + // + literal: Const { ty: i8, val: Value(Scalar(0x00)) } + goto -> bb3; // scope 0 at $DIR/matches_u8.rs:20:5: 23:6 + } + + bb3: { + return; // scope 0 at $DIR/matches_u8.rs:24:2: 24:2 + } + } + diff --git a/src/test/mir-opt/matches_u8.exhaustive_match_i8.MatchBranchSimplification.diff.64bit b/src/test/mir-opt/matches_u8.exhaustive_match_i8.MatchBranchSimplification.diff.64bit new file mode 100644 index 00000000000..2c4bbc8095e --- /dev/null +++ b/src/test/mir-opt/matches_u8.exhaustive_match_i8.MatchBranchSimplification.diff.64bit @@ -0,0 +1,40 @@ +- // MIR for `exhaustive_match_i8` before MatchBranchSimplification ++ // MIR for `exhaustive_match_i8` after MatchBranchSimplification + + fn exhaustive_match_i8(_1: E) -> i8 { + debug e => _1; // in scope 0 at $DIR/matches_u8.rs:19:28: 19:29 + let mut _0: i8; // return place in scope 0 at $DIR/matches_u8.rs:19:37: 19:39 + let mut _2: isize; // in scope 0 at $DIR/matches_u8.rs:21:9: 21:13 + + bb0: { + _2 = discriminant(_1); // scope 0 at $DIR/matches_u8.rs:21:9: 21:13 + switchInt(move _2) -> [0_isize: bb2, otherwise: bb1]; // scope 0 at $DIR/matches_u8.rs:21:9: 21:13 + } + + bb1: { + _0 = const 1_i8; // scope 0 at $DIR/matches_u8.rs:22:17: 22:18 + // ty::Const + // + ty: i8 + // + val: Value(Scalar(0x01)) + // mir::Constant + // + span: $DIR/matches_u8.rs:22:17: 22:18 + // + literal: Const { ty: i8, val: Value(Scalar(0x01)) } + goto -> bb3; // scope 0 at $DIR/matches_u8.rs:20:5: 23:6 + } + + bb2: { + _0 = const 0_i8; // scope 0 at $DIR/matches_u8.rs:21:17: 21:18 + // ty::Const + // + ty: i8 + // + val: Value(Scalar(0x00)) + // mir::Constant + // + span: $DIR/matches_u8.rs:21:17: 21:18 + // + literal: Const { ty: i8, val: Value(Scalar(0x00)) } + goto -> bb3; // scope 0 at $DIR/matches_u8.rs:20:5: 23:6 + } + + bb3: { + return; // scope 0 at $DIR/matches_u8.rs:24:2: 24:2 + } + } + diff --git a/src/test/mir-opt/matches_u8.rs b/src/test/mir-opt/matches_u8.rs new file mode 100644 index 00000000000..78373be48b6 --- /dev/null +++ b/src/test/mir-opt/matches_u8.rs @@ -0,0 +1,32 @@ +// EMIT_MIR_FOR_EACH_BIT_WIDTH +// EMIT_MIR matches_u8.exhaustive_match.MatchBranchSimplification.diff +// EMIT_MIR matches_u8.exhaustive_match_i8.MatchBranchSimplification.diff + +pub enum E { + A, + B, +} + +#[no_mangle] +pub fn exhaustive_match(e: E) -> u8 { + match e { + E::A => 0, + E::B => 1, + } +} + +#[no_mangle] +pub fn exhaustive_match_i8(e: E) -> i8 { + match e { + E::A => 0, + E::B => 1, + } +} + +fn main() { + assert_eq!(exhaustive_match(E::A), 0); + assert_eq!(exhaustive_match(E::B), 1); + + assert_eq!(exhaustive_match_i8(E::A), 0); + assert_eq!(exhaustive_match_i8(E::B), 1); +} diff --git a/src/test/run-make-fulldeps/instrument-coverage/Makefile b/src/test/run-make-fulldeps/instrument-coverage/Makefile index df47305b547..4392cfec080 100644 --- a/src/test/run-make-fulldeps/instrument-coverage/Makefile +++ b/src/test/run-make-fulldeps/instrument-coverage/Makefile @@ -3,55 +3,101 @@ # FIXME(richkadel): Debug the following problem, and reenable on Windows (by # removing the `# ignore-msvc` directive above). The current implementation -# generates a segfault when running the instrumented `main` executable, -# after the `main` program code executes, but before the process terminates. -# This most likely points to a problem generating the LLVM "main.profraw" +# generates a segfault when running the instrumented `testprog` executable, +# after the `main()` function completes, but before the process terminates. +# This most likely points to a problem generating the LLVM "testprog.profraw" # file. -include ../tools.mk +UNAME = $(shell uname) + +ifeq ($(UNAME),Darwin) + INSTR_PROF_DATA_SUFFIX=,regular,live_support + DATA_SECTION_PREFIX=__DATA, + LLVM_COV_SECTION_PREFIX=__LLVM_COV, +else + INSTR_PROF_DATA_SUFFIX= + DATA_SECTION_PREFIX= + LLVM_COV_SECTION_PREFIX= +endif + # This test makes sure that LLVM coverage maps are genereated in LLVM IR. COMMON_FLAGS=-Zinstrument-coverage all: # Compile the test program with instrumentation, and also generate LLVM IR - $(RUSTC) $(COMMON_FLAGS) main.rs + $(RUSTC) $(COMMON_FLAGS) testprog.rs \ + --emit=link,llvm-ir + + # check the LLVM IR +ifdef IS_WIN32 + cat "$(TMPDIR)"/testprog.ll | "$(LLVM_FILECHECK)" filecheck-patterns.txt \ + -check-prefixes=CHECK,WIN32 \ + -DPRIVATE_GLOBAL="internal global" \ + -DINSTR_PROF_DATA=".lprfd$$M" \ + -DINSTR_PROF_NAME=".lprfn$$M" \ + -DINSTR_PROF_CNTS=".lprfc$$M" \ + -DINSTR_PROF_VALS=".lprfv$$M" \ + -DINSTR_PROF_VNODES=".lprfnd$$M" \ + -DINSTR_PROF_COVMAP=".lcovmap$$M" \ + -DINSTR_PROF_ORDERFILE=".lorderfile$$M" +else + cat "$(TMPDIR)"/testprog.ll | "$(LLVM_FILECHECK)" filecheck-patterns.txt \ + -check-prefixes=CHECK \ + -DPRIVATE_GLOBAL="private global" \ + -DINSTR_PROF_DATA="$(DATA_SECTION_PREFIX)__llvm_prf_data$(INSTR_PROF_DATA_SUFFIX)" \ + -DINSTR_PROF_NAME="$(DATA_SECTION_PREFIX)__llvm_prf_names" \ + -DINSTR_PROF_CNTS="$(DATA_SECTION_PREFIX)__llvm_prf_cnts" \ + -DINSTR_PROF_VALS="$(DATA_SECTION_PREFIX)__llvm_prf_vals" \ + -DINSTR_PROF_VNODES="$(DATA_SECTION_PREFIX)__llvm_prf_vnds" \ + -DINSTR_PROF_COVMAP="$(LLVM_COV_SECTION_PREFIX)__llvm_covmap" \ + -DINSTR_PROF_ORDERFILE="$(DATA_SECTION_PREFIX)__llvm_orderfile" +endif # Run it in order to generate some profiling data, # with `LLVM_PROFILE_FILE=<profdata_file>` environment variable set to # output the coverage stats for this run. - LLVM_PROFILE_FILE="$(TMPDIR)"/main.profraw \ - $(call RUN,main) + LLVM_PROFILE_FILE="$(TMPDIR)"/testprog.profraw \ + $(call RUN,testprog) # Postprocess the profiling data so it can be used by the llvm-cov tool "$(LLVM_BIN_DIR)"/llvm-profdata merge --sparse \ - "$(TMPDIR)"/main.profraw \ - -o "$(TMPDIR)"/main.profdata + "$(TMPDIR)"/testprog.profraw \ + -o "$(TMPDIR)"/testprog.profdata # Generate a coverage report using `llvm-cov show`. The output ordering # can be non-deterministic, so ignore the return status. If the test fails # when comparing the JSON `export`, the `show` output may be useful when # debugging. "$(LLVM_BIN_DIR)"/llvm-cov show \ - --Xdemangler="$(RUST_DEMANGLER)" \ - --show-line-counts-or-regions \ - --instr-profile="$(TMPDIR)"/main.profdata \ - $(call BIN,"$(TMPDIR)"/main) \ + --Xdemangler="$(RUST_DEMANGLER)" \ + --show-line-counts-or-regions \ + --instr-profile="$(TMPDIR)"/testprog.profdata \ + $(call BIN,"$(TMPDIR)"/testprog) \ > "$(TMPDIR)"/actual_show_coverage.txt +ifdef RUSTC_BLESS_TEST + cp "$(TMPDIR)"/actual_show_coverage.txt typical_show_coverage.txt +else # Compare the show coverage output $(DIFF) typical_show_coverage.txt "$(TMPDIR)"/actual_show_coverage.txt || \ - >&2 echo 'diff failed for `llvm-cov show` (might not be an error)' + >&2 echo 'diff failed for `llvm-cov show` (might not be an error)' +endif # Generate a coverage report in JSON, using `llvm-cov export`, and fail if # there are differences from the expected output. "$(LLVM_BIN_DIR)"/llvm-cov export \ - --summary-only \ - --instr-profile="$(TMPDIR)"/main.profdata \ - $(call BIN,"$(TMPDIR)"/main) \ + --summary-only \ + --instr-profile="$(TMPDIR)"/testprog.profdata \ + $(call BIN,"$(TMPDIR)"/testprog) \ | "$(PYTHON)" prettify_json.py \ > "$(TMPDIR)"/actual_export_coverage.json +ifdef RUSTC_BLESS_TEST + cp "$(TMPDIR)"/actual_export_coverage.json expected_export_coverage.json +else # Check that the exported JSON coverage data matches what we expect $(DIFF) expected_export_coverage.json "$(TMPDIR)"/actual_export_coverage.json +endif diff --git a/src/test/run-make-fulldeps/instrument-coverage/expected_export_coverage.json b/src/test/run-make-fulldeps/instrument-coverage/expected_export_coverage.json index 9d739a89114..5881cf4b7db 100644 --- a/src/test/run-make-fulldeps/instrument-coverage/expected_export_coverage.json +++ b/src/test/run-make-fulldeps/instrument-coverage/expected_export_coverage.json @@ -3,7 +3,7 @@ { "files": [ { - "filename": "main.rs", + "filename": "testprog.rs", "summary": { "functions": { "count": 7, diff --git a/src/test/run-make-fulldeps/instrument-coverage/filecheck-patterns.txt b/src/test/run-make-fulldeps/instrument-coverage/filecheck-patterns.txt new file mode 100644 index 00000000000..5a7cc9a1882 --- /dev/null +++ b/src/test/run-make-fulldeps/instrument-coverage/filecheck-patterns.txt @@ -0,0 +1,51 @@ +# Check for metadata, variables, declarations, and function definitions injected +# into LLVM IR when compiling with -Zinstrument-coverage. + +WIN32: $__llvm_profile_runtime_user = comdat any + +CHECK: @__llvm_coverage_mapping = internal constant +CHECK-SAME: section "[[INSTR_PROF_COVMAP]]", align 8 + +WIN32: @__llvm_profile_runtime = external global i32 + +CHECK: @__profc__R{{[a-zA-Z0-9_]+}}testprog14will_be_called = [[PRIVATE_GLOBAL]] +CHECK-SAME: section "[[INSTR_PROF_CNTS]]", align 8 + +CHECK: @__profd__R{{[a-zA-Z0-9_]+}}testprog14will_be_called = [[PRIVATE_GLOBAL]] +CHECK-SAME: @__profc__R{{[a-zA-Z0-9_]+}}testprog14will_be_called, +CHECK-SAME: ()* @_R{{[a-zA-Z0-9_]+}}testprog14will_be_called to i8*), +CHECK-SAME: section "[[INSTR_PROF_DATA]]", align 8 + +CHECK: @__profc__R{{[a-zA-Z0-9_]+}}testprog4main = [[PRIVATE_GLOBAL]] +CHECK-SAME: section "[[INSTR_PROF_CNTS]]", align 8 + +CHECK: @__profd__R{{[a-zA-Z0-9_]+}}testprog4main = [[PRIVATE_GLOBAL]] +CHECK-SAME: @__profc__R{{[a-zA-Z0-9_]+}}testprog4main, +CHECK-SAME: ()* @_R{{[a-zA-Z0-9_]+}}testprog4main to i8*), +CHECK-SAME: section "[[INSTR_PROF_DATA]]", align 8 + +CHECK: @__llvm_prf_nm = private constant +CHECK-SAME: section "[[INSTR_PROF_NAME]]", align 1 + +CHECK: @llvm.used = appending global +CHECK-SAME: i8* bitcast ({ {{.*}} }* @__llvm_coverage_mapping to i8*) +WIN32-SAME: i8* bitcast (i32 ()* @__llvm_profile_runtime_user to i8*) +CHECK-SAME: i8* bitcast ({ {{.*}} }* @__profd__R{{[a-zA-Z0-9_]*}}testprog4main to i8*) +CHECK-SAME: i8* getelementptr inbounds ({{.*}}* @__llvm_prf_nm, i32 0, i32 0) +CHECK-SAME: section "llvm.metadata" + +CHECK: define hidden { {{.*}} } @_R{{[a-zA-Z0-9_]+}}testprog14will_be_called() unnamed_addr #{{[0-9]+}} { +CHECK-NEXT: start: +CHECK-NOT: bb{{[0-9]+}}: +CHECK: %pgocount = load i64, i64* getelementptr inbounds +CHECK-SAME: * @__profc__R{{[a-zA-Z0-9_]+}}testprog14will_be_called, + +CHECK: declare void @llvm.instrprof.increment(i8*, i64, i32, i32) #[[LLVM_INSTRPROF_INCREMENT_ATTR:[0-9]+]] + +WIN32: define linkonce_odr hidden i32 @__llvm_profile_runtime_user() #[[LLVM_PROFILE_RUNTIME_USER_ATTR:[0-9]+]] comdat { +WIN32-NEXT: %1 = load i32, i32* @__llvm_profile_runtime +WIN32-NEXT: ret i32 %1 +WIN32-NEXT: } + +CHECK: attributes #[[LLVM_INSTRPROF_INCREMENT_ATTR]] = { nounwind } +WIN32: attributes #[[LLVM_PROFILE_RUNTIME_USER_ATTR]] = { noinline } \ No newline at end of file diff --git a/src/test/run-make-fulldeps/instrument-coverage/main.rs b/src/test/run-make-fulldeps/instrument-coverage/testprog.rs index 358c25677ae..358c25677ae 100644 --- a/src/test/run-make-fulldeps/instrument-coverage/main.rs +++ b/src/test/run-make-fulldeps/instrument-coverage/testprog.rs diff --git a/src/test/run-make-fulldeps/instrument-coverage/typical_show_coverage.txt b/src/test/run-make-fulldeps/instrument-coverage/typical_show_coverage.txt index 9c593d0809d..ae123afff04 100644 --- a/src/test/run-make-fulldeps/instrument-coverage/typical_show_coverage.txt +++ b/src/test/run-make-fulldeps/instrument-coverage/typical_show_coverage.txt @@ -25,14 +25,14 @@ 25| 2| } 26| 2|} ------------------ - | main[317d481089b8c8fe]::wrap_with::<main[317d481089b8c8fe]::main::{closure#0}, &str>: + | testprog[317d481089b8c8fe]::wrap_with::<testprog[317d481089b8c8fe]::main::{closure#0}, &str>: | 22| 1|{ | 23| 1| if should_wrap { | 24| 1| wrapper(&inner) | 25| 1| } | 26| 1|} ------------------ - | main[317d481089b8c8fe]::wrap_with::<main[317d481089b8c8fe]::main::{closure#1}, &str>: + | testprog[317d481089b8c8fe]::wrap_with::<testprog[317d481089b8c8fe]::main::{closure#1}, &str>: | 22| 1|{ | 23| 1| if should_wrap { | 24| 1| wrapper(&inner) diff --git a/src/test/run-make-fulldeps/sanitizer-cdylib-link/Makefile b/src/test/run-make-fulldeps/sanitizer-cdylib-link/Makefile index b11d4c4cab7..e72fe5a5091 100644 --- a/src/test/run-make-fulldeps/sanitizer-cdylib-link/Makefile +++ b/src/test/run-make-fulldeps/sanitizer-cdylib-link/Makefile @@ -1,6 +1,5 @@ # needs-sanitizer-support # needs-sanitizer-address -# only-linux -include ../tools.mk diff --git a/src/test/run-make-fulldeps/sanitizer-dylib-link/Makefile b/src/test/run-make-fulldeps/sanitizer-dylib-link/Makefile index c2ebd2a6d8c..b9a3f829555 100644 --- a/src/test/run-make-fulldeps/sanitizer-dylib-link/Makefile +++ b/src/test/run-make-fulldeps/sanitizer-dylib-link/Makefile @@ -1,6 +1,5 @@ # needs-sanitizer-support # needs-sanitizer-address -# only-linux -include ../tools.mk diff --git a/src/test/run-make-fulldeps/sanitizer-staticlib-link/Makefile b/src/test/run-make-fulldeps/sanitizer-staticlib-link/Makefile index 5ceff16471c..4894f65b114 100644 --- a/src/test/run-make-fulldeps/sanitizer-staticlib-link/Makefile +++ b/src/test/run-make-fulldeps/sanitizer-staticlib-link/Makefile @@ -1,6 +1,5 @@ # needs-sanitizer-support # needs-sanitizer-address -# only-linux -include ../tools.mk diff --git a/src/test/run-make-fulldeps/save-analysis/foo.rs b/src/test/run-make-fulldeps/save-analysis/foo.rs index 789ab686e3f..483eeed0b39 100644 --- a/src/test/run-make-fulldeps/save-analysis/foo.rs +++ b/src/test/run-make-fulldeps/save-analysis/foo.rs @@ -1,4 +1,4 @@ -#![ crate_name = "test" ] +#![crate_name = "test"] #![feature(box_syntax)] #![feature(rustc_private)] #![feature(associated_type_defaults)] @@ -11,11 +11,10 @@ extern crate krate2; extern crate krate2 as krate3; use rustc_graphviz::RenderOption; -use std::collections::{HashMap,HashSet}; use std::cell::RefCell; +use std::collections::{HashMap, HashSet}; use std::io::Write; - use sub::sub2 as msalias; use sub::sub2; use sub::sub2::nested_struct as sub_struct; @@ -32,7 +31,7 @@ static bob: Option<rustc_graphviz::RenderOption> = None; // buglink test - see issue #1337. fn test_alias<I: Iterator>(i: Option<<I as Iterator>::Item>) { - let s = sub_struct{ field2: 45u32, }; + let s = sub_struct { field2: 45u32 }; // import tests fn foo(x: &Write) {} @@ -82,7 +81,7 @@ mod sub { pub enum nested_enum { Nest2 = 2, - Nest3 = 3 + Nest3 = 3, } } } @@ -103,7 +102,9 @@ struct some_fields { type SF = some_fields; trait SuperTrait { - fn qux(&self) { panic!(); } + fn qux(&self) { + panic!(); + } } trait SomeTrait: SuperTrait { @@ -131,8 +132,7 @@ impl SomeTrait for some_fields { } } -impl SuperTrait for some_fields { -} +impl SuperTrait for some_fields {} impl SubTrait for some_fields {} @@ -145,17 +145,14 @@ impl some_fields { 42 } - fn align_to<T>(&mut self) { - - } + fn align_to<T>(&mut self) {} fn test(&mut self) { self.align_to::<bool>(); } } -impl SuperTrait for nofields { -} +impl SuperTrait for nofields {} impl SomeTrait for nofields { fn Method(&self, x: u32) -> u32 { self.Method(x); @@ -181,59 +178,70 @@ enum SomeEnum<'a> { Ints(isize, isize), Floats(f64, f64), Strings(&'a str, &'a str, &'a str), - MyTypes(MyType, MyType) + MyTypes(MyType, MyType), } #[derive(Copy, Clone)] enum SomeOtherEnum { SomeConst1, SomeConst2, - SomeConst3 + SomeConst3, } enum SomeStructEnum { - EnumStruct{a:isize, b:isize}, - EnumStruct2{f1:MyType, f2:MyType}, - EnumStruct3{f1:MyType, f2:MyType, f3:SomeEnum<'static>} + EnumStruct { a: isize, b: isize }, + EnumStruct2 { f1: MyType, f2: MyType }, + EnumStruct3 { f1: MyType, f2: MyType, f3: SomeEnum<'static> }, } fn matchSomeEnum(val: SomeEnum) { match val { - SomeEnum::Ints(int1, int2) => { println(&(int1+int2).to_string()); } - SomeEnum::Floats(float1, float2) => { println(&(float2*float1).to_string()); } - SomeEnum::Strings(.., s3) => { println(s3); } - SomeEnum::MyTypes(mt1, mt2) => { println(&(mt1.field1 - mt2.field1).to_string()); } + SomeEnum::Ints(int1, int2) => { + println(&(int1 + int2).to_string()); + } + SomeEnum::Floats(float1, float2) => { + println(&(float2 * float1).to_string()); + } + SomeEnum::Strings(.., s3) => { + println(s3); + } + SomeEnum::MyTypes(mt1, mt2) => { + println(&(mt1.field1 - mt2.field1).to_string()); + } } } fn matchSomeStructEnum(se: SomeStructEnum) { match se { - SomeStructEnum::EnumStruct{a:a, ..} => println(&a.to_string()), - SomeStructEnum::EnumStruct2{f1:f1, f2:f_2} => println(&f_2.field1.to_string()), - SomeStructEnum::EnumStruct3{f1, ..} => println(&f1.field1.to_string()), + SomeStructEnum::EnumStruct { a: a, .. } => println(&a.to_string()), + SomeStructEnum::EnumStruct2 { f1: f1, f2: f_2 } => println(&f_2.field1.to_string()), + SomeStructEnum::EnumStruct3 { f1, .. } => println(&f1.field1.to_string()), } } - fn matchSomeStructEnum2(se: SomeStructEnum) { use SomeStructEnum::*; match se { - EnumStruct{a: ref aaa, ..} => println(&aaa.to_string()), - EnumStruct2{f1, f2: f2} => println(&f1.field1.to_string()), - EnumStruct3{f1, f3: SomeEnum::Ints(..), f2} => println(&f1.field1.to_string()), - _ => {}, + EnumStruct { a: ref aaa, .. } => println(&aaa.to_string()), + EnumStruct2 { f1, f2: f2 } => println(&f1.field1.to_string()), + EnumStruct3 { f1, f3: SomeEnum::Ints(..), f2 } => println(&f1.field1.to_string()), + _ => {} } } fn matchSomeOtherEnum(val: SomeOtherEnum) { use SomeOtherEnum::{SomeConst2, SomeConst3}; match val { - SomeOtherEnum::SomeConst1 => { println("I'm const1."); } - SomeConst2 | SomeConst3 => { println("I'm const2 or const3."); } + SomeOtherEnum::SomeConst1 => { + println("I'm const1."); + } + SomeConst2 | SomeConst3 => { + println("I'm const2 or const3."); + } } } -fn hello<X: SomeTrait>((z, a) : (u32, String), ex: X) { +fn hello<X: SomeTrait>((z, a): (u32, String), ex: X) { SameDir2::hello(43); println(&yy.to_string()); @@ -248,8 +256,8 @@ fn hello<X: SomeTrait>((z, a) : (u32, String), ex: X) { let x = 32.0f32; let _ = (x + ((x * x) + 1.0).sqrt()).ln(); - let s: Box<SomeTrait> = box some_fields {field1: 43}; - let s2: Box<some_fields> = box some_fields {field1: 43}; + let s: Box<SomeTrait> = box some_fields { field1: 43 }; + let s2: Box<some_fields> = box some_fields { field1: 43 }; let s3 = box nofields; s.Method(43); @@ -302,8 +310,9 @@ mod macro_use_test { } } -fn main() { // foo - let s = box some_fields {field1: 43}; +fn main() { + // foo + let s = box some_fields { field1: 43 }; hello((43, "a".to_string()), *s); sub::sub2::hello(); sub2::sub3::hello(); @@ -324,26 +333,24 @@ fn main() { // foo let vs = variable_str!(32); let mut candidates: RefCell<HashMap<&'static str, &'static str>> = RefCell::new(HashMap::new()); - let _ = blah { - used_link_args: RefCell::new([]), - }; + let _ = blah { used_link_args: RefCell::new([]) }; let s1 = nofields; - let s2 = SF { field1: 55}; - let s3: some_fields = some_fields{ field1: 55}; - let s4: msalias::nested_struct = sub::sub2::nested_struct{ field2: 55}; - let s4: msalias::nested_struct = sub2::nested_struct{ field2: 55}; + let s2 = SF { field1: 55 }; + let s3: some_fields = some_fields { field1: 55 }; + let s4: msalias::nested_struct = sub::sub2::nested_struct { field2: 55 }; + let s4: msalias::nested_struct = sub2::nested_struct { field2: 55 }; println(&s2.field1.to_string()); - let s5: MyType = box some_fields{ field1: 55}; - let s = SameDir::SameStruct{name: "Bob".to_string()}; - let s = SubDir::SubStruct{name:"Bob".to_string()}; + let s5: MyType = box some_fields { field1: 55 }; + let s = SameDir::SameStruct { name: "Bob".to_string() }; + let s = SubDir::SubStruct { name: "Bob".to_string() }; let s6: SomeEnum = SomeEnum::MyTypes(box s2.clone(), s5); let s7: SomeEnum = SomeEnum::Strings("one", "two", "three"); matchSomeEnum(s6); matchSomeEnum(s7); let s8: SomeOtherEnum = SomeOtherEnum::SomeConst2; matchSomeOtherEnum(s8); - let s9: SomeStructEnum = SomeStructEnum::EnumStruct2{ f1: box some_fields{ field1:10 }, - f2: box s2 }; + let s9: SomeStructEnum = + SomeStructEnum::EnumStruct2 { f1: box some_fields { field1: 10 }, f2: box s2 }; matchSomeStructEnum(s9); for x in &vec![1, 2, 3] { @@ -404,8 +411,7 @@ impl<'a> Pattern<'a> for CharEqPattern { struct CharSearcher<'a>(<CharEqPattern as Pattern<'a>>::Searcher); -pub trait Error { -} +pub trait Error {} impl Error + 'static { pub fn is<T: Error + 'static>(&self) -> bool { @@ -419,8 +425,7 @@ impl Error + 'static + Send { } } extern crate rustc_serialize; -#[derive(Clone, Copy, Hash, RustcEncodable, RustcDecodable, - PartialEq, Eq, PartialOrd, Ord, Debug, Default)] +#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord, Debug, Default)] struct AllDerives(i32); fn test_format_args() { @@ -433,9 +438,8 @@ fn test_format_args() { print!("x is {}, y is {1}, name is {n}", x, y, n = name); } - union TestUnion { - f1: u32 + f1: u32, } struct FrameBuffer; @@ -454,5 +458,5 @@ trait Foo { type Bar = FrameBuffer; } -#[doc(include="extra-docs.md")] +#[doc(include = "extra-docs.md")] struct StructWithDocs; diff --git a/src/test/ui-fulldeps/derive-no-std-not-supported.rs b/src/test/ui-fulldeps/derive-no-std-not-supported.rs deleted file mode 100644 index 1299d82d9c4..00000000000 --- a/src/test/ui-fulldeps/derive-no-std-not-supported.rs +++ /dev/null @@ -1,22 +0,0 @@ -// run-pass - -#![allow(dead_code)] -#![feature(rustc_private)] -#![no_std] - -extern crate rustc_serialize; - -#[derive(RustcEncodable)] -struct Bar { - x: u32, -} - -#[derive(RustcDecodable)] -struct Baz { - x: u32, -} - -fn main() { - Bar { x: 0 }; - Baz { x: 0 }; -} diff --git a/src/test/ui-fulldeps/deriving-encodable-decodable-box.rs b/src/test/ui-fulldeps/deriving-encodable-decodable-box.rs index 2b349ae9556..119fa3d6fa8 100644 --- a/src/test/ui-fulldeps/deriving-encodable-decodable-box.rs +++ b/src/test/ui-fulldeps/deriving-encodable-decodable-box.rs @@ -1,16 +1,17 @@ // run-pass #![allow(unused_imports)] - #![feature(box_syntax)] #![feature(rustc_private)] +extern crate rustc_macros; extern crate rustc_serialize; -use rustc_serialize::{Encodable, Decodable}; +use rustc_macros::{Decodable, Encodable}; use rustc_serialize::json; +use rustc_serialize::{Decodable, Encodable}; -#[derive(RustcEncodable, RustcDecodable)] +#[derive(Encodable, Decodable)] struct A { foo: Box<[bool]>, } diff --git a/src/test/ui-fulldeps/deriving-encodable-decodable-cell-refcell.rs b/src/test/ui-fulldeps/deriving-encodable-decodable-cell-refcell.rs index c2aecbdc167..9dedf990f25 100644 --- a/src/test/ui-fulldeps/deriving-encodable-decodable-cell-refcell.rs +++ b/src/test/ui-fulldeps/deriving-encodable-decodable-cell-refcell.rs @@ -3,32 +3,29 @@ #![allow(unused_imports)] // This briefly tests the capability of `Cell` and `RefCell` to implement the // `Encodable` and `Decodable` traits via `#[derive(Encodable, Decodable)]` - - #![feature(rustc_private)] +extern crate rustc_macros; extern crate rustc_serialize; -use std::cell::{Cell, RefCell}; -use rustc_serialize::{Encodable, Decodable}; +use rustc_macros::{Decodable, Encodable}; use rustc_serialize::json; +use rustc_serialize::{Decodable, Encodable}; +use std::cell::{Cell, RefCell}; -#[derive(RustcEncodable, RustcDecodable)] +#[derive(Encodable, Decodable)] struct A { - baz: isize + baz: isize, } -#[derive(RustcEncodable, RustcDecodable)] +#[derive(Encodable, Decodable)] struct B { foo: Cell<bool>, bar: RefCell<A>, } fn main() { - let obj = B { - foo: Cell::new(true), - bar: RefCell::new( A { baz: 2 } ) - }; + let obj = B { foo: Cell::new(true), bar: RefCell::new(A { baz: 2 }) }; let s = json::encode(&obj).unwrap(); let obj2: B = json::decode(&s).unwrap(); assert_eq!(obj.foo.get(), obj2.foo.get()); diff --git a/src/test/ui-fulldeps/deriving-global.rs b/src/test/ui-fulldeps/deriving-global.rs index 5ba34a7af6b..921767af981 100644 --- a/src/test/ui-fulldeps/deriving-global.rs +++ b/src/test/ui-fulldeps/deriving-global.rs @@ -2,33 +2,29 @@ #![feature(rustc_private)] +extern crate rustc_macros; extern crate rustc_serialize; mod submod { + use rustc_macros::{Decodable, Encodable}; + // if any of these are implemented without global calls for any // function calls, then being in a submodule will (correctly) // cause errors about unrecognised module `std` (or `extra`) - #[derive(PartialEq, PartialOrd, Eq, Ord, - Hash, - Clone, - Debug, - RustcEncodable, RustcDecodable)] - enum A { A1(usize), A2(isize) } + #[derive(PartialEq, PartialOrd, Eq, Ord, Hash, Clone, Debug, Encodable, Decodable)] + enum A { + A1(usize), + A2(isize), + } - #[derive(PartialEq, PartialOrd, Eq, Ord, - Hash, - Clone, - Debug, - RustcEncodable, RustcDecodable)] - struct B { x: usize, y: isize } + #[derive(PartialEq, PartialOrd, Eq, Ord, Hash, Clone, Debug, Encodable, Decodable)] + struct B { + x: usize, + y: isize, + } - #[derive(PartialEq, PartialOrd, Eq, Ord, - Hash, - Clone, - Debug, - RustcEncodable, RustcDecodable)] + #[derive(PartialEq, PartialOrd, Eq, Ord, Hash, Clone, Debug, Encodable, Decodable)] struct C(usize, isize); - } pub fn main() {} diff --git a/src/test/ui-fulldeps/deriving-hygiene.rs b/src/test/ui-fulldeps/deriving-hygiene.rs index 85ef217e767..8486b8b6e48 100644 --- a/src/test/ui-fulldeps/deriving-hygiene.rs +++ b/src/test/ui-fulldeps/deriving-hygiene.rs @@ -2,8 +2,11 @@ #![allow(non_upper_case_globals)] #![feature(rustc_private)] +extern crate rustc_macros; extern crate rustc_serialize; +use rustc_macros::{Decodable, Encodable}; + pub const other: u8 = 1; pub const f: u8 = 1; pub const d: u8 = 1; @@ -11,8 +14,7 @@ pub const s: u8 = 1; pub const state: u8 = 1; pub const cmp: u8 = 1; -#[derive(Ord,Eq,PartialOrd,PartialEq,Debug,RustcDecodable,RustcEncodable,Hash)] +#[derive(Ord, Eq, PartialOrd, PartialEq, Debug, Decodable, Encodable, Hash)] struct Foo {} -fn main() { -} +fn main() {} diff --git a/src/test/ui-fulldeps/empty-struct-braces-derive.rs b/src/test/ui-fulldeps/empty-struct-braces-derive.rs index fc85765eea4..6e5eb54629c 100644 --- a/src/test/ui-fulldeps/empty-struct-braces-derive.rs +++ b/src/test/ui-fulldeps/empty-struct-braces-derive.rs @@ -3,18 +3,18 @@ #![feature(rustc_private)] +extern crate rustc_macros; extern crate rustc_serialize; -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, - Default, Debug, RustcEncodable, RustcDecodable)] +use rustc_macros::{Decodable, Encodable}; + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Debug, Encodable, Decodable)] struct S {} -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, - Default, Debug, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Debug, Encodable, Decodable)] struct Z(); -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, - Debug, RustcEncodable, RustcDecodable)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Encodable, Decodable)] enum E { V {}, U, diff --git a/src/test/ui-fulldeps/issue-11881.rs b/src/test/ui-fulldeps/issue-11881.rs index 7b0abba4d16..6d64aeeda7e 100644 --- a/src/test/ui-fulldeps/issue-11881.rs +++ b/src/test/ui-fulldeps/issue-11881.rs @@ -3,26 +3,27 @@ #![allow(unused_must_use)] #![allow(dead_code)] #![allow(unused_imports)] - #![feature(rustc_private)] +extern crate rustc_macros; extern crate rustc_serialize; -use std::io::Cursor; -use std::io::prelude::*; use std::fmt; +use std::io::prelude::*; +use std::io::Cursor; use std::slice; -use rustc_serialize::{Encodable, Encoder}; +use rustc_macros::Encodable; use rustc_serialize::json; use rustc_serialize::opaque; +use rustc_serialize::{Encodable, Encoder}; -#[derive(RustcEncodable)] +#[derive(Encodable)] struct Foo { baz: bool, } -#[derive(RustcEncodable)] +#[derive(Encodable)] struct Bar { froboz: usize, } @@ -33,19 +34,19 @@ enum WireProtocol { // ... } -fn encode_json<T: Encodable>(val: &T, wr: &mut Cursor<Vec<u8>>) { +fn encode_json<T: for<'a> Encodable<json::Encoder<'a>>>(val: &T, wr: &mut Cursor<Vec<u8>>) { write!(wr, "{}", json::as_json(val)); } -fn encode_opaque<T: Encodable>(val: &T, wr: Vec<u8>) { +fn encode_opaque<T: Encodable<opaque::Encoder>>(val: &T, wr: Vec<u8>) { let mut encoder = opaque::Encoder::new(wr); val.encode(&mut encoder); } pub fn main() { - let target = Foo{baz: false,}; + let target = Foo { baz: false }; let proto = WireProtocol::JSON; match proto { WireProtocol::JSON => encode_json(&target, &mut Cursor::new(Vec::new())), - WireProtocol::Opaque => encode_opaque(&target, Vec::new()) + WireProtocol::Opaque => encode_opaque(&target, Vec::new()), } } diff --git a/src/test/ui-fulldeps/issue-14021.rs b/src/test/ui-fulldeps/issue-14021.rs index 1898b12c703..be88a593962 100644 --- a/src/test/ui-fulldeps/issue-14021.rs +++ b/src/test/ui-fulldeps/issue-14021.rs @@ -4,12 +4,14 @@ #![allow(unused_imports)] #![feature(rustc_private)] +extern crate rustc_macros; extern crate rustc_serialize; -use rustc_serialize::{Encodable, Decodable}; +use rustc_macros::{Decodable, Encodable}; use rustc_serialize::json; +use rustc_serialize::{Decodable, Encodable}; -#[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)] +#[derive(Encodable, Decodable, PartialEq, Debug)] struct UnitLikeStruct; pub fn main() { diff --git a/src/test/ui-fulldeps/issue-15924.rs b/src/test/ui-fulldeps/issue-15924.rs index e3d4b0eb446..5adc2c482f5 100644 --- a/src/test/ui-fulldeps/issue-15924.rs +++ b/src/test/ui-fulldeps/issue-15924.rs @@ -3,20 +3,19 @@ #![allow(unused_imports)] #![allow(unused_must_use)] // pretty-expanded FIXME #23616 - #![feature(rustc_private)] extern crate rustc_serialize; -use std::fmt; -use rustc_serialize::{Encoder, Encodable}; use rustc_serialize::json; +use rustc_serialize::{Encodable, Encoder}; +use std::fmt; -struct Foo<T: Encodable> { +struct Foo<T: for<'a> Encodable<json::Encoder<'a>>> { v: T, } -impl<T: Encodable> Drop for Foo<T> { +impl<T: for<'a> Encodable<json::Encoder<'a>>> Drop for Foo<T> { fn drop(&mut self) { json::encode(&self.v); } diff --git a/src/test/ui-fulldeps/issue-24972.rs b/src/test/ui-fulldeps/issue-24972.rs index 51e134fbf88..044a0c5000e 100644 --- a/src/test/ui-fulldeps/issue-24972.rs +++ b/src/test/ui-fulldeps/issue-24972.rs @@ -5,11 +5,18 @@ extern crate rustc_serialize; -use rustc_serialize::{Encodable, Decodable}; +use rustc_serialize::{json, Decodable, Encodable}; use std::fmt::Display; -pub trait Entity : Decodable + Encodable + Sized { - type Key: Clone + Decodable + Encodable + ToString + Display + Eq + Ord + Sized; +pub trait Entity: Decodable<json::Decoder> + for<'a> Encodable<json::Encoder<'a>> + Sized { + type Key: Clone + + Decodable<json::Decoder> + + for<'a> Encodable<json::Encoder<'a>> + + ToString + + Display + + Eq + + Ord + + Sized; fn id(&self) -> Self::Key; @@ -20,7 +27,10 @@ pub struct DbRef<E: Entity> { pub id: E::Key, } -impl<E> DbRef<E> where E: Entity { +impl<E> DbRef<E> +where + E: Entity, +{ fn get(self) -> Option<E> { E::find_by_id(self.id) } diff --git a/src/test/ui-fulldeps/issue-4016.rs b/src/test/ui-fulldeps/issue-4016.rs index 96157c2f426..4fd192497a0 100644 --- a/src/test/ui-fulldeps/issue-4016.rs +++ b/src/test/ui-fulldeps/issue-4016.rs @@ -1,14 +1,13 @@ // run-pass #![allow(dead_code)] - #![feature(rustc_private)] extern crate rustc_serialize; use rustc_serialize::{json, Decodable}; -trait JD : Decodable {} +trait JD: Decodable<json::Decoder> {} fn exec<T: JD>() { let doc = json::from_str("").unwrap(); diff --git a/src/test/ui-fulldeps/rustc_encodable_hygiene.rs b/src/test/ui-fulldeps/rustc_encodable_hygiene.rs index b49135cb60b..452110a65e4 100644 --- a/src/test/ui-fulldeps/rustc_encodable_hygiene.rs +++ b/src/test/ui-fulldeps/rustc_encodable_hygiene.rs @@ -2,11 +2,13 @@ #![feature(rustc_private)] +extern crate rustc_macros; #[allow(dead_code)] - extern crate rustc_serialize; -#[derive(RustcDecodable, RustcEncodable,Debug)] +use rustc_macros::{Decodable, Encodable}; + +#[derive(Decodable, Encodable, Debug)] struct A { a: String, } diff --git a/src/test/ui/associated-types/bound-lifetime-in-binding-only.elision.stderr b/src/test/ui/associated-types/bound-lifetime-in-binding-only.elision.stderr index 00f44129cc8..6c68cc7bc61 100644 --- a/src/test/ui/associated-types/bound-lifetime-in-binding-only.elision.stderr +++ b/src/test/ui/associated-types/bound-lifetime-in-binding-only.elision.stderr @@ -5,6 +5,11 @@ LL | fn elision<T: Fn() -> &i32>() { | ^ expected named lifetime parameter | = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from + = note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html +help: consider making the bound lifetime-generic with a new `'a` lifetime + | +LL | fn elision<T: for<'a> Fn() -> &'a i32>() { + | ^^^^^^^ ^^^ help: consider using the `'static` lifetime | LL | fn elision<T: Fn() -> &'static i32>() { diff --git a/src/test/ui/associated-types/bound-lifetime-in-return-only.elision.stderr b/src/test/ui/associated-types/bound-lifetime-in-return-only.elision.stderr index a5242707c71..93d2f8e7911 100644 --- a/src/test/ui/associated-types/bound-lifetime-in-return-only.elision.stderr +++ b/src/test/ui/associated-types/bound-lifetime-in-return-only.elision.stderr @@ -5,6 +5,11 @@ LL | fn elision(_: fn() -> &i32) { | ^ expected named lifetime parameter | = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from + = note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html +help: consider making the type lifetime-generic with a new `'a` lifetime + | +LL | fn elision(_: for<'a> fn() -> &'a i32) { + | ^^^^^^^ ^^^ help: consider using the `'static` lifetime | LL | fn elision(_: fn() -> &'static i32) { diff --git a/src/test/ui/ast-json/ast-json-noexpand-output.stdout b/src/test/ui/ast-json/ast-json-noexpand-output.stdout index c7b0fbeb0e3..d0942f78bb8 100644 --- a/src/test/ui/ast-json/ast-json-noexpand-output.stdout +++ b/src/test/ui/ast-json/ast-json-noexpand-output.stdout @@ -1 +1 @@ -{"module":{"inner":{"lo":0,"hi":0},"items":[{"attrs":[],"id":0,"span":{"lo":0,"hi":0},"vis":{"node":"Inherited","span":{"lo":0,"hi":0}},"ident":{"name":"core","span":{"lo":0,"hi":0}},"kind":{"variant":"ExternCrate","fields":[null]},"tokens":null}],"inline":true},"attrs":[{"kind":{"variant":"Normal","fields":[{"path":{"span":{"lo":0,"hi":0},"segments":[{"ident":{"name":"crate_type","span":{"lo":0,"hi":0}},"id":0,"args":null}]},"args":{"variant":"Eq","fields":[{"lo":0,"hi":0},{"_field0":[[{"variant":"Token","fields":[{"kind":{"variant":"Literal","fields":[{"kind":"Str","symbol":"lib","suffix":null}]},"span":{"lo":0,"hi":0}}]},"NonJoint"]]}]}}]},"id":null,"style":"Inner","span":{"lo":0,"hi":0}}],"span":{"lo":0,"hi":0},"proc_macros":[]} +{"module":{"inner":{"lo":0,"hi":0},"items":[{"attrs":[],"id":0,"span":{"lo":0,"hi":0},"vis":{"node":"Inherited","span":{"lo":0,"hi":0}},"ident":{"name":"core","span":{"lo":0,"hi":0}},"kind":{"variant":"ExternCrate","fields":[null]},"tokens":null}],"inline":true},"attrs":[{"kind":{"variant":"Normal","fields":[{"path":{"span":{"lo":0,"hi":0},"segments":[{"ident":{"name":"crate_type","span":{"lo":0,"hi":0}},"id":0,"args":null}]},"args":{"variant":"Eq","fields":[{"lo":0,"hi":0},{"0":[[{"variant":"Token","fields":[{"kind":{"variant":"Literal","fields":[{"kind":"Str","symbol":"lib","suffix":null}]},"span":{"lo":0,"hi":0}}]},"NonJoint"]]}]}}]},"id":null,"style":"Inner","span":{"lo":0,"hi":0}}],"span":{"lo":0,"hi":0},"proc_macros":[]} diff --git a/src/test/ui/ast-json/ast-json-output.stdout b/src/test/ui/ast-json/ast-json-output.stdout index 59ed68c2a77..dc06fd74a4b 100644 --- a/src/test/ui/ast-json/ast-json-output.stdout +++ b/src/test/ui/ast-json/ast-json-output.stdout @@ -1 +1 @@ -{"module":{"inner":{"lo":0,"hi":0},"items":[{"attrs":[{"kind":{"variant":"Normal","fields":[{"path":{"span":{"lo":0,"hi":0},"segments":[{"ident":{"name":"prelude_import","span":{"lo":0,"hi":0}},"id":0,"args":null}]},"args":"Empty"}]},"id":null,"style":"Outer","span":{"lo":0,"hi":0}}],"id":0,"span":{"lo":0,"hi":0},"vis":{"node":"Inherited","span":{"lo":0,"hi":0}},"ident":{"name":"","span":{"lo":0,"hi":0}},"kind":{"variant":"Use","fields":[{"prefix":{"span":{"lo":0,"hi":0},"segments":[{"ident":{"name":"{{root}}","span":{"lo":0,"hi":0}},"id":0,"args":null},{"ident":{"name":"std","span":{"lo":0,"hi":0}},"id":0,"args":null},{"ident":{"name":"prelude","span":{"lo":0,"hi":0}},"id":0,"args":null},{"ident":{"name":"v1","span":{"lo":0,"hi":0}},"id":0,"args":null}]},"kind":"Glob","span":{"lo":0,"hi":0}}]},"tokens":null},{"attrs":[{"kind":{"variant":"Normal","fields":[{"path":{"span":{"lo":0,"hi":0},"segments":[{"ident":{"name":"macro_use","span":{"lo":0,"hi":0}},"id":0,"args":null}]},"args":"Empty"}]},"id":null,"style":"Outer","span":{"lo":0,"hi":0}}],"id":0,"span":{"lo":0,"hi":0},"vis":{"node":"Inherited","span":{"lo":0,"hi":0}},"ident":{"name":"std","span":{"lo":0,"hi":0}},"kind":{"variant":"ExternCrate","fields":[null]},"tokens":null},{"attrs":[],"id":0,"span":{"lo":0,"hi":0},"vis":{"node":"Inherited","span":{"lo":0,"hi":0}},"ident":{"name":"core","span":{"lo":0,"hi":0}},"kind":{"variant":"ExternCrate","fields":[null]},"tokens":null}],"inline":true},"attrs":[{"kind":{"variant":"Normal","fields":[{"path":{"span":{"lo":0,"hi":0},"segments":[{"ident":{"name":"crate_type","span":{"lo":0,"hi":0}},"id":0,"args":null}]},"args":{"variant":"Eq","fields":[{"lo":0,"hi":0},{"_field0":[[{"variant":"Token","fields":[{"kind":{"variant":"Literal","fields":[{"kind":"Str","symbol":"lib","suffix":null}]},"span":{"lo":0,"hi":0}}]},"NonJoint"]]}]}}]},"id":null,"style":"Inner","span":{"lo":0,"hi":0}}],"span":{"lo":0,"hi":0},"proc_macros":[]} +{"module":{"inner":{"lo":0,"hi":0},"items":[{"attrs":[{"kind":{"variant":"Normal","fields":[{"path":{"span":{"lo":0,"hi":0},"segments":[{"ident":{"name":"prelude_import","span":{"lo":0,"hi":0}},"id":0,"args":null}]},"args":"Empty"}]},"id":null,"style":"Outer","span":{"lo":0,"hi":0}}],"id":0,"span":{"lo":0,"hi":0},"vis":{"node":"Inherited","span":{"lo":0,"hi":0}},"ident":{"name":"","span":{"lo":0,"hi":0}},"kind":{"variant":"Use","fields":[{"prefix":{"span":{"lo":0,"hi":0},"segments":[{"ident":{"name":"{{root}}","span":{"lo":0,"hi":0}},"id":0,"args":null},{"ident":{"name":"std","span":{"lo":0,"hi":0}},"id":0,"args":null},{"ident":{"name":"prelude","span":{"lo":0,"hi":0}},"id":0,"args":null},{"ident":{"name":"v1","span":{"lo":0,"hi":0}},"id":0,"args":null}]},"kind":"Glob","span":{"lo":0,"hi":0}}]},"tokens":null},{"attrs":[{"kind":{"variant":"Normal","fields":[{"path":{"span":{"lo":0,"hi":0},"segments":[{"ident":{"name":"macro_use","span":{"lo":0,"hi":0}},"id":0,"args":null}]},"args":"Empty"}]},"id":null,"style":"Outer","span":{"lo":0,"hi":0}}],"id":0,"span":{"lo":0,"hi":0},"vis":{"node":"Inherited","span":{"lo":0,"hi":0}},"ident":{"name":"std","span":{"lo":0,"hi":0}},"kind":{"variant":"ExternCrate","fields":[null]},"tokens":null},{"attrs":[],"id":0,"span":{"lo":0,"hi":0},"vis":{"node":"Inherited","span":{"lo":0,"hi":0}},"ident":{"name":"core","span":{"lo":0,"hi":0}},"kind":{"variant":"ExternCrate","fields":[null]},"tokens":null}],"inline":true},"attrs":[{"kind":{"variant":"Normal","fields":[{"path":{"span":{"lo":0,"hi":0},"segments":[{"ident":{"name":"crate_type","span":{"lo":0,"hi":0}},"id":0,"args":null}]},"args":{"variant":"Eq","fields":[{"lo":0,"hi":0},{"0":[[{"variant":"Token","fields":[{"kind":{"variant":"Literal","fields":[{"kind":"Str","symbol":"lib","suffix":null}]},"span":{"lo":0,"hi":0}}]},"NonJoint"]]}]}}]},"id":null,"style":"Inner","span":{"lo":0,"hi":0}}],"span":{"lo":0,"hi":0},"proc_macros":[]} diff --git a/src/test/ui/const-generics/apit-with-const-param.rs b/src/test/ui/const-generics/apit-with-const-param.rs index f9c6e201b17..facc0bcf513 100644 --- a/src/test/ui/const-generics/apit-with-const-param.rs +++ b/src/test/ui/const-generics/apit-with-const-param.rs @@ -1,7 +1,9 @@ // check-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] trait Trait {} diff --git a/src/test/ui/const-generics/apit-with-const-param.stderr b/src/test/ui/const-generics/apit-with-const-param.stderr deleted file mode 100644 index 4389e4738ea..00000000000 --- a/src/test/ui/const-generics/apit-with-const-param.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/apit-with-const-param.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/array-size-in-generic-struct-param.full.stderr b/src/test/ui/const-generics/array-size-in-generic-struct-param.full.stderr new file mode 100644 index 00000000000..cf4487b5829 --- /dev/null +++ b/src/test/ui/const-generics/array-size-in-generic-struct-param.full.stderr @@ -0,0 +1,18 @@ +error: constant expression depends on a generic parameter + --> $DIR/array-size-in-generic-struct-param.rs:9:38 + | +LL | struct ArithArrayLen<const N: usize>([u32; 0 + N]); + | ^^^^^^^^^^^^ + | + = note: this may fail depending on what value the parameter takes + +error: constant expression depends on a generic parameter + --> $DIR/array-size-in-generic-struct-param.rs:20:10 + | +LL | arr: [u8; CFG.arr_size], + | ^^^^^^^^^^^^^^^^^^ + | + = note: this may fail depending on what value the parameter takes + +error: aborting due to 2 previous errors + diff --git a/src/test/ui/const-generics/array-size-in-generic-struct-param.min.stderr b/src/test/ui/const-generics/array-size-in-generic-struct-param.min.stderr new file mode 100644 index 00000000000..61d23475c6f --- /dev/null +++ b/src/test/ui/const-generics/array-size-in-generic-struct-param.min.stderr @@ -0,0 +1,27 @@ +error: generic parameters must not be used inside of non trivial constant values + --> $DIR/array-size-in-generic-struct-param.rs:9:48 + | +LL | struct ArithArrayLen<const N: usize>([u32; 0 + N]); + | ^ non-trivial anonymous constants must not depend on the parameter `N` + | + = help: it is currently only allowed to use either `N` or `{ N }` as generic constants + +error: generic parameters must not be used inside of non trivial constant values + --> $DIR/array-size-in-generic-struct-param.rs:20:15 + | +LL | arr: [u8; CFG.arr_size], + | ^^^ non-trivial anonymous constants must not depend on the parameter `CFG` + | + = help: it is currently only allowed to use either `CFG` or `{ CFG }` as generic constants + +error: using `Config` as const generic parameters is forbidden + --> $DIR/array-size-in-generic-struct-param.rs:18:21 + | +LL | struct B<const CFG: Config> { + | ^^^^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: aborting due to 3 previous errors + diff --git a/src/test/ui/const-generics/array-size-in-generic-struct-param.rs b/src/test/ui/const-generics/array-size-in-generic-struct-param.rs index 5c02e585dc8..aa1a3b9cf28 100644 --- a/src/test/ui/const-generics/array-size-in-generic-struct-param.rs +++ b/src/test/ui/const-generics/array-size-in-generic-struct-param.rs @@ -1,9 +1,14 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// Tests that array sizes that depend on const-params are checked using `ConstEvaluatable`. +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] #[allow(dead_code)] struct ArithArrayLen<const N: usize>([u32; 0 + N]); -//~^ ERROR constant expression depends on a generic parameter +//[full]~^ ERROR constant expression depends on a generic parameter +//[min]~^^ ERROR generic parameters must not be used inside of non trivial constant values #[derive(PartialEq, Eq)] struct Config { @@ -11,7 +16,10 @@ struct Config { } struct B<const CFG: Config> { - arr: [u8; CFG.arr_size], //~ ERROR constant expression depends on a generic parameter + //[min]~^ ERROR using `Config` as const generic parameters is forbidden + arr: [u8; CFG.arr_size], + //[full]~^ ERROR constant expression depends on a generic parameter + //[min]~^^ ERROR generic parameters must not be used inside of non trivial } const C: Config = Config { arr_size: 5 }; diff --git a/src/test/ui/const-generics/array-size-in-generic-struct-param.stderr b/src/test/ui/const-generics/array-size-in-generic-struct-param.stderr deleted file mode 100644 index ad67a87265b..00000000000 --- a/src/test/ui/const-generics/array-size-in-generic-struct-param.stderr +++ /dev/null @@ -1,27 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/array-size-in-generic-struct-param.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error: constant expression depends on a generic parameter - --> $DIR/array-size-in-generic-struct-param.rs:5:38 - | -LL | struct ArithArrayLen<const N: usize>([u32; 0 + N]); - | ^^^^^^^^^^^^ - | - = note: this may fail depending on what value the parameter takes - -error: constant expression depends on a generic parameter - --> $DIR/array-size-in-generic-struct-param.rs:14:10 - | -LL | arr: [u8; CFG.arr_size], - | ^^^^^^^^^^^^^^^^^^ - | - = note: this may fail depending on what value the parameter takes - -error: aborting due to 2 previous errors; 1 warning emitted - diff --git a/src/test/ui/const-generics/broken-mir-1.rs b/src/test/ui/const-generics/broken-mir-1.rs index f137be2d6a6..d13ae12c03b 100644 --- a/src/test/ui/const-generics/broken-mir-1.rs +++ b/src/test/ui/const-generics/broken-mir-1.rs @@ -1,7 +1,9 @@ // run-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] pub trait Foo { fn foo(&self); diff --git a/src/test/ui/const-generics/broken-mir-1.stderr b/src/test/ui/const-generics/broken-mir-1.stderr deleted file mode 100644 index a5532bde1f5..00000000000 --- a/src/test/ui/const-generics/broken-mir-1.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/broken-mir-1.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/broken-mir-2.rs b/src/test/ui/const-generics/broken-mir-2.rs index 2cd035639ee..2f9afe0b464 100644 --- a/src/test/ui/const-generics/broken-mir-2.rs +++ b/src/test/ui/const-generics/broken-mir-2.rs @@ -1,7 +1,9 @@ // run-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] use std::fmt::Debug; diff --git a/src/test/ui/const-generics/broken-mir-2.stderr b/src/test/ui/const-generics/broken-mir-2.stderr deleted file mode 100644 index c36ef845097..00000000000 --- a/src/test/ui/const-generics/broken-mir-2.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/broken-mir-2.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/cannot-infer-const-args.full.stderr b/src/test/ui/const-generics/cannot-infer-const-args.full.stderr new file mode 100644 index 00000000000..053139787ed --- /dev/null +++ b/src/test/ui/const-generics/cannot-infer-const-args.full.stderr @@ -0,0 +1,11 @@ +error[E0282]: type annotations needed + --> $DIR/cannot-infer-const-args.rs:12:5 + | +LL | foo(); + | ^^^ + | + = note: unable to infer the value of a const parameter + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0282`. diff --git a/src/test/ui/const-generics/cannot-infer-const-args.min.stderr b/src/test/ui/const-generics/cannot-infer-const-args.min.stderr new file mode 100644 index 00000000000..053139787ed --- /dev/null +++ b/src/test/ui/const-generics/cannot-infer-const-args.min.stderr @@ -0,0 +1,11 @@ +error[E0282]: type annotations needed + --> $DIR/cannot-infer-const-args.rs:12:5 + | +LL | foo(); + | ^^^ + | + = note: unable to infer the value of a const parameter + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0282`. diff --git a/src/test/ui/const-generics/cannot-infer-const-args.rs b/src/test/ui/const-generics/cannot-infer-const-args.rs index 2f6ad2654c1..2d74b4788bf 100644 --- a/src/test/ui/const-generics/cannot-infer-const-args.rs +++ b/src/test/ui/const-generics/cannot-infer-const-args.rs @@ -1,5 +1,8 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] fn foo<const X: usize>() -> usize { 0 diff --git a/src/test/ui/const-generics/cannot-infer-const-args.stderr b/src/test/ui/const-generics/cannot-infer-const-args.stderr deleted file mode 100644 index b29d27e5247..00000000000 --- a/src/test/ui/const-generics/cannot-infer-const-args.stderr +++ /dev/null @@ -1,20 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/cannot-infer-const-args.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error[E0282]: type annotations needed - --> $DIR/cannot-infer-const-args.rs:9:5 - | -LL | foo(); - | ^^^ - | - = note: unable to infer the value of a const parameter - -error: aborting due to previous error; 1 warning emitted - -For more information about this error, try `rustc --explain E0282`. diff --git a/src/test/ui/const-generics/coerce_unsized_array.rs b/src/test/ui/const-generics/coerce_unsized_array.rs index b28768a5163..a3c295f73c7 100644 --- a/src/test/ui/const-generics/coerce_unsized_array.rs +++ b/src/test/ui/const-generics/coerce_unsized_array.rs @@ -1,6 +1,9 @@ // run-pass -#![feature(const_generics)] -#![allow(incomplete_features)] +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] fn foo<const N: usize>(v: &[u8; N]) -> &[u8] { v diff --git a/src/test/ui/const-generics/concrete-const-as-fn-arg.rs b/src/test/ui/const-generics/concrete-const-as-fn-arg.rs index 18ebba49f6f..7771bf33601 100644 --- a/src/test/ui/const-generics/concrete-const-as-fn-arg.rs +++ b/src/test/ui/const-generics/concrete-const-as-fn-arg.rs @@ -1,8 +1,10 @@ // Test that a concrete const type i.e. A<2>, can be used as an argument type in a function // run-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] struct A<const N: usize>; // ok diff --git a/src/test/ui/const-generics/concrete-const-as-fn-arg.stderr b/src/test/ui/const-generics/concrete-const-as-fn-arg.stderr deleted file mode 100644 index c8f3a8beaf8..00000000000 --- a/src/test/ui/const-generics/concrete-const-as-fn-arg.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/concrete-const-as-fn-arg.rs:4:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/concrete-const-impl-method.rs b/src/test/ui/const-generics/concrete-const-impl-method.rs index c1ddf9a3314..edb403ce8fd 100644 --- a/src/test/ui/const-generics/concrete-const-impl-method.rs +++ b/src/test/ui/const-generics/concrete-const-impl-method.rs @@ -1,9 +1,11 @@ // Test that a method/associated non-method within an impl block of a concrete const type i.e. A<2>, // is callable. // run-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] pub struct A<const N: u32>; diff --git a/src/test/ui/const-generics/concrete-const-impl-method.stderr b/src/test/ui/const-generics/concrete-const-impl-method.stderr deleted file mode 100644 index 5edb4f4f6cd..00000000000 --- a/src/test/ui/const-generics/concrete-const-impl-method.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/concrete-const-impl-method.rs:5:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/condition-in-trait-const-arg.rs b/src/test/ui/const-generics/condition-in-trait-const-arg.rs index 9d8aaed54bd..77b68052fc0 100644 --- a/src/test/ui/const-generics/condition-in-trait-const-arg.rs +++ b/src/test/ui/const-generics/condition-in-trait-const-arg.rs @@ -1,7 +1,10 @@ +// Checks that `impl Trait<{anon_const}> for Type` evaluates successfully. // run-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] trait IsZeroTrait<const IS_ZERO: bool>{} diff --git a/src/test/ui/const-generics/condition-in-trait-const-arg.stderr b/src/test/ui/const-generics/condition-in-trait-const-arg.stderr deleted file mode 100644 index 9ac33454128..00000000000 --- a/src/test/ui/const-generics/condition-in-trait-const-arg.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/condition-in-trait-const-arg.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/const-arg-in-fn.rs b/src/test/ui/const-generics/const-arg-in-fn.rs index 5ea2cf92fdc..5c438efd82a 100644 --- a/src/test/ui/const-generics/const-arg-in-fn.rs +++ b/src/test/ui/const-generics/const-arg-in-fn.rs @@ -1,7 +1,9 @@ // run-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] fn const_u32_identity<const X: u32>() -> u32 { X diff --git a/src/test/ui/const-generics/const-arg-in-fn.stderr b/src/test/ui/const-generics/const-arg-in-fn.stderr deleted file mode 100644 index bb66849c7fe..00000000000 --- a/src/test/ui/const-generics/const-arg-in-fn.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/const-arg-in-fn.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/const-argument-non-static-lifetime.rs b/src/test/ui/const-generics/const-argument-non-static-lifetime.rs index bc09ba2ab55..dc34621b905 100644 --- a/src/test/ui/const-generics/const-argument-non-static-lifetime.rs +++ b/src/test/ui/const-generics/const-argument-non-static-lifetime.rs @@ -1,7 +1,9 @@ // run-pass +// revisions: full +// FIXME(#75323) Omitted min revision for now due to ICE. -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] #![allow(dead_code)] fn test<const N: usize>() {} diff --git a/src/test/ui/const-generics/const-argument-non-static-lifetime.stderr b/src/test/ui/const-generics/const-argument-non-static-lifetime.stderr deleted file mode 100644 index 53a7550090d..00000000000 --- a/src/test/ui/const-generics/const-argument-non-static-lifetime.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/const-argument-non-static-lifetime.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/const-expression-parameter.full.stderr b/src/test/ui/const-generics/const-expression-parameter.full.stderr new file mode 100644 index 00000000000..496af9c6e02 --- /dev/null +++ b/src/test/ui/const-generics/const-expression-parameter.full.stderr @@ -0,0 +1,8 @@ +error: expected one of `,` or `>`, found `+` + --> $DIR/const-expression-parameter.rs:16:22 + | +LL | i32_identity::<1 + 2>(); + | ^ expected one of `,` or `>` + +error: aborting due to previous error + diff --git a/src/test/ui/const-generics/const-expression-parameter.min.stderr b/src/test/ui/const-generics/const-expression-parameter.min.stderr new file mode 100644 index 00000000000..496af9c6e02 --- /dev/null +++ b/src/test/ui/const-generics/const-expression-parameter.min.stderr @@ -0,0 +1,8 @@ +error: expected one of `,` or `>`, found `+` + --> $DIR/const-expression-parameter.rs:16:22 + | +LL | i32_identity::<1 + 2>(); + | ^ expected one of `,` or `>` + +error: aborting due to previous error + diff --git a/src/test/ui/const-generics/const-expression-parameter.rs b/src/test/ui/const-generics/const-expression-parameter.rs index e0b66a7c14c..7a1eaf9f939 100644 --- a/src/test/ui/const-generics/const-expression-parameter.rs +++ b/src/test/ui/const-generics/const-expression-parameter.rs @@ -1,5 +1,8 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] fn i32_identity<const X: i32>() -> i32 { 5 diff --git a/src/test/ui/const-generics/const-expression-parameter.stderr b/src/test/ui/const-generics/const-expression-parameter.stderr deleted file mode 100644 index e421c22be01..00000000000 --- a/src/test/ui/const-generics/const-expression-parameter.stderr +++ /dev/null @@ -1,17 +0,0 @@ -error: expected one of `,` or `>`, found `+` - --> $DIR/const-expression-parameter.rs:13:22 - | -LL | i32_identity::<1 + 2>(); - | ^ expected one of `,` or `>` - -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/const-expression-parameter.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error: aborting due to previous error; 1 warning emitted - diff --git a/src/test/ui/const-generics/const-fn-with-const-param.rs b/src/test/ui/const-generics/const-fn-with-const-param.rs index bbc55815e9a..add1290b1d9 100644 --- a/src/test/ui/const-generics/const-fn-with-const-param.rs +++ b/src/test/ui/const-generics/const-fn-with-const-param.rs @@ -1,6 +1,10 @@ +// Checks that `const fn` with const params can be used. // run-pass -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] const fn const_u32_identity<const X: u32>() -> u32 { X diff --git a/src/test/ui/const-generics/const-fn-with-const-param.stderr b/src/test/ui/const-generics/const-fn-with-const-param.stderr deleted file mode 100644 index 109b5002848..00000000000 --- a/src/test/ui/const-generics/const-fn-with-const-param.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/const-fn-with-const-param.rs:2:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/const-generic-array-wrapper.rs b/src/test/ui/const-generics/const-generic-array-wrapper.rs index 3e43387163b..34edd0b4a8e 100644 --- a/src/test/ui/const-generics/const-generic-array-wrapper.rs +++ b/src/test/ui/const-generics/const-generic-array-wrapper.rs @@ -1,7 +1,9 @@ // run-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] struct Foo<T, const N: usize>([T; N]); diff --git a/src/test/ui/const-generics/const-generic-array-wrapper.stderr b/src/test/ui/const-generics/const-generic-array-wrapper.stderr deleted file mode 100644 index 47448bbd19d..00000000000 --- a/src/test/ui/const-generics/const-generic-array-wrapper.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/const-generic-array-wrapper.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/const-generic-type_name.rs b/src/test/ui/const-generics/const-generic-type_name.rs index 22f9bd2a0f0..a954c026352 100644 --- a/src/test/ui/const-generics/const-generic-type_name.rs +++ b/src/test/ui/const-generics/const-generic-type_name.rs @@ -1,7 +1,9 @@ // run-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] #[derive(Debug)] struct S<const N: usize>; diff --git a/src/test/ui/const-generics/const-generic-type_name.stderr b/src/test/ui/const-generics/const-generic-type_name.stderr deleted file mode 100644 index f161739c9c8..00000000000 --- a/src/test/ui/const-generics/const-generic-type_name.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/const-generic-type_name.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/const-param-after-const-literal-arg.rs b/src/test/ui/const-generics/const-param-after-const-literal-arg.rs index 19c4120eb2f..3982f7a7f12 100644 --- a/src/test/ui/const-generics/const-param-after-const-literal-arg.rs +++ b/src/test/ui/const-generics/const-param-after-const-literal-arg.rs @@ -1,7 +1,9 @@ // check-pass +// revisions: full min -#![allow(incomplete_features)] -#![feature(const_generics)] +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] struct Foo<const A: usize, const B: usize>; diff --git a/src/test/ui/const-generics/const-param-elided-lifetime.stderr b/src/test/ui/const-generics/const-param-elided-lifetime.full.stderr index 8c50fb73679..aa29d61d917 100644 --- a/src/test/ui/const-generics/const-param-elided-lifetime.stderr +++ b/src/test/ui/const-generics/const-param-elided-lifetime.full.stderr @@ -1,42 +1,33 @@ error[E0637]: `&` without an explicit lifetime name cannot be used here - --> $DIR/const-param-elided-lifetime.rs:9:19 + --> $DIR/const-param-elided-lifetime.rs:11:19 | LL | struct A<const N: &u8>; | ^ explicit lifetime name needed here error[E0637]: `&` without an explicit lifetime name cannot be used here - --> $DIR/const-param-elided-lifetime.rs:13:15 + --> $DIR/const-param-elided-lifetime.rs:16:15 | LL | impl<const N: &u8> A<N> { | ^ explicit lifetime name needed here error[E0637]: `&` without an explicit lifetime name cannot be used here - --> $DIR/const-param-elided-lifetime.rs:14:21 + --> $DIR/const-param-elided-lifetime.rs:19:21 | LL | fn foo<const M: &u8>(&self) {} | ^ explicit lifetime name needed here error[E0637]: `&` without an explicit lifetime name cannot be used here - --> $DIR/const-param-elided-lifetime.rs:18:15 + --> $DIR/const-param-elided-lifetime.rs:24:15 | LL | impl<const N: &u8> B for A<N> {} | ^ explicit lifetime name needed here error[E0637]: `&` without an explicit lifetime name cannot be used here - --> $DIR/const-param-elided-lifetime.rs:21:17 + --> $DIR/const-param-elided-lifetime.rs:28:17 | LL | fn bar<const N: &u8>() {} | ^ explicit lifetime name needed here -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/const-param-elided-lifetime.rs:6:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error: aborting due to 5 previous errors; 1 warning emitted +error: aborting due to 5 previous errors For more information about this error, try `rustc --explain E0637`. diff --git a/src/test/ui/const-generics/const-param-elided-lifetime.min.stderr b/src/test/ui/const-generics/const-param-elided-lifetime.min.stderr new file mode 100644 index 00000000000..bdd1da96c75 --- /dev/null +++ b/src/test/ui/const-generics/const-param-elided-lifetime.min.stderr @@ -0,0 +1,78 @@ +error[E0637]: `&` without an explicit lifetime name cannot be used here + --> $DIR/const-param-elided-lifetime.rs:11:19 + | +LL | struct A<const N: &u8>; + | ^ explicit lifetime name needed here + +error[E0637]: `&` without an explicit lifetime name cannot be used here + --> $DIR/const-param-elided-lifetime.rs:16:15 + | +LL | impl<const N: &u8> A<N> { + | ^ explicit lifetime name needed here + +error[E0637]: `&` without an explicit lifetime name cannot be used here + --> $DIR/const-param-elided-lifetime.rs:19:21 + | +LL | fn foo<const M: &u8>(&self) {} + | ^ explicit lifetime name needed here + +error[E0637]: `&` without an explicit lifetime name cannot be used here + --> $DIR/const-param-elided-lifetime.rs:24:15 + | +LL | impl<const N: &u8> B for A<N> {} + | ^ explicit lifetime name needed here + +error[E0637]: `&` without an explicit lifetime name cannot be used here + --> $DIR/const-param-elided-lifetime.rs:28:17 + | +LL | fn bar<const N: &u8>() {} + | ^ explicit lifetime name needed here + +error: using `&'static u8` as const generic parameters is forbidden + --> $DIR/const-param-elided-lifetime.rs:11:19 + | +LL | struct A<const N: &u8>; + | ^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: using `&'static u8` as const generic parameters is forbidden + --> $DIR/const-param-elided-lifetime.rs:16:15 + | +LL | impl<const N: &u8> A<N> { + | ^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: using `&'static u8` as const generic parameters is forbidden + --> $DIR/const-param-elided-lifetime.rs:24:15 + | +LL | impl<const N: &u8> B for A<N> {} + | ^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: using `&'static u8` as const generic parameters is forbidden + --> $DIR/const-param-elided-lifetime.rs:28:17 + | +LL | fn bar<const N: &u8>() {} + | ^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: using `&'static u8` as const generic parameters is forbidden + --> $DIR/const-param-elided-lifetime.rs:19:21 + | +LL | fn foo<const M: &u8>(&self) {} + | ^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: aborting due to 10 previous errors + +For more information about this error, try `rustc --explain E0637`. diff --git a/src/test/ui/const-generics/const-param-elided-lifetime.rs b/src/test/ui/const-generics/const-param-elided-lifetime.rs index 5e6b6c4dabe..814b71d4b74 100644 --- a/src/test/ui/const-generics/const-param-elided-lifetime.rs +++ b/src/test/ui/const-generics/const-param-elided-lifetime.rs @@ -2,23 +2,31 @@ // behaviour of trait bounds where `fn foo<T: Ord<&u8>>() {}` is illegal. Though we could change // elided lifetimes within the type of a const generic parameters to be 'static, like elided // lifetimes within const/static items. +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] struct A<const N: &u8>; //~^ ERROR `&` without an explicit lifetime name cannot be used here +//[min]~^^ ERROR using `&'static u8` as const generic parameters is forbidden trait B {} -impl<const N: &u8> A<N> { //~ ERROR `&` without an explicit lifetime name cannot be used here +impl<const N: &u8> A<N> { +//~^ ERROR `&` without an explicit lifetime name cannot be used here +//[min]~^^ ERROR using `&'static u8` as const generic parameters is forbidden fn foo<const M: &u8>(&self) {} //~^ ERROR `&` without an explicit lifetime name cannot be used here + //[min]~^^ ERROR using `&'static u8` as const generic parameters is forbidden } impl<const N: &u8> B for A<N> {} //~^ ERROR `&` without an explicit lifetime name cannot be used here +//[min]~^^ ERROR using `&'static u8` as const generic parameters is forbidden fn bar<const N: &u8>() {} //~^ ERROR `&` without an explicit lifetime name cannot be used here +//[min]~^^ ERROR using `&'static u8` as const generic parameters is forbidden fn main() {} diff --git a/src/test/ui/const-generics/const-param-from-outer-fn.full.stderr b/src/test/ui/const-generics/const-param-from-outer-fn.full.stderr new file mode 100644 index 00000000000..5a126f5c3c6 --- /dev/null +++ b/src/test/ui/const-generics/const-param-from-outer-fn.full.stderr @@ -0,0 +1,13 @@ +error[E0401]: can't use generic parameters from outer function + --> $DIR/const-param-from-outer-fn.rs:9:9 + | +LL | fn foo<const X: u32>() { + | - const parameter from outer function +LL | fn bar() -> u32 { + | --- try adding a local generic parameter in this method instead +LL | X + | ^ use of generic parameter from outer function + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0401`. diff --git a/src/test/ui/const-generics/const-param-from-outer-fn.min.stderr b/src/test/ui/const-generics/const-param-from-outer-fn.min.stderr new file mode 100644 index 00000000000..5a126f5c3c6 --- /dev/null +++ b/src/test/ui/const-generics/const-param-from-outer-fn.min.stderr @@ -0,0 +1,13 @@ +error[E0401]: can't use generic parameters from outer function + --> $DIR/const-param-from-outer-fn.rs:9:9 + | +LL | fn foo<const X: u32>() { + | - const parameter from outer function +LL | fn bar() -> u32 { + | --- try adding a local generic parameter in this method instead +LL | X + | ^ use of generic parameter from outer function + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0401`. diff --git a/src/test/ui/const-generics/const-param-from-outer-fn.rs b/src/test/ui/const-generics/const-param-from-outer-fn.rs index 4b8e2db7233..e1376c6e108 100644 --- a/src/test/ui/const-generics/const-param-from-outer-fn.rs +++ b/src/test/ui/const-generics/const-param-from-outer-fn.rs @@ -1,5 +1,8 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] fn foo<const X: u32>() { fn bar() -> u32 { diff --git a/src/test/ui/const-generics/const-param-from-outer-fn.stderr b/src/test/ui/const-generics/const-param-from-outer-fn.stderr deleted file mode 100644 index 30bd1d72914..00000000000 --- a/src/test/ui/const-generics/const-param-from-outer-fn.stderr +++ /dev/null @@ -1,22 +0,0 @@ -error[E0401]: can't use generic parameters from outer function - --> $DIR/const-param-from-outer-fn.rs:6:9 - | -LL | fn foo<const X: u32>() { - | - const parameter from outer function -LL | fn bar() -> u32 { - | --- try adding a local generic parameter in this method instead -LL | X - | ^ use of generic parameter from outer function - -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/const-param-from-outer-fn.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error: aborting due to previous error; 1 warning emitted - -For more information about this error, try `rustc --explain E0401`. diff --git a/src/test/ui/const-generics/const-param-in-trait.rs b/src/test/ui/const-generics/const-param-in-trait.rs index 68740725711..9d31162c1c6 100644 --- a/src/test/ui/const-generics/const-param-in-trait.rs +++ b/src/test/ui/const-generics/const-param-in-trait.rs @@ -1,8 +1,12 @@ +// Check that const parameters are permitted in traits. // run-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] -trait Trait<const T: ()> {} + +trait Trait<const T: u8> {} fn main() {} diff --git a/src/test/ui/const-generics/const-param-in-trait.stderr b/src/test/ui/const-generics/const-param-in-trait.stderr deleted file mode 100644 index a2e367b25ad..00000000000 --- a/src/test/ui/const-generics/const-param-in-trait.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/const-param-in-trait.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/const-param-type-depends-on-const-param.full.stderr b/src/test/ui/const-generics/const-param-type-depends-on-const-param.full.stderr new file mode 100644 index 00000000000..f7ad579dbca --- /dev/null +++ b/src/test/ui/const-generics/const-param-type-depends-on-const-param.full.stderr @@ -0,0 +1,15 @@ +error[E0770]: the type of const parameters must not depend on other generic parameters + --> $DIR/const-param-type-depends-on-const-param.rs:12:52 + | +LL | pub struct Dependent<const N: usize, const X: [u8; N]>([(); N]); + | ^ the type must not depend on the parameter `N` + +error[E0770]: the type of const parameters must not depend on other generic parameters + --> $DIR/const-param-type-depends-on-const-param.rs:16:40 + | +LL | pub struct SelfDependent<const N: [u8; N]>; + | ^ the type must not depend on the parameter `N` + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0770`. diff --git a/src/test/ui/const-generics/const-param-type-depends-on-const-param.min.stderr b/src/test/ui/const-generics/const-param-type-depends-on-const-param.min.stderr new file mode 100644 index 00000000000..103f4c36fae --- /dev/null +++ b/src/test/ui/const-generics/const-param-type-depends-on-const-param.min.stderr @@ -0,0 +1,33 @@ +error[E0770]: the type of const parameters must not depend on other generic parameters + --> $DIR/const-param-type-depends-on-const-param.rs:12:52 + | +LL | pub struct Dependent<const N: usize, const X: [u8; N]>([(); N]); + | ^ the type must not depend on the parameter `N` + +error[E0770]: the type of const parameters must not depend on other generic parameters + --> $DIR/const-param-type-depends-on-const-param.rs:16:40 + | +LL | pub struct SelfDependent<const N: [u8; N]>; + | ^ the type must not depend on the parameter `N` + +error: using `[u8; _]` as const generic parameters is forbidden + --> $DIR/const-param-type-depends-on-const-param.rs:12:47 + | +LL | pub struct Dependent<const N: usize, const X: [u8; N]>([(); N]); + | ^^^^^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: using `[u8; _]` as const generic parameters is forbidden + --> $DIR/const-param-type-depends-on-const-param.rs:16:35 + | +LL | pub struct SelfDependent<const N: [u8; N]>; + | ^^^^^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: aborting due to 4 previous errors + +For more information about this error, try `rustc --explain E0770`. diff --git a/src/test/ui/const-generics/const-param-type-depends-on-const-param.rs b/src/test/ui/const-generics/const-param-type-depends-on-const-param.rs index 5aa3617d1d7..d21a7cec117 100644 --- a/src/test/ui/const-generics/const-param-type-depends-on-const-param.rs +++ b/src/test/ui/const-generics/const-param-type-depends-on-const-param.rs @@ -1,5 +1,8 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] // Currently, const parameters cannot depend on other generic parameters, // as our current implementation can't really support this. @@ -8,8 +11,10 @@ pub struct Dependent<const N: usize, const X: [u8; N]>([(); N]); //~^ ERROR: the type of const parameters must not depend on other generic parameters +//[min]~^^ ERROR using `[u8; _]` as const generic parameters is forbidden pub struct SelfDependent<const N: [u8; N]>; //~^ ERROR: the type of const parameters must not depend on other generic parameters +//[min]~^^ ERROR using `[u8; _]` as const generic parameters is forbidden fn main() {} diff --git a/src/test/ui/const-generics/const-param-type-depends-on-const-param.stderr b/src/test/ui/const-generics/const-param-type-depends-on-const-param.stderr deleted file mode 100644 index f6606aea726..00000000000 --- a/src/test/ui/const-generics/const-param-type-depends-on-const-param.stderr +++ /dev/null @@ -1,24 +0,0 @@ -error[E0770]: the type of const parameters must not depend on other generic parameters - --> $DIR/const-param-type-depends-on-const-param.rs:9:52 - | -LL | pub struct Dependent<const N: usize, const X: [u8; N]>([(); N]); - | ^ the type must not depend on the parameter `N` - -error[E0770]: the type of const parameters must not depend on other generic parameters - --> $DIR/const-param-type-depends-on-const-param.rs:12:40 - | -LL | pub struct SelfDependent<const N: [u8; N]>; - | ^ the type must not depend on the parameter `N` - -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/const-param-type-depends-on-const-param.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error: aborting due to 2 previous errors; 1 warning emitted - -For more information about this error, try `rustc --explain E0770`. diff --git a/src/test/ui/const-generics/const-param-type-depends-on-type-param.stderr b/src/test/ui/const-generics/const-param-type-depends-on-type-param.full.stderr index d081dcbbc7a..ba99c87722c 100644 --- a/src/test/ui/const-generics/const-param-type-depends-on-type-param.stderr +++ b/src/test/ui/const-generics/const-param-type-depends-on-type-param.full.stderr @@ -1,27 +1,18 @@ error[E0770]: the type of const parameters must not depend on other generic parameters - --> $DIR/const-param-type-depends-on-type-param.rs:9:34 + --> $DIR/const-param-type-depends-on-type-param.rs:12:34 | LL | pub struct Dependent<T, const X: T>([(); X]); | ^ the type must not depend on the parameter `T` -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/const-param-type-depends-on-type-param.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - error[E0392]: parameter `T` is never used - --> $DIR/const-param-type-depends-on-type-param.rs:9:22 + --> $DIR/const-param-type-depends-on-type-param.rs:12:22 | LL | pub struct Dependent<T, const X: T>([(); X]); | ^ unused parameter | = help: consider removing `T`, referring to it in a field, or using a marker such as `std::marker::PhantomData` -error: aborting due to 2 previous errors; 1 warning emitted +error: aborting due to 2 previous errors Some errors have detailed explanations: E0392, E0770. For more information about an error, try `rustc --explain E0392`. diff --git a/src/test/ui/const-generics/const-param-type-depends-on-type-param.min.stderr b/src/test/ui/const-generics/const-param-type-depends-on-type-param.min.stderr new file mode 100644 index 00000000000..ba99c87722c --- /dev/null +++ b/src/test/ui/const-generics/const-param-type-depends-on-type-param.min.stderr @@ -0,0 +1,18 @@ +error[E0770]: the type of const parameters must not depend on other generic parameters + --> $DIR/const-param-type-depends-on-type-param.rs:12:34 + | +LL | pub struct Dependent<T, const X: T>([(); X]); + | ^ the type must not depend on the parameter `T` + +error[E0392]: parameter `T` is never used + --> $DIR/const-param-type-depends-on-type-param.rs:12:22 + | +LL | pub struct Dependent<T, const X: T>([(); X]); + | ^ unused parameter + | + = help: consider removing `T`, referring to it in a field, or using a marker such as `std::marker::PhantomData` + +error: aborting due to 2 previous errors + +Some errors have detailed explanations: E0392, E0770. +For more information about an error, try `rustc --explain E0392`. diff --git a/src/test/ui/const-generics/const-param-type-depends-on-type-param.rs b/src/test/ui/const-generics/const-param-type-depends-on-type-param.rs index 7fe04a43412..93ae1117512 100644 --- a/src/test/ui/const-generics/const-param-type-depends-on-type-param.rs +++ b/src/test/ui/const-generics/const-param-type-depends-on-type-param.rs @@ -1,5 +1,8 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] // Currently, const parameters cannot depend on other generic parameters, // as our current implementation can't really support this. diff --git a/src/test/ui/const-generics/const-parameter-uppercase-lint.full.stderr b/src/test/ui/const-generics/const-parameter-uppercase-lint.full.stderr new file mode 100644 index 00000000000..0f4f007f9d2 --- /dev/null +++ b/src/test/ui/const-generics/const-parameter-uppercase-lint.full.stderr @@ -0,0 +1,14 @@ +error: const parameter `x` should have an upper case name + --> $DIR/const-parameter-uppercase-lint.rs:9:15 + | +LL | fn noop<const x: u32>() { + | ^ help: convert the identifier to upper case (notice the capitalization): `X` + | +note: the lint level is defined here + --> $DIR/const-parameter-uppercase-lint.rs:7:9 + | +LL | #![deny(non_upper_case_globals)] + | ^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/src/test/ui/const-generics/const-parameter-uppercase-lint.min.stderr b/src/test/ui/const-generics/const-parameter-uppercase-lint.min.stderr new file mode 100644 index 00000000000..0f4f007f9d2 --- /dev/null +++ b/src/test/ui/const-generics/const-parameter-uppercase-lint.min.stderr @@ -0,0 +1,14 @@ +error: const parameter `x` should have an upper case name + --> $DIR/const-parameter-uppercase-lint.rs:9:15 + | +LL | fn noop<const x: u32>() { + | ^ help: convert the identifier to upper case (notice the capitalization): `X` + | +note: the lint level is defined here + --> $DIR/const-parameter-uppercase-lint.rs:7:9 + | +LL | #![deny(non_upper_case_globals)] + | ^^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/src/test/ui/const-generics/const-parameter-uppercase-lint.rs b/src/test/ui/const-generics/const-parameter-uppercase-lint.rs index 54a33e21812..b9bd6666af3 100644 --- a/src/test/ui/const-generics/const-parameter-uppercase-lint.rs +++ b/src/test/ui/const-generics/const-parameter-uppercase-lint.rs @@ -1,5 +1,8 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] #![deny(non_upper_case_globals)] diff --git a/src/test/ui/const-generics/const-parameter-uppercase-lint.stderr b/src/test/ui/const-generics/const-parameter-uppercase-lint.stderr deleted file mode 100644 index b7febed7bdd..00000000000 --- a/src/test/ui/const-generics/const-parameter-uppercase-lint.stderr +++ /dev/null @@ -1,23 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/const-parameter-uppercase-lint.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error: const parameter `x` should have an upper case name - --> $DIR/const-parameter-uppercase-lint.rs:6:15 - | -LL | fn noop<const x: u32>() { - | ^ help: convert the identifier to upper case (notice the capitalization): `X` - | -note: the lint level is defined here - --> $DIR/const-parameter-uppercase-lint.rs:4:9 - | -LL | #![deny(non_upper_case_globals)] - | ^^^^^^^^^^^^^^^^^^^^^^ - -error: aborting due to previous error; 1 warning emitted - diff --git a/src/test/ui/const-generics/const-types.rs b/src/test/ui/const-generics/const-types.rs index bde80f4a1ed..cd34cfc0478 100644 --- a/src/test/ui/const-generics/const-types.rs +++ b/src/test/ui/const-generics/const-types.rs @@ -1,7 +1,10 @@ +// Check that arrays can be used with generic const and type. // run-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] #![allow(dead_code, unused_variables)] diff --git a/src/test/ui/const-generics/const-types.stderr b/src/test/ui/const-generics/const-types.stderr deleted file mode 100644 index 4628c900318..00000000000 --- a/src/test/ui/const-generics/const-types.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/const-types.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/defaults/needs-feature.min.stderr b/src/test/ui/const-generics/defaults/needs-feature.min.stderr index d57190ea3bb..7058327fdce 100644 --- a/src/test/ui/const-generics/defaults/needs-feature.min.stderr +++ b/src/test/ui/const-generics/defaults/needs-feature.min.stderr @@ -2,7 +2,7 @@ error: type parameters must be declared prior to const parameters --> $DIR/needs-feature.rs:10:26 | LL | struct A<const N: usize, T=u32>(T); - | -----------------^----- help: reorder the parameters: lifetimes, then consts, then types: `<T, const N: usize>` + | -----------------^----- help: reorder the parameters: lifetimes, then types, then consts: `<T, const N: usize>` error: aborting due to previous error diff --git a/src/test/ui/const-generics/derive-debug-array-wrapper.rs b/src/test/ui/const-generics/derive-debug-array-wrapper.rs index 36272ae8619..13fd87f1e3e 100644 --- a/src/test/ui/const-generics/derive-debug-array-wrapper.rs +++ b/src/test/ui/const-generics/derive-debug-array-wrapper.rs @@ -1,7 +1,10 @@ +// Check that deriving debug on struct with const is permitted. // run-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] #[derive(Debug)] struct X<const N: usize> { diff --git a/src/test/ui/const-generics/derive-debug-array-wrapper.stderr b/src/test/ui/const-generics/derive-debug-array-wrapper.stderr deleted file mode 100644 index 8f7ab822554..00000000000 --- a/src/test/ui/const-generics/derive-debug-array-wrapper.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/derive-debug-array-wrapper.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/different_byref.full.stderr b/src/test/ui/const-generics/different_byref.full.stderr new file mode 100644 index 00000000000..4463ed7fcdd --- /dev/null +++ b/src/test/ui/const-generics/different_byref.full.stderr @@ -0,0 +1,12 @@ +error[E0308]: mismatched types + --> $DIR/different_byref.rs:13:9 + | +LL | x = Const::<{ [4] }> {}; + | ^^^^^^^^^^^^^^^^^^^ expected `3_usize`, found `4_usize` + | + = note: expected type `[3_usize]` + found type `[4_usize]` + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/const-generics/different_byref.min.stderr b/src/test/ui/const-generics/different_byref.min.stderr new file mode 100644 index 00000000000..770491179ab --- /dev/null +++ b/src/test/ui/const-generics/different_byref.min.stderr @@ -0,0 +1,11 @@ +error: using `[usize; 1]` as const generic parameters is forbidden + --> $DIR/different_byref.rs:8:23 + | +LL | struct Const<const V: [usize; 1]> {} + | ^^^^^^^^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: aborting due to previous error + diff --git a/src/test/ui/const-generics/different_byref.rs b/src/test/ui/const-generics/different_byref.rs index 78964eb3dee..ec85ed775d4 100644 --- a/src/test/ui/const-generics/different_byref.rs +++ b/src/test/ui/const-generics/different_byref.rs @@ -1,11 +1,15 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// Check that different const types are different. +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] struct Const<const V: [usize; 1]> {} +//[min]~^ using `[usize; 1]` as const generic parameters is forbidden fn main() { let mut x = Const::<{ [3] }> {}; x = Const::<{ [4] }> {}; - //~^ ERROR mismatched types - + //[full]~^ ERROR mismatched types } diff --git a/src/test/ui/const-generics/different_byref.stderr b/src/test/ui/const-generics/different_byref.stderr deleted file mode 100644 index a3f331ee811..00000000000 --- a/src/test/ui/const-generics/different_byref.stderr +++ /dev/null @@ -1,21 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/different_byref.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error[E0308]: mismatched types - --> $DIR/different_byref.rs:8:9 - | -LL | x = Const::<{ [4] }> {}; - | ^^^^^^^^^^^^^^^^^^^ expected `3_usize`, found `4_usize` - | - = note: expected type `[3_usize]` - found type `[4_usize]` - -error: aborting due to previous error; 1 warning emitted - -For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/const-generics/different_byref_simple.full.stderr b/src/test/ui/const-generics/different_byref_simple.full.stderr new file mode 100644 index 00000000000..b6729c852ab --- /dev/null +++ b/src/test/ui/const-generics/different_byref_simple.full.stderr @@ -0,0 +1,12 @@ +error[E0308]: mismatched types + --> $DIR/different_byref_simple.rs:12:9 + | +LL | u = ConstUsize::<4> {}; + | ^^^^^^^^^^^^^^^^^^ expected `3_usize`, found `4_usize` + | + = note: expected struct `ConstUsize<3_usize>` + found struct `ConstUsize<4_usize>` + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/const-generics/different_byref_simple.min.stderr b/src/test/ui/const-generics/different_byref_simple.min.stderr new file mode 100644 index 00000000000..b6729c852ab --- /dev/null +++ b/src/test/ui/const-generics/different_byref_simple.min.stderr @@ -0,0 +1,12 @@ +error[E0308]: mismatched types + --> $DIR/different_byref_simple.rs:12:9 + | +LL | u = ConstUsize::<4> {}; + | ^^^^^^^^^^^^^^^^^^ expected `3_usize`, found `4_usize` + | + = note: expected struct `ConstUsize<3_usize>` + found struct `ConstUsize<4_usize>` + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/const-generics/different_byref_simple.rs b/src/test/ui/const-generics/different_byref_simple.rs new file mode 100644 index 00000000000..93289f93331 --- /dev/null +++ b/src/test/ui/const-generics/different_byref_simple.rs @@ -0,0 +1,14 @@ +// Check that different const types are different. +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] + +struct ConstUsize<const V: usize> {} + +fn main() { + let mut u = ConstUsize::<3> {}; + u = ConstUsize::<4> {}; + //~^ ERROR mismatched types +} diff --git a/src/test/ui/const-generics/fn-const-param-call.full.stderr b/src/test/ui/const-generics/fn-const-param-call.full.stderr new file mode 100644 index 00000000000..f1bd8def9ff --- /dev/null +++ b/src/test/ui/const-generics/fn-const-param-call.full.stderr @@ -0,0 +1,14 @@ +error: using function pointers as const generic parameters is forbidden + --> $DIR/fn-const-param-call.rs:12:25 + | +LL | struct Wrapper<const F: fn() -> u32>; + | ^^^^^^^^^^^ + +error: using function pointers as const generic parameters is forbidden + --> $DIR/fn-const-param-call.rs:14:15 + | +LL | impl<const F: fn() -> u32> Wrapper<F> { + | ^^^^^^^^^^^ + +error: aborting due to 2 previous errors + diff --git a/src/test/ui/const-generics/fn-const-param-call.min.stderr b/src/test/ui/const-generics/fn-const-param-call.min.stderr new file mode 100644 index 00000000000..83acd04e464 --- /dev/null +++ b/src/test/ui/const-generics/fn-const-param-call.min.stderr @@ -0,0 +1,20 @@ +error: using function pointers as const generic parameters is forbidden + --> $DIR/fn-const-param-call.rs:12:25 + | +LL | struct Wrapper<const F: fn() -> u32>; + | ^^^^^^^^^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: using function pointers as const generic parameters is forbidden + --> $DIR/fn-const-param-call.rs:14:15 + | +LL | impl<const F: fn() -> u32> Wrapper<F> { + | ^^^^^^^^^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: aborting due to 2 previous errors + diff --git a/src/test/ui/const-generics/fn-const-param-call.rs b/src/test/ui/const-generics/fn-const-param-call.rs index 90c438b05cb..bba6c1f7a16 100644 --- a/src/test/ui/const-generics/fn-const-param-call.rs +++ b/src/test/ui/const-generics/fn-const-param-call.rs @@ -1,5 +1,9 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// Check that functions cannot be used as const parameters. +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] fn function() -> u32 { 17 diff --git a/src/test/ui/const-generics/fn-const-param-call.stderr b/src/test/ui/const-generics/fn-const-param-call.stderr deleted file mode 100644 index b5811243caa..00000000000 --- a/src/test/ui/const-generics/fn-const-param-call.stderr +++ /dev/null @@ -1,23 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/fn-const-param-call.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error: using function pointers as const generic parameters is forbidden - --> $DIR/fn-const-param-call.rs:8:25 - | -LL | struct Wrapper<const F: fn() -> u32>; - | ^^^^^^^^^^^ - -error: using function pointers as const generic parameters is forbidden - --> $DIR/fn-const-param-call.rs:10:15 - | -LL | impl<const F: fn() -> u32> Wrapper<F> { - | ^^^^^^^^^^^ - -error: aborting due to 2 previous errors; 1 warning emitted - diff --git a/src/test/ui/const-generics/fn-const-param-infer.full.stderr b/src/test/ui/const-generics/fn-const-param-infer.full.stderr new file mode 100644 index 00000000000..4bdc9b89af6 --- /dev/null +++ b/src/test/ui/const-generics/fn-const-param-infer.full.stderr @@ -0,0 +1,8 @@ +error: using function pointers as const generic parameters is forbidden + --> $DIR/fn-const-param-infer.rs:7:25 + | +LL | struct Checked<const F: fn(usize) -> bool>; + | ^^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/src/test/ui/const-generics/fn-const-param-infer.min.stderr b/src/test/ui/const-generics/fn-const-param-infer.min.stderr new file mode 100644 index 00000000000..27d1101cbcb --- /dev/null +++ b/src/test/ui/const-generics/fn-const-param-infer.min.stderr @@ -0,0 +1,11 @@ +error: using function pointers as const generic parameters is forbidden + --> $DIR/fn-const-param-infer.rs:7:25 + | +LL | struct Checked<const F: fn(usize) -> bool>; + | ^^^^^^^^^^^^^^^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: aborting due to previous error + diff --git a/src/test/ui/const-generics/fn-const-param-infer.rs b/src/test/ui/const-generics/fn-const-param-infer.rs index 14fa3b494b3..3ed75e7b00d 100644 --- a/src/test/ui/const-generics/fn-const-param-infer.rs +++ b/src/test/ui/const-generics/fn-const-param-infer.rs @@ -1,5 +1,8 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] struct Checked<const F: fn(usize) -> bool>; //~^ ERROR: using function pointers as const generic parameters diff --git a/src/test/ui/const-generics/fn-const-param-infer.stderr b/src/test/ui/const-generics/fn-const-param-infer.stderr deleted file mode 100644 index 7aaa41eb7d7..00000000000 --- a/src/test/ui/const-generics/fn-const-param-infer.stderr +++ /dev/null @@ -1,17 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/fn-const-param-infer.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error: using function pointers as const generic parameters is forbidden - --> $DIR/fn-const-param-infer.rs:4:25 - | -LL | struct Checked<const F: fn(usize) -> bool>; - | ^^^^^^^^^^^^^^^^^ - -error: aborting due to previous error; 1 warning emitted - diff --git a/src/test/ui/const-generics/fn-taking-const-generic-array.rs b/src/test/ui/const-generics/fn-taking-const-generic-array.rs index 8e16221ed4b..950684aaa8d 100644 --- a/src/test/ui/const-generics/fn-taking-const-generic-array.rs +++ b/src/test/ui/const-generics/fn-taking-const-generic-array.rs @@ -1,7 +1,9 @@ // run-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] use std::fmt::Display; diff --git a/src/test/ui/const-generics/fn-taking-const-generic-array.stderr b/src/test/ui/const-generics/fn-taking-const-generic-array.stderr deleted file mode 100644 index 52fd0a8fec0..00000000000 --- a/src/test/ui/const-generics/fn-taking-const-generic-array.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/fn-taking-const-generic-array.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/forbid-non-structural_match-types.full.stderr b/src/test/ui/const-generics/forbid-non-structural_match-types.full.stderr new file mode 100644 index 00000000000..adcaa759963 --- /dev/null +++ b/src/test/ui/const-generics/forbid-non-structural_match-types.full.stderr @@ -0,0 +1,9 @@ +error[E0741]: `C` must be annotated with `#[derive(PartialEq, Eq)]` to be used as the type of a const parameter + --> $DIR/forbid-non-structural_match-types.rs:15:19 + | +LL | struct D<const X: C>; + | ^ `C` doesn't derive both `PartialEq` and `Eq` + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0741`. diff --git a/src/test/ui/const-generics/forbid-non-structural_match-types.min.stderr b/src/test/ui/const-generics/forbid-non-structural_match-types.min.stderr new file mode 100644 index 00000000000..25aa3540223 --- /dev/null +++ b/src/test/ui/const-generics/forbid-non-structural_match-types.min.stderr @@ -0,0 +1,27 @@ +error: using `A` as const generic parameters is forbidden + --> $DIR/forbid-non-structural_match-types.rs:10:19 + | +LL | struct B<const X: A>; // ok + | ^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: using `C` as const generic parameters is forbidden + --> $DIR/forbid-non-structural_match-types.rs:15:19 + | +LL | struct D<const X: C>; + | ^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error[E0741]: `C` must be annotated with `#[derive(PartialEq, Eq)]` to be used as the type of a const parameter + --> $DIR/forbid-non-structural_match-types.rs:15:19 + | +LL | struct D<const X: C>; + | ^ `C` doesn't derive both `PartialEq` and `Eq` + +error: aborting due to 3 previous errors + +For more information about this error, try `rustc --explain E0741`. diff --git a/src/test/ui/const-generics/forbid-non-structural_match-types.rs b/src/test/ui/const-generics/forbid-non-structural_match-types.rs index 514e215ba1a..86540db2d03 100644 --- a/src/test/ui/const-generics/forbid-non-structural_match-types.rs +++ b/src/test/ui/const-generics/forbid-non-structural_match-types.rs @@ -1,13 +1,18 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] #[derive(PartialEq, Eq)] struct A; struct B<const X: A>; // ok +//[min]~^ ERROR using `A` as const generic parameters is forbidden struct C; struct D<const X: C>; //~ ERROR `C` must be annotated with `#[derive(PartialEq, Eq)]` +//[min]~^ ERROR using `C` as const generic parameters is forbidden fn main() {} diff --git a/src/test/ui/const-generics/forbid-non-structural_match-types.stderr b/src/test/ui/const-generics/forbid-non-structural_match-types.stderr deleted file mode 100644 index 600be64b1e1..00000000000 --- a/src/test/ui/const-generics/forbid-non-structural_match-types.stderr +++ /dev/null @@ -1,18 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/forbid-non-structural_match-types.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error[E0741]: `C` must be annotated with `#[derive(PartialEq, Eq)]` to be used as the type of a const parameter - --> $DIR/forbid-non-structural_match-types.rs:11:19 - | -LL | struct D<const X: C>; - | ^ `C` doesn't derive both `PartialEq` and `Eq` - -error: aborting due to previous error; 1 warning emitted - -For more information about this error, try `rustc --explain E0741`. diff --git a/src/test/ui/const-generics/foreign-item-const-parameter.stderr b/src/test/ui/const-generics/foreign-item-const-parameter.full.stderr index ee947943af1..0ac51e8c9e6 100644 --- a/src/test/ui/const-generics/foreign-item-const-parameter.stderr +++ b/src/test/ui/const-generics/foreign-item-const-parameter.full.stderr @@ -1,14 +1,5 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/foreign-item-const-parameter.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - error[E0044]: foreign items may not have const parameters - --> $DIR/foreign-item-const-parameter.rs:5:5 + --> $DIR/foreign-item-const-parameter.rs:8:5 | LL | fn foo<const X: usize>(); | ^^^^^^^^^^^^^^^^^^^^^^^^^ can't have const parameters @@ -16,13 +7,13 @@ LL | fn foo<const X: usize>(); = help: replace the const parameters with concrete consts error[E0044]: foreign items may not have type or const parameters - --> $DIR/foreign-item-const-parameter.rs:7:5 + --> $DIR/foreign-item-const-parameter.rs:10:5 | LL | fn bar<T, const X: usize>(_: T); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ can't have type or const parameters | = help: replace the type or const parameters with concrete types or consts -error: aborting due to 2 previous errors; 1 warning emitted +error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0044`. diff --git a/src/test/ui/const-generics/foreign-item-const-parameter.min.stderr b/src/test/ui/const-generics/foreign-item-const-parameter.min.stderr new file mode 100644 index 00000000000..0ac51e8c9e6 --- /dev/null +++ b/src/test/ui/const-generics/foreign-item-const-parameter.min.stderr @@ -0,0 +1,19 @@ +error[E0044]: foreign items may not have const parameters + --> $DIR/foreign-item-const-parameter.rs:8:5 + | +LL | fn foo<const X: usize>(); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ can't have const parameters + | + = help: replace the const parameters with concrete consts + +error[E0044]: foreign items may not have type or const parameters + --> $DIR/foreign-item-const-parameter.rs:10:5 + | +LL | fn bar<T, const X: usize>(_: T); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ can't have type or const parameters + | + = help: replace the type or const parameters with concrete types or consts + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0044`. diff --git a/src/test/ui/const-generics/foreign-item-const-parameter.rs b/src/test/ui/const-generics/foreign-item-const-parameter.rs index 41113780de3..44b6d0332c3 100644 --- a/src/test/ui/const-generics/foreign-item-const-parameter.rs +++ b/src/test/ui/const-generics/foreign-item-const-parameter.rs @@ -1,5 +1,8 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] extern "C" { fn foo<const X: usize>(); //~ ERROR foreign items may not have const parameters diff --git a/src/test/ui/const-generics/impl-const-generic-struct.rs b/src/test/ui/const-generics/impl-const-generic-struct.rs index 4c2aee59ffe..05cabc46baa 100644 --- a/src/test/ui/const-generics/impl-const-generic-struct.rs +++ b/src/test/ui/const-generics/impl-const-generic-struct.rs @@ -1,7 +1,9 @@ // run-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] struct S<const X: u32>; diff --git a/src/test/ui/const-generics/impl-const-generic-struct.stderr b/src/test/ui/const-generics/impl-const-generic-struct.stderr deleted file mode 100644 index 9d68df07ce6..00000000000 --- a/src/test/ui/const-generics/impl-const-generic-struct.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/impl-const-generic-struct.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/incorrect-number-of-const-args.full.stderr b/src/test/ui/const-generics/incorrect-number-of-const-args.full.stderr new file mode 100644 index 00000000000..6b902e2d658 --- /dev/null +++ b/src/test/ui/const-generics/incorrect-number-of-const-args.full.stderr @@ -0,0 +1,15 @@ +error[E0107]: wrong number of const arguments: expected 2, found 1 + --> $DIR/incorrect-number-of-const-args.rs:12:5 + | +LL | foo::<0>(); + | ^^^^^^^^ expected 2 const arguments + +error[E0107]: wrong number of const arguments: expected 2, found 3 + --> $DIR/incorrect-number-of-const-args.rs:13:17 + | +LL | foo::<0, 0, 0>(); + | ^ unexpected const argument + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0107`. diff --git a/src/test/ui/const-generics/incorrect-number-of-const-args.min.stderr b/src/test/ui/const-generics/incorrect-number-of-const-args.min.stderr new file mode 100644 index 00000000000..6b902e2d658 --- /dev/null +++ b/src/test/ui/const-generics/incorrect-number-of-const-args.min.stderr @@ -0,0 +1,15 @@ +error[E0107]: wrong number of const arguments: expected 2, found 1 + --> $DIR/incorrect-number-of-const-args.rs:12:5 + | +LL | foo::<0>(); + | ^^^^^^^^ expected 2 const arguments + +error[E0107]: wrong number of const arguments: expected 2, found 3 + --> $DIR/incorrect-number-of-const-args.rs:13:17 + | +LL | foo::<0, 0, 0>(); + | ^ unexpected const argument + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0107`. diff --git a/src/test/ui/const-generics/incorrect-number-of-const-args.rs b/src/test/ui/const-generics/incorrect-number-of-const-args.rs index cea64654e11..f7bdf761f7d 100644 --- a/src/test/ui/const-generics/incorrect-number-of-const-args.rs +++ b/src/test/ui/const-generics/incorrect-number-of-const-args.rs @@ -1,5 +1,8 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] fn foo<const X: usize, const Y: usize>() -> usize { 0 diff --git a/src/test/ui/const-generics/incorrect-number-of-const-args.stderr b/src/test/ui/const-generics/incorrect-number-of-const-args.stderr deleted file mode 100644 index 51064d7f90f..00000000000 --- a/src/test/ui/const-generics/incorrect-number-of-const-args.stderr +++ /dev/null @@ -1,24 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/incorrect-number-of-const-args.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error[E0107]: wrong number of const arguments: expected 2, found 1 - --> $DIR/incorrect-number-of-const-args.rs:9:5 - | -LL | foo::<0>(); - | ^^^^^^^^ expected 2 const arguments - -error[E0107]: wrong number of const arguments: expected 2, found 3 - --> $DIR/incorrect-number-of-const-args.rs:10:17 - | -LL | foo::<0, 0, 0>(); - | ^ unexpected const argument - -error: aborting due to 2 previous errors; 1 warning emitted - -For more information about this error, try `rustc --explain E0107`. diff --git a/src/test/ui/const-generics/infer_arg_from_pat.rs b/src/test/ui/const-generics/infer_arg_from_pat.rs index 7e8152dacc4..609fdb35cf1 100644 --- a/src/test/ui/const-generics/infer_arg_from_pat.rs +++ b/src/test/ui/const-generics/infer_arg_from_pat.rs @@ -1,8 +1,11 @@ // run-pass // // see issue #70529 -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] struct A<const N: usize> { arr: [u8; N], diff --git a/src/test/ui/const-generics/infer_arg_from_pat.stderr b/src/test/ui/const-generics/infer_arg_from_pat.stderr deleted file mode 100644 index f52e5e49a3b..00000000000 --- a/src/test/ui/const-generics/infer_arg_from_pat.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/infer_arg_from_pat.rs:4:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/infer_arr_len_from_pat.rs b/src/test/ui/const-generics/infer_arr_len_from_pat.rs index cede9ea045d..cbf48e3d249 100644 --- a/src/test/ui/const-generics/infer_arr_len_from_pat.rs +++ b/src/test/ui/const-generics/infer_arr_len_from_pat.rs @@ -1,8 +1,11 @@ // check-pass // // see issue #70529 -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] fn as_chunks<const N: usize>() -> [u8; N] { loop {} diff --git a/src/test/ui/const-generics/infer_arr_len_from_pat.stderr b/src/test/ui/const-generics/infer_arr_len_from_pat.stderr deleted file mode 100644 index dfadfbb1663..00000000000 --- a/src/test/ui/const-generics/infer_arr_len_from_pat.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/infer_arr_len_from_pat.rs:4:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/integer-literal-generic-arg-in-where-clause.rs b/src/test/ui/const-generics/integer-literal-generic-arg-in-where-clause.rs index 952e05bac30..bdbf338295c 100644 --- a/src/test/ui/const-generics/integer-literal-generic-arg-in-where-clause.rs +++ b/src/test/ui/const-generics/integer-literal-generic-arg-in-where-clause.rs @@ -1,7 +1,9 @@ // check-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] fn takes_closure_of_array_3<F>(f: F) where F: Fn([i32; 3]) { f([1, 2, 3]); @@ -15,4 +17,7 @@ fn returns_closure_of_array_3() -> impl Fn([i32; 3]) { |_| {} } -fn main() {} +fn main() { + takes_closure_of_array_3(returns_closure_of_array_3()); + takes_closure_of_array_3_apit(returns_closure_of_array_3()); +} diff --git a/src/test/ui/const-generics/integer-literal-generic-arg-in-where-clause.stderr b/src/test/ui/const-generics/integer-literal-generic-arg-in-where-clause.stderr deleted file mode 100644 index aadd10e5cca..00000000000 --- a/src/test/ui/const-generics/integer-literal-generic-arg-in-where-clause.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/integer-literal-generic-arg-in-where-clause.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/issue-61522-array-len-succ.full.stderr b/src/test/ui/const-generics/issue-61522-array-len-succ.full.stderr new file mode 100644 index 00000000000..8855f187e97 --- /dev/null +++ b/src/test/ui/const-generics/issue-61522-array-len-succ.full.stderr @@ -0,0 +1,18 @@ +error: constant expression depends on a generic parameter + --> $DIR/issue-61522-array-len-succ.rs:7:40 + | +LL | pub struct MyArray<const COUNT: usize>([u8; COUNT + 1]); + | ^^^^^^^^^^^^^^^ + | + = note: this may fail depending on what value the parameter takes + +error: constant expression depends on a generic parameter + --> $DIR/issue-61522-array-len-succ.rs:12:24 + | +LL | fn inner(&self) -> &[u8; COUNT + 1] { + | ^^^^^^^^^^^^^^^^ + | + = note: this may fail depending on what value the parameter takes + +error: aborting due to 2 previous errors + diff --git a/src/test/ui/const-generics/issue-61522-array-len-succ.min.stderr b/src/test/ui/const-generics/issue-61522-array-len-succ.min.stderr new file mode 100644 index 00000000000..a1b1a095041 --- /dev/null +++ b/src/test/ui/const-generics/issue-61522-array-len-succ.min.stderr @@ -0,0 +1,18 @@ +error: generic parameters must not be used inside of non trivial constant values + --> $DIR/issue-61522-array-len-succ.rs:7:45 + | +LL | pub struct MyArray<const COUNT: usize>([u8; COUNT + 1]); + | ^^^^^ non-trivial anonymous constants must not depend on the parameter `COUNT` + | + = help: it is currently only allowed to use either `COUNT` or `{ COUNT }` as generic constants + +error: generic parameters must not be used inside of non trivial constant values + --> $DIR/issue-61522-array-len-succ.rs:12:30 + | +LL | fn inner(&self) -> &[u8; COUNT + 1] { + | ^^^^^ non-trivial anonymous constants must not depend on the parameter `COUNT` + | + = help: it is currently only allowed to use either `COUNT` or `{ COUNT }` as generic constants + +error: aborting due to 2 previous errors + diff --git a/src/test/ui/const-generics/issue-61522-array-len-succ.rs b/src/test/ui/const-generics/issue-61522-array-len-succ.rs index 7c8cdeece87..81443b90d61 100644 --- a/src/test/ui/const-generics/issue-61522-array-len-succ.rs +++ b/src/test/ui/const-generics/issue-61522-array-len-succ.rs @@ -1,12 +1,17 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] pub struct MyArray<const COUNT: usize>([u8; COUNT + 1]); -//~^ ERROR constant expression depends on a generic parameter +//[full]~^ ERROR constant expression depends on a generic parameter +//[min]~^^ ERROR generic parameters must not be used impl<const COUNT: usize> MyArray<COUNT> { fn inner(&self) -> &[u8; COUNT + 1] { - //~^ ERROR constant expression depends on a generic parameter + //[full]~^ ERROR constant expression depends on a generic parameter + //[min]~^^ ERROR generic parameters must not be used &self.0 } } diff --git a/src/test/ui/const-generics/issue-61522-array-len-succ.stderr b/src/test/ui/const-generics/issue-61522-array-len-succ.stderr deleted file mode 100644 index a1fbd5f2025..00000000000 --- a/src/test/ui/const-generics/issue-61522-array-len-succ.stderr +++ /dev/null @@ -1,27 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/issue-61522-array-len-succ.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error: constant expression depends on a generic parameter - --> $DIR/issue-61522-array-len-succ.rs:4:40 - | -LL | pub struct MyArray<const COUNT: usize>([u8; COUNT + 1]); - | ^^^^^^^^^^^^^^^ - | - = note: this may fail depending on what value the parameter takes - -error: constant expression depends on a generic parameter - --> $DIR/issue-61522-array-len-succ.rs:8:24 - | -LL | fn inner(&self) -> &[u8; COUNT + 1] { - | ^^^^^^^^^^^^^^^^ - | - = note: this may fail depending on what value the parameter takes - -error: aborting due to 2 previous errors; 1 warning emitted - diff --git a/src/test/ui/const-generics/issue-66596-impl-trait-for-str-const-arg.min.stderr b/src/test/ui/const-generics/issue-66596-impl-trait-for-str-const-arg.min.stderr new file mode 100644 index 00000000000..3ff17ddb3bc --- /dev/null +++ b/src/test/ui/const-generics/issue-66596-impl-trait-for-str-const-arg.min.stderr @@ -0,0 +1,11 @@ +error: using `&'static str` as const generic parameters is forbidden + --> $DIR/issue-66596-impl-trait-for-str-const-arg.rs:9:25 + | +LL | trait Trait<const NAME: &'static str> { + | ^^^^^^^^^^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: aborting due to previous error + diff --git a/src/test/ui/const-generics/issue-66596-impl-trait-for-str-const-arg.rs b/src/test/ui/const-generics/issue-66596-impl-trait-for-str-const-arg.rs index 74f036e6d89..d458a366fb3 100644 --- a/src/test/ui/const-generics/issue-66596-impl-trait-for-str-const-arg.rs +++ b/src/test/ui/const-generics/issue-66596-impl-trait-for-str-const-arg.rs @@ -1,9 +1,13 @@ -// check-pass +//[full] check-pass +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete trait Trait<const NAME: &'static str> { +//[min]~^ ERROR using `&'static str` as const generic parameters is forbidden type Assoc; } diff --git a/src/test/ui/const-generics/issue-66596-impl-trait-for-str-const-arg.stderr b/src/test/ui/const-generics/issue-66596-impl-trait-for-str-const-arg.stderr deleted file mode 100644 index 720420d9cd6..00000000000 --- a/src/test/ui/const-generics/issue-66596-impl-trait-for-str-const-arg.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/issue-66596-impl-trait-for-str-const-arg.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/issue-68104-print-stack-overflow.rs b/src/test/ui/const-generics/issue-68104-print-stack-overflow.rs index bda9ce8767d..eab63d3a6e6 100644 --- a/src/test/ui/const-generics/issue-68104-print-stack-overflow.rs +++ b/src/test/ui/const-generics/issue-68104-print-stack-overflow.rs @@ -1,8 +1,10 @@ // aux-build:impl-const.rs // run-pass +// revisions: full min -#![feature(const_generics)] -#![allow(incomplete_features)] +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] extern crate impl_const; diff --git a/src/test/ui/const-generics/issue-70180-1-stalled_on.rs b/src/test/ui/const-generics/issue-70180-1-stalled_on.rs index ff2a5250263..9cfa57006d5 100644 --- a/src/test/ui/const-generics/issue-70180-1-stalled_on.rs +++ b/src/test/ui/const-generics/issue-70180-1-stalled_on.rs @@ -1,6 +1,9 @@ // build-pass -#![feature(const_generics)] -#![allow(incomplete_features)] +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] pub fn works() { let array/*: [_; _]*/ = default_array(); diff --git a/src/test/ui/const-generics/issue-70180-2-stalled_on.rs b/src/test/ui/const-generics/issue-70180-2-stalled_on.rs index 83338668f4f..bbde404966c 100644 --- a/src/test/ui/const-generics/issue-70180-2-stalled_on.rs +++ b/src/test/ui/const-generics/issue-70180-2-stalled_on.rs @@ -1,6 +1,9 @@ // build-pass -#![feature(const_generics)] -#![allow(incomplete_features)] +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] fn works() { let array/*: [u8; _]*/ = default_byte_array(); diff --git a/src/test/ui/const-generics/issue-71986.rs b/src/test/ui/const-generics/issue-71986.rs index 048ed18c927..d4c962452d1 100644 --- a/src/test/ui/const-generics/issue-71986.rs +++ b/src/test/ui/const-generics/issue-71986.rs @@ -1,6 +1,9 @@ // check-pass -#![allow(incomplete_features)] -#![feature(const_generics)] +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] pub trait Foo<const B: bool> {} pub fn bar<T: Foo<{ true }>>() {} diff --git a/src/test/ui/const-generics/mut-ref-const-param-array.rs b/src/test/ui/const-generics/mut-ref-const-param-array.rs index 9ca1f4552f5..cf24cbe7e82 100644 --- a/src/test/ui/const-generics/mut-ref-const-param-array.rs +++ b/src/test/ui/const-generics/mut-ref-const-param-array.rs @@ -1,7 +1,10 @@ // run-pass +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete use std::ops::AddAssign; diff --git a/src/test/ui/const-generics/mut-ref-const-param-array.stderr b/src/test/ui/const-generics/mut-ref-const-param-array.stderr deleted file mode 100644 index acbc2df1d74..00000000000 --- a/src/test/ui/const-generics/mut-ref-const-param-array.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/mut-ref-const-param-array.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/nested-type.stderr b/src/test/ui/const-generics/nested-type.full.stderr index da0e8032404..012b8fe587b 100644 --- a/src/test/ui/const-generics/nested-type.stderr +++ b/src/test/ui/const-generics/nested-type.full.stderr @@ -1,154 +1,154 @@ error[E0391]: cycle detected when computing type of `Foo` - --> $DIR/nested-type.rs:4:1 + --> $DIR/nested-type.rs:7:1 | LL | struct Foo<const N: [u8; { | ^^^^^^^^^^^^^^^^^^^^^^^^ | note: ...which requires computing type of `Foo::N`... - --> $DIR/nested-type.rs:4:18 + --> $DIR/nested-type.rs:7:18 | LL | struct Foo<const N: [u8; { | ^ note: ...which requires const-evaluating + checking `Foo::{{constant}}#0`... - --> $DIR/nested-type.rs:4:26 + --> $DIR/nested-type.rs:7:26 | LL | struct Foo<const N: [u8; { | __________________________^ LL | | LL | | -LL | | struct Foo<const N: usize>; +LL | | ... | LL | | Foo::<17>::value() LL | | }]>; | |_^ note: ...which requires const-evaluating + checking `Foo::{{constant}}#0`... - --> $DIR/nested-type.rs:4:26 + --> $DIR/nested-type.rs:7:26 | LL | struct Foo<const N: [u8; { | __________________________^ LL | | LL | | -LL | | struct Foo<const N: usize>; +LL | | ... | LL | | Foo::<17>::value() LL | | }]>; | |_^ note: ...which requires const-evaluating `Foo::{{constant}}#0`... - --> $DIR/nested-type.rs:4:26 + --> $DIR/nested-type.rs:7:26 | LL | struct Foo<const N: [u8; { | __________________________^ LL | | LL | | -LL | | struct Foo<const N: usize>; +LL | | ... | LL | | Foo::<17>::value() LL | | }]>; | |_^ note: ...which requires type-checking `Foo::{{constant}}#0`... - --> $DIR/nested-type.rs:4:26 + --> $DIR/nested-type.rs:7:26 | LL | struct Foo<const N: [u8; { | __________________________^ LL | | LL | | -LL | | struct Foo<const N: usize>; +LL | | ... | LL | | Foo::<17>::value() LL | | }]>; | |_^ note: ...which requires computing the variances of `Foo::{{constant}}#0::Foo`... - --> $DIR/nested-type.rs:7:5 + --> $DIR/nested-type.rs:11:5 | LL | struct Foo<const N: usize>; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ = note: ...which requires computing the variances for items in this crate... = note: ...which again requires computing type of `Foo`, completing the cycle note: cycle used when collecting item types in top-level module - --> $DIR/nested-type.rs:1:1 + --> $DIR/nested-type.rs:3:1 | -LL | / #![feature(const_generics)] -LL | | #![allow(incomplete_features)] +LL | / #![cfg_attr(full, feature(const_generics))] +LL | | #![cfg_attr(full, allow(incomplete_features))] +LL | | #![cfg_attr(min, feature(min_const_generics))] LL | | -LL | | struct Foo<const N: [u8; { ... | LL | | LL | | fn main() {} | |____________^ error[E0391]: cycle detected when computing type of `Foo` - --> $DIR/nested-type.rs:4:1 + --> $DIR/nested-type.rs:7:1 | LL | struct Foo<const N: [u8; { | ^^^^^^^^^^^^^^^^^^^^^^^^ | note: ...which requires computing type of `Foo::N`... - --> $DIR/nested-type.rs:4:18 + --> $DIR/nested-type.rs:7:18 | LL | struct Foo<const N: [u8; { | ^ note: ...which requires const-evaluating + checking `Foo::{{constant}}#0`... - --> $DIR/nested-type.rs:4:26 + --> $DIR/nested-type.rs:7:26 | LL | struct Foo<const N: [u8; { | __________________________^ LL | | LL | | -LL | | struct Foo<const N: usize>; +LL | | ... | LL | | Foo::<17>::value() LL | | }]>; | |_^ note: ...which requires const-evaluating + checking `Foo::{{constant}}#0`... - --> $DIR/nested-type.rs:4:26 + --> $DIR/nested-type.rs:7:26 | LL | struct Foo<const N: [u8; { | __________________________^ LL | | LL | | -LL | | struct Foo<const N: usize>; +LL | | ... | LL | | Foo::<17>::value() LL | | }]>; | |_^ note: ...which requires const-evaluating `Foo::{{constant}}#0`... - --> $DIR/nested-type.rs:4:26 + --> $DIR/nested-type.rs:7:26 | LL | struct Foo<const N: [u8; { | __________________________^ LL | | LL | | -LL | | struct Foo<const N: usize>; +LL | | ... | LL | | Foo::<17>::value() LL | | }]>; | |_^ note: ...which requires type-checking `Foo::{{constant}}#0`... - --> $DIR/nested-type.rs:4:26 + --> $DIR/nested-type.rs:7:26 | LL | struct Foo<const N: [u8; { | __________________________^ LL | | LL | | -LL | | struct Foo<const N: usize>; +LL | | ... | LL | | Foo::<17>::value() LL | | }]>; | |_^ note: ...which requires computing the variances of `Foo::{{constant}}#0::Foo`... - --> $DIR/nested-type.rs:7:5 + --> $DIR/nested-type.rs:11:5 | LL | struct Foo<const N: usize>; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ = note: ...which requires computing the variances for items in this crate... = note: ...which again requires computing type of `Foo`, completing the cycle note: cycle used when collecting item types in top-level module - --> $DIR/nested-type.rs:1:1 + --> $DIR/nested-type.rs:3:1 | -LL | / #![feature(const_generics)] -LL | | #![allow(incomplete_features)] +LL | / #![cfg_attr(full, feature(const_generics))] +LL | | #![cfg_attr(full, allow(incomplete_features))] +LL | | #![cfg_attr(min, feature(min_const_generics))] LL | | -LL | | struct Foo<const N: [u8; { ... | LL | | LL | | fn main() {} diff --git a/src/test/ui/const-generics/nested-type.min.stderr b/src/test/ui/const-generics/nested-type.min.stderr new file mode 100644 index 00000000000..ebe818785ac --- /dev/null +++ b/src/test/ui/const-generics/nested-type.min.stderr @@ -0,0 +1,175 @@ +error: using `[u8; _]` as const generic parameters is forbidden + --> $DIR/nested-type.rs:7:21 + | +LL | struct Foo<const N: [u8; { + | _____________________^ +LL | | +LL | | +LL | | +... | +LL | | Foo::<17>::value() +LL | | }]>; + | |__^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error[E0391]: cycle detected when computing type of `Foo` + --> $DIR/nested-type.rs:7:1 + | +LL | struct Foo<const N: [u8; { + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | +note: ...which requires computing type of `Foo::N`... + --> $DIR/nested-type.rs:7:18 + | +LL | struct Foo<const N: [u8; { + | ^ +note: ...which requires const-evaluating + checking `Foo::{{constant}}#0`... + --> $DIR/nested-type.rs:7:26 + | +LL | struct Foo<const N: [u8; { + | __________________________^ +LL | | +LL | | +LL | | +... | +LL | | Foo::<17>::value() +LL | | }]>; + | |_^ +note: ...which requires const-evaluating + checking `Foo::{{constant}}#0`... + --> $DIR/nested-type.rs:7:26 + | +LL | struct Foo<const N: [u8; { + | __________________________^ +LL | | +LL | | +LL | | +... | +LL | | Foo::<17>::value() +LL | | }]>; + | |_^ +note: ...which requires const-evaluating `Foo::{{constant}}#0`... + --> $DIR/nested-type.rs:7:26 + | +LL | struct Foo<const N: [u8; { + | __________________________^ +LL | | +LL | | +LL | | +... | +LL | | Foo::<17>::value() +LL | | }]>; + | |_^ +note: ...which requires type-checking `Foo::{{constant}}#0`... + --> $DIR/nested-type.rs:7:26 + | +LL | struct Foo<const N: [u8; { + | __________________________^ +LL | | +LL | | +LL | | +... | +LL | | Foo::<17>::value() +LL | | }]>; + | |_^ +note: ...which requires computing the variances of `Foo::{{constant}}#0::Foo`... + --> $DIR/nested-type.rs:11:5 + | +LL | struct Foo<const N: usize>; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + = note: ...which requires computing the variances for items in this crate... + = note: ...which again requires computing type of `Foo`, completing the cycle +note: cycle used when collecting item types in top-level module + --> $DIR/nested-type.rs:3:1 + | +LL | / #![cfg_attr(full, feature(const_generics))] +LL | | #![cfg_attr(full, allow(incomplete_features))] +LL | | #![cfg_attr(min, feature(min_const_generics))] +LL | | +... | +LL | | +LL | | fn main() {} + | |____________^ + +error[E0391]: cycle detected when computing type of `Foo` + --> $DIR/nested-type.rs:7:1 + | +LL | struct Foo<const N: [u8; { + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | +note: ...which requires computing type of `Foo::N`... + --> $DIR/nested-type.rs:7:18 + | +LL | struct Foo<const N: [u8; { + | ^ +note: ...which requires const-evaluating + checking `Foo::{{constant}}#0`... + --> $DIR/nested-type.rs:7:26 + | +LL | struct Foo<const N: [u8; { + | __________________________^ +LL | | +LL | | +LL | | +... | +LL | | Foo::<17>::value() +LL | | }]>; + | |_^ +note: ...which requires const-evaluating + checking `Foo::{{constant}}#0`... + --> $DIR/nested-type.rs:7:26 + | +LL | struct Foo<const N: [u8; { + | __________________________^ +LL | | +LL | | +LL | | +... | +LL | | Foo::<17>::value() +LL | | }]>; + | |_^ +note: ...which requires const-evaluating `Foo::{{constant}}#0`... + --> $DIR/nested-type.rs:7:26 + | +LL | struct Foo<const N: [u8; { + | __________________________^ +LL | | +LL | | +LL | | +... | +LL | | Foo::<17>::value() +LL | | }]>; + | |_^ +note: ...which requires type-checking `Foo::{{constant}}#0`... + --> $DIR/nested-type.rs:7:26 + | +LL | struct Foo<const N: [u8; { + | __________________________^ +LL | | +LL | | +LL | | +... | +LL | | Foo::<17>::value() +LL | | }]>; + | |_^ +note: ...which requires computing the variances of `Foo::{{constant}}#0::Foo`... + --> $DIR/nested-type.rs:11:5 + | +LL | struct Foo<const N: usize>; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + = note: ...which requires computing the variances for items in this crate... + = note: ...which again requires computing type of `Foo`, completing the cycle +note: cycle used when collecting item types in top-level module + --> $DIR/nested-type.rs:3:1 + | +LL | / #![cfg_attr(full, feature(const_generics))] +LL | | #![cfg_attr(full, allow(incomplete_features))] +LL | | #![cfg_attr(min, feature(min_const_generics))] +LL | | +... | +LL | | +LL | | fn main() {} + | |____________^ + +error: aborting due to 3 previous errors + +For more information about this error, try `rustc --explain E0391`. diff --git a/src/test/ui/const-generics/nested-type.rs b/src/test/ui/const-generics/nested-type.rs index 12ea850c8f6..98a5a0dd3d8 100644 --- a/src/test/ui/const-generics/nested-type.rs +++ b/src/test/ui/const-generics/nested-type.rs @@ -1,9 +1,13 @@ -#![feature(const_generics)] -#![allow(incomplete_features)] +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] struct Foo<const N: [u8; { //~^ ERROR cycle detected //~| ERROR cycle detected +//[min]~| ERROR using `[u8; _]` as const generic struct Foo<const N: usize>; impl<const N: usize> Foo<N> { diff --git a/src/test/ui/const-generics/params-in-ct-in-ty-param-lazy-norm.stderr b/src/test/ui/const-generics/params-in-ct-in-ty-param-lazy-norm.full.stderr index 571be91683b..3dccfd73dcc 100644 --- a/src/test/ui/const-generics/params-in-ct-in-ty-param-lazy-norm.stderr +++ b/src/test/ui/const-generics/params-in-ct-in-ty-param-lazy-norm.full.stderr @@ -1,5 +1,5 @@ error: type parameters with a default must be trailing - --> $DIR/params-in-ct-in-ty-param-lazy-norm.rs:7:12 + --> $DIR/params-in-ct-in-ty-param-lazy-norm.rs:12:12 | LL | struct Bar<T = [u8; N], const N: usize>(T); | ^ @@ -7,25 +7,16 @@ LL | struct Bar<T = [u8; N], const N: usize>(T); = note: using type defaults and const parameters in the same parameter list is currently not permitted error: constant values inside of type parameter defaults must not depend on generic parameters - --> $DIR/params-in-ct-in-ty-param-lazy-norm.rs:3:44 + --> $DIR/params-in-ct-in-ty-param-lazy-norm.rs:7:44 | LL | struct Foo<T, U = [u8; std::mem::size_of::<T>()]>(T, U); | ^ the anonymous constant must not depend on the parameter `T` error: constant values inside of type parameter defaults must not depend on generic parameters - --> $DIR/params-in-ct-in-ty-param-lazy-norm.rs:7:21 + --> $DIR/params-in-ct-in-ty-param-lazy-norm.rs:12:21 | LL | struct Bar<T = [u8; N], const N: usize>(T); | ^ the anonymous constant must not depend on the parameter `N` -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/params-in-ct-in-ty-param-lazy-norm.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error: aborting due to 3 previous errors; 1 warning emitted +error: aborting due to 3 previous errors diff --git a/src/test/ui/const-generics/params-in-ct-in-ty-param-lazy-norm.min.stderr b/src/test/ui/const-generics/params-in-ct-in-ty-param-lazy-norm.min.stderr new file mode 100644 index 00000000000..461822a9608 --- /dev/null +++ b/src/test/ui/const-generics/params-in-ct-in-ty-param-lazy-norm.min.stderr @@ -0,0 +1,24 @@ +error: type parameters with a default must be trailing + --> $DIR/params-in-ct-in-ty-param-lazy-norm.rs:12:12 + | +LL | struct Bar<T = [u8; N], const N: usize>(T); + | ^ + | + = note: using type defaults and const parameters in the same parameter list is currently not permitted + +error: generic parameters must not be used inside of non trivial constant values + --> $DIR/params-in-ct-in-ty-param-lazy-norm.rs:7:44 + | +LL | struct Foo<T, U = [u8; std::mem::size_of::<T>()]>(T, U); + | ^ non-trivial anonymous constants must not depend on the parameter `T` + | + = help: it is currently only allowed to use either `T` or `{ T }` as generic constants + +error: constant values inside of type parameter defaults must not depend on generic parameters + --> $DIR/params-in-ct-in-ty-param-lazy-norm.rs:12:21 + | +LL | struct Bar<T = [u8; N], const N: usize>(T); + | ^ the anonymous constant must not depend on the parameter `N` + +error: aborting due to 3 previous errors + diff --git a/src/test/ui/const-generics/params-in-ct-in-ty-param-lazy-norm.rs b/src/test/ui/const-generics/params-in-ct-in-ty-param-lazy-norm.rs index 84bbea5b880..e52773c78db 100644 --- a/src/test/ui/const-generics/params-in-ct-in-ty-param-lazy-norm.rs +++ b/src/test/ui/const-generics/params-in-ct-in-ty-param-lazy-norm.rs @@ -1,7 +1,12 @@ -#![feature(const_generics)] //~ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] struct Foo<T, U = [u8; std::mem::size_of::<T>()]>(T, U); -//~^ ERROR constant values inside of type parameter defaults +//[full]~^ ERROR constant values inside of type parameter defaults +//[min]~^^ ERROR generic parameters must not be used inside of non trivial // FIXME(const_generics:defaults): We still don't know how to we deal with type defaults. struct Bar<T = [u8; N], const N: usize>(T); diff --git a/src/test/ui/const-generics/raw-ptr-const-param-deref.full.stderr b/src/test/ui/const-generics/raw-ptr-const-param-deref.full.stderr new file mode 100644 index 00000000000..ffaab51f766 --- /dev/null +++ b/src/test/ui/const-generics/raw-ptr-const-param-deref.full.stderr @@ -0,0 +1,14 @@ +error: using raw pointers as const generic parameters is forbidden + --> $DIR/raw-ptr-const-param-deref.rs:10:23 + | +LL | struct Const<const P: *const u32>; + | ^^^^^^^^^^ + +error: using raw pointers as const generic parameters is forbidden + --> $DIR/raw-ptr-const-param-deref.rs:12:15 + | +LL | impl<const P: *const u32> Const<P> { + | ^^^^^^^^^^ + +error: aborting due to 2 previous errors + diff --git a/src/test/ui/const-generics/raw-ptr-const-param-deref.min.stderr b/src/test/ui/const-generics/raw-ptr-const-param-deref.min.stderr new file mode 100644 index 00000000000..dc4bb8b0f04 --- /dev/null +++ b/src/test/ui/const-generics/raw-ptr-const-param-deref.min.stderr @@ -0,0 +1,20 @@ +error: using raw pointers as const generic parameters is forbidden + --> $DIR/raw-ptr-const-param-deref.rs:10:23 + | +LL | struct Const<const P: *const u32>; + | ^^^^^^^^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: using raw pointers as const generic parameters is forbidden + --> $DIR/raw-ptr-const-param-deref.rs:12:15 + | +LL | impl<const P: *const u32> Const<P> { + | ^^^^^^^^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: aborting due to 2 previous errors + diff --git a/src/test/ui/const-generics/raw-ptr-const-param-deref.rs b/src/test/ui/const-generics/raw-ptr-const-param-deref.rs index 97ca9d6a44c..20cc62ebc17 100644 --- a/src/test/ui/const-generics/raw-ptr-const-param-deref.rs +++ b/src/test/ui/const-generics/raw-ptr-const-param-deref.rs @@ -1,5 +1,9 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// Checks that pointers must not be used as the type of const params. +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] const A: u32 = 3; diff --git a/src/test/ui/const-generics/raw-ptr-const-param-deref.stderr b/src/test/ui/const-generics/raw-ptr-const-param-deref.stderr deleted file mode 100644 index 1ce8bb9c054..00000000000 --- a/src/test/ui/const-generics/raw-ptr-const-param-deref.stderr +++ /dev/null @@ -1,23 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/raw-ptr-const-param-deref.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error: using raw pointers as const generic parameters is forbidden - --> $DIR/raw-ptr-const-param-deref.rs:6:23 - | -LL | struct Const<const P: *const u32>; - | ^^^^^^^^^^ - -error: using raw pointers as const generic parameters is forbidden - --> $DIR/raw-ptr-const-param-deref.rs:8:15 - | -LL | impl<const P: *const u32> Const<P> { - | ^^^^^^^^^^ - -error: aborting due to 2 previous errors; 1 warning emitted - diff --git a/src/test/ui/const-generics/raw-ptr-const-param.full.stderr b/src/test/ui/const-generics/raw-ptr-const-param.full.stderr new file mode 100644 index 00000000000..d317aa0f585 --- /dev/null +++ b/src/test/ui/const-generics/raw-ptr-const-param.full.stderr @@ -0,0 +1,8 @@ +error: using raw pointers as const generic parameters is forbidden + --> $DIR/raw-ptr-const-param.rs:7:23 + | +LL | struct Const<const P: *const u32>; + | ^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/src/test/ui/const-generics/raw-ptr-const-param.min.stderr b/src/test/ui/const-generics/raw-ptr-const-param.min.stderr new file mode 100644 index 00000000000..f387974a21a --- /dev/null +++ b/src/test/ui/const-generics/raw-ptr-const-param.min.stderr @@ -0,0 +1,11 @@ +error: using raw pointers as const generic parameters is forbidden + --> $DIR/raw-ptr-const-param.rs:7:23 + | +LL | struct Const<const P: *const u32>; + | ^^^^^^^^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: aborting due to previous error + diff --git a/src/test/ui/const-generics/raw-ptr-const-param.rs b/src/test/ui/const-generics/raw-ptr-const-param.rs index 237b410e073..36e593aa210 100644 --- a/src/test/ui/const-generics/raw-ptr-const-param.rs +++ b/src/test/ui/const-generics/raw-ptr-const-param.rs @@ -1,5 +1,8 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] struct Const<const P: *const u32>; //~ ERROR: using raw pointers as const generic parameters diff --git a/src/test/ui/const-generics/raw-ptr-const-param.stderr b/src/test/ui/const-generics/raw-ptr-const-param.stderr deleted file mode 100644 index 6e64f8a327f..00000000000 --- a/src/test/ui/const-generics/raw-ptr-const-param.stderr +++ /dev/null @@ -1,17 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/raw-ptr-const-param.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error: using raw pointers as const generic parameters is forbidden - --> $DIR/raw-ptr-const-param.rs:4:23 - | -LL | struct Const<const P: *const u32>; - | ^^^^^^^^^^ - -error: aborting due to previous error; 1 warning emitted - diff --git a/src/test/ui/const-generics/slice-const-param-mismatch.stderr b/src/test/ui/const-generics/slice-const-param-mismatch.full.stderr index cc21f197e08..d06da2ef063 100644 --- a/src/test/ui/const-generics/slice-const-param-mismatch.stderr +++ b/src/test/ui/const-generics/slice-const-param-mismatch.full.stderr @@ -1,14 +1,5 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/slice-const-param-mismatch.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - error[E0308]: mismatched types - --> $DIR/slice-const-param-mismatch.rs:9:35 + --> $DIR/slice-const-param-mismatch.rs:15:35 | LL | let _: ConstString<"Hello"> = ConstString::<"World">; | -------------------- ^^^^^^^^^^^^^^^^^^^^^^ expected `"Hello"`, found `"World"` @@ -19,7 +10,7 @@ LL | let _: ConstString<"Hello"> = ConstString::<"World">; found struct `ConstString<"World">` error[E0308]: mismatched types - --> $DIR/slice-const-param-mismatch.rs:11:33 + --> $DIR/slice-const-param-mismatch.rs:17:33 | LL | let _: ConstString<"ℇ㇈↦"> = ConstString::<"ℇ㇈↥">; | ------------------- ^^^^^^^^^^^^^^^^^^^^^ expected `"ℇ㇈↦"`, found `"ℇ㇈↥"` @@ -30,7 +21,7 @@ LL | let _: ConstString<"ℇ㇈↦"> = ConstString::<"ℇ㇈↥">; found struct `ConstString<"ℇ㇈↥">` error[E0308]: mismatched types - --> $DIR/slice-const-param-mismatch.rs:13:33 + --> $DIR/slice-const-param-mismatch.rs:19:33 | LL | let _: ConstBytes<b"AAA"> = ConstBytes::<b"BBB">; | ------------------ ^^^^^^^^^^^^^^^^^^^^ expected `b"AAA"`, found `b"BBB"` @@ -40,6 +31,6 @@ LL | let _: ConstBytes<b"AAA"> = ConstBytes::<b"BBB">; = note: expected struct `ConstBytes<b"AAA">` found struct `ConstBytes<b"BBB">` -error: aborting due to 3 previous errors; 1 warning emitted +error: aborting due to 3 previous errors For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/const-generics/slice-const-param-mismatch.min.stderr b/src/test/ui/const-generics/slice-const-param-mismatch.min.stderr new file mode 100644 index 00000000000..e86f885b9bb --- /dev/null +++ b/src/test/ui/const-generics/slice-const-param-mismatch.min.stderr @@ -0,0 +1,20 @@ +error: using `&'static str` as const generic parameters is forbidden + --> $DIR/slice-const-param-mismatch.rs:8:29 + | +LL | struct ConstString<const T: &'static str>; + | ^^^^^^^^^^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: using `&'static [u8]` as const generic parameters is forbidden + --> $DIR/slice-const-param-mismatch.rs:10:28 + | +LL | struct ConstBytes<const T: &'static [u8]>; + | ^^^^^^^^^^^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: aborting due to 2 previous errors + diff --git a/src/test/ui/const-generics/slice-const-param-mismatch.rs b/src/test/ui/const-generics/slice-const-param-mismatch.rs index 4f321b02b82..0f8ae9bac4a 100644 --- a/src/test/ui/const-generics/slice-const-param-mismatch.rs +++ b/src/test/ui/const-generics/slice-const-param-mismatch.rs @@ -1,14 +1,20 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] + struct ConstString<const T: &'static str>; +//[min]~^ ERROR struct ConstBytes<const T: &'static [u8]>; +//[min]~^ ERROR pub fn main() { let _: ConstString<"Hello"> = ConstString::<"Hello">; - let _: ConstString<"Hello"> = ConstString::<"World">; //~ ERROR mismatched types + let _: ConstString<"Hello"> = ConstString::<"World">; //[full]~ ERROR mismatched types let _: ConstString<"ℇ㇈↦"> = ConstString::<"ℇ㇈↦">; - let _: ConstString<"ℇ㇈↦"> = ConstString::<"ℇ㇈↥">; //~ ERROR mismatched types + let _: ConstString<"ℇ㇈↦"> = ConstString::<"ℇ㇈↥">; //[full]~ ERROR mismatched types let _: ConstBytes<b"AAA"> = ConstBytes::<{&[0x41, 0x41, 0x41]}>; - let _: ConstBytes<b"AAA"> = ConstBytes::<b"BBB">; //~ ERROR mismatched types + let _: ConstBytes<b"AAA"> = ConstBytes::<b"BBB">; //[full]~ ERROR mismatched types } diff --git a/src/test/ui/const-generics/slice-const-param.min.stderr b/src/test/ui/const-generics/slice-const-param.min.stderr new file mode 100644 index 00000000000..e2ffc67c357 --- /dev/null +++ b/src/test/ui/const-generics/slice-const-param.min.stderr @@ -0,0 +1,20 @@ +error: using `&'static str` as const generic parameters is forbidden + --> $DIR/slice-const-param.rs:8:40 + | +LL | pub fn function_with_str<const STRING: &'static str>() -> &'static str { + | ^^^^^^^^^^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: using `&'static [u8]` as const generic parameters is forbidden + --> $DIR/slice-const-param.rs:13:41 + | +LL | pub fn function_with_bytes<const BYTES: &'static [u8]>() -> &'static [u8] { + | ^^^^^^^^^^^^^ + | + = note: the only supported types are integers, `bool` and `char` + = note: more complex types are supported with `#[feature(const_generics)]` + +error: aborting due to 2 previous errors + diff --git a/src/test/ui/const-generics/slice-const-param.rs b/src/test/ui/const-generics/slice-const-param.rs index 9668f7ddabb..1b6d2f6216c 100644 --- a/src/test/ui/const-generics/slice-const-param.rs +++ b/src/test/ui/const-generics/slice-const-param.rs @@ -1,13 +1,17 @@ -// run-pass +//[full] run-pass +// revisions: min full -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] pub fn function_with_str<const STRING: &'static str>() -> &'static str { + //[min]~^ ERROR using `&'static str` as const STRING } pub fn function_with_bytes<const BYTES: &'static [u8]>() -> &'static [u8] { + //[min]~^ ERROR using `&'static [u8]` as const BYTES } diff --git a/src/test/ui/const-generics/slice-const-param.stderr b/src/test/ui/const-generics/slice-const-param.stderr deleted file mode 100644 index 524bd41a669..00000000000 --- a/src/test/ui/const-generics/slice-const-param.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/slice-const-param.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/struct-with-invalid-const-param.full.stderr b/src/test/ui/const-generics/struct-with-invalid-const-param.full.stderr new file mode 100644 index 00000000000..e73a297c878 --- /dev/null +++ b/src/test/ui/const-generics/struct-with-invalid-const-param.full.stderr @@ -0,0 +1,9 @@ +error[E0573]: expected type, found const parameter `C` + --> $DIR/struct-with-invalid-const-param.rs:8:23 + | +LL | struct S<const C: u8>(C); + | ^ not a type + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0573`. diff --git a/src/test/ui/const-generics/struct-with-invalid-const-param.min.stderr b/src/test/ui/const-generics/struct-with-invalid-const-param.min.stderr new file mode 100644 index 00000000000..e73a297c878 --- /dev/null +++ b/src/test/ui/const-generics/struct-with-invalid-const-param.min.stderr @@ -0,0 +1,9 @@ +error[E0573]: expected type, found const parameter `C` + --> $DIR/struct-with-invalid-const-param.rs:8:23 + | +LL | struct S<const C: u8>(C); + | ^ not a type + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0573`. diff --git a/src/test/ui/const-generics/struct-with-invalid-const-param.rs b/src/test/ui/const-generics/struct-with-invalid-const-param.rs index 0b00481d903..f0122ace3ae 100644 --- a/src/test/ui/const-generics/struct-with-invalid-const-param.rs +++ b/src/test/ui/const-generics/struct-with-invalid-const-param.rs @@ -1,5 +1,9 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// Checks that a const param cannot be stored in a struct. +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] struct S<const C: u8>(C); //~ ERROR expected type, found const parameter diff --git a/src/test/ui/const-generics/trait-const-args.rs b/src/test/ui/const-generics/trait-const-args.rs index b60d7e89651..b66d79845f9 100644 --- a/src/test/ui/const-generics/trait-const-args.rs +++ b/src/test/ui/const-generics/trait-const-args.rs @@ -1,6 +1,9 @@ // check-pass -#![allow(incomplete_features)] -#![feature(const_generics)] +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] struct Const<const N: usize>; trait Foo<const N: usize> {} diff --git a/src/test/ui/const-generics/transparent-maybeunit-array-wrapper.rs b/src/test/ui/const-generics/transparent-maybeunit-array-wrapper.rs index 1aed9cfe927..e041e9709d0 100644 --- a/src/test/ui/const-generics/transparent-maybeunit-array-wrapper.rs +++ b/src/test/ui/const-generics/transparent-maybeunit-array-wrapper.rs @@ -1,7 +1,9 @@ // run-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] use std::mem::MaybeUninit; diff --git a/src/test/ui/const-generics/transparent-maybeunit-array-wrapper.stderr b/src/test/ui/const-generics/transparent-maybeunit-array-wrapper.stderr deleted file mode 100644 index 6077fe5b1ed..00000000000 --- a/src/test/ui/const-generics/transparent-maybeunit-array-wrapper.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/transparent-maybeunit-array-wrapper.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/type_of_anon_const.rs b/src/test/ui/const-generics/type_of_anon_const.rs index 588c7b9523a..f424fd03341 100644 --- a/src/test/ui/const-generics/type_of_anon_const.rs +++ b/src/test/ui/const-generics/type_of_anon_const.rs @@ -1,7 +1,9 @@ // run-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] trait T<const A: usize> { fn l<const N: bool>() -> usize; diff --git a/src/test/ui/const-generics/type_of_anon_const.stderr b/src/test/ui/const-generics/type_of_anon_const.stderr deleted file mode 100644 index 8afed0d3986..00000000000 --- a/src/test/ui/const-generics/type_of_anon_const.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/type_of_anon_const.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/uninferred-consts.full.stderr b/src/test/ui/const-generics/uninferred-consts.full.stderr new file mode 100644 index 00000000000..2c5af9e65f8 --- /dev/null +++ b/src/test/ui/const-generics/uninferred-consts.full.stderr @@ -0,0 +1,11 @@ +error[E0282]: type annotations needed + --> $DIR/uninferred-consts.rs:14:5 + | +LL | Foo.foo(); + | ^^^^^^^^^ + | + = note: unable to infer the value of a const parameter + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0282`. diff --git a/src/test/ui/const-generics/uninferred-consts.min.stderr b/src/test/ui/const-generics/uninferred-consts.min.stderr new file mode 100644 index 00000000000..2c5af9e65f8 --- /dev/null +++ b/src/test/ui/const-generics/uninferred-consts.min.stderr @@ -0,0 +1,11 @@ +error[E0282]: type annotations needed + --> $DIR/uninferred-consts.rs:14:5 + | +LL | Foo.foo(); + | ^^^^^^^^^ + | + = note: unable to infer the value of a const parameter + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0282`. diff --git a/src/test/ui/const-generics/uninferred-consts.rs b/src/test/ui/const-generics/uninferred-consts.rs index 3b2bb49197d..ec5b3ffe544 100644 --- a/src/test/ui/const-generics/uninferred-consts.rs +++ b/src/test/ui/const-generics/uninferred-consts.rs @@ -1,5 +1,9 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// Test that we emit an error if we cannot properly infer a constant. +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] // taken from https://github.com/rust-lang/rust/issues/70507#issuecomment-615268893 struct Foo; diff --git a/src/test/ui/const-generics/uninferred-consts.stderr b/src/test/ui/const-generics/uninferred-consts.stderr deleted file mode 100644 index a3620084a42..00000000000 --- a/src/test/ui/const-generics/uninferred-consts.stderr +++ /dev/null @@ -1,20 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/uninferred-consts.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error[E0282]: type annotations needed - --> $DIR/uninferred-consts.rs:10:5 - | -LL | Foo.foo(); - | ^^^^^^^^^ - | - = note: unable to infer the value of a const parameter - -error: aborting due to previous error; 1 warning emitted - -For more information about this error, try `rustc --explain E0282`. diff --git a/src/test/ui/const-generics/unknown_adt.stderr b/src/test/ui/const-generics/unknown_adt.full.stderr index b2e287b762c..94f3165eaec 100644 --- a/src/test/ui/const-generics/unknown_adt.stderr +++ b/src/test/ui/const-generics/unknown_adt.full.stderr @@ -1,5 +1,5 @@ error[E0412]: cannot find type `UnknownStruct` in this scope - --> $DIR/unknown_adt.rs:5:12 + --> $DIR/unknown_adt.rs:8:12 | LL | let _: UnknownStruct<7>; | ^^^^^^^^^^^^^ not found in this scope diff --git a/src/test/ui/const-generics/unknown_adt.min.stderr b/src/test/ui/const-generics/unknown_adt.min.stderr new file mode 100644 index 00000000000..94f3165eaec --- /dev/null +++ b/src/test/ui/const-generics/unknown_adt.min.stderr @@ -0,0 +1,9 @@ +error[E0412]: cannot find type `UnknownStruct` in this scope + --> $DIR/unknown_adt.rs:8:12 + | +LL | let _: UnknownStruct<7>; + | ^^^^^^^^^^^^^ not found in this scope + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0412`. diff --git a/src/test/ui/const-generics/unknown_adt.rs b/src/test/ui/const-generics/unknown_adt.rs index 0ba9945b399..c6131402aeb 100644 --- a/src/test/ui/const-generics/unknown_adt.rs +++ b/src/test/ui/const-generics/unknown_adt.rs @@ -1,5 +1,8 @@ -#![feature(const_generics)] -#![allow(incomplete_features)] +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] fn main() { let _: UnknownStruct<7>; diff --git a/src/test/ui/const-generics/unused-const-param.rs b/src/test/ui/const-generics/unused-const-param.rs index d9292efc21b..3c305167b4b 100644 --- a/src/test/ui/const-generics/unused-const-param.rs +++ b/src/test/ui/const-generics/unused-const-param.rs @@ -1,7 +1,9 @@ // check-pass +// revisions: full min -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] struct A<const N: usize>; // ok diff --git a/src/test/ui/const-generics/unused-const-param.stderr b/src/test/ui/const-generics/unused-const-param.stderr deleted file mode 100644 index be015a689ae..00000000000 --- a/src/test/ui/const-generics/unused-const-param.stderr +++ /dev/null @@ -1,11 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/unused-const-param.rs:3:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -warning: 1 warning emitted - diff --git a/src/test/ui/const-generics/unused_braces.full.fixed b/src/test/ui/const-generics/unused_braces.full.fixed new file mode 100644 index 00000000000..1b075ade16a --- /dev/null +++ b/src/test/ui/const-generics/unused_braces.full.fixed @@ -0,0 +1,17 @@ +// check-pass +// run-rustfix +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] +#![warn(unused_braces)] + + +struct A<const N: usize>; + +fn main() { + let _: A<7>; // ok + let _: A<7>; //~ WARN unnecessary braces + let _: A<{ 3 + 5 }>; // ok +} diff --git a/src/test/ui/const-generics/unused_braces.stderr b/src/test/ui/const-generics/unused_braces.full.stderr index 618698a3234..1752779a60a 100644 --- a/src/test/ui/const-generics/unused_braces.stderr +++ b/src/test/ui/const-generics/unused_braces.full.stderr @@ -1,11 +1,11 @@ warning: unnecessary braces around const expression - --> $DIR/unused_braces.rs:13:14 + --> $DIR/unused_braces.rs:15:14 | LL | let _: A<{ 7 }>; | ^^^^^ help: remove these braces | note: the lint level is defined here - --> $DIR/unused_braces.rs:5:9 + --> $DIR/unused_braces.rs:8:9 | LL | #![warn(unused_braces)] | ^^^^^^^^^^^^^ diff --git a/src/test/ui/const-generics/unused_braces.min.fixed b/src/test/ui/const-generics/unused_braces.min.fixed new file mode 100644 index 00000000000..1b075ade16a --- /dev/null +++ b/src/test/ui/const-generics/unused_braces.min.fixed @@ -0,0 +1,17 @@ +// check-pass +// run-rustfix +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] +#![warn(unused_braces)] + + +struct A<const N: usize>; + +fn main() { + let _: A<7>; // ok + let _: A<7>; //~ WARN unnecessary braces + let _: A<{ 3 + 5 }>; // ok +} diff --git a/src/test/ui/const-generics/unused_braces.min.stderr b/src/test/ui/const-generics/unused_braces.min.stderr new file mode 100644 index 00000000000..1752779a60a --- /dev/null +++ b/src/test/ui/const-generics/unused_braces.min.stderr @@ -0,0 +1,14 @@ +warning: unnecessary braces around const expression + --> $DIR/unused_braces.rs:15:14 + | +LL | let _: A<{ 7 }>; + | ^^^^^ help: remove these braces + | +note: the lint level is defined here + --> $DIR/unused_braces.rs:8:9 + | +LL | #![warn(unused_braces)] + | ^^^^^^^^^^^^^ + +warning: 1 warning emitted + diff --git a/src/test/ui/const-generics/unused_braces.rs b/src/test/ui/const-generics/unused_braces.rs index c3e02b45ed5..31c4caf7ab8 100644 --- a/src/test/ui/const-generics/unused_braces.rs +++ b/src/test/ui/const-generics/unused_braces.rs @@ -1,10 +1,12 @@ // check-pass // run-rustfix +// revisions: full min -#![allow(incomplete_features)] +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] #![warn(unused_braces)] -#![feature(const_generics)] struct A<const N: usize>; diff --git a/src/test/ui/const-generics/wf-misc.full.stderr b/src/test/ui/const-generics/wf-misc.full.stderr new file mode 100644 index 00000000000..4af48fa1590 --- /dev/null +++ b/src/test/ui/const-generics/wf-misc.full.stderr @@ -0,0 +1,18 @@ +error: constant expression depends on a generic parameter + --> $DIR/wf-misc.rs:9:12 + | +LL | let _: [u8; N + 1]; + | ^^^^^^^^^^^ + | + = note: this may fail depending on what value the parameter takes + +error: constant expression depends on a generic parameter + --> $DIR/wf-misc.rs:17:12 + | +LL | let _: Const::<{N + 1}>; + | ^^^^^^^^^^^^^^^^ + | + = note: this may fail depending on what value the parameter takes + +error: aborting due to 2 previous errors + diff --git a/src/test/ui/const-generics/wf-misc.min.stderr b/src/test/ui/const-generics/wf-misc.min.stderr new file mode 100644 index 00000000000..f2acb8fc06e --- /dev/null +++ b/src/test/ui/const-generics/wf-misc.min.stderr @@ -0,0 +1,18 @@ +error: generic parameters must not be used inside of non trivial constant values + --> $DIR/wf-misc.rs:9:17 + | +LL | let _: [u8; N + 1]; + | ^ non-trivial anonymous constants must not depend on the parameter `N` + | + = help: it is currently only allowed to use either `N` or `{ N }` as generic constants + +error: generic parameters must not be used inside of non trivial constant values + --> $DIR/wf-misc.rs:17:21 + | +LL | let _: Const::<{N + 1}>; + | ^ non-trivial anonymous constants must not depend on the parameter `N` + | + = help: it is currently only allowed to use either `N` or `{ N }` as generic constants + +error: aborting due to 2 previous errors + diff --git a/src/test/ui/const-generics/wf-misc.rs b/src/test/ui/const-generics/wf-misc.rs index 4ff1b9e2da5..e6f7a9963e8 100644 --- a/src/test/ui/const-generics/wf-misc.rs +++ b/src/test/ui/const-generics/wf-misc.rs @@ -1,16 +1,22 @@ -#![feature(const_generics)] -//~^ WARN the feature `const_generics` is incomplete +// Tests miscellaneous well-formedness examples. +// revisions: full min + +#![cfg_attr(full, feature(const_generics))] +#![cfg_attr(full, allow(incomplete_features))] +#![cfg_attr(min, feature(min_const_generics))] pub fn arr_len<const N: usize>() { let _: [u8; N + 1]; - //~^ ERROR constant expression depends on a generic parameter + //[full]~^ ERROR constant expression depends on a generic parameter + //[min]~^^ ERROR generic parameters must not be used inside of non trivial } struct Const<const N: usize>; pub fn func_call<const N: usize>() { let _: Const::<{N + 1}>; - //~^ ERROR constant expression depends on a generic parameter + //[full]~^ ERROR constant expression depends on a generic parameter + //[min]~^^ ERROR generic parameters must not be used inside of non trivial } fn main() {} diff --git a/src/test/ui/const-generics/wf-misc.stderr b/src/test/ui/const-generics/wf-misc.stderr deleted file mode 100644 index 03f2bf3f526..00000000000 --- a/src/test/ui/const-generics/wf-misc.stderr +++ /dev/null @@ -1,27 +0,0 @@ -warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes - --> $DIR/wf-misc.rs:1:12 - | -LL | #![feature(const_generics)] - | ^^^^^^^^^^^^^^ - | - = note: `#[warn(incomplete_features)]` on by default - = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information - -error: constant expression depends on a generic parameter - --> $DIR/wf-misc.rs:5:12 - | -LL | let _: [u8; N + 1]; - | ^^^^^^^^^^^ - | - = note: this may fail depending on what value the parameter takes - -error: constant expression depends on a generic parameter - --> $DIR/wf-misc.rs:12:12 - | -LL | let _: Const::<{N + 1}>; - | ^^^^^^^^^^^^^^^^ - | - = note: this may fail depending on what value the parameter takes - -error: aborting due to 2 previous errors; 1 warning emitted - diff --git a/src/test/ui/consts/const-err-multi.stderr b/src/test/ui/consts/const-err-multi.stderr index 4ac4a8754d3..a0c91ff6b54 100644 --- a/src/test/ui/consts/const-err-multi.stderr +++ b/src/test/ui/consts/const-err-multi.stderr @@ -24,17 +24,17 @@ error: any use of this value will cause an error --> $DIR/const-err-multi.rs:7:19 | LL | pub const C: u8 = A as u8; - | ------------------^^^^^^^- + | ------------------^------- | | | referenced constant has errors error: any use of this value will cause an error - --> $DIR/const-err-multi.rs:9:19 + --> $DIR/const-err-multi.rs:9:24 | LL | pub const D: i8 = 50 - A; - | ------------------^^^^^^- - | | - | referenced constant has errors + | -----------------------^- + | | + | referenced constant has errors error: aborting due to 4 previous errors diff --git a/src/test/ui/consts/const-eval/erroneous-const.rs b/src/test/ui/consts/const-eval/erroneous-const.rs index 93c4e9372e8..3df491bf229 100644 --- a/src/test/ui/consts/const-eval/erroneous-const.rs +++ b/src/test/ui/consts/const-eval/erroneous-const.rs @@ -8,8 +8,8 @@ impl<T> PrintName<T> { } const fn no_codegen<T>() { - if false { //~ERROR evaluation of constant value failed - let _ = PrintName::<T>::VOID; + if false { + let _ = PrintName::<T>::VOID; //~ERROR evaluation of constant value failed } } diff --git a/src/test/ui/consts/const-eval/erroneous-const.stderr b/src/test/ui/consts/const-eval/erroneous-const.stderr index da7e7247d50..f06e2c33fd0 100644 --- a/src/test/ui/consts/const-eval/erroneous-const.stderr +++ b/src/test/ui/consts/const-eval/erroneous-const.stderr @@ -25,12 +25,10 @@ LL | #![warn(const_err, unconditional_panic)] | ^^^^^^^^^ error[E0080]: evaluation of constant value failed - --> $DIR/erroneous-const.rs:11:5 + --> $DIR/erroneous-const.rs:12:17 | -LL | / if false { -LL | | let _ = PrintName::<T>::VOID; -LL | | } - | |_____^ referenced constant has errors +LL | let _ = PrintName::<T>::VOID; + | ^^^^^^^^^^^^^^^^^^^^ referenced constant has errors error[E0080]: could not evaluate static initializer --> $DIR/erroneous-const.rs:16:22 diff --git a/src/test/ui/consts/uninhabited-const-issue-61744.rs b/src/test/ui/consts/uninhabited-const-issue-61744.rs index 55f42d84f9c..15436f9c1b2 100644 --- a/src/test/ui/consts/uninhabited-const-issue-61744.rs +++ b/src/test/ui/consts/uninhabited-const-issue-61744.rs @@ -1,11 +1,11 @@ // build-fail pub const unsafe fn fake_type<T>() -> T { - hint_unreachable() //~ ERROR evaluation of constant value failed + hint_unreachable() } pub const unsafe fn hint_unreachable() -> ! { - fake_type() + fake_type() //~ ERROR evaluation of constant value failed } trait Const { diff --git a/src/test/ui/consts/uninhabited-const-issue-61744.stderr b/src/test/ui/consts/uninhabited-const-issue-61744.stderr index fc908b2b222..024f9782d4a 100644 --- a/src/test/ui/consts/uninhabited-const-issue-61744.stderr +++ b/src/test/ui/consts/uninhabited-const-issue-61744.stderr @@ -1,11 +1,9 @@ error[E0080]: evaluation of constant value failed - --> $DIR/uninhabited-const-issue-61744.rs:4:5 + --> $DIR/uninhabited-const-issue-61744.rs:8:5 | LL | hint_unreachable() - | ^^^^^^^^^^^^^^^^^^ + | ------------------ | | - | reached the configured maximum number of stack frames - | inside `fake_type::<!>` at $DIR/uninhabited-const-issue-61744.rs:4:5 | inside `fake_type::<!>` at $DIR/uninhabited-const-issue-61744.rs:4:5 | inside `fake_type::<!>` at $DIR/uninhabited-const-issue-61744.rs:4:5 | inside `fake_type::<!>` at $DIR/uninhabited-const-issue-61744.rs:4:5 @@ -72,8 +70,9 @@ LL | hint_unreachable() | inside `fake_type::<i32>` at $DIR/uninhabited-const-issue-61744.rs:4:5 ... LL | fake_type() - | ----------- + | ^^^^^^^^^^^ | | + | reached the configured maximum number of stack frames | inside `hint_unreachable` at $DIR/uninhabited-const-issue-61744.rs:8:5 | inside `hint_unreachable` at $DIR/uninhabited-const-issue-61744.rs:8:5 | inside `hint_unreachable` at $DIR/uninhabited-const-issue-61744.rs:8:5 diff --git a/src/test/ui/empty/empty-struct-tuple-pat.stderr b/src/test/ui/empty/empty-struct-tuple-pat.stderr index 7b21d31635c..7b0d9717e63 100644 --- a/src/test/ui/empty/empty-struct-tuple-pat.stderr +++ b/src/test/ui/empty/empty-struct-tuple-pat.stderr @@ -23,16 +23,13 @@ LL | Empty4() | -------- `E::Empty4` defined here ... LL | E::Empty4 => () - | ^^^^^^^^^ did you mean `E::Empty4( /* fields */ )`? + | ^^^^^^^^^ help: use the tuple variant pattern syntax instead: `E::Empty4()` error[E0532]: expected unit struct, unit variant or constant, found tuple variant `XE::XEmpty5` --> $DIR/empty-struct-tuple-pat.rs:33:9 | LL | XE::XEmpty5 => (), - | ^^^^------- - | | | - | | help: a unit variant with a similar name exists: `XEmpty4` - | did you mean `XE::XEmpty5( /* fields */ )`? + | ^^^^^^^^^^^ | ::: $DIR/auxiliary/empty-struct.rs:7:5 | @@ -40,6 +37,15 @@ LL | XEmpty4, | ------- similarly named unit variant `XEmpty4` defined here LL | XEmpty5(), | --------- `XE::XEmpty5` defined here + | +help: use the tuple variant pattern syntax instead + | +LL | XE::XEmpty5(/* fields */) => (), + | ^^^^^^^^^^^^^^^^^^^^^^^^^ +help: a unit variant with a similar name exists + | +LL | XE::XEmpty4 => (), + | ^^^^^^^ error: aborting due to 4 previous errors diff --git a/src/test/ui/error-codes/E0106.stderr b/src/test/ui/error-codes/E0106.stderr index a23bcbfd71a..ac70e887626 100644 --- a/src/test/ui/error-codes/E0106.stderr +++ b/src/test/ui/error-codes/E0106.stderr @@ -51,6 +51,15 @@ error[E0106]: missing lifetime specifiers | LL | buzz: Buzz, | ^^^^ expected 2 lifetime parameters + | +help: consider introducing a named lifetime parameter + | +LL | struct Quux<'a> { +LL | baz: Baz, +LL | +LL | +LL | buzz: Buzz<'a, 'a>, + | error: aborting due to 5 previous errors diff --git a/src/test/ui/error-codes/E0424.rs b/src/test/ui/error-codes/E0424.rs index 3c6a1d4f88f..fa0c86ecf48 100644 --- a/src/test/ui/error-codes/E0424.rs +++ b/src/test/ui/error-codes/E0424.rs @@ -6,6 +6,10 @@ impl Foo { fn foo() { self.bar(); //~ ERROR E0424 } + + fn baz(_: i32) { + self.bar(); //~ ERROR E0424 + } } fn main () { diff --git a/src/test/ui/error-codes/E0424.stderr b/src/test/ui/error-codes/E0424.stderr index 690a101496d..9b8a29e8272 100644 --- a/src/test/ui/error-codes/E0424.stderr +++ b/src/test/ui/error-codes/E0424.stderr @@ -1,21 +1,37 @@ error[E0424]: expected value, found module `self` --> $DIR/E0424.rs:7:9 | -LL | / fn foo() { -LL | | self.bar(); - | | ^^^^ `self` value is a keyword only available in methods with a `self` parameter -LL | | } - | |_____- this function doesn't have a `self` parameter +LL | fn foo() { + | --- this function doesn't have a `self` parameter +LL | self.bar(); + | ^^^^ `self` value is a keyword only available in methods with a `self` parameter + | +help: add a `self` receiver parameter to make the associated `fn` a method + | +LL | fn foo(&self) { + | ^^^^^ + +error[E0424]: expected value, found module `self` + --> $DIR/E0424.rs:11:9 + | +LL | fn baz(_: i32) { + | --- this function doesn't have a `self` parameter +LL | self.bar(); + | ^^^^ `self` value is a keyword only available in methods with a `self` parameter + | +help: add a `self` receiver parameter to make the associated `fn` a method + | +LL | fn baz(&self, _: i32) { + | ^^^^^^ error[E0424]: expected unit struct, unit variant or constant, found module `self` - --> $DIR/E0424.rs:12:9 + --> $DIR/E0424.rs:16:9 | -LL | / fn main () { -LL | | let self = "self"; - | | ^^^^ `self` value is a keyword and may not be bound to variables or shadowed -LL | | } - | |_- this function doesn't have a `self` parameter +LL | fn main () { + | ---- this function can't have a `self` parameter +LL | let self = "self"; + | ^^^^ `self` value is a keyword and may not be bound to variables or shadowed -error: aborting due to 2 previous errors +error: aborting due to 3 previous errors For more information about this error, try `rustc --explain E0424`. diff --git a/src/test/ui/issues/issue-32004.stderr b/src/test/ui/issues/issue-32004.stderr index ab723e26680..f95afb9c1fd 100644 --- a/src/test/ui/issues/issue-32004.stderr +++ b/src/test/ui/issues/issue-32004.stderr @@ -7,10 +7,16 @@ LL | Baz | --- similarly named unit variant `Baz` defined here ... LL | Foo::Bar => {} - | ^^^^^--- - | | | - | | help: a unit variant with a similar name exists: `Baz` - | did you mean `Foo::Bar( /* fields */ )`? + | ^^^^^^^^ + | +help: use the tuple variant pattern syntax instead + | +LL | Foo::Bar(_) => {} + | ^^^^^^^^^^^ +help: a unit variant with a similar name exists + | +LL | Foo::Baz => {} + | ^^^ error[E0532]: expected tuple struct or tuple variant, found unit struct `S` --> $DIR/issue-32004.rs:16:9 diff --git a/src/test/ui/issues/issue-5099.rs b/src/test/ui/issues/issue-5099.rs index d00fff32809..ee134835c37 100644 --- a/src/test/ui/issues/issue-5099.rs +++ b/src/test/ui/issues/issue-5099.rs @@ -1,3 +1,10 @@ -trait B < A > { fn a() -> A { this.a } } //~ ERROR cannot find value `this` in this scope +trait B <A> { + fn a() -> A { + this.a //~ ERROR cannot find value `this` in this scope + } + fn b(x: i32) { + this.b(x); //~ ERROR cannot find value `this` in this scope + } +} fn main() {} diff --git a/src/test/ui/issues/issue-5099.stderr b/src/test/ui/issues/issue-5099.stderr index cc11db9c5ec..b52fd28b2b5 100644 --- a/src/test/ui/issues/issue-5099.stderr +++ b/src/test/ui/issues/issue-5099.stderr @@ -1,9 +1,33 @@ error[E0425]: cannot find value `this` in this scope - --> $DIR/issue-5099.rs:1:31 + --> $DIR/issue-5099.rs:3:9 | -LL | trait B < A > { fn a() -> A { this.a } } - | ^^^^ not found in this scope +LL | this.a + | ^^^^ not found in this scope + | +help: you might have meant to use `self` here instead + | +LL | self.a + | ^^^^ +help: if you meant to use `self`, you are also missing a `self` receiver argument + | +LL | fn a(&self) -> A { + | ^^^^^ + +error[E0425]: cannot find value `this` in this scope + --> $DIR/issue-5099.rs:6:9 + | +LL | this.b(x); + | ^^^^ not found in this scope + | +help: you might have meant to use `self` here instead + | +LL | self.b(x); + | ^^^^ +help: if you meant to use `self`, you are also missing a `self` receiver argument + | +LL | fn b(&self, x: i32) { + | ^^^^^^ -error: aborting due to previous error +error: aborting due to 2 previous errors For more information about this error, try `rustc --explain E0425`. diff --git a/src/test/ui/issues/issue-63983.stderr b/src/test/ui/issues/issue-63983.stderr index 771a5c285af..eb042834102 100644 --- a/src/test/ui/issues/issue-63983.stderr +++ b/src/test/ui/issues/issue-63983.stderr @@ -5,7 +5,7 @@ LL | Tuple(i32), | ---------- `MyEnum::Tuple` defined here ... LL | MyEnum::Tuple => "", - | ^^^^^^^^^^^^^ did you mean `MyEnum::Tuple( /* fields */ )`? + | ^^^^^^^^^^^^^ help: use the tuple variant pattern syntax instead: `MyEnum::Tuple(_)` error[E0532]: expected unit struct, unit variant or constant, found struct variant `MyEnum::Struct` --> $DIR/issue-63983.rs:10:9 diff --git a/src/test/ui/issues/issue-74739.rs b/src/test/ui/issues/issue-74739.rs new file mode 100644 index 00000000000..03622358ae1 --- /dev/null +++ b/src/test/ui/issues/issue-74739.rs @@ -0,0 +1,14 @@ +// compile-flags: -O +// run-pass + +struct Foo { + x: i32, +} + +pub fn main() { + let mut foo = Foo { x: 42 }; + let x = &mut foo.x; + *x = 13; + let y = foo; + assert_eq!(y.x, 13); // used to print 42 due to mir-opt bug +} diff --git a/src/test/ui/issues/issue-75307.rs b/src/test/ui/issues/issue-75307.rs new file mode 100644 index 00000000000..2fe112a3b95 --- /dev/null +++ b/src/test/ui/issues/issue-75307.rs @@ -0,0 +1,3 @@ +fn main() { + format!(r"{}{}{}", named_arg=1); //~ ERROR invalid reference to positional arguments 1 and 2 +} diff --git a/src/test/ui/issues/issue-75307.stderr b/src/test/ui/issues/issue-75307.stderr new file mode 100644 index 00000000000..4a5d997e00d --- /dev/null +++ b/src/test/ui/issues/issue-75307.stderr @@ -0,0 +1,10 @@ +error: invalid reference to positional arguments 1 and 2 (there is 1 argument) + --> $DIR/issue-75307.rs:2:13 + | +LL | format!(r"{}{}{}", named_arg=1); + | ^^^^^^^^^ + | + = note: positional arguments are zero-based + +error: aborting due to previous error + diff --git a/src/test/ui/mir/issue-75419-validation-impl-trait.rs b/src/test/ui/mir/issue-75419-validation-impl-trait.rs new file mode 100644 index 00000000000..a8741befb0c --- /dev/null +++ b/src/test/ui/mir/issue-75419-validation-impl-trait.rs @@ -0,0 +1,13 @@ +// build-pass + +// This used to fail MIR validation due to the types on both sides of +// an assignment not being equal. +// The failure doesn't occur with a check-only build. + +fn iter_slice<'a, T>(xs: &'a [T]) -> impl Iterator<Item = &'a T> { + xs.iter() +} + +fn main() { + iter_slice::<()> as fn(_) -> _; +} diff --git a/src/test/ui/mismatched_types/issue-74918-missing-lifetime.stderr b/src/test/ui/mismatched_types/issue-74918-missing-lifetime.stderr index da3056eac90..d260addef48 100644 --- a/src/test/ui/mismatched_types/issue-74918-missing-lifetime.stderr +++ b/src/test/ui/mismatched_types/issue-74918-missing-lifetime.stderr @@ -6,8 +6,8 @@ LL | type Item = IteratorChunk<T, S>; | help: consider introducing a named lifetime parameter | -LL | type Item<'a> = IteratorChunk<<'a>T, S>; - | ^^^^ ^^^^ +LL | type Item<'a> = IteratorChunk<'a, T, S>; + | ^^^^ ^^^ error: `impl` item signature doesn't match `trait` item signature --> $DIR/issue-74918-missing-lifetime.rs:11:5 diff --git a/src/test/ui/parser/expr-as-stmt-2.rs b/src/test/ui/parser/expr-as-stmt-2.rs new file mode 100644 index 00000000000..3a18bdc3b73 --- /dev/null +++ b/src/test/ui/parser/expr-as-stmt-2.rs @@ -0,0 +1,10 @@ +// This is not autofixable because we give extra suggestions to end the first expression with `;`. +fn foo(a: Option<u32>, b: Option<u32>) -> bool { + if let Some(x) = a { true } else { false } + //~^ ERROR mismatched types + //~| ERROR mismatched types + && //~ ERROR mismatched types + if let Some(y) = a { true } else { false } +} + +fn main() {} diff --git a/src/test/ui/parser/expr-as-stmt-2.stderr b/src/test/ui/parser/expr-as-stmt-2.stderr new file mode 100644 index 00000000000..ee07c367633 --- /dev/null +++ b/src/test/ui/parser/expr-as-stmt-2.stderr @@ -0,0 +1,33 @@ +error[E0308]: mismatched types + --> $DIR/expr-as-stmt-2.rs:3:26 + | +LL | if let Some(x) = a { true } else { false } + | ---------------------^^^^------------------ help: consider using a semicolon here + | | | + | | expected `()`, found `bool` + | expected this to be `()` + +error[E0308]: mismatched types + --> $DIR/expr-as-stmt-2.rs:3:40 + | +LL | if let Some(x) = a { true } else { false } + | -----------------------------------^^^^^--- help: consider using a semicolon here + | | | + | | expected `()`, found `bool` + | expected this to be `()` + +error[E0308]: mismatched types + --> $DIR/expr-as-stmt-2.rs:6:5 + | +LL | fn foo(a: Option<u32>, b: Option<u32>) -> bool { + | ---- expected `bool` because of return type +LL | if let Some(x) = a { true } else { false } + | ------------------------------------------ help: parentheses are required to parse this as an expression: `(if let Some(x) = a { true } else { false })` +... +LL | / && +LL | | if let Some(y) = a { true } else { false } + | |______________________________________________^ expected `bool`, found `&&bool` + +error: aborting due to 3 previous errors + +For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/parser/expr-as-stmt.fixed b/src/test/ui/parser/expr-as-stmt.fixed index 1ce6f9c2503..02816ef2791 100644 --- a/src/test/ui/parser/expr-as-stmt.fixed +++ b/src/test/ui/parser/expr-as-stmt.fixed @@ -25,12 +25,6 @@ fn baz() -> i32 { //~^ ERROR mismatched types } -fn qux(a: Option<u32>, b: Option<u32>) -> bool { - (if let Some(x) = a { true } else { false }) - && //~ ERROR expected expression - if let Some(y) = a { true } else { false } -} - fn moo(x: u32) -> bool { (match x { _ => 1, diff --git a/src/test/ui/parser/expr-as-stmt.rs b/src/test/ui/parser/expr-as-stmt.rs index b526c17488e..93baa8278f8 100644 --- a/src/test/ui/parser/expr-as-stmt.rs +++ b/src/test/ui/parser/expr-as-stmt.rs @@ -25,12 +25,6 @@ fn baz() -> i32 { //~^ ERROR mismatched types } -fn qux(a: Option<u32>, b: Option<u32>) -> bool { - if let Some(x) = a { true } else { false } - && //~ ERROR expected expression - if let Some(y) = a { true } else { false } -} - fn moo(x: u32) -> bool { match x { _ => 1, diff --git a/src/test/ui/parser/expr-as-stmt.stderr b/src/test/ui/parser/expr-as-stmt.stderr index 4d93e130901..324aed0ad7c 100644 --- a/src/test/ui/parser/expr-as-stmt.stderr +++ b/src/test/ui/parser/expr-as-stmt.stderr @@ -22,16 +22,8 @@ LL | { 42 } + foo; | | | help: parentheses are required to parse this as an expression: `({ 42 })` -error: expected expression, found `&&` - --> $DIR/expr-as-stmt.rs:30:5 - | -LL | if let Some(x) = a { true } else { false } - | ------------------------------------------ help: parentheses are required to parse this as an expression: `(if let Some(x) = a { true } else { false })` -LL | && - | ^^ expected expression - error: expected expression, found `>` - --> $DIR/expr-as-stmt.rs:37:7 + --> $DIR/expr-as-stmt.rs:31:7 | LL | } > 0 | ^ expected expression @@ -75,7 +67,7 @@ LL | { 3 } * 3 | | | help: parentheses are required to parse this as an expression: `({ 3 })` -error: aborting due to 10 previous errors +error: aborting due to 9 previous errors Some errors have detailed explanations: E0308, E0614. For more information about an error, try `rustc --explain E0308`. diff --git a/src/test/ui/parser/mismatched-braces/missing-close-brace-in-struct.rs b/src/test/ui/parser/mismatched-braces/missing-close-brace-in-struct.rs index 0d53315839c..090a17b413d 100644 --- a/src/test/ui/parser/mismatched-braces/missing-close-brace-in-struct.rs +++ b/src/test/ui/parser/mismatched-braces/missing-close-brace-in-struct.rs @@ -2,7 +2,6 @@ pub(crate) struct Bar<T> { foo: T, trait T { //~ ERROR expected identifier, found keyword `trait` -//~^ ERROR expected `:`, found `T` fn foo(&self); } diff --git a/src/test/ui/parser/mismatched-braces/missing-close-brace-in-struct.stderr b/src/test/ui/parser/mismatched-braces/missing-close-brace-in-struct.stderr index ac8dd48a588..a47d5506ef0 100644 --- a/src/test/ui/parser/mismatched-braces/missing-close-brace-in-struct.stderr +++ b/src/test/ui/parser/mismatched-braces/missing-close-brace-in-struct.stderr @@ -1,5 +1,5 @@ error: this file contains an unclosed delimiter - --> $DIR/missing-close-brace-in-struct.rs:14:65 + --> $DIR/missing-close-brace-in-struct.rs:13:65 | LL | pub(crate) struct Bar<T> { | - unclosed delimiter @@ -13,11 +13,5 @@ error: expected identifier, found keyword `trait` LL | trait T { | ^^^^^ expected identifier, found keyword -error: expected `:`, found `T` - --> $DIR/missing-close-brace-in-struct.rs:4:7 - | -LL | trait T { - | ^ expected `:` - -error: aborting due to 3 previous errors +error: aborting due to 2 previous errors diff --git a/src/test/ui/parser/recover-from-bad-variant.rs b/src/test/ui/parser/recover-from-bad-variant.rs index 27b03c0c2db..1bcef450bb9 100644 --- a/src/test/ui/parser/recover-from-bad-variant.rs +++ b/src/test/ui/parser/recover-from-bad-variant.rs @@ -9,6 +9,7 @@ fn main() { match x { Enum::Foo(a, b) => {} //~^ ERROR expected tuple struct or tuple variant, found struct variant `Enum::Foo` - Enum::Bar(a, b) => {} + Enum::Bar { a, b } => {} + //~^ ERROR tuple variant `Enum::Bar` written as struct variant } } diff --git a/src/test/ui/parser/recover-from-bad-variant.stderr b/src/test/ui/parser/recover-from-bad-variant.stderr index 6986d966d69..89232a519d7 100644 --- a/src/test/ui/parser/recover-from-bad-variant.stderr +++ b/src/test/ui/parser/recover-from-bad-variant.stderr @@ -18,6 +18,13 @@ LL | Foo { a: usize, b: usize }, LL | Enum::Foo(a, b) => {} | ^^^^^^^^^^^^^^^ help: use struct pattern syntax instead: `Enum::Foo { a, b }` -error: aborting due to 2 previous errors +error[E0769]: tuple variant `Enum::Bar` written as struct variant + --> $DIR/recover-from-bad-variant.rs:12:9 + | +LL | Enum::Bar { a, b } => {} + | ^^^^^^^^^^^^^^^^^^ help: use the tuple variant pattern syntax instead: `Enum::Bar(a, b)` + +error: aborting due to 3 previous errors -For more information about this error, try `rustc --explain E0532`. +Some errors have detailed explanations: E0532, E0769. +For more information about an error, try `rustc --explain E0532`. diff --git a/src/test/ui/parser/removed-syntax-field-let.rs b/src/test/ui/parser/removed-syntax-field-let.rs index 9fe4a148a56..6d64de296f1 100644 --- a/src/test/ui/parser/removed-syntax-field-let.rs +++ b/src/test/ui/parser/removed-syntax-field-let.rs @@ -1,7 +1,6 @@ struct S { let foo: (), //~^ ERROR expected identifier, found keyword `let` - //~^^ ERROR expected `:`, found `foo` } fn main() {} diff --git a/src/test/ui/parser/removed-syntax-field-let.stderr b/src/test/ui/parser/removed-syntax-field-let.stderr index 7de2c730a70..10be2e045b2 100644 --- a/src/test/ui/parser/removed-syntax-field-let.stderr +++ b/src/test/ui/parser/removed-syntax-field-let.stderr @@ -4,11 +4,5 @@ error: expected identifier, found keyword `let` LL | let foo: (), | ^^^ expected identifier, found keyword -error: expected `:`, found `foo` - --> $DIR/removed-syntax-field-let.rs:2:9 - | -LL | let foo: (), - | ^^^ expected `:` - -error: aborting due to 2 previous errors +error: aborting due to previous error diff --git a/src/test/ui/polymorphization/predicates.rs b/src/test/ui/polymorphization/predicates.rs index 82a94933b47..60555dc12dc 100644 --- a/src/test/ui/polymorphization/predicates.rs +++ b/src/test/ui/polymorphization/predicates.rs @@ -18,7 +18,55 @@ where bar::<I>() } +#[rustc_polymorphize_error] +fn baz<I, T>(_: I) +where + std::iter::Repeat<I>: Iterator<Item = T>, +{ + bar::<I>() +} + +// In addition, check that `I` is considered used in `next::{{closure}}`, because `T` is used and +// `T` is really just `I::Item`. `E` is used due to the fixed-point marking of predicates. + +pub(crate) struct Foo<'a, I, E>(I, &'a E); + +impl<'a, I, T: 'a, E> Iterator for Foo<'a, I, E> +where + I: Iterator<Item = &'a (T, E)>, +{ + type Item = T; + + #[rustc_polymorphize_error] + fn next(&mut self) -> Option<Self::Item> { + self.find(|_| true) + } +} + +// Furthermore, check that `B` is considered used because `C` is used, and that `A` is considered +// used because `B` is now used. + +trait Baz<Z> {} + +impl Baz<u16> for u8 {} +impl Baz<u32> for u16 {} + +#[rustc_polymorphize_error] +fn quux<A, B, C: Default>() -> usize +where + A: Baz<B>, + B: Baz<C>, +{ + std::mem::size_of::<C>() +} + fn main() { let x = &[2u32]; foo(x.iter()); + baz(x.iter()); + + let mut a = Foo([(1u32, 1u16)].iter(), &1u16); + let _ = a.next(); + + let _ = quux::<u8, u16, u32>(); } diff --git a/src/test/ui/polymorphization/symbol-ambiguity.rs b/src/test/ui/polymorphization/symbol-ambiguity.rs new file mode 100644 index 00000000000..d97bae183d9 --- /dev/null +++ b/src/test/ui/polymorphization/symbol-ambiguity.rs @@ -0,0 +1,22 @@ +// build-pass +// compile-flags: -Zpolymorphize=on -Zsymbol-mangling-version=v0 + +pub(crate) struct Foo<'a, I, E>(I, &'a E); + +impl<'a, I, T: 'a, E> Iterator for Foo<'a, I, E> +where + I: Iterator<Item = &'a (T, E)>, +{ + type Item = T; + + fn next(&mut self) -> Option<Self::Item> { + self.find(|_| true) + } +} + +fn main() { + let mut a = Foo([(1u32, 1u16)].iter(), &1u16); + let mut b = Foo([(1u16, 1u32)].iter(), &1u32); + let _ = a.next(); + let _ = b.next(); +} diff --git a/src/test/ui/resolve/issue-2356.stderr b/src/test/ui/resolve/issue-2356.stderr index b687f0b0af0..0339daa0d6a 100644 --- a/src/test/ui/resolve/issue-2356.stderr +++ b/src/test/ui/resolve/issue-2356.stderr @@ -70,14 +70,15 @@ LL | purr(); error[E0424]: expected value, found module `self` --> $DIR/issue-2356.rs:65:8 | -LL | / fn meow() { -LL | | if self.whiskers > 3 { - | | ^^^^ `self` value is a keyword only available in methods with a `self` parameter -LL | | -LL | | println!("MEOW"); -LL | | } -LL | | } - | |___- this function doesn't have a `self` parameter +LL | fn meow() { + | ---- this function doesn't have a `self` parameter +LL | if self.whiskers > 3 { + | ^^^^ `self` value is a keyword only available in methods with a `self` parameter + | +help: add a `self` receiver parameter to make the associated `fn` a method + | +LL | fn meow(&self) { + | ^^^^^ error[E0425]: cannot find function `grow_older` in this scope --> $DIR/issue-2356.rs:72:5 @@ -112,12 +113,10 @@ LL | purr_louder(); error[E0424]: expected value, found module `self` --> $DIR/issue-2356.rs:92:5 | -LL | / fn main() { -LL | | self += 1; - | | ^^^^ `self` value is a keyword only available in methods with a `self` parameter -LL | | -LL | | } - | |_- this function doesn't have a `self` parameter +LL | fn main() { + | ---- this function can't have a `self` parameter +LL | self += 1; + | ^^^^ `self` value is a keyword only available in methods with a `self` parameter error: aborting due to 17 previous errors diff --git a/src/test/ui/suggestions/missing-lifetime-in-assoc-const-type.rs b/src/test/ui/suggestions/missing-lifetime-in-assoc-const-type.rs new file mode 100644 index 00000000000..38332627f4c --- /dev/null +++ b/src/test/ui/suggestions/missing-lifetime-in-assoc-const-type.rs @@ -0,0 +1,16 @@ +trait ZstAssert: Sized { + const A: &str = ""; //~ ERROR missing lifetime specifier + const B: S = S { s: &() }; //~ ERROR missing lifetime specifier + const C: &'_ str = ""; //~ ERROR missing lifetime specifier + const D: T = T { a: &(), b: &() }; //~ ERROR missing lifetime specifier +} + +struct S<'a> { + s: &'a (), +} +struct T<'a, 'b> { + a: &'a (), + b: &'b (), +} + +fn main() {} diff --git a/src/test/ui/suggestions/missing-lifetime-in-assoc-const-type.stderr b/src/test/ui/suggestions/missing-lifetime-in-assoc-const-type.stderr new file mode 100644 index 00000000000..b20778ce208 --- /dev/null +++ b/src/test/ui/suggestions/missing-lifetime-in-assoc-const-type.stderr @@ -0,0 +1,73 @@ +error[E0106]: missing lifetime specifier + --> $DIR/missing-lifetime-in-assoc-const-type.rs:2:14 + | +LL | const A: &str = ""; + | ^ expected named lifetime parameter + | +help: consider using the `'static` lifetime + | +LL | const A: &'static str = ""; + | ^^^^^^^ +help: consider introducing a named lifetime parameter + | +LL | trait ZstAssert<'a>: Sized { +LL | const A: &'a str = ""; + | + +error[E0106]: missing lifetime specifier + --> $DIR/missing-lifetime-in-assoc-const-type.rs:3:14 + | +LL | const B: S = S { s: &() }; + | ^ expected named lifetime parameter + | +help: consider using the `'static` lifetime + | +LL | const B: S<'static> = S { s: &() }; + | ^^^^^^^^^ +help: consider introducing a named lifetime parameter + | +LL | trait ZstAssert<'a>: Sized { +LL | const A: &str = ""; +LL | const B: S<'a> = S { s: &() }; + | + +error[E0106]: missing lifetime specifier + --> $DIR/missing-lifetime-in-assoc-const-type.rs:4:15 + | +LL | const C: &'_ str = ""; + | ^^ expected named lifetime parameter + | +help: consider using the `'static` lifetime + | +LL | const C: &'static str = ""; + | ^^^^^^^ +help: consider introducing a named lifetime parameter + | +LL | trait ZstAssert<'a>: Sized { +LL | const A: &str = ""; +LL | const B: S = S { s: &() }; +LL | const C: &'a str = ""; + | + +error[E0106]: missing lifetime specifiers + --> $DIR/missing-lifetime-in-assoc-const-type.rs:5:14 + | +LL | const D: T = T { a: &(), b: &() }; + | ^ expected 2 lifetime parameters + | +help: consider using the `'static` lifetime + | +LL | const D: T<'static, 'static> = T { a: &(), b: &() }; + | ^^^^^^^^^^^^^^^^^^ +help: consider introducing a named lifetime parameter + | +LL | trait ZstAssert<'a>: Sized { +LL | const A: &str = ""; +LL | const B: S = S { s: &() }; +LL | const C: &'_ str = ""; +LL | const D: T<'a, 'a> = T { a: &(), b: &() }; + | + +error: aborting due to 4 previous errors + +For more information about this error, try `rustc --explain E0106`. diff --git a/src/test/ui/suggestions/missing-lifetime-specifier.rs b/src/test/ui/suggestions/missing-lifetime-specifier.rs index b09c1879d70..fe88d105c78 100644 --- a/src/test/ui/suggestions/missing-lifetime-specifier.rs +++ b/src/test/ui/suggestions/missing-lifetime-specifier.rs @@ -25,8 +25,6 @@ thread_local! { //~| ERROR missing lifetime specifier //~| ERROR missing lifetime specifier //~| ERROR missing lifetime specifier - //~| ERROR the lifetime bound for this object type cannot be deduced from context - //~| ERROR the lifetime bound for this object type cannot be deduced from context } thread_local! { static c: RefCell<HashMap<i32, Vec<Vec<Qux<i32>>>>> = RefCell::new(HashMap::new()); @@ -39,8 +37,6 @@ thread_local! { //~| ERROR missing lifetime specifier //~| ERROR missing lifetime specifier //~| ERROR missing lifetime specifier - //~| ERROR the lifetime bound for this object type cannot be deduced from context - //~| ERROR the lifetime bound for this object type cannot be deduced from context } thread_local! { @@ -52,9 +48,7 @@ thread_local! { } thread_local! { static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new()); - //~^ ERROR the lifetime bound for this object type cannot be deduced from context - //~| ERROR the lifetime bound for this object type cannot be deduced from context - //~| ERROR wrong number of lifetime arguments: expected 2, found 1 + //~^ ERROR wrong number of lifetime arguments: expected 2, found 1 //~| ERROR wrong number of lifetime arguments: expected 2, found 1 //~| ERROR wrong number of lifetime arguments: expected 2, found 1 //~| ERROR wrong number of lifetime arguments: expected 2, found 1 diff --git a/src/test/ui/suggestions/missing-lifetime-specifier.stderr b/src/test/ui/suggestions/missing-lifetime-specifier.stderr index 2630cf1affa..9838ac72ad7 100644 --- a/src/test/ui/suggestions/missing-lifetime-specifier.stderr +++ b/src/test/ui/suggestions/missing-lifetime-specifier.stderr @@ -71,7 +71,7 @@ LL | static b: RefCell<HashMap<i32, Vec<Vec<&Bar<'static, 'static>>>>> = Ref | ^^^^^^^^^^^^^^^^^^^^^ error[E0106]: missing lifetime specifiers - --> $DIR/missing-lifetime-specifier.rs:32:48 + --> $DIR/missing-lifetime-specifier.rs:30:48 | LL | static c: RefCell<HashMap<i32, Vec<Vec<Qux<i32>>>>> = RefCell::new(HashMap::new()); | ^ expected 2 lifetime parameters @@ -83,7 +83,7 @@ LL | static c: RefCell<HashMap<i32, Vec<Vec<Qux<'static, 'static, i32>>>>> = | ^^^^^^^^^^^^^^^^^ error[E0106]: missing lifetime specifiers - --> $DIR/missing-lifetime-specifier.rs:32:48 + --> $DIR/missing-lifetime-specifier.rs:30:48 | LL | static c: RefCell<HashMap<i32, Vec<Vec<Qux<i32>>>>> = RefCell::new(HashMap::new()); | ^ expected 2 lifetime parameters @@ -95,7 +95,7 @@ LL | static c: RefCell<HashMap<i32, Vec<Vec<Qux<'static, 'static, i32>>>>> = | ^^^^^^^^^^^^^^^^^ error[E0106]: missing lifetime specifier - --> $DIR/missing-lifetime-specifier.rs:37:44 + --> $DIR/missing-lifetime-specifier.rs:35:44 | LL | static d: RefCell<HashMap<i32, Vec<Vec<&Tar<i32>>>>> = RefCell::new(HashMap::new()); | ^ expected named lifetime parameter @@ -107,7 +107,7 @@ LL | static d: RefCell<HashMap<i32, Vec<Vec<&'static Tar<i32>>>>> = RefCell: | ^^^^^^^^ error[E0106]: missing lifetime specifiers - --> $DIR/missing-lifetime-specifier.rs:37:49 + --> $DIR/missing-lifetime-specifier.rs:35:49 | LL | static d: RefCell<HashMap<i32, Vec<Vec<&Tar<i32>>>>> = RefCell::new(HashMap::new()); | ^ expected 2 lifetime parameters @@ -119,7 +119,7 @@ LL | static d: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, 'static, i32>>>>> | ^^^^^^^^^^^^^^^^^ error[E0106]: missing lifetime specifier - --> $DIR/missing-lifetime-specifier.rs:37:44 + --> $DIR/missing-lifetime-specifier.rs:35:44 | LL | static d: RefCell<HashMap<i32, Vec<Vec<&Tar<i32>>>>> = RefCell::new(HashMap::new()); | ^ expected named lifetime parameter @@ -131,7 +131,7 @@ LL | static d: RefCell<HashMap<i32, Vec<Vec<&'static Tar<i32>>>>> = RefCell: | ^^^^^^^^ error[E0106]: missing lifetime specifiers - --> $DIR/missing-lifetime-specifier.rs:37:49 + --> $DIR/missing-lifetime-specifier.rs:35:49 | LL | static d: RefCell<HashMap<i32, Vec<Vec<&Tar<i32>>>>> = RefCell::new(HashMap::new()); | ^ expected 2 lifetime parameters @@ -143,7 +143,7 @@ LL | static d: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, 'static, i32>>>>> | ^^^^^^^^^^^^^^^^^ error[E0106]: missing lifetime specifier - --> $DIR/missing-lifetime-specifier.rs:54:44 + --> $DIR/missing-lifetime-specifier.rs:50:44 | LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new()); | ^ expected named lifetime parameter @@ -155,7 +155,7 @@ LL | static f: RefCell<HashMap<i32, Vec<Vec<&'static Tar<'static, i32>>>>> = | ^^^^^^^^ error[E0106]: missing lifetime specifier - --> $DIR/missing-lifetime-specifier.rs:54:44 + --> $DIR/missing-lifetime-specifier.rs:50:44 | LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new()); | ^ expected named lifetime parameter @@ -166,91 +166,55 @@ help: consider using the `'static` lifetime LL | static f: RefCell<HashMap<i32, Vec<Vec<&'static Tar<'static, i32>>>>> = RefCell::new(HashMap::new()); | ^^^^^^^^ -error[E0228]: the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound - --> $DIR/missing-lifetime-specifier.rs:23:45 - | -LL | static b: RefCell<HashMap<i32, Vec<Vec<&Bar>>>> = RefCell::new(HashMap::new()); - | ^^^ - -error[E0228]: the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound - --> $DIR/missing-lifetime-specifier.rs:23:45 - | -LL | static b: RefCell<HashMap<i32, Vec<Vec<&Bar>>>> = RefCell::new(HashMap::new()); - | ^^^ - -error[E0228]: the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound - --> $DIR/missing-lifetime-specifier.rs:37:45 - | -LL | static d: RefCell<HashMap<i32, Vec<Vec<&Tar<i32>>>>> = RefCell::new(HashMap::new()); - | ^^^^^^^^ - -error[E0228]: the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound - --> $DIR/missing-lifetime-specifier.rs:37:45 - | -LL | static d: RefCell<HashMap<i32, Vec<Vec<&Tar<i32>>>>> = RefCell::new(HashMap::new()); - | ^^^^^^^^ - error[E0107]: wrong number of lifetime arguments: expected 2, found 1 - --> $DIR/missing-lifetime-specifier.rs:47:44 + --> $DIR/missing-lifetime-specifier.rs:43:44 | LL | static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, i32>>>>> = RefCell::new(HashMap::new()); | ^^^^^^^^^^^^^^^^^ expected 2 lifetime arguments error[E0107]: wrong number of lifetime arguments: expected 2, found 1 - --> $DIR/missing-lifetime-specifier.rs:47:44 + --> $DIR/missing-lifetime-specifier.rs:43:44 | LL | static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, i32>>>>> = RefCell::new(HashMap::new()); | ^^^^^^^^^^^^^^^^^ expected 2 lifetime arguments error[E0107]: wrong number of lifetime arguments: expected 2, found 1 - --> $DIR/missing-lifetime-specifier.rs:47:44 + --> $DIR/missing-lifetime-specifier.rs:43:44 | LL | static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, i32>>>>> = RefCell::new(HashMap::new()); | ^^^^^^^^^^^^^^^^^ expected 2 lifetime arguments error[E0107]: wrong number of lifetime arguments: expected 2, found 1 - --> $DIR/missing-lifetime-specifier.rs:47:44 + --> $DIR/missing-lifetime-specifier.rs:43:44 | LL | static e: RefCell<HashMap<i32, Vec<Vec<Qux<'static, i32>>>>> = RefCell::new(HashMap::new()); | ^^^^^^^^^^^^^^^^^ expected 2 lifetime arguments error[E0107]: wrong number of lifetime arguments: expected 2, found 1 - --> $DIR/missing-lifetime-specifier.rs:54:45 + --> $DIR/missing-lifetime-specifier.rs:50:45 | LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new()); | ^^^^^^^^^^^^^^^^^ expected 2 lifetime arguments error[E0107]: wrong number of lifetime arguments: expected 2, found 1 - --> $DIR/missing-lifetime-specifier.rs:54:45 + --> $DIR/missing-lifetime-specifier.rs:50:45 | LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new()); | ^^^^^^^^^^^^^^^^^ expected 2 lifetime arguments -error[E0228]: the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound - --> $DIR/missing-lifetime-specifier.rs:54:45 - | -LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new()); - | ^^^^^^^^^^^^^^^^^ - error[E0107]: wrong number of lifetime arguments: expected 2, found 1 - --> $DIR/missing-lifetime-specifier.rs:54:45 + --> $DIR/missing-lifetime-specifier.rs:50:45 | LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new()); | ^^^^^^^^^^^^^^^^^ expected 2 lifetime arguments -error[E0228]: the lifetime bound for this object type cannot be deduced from context; please supply an explicit bound - --> $DIR/missing-lifetime-specifier.rs:54:45 - | -LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new()); - | ^^^^^^^^^^^^^^^^^ - error[E0107]: wrong number of lifetime arguments: expected 2, found 1 - --> $DIR/missing-lifetime-specifier.rs:54:45 + --> $DIR/missing-lifetime-specifier.rs:50:45 | LL | static f: RefCell<HashMap<i32, Vec<Vec<&Tar<'static, i32>>>>> = RefCell::new(HashMap::new()); | ^^^^^^^^^^^^^^^^^ expected 2 lifetime arguments -error: aborting due to 28 previous errors +error: aborting due to 22 previous errors -Some errors have detailed explanations: E0106, E0107, E0228. +Some errors have detailed explanations: E0106, E0107. For more information about an error, try `rustc --explain E0106`. diff --git a/src/test/ui/suggestions/missing-lt-for-hrtb.rs b/src/test/ui/suggestions/missing-lt-for-hrtb.rs new file mode 100644 index 00000000000..a90a90122ad --- /dev/null +++ b/src/test/ui/suggestions/missing-lt-for-hrtb.rs @@ -0,0 +1,15 @@ +struct X<'a>(&'a ()); +struct S<'a>(&'a dyn Fn(&X) -> &X); +//~^ ERROR missing lifetime specifier +//~| ERROR missing lifetime specifier +struct V<'a>(&'a dyn for<'b> Fn(&X) -> &X); +//~^ ERROR missing lifetime specifier +//~| ERROR missing lifetime specifier + +fn main() { + let x = S(&|x| { + println!("hi"); + x + }); + x.0(&X(&())); +} diff --git a/src/test/ui/suggestions/missing-lt-for-hrtb.stderr b/src/test/ui/suggestions/missing-lt-for-hrtb.stderr new file mode 100644 index 00000000000..2cb63500e48 --- /dev/null +++ b/src/test/ui/suggestions/missing-lt-for-hrtb.stderr @@ -0,0 +1,63 @@ +error[E0106]: missing lifetime specifier + --> $DIR/missing-lt-for-hrtb.rs:2:32 + | +LL | struct S<'a>(&'a dyn Fn(&X) -> &X); + | -- ^ expected named lifetime parameter + | + = help: this function's return type contains a borrowed value, but the signature does not say which one of argument 1's 2 lifetimes it is borrowed from + = note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html +help: consider making the bound lifetime-generic with a new `'b` lifetime + | +LL | struct S<'a>(&'a dyn for<'b> Fn(&'b X) -> &'b X); + | ^^^^^^^ ^^^^^ ^^^ +help: consider using the `'a` lifetime + | +LL | struct S<'a>(&'a dyn Fn(&X) -> &'a X); + | ^^^ + +error[E0106]: missing lifetime specifier + --> $DIR/missing-lt-for-hrtb.rs:2:33 + | +LL | struct S<'a>(&'a dyn Fn(&X) -> &X); + | -- ^ expected named lifetime parameter + | + = help: this function's return type contains a borrowed value, but the signature does not say which one of argument 1's 2 lifetimes it is borrowed from + = note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html +help: consider making the bound lifetime-generic with a new `'b` lifetime + | +LL | struct S<'a>(&'a dyn for<'b> Fn(&'b X) -> &X<'b>); + | ^^^^^^^ ^^^^^ ^^^^^ +help: consider using the `'a` lifetime + | +LL | struct S<'a>(&'a dyn Fn(&X) -> &X<'a>); + | ^^^^^ + +error[E0106]: missing lifetime specifier + --> $DIR/missing-lt-for-hrtb.rs:5:40 + | +LL | struct V<'a>(&'a dyn for<'b> Fn(&X) -> &X); + | -- ^ expected named lifetime parameter + | + = help: this function's return type contains a borrowed value, but the signature does not say which one of argument 1's 2 lifetimes it is borrowed from +note: these named lifetimes are available to use + --> $DIR/missing-lt-for-hrtb.rs:5:10 + | +LL | struct V<'a>(&'a dyn for<'b> Fn(&X) -> &X); + | ^^ ^^ + +error[E0106]: missing lifetime specifier + --> $DIR/missing-lt-for-hrtb.rs:5:41 + | +LL | struct V<'a>(&'a dyn for<'b> Fn(&X) -> &X); + | -- ^ expected named lifetime parameter + | + = help: this function's return type contains a borrowed value, but the signature does not say which one of argument 1's 2 lifetimes it is borrowed from +note: these named lifetimes are available to use + --> $DIR/missing-lt-for-hrtb.rs:5:10 + | +LL | struct V<'a>(&'a dyn for<'b> Fn(&X) -> &X); + | ^^ ^^ + +error: aborting due to 4 previous errors + +For more information about this error, try `rustc --explain E0106`. diff --git a/src/test/ui/unknown-llvm-arg.rs b/src/test/ui/unknown-llvm-arg.rs new file mode 100644 index 00000000000..289bae24f81 --- /dev/null +++ b/src/test/ui/unknown-llvm-arg.rs @@ -0,0 +1,22 @@ +// compile-flags: -Cllvm-args=-not-a-real-llvm-arg +// normalize-stderr-test "--help" -> "-help" +// normalize-stderr-test "\n(\n|.)*" -> "" + +// I'm seeing "--help" locally, but "-help" in CI, so I'm normalizing it to just "-help". + +// Note that the rustc-supplied "program name", given when invoking LLVM, is used by LLVM to +// generate user-facing error messages and a usage (--help) messages. If the program name is +// `rustc`, the usage message in response to `--llvm-args="--help"` starts with: +// ``` +// USAGE: rustc [options] +// ``` +// followed by the list of options not to `rustc` but to `llvm`. +// +// On the other hand, if the program name is set to `rustc -Cllvm-args="..." with`, the usage +// message is more clear: +// ``` +// USAGE: rustc -Cllvm-args="..." with [options] +// ``` +// This test captures the effect of the current program name setting on LLVM command line +// error messages. +fn main() {} diff --git a/src/test/ui/unknown-llvm-arg.stderr b/src/test/ui/unknown-llvm-arg.stderr new file mode 100644 index 00000000000..e1d3cfea28f --- /dev/null +++ b/src/test/ui/unknown-llvm-arg.stderr @@ -0,0 +1 @@ +rustc -Cllvm-args="..." with: Unknown command line argument '-not-a-real-llvm-arg'. Try: 'rustc -Cllvm-args="..." with -help' \ No newline at end of file diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs index 5dede95a858..58022484fa6 100644 --- a/src/tools/build-manifest/src/main.rs +++ b/src/tools/build-manifest/src/main.rs @@ -447,6 +447,7 @@ impl Builder { let mut package = |name, targets| self.package(name, &mut manifest.pkg, targets); package("rustc", HOSTS); package("rustc-dev", HOSTS); + package("rustc-docs", HOSTS); package("cargo", HOSTS); package("rust-mingw", MINGW); package("rust-std", TARGETS); @@ -500,6 +501,7 @@ impl Builder { // for users to install the additional component manually, if needed. if self.rust_release == "nightly" { self.extend_profile("complete", &mut manifest.profiles, &["rustc-dev"]); + self.extend_profile("complete", &mut manifest.profiles, &["rustc-docs"]); } } @@ -575,6 +577,7 @@ impl Builder { .map(|target| Component::from_str("rust-std", target)), ); extensions.extend(HOSTS.iter().map(|target| Component::from_str("rustc-dev", target))); + extensions.extend(HOSTS.iter().map(|target| Component::from_str("rustc-docs", target))); extensions.push(Component::from_str("rust-src", "*")); // If the components/extensions don't actually exist for this diff --git a/src/tools/cargo b/src/tools/cargo -Subproject 1653f354644834073d6d2541e27fae94588e685 +Subproject ab32ee88dade1b50c77347599e82ca2de3fb8a5 diff --git a/src/tools/clippy/clippy_lints/src/derive.rs b/src/tools/clippy/clippy_lints/src/derive.rs index 80a06758982..58b0704294b 100644 --- a/src/tools/clippy/clippy_lints/src/derive.rs +++ b/src/tools/clippy/clippy_lints/src/derive.rs @@ -224,7 +224,7 @@ fn check_hash_peq<'tcx>( mess, |diag| { if let Some(local_def_id) = impl_id.as_local() { - let hir_id = cx.tcx.hir().as_local_hir_id(local_def_id); + let hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id); diag.span_note( cx.tcx.hir().span(hir_id), "`PartialEq` implemented here" @@ -278,7 +278,7 @@ fn check_ord_partial_ord<'tcx>( mess, |diag| { if let Some(local_def_id) = impl_id.as_local() { - let hir_id = cx.tcx.hir().as_local_hir_id(local_def_id); + let hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id); diag.span_note( cx.tcx.hir().span(hir_id), "`PartialOrd` implemented here" @@ -341,7 +341,7 @@ fn check_unsafe_derive_deserialize<'tcx>( ty: Ty<'tcx>, ) { fn item_from_def_id<'tcx>(cx: &LateContext<'tcx>, def_id: DefId) -> &'tcx Item<'tcx> { - let hir_id = cx.tcx.hir().as_local_hir_id(def_id.expect_local()); + let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def_id.expect_local()); cx.tcx.hir().expect_item(hir_id) } @@ -355,7 +355,7 @@ fn check_unsafe_derive_deserialize<'tcx>( if match_path(&trait_ref.path, &paths::SERDE_DESERIALIZE); if let ty::Adt(def, _) = ty.kind; if let Some(local_def_id) = def.did.as_local(); - let adt_hir_id = cx.tcx.hir().as_local_hir_id(local_def_id); + let adt_hir_id = cx.tcx.hir().local_def_id_to_hir_id(local_def_id); if !is_allowed(cx, UNSAFE_DERIVE_DESERIALIZE, adt_hir_id); if cx.tcx.inherent_impls(def.did) .iter() diff --git a/src/tools/clippy/clippy_lints/src/new_without_default.rs b/src/tools/clippy/clippy_lints/src/new_without_default.rs index 621ebdef2f0..28d1322e946 100644 --- a/src/tools/clippy/clippy_lints/src/new_without_default.rs +++ b/src/tools/clippy/clippy_lints/src/new_without_default.rs @@ -103,7 +103,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault { cx.tcx.for_each_impl(default_trait_id, |d| { if let Some(ty_def) = cx.tcx.type_of(d).ty_adt_def() { if let Some(local_def_id) = ty_def.did.as_local() { - impls.insert(cx.tcx.hir().as_local_hir_id(local_def_id)); + impls.insert(cx.tcx.hir().local_def_id_to_hir_id(local_def_id)); } } }); diff --git a/src/tools/compiletest/Cargo.toml b/src/tools/compiletest/Cargo.toml index bd4c5949800..c601084d119 100644 --- a/src/tools/compiletest/Cargo.toml +++ b/src/tools/compiletest/Cargo.toml @@ -8,7 +8,7 @@ edition = "2018" diff = "0.1.10" env_logger = { version = "0.7", default-features = false } getopts = "0.2" -log = { package = "tracing", version = "0.1" } +tracing = "0.1" regex = "1.0" serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" diff --git a/src/tools/compiletest/src/errors.rs b/src/tools/compiletest/src/errors.rs index 8f685fb8559..8edc9c9cd03 100644 --- a/src/tools/compiletest/src/errors.rs +++ b/src/tools/compiletest/src/errors.rs @@ -8,8 +8,8 @@ use std::path::Path; use std::str::FromStr; use lazy_static::lazy_static; -use log::*; use regex::Regex; +use tracing::*; #[derive(Clone, Debug, PartialEq)] pub enum ErrorKind { diff --git a/src/tools/compiletest/src/header.rs b/src/tools/compiletest/src/header.rs index edbb8372633..90a0d8926ad 100644 --- a/src/tools/compiletest/src/header.rs +++ b/src/tools/compiletest/src/header.rs @@ -5,7 +5,7 @@ use std::io::prelude::*; use std::io::BufReader; use std::path::{Path, PathBuf}; -use log::*; +use tracing::*; use crate::common::{CompareMode, Config, Debugger, FailMode, Mode, PassMode}; use crate::extract_gdb_version; diff --git a/src/tools/compiletest/src/main.rs b/src/tools/compiletest/src/main.rs index bf3510ea089..46e16393a24 100644 --- a/src/tools/compiletest/src/main.rs +++ b/src/tools/compiletest/src/main.rs @@ -9,7 +9,6 @@ use crate::common::{expected_output_path, output_base_dir, output_relative_path, use crate::common::{CompareMode, Config, Debugger, Mode, PassMode, Pretty, TestPaths}; use crate::util::logv; use getopts::Options; -use log::*; use std::env; use std::ffi::OsString; use std::fs; @@ -18,6 +17,7 @@ use std::path::{Path, PathBuf}; use std::process::Command; use std::time::SystemTime; use test::ColorConfig; +use tracing::*; use walkdir::WalkDir; use self::header::EarlyProps; diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs index 7f49cb913b1..03136921ad6 100644 --- a/src/tools/compiletest/src/runtest.rs +++ b/src/tools/compiletest/src/runtest.rs @@ -30,7 +30,7 @@ use std::str; use glob::glob; use lazy_static::lazy_static; -use log::*; +use tracing::*; use crate::extract_gdb_version; use crate::is_android_gdb_target; diff --git a/src/tools/compiletest/src/util.rs b/src/tools/compiletest/src/util.rs index ddd7941b114..cc4b21f9efb 100644 --- a/src/tools/compiletest/src/util.rs +++ b/src/tools/compiletest/src/util.rs @@ -3,7 +3,7 @@ use std::env; use std::ffi::OsStr; use std::path::PathBuf; -use log::*; +use tracing::*; #[cfg(test)] mod tests; @@ -87,6 +87,7 @@ pub const ASAN_SUPPORTED_TARGETS: &'static [&'static str] = &[ "aarch64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-fuchsia", + "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu", ]; @@ -94,10 +95,14 @@ pub const LSAN_SUPPORTED_TARGETS: &'static [&'static str] = &["aarch64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-unknown-linux-gnu"]; pub const MSAN_SUPPORTED_TARGETS: &'static [&'static str] = - &["aarch64-unknown-linux-gnu", "x86_64-unknown-linux-gnu"]; + &["aarch64-unknown-linux-gnu", "x86_64-unknown-freebsd", "x86_64-unknown-linux-gnu"]; -pub const TSAN_SUPPORTED_TARGETS: &'static [&'static str] = - &["aarch64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-unknown-linux-gnu"]; +pub const TSAN_SUPPORTED_TARGETS: &'static [&'static str] = &[ + "aarch64-unknown-linux-gnu", + "x86_64-apple-darwin", + "x86_64-unknown-freebsd", + "x86_64-unknown-linux-gnu", +]; const BIG_ENDIAN: &'static [&'static str] = &[ "armebv7r", diff --git a/src/tools/miri b/src/tools/miri -Subproject 1edd231065c8eb75abf42bb375adda2120c9a6b +Subproject 1bfb26d6cae6f535ac1034877635fc0cef87fe6 diff --git a/src/tools/tier-check/Cargo.toml b/src/tools/tier-check/Cargo.toml new file mode 100644 index 00000000000..9917b383aab --- /dev/null +++ b/src/tools/tier-check/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "tier-check" +version = "0.1.0" +authors = ["Eric Huss"] +edition = "2018" +license = "MIT OR Apache-2.0" + +[dependencies] diff --git a/src/tools/tier-check/src/main.rs b/src/tools/tier-check/src/main.rs new file mode 100644 index 00000000000..b8d60a5e2fe --- /dev/null +++ b/src/tools/tier-check/src/main.rs @@ -0,0 +1,52 @@ +//! This is a script for validating the platform support page in the rustc book. +//! +//! The script takes two arguments, the path to the Platform Support source +//! page, and the second argument is the path to `rustc`. + +use std::collections::HashSet; + +fn main() { + let mut args = std::env::args().skip(1); + let src = args.next().expect("expected source file as first argument"); + let filename = std::path::Path::new(&src).file_name().unwrap().to_str().unwrap(); + let rustc = args.next().expect("expected rustc as second argument"); + let output = std::process::Command::new(rustc) + .arg("--print=target-list") + .output() + .expect("rustc should run"); + if !output.status.success() { + eprintln!("rustc failed to run"); + std::process::exit(0); + } + let stdout = std::str::from_utf8(&output.stdout).expect("utf8"); + let target_list: HashSet<_> = stdout.lines().collect(); + + let doc_targets_md = std::fs::read_to_string(&src).expect("failed to read input source"); + let doc_targets: HashSet<_> = doc_targets_md + .lines() + .filter(|line| line.starts_with('`') && line.contains('|')) + // These platforms only exist on macos. + .filter(|line| !line.contains("[^apple]") || cfg!(target_os = "macos")) + .map(|line| line.split('`').skip(1).next().expect("expected target code span")) + .collect(); + + let missing: Vec<_> = target_list.difference(&doc_targets).collect(); + let extra: Vec<_> = doc_targets.difference(&target_list).collect(); + for target in &missing { + eprintln!( + "error: target `{}` is missing from {}\n\ + If this is a new target, please add it to {}.", + target, filename, src + ); + } + for target in &extra { + eprintln!( + "error: target `{}` is in {}, but does not appear in the rustc target list\n\ + If the target has been removed, please edit {} and remove the target.", + target, filename, src + ); + } + if !missing.is_empty() || !extra.is_empty() { + std::process::exit(1); + } +} |