mirror of
https://git.proxmox.com/git/rustc
synced 2025-08-03 13:39:05 +00:00
New upstream version 1.46.0+dfsg1
This commit is contained in:
Ximin Luo
parent
f035d41bc1
commit
f96527815a
149
RELEASES.md
149
RELEASES.md
@ -1,3 +1,140 @@
|
||||
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)
|
||||
==========================
|
||||
|
||||
@ -47,7 +184,7 @@ Libraries
|
||||
// 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
|
||||
@ -82,6 +219,9 @@ Stabilized APIs
|
||||
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.
|
||||
@ -97,12 +237,18 @@ Compatibility Notes
|
||||
- [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/
|
||||
@ -129,6 +275,7 @@ Internals Only
|
||||
[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
|
||||
|
||||
@ -1 +1 @@
|
||||
6f959902b3103c49ca981fbc01871589c3498489
|
||||
04488afe34512aa4c33566eb16d8c912a3ae04f9
|
||||
@ -159,11 +159,6 @@ macro_rules! install {
|
||||
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 {
|
||||
@ -210,8 +205,7 @@ install!((self, builder, _config),
|
||||
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(
|
||||
@ -221,27 +215,14 @@ install!((self, builder, _config),
|
||||
};
|
||||
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(
|
||||
@ -253,7 +234,7 @@ install!((self, builder, _config),
|
||||
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(
|
||||
|
||||
@ -10,73 +10,23 @@
|
||||
#####################################
|
||||
|
||||
#
|
||||
# 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.
|
||||
@ -110,115 +60,3 @@ jobs:
|
||||
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
|
||||
|
||||
@ -1,33 +0,0 @@
|
||||
#####################################
|
||||
## 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)
|
||||
@ -1,35 +0,0 @@
|
||||
#####################################
|
||||
## 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
|
||||
@ -13,70 +13,10 @@ pr: none
|
||||
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"
|
||||
|
||||
@ -7,7 +7,7 @@ target="x86_64-fortanix-unknown-sgx"
|
||||
|
||||
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 \
|
||||
|
||||
@ -35,11 +35,26 @@ x--expand-yaml-anchors--remove:
|
||||
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
|
||||
@ -92,6 +107,15 @@ x--expand-yaml-anchors--remove:
|
||||
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:
|
||||
@ -550,7 +574,7 @@ jobs:
|
||||
<<: *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:
|
||||
|
||||
@ -51,7 +51,7 @@ fi
|
||||
#
|
||||
# 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
|
||||
|
||||
@ -1598,7 +1598,9 @@ fn linker_with_args<'a, B: ArchiveBuilder<'a>>(
|
||||
}
|
||||
|
||||
// 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 {
|
||||
|
||||
@ -619,13 +619,7 @@ impl<'a> Linker for GccLinker<'a> {
|
||||
// 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");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -2051,7 +2051,7 @@ impl<'tcx> LateLintPass<'tcx> for InvalidValue {
|
||||
|
||||
declare_lint! {
|
||||
pub CLASHING_EXTERN_DECLARATIONS,
|
||||
Warn,
|
||||
Allow,
|
||||
"detects when an extern fn has been declared with the same name but different types"
|
||||
}
|
||||
|
||||
|
||||
@ -531,23 +531,28 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
|
||||
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));
|
||||
|
||||
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;
|
||||
if guaranteed_nonnull_optimization {
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -558,7 +563,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
|
||||
}
|
||||
|
||||
/// 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,
|
||||
@ -692,6 +697,12 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
|
||||
}
|
||||
|
||||
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);
|
||||
|
||||
@ -375,7 +375,7 @@ impl<'tcx> Instance<'tcx> {
|
||||
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)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -484,7 +484,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
|
||||
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| {
|
||||
@ -1004,11 +1004,27 @@ impl<'mir, 'tcx> MutVisitor<'tcx> for ConstPropagator<'mir, 'tcx> {
|
||||
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) => {
|
||||
|
||||
@ -193,7 +193,15 @@ fn check_rvalue(
|
||||
_,
|
||||
) => 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)?;
|
||||
|
||||
30
src/librustc_target/spec/aarch64_apple_darwin.rs
Normal file
30
src/librustc_target/spec/aarch64_apple_darwin.rs
Normal file
@ -0,0 +1,30 @@
|
||||
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 },
|
||||
})
|
||||
}
|
||||
@ -31,6 +31,7 @@ pub fn opts() -> TargetOptions {
|
||||
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
|
||||
|
||||
@ -25,6 +25,7 @@ pub fn opts() -> TargetOptions {
|
||||
has_rpath: false,
|
||||
pre_link_args: args,
|
||||
position_independent_executables: false,
|
||||
eh_frame_header: false,
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
@ -23,6 +23,7 @@ pub fn opts() -> TargetOptions {
|
||||
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
|
||||
|
||||
@ -574,6 +574,7 @@ supported_targets! {
|
||||
("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),
|
||||
|
||||
@ -989,6 +990,11 @@ pub struct TargetOptions {
|
||||
/// 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 {
|
||||
@ -1081,6 +1087,7 @@ impl Default for TargetOptions {
|
||||
relax_elf_relocations: false,
|
||||
llvm_args: vec![],
|
||||
use_ctors_section: false,
|
||||
eh_frame_header: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1474,6 +1481,7 @@ impl Target {
|
||||
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.
|
||||
@ -1712,6 +1720,7 @@ impl ToJson for Target {
|
||||
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(
|
||||
|
||||
@ -56,6 +56,8 @@ pub fn target() -> TargetResult {
|
||||
// See the thumb_base.rs file for an explanation of this value
|
||||
emit_debug_gdb_scripts: false,
|
||||
|
||||
eh_frame_header: false,
|
||||
|
||||
..Default::default()
|
||||
},
|
||||
})
|
||||
|
||||
@ -25,6 +25,7 @@ pub fn target() -> TargetResult {
|
||||
relocation_model: RelocModel::Static,
|
||||
emit_debug_gdb_scripts: false,
|
||||
unsupported_abis: super::riscv_base::unsupported_abis(),
|
||||
eh_frame_header: false,
|
||||
..Default::default()
|
||||
},
|
||||
})
|
||||
|
||||
@ -25,6 +25,7 @@ pub fn target() -> TargetResult {
|
||||
relocation_model: RelocModel::Static,
|
||||
emit_debug_gdb_scripts: false,
|
||||
unsupported_abis: super::riscv_base::unsupported_abis(),
|
||||
eh_frame_header: false,
|
||||
..Default::default()
|
||||
},
|
||||
})
|
||||
|
||||
@ -25,6 +25,7 @@ pub fn target() -> TargetResult {
|
||||
relocation_model: RelocModel::Static,
|
||||
emit_debug_gdb_scripts: false,
|
||||
unsupported_abis: super::riscv_base::unsupported_abis(),
|
||||
eh_frame_header: false,
|
||||
..Default::default()
|
||||
},
|
||||
})
|
||||
|
||||
@ -26,6 +26,7 @@ pub fn target() -> TargetResult {
|
||||
code_model: Some(CodeModel::Medium),
|
||||
emit_debug_gdb_scripts: false,
|
||||
unsupported_abis: super::riscv_base::unsupported_abis(),
|
||||
eh_frame_header: false,
|
||||
..Default::default()
|
||||
},
|
||||
})
|
||||
|
||||
@ -26,6 +26,7 @@ pub fn target() -> TargetResult {
|
||||
code_model: Some(CodeModel::Medium),
|
||||
emit_debug_gdb_scripts: false,
|
||||
unsupported_abis: super::riscv_base::unsupported_abis(),
|
||||
eh_frame_header: false,
|
||||
..Default::default()
|
||||
},
|
||||
})
|
||||
|
||||
@ -8,6 +8,7 @@ pub fn opts() -> TargetOptions {
|
||||
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()
|
||||
}
|
||||
|
||||
@ -91,6 +91,7 @@ pub fn opts() -> TargetOptions {
|
||||
abi_return_struct_as_int: true,
|
||||
emit_debug_gdb_scripts: false,
|
||||
requires_uwtable: true,
|
||||
eh_frame_header: false,
|
||||
|
||||
..Default::default()
|
||||
}
|
||||
|
||||
@ -5,7 +5,10 @@ pub fn target() -> TargetResult {
|
||||
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;
|
||||
|
||||
|
||||
@ -729,7 +729,7 @@ impl AutoTraitFinder<'tcx> {
|
||||
// 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 \
|
||||
@ -738,7 +738,11 @@ impl AutoTraitFinder<'tcx> {
|
||||
);
|
||||
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
|
||||
@ -757,8 +761,8 @@ impl AutoTraitFinder<'tcx> {
|
||||
}
|
||||
}
|
||||
}
|
||||
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).
|
||||
|
||||
@ -426,14 +426,20 @@ impl<'a, 'b, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'tcx> {
|
||||
|
||||
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)),
|
||||
}
|
||||
}
|
||||
|
||||
@ -51,9 +51,7 @@ pub use self::object_safety::is_vtable_safe_method;
|
||||
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;
|
||||
|
||||
@ -40,6 +40,8 @@ pub type ProjectionObligation<'tcx> = Obligation<'tcx, ty::ProjectionPredicate<'
|
||||
|
||||
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> {
|
||||
@ -142,10 +144,26 @@ impl<'tcx> ProjectionTyCandidateSet<'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();
|
||||
@ -164,10 +182,15 @@ pub fn poly_project_and_unify_type<'cx, 'tcx>(
|
||||
/// <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![];
|
||||
@ -179,8 +202,9 @@ fn project_and_unify_type<'cx, 'tcx>(
|
||||
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!(
|
||||
@ -195,7 +219,7 @@ fn project_and_unify_type<'cx, 'tcx>(
|
||||
{
|
||||
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);
|
||||
@ -323,8 +347,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,
|
||||
@ -352,9 +375,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
|
||||
@ -421,6 +442,8 @@ pub fn normalize_projection_type<'a, 'b, 'tcx>(
|
||||
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
|
||||
@ -457,7 +480,7 @@ fn opt_normalize_projection_type<'a, 'b, 'tcx>(
|
||||
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);
|
||||
@ -489,7 +512,7 @@ fn opt_normalize_projection_type<'a, 'b, 'tcx>(
|
||||
"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
|
||||
@ -504,24 +527,14 @@ fn opt_normalize_projection_type<'a, 'b, 'tcx>(
|
||||
// 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.
|
||||
@ -557,7 +570,7 @@ fn opt_normalize_projection_type<'a, 'b, 'tcx>(
|
||||
cause,
|
||||
depth,
|
||||
));
|
||||
return Some(ty.value);
|
||||
return Ok(Some(ty.value));
|
||||
}
|
||||
Err(ProjectionCacheEntry::Error) => {
|
||||
debug!(
|
||||
@ -566,7 +579,7 @@ fn opt_normalize_projection_type<'a, 'b, 'tcx>(
|
||||
);
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
@ -613,7 +626,7 @@ fn opt_normalize_projection_type<'a, 'b, 'tcx>(
|
||||
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!(
|
||||
@ -624,7 +637,7 @@ fn opt_normalize_projection_type<'a, 'b, 'tcx>(
|
||||
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!(
|
||||
@ -632,7 +645,7 @@ fn opt_normalize_projection_type<'a, 'b, 'tcx>(
|
||||
too many candidates"
|
||||
);
|
||||
infcx.inner.borrow_mut().projection_cache().ambiguous(cache_key);
|
||||
None
|
||||
Ok(None)
|
||||
}
|
||||
Err(ProjectionTyError::TraitSelectionError(_)) => {
|
||||
debug!("opt_normalize_projection_type: ERROR");
|
||||
@ -644,7 +657,7 @@ fn opt_normalize_projection_type<'a, 'b, 'tcx>(
|
||||
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))
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1115,11 +1128,11 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
|
||||
}
|
||||
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(());
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
@ -458,7 +458,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
|
||||
&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,
|
||||
@ -471,7 +471,13 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
|
||||
}
|
||||
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),
|
||||
}
|
||||
}
|
||||
|
||||
@ -387,6 +387,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
|
||||
// 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,
|
||||
|
||||
@ -252,14 +252,6 @@ pub struct Inherited<'a, 'tcx> {
|
||||
/// 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>,
|
||||
}
|
||||
|
||||
@ -678,7 +670,6 @@ impl Inherited<'a, 'tcx> {
|
||||
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,
|
||||
}
|
||||
}
|
||||
|
||||
@ -9,6 +9,7 @@ use rustc_middle::ty::{self, Ty};
|
||||
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.
|
||||
@ -245,19 +246,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
@ -269,9 +262,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
||||
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;
|
||||
@ -286,6 +278,25 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
||||
.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),
|
||||
|
||||
@ -308,7 +308,7 @@ impl<'a, 'tcx> RegionCtxt<'a, 'tcx> {
|
||||
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,
|
||||
);
|
||||
|
||||
|
||||
@ -100,7 +100,7 @@ use rustc_middle::ty::query::Providers;
|
||||
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::{
|
||||
@ -194,6 +194,23 @@ fn check_main_fn_ty(tcx: TyCtxt<'_>, main_def_id: LocalDefId) {
|
||||
.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;
|
||||
}
|
||||
@ -268,12 +285,29 @@ fn check_start_fn_ty(tcx: TyCtxt<'_>, start_def_id: LocalDefId) {
|
||||
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;
|
||||
}
|
||||
|
||||
@ -12,9 +12,9 @@
|
||||
# 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
|
||||
@ -40,4 +40,4 @@ cargo: 0.46.0
|
||||
# looking at a beta source tarball and it's uncommented we'll shortly comment it
|
||||
# out.
|
||||
|
||||
dev: 1
|
||||
#dev: 1
|
||||
|
||||
@ -26,16 +26,16 @@ impl Tr for u32 {
|
||||
|
||||
// ...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() {
|
||||
|
||||
@ -1,33 +1,34 @@
|
||||
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`.
|
||||
|
||||
@ -10,7 +10,7 @@ trait Tr {
|
||||
|
||||
// ...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 {
|
||||
@ -28,16 +28,16 @@ impl Tr for u32 {
|
||||
|
||||
// ...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() {
|
||||
|
||||
@ -1,33 +1,33 @@
|
||||
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`.
|
||||
|
||||
@ -0,0 +1,20 @@
|
||||
// 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() {}
|
||||
43
src/test/ui/associated-types/normalize-cycle-in-eval.rs
Normal file
43
src/test/ui/associated-types/normalize-cycle-in-eval.rs
Normal file
@ -0,0 +1,43 @@
|
||||
// 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() {}
|
||||
@ -4,6 +4,6 @@
|
||||
|
||||
#[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
|
||||
}
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
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
|
||||
|
||||
|
||||
@ -1,5 +1,3 @@
|
||||
//~ ERROR
|
||||
|
||||
#![feature(optin_builtin_traits)]
|
||||
#![feature(negative_impls)]
|
||||
|
||||
|
||||
@ -1,17 +1,11 @@
|
||||
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 previous error
|
||||
|
||||
error: aborting due to 2 previous errors
|
||||
|
||||
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`.
|
||||
|
||||
@ -1,9 +1,12 @@
|
||||
// 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() {}
|
||||
|
||||
14
src/test/ui/const_prop/ice-assert-fail-div-by-zero.stderr
Normal file
14
src/test/ui/const_prop/ice-assert-fail-div-by-zero.stderr
Normal file
@ -0,0 +1,14 @@
|
||||
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
|
||||
|
||||
10
src/test/ui/consts/unsizing-cast-non-null.rs
Normal file
10
src/test/ui/consts/unsizing-cast-non-null.rs
Normal file
@ -0,0 +1,10 @@
|
||||
// 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() {}
|
||||
12
src/test/ui/consts/unsizing-cast-non-null.stderr
Normal file
12
src/test/ui/consts/unsizing-cast-non-null.stderr
Normal file
@ -0,0 +1,12 @@
|
||||
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`.
|
||||
@ -5,9 +5,9 @@ trait Foo {
|
||||
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() {}
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
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;
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
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;
|
||||
|
||||
6
src/test/ui/issues/issue-73886.rs
Normal file
6
src/test/ui/issues/issue-73886.rs
Normal file
@ -0,0 +1,6 @@
|
||||
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<_>`
|
||||
}
|
||||
15
src/test/ui/issues/issue-73886.stderr
Normal file
15
src/test/ui/issues/issue-73886.stderr
Normal file
@ -0,0 +1,15 @@
|
||||
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`.
|
||||
14
src/test/ui/lint/lint-ctypes-73747.rs
Normal file
14
src/test/ui/lint/lint-ctypes-73747.rs
Normal file
@ -0,0 +1,14 @@
|
||||
// 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() {}
|
||||
@ -71,7 +71,8 @@ pub extern "C" fn str_type(p: &str) { }
|
||||
//~^ 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`
|
||||
@ -106,7 +107,6 @@ pub extern "C" fn fn_type2(p: fn()) { }
|
||||
//~^ 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`
|
||||
@ -115,7 +115,6 @@ pub extern "C" fn transparent_str(p: TransparentStr) { }
|
||||
//~^ 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()>) { }
|
||||
|
||||
|
||||
@ -21,17 +21,8 @@ LL | pub extern "C" fn str_type(p: &str) { }
|
||||
= 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
|
||||
@ -40,7 +31,7 @@ LL | pub extern "C" fn char_type(p: char) { }
|
||||
= 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
|
||||
@ -48,7 +39,7 @@ LL | pub extern "C" fn i128_type(p: i128) { }
|
||||
= 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
|
||||
@ -56,7 +47,7 @@ LL | pub extern "C" fn u128_type(p: u128) { }
|
||||
= 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
|
||||
@ -65,7 +56,7 @@ LL | pub extern "C" fn tuple_type(p: (i32, i32)) { }
|
||||
= 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
|
||||
@ -74,7 +65,7 @@ LL | pub extern "C" fn tuple_type2(p: I32Pair) { }
|
||||
= 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
|
||||
@ -88,7 +79,7 @@ LL | pub struct ZeroSize;
|
||||
| ^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
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
|
||||
@ -101,7 +92,7 @@ LL | pub struct ZeroSizeWithPhantomData(PhantomData<i32>);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
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
|
||||
@ -109,7 +100,7 @@ LL | pub extern "C" fn zero_size_phantom_toplevel() -> PhantomData<bool> {
|
||||
= 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
|
||||
@ -118,7 +109,7 @@ LL | pub extern "C" fn fn_type(p: RustFn) { }
|
||||
= 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
|
||||
@ -126,15 +117,6 @@ LL | pub extern "C" fn fn_type2(p: fn()) { }
|
||||
= 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
|
||||
|
|
||||
@ -152,17 +134,8 @@ LL | pub extern "C" fn transparent_str(p: TransparentStr) { }
|
||||
= 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
|
||||
@ -170,7 +143,7 @@ LL | pub extern "C" fn unused_generic2<T>() -> PhantomData<bool> {
|
||||
= 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
|
||||
@ -179,7 +152,7 @@ LL | pub extern "C" fn used_generic4<T>(x: Vec<T>) { }
|
||||
= 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
|
||||
@ -187,5 +160,5 @@ LL | pub extern "C" fn used_generic5<T>() -> Vec<T> {
|
||||
= 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
|
||||
|
||||
|
||||
@ -48,6 +48,8 @@ extern {
|
||||
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`
|
||||
|
||||
@ -58,8 +58,17 @@ LL | pub fn box_type(p: Box<u32>);
|
||||
= 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
|
||||
@ -68,7 +77,7 @@ LL | pub fn char_type(p: char);
|
||||
= 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
|
||||
@ -76,7 +85,7 @@ LL | pub fn i128_type(p: i128);
|
||||
= 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
|
||||
@ -84,7 +93,7 @@ LL | pub fn u128_type(p: u128);
|
||||
= 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
|
||||
@ -92,7 +101,7 @@ LL | pub fn trait_type(p: &dyn Clone);
|
||||
= 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
|
||||
@ -101,7 +110,7 @@ LL | pub fn tuple_type(p: (i32, i32));
|
||||
= 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
|
||||
@ -110,7 +119,7 @@ LL | pub fn tuple_type2(p: I32Pair);
|
||||
= 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
|
||||
@ -124,7 +133,7 @@ LL | pub struct ZeroSize;
|
||||
| ^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
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
|
||||
@ -137,7 +146,7 @@ LL | pub struct ZeroSizeWithPhantomData(::std::marker::PhantomData<i32>);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
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
|
||||
@ -145,7 +154,7 @@ LL | -> ::std::marker::PhantomData<bool>;
|
||||
= 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
|
||||
@ -154,7 +163,7 @@ LL | pub fn fn_type(p: RustFn);
|
||||
= 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
|
||||
@ -163,7 +172,7 @@ LL | pub fn fn_type2(p: fn());
|
||||
= 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
|
||||
@ -172,7 +181,7 @@ LL | pub fn fn_contained(p: RustBadRet);
|
||||
= 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
|
||||
@ -180,7 +189,7 @@ LL | pub fn transparent_i128(p: TransparentI128);
|
||||
= 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
|
||||
@ -189,7 +198,7 @@ LL | pub fn transparent_str(p: TransparentStr);
|
||||
= 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
|
||||
@ -198,7 +207,7 @@ LL | pub fn transparent_fn(p: TransparentBadFn);
|
||||
= 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
|
||||
@ -207,7 +216,7 @@ LL | pub fn raw_array(arr: [u8; 8]);
|
||||
= 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
|
||||
@ -215,12 +224,12 @@ LL | pub static static_u128_type: u128;
|
||||
= 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
|
||||
|
||||
|
||||
13
src/test/ui/mir/issue-75419-validation-impl-trait.rs
Normal file
13
src/test/ui/mir/issue-75419-validation-impl-trait.rs
Normal file
@ -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(_) -> _;
|
||||
}
|
||||
@ -0,0 +1,66 @@
|
||||
// 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() {}
|
||||
@ -0,0 +1,35 @@
|
||||
// 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() {}
|
||||
4
src/test/ui/rfc-2091-track-caller/error-with-main.rs
Normal file
4
src/test/ui/rfc-2091-track-caller/error-with-main.rs
Normal file
@ -0,0 +1,4 @@
|
||||
#[track_caller] //~ ERROR `main` function is not allowed to be
|
||||
fn main() {
|
||||
panic!("{}: oh no", std::panic::Location::caller());
|
||||
}
|
||||
12
src/test/ui/rfc-2091-track-caller/error-with-main.stderr
Normal file
12
src/test/ui/rfc-2091-track-caller/error-with-main.stderr
Normal file
@ -0,0 +1,12 @@
|
||||
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
|
||||
|
||||
7
src/test/ui/rfc-2091-track-caller/error-with-start.rs
Normal file
7
src/test/ui/rfc-2091-track-caller/error-with-start.rs
Normal file
@ -0,0 +1,7 @@
|
||||
#![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());
|
||||
}
|
||||
12
src/test/ui/rfc-2091-track-caller/error-with-start.stderr
Normal file
12
src/test/ui/rfc-2091-track-caller/error-with-start.stderr
Normal file
@ -0,0 +1,12 @@
|
||||
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
|
||||
|
||||
23
src/test/ui/rfc-2091-track-caller/tracked-trait-obj.rs
Normal file
23
src/test/ui/rfc-2091-track-caller/tracked-trait-obj.rs
Normal file
@ -0,0 +1,23 @@
|
||||
// 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();
|
||||
}
|
||||
38
src/test/ui/typeck/issue-74933.rs
Normal file
38
src/test/ui/typeck/issue-74933.rs
Normal file
@ -0,0 +1,38 @@
|
||||
// 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);
|
||||
}
|
||||
@ -32,8 +32,7 @@ MAINTAINERS = {
|
||||
'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'},
|
||||
|
||||
Loading…
Reference in New Issue
Block a user