mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rollup merge of #122343 - compiler-errors:rando, r=fmease

Browse Source 
Remove some unnecessary `allow(incomplete_features)` in the test suite

A useless change, but I like things to be clean.
This commit is contained in:
Matthias Krüger 2024-03-12 06:29:05 +01:00 committed by GitHub
commit 39e00760ec
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
62 changed files with 261 additions and 323 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests/ui/async-await/in-trait/early-bound-2.rs
View File

@ -1,8 +1,6 @@
//@ check-pass //@ check-pass
//@ edition:2021 //@ edition:2021
#![allow(incomplete_features)]
pub trait Foo { pub trait Foo {
#[allow(async_fn_in_trait)] #[allow(async_fn_in_trait)]
async fn foo(&mut self); async fn foo(&mut self);

2
tests/ui/async-await/in-trait/fn-not-async-err.rs
View File

@ -1,7 +1,5 @@
//@ edition: 2021 //@ edition: 2021
#![allow(incomplete_features)]
trait MyTrait { trait MyTrait {
async fn foo(&self) -> i32; async fn foo(&self) -> i32;
} }

4
tests/ui/async-await/in-trait/fn-not-async-err.stderr
View File

@ -1,11 +1,11 @@
error: method should be `async` or return a future, but it is synchronous error: method should be `async` or return a future, but it is synchronous
--> $DIR/fn-not-async-err.rs:10:5 --> $DIR/fn-not-async-err.rs:8:5
| |
LL | fn foo(&self) -> i32 { LL | fn foo(&self) -> i32 {
| ^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^
| |
note: this method is `async` so it expects a future to be returned note: this method is `async` so it expects a future to be returned
--> $DIR/fn-not-async-err.rs:6:5 --> $DIR/fn-not-async-err.rs:4:5
| |
LL | async fn foo(&self) -> i32; LL | async fn foo(&self) -> i32;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^

2
tests/ui/async-await/in-trait/fn-not-async-err2.rs
View File

@ -1,8 +1,6 @@
//@ edition: 2021 //@ edition: 2021
//@ check-pass //@ check-pass
#![allow(incomplete_features)]
use std::future::Future; use std::future::Future;
trait MyTrait { trait MyTrait {

2
tests/ui/async-await/in-trait/generics-mismatch.rs
View File

@ -1,7 +1,5 @@
//@ edition: 2021 //@ edition: 2021
#![allow(incomplete_features)]
trait Foo { trait Foo {
async fn foo<T>(); async fn foo<T>();
} }

2
tests/ui/async-await/in-trait/generics-mismatch.stderr
View File

@ -1,5 +1,5 @@
error[E0053]: method `foo` has an incompatible generic parameter for trait `Foo` error[E0053]: method `foo` has an incompatible generic parameter for trait `Foo`
--> $DIR/generics-mismatch.rs:10:18 --> $DIR/generics-mismatch.rs:8:18
| |
LL | trait Foo { LL | trait Foo {
| --- | ---

2
tests/ui/async-await/in-trait/implied-bounds.rs
View File

@ -1,8 +1,6 @@
//@ check-pass //@ check-pass
//@ edition: 2021 //@ edition: 2021
#![allow(incomplete_features)]
trait TcpStack { trait TcpStack {
type Connection<'a>: Sized where Self: 'a; type Connection<'a>: Sized where Self: 'a;
fn connect<'a>(&'a self) -> Self::Connection<'a>; fn connect<'a>(&'a self) -> Self::Connection<'a>;

2
tests/ui/async-await/in-trait/issue-102138.rs
View File

@ -1,8 +1,6 @@
//@ check-pass //@ check-pass
//@ edition:2021 //@ edition:2021
#![allow(incomplete_features)]
use std::future::Future; use std::future::Future;
async fn yield_now() {} async fn yield_now() {}

2
tests/ui/async-await/in-trait/issue-102219.rs
View File

@ -2,8 +2,6 @@
//@ edition:2021 //@ edition:2021
//@ check-pass //@ check-pass
#![allow(incomplete_features)]
trait T { trait T {
#[allow(async_fn_in_trait)] #[allow(async_fn_in_trait)]
async fn foo(); async fn foo();

2
tests/ui/async-await/in-trait/issue-102310.rs
View File

@ -1,8 +1,6 @@
//@ check-pass //@ check-pass
//@ edition:2021 //@ edition:2021
#![allow(incomplete_features)]
pub trait SpiDevice { pub trait SpiDevice {
#[allow(async_fn_in_trait)] #[allow(async_fn_in_trait)]
async fn transaction<F, R>(&mut self); async fn transaction<F, R>(&mut self);

2
tests/ui/async-await/in-trait/issue-104678.rs
View File

@ -1,8 +1,6 @@
//@ edition:2021 //@ edition:2021
//@ check-pass //@ check-pass
#![allow(incomplete_features)]
use std::future::Future; use std::future::Future;
pub trait Pool { pub trait Pool {
type Conn; type Conn;

2
tests/ui/async-await/in-trait/nested-rpit.rs
View File

@ -1,8 +1,6 @@
//@ edition: 2021 //@ edition: 2021
//@ check-pass //@ check-pass
#![allow(incomplete_features)]
use std::future::Future; use std::future::Future;
use std::marker::PhantomData; use std::marker::PhantomData;

1
tests/ui/const-generics/auxiliary/generics_of_parent.rs
View File

@ -1,5 +1,4 @@
#![feature(generic_const_exprs)] #![feature(generic_const_exprs)]
#![allow(incomplete_features)]
// library portion of regression test for #87674 // library portion of regression test for #87674
pub struct Foo<const N: usize>([(); N + 1]) pub struct Foo<const N: usize>([(); N + 1])

1
tests/ui/const-generics/auxiliary/generics_of_parent_impl_trait.rs
View File

@ -1,5 +1,4 @@
#![feature(generic_const_exprs)] #![feature(generic_const_exprs)]
#![allow(incomplete_features)]
// library portion of testing that `impl Trait<{ expr }>` doesnt // library portion of testing that `impl Trait<{ expr }>` doesnt
// ice because of a `DefKind::TyParam` parent // ice because of a `DefKind::TyParam` parent

1
tests/ui/const-generics/generic_const_exprs/auxiliary/anon_const_non_local.rs
View File

@ -1,5 +1,4 @@
#![feature(generic_const_exprs)] #![feature(generic_const_exprs)]
#![allow(incomplete_features)]
pub struct Foo<const N: usize>; pub struct Foo<const N: usize>;

1
tests/ui/const-generics/generic_const_exprs/auxiliary/const_evaluatable_lib.rs
View File

@ -1,5 +1,4 @@
#![feature(generic_const_exprs)] #![feature(generic_const_exprs)]
#![allow(incomplete_features)]
pub fn test1<T>() -> [u8; std::mem::size_of::<T>() - 1] pub fn test1<T>() -> [u8; std::mem::size_of::<T>() - 1]
where where

8
tests/ui/const-generics/generic_const_exprs/cross_crate_predicate.stderr
View File

@ -6,7 +6,7 @@ LL | let _ = const_evaluatable_lib::test1::<T>();
| |
= help: try adding a `where` bound using this expression: `where [(); std::mem::size_of::<T>() - 1]:` = help: try adding a `where` bound using this expression: `where [(); std::mem::size_of::<T>() - 1]:`
note: required by a bound in `test1` note: required by a bound in `test1`
--> $DIR/auxiliary/const_evaluatable_lib.rs:6:10 --> $DIR/auxiliary/const_evaluatable_lib.rs:5:10
| |
LL | pub fn test1<T>() -> [u8; std::mem::size_of::<T>() - 1] LL | pub fn test1<T>() -> [u8; std::mem::size_of::<T>() - 1]
| ----- required by a bound in this function | ----- required by a bound in this function
@ -22,7 +22,7 @@ LL | let _ = const_evaluatable_lib::test1::<T>();
| |
= help: try adding a `where` bound using this expression: `where [(); std::mem::size_of::<T>() - 1]:` = help: try adding a `where` bound using this expression: `where [(); std::mem::size_of::<T>() - 1]:`
note: required by a bound in `test1` note: required by a bound in `test1`
--> $DIR/auxiliary/const_evaluatable_lib.rs:4:27 --> $DIR/auxiliary/const_evaluatable_lib.rs:3:27
| |
LL | pub fn test1<T>() -> [u8; std::mem::size_of::<T>() - 1] LL | pub fn test1<T>() -> [u8; std::mem::size_of::<T>() - 1]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `test1` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `test1`
@ -35,7 +35,7 @@ LL | let _ = const_evaluatable_lib::test1::<T>();
| |
= help: try adding a `where` bound using this expression: `where [(); std::mem::size_of::<T>() - 1]:` = help: try adding a `where` bound using this expression: `where [(); std::mem::size_of::<T>() - 1]:`
note: required by a bound in `test1` note: required by a bound in `test1`
--> $DIR/auxiliary/const_evaluatable_lib.rs:6:10 --> $DIR/auxiliary/const_evaluatable_lib.rs:5:10
| |
LL | pub fn test1<T>() -> [u8; std::mem::size_of::<T>() - 1] LL | pub fn test1<T>() -> [u8; std::mem::size_of::<T>() - 1]
| ----- required by a bound in this function | ----- required by a bound in this function
@ -51,7 +51,7 @@ LL | let _ = const_evaluatable_lib::test1::<T>();
| |
= help: try adding a `where` bound using this expression: `where [(); std::mem::size_of::<T>() - 1]:` = help: try adding a `where` bound using this expression: `where [(); std::mem::size_of::<T>() - 1]:`
note: required by a bound in `test1` note: required by a bound in `test1`
--> $DIR/auxiliary/const_evaluatable_lib.rs:4:27 --> $DIR/auxiliary/const_evaluatable_lib.rs:3:27
| |
LL | pub fn test1<T>() -> [u8; std::mem::size_of::<T>() - 1] LL | pub fn test1<T>() -> [u8; std::mem::size_of::<T>() - 1]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `test1` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `test1`

1
tests/ui/const-generics/issues/auxiliary/const_generic_issues_lib.rs
View File

@ -1,5 +1,4 @@
#![feature(generic_const_exprs)] #![feature(generic_const_exprs)]
#![allow(incomplete_features)]
// All of these three items must be in `lib2` to reproduce the error // All of these three items must be in `lib2` to reproduce the error

2
tests/ui/const-generics/parent_generics_of_encoding_impl_trait.stderr
View File

@ -5,7 +5,7 @@ LL | generics_of_parent_impl_trait::foo([()]);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer the value of const parameter `N` declared on the function `foo` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer the value of const parameter `N` declared on the function `foo`
| |
note: required by a bound in `foo` note: required by a bound in `foo`
--> $DIR/auxiliary/generics_of_parent_impl_trait.rs:6:48 --> $DIR/auxiliary/generics_of_parent_impl_trait.rs:5:48
| |
LL | pub fn foo<const N: usize>(foo: impl Into<[(); N + 1]>) { LL | pub fn foo<const N: usize>(foo: impl Into<[(); N + 1]>) {
| ^^^^^ required by this bound in `foo` | ^^^^^ required by this bound in `foo`

1
tests/ui/consts/auxiliary/closure-in-foreign-crate.rs
View File

@ -1,6 +1,5 @@
#![crate_type = "lib"] #![crate_type = "lib"]
#![feature(const_closures, const_trait_impl, effects)] #![feature(const_closures, const_trait_impl, effects)]
#![allow(incomplete_features)]
pub const fn test() { pub const fn test() {
let cl = const || {}; let cl = const || {};

1
tests/ui/dyn-star/auxiliary/dyn-star-foreign.rs
View File

@ -1,5 +1,4 @@
#![feature(dyn_star)] #![feature(dyn_star)]
#![allow(incomplete_features)]
use std::fmt::Display; use std::fmt::Display;

2
tests/ui/dyn-star/no-implicit-dyn-star.stderr
View File

@ -10,7 +10,7 @@ LL | dyn_star_foreign::require_dyn_star_display(1usize);
found type `usize` found type `usize`
= help: `usize` implements `Display`, `#[feature(dyn_star)]` is likely not enabled; that feature it is currently incomplete = help: `usize` implements `Display`, `#[feature(dyn_star)]` is likely not enabled; that feature it is currently incomplete
note: function defined here note: function defined here
--> $DIR/auxiliary/dyn-star-foreign.rs:6:8 --> $DIR/auxiliary/dyn-star-foreign.rs:5:8
| |
LL | pub fn require_dyn_star_display(_: dyn* Display) {} LL | pub fn require_dyn_star_display(_: dyn* Display) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^

1
tests/ui/generic-associated-types/issue-90014-tait2.rs
View File

@ -6,7 +6,6 @@
//@ error-pattern: expected generic lifetime parameter, found `'a` //@ error-pattern: expected generic lifetime parameter, found `'a`
#![feature(type_alias_impl_trait)] #![feature(type_alias_impl_trait)]
#![allow(incomplete_features)]
use std::future::Future; use std::future::Future;

2
tests/ui/generic-associated-types/issue-90014-tait2.stderr
View File

@ -1,5 +1,5 @@
error[E0792]: expected generic lifetime parameter, found `'a` error[E0792]: expected generic lifetime parameter, found `'a`
--> $DIR/issue-90014-tait2.rs:27:9 --> $DIR/issue-90014-tait2.rs:26:9
| |
LL | type Fut<'a> = impl Future<Output = ()>; LL | type Fut<'a> = impl Future<Output = ()>;
| -- this generic parameter must be used with a generic lifetime parameter | -- this generic parameter must be used with a generic lifetime parameter

1
tests/ui/impl-trait/in-trait/deep-match-works.rs
View File

@ -1,7 +1,6 @@
//@ check-pass //@ check-pass
#![feature(lint_reasons)] #![feature(lint_reasons)]
#![allow(incomplete_features)]
pub struct Wrapper<T>(T); pub struct Wrapper<T>(T);

2
tests/ui/impl-trait/in-trait/default-body-type-err-2.rs
View File

@ -1,7 +1,5 @@
//@ edition:2021 //@ edition:2021
#![allow(incomplete_features)]
pub trait Foo { pub trait Foo {
async fn woopsie_async(&self) -> String { async fn woopsie_async(&self) -> String {
42 42

2
tests/ui/impl-trait/in-trait/default-body-type-err-2.stderr
View File

@ -1,5 +1,5 @@
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/default-body-type-err-2.rs:7:9 --> $DIR/default-body-type-err-2.rs:5:9
| |
LL | async fn woopsie_async(&self) -> String { LL | async fn woopsie_async(&self) -> String {
| ------ expected `String` because of return type | ------ expected `String` because of return type

2
tests/ui/impl-trait/in-trait/default-body-with-rpit.rs
View File

@ -1,8 +1,6 @@
//@ edition:2021 //@ edition:2021
//@ check-pass //@ check-pass
#![allow(incomplete_features)]
use std::fmt::Debug; use std::fmt::Debug;
trait Foo { trait Foo {

2
tests/ui/impl-trait/in-trait/default-body.rs
View File

@ -1,8 +1,6 @@
//@ check-pass //@ check-pass
//@ edition:2021 //@ edition:2021
#![allow(incomplete_features)]
use std::fmt::Debug; use std::fmt::Debug;
trait Foo { trait Foo {

2
tests/ui/impl-trait/in-trait/early.rs
View File

@ -1,8 +1,6 @@
//@ check-pass //@ check-pass
//@ edition:2021 //@ edition:2021
#![allow(incomplete_features)]
pub trait Foo { pub trait Foo {
#[allow(async_fn_in_trait)] #[allow(async_fn_in_trait)]
async fn bar<'a: 'a>(&'a mut self); async fn bar<'a: 'a>(&'a mut self);

2
tests/ui/impl-trait/in-trait/encode.rs
View File

@ -1,8 +1,6 @@
//@ build-pass //@ build-pass
//@ compile-flags: --crate-type=lib //@ compile-flags: --crate-type=lib
#![allow(incomplete_features)]
trait Foo { trait Foo {
fn bar() -> impl Sized; fn bar() -> impl Sized;
} }

2
tests/ui/impl-trait/in-trait/issue-102301.rs
View File

@ -1,7 +1,5 @@
//@ check-pass //@ check-pass
#![allow(incomplete_features)]
trait Foo<T> { trait Foo<T> {
fn foo<F2: Foo<T>>(self) -> impl Foo<T>; fn foo<F2: Foo<T>>(self) -> impl Foo<T>;
} }

4
tests/ui/impl-trait/in-trait/method-signature-matches.lt.stderr
View File

@ -1,5 +1,5 @@
error[E0053]: method `early` has an incompatible type for trait error[E0053]: method `early` has an incompatible type for trait
--> $DIR/method-signature-matches.rs:57:27 --> $DIR/method-signature-matches.rs:55:27
| |
LL | fn early<'late, T>(_: &'late ()) {} LL | fn early<'late, T>(_: &'late ()) {}
| - ^^^^^^^^^ | - ^^^^^^^^^
@ -9,7 +9,7 @@ LL | fn early<'late, T>(_: &'late ()) {}
| expected this type parameter | expected this type parameter
| |
note: type in trait note: type in trait
--> $DIR/method-signature-matches.rs:52:28 --> $DIR/method-signature-matches.rs:50:28
| |
LL | fn early<'early, T>(x: &'early T) -> impl Sized; LL | fn early<'early, T>(x: &'early T) -> impl Sized;
| ^^^^^^^^^ | ^^^^^^^^^

4
tests/ui/impl-trait/in-trait/method-signature-matches.mismatch.stderr
View File

@ -1,5 +1,5 @@
error[E0053]: method `owo` has an incompatible type for trait error[E0053]: method `owo` has an incompatible type for trait
--> $DIR/method-signature-matches.rs:13:15 --> $DIR/method-signature-matches.rs:11:15
| |
LL | fn owo(_: u8) {} LL | fn owo(_: u8) {}
| ^^ | ^^
@ -8,7 +8,7 @@ LL | fn owo(_: u8) {}
| help: change the parameter type to match the trait: `()` | help: change the parameter type to match the trait: `()`
| |
note: type in trait note: type in trait
--> $DIR/method-signature-matches.rs:8:15 --> $DIR/method-signature-matches.rs:6:15
| |
LL | fn owo(x: ()) -> impl Sized; LL | fn owo(x: ()) -> impl Sized;
| ^^ | ^^

4
tests/ui/impl-trait/in-trait/method-signature-matches.mismatch_async.stderr
View File

@ -1,5 +1,5 @@
error[E0053]: method `owo` has an incompatible type for trait error[E0053]: method `owo` has an incompatible type for trait
--> $DIR/method-signature-matches.rs:24:21 --> $DIR/method-signature-matches.rs:22:21
| |
LL | async fn owo(_: u8) {} LL | async fn owo(_: u8) {}
| ^^ | ^^
@ -8,7 +8,7 @@ LL | async fn owo(_: u8) {}
| help: change the parameter type to match the trait: `()` | help: change the parameter type to match the trait: `()`
| |
note: type in trait note: type in trait
--> $DIR/method-signature-matches.rs:19:21 --> $DIR/method-signature-matches.rs:17:21
| |
LL | async fn owo(x: ()) {} LL | async fn owo(x: ()) {}
| ^^ | ^^

2
tests/ui/impl-trait/in-trait/method-signature-matches.rs
View File

@ -1,8 +1,6 @@
//@ edition: 2021 //@ edition: 2021
//@ revisions: mismatch mismatch_async too_many too_few lt //@ revisions: mismatch mismatch_async too_many too_few lt
#![allow(incomplete_features)]
#[cfg(mismatch)] #[cfg(mismatch)]
trait Uwu { trait Uwu {
fn owo(x: ()) -> impl Sized; fn owo(x: ()) -> impl Sized;

2
tests/ui/impl-trait/in-trait/method-signature-matches.too_few.stderr
View File

@ -1,5 +1,5 @@
error[E0050]: method `come_on_a_little_more_effort` has 0 parameters but the declaration in trait `TooLittle::come_on_a_little_more_effort` has 3 error[E0050]: method `come_on_a_little_more_effort` has 0 parameters but the declaration in trait `TooLittle::come_on_a_little_more_effort` has 3
--> $DIR/method-signature-matches.rs:46:5 --> $DIR/method-signature-matches.rs:44:5
| |
LL | fn come_on_a_little_more_effort(_: (), _: (), _: ()) -> impl Sized; LL | fn come_on_a_little_more_effort(_: (), _: (), _: ()) -> impl Sized;
| ---------------- trait requires 3 parameters | ---------------- trait requires 3 parameters

2
tests/ui/impl-trait/in-trait/method-signature-matches.too_many.stderr
View File

@ -1,5 +1,5 @@
error[E0050]: method `calm_down_please` has 3 parameters but the declaration in trait `TooMuch::calm_down_please` has 0 error[E0050]: method `calm_down_please` has 3 parameters but the declaration in trait `TooMuch::calm_down_please` has 0
--> $DIR/method-signature-matches.rs:35:28 --> $DIR/method-signature-matches.rs:33:28
| |
LL | fn calm_down_please() -> impl Sized; LL | fn calm_down_please() -> impl Sized;
| ------------------------------------ trait requires 0 parameters | ------------------------------------ trait requires 0 parameters

1
tests/ui/impl-trait/in-trait/nested-rpitit.rs
View File

@ -1,7 +1,6 @@
//@ check-pass //@ check-pass
#![feature(lint_reasons)] #![feature(lint_reasons)]
#![allow(incomplete_features)]
use std::fmt::Display; use std::fmt::Display;
use std::ops::Deref; use std::ops::Deref;

2
tests/ui/impl-trait/in-trait/opaque-in-impl.rs
View File

@ -1,7 +1,5 @@
//@ check-pass //@ check-pass
#![allow(incomplete_features)]
use std::fmt::Debug; use std::fmt::Debug;
trait Foo { trait Foo {

1
tests/ui/impl-trait/in-trait/reveal.rs
View File

@ -1,7 +1,6 @@
//@ check-pass //@ check-pass
#![feature(lint_reasons)] #![feature(lint_reasons)]
#![allow(incomplete_features)]
pub trait Foo { pub trait Foo {
fn f() -> Box<impl Sized>; fn f() -> Box<impl Sized>;

1
tests/ui/impl-trait/in-trait/success.rs
View File

@ -1,7 +1,6 @@
//@ check-pass //@ check-pass
#![feature(lint_reasons)] #![feature(lint_reasons)]
#![allow(incomplete_features)]
use std::fmt::Display; use std::fmt::Display;

2
tests/ui/impl-trait/in-trait/wf-bounds.rs
View File

@ -1,7 +1,5 @@
// issue #101663 // issue #101663
#![allow(incomplete_features)]
use std::fmt::Display; use std::fmt::Display;
trait Wf<T> { trait Wf<T> {

12
tests/ui/impl-trait/in-trait/wf-bounds.stderr
View File

@ -1,5 +1,5 @@
error[E0277]: the size for values of type `[u8]` cannot be known at compilation time error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
--> $DIR/wf-bounds.rs:14:22 --> $DIR/wf-bounds.rs:12:22
| |
LL | fn nya() -> impl Wf<Vec<[u8]>>; LL | fn nya() -> impl Wf<Vec<[u8]>>;
| ^^^^^^^^^^^^^ doesn't have a size known at compile-time | ^^^^^^^^^^^^^ doesn't have a size known at compile-time
@ -9,14 +9,14 @@ note: required by an implicit `Sized` bound in `Vec`
--> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
error[E0277]: the size for values of type `[u8]` cannot be known at compilation time error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
--> $DIR/wf-bounds.rs:17:23 --> $DIR/wf-bounds.rs:15:23
| |
LL | fn nya2() -> impl Wf<[u8]>; LL | fn nya2() -> impl Wf<[u8]>;
| ^^^^^^^^ doesn't have a size known at compile-time | ^^^^^^^^ doesn't have a size known at compile-time
| |
= help: the trait `Sized` is not implemented for `[u8]` = help: the trait `Sized` is not implemented for `[u8]`
note: required by an implicit `Sized` bound in `Wf` note: required by an implicit `Sized` bound in `Wf`
--> $DIR/wf-bounds.rs:7:10 --> $DIR/wf-bounds.rs:5:10
| |
LL | trait Wf<T> { LL | trait Wf<T> {
| ^ required by the implicit `Sized` requirement on this type parameter in `Wf` | ^ required by the implicit `Sized` requirement on this type parameter in `Wf`
@ -26,7 +26,7 @@ LL | trait Wf<T: ?Sized> {
| ++++++++ | ++++++++
error[E0277]: the size for values of type `[u8]` cannot be known at compilation time error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
--> $DIR/wf-bounds.rs:20:44 --> $DIR/wf-bounds.rs:18:44
| |
LL | fn nya3() -> impl Wf<(), Output = impl Wf<Vec<[u8]>>>; LL | fn nya3() -> impl Wf<(), Output = impl Wf<Vec<[u8]>>>;
| ^^^^^^^^^^^^^ doesn't have a size known at compile-time | ^^^^^^^^^^^^^ doesn't have a size known at compile-time
@ -36,14 +36,14 @@ note: required by an implicit `Sized` bound in `Vec`
--> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
error[E0277]: `T` doesn't implement `std::fmt::Display` error[E0277]: `T` doesn't implement `std::fmt::Display`
--> $DIR/wf-bounds.rs:23:26 --> $DIR/wf-bounds.rs:21:26
| |
LL | fn nya4<T>() -> impl Wf<NeedsDisplay<T>>; LL | fn nya4<T>() -> impl Wf<NeedsDisplay<T>>;
| ^^^^^^^^^^^^^^^^^^^ `T` cannot be formatted with the default formatter | ^^^^^^^^^^^^^^^^^^^ `T` cannot be formatted with the default formatter
| |
= note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
note: required by a bound in `NeedsDisplay` note: required by a bound in `NeedsDisplay`
--> $DIR/wf-bounds.rs:11:24 --> $DIR/wf-bounds.rs:9:24
| |
LL | struct NeedsDisplay<T: Display>(T); LL | struct NeedsDisplay<T: Display>(T);
| ^^^^^^^ required by this bound in `NeedsDisplay` | ^^^^^^^ required by this bound in `NeedsDisplay`

2
tests/ui/impl-trait/in-trait/where-clause.rs
View File

@ -1,8 +1,6 @@
//@ check-pass //@ check-pass
//@ edition: 2021 //@ edition: 2021
#![allow(incomplete_features)]
use std::fmt::Debug; use std::fmt::Debug;
trait Foo<Item> { trait Foo<Item> {

1
tests/ui/lazy-type-alias/auxiliary/lazy.rs
View File

@ -1,4 +1,3 @@
#![feature(lazy_type_alias)] #![feature(lazy_type_alias)]
#![allow(incomplete_features)]
pub type Alias<T: Copy> = Option<T>; pub type Alias<T: Copy> = Option<T>;

2
tests/ui/lazy-type-alias/extern-crate-has-lazy-type-aliases.locally_eager.stderr
View File

@ -5,7 +5,7 @@ LL | let _: lazy::Alias<String>;
| ^^^^^^ the trait `Copy` is not implemented for `String` | ^^^^^^ the trait `Copy` is not implemented for `String`
| |
note: required by a bound in `lazy::Alias` note: required by a bound in `lazy::Alias`
--> $DIR/auxiliary/lazy.rs:4:19 --> $DIR/auxiliary/lazy.rs:3:19
| |
LL | pub type Alias<T: Copy> = Option<T>; LL | pub type Alias<T: Copy> = Option<T>;
| ^^^^ required by this bound in `Alias` | ^^^^ required by this bound in `Alias`

2
tests/ui/lazy-type-alias/extern-crate-has-lazy-type-aliases.locally_lazy.stderr
View File

@ -5,7 +5,7 @@ LL | let _: lazy::Alias<String>;
| ^^^^^^ the trait `Copy` is not implemented for `String` | ^^^^^^ the trait `Copy` is not implemented for `String`
| |
note: required by a bound in `lazy::Alias` note: required by a bound in `lazy::Alias`
--> $DIR/auxiliary/lazy.rs:4:19 --> $DIR/auxiliary/lazy.rs:3:19
| |
LL | pub type Alias<T: Copy> = Option<T>; LL | pub type Alias<T: Copy> = Option<T>;
| ^^^^ required by this bound in `Alias` | ^^^^ required by this bound in `Alias`

2
tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-2.rs
View File

@ -1,5 +1,3 @@
#![allow(incomplete_features)]
mod child { mod child {
trait Main { trait Main {
fn main() -> impl std::process::Termination; fn main() -> impl std::process::Termination;

4
tests/ui/rfcs/rfc-1937-termination-trait/issue-103052-2.stderr
View File

@ -1,11 +1,11 @@
error[E0277]: the trait bound `Something: Termination` is not satisfied error[E0277]: the trait bound `Something: Termination` is not satisfied
--> $DIR/issue-103052-2.rs:11:22 --> $DIR/issue-103052-2.rs:9:22
| |
LL | fn main() -> Something { LL | fn main() -> Something {
| ^^^^^^^^^ the trait `Termination` is not implemented for `Something` | ^^^^^^^^^ the trait `Termination` is not implemented for `Something`
| |
note: required by a bound in `Main::{synthetic#0}` note: required by a bound in `Main::{synthetic#0}`
--> $DIR/issue-103052-2.rs:5:27 --> $DIR/issue-103052-2.rs:3:27
| |
LL | fn main() -> impl std::process::Termination; LL | fn main() -> impl std::process::Termination;
| ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Main::{synthetic#0}` | ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Main::{synthetic#0}`

1
tests/ui/rfcs/rfc-2528-type-changing-struct-update/coerce-in-base-expr.rs
View File

@ -1,7 +1,6 @@
//@ check-pass //@ check-pass
#![feature(type_changing_struct_update)] #![feature(type_changing_struct_update)]
#![allow(incomplete_features)]
use std::any::Any; use std::any::Any;

1
tests/ui/rfcs/rfc-2528-type-changing-struct-update/issue-96878.rs
View File

@ -1,7 +1,6 @@
//@ check-pass //@ check-pass
#![feature(type_changing_struct_update)] #![feature(type_changing_struct_update)]
#![allow(incomplete_features)]
use std::borrow::Cow; use std::borrow::Cow;
use std::marker::PhantomData; use std::marker::PhantomData;

1
tests/ui/rfcs/rfc-2528-type-changing-struct-update/lifetime-update.rs
View File

@ -1,5 +1,4 @@
#![feature(type_changing_struct_update)] #![feature(type_changing_struct_update)]
#![allow(incomplete_features)]
#[derive(Clone)] #[derive(Clone)]
struct Machine<'a, S> { struct Machine<'a, S> {

2
tests/ui/rfcs/rfc-2528-type-changing-struct-update/lifetime-update.stderr
View File

@ -1,5 +1,5 @@
error[E0597]: `s` does not live long enough error[E0597]: `s` does not live long enough
--> $DIR/lifetime-update.rs:20:17 --> $DIR/lifetime-update.rs:19:17
| |
LL | let s = String::from("hello"); LL | let s = String::from("hello");
| - binding `s` declared here | - binding `s` declared here

1
tests/ui/rfcs/rfc-2528-type-changing-struct-update/type-generic-update.rs
View File

@ -1,5 +1,4 @@
#![feature(type_changing_struct_update)] #![feature(type_changing_struct_update)]
#![allow(incomplete_features)]
struct Machine<'a, S, M> { struct Machine<'a, S, M> {
state: S, state: S,

4
tests/ui/rfcs/rfc-2528-type-changing-struct-update/type-generic-update.stderr
View File

@ -1,5 +1,5 @@
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/type-generic-update.rs:46:11 --> $DIR/type-generic-update.rs:45:11
| |
LL | ..m1 LL | ..m1
| ^^ expected `Machine<'_, i32, f64>`, found `Machine<'_, f64, f64>` | ^^ expected `Machine<'_, i32, f64>`, found `Machine<'_, f64, f64>`
@ -8,7 +8,7 @@ LL | ..m1
found struct `Machine<'_, f64, _>` found struct `Machine<'_, f64, _>`
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/type-generic-update.rs:51:11 --> $DIR/type-generic-update.rs:50:11
| |
LL | ..m1 LL | ..m1
| ^^ expected `Machine<'_, i32, i32>`, found `Machine<'_, f64, f64>` | ^^ expected `Machine<'_, i32, i32>`, found `Machine<'_, f64, f64>`

228
tests/ui/transmutability/primitives/numbers.current.stderr
View File

@ -1,11 +1,11 @@
error[E0277]: `i8` cannot be safely transmuted into `i16` error[E0277]: `i8` cannot be safely transmuted into `i16`
--> $DIR/numbers.rs:65:40 --> $DIR/numbers.rs:64:40
| |
LL | assert::is_transmutable::< i8, i16>(); LL | assert::is_transmutable::< i8, i16>();
| ^^^ The size of `i8` is smaller than the size of `i16` | ^^^ The size of `i8` is smaller than the size of `i16`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -14,13 +14,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u16` error[E0277]: `i8` cannot be safely transmuted into `u16`
--> $DIR/numbers.rs:66:40 --> $DIR/numbers.rs:65:40
| |
LL | assert::is_transmutable::< i8, u16>(); LL | assert::is_transmutable::< i8, u16>();
| ^^^ The size of `i8` is smaller than the size of `u16` | ^^^ The size of `i8` is smaller than the size of `u16`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -29,13 +29,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `i32` error[E0277]: `i8` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:67:40 --> $DIR/numbers.rs:66:40
| |
LL | assert::is_transmutable::< i8, i32>(); LL | assert::is_transmutable::< i8, i32>();
| ^^^ The size of `i8` is smaller than the size of `i32` | ^^^ The size of `i8` is smaller than the size of `i32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -44,13 +44,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `f32` error[E0277]: `i8` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:68:40 --> $DIR/numbers.rs:67:40
| |
LL | assert::is_transmutable::< i8, f32>(); LL | assert::is_transmutable::< i8, f32>();
| ^^^ The size of `i8` is smaller than the size of `f32` | ^^^ The size of `i8` is smaller than the size of `f32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -59,13 +59,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u32` error[E0277]: `i8` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:69:40 --> $DIR/numbers.rs:68:40
| |
LL | assert::is_transmutable::< i8, u32>(); LL | assert::is_transmutable::< i8, u32>();
| ^^^ The size of `i8` is smaller than the size of `u32` | ^^^ The size of `i8` is smaller than the size of `u32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -74,13 +74,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u64` error[E0277]: `i8` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:70:40 --> $DIR/numbers.rs:69:40
| |
LL | assert::is_transmutable::< i8, u64>(); LL | assert::is_transmutable::< i8, u64>();
| ^^^ The size of `i8` is smaller than the size of `u64` | ^^^ The size of `i8` is smaller than the size of `u64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -89,13 +89,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `i64` error[E0277]: `i8` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:71:40 --> $DIR/numbers.rs:70:40
| |
LL | assert::is_transmutable::< i8, i64>(); LL | assert::is_transmutable::< i8, i64>();
| ^^^ The size of `i8` is smaller than the size of `i64` | ^^^ The size of `i8` is smaller than the size of `i64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -104,13 +104,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `f64` error[E0277]: `i8` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:72:40 --> $DIR/numbers.rs:71:40
| |
LL | assert::is_transmutable::< i8, f64>(); LL | assert::is_transmutable::< i8, f64>();
| ^^^ The size of `i8` is smaller than the size of `f64` | ^^^ The size of `i8` is smaller than the size of `f64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -119,13 +119,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u128` error[E0277]: `i8` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:73:39 --> $DIR/numbers.rs:72:39
| |
LL | assert::is_transmutable::< i8, u128>(); LL | assert::is_transmutable::< i8, u128>();
| ^^^^ The size of `i8` is smaller than the size of `u128` | ^^^^ The size of `i8` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -134,13 +134,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `i128` error[E0277]: `i8` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:74:39 --> $DIR/numbers.rs:73:39
| |
LL | assert::is_transmutable::< i8, i128>(); LL | assert::is_transmutable::< i8, i128>();
| ^^^^ The size of `i8` is smaller than the size of `i128` | ^^^^ The size of `i8` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -149,13 +149,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i16` error[E0277]: `u8` cannot be safely transmuted into `i16`
--> $DIR/numbers.rs:76:40 --> $DIR/numbers.rs:75:40
| |
LL | assert::is_transmutable::< u8, i16>(); LL | assert::is_transmutable::< u8, i16>();
| ^^^ The size of `u8` is smaller than the size of `i16` | ^^^ The size of `u8` is smaller than the size of `i16`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -164,13 +164,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u16` error[E0277]: `u8` cannot be safely transmuted into `u16`
--> $DIR/numbers.rs:77:40 --> $DIR/numbers.rs:76:40
| |
LL | assert::is_transmutable::< u8, u16>(); LL | assert::is_transmutable::< u8, u16>();
| ^^^ The size of `u8` is smaller than the size of `u16` | ^^^ The size of `u8` is smaller than the size of `u16`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -179,13 +179,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i32` error[E0277]: `u8` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:78:40 --> $DIR/numbers.rs:77:40
| |
LL | assert::is_transmutable::< u8, i32>(); LL | assert::is_transmutable::< u8, i32>();
| ^^^ The size of `u8` is smaller than the size of `i32` | ^^^ The size of `u8` is smaller than the size of `i32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -194,13 +194,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `f32` error[E0277]: `u8` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:79:40 --> $DIR/numbers.rs:78:40
| |
LL | assert::is_transmutable::< u8, f32>(); LL | assert::is_transmutable::< u8, f32>();
| ^^^ The size of `u8` is smaller than the size of `f32` | ^^^ The size of `u8` is smaller than the size of `f32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -209,13 +209,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u32` error[E0277]: `u8` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:80:40 --> $DIR/numbers.rs:79:40
| |
LL | assert::is_transmutable::< u8, u32>(); LL | assert::is_transmutable::< u8, u32>();
| ^^^ The size of `u8` is smaller than the size of `u32` | ^^^ The size of `u8` is smaller than the size of `u32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -224,13 +224,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u64` error[E0277]: `u8` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:81:40 --> $DIR/numbers.rs:80:40
| |
LL | assert::is_transmutable::< u8, u64>(); LL | assert::is_transmutable::< u8, u64>();
| ^^^ The size of `u8` is smaller than the size of `u64` | ^^^ The size of `u8` is smaller than the size of `u64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -239,13 +239,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i64` error[E0277]: `u8` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:82:40 --> $DIR/numbers.rs:81:40
| |
LL | assert::is_transmutable::< u8, i64>(); LL | assert::is_transmutable::< u8, i64>();
| ^^^ The size of `u8` is smaller than the size of `i64` | ^^^ The size of `u8` is smaller than the size of `i64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -254,13 +254,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `f64` error[E0277]: `u8` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:83:40 --> $DIR/numbers.rs:82:40
| |
LL | assert::is_transmutable::< u8, f64>(); LL | assert::is_transmutable::< u8, f64>();
| ^^^ The size of `u8` is smaller than the size of `f64` | ^^^ The size of `u8` is smaller than the size of `f64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -269,13 +269,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u128` error[E0277]: `u8` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:84:39 --> $DIR/numbers.rs:83:39
| |
LL | assert::is_transmutable::< u8, u128>(); LL | assert::is_transmutable::< u8, u128>();
| ^^^^ The size of `u8` is smaller than the size of `u128` | ^^^^ The size of `u8` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -284,13 +284,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i128` error[E0277]: `u8` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:85:39 --> $DIR/numbers.rs:84:39
| |
LL | assert::is_transmutable::< u8, i128>(); LL | assert::is_transmutable::< u8, i128>();
| ^^^^ The size of `u8` is smaller than the size of `i128` | ^^^^ The size of `u8` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -299,13 +299,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `i32` error[E0277]: `i16` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:87:40 --> $DIR/numbers.rs:86:40
| |
LL | assert::is_transmutable::< i16, i32>(); LL | assert::is_transmutable::< i16, i32>();
| ^^^ The size of `i16` is smaller than the size of `i32` | ^^^ The size of `i16` is smaller than the size of `i32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -314,13 +314,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `f32` error[E0277]: `i16` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:88:40 --> $DIR/numbers.rs:87:40
| |
LL | assert::is_transmutable::< i16, f32>(); LL | assert::is_transmutable::< i16, f32>();
| ^^^ The size of `i16` is smaller than the size of `f32` | ^^^ The size of `i16` is smaller than the size of `f32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -329,13 +329,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `u32` error[E0277]: `i16` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:89:40 --> $DIR/numbers.rs:88:40
| |
LL | assert::is_transmutable::< i16, u32>(); LL | assert::is_transmutable::< i16, u32>();
| ^^^ The size of `i16` is smaller than the size of `u32` | ^^^ The size of `i16` is smaller than the size of `u32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -344,13 +344,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `u64` error[E0277]: `i16` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:90:40 --> $DIR/numbers.rs:89:40
| |
LL | assert::is_transmutable::< i16, u64>(); LL | assert::is_transmutable::< i16, u64>();
| ^^^ The size of `i16` is smaller than the size of `u64` | ^^^ The size of `i16` is smaller than the size of `u64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -359,13 +359,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `i64` error[E0277]: `i16` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:91:40 --> $DIR/numbers.rs:90:40
| |
LL | assert::is_transmutable::< i16, i64>(); LL | assert::is_transmutable::< i16, i64>();
| ^^^ The size of `i16` is smaller than the size of `i64` | ^^^ The size of `i16` is smaller than the size of `i64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -374,13 +374,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `f64` error[E0277]: `i16` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:92:40 --> $DIR/numbers.rs:91:40
| |
LL | assert::is_transmutable::< i16, f64>(); LL | assert::is_transmutable::< i16, f64>();
| ^^^ The size of `i16` is smaller than the size of `f64` | ^^^ The size of `i16` is smaller than the size of `f64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -389,13 +389,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `u128` error[E0277]: `i16` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:93:39 --> $DIR/numbers.rs:92:39
| |
LL | assert::is_transmutable::< i16, u128>(); LL | assert::is_transmutable::< i16, u128>();
| ^^^^ The size of `i16` is smaller than the size of `u128` | ^^^^ The size of `i16` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -404,13 +404,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `i128` error[E0277]: `i16` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:94:39 --> $DIR/numbers.rs:93:39
| |
LL | assert::is_transmutable::< i16, i128>(); LL | assert::is_transmutable::< i16, i128>();
| ^^^^ The size of `i16` is smaller than the size of `i128` | ^^^^ The size of `i16` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -419,13 +419,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `i32` error[E0277]: `u16` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:96:40 --> $DIR/numbers.rs:95:40
| |
LL | assert::is_transmutable::< u16, i32>(); LL | assert::is_transmutable::< u16, i32>();
| ^^^ The size of `u16` is smaller than the size of `i32` | ^^^ The size of `u16` is smaller than the size of `i32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -434,13 +434,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `f32` error[E0277]: `u16` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:97:40 --> $DIR/numbers.rs:96:40
| |
LL | assert::is_transmutable::< u16, f32>(); LL | assert::is_transmutable::< u16, f32>();
| ^^^ The size of `u16` is smaller than the size of `f32` | ^^^ The size of `u16` is smaller than the size of `f32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -449,13 +449,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `u32` error[E0277]: `u16` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:98:40 --> $DIR/numbers.rs:97:40
| |
LL | assert::is_transmutable::< u16, u32>(); LL | assert::is_transmutable::< u16, u32>();
| ^^^ The size of `u16` is smaller than the size of `u32` | ^^^ The size of `u16` is smaller than the size of `u32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -464,13 +464,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `u64` error[E0277]: `u16` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:99:40 --> $DIR/numbers.rs:98:40
| |
LL | assert::is_transmutable::< u16, u64>(); LL | assert::is_transmutable::< u16, u64>();
| ^^^ The size of `u16` is smaller than the size of `u64` | ^^^ The size of `u16` is smaller than the size of `u64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -479,13 +479,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `i64` error[E0277]: `u16` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:100:40 --> $DIR/numbers.rs:99:40
| |
LL | assert::is_transmutable::< u16, i64>(); LL | assert::is_transmutable::< u16, i64>();
| ^^^ The size of `u16` is smaller than the size of `i64` | ^^^ The size of `u16` is smaller than the size of `i64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -494,13 +494,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `f64` error[E0277]: `u16` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:101:40 --> $DIR/numbers.rs:100:40
| |
LL | assert::is_transmutable::< u16, f64>(); LL | assert::is_transmutable::< u16, f64>();
| ^^^ The size of `u16` is smaller than the size of `f64` | ^^^ The size of `u16` is smaller than the size of `f64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -509,13 +509,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `u128` error[E0277]: `u16` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:102:39 --> $DIR/numbers.rs:101:39
| |
LL | assert::is_transmutable::< u16, u128>(); LL | assert::is_transmutable::< u16, u128>();
| ^^^^ The size of `u16` is smaller than the size of `u128` | ^^^^ The size of `u16` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -524,13 +524,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `i128` error[E0277]: `u16` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:103:39 --> $DIR/numbers.rs:102:39
| |
LL | assert::is_transmutable::< u16, i128>(); LL | assert::is_transmutable::< u16, i128>();
| ^^^^ The size of `u16` is smaller than the size of `i128` | ^^^^ The size of `u16` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -539,13 +539,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `u64` error[E0277]: `i32` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:105:40 --> $DIR/numbers.rs:104:40
| |
LL | assert::is_transmutable::< i32, u64>(); LL | assert::is_transmutable::< i32, u64>();
| ^^^ The size of `i32` is smaller than the size of `u64` | ^^^ The size of `i32` is smaller than the size of `u64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -554,13 +554,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `i64` error[E0277]: `i32` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:106:40 --> $DIR/numbers.rs:105:40
| |
LL | assert::is_transmutable::< i32, i64>(); LL | assert::is_transmutable::< i32, i64>();
| ^^^ The size of `i32` is smaller than the size of `i64` | ^^^ The size of `i32` is smaller than the size of `i64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -569,13 +569,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `f64` error[E0277]: `i32` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:107:40 --> $DIR/numbers.rs:106:40
| |
LL | assert::is_transmutable::< i32, f64>(); LL | assert::is_transmutable::< i32, f64>();
| ^^^ The size of `i32` is smaller than the size of `f64` | ^^^ The size of `i32` is smaller than the size of `f64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -584,13 +584,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `u128` error[E0277]: `i32` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:108:39 --> $DIR/numbers.rs:107:39
| |
LL | assert::is_transmutable::< i32, u128>(); LL | assert::is_transmutable::< i32, u128>();
| ^^^^ The size of `i32` is smaller than the size of `u128` | ^^^^ The size of `i32` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -599,13 +599,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `i128` error[E0277]: `i32` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:109:39 --> $DIR/numbers.rs:108:39
| |
LL | assert::is_transmutable::< i32, i128>(); LL | assert::is_transmutable::< i32, i128>();
| ^^^^ The size of `i32` is smaller than the size of `i128` | ^^^^ The size of `i32` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -614,13 +614,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `u64` error[E0277]: `f32` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:111:40 --> $DIR/numbers.rs:110:40
| |
LL | assert::is_transmutable::< f32, u64>(); LL | assert::is_transmutable::< f32, u64>();
| ^^^ The size of `f32` is smaller than the size of `u64` | ^^^ The size of `f32` is smaller than the size of `u64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -629,13 +629,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `i64` error[E0277]: `f32` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:112:40 --> $DIR/numbers.rs:111:40
| |
LL | assert::is_transmutable::< f32, i64>(); LL | assert::is_transmutable::< f32, i64>();
| ^^^ The size of `f32` is smaller than the size of `i64` | ^^^ The size of `f32` is smaller than the size of `i64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -644,13 +644,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `f64` error[E0277]: `f32` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:113:40 --> $DIR/numbers.rs:112:40
| |
LL | assert::is_transmutable::< f32, f64>(); LL | assert::is_transmutable::< f32, f64>();
| ^^^ The size of `f32` is smaller than the size of `f64` | ^^^ The size of `f32` is smaller than the size of `f64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -659,13 +659,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `u128` error[E0277]: `f32` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:114:39 --> $DIR/numbers.rs:113:39
| |
LL | assert::is_transmutable::< f32, u128>(); LL | assert::is_transmutable::< f32, u128>();
| ^^^^ The size of `f32` is smaller than the size of `u128` | ^^^^ The size of `f32` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -674,13 +674,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `i128` error[E0277]: `f32` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:115:39 --> $DIR/numbers.rs:114:39
| |
LL | assert::is_transmutable::< f32, i128>(); LL | assert::is_transmutable::< f32, i128>();
| ^^^^ The size of `f32` is smaller than the size of `i128` | ^^^^ The size of `f32` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -689,13 +689,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `u64` error[E0277]: `u32` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:117:40 --> $DIR/numbers.rs:116:40
| |
LL | assert::is_transmutable::< u32, u64>(); LL | assert::is_transmutable::< u32, u64>();
| ^^^ The size of `u32` is smaller than the size of `u64` | ^^^ The size of `u32` is smaller than the size of `u64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -704,13 +704,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `i64` error[E0277]: `u32` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:118:40 --> $DIR/numbers.rs:117:40
| |
LL | assert::is_transmutable::< u32, i64>(); LL | assert::is_transmutable::< u32, i64>();
| ^^^ The size of `u32` is smaller than the size of `i64` | ^^^ The size of `u32` is smaller than the size of `i64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -719,13 +719,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `f64` error[E0277]: `u32` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:119:40 --> $DIR/numbers.rs:118:40
| |
LL | assert::is_transmutable::< u32, f64>(); LL | assert::is_transmutable::< u32, f64>();
| ^^^ The size of `u32` is smaller than the size of `f64` | ^^^ The size of `u32` is smaller than the size of `f64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -734,13 +734,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `u128` error[E0277]: `u32` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:120:39 --> $DIR/numbers.rs:119:39
| |
LL | assert::is_transmutable::< u32, u128>(); LL | assert::is_transmutable::< u32, u128>();
| ^^^^ The size of `u32` is smaller than the size of `u128` | ^^^^ The size of `u32` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -749,13 +749,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `i128` error[E0277]: `u32` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:121:39 --> $DIR/numbers.rs:120:39
| |
LL | assert::is_transmutable::< u32, i128>(); LL | assert::is_transmutable::< u32, i128>();
| ^^^^ The size of `u32` is smaller than the size of `i128` | ^^^^ The size of `u32` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -764,13 +764,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u64` cannot be safely transmuted into `u128` error[E0277]: `u64` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:123:39 --> $DIR/numbers.rs:122:39
| |
LL | assert::is_transmutable::< u64, u128>(); LL | assert::is_transmutable::< u64, u128>();
| ^^^^ The size of `u64` is smaller than the size of `u128` | ^^^^ The size of `u64` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -779,13 +779,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u64` cannot be safely transmuted into `i128` error[E0277]: `u64` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:124:39 --> $DIR/numbers.rs:123:39
| |
LL | assert::is_transmutable::< u64, i128>(); LL | assert::is_transmutable::< u64, i128>();
| ^^^^ The size of `u64` is smaller than the size of `i128` | ^^^^ The size of `u64` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -794,13 +794,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i64` cannot be safely transmuted into `u128` error[E0277]: `i64` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:126:39 --> $DIR/numbers.rs:125:39
| |
LL | assert::is_transmutable::< i64, u128>(); LL | assert::is_transmutable::< i64, u128>();
| ^^^^ The size of `i64` is smaller than the size of `u128` | ^^^^ The size of `i64` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -809,13 +809,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i64` cannot be safely transmuted into `i128` error[E0277]: `i64` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:127:39 --> $DIR/numbers.rs:126:39
| |
LL | assert::is_transmutable::< i64, i128>(); LL | assert::is_transmutable::< i64, i128>();
| ^^^^ The size of `i64` is smaller than the size of `i128` | ^^^^ The size of `i64` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -824,13 +824,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f64` cannot be safely transmuted into `u128` error[E0277]: `f64` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:129:39 --> $DIR/numbers.rs:128:39
| |
LL | assert::is_transmutable::< f64, u128>(); LL | assert::is_transmutable::< f64, u128>();
| ^^^^ The size of `f64` is smaller than the size of `u128` | ^^^^ The size of `f64` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -839,13 +839,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f64` cannot be safely transmuted into `i128` error[E0277]: `f64` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:130:39 --> $DIR/numbers.rs:129:39
| |
LL | assert::is_transmutable::< f64, i128>(); LL | assert::is_transmutable::< f64, i128>();
| ^^^^ The size of `f64` is smaller than the size of `i128` | ^^^^ The size of `f64` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function

228
tests/ui/transmutability/primitives/numbers.next.stderr
View File

@ -1,11 +1,11 @@
error[E0277]: `i8` cannot be safely transmuted into `i16` error[E0277]: `i8` cannot be safely transmuted into `i16`
--> $DIR/numbers.rs:65:40 --> $DIR/numbers.rs:64:40
| |
LL | assert::is_transmutable::< i8, i16>(); LL | assert::is_transmutable::< i8, i16>();
| ^^^ The size of `i8` is smaller than the size of `i16` | ^^^ The size of `i8` is smaller than the size of `i16`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -14,13 +14,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u16` error[E0277]: `i8` cannot be safely transmuted into `u16`
--> $DIR/numbers.rs:66:40 --> $DIR/numbers.rs:65:40
| |
LL | assert::is_transmutable::< i8, u16>(); LL | assert::is_transmutable::< i8, u16>();
| ^^^ The size of `i8` is smaller than the size of `u16` | ^^^ The size of `i8` is smaller than the size of `u16`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -29,13 +29,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `i32` error[E0277]: `i8` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:67:40 --> $DIR/numbers.rs:66:40
| |
LL | assert::is_transmutable::< i8, i32>(); LL | assert::is_transmutable::< i8, i32>();
| ^^^ The size of `i8` is smaller than the size of `i32` | ^^^ The size of `i8` is smaller than the size of `i32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -44,13 +44,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `f32` error[E0277]: `i8` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:68:40 --> $DIR/numbers.rs:67:40
| |
LL | assert::is_transmutable::< i8, f32>(); LL | assert::is_transmutable::< i8, f32>();
| ^^^ The size of `i8` is smaller than the size of `f32` | ^^^ The size of `i8` is smaller than the size of `f32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -59,13 +59,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u32` error[E0277]: `i8` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:69:40 --> $DIR/numbers.rs:68:40
| |
LL | assert::is_transmutable::< i8, u32>(); LL | assert::is_transmutable::< i8, u32>();
| ^^^ The size of `i8` is smaller than the size of `u32` | ^^^ The size of `i8` is smaller than the size of `u32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -74,13 +74,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u64` error[E0277]: `i8` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:70:40 --> $DIR/numbers.rs:69:40
| |
LL | assert::is_transmutable::< i8, u64>(); LL | assert::is_transmutable::< i8, u64>();
| ^^^ The size of `i8` is smaller than the size of `u64` | ^^^ The size of `i8` is smaller than the size of `u64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -89,13 +89,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `i64` error[E0277]: `i8` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:71:40 --> $DIR/numbers.rs:70:40
| |
LL | assert::is_transmutable::< i8, i64>(); LL | assert::is_transmutable::< i8, i64>();
| ^^^ The size of `i8` is smaller than the size of `i64` | ^^^ The size of `i8` is smaller than the size of `i64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -104,13 +104,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `f64` error[E0277]: `i8` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:72:40 --> $DIR/numbers.rs:71:40
| |
LL | assert::is_transmutable::< i8, f64>(); LL | assert::is_transmutable::< i8, f64>();
| ^^^ The size of `i8` is smaller than the size of `f64` | ^^^ The size of `i8` is smaller than the size of `f64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -119,13 +119,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `u128` error[E0277]: `i8` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:73:39 --> $DIR/numbers.rs:72:39
| |
LL | assert::is_transmutable::< i8, u128>(); LL | assert::is_transmutable::< i8, u128>();
| ^^^^ The size of `i8` is smaller than the size of `u128` | ^^^^ The size of `i8` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -134,13 +134,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i8` cannot be safely transmuted into `i128` error[E0277]: `i8` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:74:39 --> $DIR/numbers.rs:73:39
| |
LL | assert::is_transmutable::< i8, i128>(); LL | assert::is_transmutable::< i8, i128>();
| ^^^^ The size of `i8` is smaller than the size of `i128` | ^^^^ The size of `i8` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -149,13 +149,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i16` error[E0277]: `u8` cannot be safely transmuted into `i16`
--> $DIR/numbers.rs:76:40 --> $DIR/numbers.rs:75:40
| |
LL | assert::is_transmutable::< u8, i16>(); LL | assert::is_transmutable::< u8, i16>();
| ^^^ The size of `u8` is smaller than the size of `i16` | ^^^ The size of `u8` is smaller than the size of `i16`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -164,13 +164,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u16` error[E0277]: `u8` cannot be safely transmuted into `u16`
--> $DIR/numbers.rs:77:40 --> $DIR/numbers.rs:76:40
| |
LL | assert::is_transmutable::< u8, u16>(); LL | assert::is_transmutable::< u8, u16>();
| ^^^ The size of `u8` is smaller than the size of `u16` | ^^^ The size of `u8` is smaller than the size of `u16`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -179,13 +179,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i32` error[E0277]: `u8` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:78:40 --> $DIR/numbers.rs:77:40
| |
LL | assert::is_transmutable::< u8, i32>(); LL | assert::is_transmutable::< u8, i32>();
| ^^^ The size of `u8` is smaller than the size of `i32` | ^^^ The size of `u8` is smaller than the size of `i32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -194,13 +194,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `f32` error[E0277]: `u8` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:79:40 --> $DIR/numbers.rs:78:40
| |
LL | assert::is_transmutable::< u8, f32>(); LL | assert::is_transmutable::< u8, f32>();
| ^^^ The size of `u8` is smaller than the size of `f32` | ^^^ The size of `u8` is smaller than the size of `f32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -209,13 +209,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u32` error[E0277]: `u8` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:80:40 --> $DIR/numbers.rs:79:40
| |
LL | assert::is_transmutable::< u8, u32>(); LL | assert::is_transmutable::< u8, u32>();
| ^^^ The size of `u8` is smaller than the size of `u32` | ^^^ The size of `u8` is smaller than the size of `u32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -224,13 +224,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u64` error[E0277]: `u8` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:81:40 --> $DIR/numbers.rs:80:40
| |
LL | assert::is_transmutable::< u8, u64>(); LL | assert::is_transmutable::< u8, u64>();
| ^^^ The size of `u8` is smaller than the size of `u64` | ^^^ The size of `u8` is smaller than the size of `u64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -239,13 +239,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i64` error[E0277]: `u8` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:82:40 --> $DIR/numbers.rs:81:40
| |
LL | assert::is_transmutable::< u8, i64>(); LL | assert::is_transmutable::< u8, i64>();
| ^^^ The size of `u8` is smaller than the size of `i64` | ^^^ The size of `u8` is smaller than the size of `i64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -254,13 +254,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `f64` error[E0277]: `u8` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:83:40 --> $DIR/numbers.rs:82:40
| |
LL | assert::is_transmutable::< u8, f64>(); LL | assert::is_transmutable::< u8, f64>();
| ^^^ The size of `u8` is smaller than the size of `f64` | ^^^ The size of `u8` is smaller than the size of `f64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -269,13 +269,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `u128` error[E0277]: `u8` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:84:39 --> $DIR/numbers.rs:83:39
| |
LL | assert::is_transmutable::< u8, u128>(); LL | assert::is_transmutable::< u8, u128>();
| ^^^^ The size of `u8` is smaller than the size of `u128` | ^^^^ The size of `u8` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -284,13 +284,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u8` cannot be safely transmuted into `i128` error[E0277]: `u8` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:85:39 --> $DIR/numbers.rs:84:39
| |
LL | assert::is_transmutable::< u8, i128>(); LL | assert::is_transmutable::< u8, i128>();
| ^^^^ The size of `u8` is smaller than the size of `i128` | ^^^^ The size of `u8` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -299,13 +299,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `i32` error[E0277]: `i16` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:87:40 --> $DIR/numbers.rs:86:40
| |
LL | assert::is_transmutable::< i16, i32>(); LL | assert::is_transmutable::< i16, i32>();
| ^^^ The size of `i16` is smaller than the size of `i32` | ^^^ The size of `i16` is smaller than the size of `i32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -314,13 +314,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `f32` error[E0277]: `i16` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:88:40 --> $DIR/numbers.rs:87:40
| |
LL | assert::is_transmutable::< i16, f32>(); LL | assert::is_transmutable::< i16, f32>();
| ^^^ The size of `i16` is smaller than the size of `f32` | ^^^ The size of `i16` is smaller than the size of `f32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -329,13 +329,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `u32` error[E0277]: `i16` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:89:40 --> $DIR/numbers.rs:88:40
| |
LL | assert::is_transmutable::< i16, u32>(); LL | assert::is_transmutable::< i16, u32>();
| ^^^ The size of `i16` is smaller than the size of `u32` | ^^^ The size of `i16` is smaller than the size of `u32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -344,13 +344,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `u64` error[E0277]: `i16` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:90:40 --> $DIR/numbers.rs:89:40
| |
LL | assert::is_transmutable::< i16, u64>(); LL | assert::is_transmutable::< i16, u64>();
| ^^^ The size of `i16` is smaller than the size of `u64` | ^^^ The size of `i16` is smaller than the size of `u64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -359,13 +359,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `i64` error[E0277]: `i16` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:91:40 --> $DIR/numbers.rs:90:40
| |
LL | assert::is_transmutable::< i16, i64>(); LL | assert::is_transmutable::< i16, i64>();
| ^^^ The size of `i16` is smaller than the size of `i64` | ^^^ The size of `i16` is smaller than the size of `i64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -374,13 +374,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `f64` error[E0277]: `i16` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:92:40 --> $DIR/numbers.rs:91:40
| |
LL | assert::is_transmutable::< i16, f64>(); LL | assert::is_transmutable::< i16, f64>();
| ^^^ The size of `i16` is smaller than the size of `f64` | ^^^ The size of `i16` is smaller than the size of `f64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -389,13 +389,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `u128` error[E0277]: `i16` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:93:39 --> $DIR/numbers.rs:92:39
| |
LL | assert::is_transmutable::< i16, u128>(); LL | assert::is_transmutable::< i16, u128>();
| ^^^^ The size of `i16` is smaller than the size of `u128` | ^^^^ The size of `i16` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -404,13 +404,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i16` cannot be safely transmuted into `i128` error[E0277]: `i16` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:94:39 --> $DIR/numbers.rs:93:39
| |
LL | assert::is_transmutable::< i16, i128>(); LL | assert::is_transmutable::< i16, i128>();
| ^^^^ The size of `i16` is smaller than the size of `i128` | ^^^^ The size of `i16` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -419,13 +419,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `i32` error[E0277]: `u16` cannot be safely transmuted into `i32`
--> $DIR/numbers.rs:96:40 --> $DIR/numbers.rs:95:40
| |
LL | assert::is_transmutable::< u16, i32>(); LL | assert::is_transmutable::< u16, i32>();
| ^^^ The size of `u16` is smaller than the size of `i32` | ^^^ The size of `u16` is smaller than the size of `i32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -434,13 +434,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `f32` error[E0277]: `u16` cannot be safely transmuted into `f32`
--> $DIR/numbers.rs:97:40 --> $DIR/numbers.rs:96:40
| |
LL | assert::is_transmutable::< u16, f32>(); LL | assert::is_transmutable::< u16, f32>();
| ^^^ The size of `u16` is smaller than the size of `f32` | ^^^ The size of `u16` is smaller than the size of `f32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -449,13 +449,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `u32` error[E0277]: `u16` cannot be safely transmuted into `u32`
--> $DIR/numbers.rs:98:40 --> $DIR/numbers.rs:97:40
| |
LL | assert::is_transmutable::< u16, u32>(); LL | assert::is_transmutable::< u16, u32>();
| ^^^ The size of `u16` is smaller than the size of `u32` | ^^^ The size of `u16` is smaller than the size of `u32`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -464,13 +464,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `u64` error[E0277]: `u16` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:99:40 --> $DIR/numbers.rs:98:40
| |
LL | assert::is_transmutable::< u16, u64>(); LL | assert::is_transmutable::< u16, u64>();
| ^^^ The size of `u16` is smaller than the size of `u64` | ^^^ The size of `u16` is smaller than the size of `u64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -479,13 +479,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `i64` error[E0277]: `u16` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:100:40 --> $DIR/numbers.rs:99:40
| |
LL | assert::is_transmutable::< u16, i64>(); LL | assert::is_transmutable::< u16, i64>();
| ^^^ The size of `u16` is smaller than the size of `i64` | ^^^ The size of `u16` is smaller than the size of `i64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -494,13 +494,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `f64` error[E0277]: `u16` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:101:40 --> $DIR/numbers.rs:100:40
| |
LL | assert::is_transmutable::< u16, f64>(); LL | assert::is_transmutable::< u16, f64>();
| ^^^ The size of `u16` is smaller than the size of `f64` | ^^^ The size of `u16` is smaller than the size of `f64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -509,13 +509,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `u128` error[E0277]: `u16` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:102:39 --> $DIR/numbers.rs:101:39
| |
LL | assert::is_transmutable::< u16, u128>(); LL | assert::is_transmutable::< u16, u128>();
| ^^^^ The size of `u16` is smaller than the size of `u128` | ^^^^ The size of `u16` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -524,13 +524,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u16` cannot be safely transmuted into `i128` error[E0277]: `u16` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:103:39 --> $DIR/numbers.rs:102:39
| |
LL | assert::is_transmutable::< u16, i128>(); LL | assert::is_transmutable::< u16, i128>();
| ^^^^ The size of `u16` is smaller than the size of `i128` | ^^^^ The size of `u16` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -539,13 +539,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `u64` error[E0277]: `i32` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:105:40 --> $DIR/numbers.rs:104:40
| |
LL | assert::is_transmutable::< i32, u64>(); LL | assert::is_transmutable::< i32, u64>();
| ^^^ The size of `i32` is smaller than the size of `u64` | ^^^ The size of `i32` is smaller than the size of `u64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -554,13 +554,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `i64` error[E0277]: `i32` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:106:40 --> $DIR/numbers.rs:105:40
| |
LL | assert::is_transmutable::< i32, i64>(); LL | assert::is_transmutable::< i32, i64>();
| ^^^ The size of `i32` is smaller than the size of `i64` | ^^^ The size of `i32` is smaller than the size of `i64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -569,13 +569,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `f64` error[E0277]: `i32` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:107:40 --> $DIR/numbers.rs:106:40
| |
LL | assert::is_transmutable::< i32, f64>(); LL | assert::is_transmutable::< i32, f64>();
| ^^^ The size of `i32` is smaller than the size of `f64` | ^^^ The size of `i32` is smaller than the size of `f64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -584,13 +584,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `u128` error[E0277]: `i32` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:108:39 --> $DIR/numbers.rs:107:39
| |
LL | assert::is_transmutable::< i32, u128>(); LL | assert::is_transmutable::< i32, u128>();
| ^^^^ The size of `i32` is smaller than the size of `u128` | ^^^^ The size of `i32` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -599,13 +599,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i32` cannot be safely transmuted into `i128` error[E0277]: `i32` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:109:39 --> $DIR/numbers.rs:108:39
| |
LL | assert::is_transmutable::< i32, i128>(); LL | assert::is_transmutable::< i32, i128>();
| ^^^^ The size of `i32` is smaller than the size of `i128` | ^^^^ The size of `i32` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -614,13 +614,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `u64` error[E0277]: `f32` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:111:40 --> $DIR/numbers.rs:110:40
| |
LL | assert::is_transmutable::< f32, u64>(); LL | assert::is_transmutable::< f32, u64>();
| ^^^ The size of `f32` is smaller than the size of `u64` | ^^^ The size of `f32` is smaller than the size of `u64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -629,13 +629,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `i64` error[E0277]: `f32` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:112:40 --> $DIR/numbers.rs:111:40
| |
LL | assert::is_transmutable::< f32, i64>(); LL | assert::is_transmutable::< f32, i64>();
| ^^^ The size of `f32` is smaller than the size of `i64` | ^^^ The size of `f32` is smaller than the size of `i64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -644,13 +644,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `f64` error[E0277]: `f32` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:113:40 --> $DIR/numbers.rs:112:40
| |
LL | assert::is_transmutable::< f32, f64>(); LL | assert::is_transmutable::< f32, f64>();
| ^^^ The size of `f32` is smaller than the size of `f64` | ^^^ The size of `f32` is smaller than the size of `f64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -659,13 +659,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `u128` error[E0277]: `f32` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:114:39 --> $DIR/numbers.rs:113:39
| |
LL | assert::is_transmutable::< f32, u128>(); LL | assert::is_transmutable::< f32, u128>();
| ^^^^ The size of `f32` is smaller than the size of `u128` | ^^^^ The size of `f32` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -674,13 +674,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f32` cannot be safely transmuted into `i128` error[E0277]: `f32` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:115:39 --> $DIR/numbers.rs:114:39
| |
LL | assert::is_transmutable::< f32, i128>(); LL | assert::is_transmutable::< f32, i128>();
| ^^^^ The size of `f32` is smaller than the size of `i128` | ^^^^ The size of `f32` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -689,13 +689,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `u64` error[E0277]: `u32` cannot be safely transmuted into `u64`
--> $DIR/numbers.rs:117:40 --> $DIR/numbers.rs:116:40
| |
LL | assert::is_transmutable::< u32, u64>(); LL | assert::is_transmutable::< u32, u64>();
| ^^^ The size of `u32` is smaller than the size of `u64` | ^^^ The size of `u32` is smaller than the size of `u64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -704,13 +704,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `i64` error[E0277]: `u32` cannot be safely transmuted into `i64`
--> $DIR/numbers.rs:118:40 --> $DIR/numbers.rs:117:40
| |
LL | assert::is_transmutable::< u32, i64>(); LL | assert::is_transmutable::< u32, i64>();
| ^^^ The size of `u32` is smaller than the size of `i64` | ^^^ The size of `u32` is smaller than the size of `i64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -719,13 +719,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `f64` error[E0277]: `u32` cannot be safely transmuted into `f64`
--> $DIR/numbers.rs:119:40 --> $DIR/numbers.rs:118:40
| |
LL | assert::is_transmutable::< u32, f64>(); LL | assert::is_transmutable::< u32, f64>();
| ^^^ The size of `u32` is smaller than the size of `f64` | ^^^ The size of `u32` is smaller than the size of `f64`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -734,13 +734,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `u128` error[E0277]: `u32` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:120:39 --> $DIR/numbers.rs:119:39
| |
LL | assert::is_transmutable::< u32, u128>(); LL | assert::is_transmutable::< u32, u128>();
| ^^^^ The size of `u32` is smaller than the size of `u128` | ^^^^ The size of `u32` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -749,13 +749,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u32` cannot be safely transmuted into `i128` error[E0277]: `u32` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:121:39 --> $DIR/numbers.rs:120:39
| |
LL | assert::is_transmutable::< u32, i128>(); LL | assert::is_transmutable::< u32, i128>();
| ^^^^ The size of `u32` is smaller than the size of `i128` | ^^^^ The size of `u32` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -764,13 +764,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u64` cannot be safely transmuted into `u128` error[E0277]: `u64` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:123:39 --> $DIR/numbers.rs:122:39
| |
LL | assert::is_transmutable::< u64, u128>(); LL | assert::is_transmutable::< u64, u128>();
| ^^^^ The size of `u64` is smaller than the size of `u128` | ^^^^ The size of `u64` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -779,13 +779,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `u64` cannot be safely transmuted into `i128` error[E0277]: `u64` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:124:39 --> $DIR/numbers.rs:123:39
| |
LL | assert::is_transmutable::< u64, i128>(); LL | assert::is_transmutable::< u64, i128>();
| ^^^^ The size of `u64` is smaller than the size of `i128` | ^^^^ The size of `u64` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -794,13 +794,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i64` cannot be safely transmuted into `u128` error[E0277]: `i64` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:126:39 --> $DIR/numbers.rs:125:39
| |
LL | assert::is_transmutable::< i64, u128>(); LL | assert::is_transmutable::< i64, u128>();
| ^^^^ The size of `i64` is smaller than the size of `u128` | ^^^^ The size of `i64` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -809,13 +809,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `i64` cannot be safely transmuted into `i128` error[E0277]: `i64` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:127:39 --> $DIR/numbers.rs:126:39
| |
LL | assert::is_transmutable::< i64, i128>(); LL | assert::is_transmutable::< i64, i128>();
| ^^^^ The size of `i64` is smaller than the size of `i128` | ^^^^ The size of `i64` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -824,13 +824,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f64` cannot be safely transmuted into `u128` error[E0277]: `f64` cannot be safely transmuted into `u128`
--> $DIR/numbers.rs:129:39 --> $DIR/numbers.rs:128:39
| |
LL | assert::is_transmutable::< f64, u128>(); LL | assert::is_transmutable::< f64, u128>();
| ^^^^ The size of `f64` is smaller than the size of `u128` | ^^^^ The size of `f64` is smaller than the size of `u128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function
@ -839,13 +839,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable` | ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
error[E0277]: `f64` cannot be safely transmuted into `i128` error[E0277]: `f64` cannot be safely transmuted into `i128`
--> $DIR/numbers.rs:130:39 --> $DIR/numbers.rs:129:39
| |
LL | assert::is_transmutable::< f64, i128>(); LL | assert::is_transmutable::< f64, i128>();
| ^^^^ The size of `f64` is smaller than the size of `i128` | ^^^^ The size of `f64` is smaller than the size of `i128`
| |
note: required by a bound in `is_transmutable` note: required by a bound in `is_transmutable`
--> $DIR/numbers.rs:15:14 --> $DIR/numbers.rs:14:14
| |
LL | pub fn is_transmutable<Src, Dst>() LL | pub fn is_transmutable<Src, Dst>()
| --------------- required by a bound in this function | --------------- required by a bound in this function

1
tests/ui/transmutability/primitives/numbers.rs
View File

@ -5,7 +5,6 @@
#![crate_type = "lib"] #![crate_type = "lib"]
#![feature(transmutability)] #![feature(transmutability)]
#![allow(dead_code)] #![allow(dead_code)]
#![allow(incomplete_features)]
mod assert { mod assert {
use std::mem::BikeshedIntrinsicFrom; use std::mem::BikeshedIntrinsicFrom;

1
tests/ui/transmutability/unions/boolish.rs
View File

@ -4,7 +4,6 @@
#![feature(transmutability)] #![feature(transmutability)]
#![feature(marker_trait_attr)] #![feature(marker_trait_attr)]
#![allow(dead_code)] #![allow(dead_code)]
#![allow(incomplete_features)]
mod assert { mod assert {
use std::mem::{Assume, BikeshedIntrinsicFrom}; use std::mem::{Assume, BikeshedIntrinsicFrom};

1
tests/ui/type-alias-impl-trait/issue-65384.rs
View File

@ -1,5 +1,4 @@
#![feature(type_alias_impl_trait)] #![feature(type_alias_impl_trait)]
#![allow(incomplete_features)]
trait MyTrait {} trait MyTrait {}

2
tests/ui/type-alias-impl-trait/issue-65384.stderr
View File

@ -1,5 +1,5 @@
error[E0119]: conflicting implementations of trait `MyTrait` for type `()` error[E0119]: conflicting implementations of trait `MyTrait` for type `()`
--> $DIR/issue-65384.rs:10:1 --> $DIR/issue-65384.rs:9:1
| |
LL | impl MyTrait for () {} LL | impl MyTrait for () {}
| ------------------- first implementation here | ------------------- first implementation here