+Version 1.46.0 (2020-08-27)
+==========================
+
+Language
+--------
+- [`if`, `match`, and `loop` expressions can now be used in const functions.][72437]
+- [Additionally you are now also able to coerce and cast to slices (`&[T]`) in
+ const functions.][73862]
+- [The `#[track_caller]` attribute can now be added to functions to use the
+ function's caller's location information for panic messages.][72445]
+- [Recursively indexing into tuples no longer needs parentheses.][71322] E.g.
+ `x.0.0` over `(x.0).0`.
+- [`mem::transmute` can now be used in static and constants.][72920] **Note**
+ You currently can't use `mem::transmute` in constant functions.
+
+Compiler
+--------
+- [You can now use the `cdylib` target on Apple iOS and tvOS platforms.][73516]
+- [Enabled static "Position Independent Executables" by default
+ for `x86_64-unknown-linux-musl`.][70740]
+
+Libraries
+---------
+- [`mem::forget` is now a `const fn`.][73887]
+- [`String` now implements `From<char>`.][73466]
+- [The `leading_ones`, and `trailing_ones` methods have been stabilised for all
+ integer types.][73032]
+- [`vec::IntoIter<T>` now implements `AsRef<[T]>`.][72583]
+- [All non-zero integer types (`NonZeroU8`) now implement `TryFrom` for their
+ zero-able equivalent (e.g. `TryFrom<u8>`).][72717]
+- [`&[T]` and `&mut [T]` now implement `PartialEq<Vec<T>>`.][71660]
+- [`(String, u16)` now implements `ToSocketAddrs`.][73007]
+- [`vec::Drain<'_, T>` now implements `AsRef<[T]>`.][72584]
+
+Stabilized APIs
+---------------
+- [`Option::zip`]
+- [`vec::Drain::as_slice`]
+
+Cargo
+-----
+Added a number of new environment variables that are now available when
+compiling your crate.
+
+- [`CARGO_BIN_NAME` and `CARGO_CRATE_NAME`][cargo/8270] Providing the name of
+ the specific binary being compiled and the name of the crate.
+- [`CARGO_PKG_LICENSE`][cargo/8325] The license from the manifest of the package.
+- [`CARGO_PKG_LICENSE_FILE`][cargo/8387] The path to the license file.
+
+Compatibility Notes
+-------------------
+- [The target configuration option `abi_blacklist` has been renamed
+ to `unsupported_abis`.][74150] The old name will still continue to work.
+- [Rustc will now warn if you have a C-like enum that implements `Drop`.][72331]
+ This was previously accepted but will become a hard error in a future release.
+- [Rustc will fail to compile if you have a struct with
+ `#[repr(i128)]` or `#[repr(u128)]`.][74109] This representation is currently only
+ allowed on `enum`s.
+- [Tokens passed to `macro_rules!` are now always captured.][73293] This helps
+ ensure that spans have the correct information, and may cause breakage if you
+ were relying on receiving spans with dummy information.
+- [The InnoSetup installer for Windows is no longer available.][72569] This was
+ a legacy installer that was replaced by a MSI installer a few years ago but
+ was still being built.
+- [`{f32, f64}::asinh` now returns the correct values for negative numbers.][72486]
+- [Rustc will no longer accept overlapping trait implementations that only
+ differ in how the lifetime was bound.][72493]
+- [Rustc now correctly relates the lifetime of an existential associated
+ type.][71896] This fixes some edge cases where `rustc` would erroneously allow
+ you to pass a shorter lifetime than expected.
+- [Rustc now dynamically links to `libz` (also called `zlib`) on Linux.][74420]
+ The library will need to be installed for `rustc` to work, even though we
+ expect it to be already available on most systems.
+- [Tests annotated with `#[should_panic]` are broken on ARMv7 while running
+ under QEMU.][74820]
+- [Pretty printing of some tokens in procedural macros changed.][75453] The
+ exact output returned by rustc's pretty printing is an unstable
+ implementation detail: we recommend any macro relying on it to switch to a
+ more robust parsing system.
+
+[75453]: https://github.com/rust-lang/rust/issues/75453/
+[74820]: https://github.com/rust-lang/rust/issues/74820/
+[74420]: https://github.com/rust-lang/rust/issues/74420/
+[74109]: https://github.com/rust-lang/rust/pull/74109/
+[74150]: https://github.com/rust-lang/rust/pull/74150/
+[73862]: https://github.com/rust-lang/rust/pull/73862/
+[73887]: https://github.com/rust-lang/rust/pull/73887/
+[73466]: https://github.com/rust-lang/rust/pull/73466/
+[73516]: https://github.com/rust-lang/rust/pull/73516/
+[73293]: https://github.com/rust-lang/rust/pull/73293/
+[73007]: https://github.com/rust-lang/rust/pull/73007/
+[73032]: https://github.com/rust-lang/rust/pull/73032/
+[72920]: https://github.com/rust-lang/rust/pull/72920/
+[72569]: https://github.com/rust-lang/rust/pull/72569/
+[72583]: https://github.com/rust-lang/rust/pull/72583/
+[72584]: https://github.com/rust-lang/rust/pull/72584/
+[72717]: https://github.com/rust-lang/rust/pull/72717/
+[72437]: https://github.com/rust-lang/rust/pull/72437/
+[72445]: https://github.com/rust-lang/rust/pull/72445/
+[72486]: https://github.com/rust-lang/rust/pull/72486/
+[72493]: https://github.com/rust-lang/rust/pull/72493/
+[72331]: https://github.com/rust-lang/rust/pull/72331/
+[71896]: https://github.com/rust-lang/rust/pull/71896/
+[71660]: https://github.com/rust-lang/rust/pull/71660/
+[71322]: https://github.com/rust-lang/rust/pull/71322/
+[70740]: https://github.com/rust-lang/rust/pull/70740/
+[cargo/8270]: https://github.com/rust-lang/cargo/pull/8270/
+[cargo/8325]: https://github.com/rust-lang/cargo/pull/8325/
+[cargo/8387]: https://github.com/rust-lang/cargo/pull/8387/
+[`Option::zip`]: https://doc.rust-lang.org/stable/std/option/enum.Option.html#method.zip
+[`vec::Drain::as_slice`]: https://doc.rust-lang.org/stable/std/vec/struct.Drain.html#method.as_slice
+
+
+Version 1.45.2 (2020-08-03)
+==========================
+
+* [Fix bindings in tuple struct patterns][74954]
+* [Fix track_caller integration with trait objects][74784]
+
+[74954]: https://github.com/rust-lang/rust/issues/74954
+[74784]: https://github.com/rust-lang/rust/issues/74784
+
+
+Version 1.45.1 (2020-07-30)
+==========================
+
+* [Fix const propagation with references.][73613]
+* [rustfmt accepts rustfmt_skip in cfg_attr again.][73078]
+* [Avoid spurious implicit region bound.][74509]
+* [Install clippy on x.py install][74457]
+
+[73613]: https://github.com/rust-lang/rust/pull/73613
+[73078]: https://github.com/rust-lang/rust/issues/73078
+[74509]: https://github.com/rust-lang/rust/pull/74509
+[74457]: https://github.com/rust-lang/rust/pull/74457
+
+
Version 1.45.0 (2020-07-16)
==========================
// Prints "abcdefghijklmnopqrstuvwxyz"
```
- [`OsString` now implements `FromStr`.][71662]
-- [The `saturating_neg` method as been added to all signed integer primitive
+- [The `saturating_neg` method has been added to all signed integer primitive
types, and the `saturating_abs` method has been added for all integer
primitive types.][71886]
- [`Arc<T>`, `Rc<T>` now implement `From<Cow<'_, T>>`, and `Box` now
Cargo
-----
+- [Cargo uses the `embed-bitcode` flag to optimize disk usage and build
+ time.][cargo/8066]
+
Misc
----
- [Rustdoc now supports strikethrough text in Markdown.][71928] E.g.
- [Rustdoc's CLI's extra error exit codes have been removed.][71900] These were
previously undocumented and not intended for public use. Rustdoc still provides
a non-zero exit code on errors.
+- [Rustc's `lto` flag is incompatible with the new `embed-bitcode=no`.][71848]
+ This may cause issues if LTO is enabled through `RUSTFLAGS` or `cargo rustc`
+ flags while cargo is adding `embed-bitcode` itself. The recommended way to
+ control LTO is with Cargo profiles, either in `Cargo.toml` or `.cargo/config`,
+ or by setting `CARGO_PROFILE_<name>_LTO` in the environment.
Internals Only
--------------
- [Make clippy a git subtree instead of a git submodule][70655]
- [Unify the undo log of all snapshot types][69464]
+[71848]: https://github.com/rust-lang/rust/issues/71848/
[73420]: https://github.com/rust-lang/rust/issues/73420/
[72324]: https://github.com/rust-lang/rust/pull/72324/
[71843]: https://github.com/rust-lang/rust/pull/71843/
[69813]: https://github.com/rust-lang/rust/pull/69813/
[69464]: https://github.com/rust-lang/rust/pull/69464/
[68717]: https://github.com/rust-lang/rust/pull/68717/
+[cargo/8066]: https://github.com/rust-lang/cargo/pull/8066
[`Arc::as_ptr`]: https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#method.as_ptr
[`BTreeMap::remove_entry`]: https://doc.rust-lang.org/stable/std/collections/struct.BTreeMap.html#method.remove_entry
[`Rc::as_ptr`]: https://doc.rust-lang.org/stable/std/rc/struct.Rc.html#method.as_ptr
-6f959902b3103c49ca981fbc01871589c3498489
\ No newline at end of file
+04488afe34512aa4c33566eb16d8c912a3ae04f9
\ No newline at end of file
config.extended && config.tools.as_ref()
.map_or(true, |t| t.contains($path))
}
-
- #[allow(dead_code)]
- fn should_install(builder: &Builder<'_>) -> bool {
- builder.config.tools.as_ref().map_or(false, |t| t.contains($path))
- }
}
impl Step for $name {
install_cargo(builder, self.compiler.stage, self.target);
};
Rls, "rls", Self::should_build(_config), only_hosts: true, {
- if builder.ensure(dist::Rls { compiler: self.compiler, target: self.target }).is_some() ||
- Self::should_install(builder) {
+ if builder.ensure(dist::Rls { compiler: self.compiler, target: self.target }).is_some() {
install_rls(builder, self.compiler.stage, self.target);
} else {
builder.info(
};
RustAnalyzer, "rust-analyzer", Self::should_build(_config), only_hosts: true, {
builder.ensure(dist::RustAnalyzer { compiler: self.compiler, target: self.target });
- if Self::should_install(builder) {
- install_rust_analyzer(builder, self.compiler.stage, self.target);
- } else {
- builder.info(
- &format!("skipping Install rust-analyzer stage{} ({})", self.compiler.stage, self.target),
- );
- }
+ install_rust_analyzer(builder, self.compiler.stage, self.target);
};
Clippy, "clippy", Self::should_build(_config), only_hosts: true, {
builder.ensure(dist::Clippy { compiler: self.compiler, target: self.target });
- if Self::should_install(builder) {
- install_clippy(builder, self.compiler.stage, self.target);
- } else {
- builder.info(
- &format!("skipping Install clippy stage{} ({})", self.compiler.stage, self.target),
- );
- }
+ install_clippy(builder, self.compiler.stage, self.target);
};
Miri, "miri", Self::should_build(_config), only_hosts: true, {
- if builder.ensure(dist::Miri { compiler: self.compiler, target: self.target }).is_some() ||
- Self::should_install(builder) {
+ if builder.ensure(dist::Miri { compiler: self.compiler, target: self.target }).is_some() {
install_miri(builder, self.compiler.stage, self.target);
} else {
builder.info(
if builder.ensure(dist::Rustfmt {
compiler: self.compiler,
target: self.target
- }).is_some() || Self::should_install(builder) {
+ }).is_some() {
install_rustfmt(builder, self.compiler.stage, self.target);
} else {
builder.info(
#####################################
#
-# Azure Pipelines "auto" branch build for Rust on Linux, macOS, and Windows.
+# Azure Pipelines "auto" branch build for Rust on macOS
#
pr: none
trigger:
- auto
-variables:
-- group: prod-credentials
-
jobs:
-- job: Linux
- timeoutInMinutes: 600
- pool:
- vmImage: ubuntu-16.04
- steps:
- - template: steps/run.yml
- strategy:
- matrix:
- x86_64-gnu-llvm-8:
- RUST_BACKTRACE: 1
- dist-x86_64-linux: {}
- dist-x86_64-linux-alt:
- IMAGE: dist-x86_64-linux
- arm-android: {}
- armhf-gnu: {}
- dist-various-1: {}
- dist-various-2: {}
- dist-aarch64-linux: {}
- dist-android: {}
- dist-arm-linux: {}
- dist-armhf-linux: {}
- dist-armv7-linux: {}
- dist-i586-gnu-i586-i686-musl: {}
- dist-i686-freebsd: {}
- dist-i686-linux: {}
- dist-mips-linux: {}
- dist-mips64-linux: {}
- dist-mips64el-linux: {}
- dist-mipsel-linux: {}
- dist-powerpc-linux: {}
- dist-powerpc64-linux: {}
- dist-powerpc64le-linux: {}
- dist-s390x-linux: {}
- dist-x86_64-freebsd: {}
- dist-x86_64-musl: {}
- dist-x86_64-netbsd: {}
- i686-gnu: {}
- i686-gnu-nopt: {}
- test-various: {}
- wasm32: {}
- x86_64-gnu: {}
- x86_64-gnu-full-bootstrap: {}
- x86_64-gnu-aux: {}
- x86_64-gnu-tools:
- DEPLOY_TOOLSTATES_JSON: toolstates-linux.json
- x86_64-gnu-debug: {}
- x86_64-gnu-nopt: {}
- x86_64-gnu-distcheck: {}
- mingw-check: {}
-
- job: macOS
timeoutInMinutes: 600
pool:
vmImage: macos-10.15
steps:
- template: steps/run.yml
+ variables:
+ # We're still uploading macOS builds from Azure Pipelines.
+ - group: prod-credentials
strategy:
matrix:
# OSX builders running tests, these run the full test suite.
MACOSX_DEPLOYMENT_TARGET: 10.7
NO_LLVM_ASSERTIONS: 1
NO_DEBUG_ASSERTIONS: 1
-
-
-- job: Windows
- timeoutInMinutes: 600
- pool:
- vmImage: 'vs2017-win2016'
- steps:
- - template: steps/run.yml
- strategy:
- matrix:
- # 32/64 bit MSVC tests
- x86_64-msvc-1:
- INITIAL_RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --enable-profiler
- SCRIPT: make ci-subset-1
- # FIXME(#59637)
- NO_DEBUG_ASSERTIONS: 1
- NO_LLVM_ASSERTIONS: 1
- x86_64-msvc-2:
- INITIAL_RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --enable-profiler
- SCRIPT: make ci-subset-2
- i686-msvc-1:
- INITIAL_RUST_CONFIGURE_ARGS: --build=i686-pc-windows-msvc
- SCRIPT: make ci-subset-1
- # FIXME(#59637)
- NO_DEBUG_ASSERTIONS: 1
- NO_LLVM_ASSERTIONS: 1
- i686-msvc-2:
- INITIAL_RUST_CONFIGURE_ARGS: --build=i686-pc-windows-msvc
- SCRIPT: make ci-subset-2
- # FIXME(#59637)
- NO_DEBUG_ASSERTIONS: 1
- NO_LLVM_ASSERTIONS: 1
- x86_64-msvc-cargo:
- SCRIPT: python x.py test src/tools/cargotest src/tools/cargo
- INITIAL_RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --enable-lld
- VCVARS_BAT: vcvars64.bat
- # FIXME(#59637)
- NO_DEBUG_ASSERTIONS: 1
- NO_LLVM_ASSERTIONS: 1
- # MSVC tools tests
- x86_64-msvc-tools:
- SCRIPT: src/ci/docker/host-x86_64/x86_64-gnu-tools/checktools.sh x.py
- INITIAL_RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --save-toolstates=/tmp/toolstate/toolstates.json
-
- # 32/64-bit MinGW builds.
- #
- # We are using MinGW with posix threads since LLVM does not compile with
- # the win32 threads version due to missing support for C++'s std::thread.
- #
- # Instead of relying on the MinGW version installed on appveryor we download
- # and install one ourselves so we won't be surprised by changes to appveyor's
- # build image.
- #
- # Finally, note that the downloads below are all in the `rust-lang-ci` S3
- # bucket, but they cleraly didn't originate there! The downloads originally
- # came from the mingw-w64 SourceForge download site. Unfortunately
- # SourceForge is notoriously flaky, so we mirror it on our own infrastructure.
- i686-mingw-1:
- INITIAL_RUST_CONFIGURE_ARGS: --build=i686-pc-windows-gnu
- SCRIPT: make ci-mingw-subset-1
- CUSTOM_MINGW: 1
- # FIXME(#59637)
- NO_DEBUG_ASSERTIONS: 1
- NO_LLVM_ASSERTIONS: 1
- i686-mingw-2:
- INITIAL_RUST_CONFIGURE_ARGS: --build=i686-pc-windows-gnu
- SCRIPT: make ci-mingw-subset-2
- CUSTOM_MINGW: 1
- x86_64-mingw-1:
- SCRIPT: make ci-mingw-subset-1
- INITIAL_RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-gnu
- CUSTOM_MINGW: 1
- # FIXME(#59637)
- NO_DEBUG_ASSERTIONS: 1
- NO_LLVM_ASSERTIONS: 1
- x86_64-mingw-2:
- SCRIPT: make ci-mingw-subset-2
- INITIAL_RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-gnu
- CUSTOM_MINGW: 1
-
- # 32/64 bit MSVC and GNU deployment
- dist-x86_64-msvc:
- INITIAL_RUST_CONFIGURE_ARGS: >-
- --build=x86_64-pc-windows-msvc
- --target=x86_64-pc-windows-msvc,aarch64-pc-windows-msvc
- --enable-full-tools
- --enable-profiler
- SCRIPT: python x.py dist
- DIST_REQUIRE_ALL_TOOLS: 1
- dist-i686-msvc:
- INITIAL_RUST_CONFIGURE_ARGS: >-
- --build=i686-pc-windows-msvc
- --target=i586-pc-windows-msvc
- --enable-full-tools
- --enable-profiler
- SCRIPT: python x.py dist
- DIST_REQUIRE_ALL_TOOLS: 1
- dist-i686-mingw:
- INITIAL_RUST_CONFIGURE_ARGS: --build=i686-pc-windows-gnu --enable-full-tools --enable-profiler
- SCRIPT: python x.py dist
- CUSTOM_MINGW: 1
- DIST_REQUIRE_ALL_TOOLS: 1
- dist-x86_64-mingw:
- SCRIPT: python x.py dist
- INITIAL_RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-gnu --enable-full-tools --enable-profiler
- CUSTOM_MINGW: 1
- DIST_REQUIRE_ALL_TOOLS: 1
-
- # "alternate" deployment, see .travis.yml for more info
- dist-x86_64-msvc-alt:
- INITIAL_RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --enable-extended --enable-profiler
- SCRIPT: python x.py dist
+++ /dev/null
-#####################################
-## READ BEFORE CHANGING THIS ##
-#####################################
-
-# We're in the process of evaluating GitHub Actions as a possible replacement
-# for Azure Pipelines, and at the moment the configuration is duplicated
-# between the two CI providers. Be sure to also change the configuration in
-# src/ci/github-actions when changing this file.
-
-#####################################
-
-#
-# Azure Pipelines job to publish toolstate. Only triggers on pushes to master.
-#
-
-pr: none
-trigger:
- - master
-
-variables:
-- group: prod-credentials
-
-pool:
- vmImage: ubuntu-16.04
-
-steps:
-- checkout: self
- fetchDepth: 2
-
-- script: src/ci/publish_toolstate.sh
- displayName: Publish toolstate
- env:
- TOOLSTATE_REPO_ACCESS_TOKEN: $(TOOLSTATE_REPO_ACCESS_TOKEN)
+++ /dev/null
-#####################################
-## READ BEFORE CHANGING THIS ##
-#####################################
-
-# We're in the process of evaluating GitHub Actions as a possible replacement
-# for Azure Pipelines, and at the moment the configuration is duplicated
-# between the two CI providers. Be sure to also change the configuration in
-# src/ci/github-actions when changing this file.
-
-#####################################
-
-#
-# Azure Pipelines pull request build for Rust
-#
-
-trigger: none
-pr:
-- master
-
-variables:
-- group: public-credentials
-
-jobs:
-- job: Linux
- timeoutInMinutes: 600
- pool:
- vmImage: ubuntu-16.04
- steps:
- - template: steps/run.yml
- strategy:
- matrix:
- x86_64-gnu-llvm-8: {}
- mingw-check: {}
- x86_64-gnu-tools:
- CI_ONLY_WHEN_SUBMODULES_CHANGED: 1
trigger:
- try
-variables:
-- group: prod-credentials
-
jobs:
-- job: Linux
+- job: Dummy
timeoutInMinutes: 600
pool:
vmImage: ubuntu-16.04
steps:
- - template: steps/run.yml
- strategy:
- matrix:
- dist-x86_64-linux: {}
-
-# The macOS and Windows builds here are currently disabled due to them not being
-# overly necessary on `try` builds. We also don't actually have anything that
-# consumes the artifacts currently. Perhaps one day we can re-enable, but for now
-# it helps free up capacity on Azure.
-# - job: macOS
-# timeoutInMinutes: 600
-# pool:
-# vmImage: macos-10.15
-# steps:
-# - template: steps/run.yml
-# strategy:
-# matrix:
-# dist-x86_64-apple:
-# SCRIPT: ./x.py dist
-# INITIAL_RUST_CONFIGURE_ARGS: --target=aarch64-apple-ios,armv7-apple-ios,armv7s-apple-ios,i386-apple-ios,x86_64-apple-ios --enable-full-tools --enable-sanitizers --enable-profiler --set rust.jemalloc
-# DEPLOY: 1
-# RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
-# MACOSX_DEPLOYMENT_TARGET: 10.7
-# NO_LLVM_ASSERTIONS: 1
-# NO_DEBUG_ASSERTIONS: 1
-# DIST_REQUIRE_ALL_TOOLS: 1
-#
-# dist-x86_64-apple-alt:
-# SCRIPT: ./x.py dist
-# INITIAL_RUST_CONFIGURE_ARGS: --enable-extended --enable-profiler --set rust.jemalloc
-# DEPLOY_ALT: 1
-# RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
-# MACOSX_DEPLOYMENT_TARGET: 10.7
-# NO_LLVM_ASSERTIONS: 1
-# NO_DEBUG_ASSERTIONS: 1
-#
-# - job: Windows
-# timeoutInMinutes: 600
-# pool:
-# vmImage: 'vs2017-win2016'
-# steps:
-# - template: steps/run.yml
-# strategy:
-# matrix:
-# dist-x86_64-msvc:
-# INITIAL_RUST_CONFIGURE_ARGS: >
-# --build=x86_64-pc-windows-msvc
-# --target=x86_64-pc-windows-msvc,aarch64-pc-windows-msvc
-# --enable-full-tools
-# --enable-profiler
-# SCRIPT: python x.py dist
-# DIST_REQUIRE_ALL_TOOLS: 1
-# DEPLOY: 1
-#
-# dist-x86_64-msvc-alt:
-# INITIAL_RUST_CONFIGURE_ARGS: --build=x86_64-pc-windows-msvc --enable-extended --enable-profiler
-# SCRIPT: python x.py dist
-# DEPLOY_ALT: 1
+ - bash: echo "We're running this job since bors is still gating on Azure"
install_prereq() {
curl https://apt.llvm.org/llvm-snapshot.gpg.key|apt-key add -
- add-apt-repository -y 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic main'
+ add-apt-repository -y 'deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic-11 main'
apt-get update
apt-get install -y --no-install-recommends \
build-essential \
CI_JOB_NAME: ${{ matrix.name }}
- &public-variables
- SCCACHE_BUCKET: rust-lang-gha-caches
- TOOLSTATE_REPO: https://github.com/pietroalbini/rust-toolstate
- CACHE_DOMAIN: ci-caches-gha.rust-lang.org
+ SCCACHE_BUCKET: rust-lang-ci-sccache2
+ TOOLSTATE_REPO: https://github.com/rust-lang-nursery/rust-toolstate
+ CACHE_DOMAIN: ci-caches.rust-lang.org
- &prod-variables
+ SCCACHE_BUCKET: rust-lang-ci-sccache2
+ DEPLOY_BUCKET: rust-lang-ci2
+ TOOLSTATE_REPO: https://github.com/rust-lang-nursery/rust-toolstate
+ TOOLSTATE_ISSUES_API_URL: https://api.github.com/repos/rust-lang/rust/issues
+ TOOLSTATE_PUBLISH: 1
+ # AWS_SECRET_ACCESS_KEYs are stored in GitHub's secrets storage, named
+ # AWS_SECRET_ACCESS_KEY_<keyid>. Including the key id in the name allows to
+ # rotate them in a single branch while keeping the old key in another
+ # branch, which wouldn't be possible if the key was named with the kind
+ # (caches, artifacts...).
+ CACHES_AWS_ACCESS_KEY_ID: AKIA46X5W6CZI5DHEBFL
+ ARTIFACTS_AWS_ACCESS_KEY_ID: AKIA46X5W6CZN24CBO55
+ CACHE_DOMAIN: ci-caches.rust-lang.org
+
+ - &dummy-variables
SCCACHE_BUCKET: rust-lang-gha-caches
DEPLOY_BUCKET: rust-lang-gha
TOOLSTATE_REPO: https://github.com/pietroalbini/rust-toolstate
if: success() && !env.SKIP_JOB && github.ref != 'refs/heads/try'
<<: *step
+ # Rust Log Analyzer can't currently detect the PR number of a GitHub
+ # Actions build on its own, so a hint in the log message is needed to
+ # point it in the right direction.
+ - name: configure the PR in which the error message will be posted
+ run: echo "[CI_PR_NUMBER=$num]"
+ env:
+ num: ${{ github.event.number }}
+ if: success() && !env.SKIP_JOBS && github.event_name == 'pull_request'
+
- name: add extra environment variables
run: src/ci/scripts/setup-environment.sh
env:
<<: *base-ci-job
name: auto-fallible
env:
- <<: [*shared-ci-variables, *prod-variables]
+ <<: [*shared-ci-variables, *dummy-variables]
if: github.event_name == 'push' && github.ref == 'refs/heads/auto' && github.repository == 'rust-lang-ci/rust'
strategy:
matrix:
#
# FIXME: need a scheme for changing this `nightly` value to `beta` and `stable`
# either automatically or manually.
-export RUST_RELEASE_CHANNEL=beta
+export RUST_RELEASE_CHANNEL=stable
# Always set the release channel for bootstrap; this is normally not important (i.e., only dist
# builds would seem to matter) but in practice bootstrap wants to know whether we're targeting
}
// NO-OPT-OUT, OBJECT-FILES-NO, AUDIT-ORDER
- cmd.add_eh_frame_header();
+ if sess.target.target.options.eh_frame_header {
+ cmd.add_eh_frame_header();
+ }
// NO-OPT-OUT, OBJECT-FILES-NO
if crt_objects_fallback {
// Some versions of `gcc` add it implicitly, some (e.g. `musl-gcc`) don't,
// so we just always add it.
fn add_eh_frame_header(&mut self) {
- if !self.sess.target.target.options.is_like_osx
- && !self.sess.target.target.options.is_like_windows
- && !self.sess.target.target.options.is_like_solaris
- && self.sess.target.target.target_os != "uefi"
- {
- self.linker_arg("--eh-frame-hdr");
- }
+ self.linker_arg("--eh-frame-hdr");
}
}
declare_lint! {
pub CLASHING_EXTERN_DECLARATIONS,
- Warn,
+ Allow,
"detects when an extern fn has been declared with the same name but different types"
}
match ty.kind {
ty::FnPtr(_) => true,
ty::Ref(..) => true,
- ty::Adt(field_def, substs) if field_def.repr.transparent() && !field_def.is_union() => {
- for field in field_def.all_fields() {
- let field_ty = self.cx.tcx.normalize_erasing_regions(
- self.cx.param_env,
- field.ty(self.cx.tcx, substs),
- );
- if field_ty.is_zst(self.cx.tcx, field.did) {
- continue;
- }
+ ty::Adt(def, _)
+ if def.is_box() && matches!(self.mode, ImproperCTypesMode::Definitions) =>
+ {
+ true
+ }
+ ty::Adt(def, substs) if def.repr.transparent() && !def.is_union() => {
+ let guaranteed_nonnull_optimization = self
+ .cx
+ .tcx
+ .get_attrs(def.did)
+ .iter()
+ .any(|a| a.check_name(sym::rustc_nonnull_optimization_guaranteed));
+
+ if guaranteed_nonnull_optimization {
+ return true;
+ }
- let attrs = self.cx.tcx.get_attrs(field_def.did);
- if attrs
- .iter()
- .any(|a| a.check_name(sym::rustc_nonnull_optimization_guaranteed))
- || self.ty_is_known_nonnull(field_ty)
- {
- return true;
+ for variant in &def.variants {
+ if let Some(field) = variant.transparent_newtype_field(self.cx.tcx) {
+ if self.ty_is_known_nonnull(field.ty(self.cx.tcx, substs)) {
+ return true;
+ }
}
}
}
/// Check if this enum can be safely exported based on the "nullable pointer optimization".
- /// Currently restricted to function pointers, references, `core::num::NonZero*`,
+ /// Currently restricted to function pointers, boxes, references, `core::num::NonZero*`,
/// `core::ptr::NonNull`, and `#[repr(transparent)]` newtypes.
fn is_repr_nullable_ptr(
&self,
}
match ty.kind {
+ ty::Adt(def, _)
+ if def.is_box() && matches!(self.mode, ImproperCTypesMode::Definitions) =>
+ {
+ FfiSafe
+ }
+
ty::Adt(def, substs) => {
if def.is_phantom_data() {
return FfiPhantom(ty);
debug!(" => associated item with unsizeable self: Self");
Some(Instance { def: InstanceDef::VtableShim(def_id), substs })
} else {
- Instance::resolve(tcx, param_env, def_id, substs).ok().flatten()
+ Instance::resolve_for_fn_ptr(tcx, param_env, def_id, substs)
}
}
lint: &'static lint::Lint,
source_info: SourceInfo,
message: &'static str,
- panic: AssertKind<ConstInt>,
+ panic: AssertKind<impl std::fmt::Debug>,
) -> Option<()> {
let lint_root = self.lint_root(source_info)?;
self.tcx.struct_span_lint_hir(lint, lint_root, source_info.span, |lint| {
let expected = ScalarMaybeUninit::from(Scalar::from_bool(*expected));
let value_const = self.ecx.read_scalar(value).unwrap();
if expected != value_const {
+ enum DbgVal<T> {
+ Val(T),
+ Underscore,
+ }
+ impl<T: std::fmt::Debug> std::fmt::Debug for DbgVal<T> {
+ fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Self::Val(val) => val.fmt(fmt),
+ Self::Underscore => fmt.write_str("_"),
+ }
+ }
+ }
let mut eval_to_int = |op| {
- let op = self
- .eval_operand(op, source_info)
- .expect("if we got here, it must be const");
- self.ecx.read_immediate(op).unwrap().to_const_int()
+ // This can be `None` if the lhs wasn't const propagated and we just
+ // triggered the assert on the value of the rhs.
+ match self.eval_operand(op, source_info) {
+ Some(op) => {
+ DbgVal::Val(self.ecx.read_immediate(op).unwrap().to_const_int())
+ }
+ None => DbgVal::Underscore,
+ }
};
let msg = match msg {
AssertKind::DivisionByZero(op) => {
_,
) => Err((span, "function pointer casts are not allowed in const fn".into())),
Rvalue::Cast(CastKind::Pointer(PointerCast::Unsize), op, cast_ty) => {
- let pointee_ty = cast_ty.builtin_deref(true).unwrap().ty;
+ let pointee_ty = if let Some(deref_ty) = cast_ty.builtin_deref(true) {
+ deref_ty.ty
+ } else {
+ // We cannot allow this for now.
+ return Err((
+ span,
+ "unsizing casts are only allowed for references right now".into(),
+ ));
+ };
let unsized_ty = tcx.struct_tail_erasing_lifetimes(pointee_ty, tcx.param_env(def_id));
if let ty::Slice(_) | ty::Str = unsized_ty.kind {
check_operand(tcx, op, span, def_id, body)?;
--- /dev/null
+use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult};
+
+pub fn target() -> TargetResult {
+ let mut base = super::apple_base::opts();
+ base.cpu = "apple-a12".to_string();
+ base.max_atomic_width = Some(128);
+ base.pre_link_args.insert(LinkerFlavor::Gcc, vec!["-arch".to_string(), "arm64".to_string()]);
+
+ base.link_env_remove.extend(super::apple_base::macos_link_env_remove());
+
+ // Clang automatically chooses a more specific target based on
+ // MACOSX_DEPLOYMENT_TARGET. To enable cross-language LTO to work
+ // correctly, we do too.
+ let arch = "aarch64";
+ let llvm_target = super::apple_base::macos_llvm_target(&arch);
+
+ Ok(Target {
+ llvm_target,
+ target_endian: "little".to_string(),
+ target_pointer_width: "64".to_string(),
+ target_c_int_width: "32".to_string(),
+ data_layout: "e-m:o-i64:64-i128:128-n32:64-S128".to_string(),
+ arch: arch.to_string(),
+ target_os: "macos".to_string(),
+ target_env: String::new(),
+ target_vendor: "apple".to_string(),
+ linker_flavor: LinkerFlavor::Gcc,
+ options: TargetOptions { target_mcount: "\u{1}mcount".to_string(), ..base },
+ })
+}
has_elf_tls: version >= (10, 7),
abi_return_struct_as_int: true,
emit_debug_gdb_scripts: false,
+ eh_frame_header: false,
// This environment variable is pretty magical but is intended for
// producing deterministic builds. This was first discovered to be used
has_rpath: false,
pre_link_args: args,
position_independent_executables: false,
+ eh_frame_header: false,
..Default::default()
}
}
is_like_solaris: true,
limit_rdylib_exports: false, // Linker doesn't support this
eliminate_frame_pointer: false,
+ eh_frame_header: false,
late_link_args,
// While we support ELF TLS, rust requires a way to register
("i686-unknown-haiku", i686_unknown_haiku),
("x86_64-unknown-haiku", x86_64_unknown_haiku),
+ ("aarch64-apple-darwin", aarch64_apple_darwin),
("x86_64-apple-darwin", x86_64_apple_darwin),
("i686-apple-darwin", i686_apple_darwin),
/// Whether to use legacy .ctors initialization hooks rather than .init_array. Defaults
/// to false (uses .init_array).
pub use_ctors_section: bool,
+
+ /// Whether the linker is instructed to add a `GNU_EH_FRAME` ELF header
+ /// used to locate unwinding information is passed
+ /// (only has effect if the linker is `ld`-like).
+ pub eh_frame_header: bool,
}
impl Default for TargetOptions {
relax_elf_relocations: false,
llvm_args: vec![],
use_ctors_section: false,
+ eh_frame_header: true,
}
}
}
key!(relax_elf_relocations, bool);
key!(llvm_args, list);
key!(use_ctors_section, bool);
+ key!(eh_frame_header, bool);
// NB: The old name is deprecated, but support for it is retained for
// compatibility.
target_option_val!(relax_elf_relocations);
target_option_val!(llvm_args);
target_option_val!(use_ctors_section);
+ target_option_val!(eh_frame_header);
if default.unsupported_abis != self.options.unsupported_abis {
d.insert(
// See the thumb_base.rs file for an explanation of this value
emit_debug_gdb_scripts: false,
+ eh_frame_header: false,
+
..Default::default()
},
})
relocation_model: RelocModel::Static,
emit_debug_gdb_scripts: false,
unsupported_abis: super::riscv_base::unsupported_abis(),
+ eh_frame_header: false,
..Default::default()
},
})
relocation_model: RelocModel::Static,
emit_debug_gdb_scripts: false,
unsupported_abis: super::riscv_base::unsupported_abis(),
+ eh_frame_header: false,
..Default::default()
},
})
relocation_model: RelocModel::Static,
emit_debug_gdb_scripts: false,
unsupported_abis: super::riscv_base::unsupported_abis(),
+ eh_frame_header: false,
..Default::default()
},
})
code_model: Some(CodeModel::Medium),
emit_debug_gdb_scripts: false,
unsupported_abis: super::riscv_base::unsupported_abis(),
+ eh_frame_header: false,
..Default::default()
},
})
code_model: Some(CodeModel::Medium),
emit_debug_gdb_scripts: false,
unsupported_abis: super::riscv_base::unsupported_abis(),
+ eh_frame_header: false,
..Default::default()
},
})
target_family: Some("unix".to_string()),
is_like_solaris: true,
limit_rdylib_exports: false, // Linker doesn't support this
+ eh_frame_header: false,
..Default::default()
}
abi_return_struct_as_int: true,
emit_debug_gdb_scripts: false,
requires_uwtable: true,
+ eh_frame_header: false,
..Default::default()
}
base.cpu = "core2".to_string();
base.max_atomic_width = Some(128); // core2 support cmpxchg16b
base.eliminate_frame_pointer = false;
- base.pre_link_args.insert(LinkerFlavor::Gcc, vec!["-m64".to_string()]);
+ base.pre_link_args.insert(
+ LinkerFlavor::Gcc,
+ vec!["-m64".to_string(), "-arch".to_string(), "x86_64".to_string()],
+ );
base.link_env_remove.extend(super::apple_base::macos_link_env_remove());
base.stack_probes = true;
// and turn them into an explicit negative impl for our type.
debug!("Projecting and unifying projection predicate {:?}", predicate);
- match poly_project_and_unify_type(select, &obligation.with(p)) {
+ match project::poly_project_and_unify_type(select, &obligation.with(p)) {
Err(e) => {
debug!(
"evaluate_nested_obligations: Unable to unify predicate \
);
return false;
}
- Ok(Some(v)) => {
+ Ok(Err(project::InProgress)) => {
+ debug!("evaluate_nested_obligations: recursive projection predicate");
+ return false;
+ }
+ Ok(Ok(Some(v))) => {
// We only care about sub-obligations
// when we started out trying to unify
// some inference variables. See the comment above
}
}
}
- Ok(None) => {
- // It's ok not to make progress when hvave no inference variables -
+ Ok(Ok(None)) => {
+ // It's ok not to make progress when have no inference variables -
// in that case, we were only performing unifcation to check if an
// error occurred (which would indicate that it's impossible for our
// type to implement the auto trait).
ty::PredicateKind::Projection(ref data) => {
let project_obligation = obligation.with(*data);
+ let tcx = self.selcx.tcx();
match project::poly_project_and_unify_type(self.selcx, &project_obligation) {
- Ok(None) => {
- let tcx = self.selcx.tcx();
- pending_obligation.stalled_on =
- trait_ref_infer_vars(self.selcx, data.to_poly_trait_ref(tcx));
+ Ok(Ok(Some(os))) => ProcessResult::Changed(mk_pending(os)),
+ Ok(Ok(None)) => {
+ pending_obligation.stalled_on = trait_ref_infer_vars(
+ self.selcx,
+ project_obligation.predicate.to_poly_trait_ref(tcx),
+ );
ProcessResult::Unchanged
}
- Ok(Some(os)) => ProcessResult::Changed(mk_pending(os)),
+ // Let the caller handle the recursion
+ Ok(Err(project::InProgress)) => ProcessResult::Changed(mk_pending(vec![
+ pending_obligation.obligation.clone(),
+ ])),
Err(e) => ProcessResult::Error(CodeProjectionError(e)),
}
}
pub use self::object_safety::MethodViolationCode;
pub use self::object_safety::ObjectSafetyViolation;
pub use self::on_unimplemented::{OnUnimplementedDirective, OnUnimplementedNote};
-pub use self::project::{
- normalize, normalize_projection_type, normalize_to, poly_project_and_unify_type,
-};
+pub use self::project::{normalize, normalize_projection_type, normalize_to};
pub use self::select::{EvaluationCache, SelectionCache, SelectionContext};
pub use self::select::{EvaluationResult, IntercrateAmbiguityCause, OverflowError};
pub use self::specialize::specialization_graph::FutureCompatOverlapError;
pub type ProjectionTyObligation<'tcx> = Obligation<'tcx, ty::ProjectionTy<'tcx>>;
+pub(super) struct InProgress;
+
/// When attempting to resolve `<T as TraitRef>::Name` ...
#[derive(Debug)]
pub enum ProjectionTyError<'tcx> {
///
/// If successful, this may result in additional obligations. Also returns
/// the projection cache key used to track these additional obligations.
-pub fn poly_project_and_unify_type<'cx, 'tcx>(
+///
+/// ## Returns
+///
+/// - `Err(_)`: the projection can be normalized, but is not equal to the
+/// expected type.
+/// - `Ok(Err(InProgress))`: this is called recursively while normalizing
+/// the same projection.
+/// - `Ok(Ok(None))`: The projection cannot be normalized due to ambiguity
+/// (resolving some inference variables in the projection may fix this).
+/// - `Ok(Ok(Some(obligations)))`: The projection bound holds subject to
+/// the given obligations. If the projection cannot be normalized because
+/// the required trait bound doesn't hold this returned with `obligations`
+/// being a predicate that cannot be proven.
+pub(super) fn poly_project_and_unify_type<'cx, 'tcx>(
selcx: &mut SelectionContext<'cx, 'tcx>,
obligation: &PolyProjectionObligation<'tcx>,
-) -> Result<Option<Vec<PredicateObligation<'tcx>>>, MismatchedProjectionTypes<'tcx>> {
+) -> Result<
+ Result<Option<Vec<PredicateObligation<'tcx>>>, InProgress>,
+ MismatchedProjectionTypes<'tcx>,
+> {
debug!("poly_project_and_unify_type(obligation={:?})", obligation);
let infcx = selcx.infcx();
/// <T as Trait>::U == V
///
/// If successful, this may result in additional obligations.
+///
+/// See [poly_project_and_unify_type] for an explanation of the return value.
fn project_and_unify_type<'cx, 'tcx>(
selcx: &mut SelectionContext<'cx, 'tcx>,
obligation: &ProjectionObligation<'tcx>,
-) -> Result<Option<Vec<PredicateObligation<'tcx>>>, MismatchedProjectionTypes<'tcx>> {
+) -> Result<
+ Result<Option<Vec<PredicateObligation<'tcx>>>, InProgress>,
+ MismatchedProjectionTypes<'tcx>,
+> {
debug!("project_and_unify_type(obligation={:?})", obligation);
let mut obligations = vec![];
obligation.recursion_depth,
&mut obligations,
) {
- Some(n) => n,
- None => return Ok(None),
+ Ok(Some(n)) => n,
+ Ok(None) => return Ok(Ok(None)),
+ Err(InProgress) => return Ok(Err(InProgress)),
};
debug!(
{
Ok(InferOk { obligations: inferred_obligations, value: () }) => {
obligations.extend(inferred_obligations);
- Ok(Some(obligations))
+ Ok(Ok(Some(obligations)))
}
Err(err) => {
debug!("project_and_unify_type: equating types encountered error {:?}", err);
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,
}
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
depth,
obligations,
)
+ .ok()
+ .flatten()
.unwrap_or_else(move || {
// if we bottom out in ambiguity, create a type variable
// and a deferred predicate to resolve this when more type
cause: ObligationCause<'tcx>,
depth: usize,
obligations: &mut Vec<PredicateObligation<'tcx>>,
-) -> Option<Ty<'tcx>> {
+) -> Result<Option<Ty<'tcx>>, InProgress> {
let infcx = selcx.infcx();
let projection_ty = infcx.resolve_vars_if_possible(&projection_ty);
"opt_normalize_projection_type: \
found cache entry: ambiguous"
);
- return None;
+ return Ok(None);
}
Err(ProjectionCacheEntry::InProgress) => {
// If while normalized A::B, we are asked to normalize
// to normalize `A::B`, we will want to check the
// where-clauses in scope. So we will try to unify `A::B`
// with `A::B`, which can trigger a recursive
- // normalization. In that case, I think we will want this code:
- //
- // ```
- // let ty = selcx.tcx().mk_projection(projection_ty.item_def_id,
- // projection_ty.substs;
- // return Some(NormalizedTy { value: v, obligations: vec![] });
- // ```
+ // normalization.
debug!(
"opt_normalize_projection_type: \
found cache entry: in-progress"
);
- // But for now, let's classify this as an overflow:
- let recursion_limit = selcx.tcx().sess.recursion_limit();
- let obligation =
- Obligation::with_depth(cause, recursion_limit.0, param_env, projection_ty);
- selcx.infcx().report_overflow_error(&obligation, false);
+ return Err(InProgress);
}
Err(ProjectionCacheEntry::NormalizedTy(ty)) => {
// This is the hottest path in this function.
cause,
depth,
));
- return Some(ty.value);
+ return Ok(Some(ty.value));
}
Err(ProjectionCacheEntry::Error) => {
debug!(
);
let result = normalize_to_error(selcx, param_env, projection_ty, cause, depth);
obligations.extend(result.obligations);
- return Some(result.value);
+ return Ok(Some(result.value));
}
}
let cache_value = prune_cache_value_obligations(infcx, &result);
infcx.inner.borrow_mut().projection_cache().insert_ty(cache_key, cache_value);
obligations.extend(result.obligations);
- Some(result.value)
+ Ok(Some(result.value))
}
Ok(ProjectedTy::NoProgress(projected_ty)) => {
debug!(
let result = Normalized { value: projected_ty, obligations: vec![] };
infcx.inner.borrow_mut().projection_cache().insert_ty(cache_key, result.clone());
// No need to extend `obligations`.
- Some(result.value)
+ Ok(Some(result.value))
}
Err(ProjectionTyError::TooManyCandidates) => {
debug!(
too many candidates"
);
infcx.inner.borrow_mut().projection_cache().ambiguous(cache_key);
- None
+ Ok(None)
}
Err(ProjectionTyError::TraitSelectionError(_)) => {
debug!("opt_normalize_projection_type: ERROR");
infcx.inner.borrow_mut().projection_cache().error(cache_key);
let result = normalize_to_error(selcx, param_env, projection_ty, cause, depth);
obligations.extend(result.obligations);
- Some(result.value)
+ Ok(Some(result.value))
}
}
}
}
super::ImplSourceAutoImpl(..) | super::ImplSourceBuiltin(..) => {
// These traits have no associated types.
- span_bug!(
+ selcx.tcx().sess.delay_span_bug(
obligation.cause.span,
- "Cannot project an associated type from `{:?}`",
- impl_source
+ &format!("Cannot project an associated type from `{:?}`", impl_source),
);
+ return Err(());
}
};
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,
}
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
&ty::PredicateKind::Projection(data) => {
let project_obligation = obligation.with(data);
match project::poly_project_and_unify_type(self, &project_obligation) {
- Ok(Some(mut subobligations)) => {
+ Ok(Ok(Some(mut subobligations))) => {
self.add_depth(subobligations.iter_mut(), obligation.recursion_depth);
let result = self.evaluate_predicates_recursively(
previous_stack,
}
result
}
- Ok(None) => Ok(EvaluatedToAmbig),
+ Ok(Ok(None)) => Ok(EvaluatedToAmbig),
+ // EvaluatedToRecur might also be acceptable here, but use
+ // Unknown for now because it means that we won't dismiss a
+ // selection candidate solely because it has a projection
+ // cycle. This is closest to the previous behavior of
+ // immediately erroring.
+ Ok(Err(project::InProgress)) => Ok(EvaluatedToUnknown),
Err(_) => Ok(EvaluatedToErr),
}
}
// Check for infer types because cases like `Option<{integer}>` would
// panic otherwise.
if !expr_ty.has_infer_types()
+ && !ty.has_infer_types()
&& fcx.tcx.type_implements_trait((
from_trait,
ty,
/// opaque type.
opaque_types_vars: RefCell<FxHashMap<Ty<'tcx>, Ty<'tcx>>>,
- /// Each type parameter has an implicit region bound that
- /// indicates it must outlive at least the function body (the user
- /// may specify stronger requirements). This field indicates the
- /// region of the callee. If it is `None`, then the parameter
- /// environment is for an item or something where the "callee" is
- /// not clear.
- implicit_region_bound: Option<ty::Region<'tcx>>,
-
body_id: Option<hir::BodyId>,
}
deferred_generator_interiors: RefCell::new(Vec::new()),
opaque_types: RefCell::new(Default::default()),
opaque_types_vars: RefCell::new(Default::default()),
- implicit_region_bound: None,
body_id,
}
}
use rustc_span::symbol::{sym, Ident};
use rustc_span::Span;
use rustc_trait_selection::autoderef::Autoderef;
+use std::slice;
impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// Type-check `*oprnd_expr` with `oprnd_expr` type-checked already.
}
match expr.kind {
- hir::ExprKind::Index(ref base_expr, ref index_expr) => {
- // We need to get the final type in case dereferences were needed for the trait
- // to apply (#72002).
- let index_expr_ty = self.tables.borrow().expr_ty_adjusted(index_expr);
- self.convert_place_op_to_mutable(
- PlaceOp::Index,
- expr,
- base_expr,
- &[index_expr_ty],
- );
+ hir::ExprKind::Index(ref base_expr, ..) => {
+ self.convert_place_op_to_mutable(PlaceOp::Index, expr, base_expr);
}
hir::ExprKind::Unary(hir::UnOp::UnDeref, ref base_expr) => {
- self.convert_place_op_to_mutable(PlaceOp::Deref, expr, base_expr, &[]);
+ self.convert_place_op_to_mutable(PlaceOp::Deref, expr, base_expr);
}
_ => {}
}
op: PlaceOp,
expr: &hir::Expr<'_>,
base_expr: &hir::Expr<'_>,
- arg_tys: &[Ty<'tcx>],
) {
- debug!("convert_place_op_to_mutable({:?}, {:?}, {:?}, {:?})", op, expr, base_expr, arg_tys);
+ debug!("convert_place_op_to_mutable({:?}, {:?}, {:?})", op, expr, base_expr);
if !self.tables.borrow().is_method_call(expr) {
debug!("convert_place_op_to_mutable - builtin, nothing to do");
return;
.expect("place op takes something that is not a ref")
.ty;
+ let arg_ty = match op {
+ PlaceOp::Deref => None,
+ PlaceOp::Index => {
+ // We would need to recover the `T` used when we resolve `<_ as Index<T>>::index`
+ // in try_index_step. This is the subst at index 1.
+ //
+ // Note: we should *not* use `expr_ty` of index_expr here because autoderef
+ // during coercions can cause type of index_expr to differ from `T` (#72002).
+ // We also could not use `expr_ty_adjusted` of index_expr because reborrowing
+ // during coercions can also cause type of index_expr to differ from `T`,
+ // which can potentially cause regionck failure (#74933).
+ Some(self.tables.borrow().node_substs(expr.hir_id).type_at(1))
+ }
+ };
+ let arg_tys = match arg_ty {
+ None => &[],
+ Some(ref ty) => slice::from_ref(ty),
+ };
+
let method = self.try_mutable_overloaded_place_op(expr.span, base_ty, arg_tys, op);
let method = match method {
Some(ok) => self.register_infer_ok_obligations(ok),
fn resolve_regions_and_report_errors(&self, mode: RegionckMode) {
self.infcx.process_registered_region_obligations(
self.outlives_environment.region_bound_pairs_map(),
- self.implicit_region_bound,
+ Some(self.tcx.lifetimes.re_root_empty),
self.param_env,
);
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_middle::util;
use rustc_session::config::EntryFnType;
-use rustc_span::{Span, DUMMY_SP};
+use rustc_span::{symbol::sym, Span, DUMMY_SP};
use rustc_target::spec::abi::Abi;
use rustc_trait_selection::traits::error_reporting::InferCtxtExt as _;
use rustc_trait_selection::traits::{
.emit();
error = true;
}
+
+ for attr in it.attrs {
+ if attr.check_name(sym::track_caller) {
+ tcx.sess
+ .struct_span_err(
+ attr.span,
+ "`main` function is not allowed to be `#[track_caller]`",
+ )
+ .span_label(
+ main_span,
+ "`main` function is not allowed to be `#[track_caller]`",
+ )
+ .emit();
+ error = true;
+ }
+ }
+
if error {
return;
}
tcx.sess,
span,
E0752,
- "start is not allowed to be `async`"
+ "`start` is not allowed to be `async`"
)
- .span_label(span, "start is not allowed to be `async`")
+ .span_label(span, "`start` is not allowed to be `async`")
.emit();
error = true;
}
+
+ for attr in it.attrs {
+ if attr.check_name(sym::track_caller) {
+ tcx.sess
+ .struct_span_err(
+ attr.span,
+ "`start` is not allowed to be `#[track_caller]`",
+ )
+ .span_label(
+ start_span,
+ "`start` is not allowed to be `#[track_caller]`",
+ )
+ .emit();
+ error = true;
+ }
+ }
+
if error {
return;
}
# source tarball for a stable release you'll likely see `1.x.0` for rustc and
# `0.(x+1).0` for Cargo where they were released on `date`.
-date: 2020-07-13
-rustc: 1.45.0
-cargo: 0.46.0
+date: 2020-08-03
+rustc: 1.45.2
+cargo: 0.46.1
# We use a nightly rustfmt to format the source because it solves some
# bootstrapping issues with use of new syntax in this repo. If you're looking at
# looking at a beta source tarball and it's uncommented we'll shortly comment it
# out.
-dev: 1
+#dev: 1
// ...but only if this actually breaks the cycle
impl Tr for bool {
-//~^ ERROR overflow evaluating the requirement
+ //~^ ERROR type mismatch resolving `<bool as Tr>::B == _`
type A = Box<Self::B>;
- //~^ ERROR overflow evaluating the requirement
+ //~^ ERROR type mismatch resolving `<bool as Tr>::B == _`
}
// (the error is shown twice for some reason)
impl Tr for usize {
-//~^ ERROR overflow evaluating the requirement
+ //~^ ERROR type mismatch resolving `<usize as Tr>::B == _`
type B = &'static Self::A;
- //~^ ERROR overflow evaluating the requirement
+ //~^ ERROR type mismatch resolving `<usize as Tr>::A == _`
}
fn main() {
-error[E0275]: overflow evaluating the requirement `<() as Tr>::B`
+error[E0275]: overflow evaluating the requirement `<() as Tr>::B == _`
--> $DIR/defaults-cyclic-fail-1.rs:10:6
|
LL | impl Tr for () {}
| ^^
-error[E0275]: overflow evaluating the requirement `<bool as Tr>::B`
+error[E0271]: type mismatch resolving `<bool as Tr>::B == _`
--> $DIR/defaults-cyclic-fail-1.rs:28:6
|
LL | impl Tr for bool {
- | ^^
+ | ^^ cyclic type of infinite size
-error[E0275]: overflow evaluating the requirement `<usize as Tr>::B`
+error[E0271]: type mismatch resolving `<usize as Tr>::B == _`
--> $DIR/defaults-cyclic-fail-1.rs:35:6
|
LL | impl Tr for usize {
- | ^^
+ | ^^ cyclic type of infinite size
-error[E0275]: overflow evaluating the requirement `<bool as Tr>::B`
+error[E0271]: type mismatch resolving `<bool as Tr>::B == _`
--> $DIR/defaults-cyclic-fail-1.rs:30:5
|
LL | type A = Box<Self::B>;
- | ^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^^^^^^^^ cyclic type of infinite size
-error[E0275]: overflow evaluating the requirement `<usize as Tr>::A`
+error[E0271]: type mismatch resolving `<usize as Tr>::A == _`
--> $DIR/defaults-cyclic-fail-1.rs:37:5
|
LL | type B = &'static Self::A;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ cyclic type of infinite size
error: aborting due to 5 previous errors
-For more information about this error, try `rustc --explain E0275`.
+Some errors have detailed explanations: E0271, E0275.
+For more information about an error, try `rustc --explain E0271`.
// ...but is an error in any impl that doesn't override at least one of the defaults
impl Tr for () {}
-//~^ ERROR overflow evaluating the requirement
+//~^ ERROR type mismatch resolving `<() as Tr>::B == _`
// As soon as at least one is redefined, it works:
impl Tr for u8 {
// ...but only if this actually breaks the cycle
impl Tr for bool {
-//~^ ERROR overflow evaluating the requirement
+ //~^ ERROR type mismatch resolving `<bool as Tr>::B == _`
type A = Box<Self::B>;
- //~^ ERROR overflow evaluating the requirement
+ //~^ ERROR type mismatch resolving `<bool as Tr>::B == _`
}
// (the error is shown twice for some reason)
impl Tr for usize {
-//~^ ERROR overflow evaluating the requirement
+ //~^ ERROR type mismatch resolving `<usize as Tr>::B == _`
type B = &'static Self::A;
- //~^ ERROR overflow evaluating the requirement
+ //~^ ERROR type mismatch resolving `<usize as Tr>::A == _`
}
fn main() {
-error[E0275]: overflow evaluating the requirement `<() as Tr>::B`
+error[E0271]: type mismatch resolving `<() as Tr>::B == _`
--> $DIR/defaults-cyclic-fail-2.rs:12:6
|
LL | impl Tr for () {}
- | ^^
+ | ^^ cyclic type of infinite size
-error[E0275]: overflow evaluating the requirement `<bool as Tr>::B`
+error[E0271]: type mismatch resolving `<bool as Tr>::B == _`
--> $DIR/defaults-cyclic-fail-2.rs:30:6
|
LL | impl Tr for bool {
- | ^^
+ | ^^ cyclic type of infinite size
-error[E0275]: overflow evaluating the requirement `<usize as Tr>::B`
+error[E0271]: type mismatch resolving `<usize as Tr>::B == _`
--> $DIR/defaults-cyclic-fail-2.rs:37:6
|
LL | impl Tr for usize {
- | ^^
+ | ^^ cyclic type of infinite size
-error[E0275]: overflow evaluating the requirement `<bool as Tr>::B`
+error[E0271]: type mismatch resolving `<bool as Tr>::B == _`
--> $DIR/defaults-cyclic-fail-2.rs:32:5
|
LL | type A = Box<Self::B>;
- | ^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^^^^^^^^ cyclic type of infinite size
-error[E0275]: overflow evaluating the requirement `<usize as Tr>::A`
+error[E0271]: type mismatch resolving `<usize as Tr>::A == _`
--> $DIR/defaults-cyclic-fail-2.rs:39:5
|
LL | type B = &'static Self::A;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ cyclic type of infinite size
error: aborting due to 5 previous errors
-For more information about this error, try `rustc --explain E0275`.
+For more information about this error, try `rustc --explain E0271`.
--- /dev/null
+// Case that the fix for #74868 also allowed to compile
+
+// check-pass
+
+trait BoxedDsl {
+ type Output;
+}
+
+impl<T> BoxedDsl for T
+where
+ T: BoxedDsl,
+{
+ type Output = <T as BoxedDsl>::Output;
+}
+
+trait HandleUpdate {}
+
+impl<T> HandleUpdate for T where T: BoxedDsl<Output = ()> {}
+
+fn main() {}
--- /dev/null
+// regression test for #74868
+
+// check-pass
+
+trait BoxedDsl<'a> {
+ type Output;
+}
+
+impl<'a, T> BoxedDsl<'a> for T
+where
+ T: BoxedDsl<'a>,
+{
+ type Output = <T as BoxedDsl<'a>>::Output;
+}
+
+// Showing this trait is wf requires proving
+// Self: HandleUpdate
+//
+// The impl below is a candidate for this projection, as well as the `Self:
+// HandleUpdate` bound in the environment.
+// We evaluate both candidates to see if we need to consider both applicable.
+// Evaluating the impl candidate requires evaluating
+// <T as BoxedDsl<'static>>::Output == ()
+// The above impl cause normalizing the above type normalize to itself.
+//
+// This previously compiled because we would generate a new region
+// variable each time around the cycle, and evaluation would eventually return
+// `EvaluatedToErr` from the `Self: Sized` in the impl, which would in turn
+// leave the bound as the only candidate.
+//
+// #73452 changed this so that region variables are canonicalized when we
+// normalize, which means that the projection cycle is detected before
+// evaluation returns EvaluatedToErr. The cycle resulted in an error being
+// emitted immediately, causing this to fail to compile.
+//
+// To fix this, normalization doesn't directly emit errors when it finds a
+// cycle, instead letting the caller handle it. This restores the original
+// behavior.
+trait HandleUpdate {}
+
+impl<T> HandleUpdate for T where T: BoxedDsl<'static, Output = ()> {}
+
+fn main() {}
#[start]
pub async fn start(_: isize, _: *const *const u8) -> isize {
-//~^ ERROR start is not allowed to be `async`
+//~^ ERROR `start` is not allowed to be `async`
0
}
-error[E0752]: start is not allowed to be `async`
+error[E0752]: `start` is not allowed to be `async`
--> $DIR/issue-68523-start.rs:6:1
|
LL | pub async fn start(_: isize, _: *const *const u8) -> isize {
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ start is not allowed to be `async`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `start` is not allowed to be `async`
error: aborting due to previous error
-//~ ERROR
-
#![feature(optin_builtin_traits)]
#![feature(negative_impls)]
error[E0380]: auto traits cannot have methods or associated items
- --> $DIR/issue-23080-2.rs:7:10
+ --> $DIR/issue-23080-2.rs:5:10
|
LL | unsafe auto trait Trait {
| ----- auto trait cannot have items
LL | type Output;
| ^^^^^^
-error[E0275]: overflow evaluating the requirement `<() as Trait>::Output`
- |
- = note: required because of the requirements on the impl of `Trait` for `()`
- = note: required because of the requirements on the impl of `Trait` for `()`
-
-error: aborting due to 2 previous errors
+error: aborting due to previous error
-Some errors have detailed explanations: E0275, E0380.
-For more information about an error, try `rustc --explain E0275`.
+For more information about this error, try `rustc --explain E0380`.
// check-pass
+// compile-flags: --crate-type lib
+
+#![warn(unconditional_panic)]
+
pub struct Fixed64(i64);
-pub fn div(f: Fixed64) {
- f.0 / 0;
+// HACK: this test passes only because this is a const fn that is written to metadata
+pub const fn div(f: Fixed64) {
+ f.0 / 0; //~ WARN will panic at runtime
}
-
-fn main() {}
--- /dev/null
+warning: this operation will panic at runtime
+ --> $DIR/ice-assert-fail-div-by-zero.rs:11:5
+ |
+LL | f.0 / 0;
+ | ^^^^^^^ attempt to divide _ by zero
+ |
+note: the lint level is defined here
+ --> $DIR/ice-assert-fail-div-by-zero.rs:5:9
+ |
+LL | #![warn(unconditional_panic)]
+ | ^^^^^^^^^^^^^^^^^^^
+
+warning: 1 warning emitted
+
--- /dev/null
+// Regression test for #75118.
+
+use std::ptr::NonNull;
+
+pub const fn dangling_slice<T>() -> NonNull<[T]> {
+ NonNull::<[T; 0]>::dangling()
+ //~^ ERROR: unsizing casts are only allowed for references right now
+}
+
+fn main() {}
--- /dev/null
+error[E0723]: unsizing casts are only allowed for references right now
+ --> $DIR/unsizing-cast-non-null.rs:6:5
+ |
+LL | NonNull::<[T; 0]>::dangling()
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
+ = help: add `#![feature(const_fn)]` to the crate attributes to enable
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0723`.
struct FooStruct;
impl Foo for FooStruct {
-//~^ ERROR overflow evaluating the requirement `<FooStruct as Foo>::A`
+ //~^ ERROR overflow evaluating the requirement `<FooStruct as Foo>::A == _`
type A = <FooStruct as Foo>::A;
- //~^ ERROR overflow evaluating the requirement `<FooStruct as Foo>::A`
+ //~^ ERROR overflow evaluating the requirement `<FooStruct as Foo>::A == _`
}
fn main() {}
-error[E0275]: overflow evaluating the requirement `<FooStruct as Foo>::A`
+error[E0275]: overflow evaluating the requirement `<FooStruct as Foo>::A == _`
--> $DIR/issue-21946.rs:7:6
|
LL | impl Foo for FooStruct {
| ^^^
-error[E0275]: overflow evaluating the requirement `<FooStruct as Foo>::A`
+error[E0275]: overflow evaluating the requirement `<FooStruct as Foo>::A == _`
--> $DIR/issue-21946.rs:9:5
|
LL | type A = <FooStruct as Foo>::A;
-error[E0275]: overflow evaluating the requirement `<GetNext<T> as Next>::Next`
+error[E0275]: overflow evaluating the requirement `<GetNext<T> as Next>::Next == _`
--> $DIR/issue-23122-1.rs:7:15
|
LL | impl<T: Next> Next for GetNext<T> {
| ^^^^
-error[E0275]: overflow evaluating the requirement `<GetNext<T> as Next>::Next`
+error[E0275]: overflow evaluating the requirement `<GetNext<T> as Next>::Next == _`
--> $DIR/issue-23122-1.rs:9:5
|
LL | type Next = <GetNext<T> as Next>::Next;
--- /dev/null
+fn main() {
+ let _ = &&[0] as &[_];
+ //~^ ERROR non-primitive cast: `&&[i32; 1]` as `&[_]`
+ let _ = 7u32 as Option<_>;
+ //~^ ERROR non-primitive cast: `u32` as `std::option::Option<_>`
+}
--- /dev/null
+error[E0605]: non-primitive cast: `&&[i32; 1]` as `&[_]`
+ --> $DIR/issue-73886.rs:2:13
+ |
+LL | let _ = &&[0] as &[_];
+ | ^^^^^^^^^^^^^ an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object
+
+error[E0605]: non-primitive cast: `u32` as `std::option::Option<_>`
+ --> $DIR/issue-73886.rs:4:13
+ |
+LL | let _ = 7u32 as Option<_>;
+ | ^^^^^^^^^^^^^^^^^ an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0605`.
--- /dev/null
+// check-pass
+
+#[repr(transparent)]
+struct NonNullRawComPtr<T: ComInterface> {
+ inner: std::ptr::NonNull<<T as ComInterface>::VTable>,
+}
+
+trait ComInterface {
+ type VTable;
+}
+
+extern "C" fn invoke<T: ComInterface>(_: Option<NonNullRawComPtr<T>>) {}
+
+fn main() {}
//~^ ERROR: uses type `str`
pub extern "C" fn box_type(p: Box<u32>) { }
-//~^ ERROR uses type `std::boxed::Box<u32>`
+
+pub extern "C" fn opt_box_type(p: Option<Box<u32>>) { }
pub extern "C" fn char_type(p: char) { }
//~^ ERROR uses type `char`
//~^ ERROR uses type `fn()`
pub extern "C" fn fn_contained(p: RustBadRet) { }
-//~^ ERROR: uses type `std::boxed::Box<u32>`
pub extern "C" fn transparent_i128(p: TransparentI128) { }
//~^ ERROR: uses type `i128`
//~^ ERROR: uses type `str`
pub extern "C" fn transparent_fn(p: TransparentBadFn) { }
-//~^ ERROR: uses type `std::boxed::Box<u32>`
pub extern "C" fn good3(fptr: Option<extern fn()>) { }
= help: consider using `*const u8` and a length instead
= note: string slices have no C equivalent
-error: `extern` fn uses type `std::boxed::Box<u32>`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:73:31
- |
-LL | pub extern "C" fn box_type(p: Box<u32>) { }
- | ^^^^^^^^ not FFI-safe
- |
- = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
- = note: this struct has unspecified layout
-
error: `extern` fn uses type `char`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:76:32
+ --> $DIR/lint-ctypes-fn.rs:77:32
|
LL | pub extern "C" fn char_type(p: char) { }
| ^^^^ not FFI-safe
= note: the `char` type has no C equivalent
error: `extern` fn uses type `i128`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:79:32
+ --> $DIR/lint-ctypes-fn.rs:80:32
|
LL | pub extern "C" fn i128_type(p: i128) { }
| ^^^^ not FFI-safe
= note: 128-bit integers don't currently have a known stable ABI
error: `extern` fn uses type `u128`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:82:32
+ --> $DIR/lint-ctypes-fn.rs:83:32
|
LL | pub extern "C" fn u128_type(p: u128) { }
| ^^^^ not FFI-safe
= note: 128-bit integers don't currently have a known stable ABI
error: `extern` fn uses type `(i32, i32)`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:85:33
+ --> $DIR/lint-ctypes-fn.rs:86:33
|
LL | pub extern "C" fn tuple_type(p: (i32, i32)) { }
| ^^^^^^^^^^ not FFI-safe
= note: tuples have unspecified layout
error: `extern` fn uses type `(i32, i32)`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:88:34
+ --> $DIR/lint-ctypes-fn.rs:89:34
|
LL | pub extern "C" fn tuple_type2(p: I32Pair) { }
| ^^^^^^^ not FFI-safe
= note: tuples have unspecified layout
error: `extern` fn uses type `ZeroSize`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:91:32
+ --> $DIR/lint-ctypes-fn.rs:92:32
|
LL | pub extern "C" fn zero_size(p: ZeroSize) { }
| ^^^^^^^^ not FFI-safe
| ^^^^^^^^^^^^^^^^^^^^
error: `extern` fn uses type `ZeroSizeWithPhantomData`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:94:40
+ --> $DIR/lint-ctypes-fn.rs:95:40
|
LL | pub extern "C" fn zero_size_phantom(p: ZeroSizeWithPhantomData) { }
| ^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: `extern` fn uses type `std::marker::PhantomData<bool>`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:97:51
+ --> $DIR/lint-ctypes-fn.rs:98:51
|
LL | pub extern "C" fn zero_size_phantom_toplevel() -> PhantomData<bool> {
| ^^^^^^^^^^^^^^^^^ not FFI-safe
= note: composed only of `PhantomData`
error: `extern` fn uses type `fn()`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:102:30
+ --> $DIR/lint-ctypes-fn.rs:103:30
|
LL | pub extern "C" fn fn_type(p: RustFn) { }
| ^^^^^^ not FFI-safe
= note: this function pointer has Rust-specific calling convention
error: `extern` fn uses type `fn()`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:105:31
+ --> $DIR/lint-ctypes-fn.rs:106:31
|
LL | pub extern "C" fn fn_type2(p: fn()) { }
| ^^^^ not FFI-safe
= help: consider using an `extern fn(...) -> ...` function pointer instead
= note: this function pointer has Rust-specific calling convention
-error: `extern` fn uses type `std::boxed::Box<u32>`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:108:35
- |
-LL | pub extern "C" fn fn_contained(p: RustBadRet) { }
- | ^^^^^^^^^^ not FFI-safe
- |
- = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
- = note: this struct has unspecified layout
-
error: `extern` fn uses type `i128`, which is not FFI-safe
--> $DIR/lint-ctypes-fn.rs:111:39
|
= help: consider using `*const u8` and a length instead
= note: string slices have no C equivalent
-error: `extern` fn uses type `std::boxed::Box<u32>`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:117:37
- |
-LL | pub extern "C" fn transparent_fn(p: TransparentBadFn) { }
- | ^^^^^^^^^^^^^^^^ not FFI-safe
- |
- = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
- = note: this struct has unspecified layout
-
error: `extern` fn uses type `std::marker::PhantomData<bool>`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:161:43
+ --> $DIR/lint-ctypes-fn.rs:160:43
|
LL | pub extern "C" fn unused_generic2<T>() -> PhantomData<bool> {
| ^^^^^^^^^^^^^^^^^ not FFI-safe
= note: composed only of `PhantomData`
error: `extern` fn uses type `std::vec::Vec<T>`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:174:39
+ --> $DIR/lint-ctypes-fn.rs:173:39
|
LL | pub extern "C" fn used_generic4<T>(x: Vec<T>) { }
| ^^^^^^ not FFI-safe
= note: this struct has unspecified layout
error: `extern` fn uses type `std::vec::Vec<T>`, which is not FFI-safe
- --> $DIR/lint-ctypes-fn.rs:177:41
+ --> $DIR/lint-ctypes-fn.rs:176:41
|
LL | pub extern "C" fn used_generic5<T>() -> Vec<T> {
| ^^^^^^ not FFI-safe
= help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
= note: this struct has unspecified layout
-error: aborting due to 20 previous errors
+error: aborting due to 17 previous errors
pub fn slice_type(p: &[u32]); //~ ERROR: uses type `[u32]`
pub fn str_type(p: &str); //~ ERROR: uses type `str`
pub fn box_type(p: Box<u32>); //~ ERROR uses type `std::boxed::Box<u32>`
+ pub fn opt_box_type(p: Option<Box<u32>>);
+ //~^ ERROR uses type `std::option::Option<std::boxed::Box<u32>>`
pub fn char_type(p: char); //~ ERROR uses type `char`
pub fn i128_type(p: i128); //~ ERROR uses type `i128`
pub fn u128_type(p: u128); //~ ERROR uses type `u128`
= help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
= note: this struct has unspecified layout
+error: `extern` block uses type `std::option::Option<std::boxed::Box<u32>>`, which is not FFI-safe
+ --> $DIR/lint-ctypes.rs:51:28
+ |
+LL | pub fn opt_box_type(p: Option<Box<u32>>);
+ | ^^^^^^^^^^^^^^^^ not FFI-safe
+ |
+ = help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
+ = note: enum has no representation hint
+
error: `extern` block uses type `char`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:51:25
+ --> $DIR/lint-ctypes.rs:53:25
|
LL | pub fn char_type(p: char);
| ^^^^ not FFI-safe
= note: the `char` type has no C equivalent
error: `extern` block uses type `i128`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:52:25
+ --> $DIR/lint-ctypes.rs:54:25
|
LL | pub fn i128_type(p: i128);
| ^^^^ not FFI-safe
= note: 128-bit integers don't currently have a known stable ABI
error: `extern` block uses type `u128`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:53:25
+ --> $DIR/lint-ctypes.rs:55:25
|
LL | pub fn u128_type(p: u128);
| ^^^^ not FFI-safe
= note: 128-bit integers don't currently have a known stable ABI
error: `extern` block uses type `dyn std::clone::Clone`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:54:26
+ --> $DIR/lint-ctypes.rs:56:26
|
LL | pub fn trait_type(p: &dyn Clone);
| ^^^^^^^^^^ not FFI-safe
= note: trait objects have no C equivalent
error: `extern` block uses type `(i32, i32)`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:55:26
+ --> $DIR/lint-ctypes.rs:57:26
|
LL | pub fn tuple_type(p: (i32, i32));
| ^^^^^^^^^^ not FFI-safe
= note: tuples have unspecified layout
error: `extern` block uses type `(i32, i32)`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:56:27
+ --> $DIR/lint-ctypes.rs:58:27
|
LL | pub fn tuple_type2(p: I32Pair);
| ^^^^^^^ not FFI-safe
= note: tuples have unspecified layout
error: `extern` block uses type `ZeroSize`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:57:25
+ --> $DIR/lint-ctypes.rs:59:25
|
LL | pub fn zero_size(p: ZeroSize);
| ^^^^^^^^ not FFI-safe
| ^^^^^^^^^^^^^^^^^^^^
error: `extern` block uses type `ZeroSizeWithPhantomData`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:58:33
+ --> $DIR/lint-ctypes.rs:60:33
|
LL | pub fn zero_size_phantom(p: ZeroSizeWithPhantomData);
| ^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: `extern` block uses type `std::marker::PhantomData<bool>`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:61:12
+ --> $DIR/lint-ctypes.rs:63:12
|
LL | -> ::std::marker::PhantomData<bool>;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
= note: composed only of `PhantomData`
error: `extern` block uses type `fn()`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:62:23
+ --> $DIR/lint-ctypes.rs:64:23
|
LL | pub fn fn_type(p: RustFn);
| ^^^^^^ not FFI-safe
= note: this function pointer has Rust-specific calling convention
error: `extern` block uses type `fn()`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:63:24
+ --> $DIR/lint-ctypes.rs:65:24
|
LL | pub fn fn_type2(p: fn());
| ^^^^ not FFI-safe
= note: this function pointer has Rust-specific calling convention
error: `extern` block uses type `std::boxed::Box<u32>`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:64:28
+ --> $DIR/lint-ctypes.rs:66:28
|
LL | pub fn fn_contained(p: RustBadRet);
| ^^^^^^^^^^ not FFI-safe
= note: this struct has unspecified layout
error: `extern` block uses type `i128`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:65:32
+ --> $DIR/lint-ctypes.rs:67:32
|
LL | pub fn transparent_i128(p: TransparentI128);
| ^^^^^^^^^^^^^^^ not FFI-safe
= note: 128-bit integers don't currently have a known stable ABI
error: `extern` block uses type `str`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:66:31
+ --> $DIR/lint-ctypes.rs:68:31
|
LL | pub fn transparent_str(p: TransparentStr);
| ^^^^^^^^^^^^^^ not FFI-safe
= note: string slices have no C equivalent
error: `extern` block uses type `std::boxed::Box<u32>`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:67:30
+ --> $DIR/lint-ctypes.rs:69:30
|
LL | pub fn transparent_fn(p: TransparentBadFn);
| ^^^^^^^^^^^^^^^^ not FFI-safe
= note: this struct has unspecified layout
error: `extern` block uses type `[u8; 8]`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:68:27
+ --> $DIR/lint-ctypes.rs:70:27
|
LL | pub fn raw_array(arr: [u8; 8]);
| ^^^^^^^ not FFI-safe
= note: passing raw arrays by value is not FFI-safe
error: `extern` block uses type `u128`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:70:34
+ --> $DIR/lint-ctypes.rs:72:34
|
LL | pub static static_u128_type: u128;
| ^^^^ not FFI-safe
= note: 128-bit integers don't currently have a known stable ABI
error: `extern` block uses type `u128`, which is not FFI-safe
- --> $DIR/lint-ctypes.rs:71:40
+ --> $DIR/lint-ctypes.rs:73:40
|
LL | pub static static_u128_array_type: [u128; 16];
| ^^^^^^^^^^ not FFI-safe
|
= note: 128-bit integers don't currently have a known stable ABI
-error: aborting due to 23 previous errors
+error: aborting due to 24 previous errors
--- /dev/null
+// 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(_) -> _;
+}
--- /dev/null
+// Regression test for #74429, where we didn't think that a type parameter
+// outlived `ReEmpty`.
+
+// check-pass
+
+use std::marker::PhantomData;
+use std::ptr::NonNull;
+
+pub unsafe trait RawData {
+ type Elem;
+}
+
+unsafe impl<A> RawData for OwnedRepr<A> {
+ type Elem = A;
+}
+
+unsafe impl<'a, A> RawData for ViewRepr<&'a A> {
+ type Elem = A;
+}
+
+pub struct OwnedRepr<A> {
+ ptr: PhantomData<A>,
+}
+
+// these Copy impls are not necessary for the repro, but allow the code to compile without error
+// on 1.44.1
+#[derive(Copy, Clone)]
+pub struct ViewRepr<A> {
+ life: PhantomData<A>,
+}
+
+#[derive(Copy, Clone)]
+pub struct ArrayBase<S>
+where
+ S: RawData,
+{
+ ptr: NonNull<S::Elem>,
+}
+
+pub type Array<A> = ArrayBase<OwnedRepr<A>>;
+
+pub type ArrayView<'a, A> = ArrayBase<ViewRepr<&'a A>>;
+
+impl<A, S> ArrayBase<S>
+where
+ S: RawData<Elem = A>,
+{
+ pub fn index_axis(&self) -> ArrayView<'_, A> {
+ unimplemented!()
+ }
+
+ pub fn axis_iter<'a>(&'a self) -> std::iter::Empty<&'a A> {
+ unimplemented!()
+ }
+}
+
+pub fn x<T: Copy>(a: Array<T>) {
+ // drop just avoids a must_use warning
+ drop((0..1).filter(|_| true));
+ let y = a.index_axis();
+ a.axis_iter().for_each(|_| {
+ drop(y);
+ });
+}
+
+fn main() {}
--- /dev/null
+// Regression test for #74429, where we didn't think that a type parameter
+// outlived `ReEmpty`.
+
+// check-pass
+
+use std::marker::PhantomData;
+
+fn apply<T, F: FnOnce(T)>(_: T, _: F) {}
+
+#[derive(Clone, Copy)]
+struct Invariant<T> {
+ t: T,
+ p: PhantomData<fn(T) -> T>,
+}
+
+fn verify_reempty<T>(x: T) {
+ // r is inferred to have type `Invariant<&ReEmpty(U0) T>`
+ let r = Invariant { t: &x, p: PhantomData };
+ // Creates a new universe, all variables from now on are in `U1`, say.
+ let _: fn(&()) = |_| {};
+ // Closure parameter is of type `&ReEmpty(U1) T`, so the closure has an implied
+ // bound of `T: ReEmpty(U1)`
+ apply(&x, |_| {
+ // Requires `typeof(r)` is well-formed, i.e. `T: ReEmpty(U0)`. If we
+ // only have the implied bound from the closure parameter to use this
+ // requires `ReEmpty(U1): ReEmpty(U0)`, which isn't true so we reported
+ // an error.
+ //
+ // This doesn't happen any more because we ensure that `T: ReEmpty(U0)`
+ // is an implicit bound for all type parameters.
+ drop(r);
+ });
+}
+
+fn main() {}
--- /dev/null
+#[track_caller] //~ ERROR `main` function is not allowed to be
+fn main() {
+ panic!("{}: oh no", std::panic::Location::caller());
+}
--- /dev/null
+error: `main` function is not allowed to be `#[track_caller]`
+ --> $DIR/error-with-main.rs:1:1
+ |
+LL | #[track_caller]
+ | ^^^^^^^^^^^^^^^
+LL | / fn main() {
+LL | | panic!("{}: oh no", std::panic::Location::caller());
+LL | | }
+ | |_- `main` function is not allowed to be `#[track_caller]`
+
+error: aborting due to previous error
+
--- /dev/null
+#![feature(start)]
+
+#[start]
+#[track_caller] //~ ERROR `start` is not allowed to be `#[track_caller]`
+fn start(_argc: isize, _argv: *const *const u8) -> isize {
+ panic!("{}: oh no", std::panic::Location::caller());
+}
--- /dev/null
+error: `start` is not allowed to be `#[track_caller]`
+ --> $DIR/error-with-start.rs:4:1
+ |
+LL | #[track_caller]
+ | ^^^^^^^^^^^^^^^
+LL | / fn start(_argc: isize, _argv: *const *const u8) -> isize {
+LL | | panic!("{}: oh no", std::panic::Location::caller());
+LL | | }
+ | |_- `start` is not allowed to be `#[track_caller]`
+
+error: aborting due to previous error
+
--- /dev/null
+// run-pass
+
+trait Tracked {
+ #[track_caller]
+ fn handle(&self) {
+ let location = std::panic::Location::caller();
+ assert_eq!(location.file(), file!());
+ // we only call this via trait object, so the def site should *always* be returned
+ assert_eq!(location.line(), line!() - 4);
+ assert_eq!(location.column(), 5);
+ }
+}
+
+impl Tracked for () {}
+impl Tracked for u8 {}
+
+fn main() {
+ let tracked: &dyn Tracked = &5u8;
+ tracked.handle();
+
+ const TRACKED: &dyn Tracked = &();
+ TRACKED.handle();
+}
--- /dev/null
+// check-pass
+//
+// rust-lang/rust#74933: Lifetime error when indexing with borrowed index
+
+use std::ops::{Index, IndexMut};
+
+struct S(V);
+struct K<'a>(&'a ());
+struct V;
+
+impl<'a> Index<&'a K<'a>> for S {
+ type Output = V;
+
+ fn index(&self, _: &'a K<'a>) -> &V {
+ &self.0
+ }
+}
+
+impl<'a> IndexMut<&'a K<'a>> for S {
+ fn index_mut(&mut self, _: &'a K<'a>) -> &mut V {
+ &mut self.0
+ }
+}
+
+impl V {
+ fn foo(&mut self) {}
+}
+
+fn test(s: &mut S, k: &K<'_>) {
+ s[k] = V;
+ s[k].foo();
+}
+
+fn main() {
+ let mut s = S(V);
+ let k = K(&());
+ test(&mut s, &k);
+}
'reference': {'steveklabnik', 'Havvy', 'matthewjasper', 'ehuss'},
'rust-by-example': {'steveklabnik', 'marioidival'},
'embedded-book': {
- 'adamgreig', 'andre-richter', 'jamesmunns', 'korken89',
- 'ryankurte', 'thejpster', 'therealprof',
+ 'adamgreig', 'andre-richter', 'jamesmunns', 'therealprof',
},
'edition-guide': {'ehuss', 'steveklabnik'},
'rustc-dev-guide': {'mark-i-m', 'spastorino', 'amanjeev', 'JohnTitor'},
-1.46.0-beta.2 (6f959902b 2020-07-23)
\ No newline at end of file
+1.46.0 (04488afe3 2020-08-24)
\ No newline at end of file
projects / rustc.git / commitdiff