languages/rust
languages/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust synced 2024-07-21 10:26:41 +00:00
Code Issues Actions 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
parent 7b29381c8a f614eaea2c
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
//@ edition:2021
#![allow(incomplete_features)]
pub trait Foo {
#[allow(async_fn_in_trait)]
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
#![allow(incomplete_features)]
trait MyTrait {
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
--> $DIR/fn-not-async-err.rs:10:5
--> $DIR/fn-not-async-err.rs:8:5
|
LL | fn foo(&self) -> i32 {
| ^^^^^^^^^^^^^^^^^^^^
|
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;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^

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

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

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

@ -1,7 +1,5 @@
//@ edition: 2021
#![allow(incomplete_features)]
trait Foo {
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`
--> $DIR/generics-mismatch.rs:10:18
--> $DIR/generics-mismatch.rs:8:18
|
LL | trait Foo {
| ---

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

@ -1,8 +1,6 @@
//@ check-pass
//@ edition: 2021
#![allow(incomplete_features)]
trait TcpStack {
type Connection<'a>: Sized where Self: '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
//@ edition:2021
#![allow(incomplete_features)]
use std::future::Future;
async fn yield_now() {}

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

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

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

@ -1,8 +1,6 @@
//@ check-pass
//@ edition:2021
#![allow(incomplete_features)]
pub trait SpiDevice {
#[allow(async_fn_in_trait)]
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
//@ check-pass
#![allow(incomplete_features)]
use std::future::Future;
pub trait Pool {
type Conn;

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

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

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

@ -1,5 +1,4 @@
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
// library portion of regression test for #87674
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)]
#![allow(incomplete_features)]
// library portion of testing that `impl Trait<{ expr }>` doesnt
// 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)]
#![allow(incomplete_features)]
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)]
#![allow(incomplete_features)]
pub fn test1<T>() -> [u8; std::mem::size_of::<T>() - 1]
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]:`
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]
| ----- 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]:`
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]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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]:`
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]
| ----- 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]:`
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]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 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)]
#![allow(incomplete_features)]
// 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`
|
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]>) {
| ^^^^^ 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"]
#![feature(const_closures, const_trait_impl, effects)]
#![allow(incomplete_features)]
pub const fn test() {
let cl = const || {};

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

@ -1,5 +1,4 @@
#![feature(dyn_star)]
#![allow(incomplete_features)]
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`
= help: `usize` implements `Display`, `#[feature(dyn_star)]` is likely not enabled; that feature it is currently incomplete
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) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^

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

@ -6,7 +6,6 @@
//@ error-pattern: expected generic lifetime parameter, found `'a`
#![feature(type_alias_impl_trait)]
#![allow(incomplete_features)]
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`
--> $DIR/issue-90014-tait2.rs:27:9
--> $DIR/issue-90014-tait2.rs:26:9
|
LL | type Fut<'a> = impl Future<Output = ()>;
| -- 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
#![feature(lint_reasons)]
#![allow(incomplete_features)]
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
#![allow(incomplete_features)]
pub trait Foo {
async fn woopsie_async(&self) -> String {
42

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

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

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

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

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

@ -1,8 +1,6 @@
//@ check-pass
//@ edition:2021
#![allow(incomplete_features)]
pub trait Foo {
#[allow(async_fn_in_trait)]
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
//@ compile-flags: --crate-type=lib
#![allow(incomplete_features)]
trait Foo {
fn bar() -> impl Sized;
}

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

@ -1,7 +1,5 @@
//@ check-pass
#![allow(incomplete_features)]
trait 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
--> $DIR/method-signature-matches.rs:57:27
--> $DIR/method-signature-matches.rs:55:27
|
LL | fn early<'late, T>(_: &'late ()) {}
| - ^^^^^^^^^
@ -9,7 +9,7 @@ LL | fn early<'late, T>(_: &'late ()) {}
| expected this type parameter
|
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;
| ^^^^^^^^^

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
--> $DIR/method-signature-matches.rs:13:15
--> $DIR/method-signature-matches.rs:11:15
|
LL | fn owo(_: u8) {}
| ^^
@ -8,7 +8,7 @@ LL | fn owo(_: u8) {}
| help: change the parameter type to match the 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;
| ^^

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
--> $DIR/method-signature-matches.rs:24:21
--> $DIR/method-signature-matches.rs:22:21
|
LL | async fn owo(_: u8) {}
| ^^
@ -8,7 +8,7 @@ LL | async fn owo(_: u8) {}
| help: change the parameter type to match the trait: `()`
|
note: type in trait
--> $DIR/method-signature-matches.rs:19:21
--> $DIR/method-signature-matches.rs:17:21
|
LL | async fn owo(x: ()) {}
| ^^

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

@ -1,8 +1,6 @@
//@ edition: 2021
//@ revisions: mismatch mismatch_async too_many too_few lt
#![allow(incomplete_features)]
#[cfg(mismatch)]
trait Uwu {
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
--> $DIR/method-signature-matches.rs:46:5
--> $DIR/method-signature-matches.rs:44:5
|
LL | fn come_on_a_little_more_effort(_: (), _: (), _: ()) -> impl Sized;
| ---------------- 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
--> $DIR/method-signature-matches.rs:35:28
--> $DIR/method-signature-matches.rs:33:28
|
LL | fn calm_down_please() -> impl Sized;
| ------------------------------------ trait requires 0 parameters

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

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

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

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

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

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

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

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

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

@ -1,7 +1,5 @@
// issue #101663
#![allow(incomplete_features)]
use std::fmt::Display;
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
--> $DIR/wf-bounds.rs:14:22
--> $DIR/wf-bounds.rs:12:22
|
LL | fn nya() -> impl Wf<Vec<[u8]>>;
| ^^^^^^^^^^^^^ 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
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]>;
| ^^^^^^^^ doesn't have a size known at compile-time
|
= help: the trait `Sized` is not implemented for `[u8]`
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> {
| ^ 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
--> $DIR/wf-bounds.rs:20:44
--> $DIR/wf-bounds.rs:18:44
|
LL | fn nya3() -> impl Wf<(), Output = impl Wf<Vec<[u8]>>>;
| ^^^^^^^^^^^^^ 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
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>>;
| ^^^^^^^^^^^^^^^^^^^ `T` cannot be formatted with the default formatter
|
= note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
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);
| ^^^^^^^ required by this bound in `NeedsDisplay`

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

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

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

@ -1,4 +1,3 @@
#![feature(lazy_type_alias)]
#![allow(incomplete_features)]
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`
|
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>;
| ^^^^ 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`
|
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>;
| ^^^^ 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 {
trait Main {
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
--> $DIR/issue-103052-2.rs:11:22
--> $DIR/issue-103052-2.rs:9:22
|
LL | fn main() -> Something {
| ^^^^^^^^^ the trait `Termination` is not implemented for `Something`
|
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;
| ^^^^^^^^^^^^^^^^^^^^^^^^^ 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
#![feature(type_changing_struct_update)]
#![allow(incomplete_features)]
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
#![feature(type_changing_struct_update)]
#![allow(incomplete_features)]
use std::borrow::Cow;
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)]
#![allow(incomplete_features)]
#[derive(Clone)]
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
--> $DIR/lifetime-update.rs:20:17
--> $DIR/lifetime-update.rs:19:17
|
LL | let s = String::from("hello");
| - 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)]
#![allow(incomplete_features)]
struct Machine<'a, S, M> {
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
--> $DIR/type-generic-update.rs:46:11
--> $DIR/type-generic-update.rs:45:11
|
LL | ..m1
| ^^ expected `Machine<'_, i32, f64>`, found `Machine<'_, f64, f64>`
@ -8,7 +8,7 @@ LL | ..m1
found struct `Machine<'_, f64, _>`
error[E0308]: mismatched types
--> $DIR/type-generic-update.rs:51:11
--> $DIR/type-generic-update.rs:50:11
|
LL | ..m1
| ^^ 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`
--> $DIR/numbers.rs:65:40
--> $DIR/numbers.rs:64:40
|
LL | assert::is_transmutable::< i8, i16>();
| ^^^ The size of `i8` is smaller than the size of `i16`
|
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>()
| --------------- required by a bound in this function
@ -14,13 +14,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i8` is smaller than the size of `u16`
|
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>()
| --------------- required by a bound in this function
@ -29,13 +29,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i8` is smaller than the size of `i32`
|
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>()
| --------------- required by a bound in this function
@ -44,13 +44,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i8` is smaller than the size of `f32`
|
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>()
| --------------- required by a bound in this function
@ -59,13 +59,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i8` is smaller than the size of `u32`
|
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>()
| --------------- required by a bound in this function
@ -74,13 +74,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i8` is smaller than the size of `u64`
|
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>()
| --------------- required by a bound in this function
@ -89,13 +89,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i8` is smaller than the size of `i64`
|
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>()
| --------------- required by a bound in this function
@ -104,13 +104,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i8` is smaller than the size of `f64`
|
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>()
| --------------- required by a bound in this function
@ -119,13 +119,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i8` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -134,13 +134,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i8` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -149,13 +149,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `i16`
|
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>()
| --------------- required by a bound in this function
@ -164,13 +164,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `u16`
|
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>()
| --------------- required by a bound in this function
@ -179,13 +179,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `i32`
|
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>()
| --------------- required by a bound in this function
@ -194,13 +194,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `f32`
|
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>()
| --------------- required by a bound in this function
@ -209,13 +209,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `u32`
|
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>()
| --------------- required by a bound in this function
@ -224,13 +224,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `u64`
|
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>()
| --------------- required by a bound in this function
@ -239,13 +239,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `i64`
|
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>()
| --------------- required by a bound in this function
@ -254,13 +254,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `f64`
|
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>()
| --------------- required by a bound in this function
@ -269,13 +269,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u8` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -284,13 +284,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u8` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -299,13 +299,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i16` is smaller than the size of `i32`
|
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>()
| --------------- required by a bound in this function
@ -314,13 +314,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i16` is smaller than the size of `f32`
|
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>()
| --------------- required by a bound in this function
@ -329,13 +329,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i16` is smaller than the size of `u32`
|
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>()
| --------------- required by a bound in this function
@ -344,13 +344,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i16` is smaller than the size of `u64`
|
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>()
| --------------- required by a bound in this function
@ -359,13 +359,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i16` is smaller than the size of `i64`
|
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>()
| --------------- required by a bound in this function
@ -374,13 +374,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i16` is smaller than the size of `f64`
|
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>()
| --------------- required by a bound in this function
@ -389,13 +389,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i16` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -404,13 +404,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i16` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -419,13 +419,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u16` is smaller than the size of `i32`
|
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>()
| --------------- required by a bound in this function
@ -434,13 +434,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u16` is smaller than the size of `f32`
|
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>()
| --------------- required by a bound in this function
@ -449,13 +449,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u16` is smaller than the size of `u32`
|
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>()
| --------------- required by a bound in this function
@ -464,13 +464,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u16` is smaller than the size of `u64`
|
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>()
| --------------- required by a bound in this function
@ -479,13 +479,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u16` is smaller than the size of `i64`
|
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>()
| --------------- required by a bound in this function
@ -494,13 +494,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u16` is smaller than the size of `f64`
|
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>()
| --------------- required by a bound in this function
@ -509,13 +509,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u16` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -524,13 +524,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u16` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -539,13 +539,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i32` is smaller than the size of `u64`
|
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>()
| --------------- required by a bound in this function
@ -554,13 +554,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i32` is smaller than the size of `i64`
|
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>()
| --------------- required by a bound in this function
@ -569,13 +569,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i32` is smaller than the size of `f64`
|
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>()
| --------------- required by a bound in this function
@ -584,13 +584,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i32` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -599,13 +599,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i32` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -614,13 +614,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `f32` is smaller than the size of `u64`
|
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>()
| --------------- required by a bound in this function
@ -629,13 +629,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `f32` is smaller than the size of `i64`
|
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>()
| --------------- required by a bound in this function
@ -644,13 +644,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `f32` is smaller than the size of `f64`
|
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>()
| --------------- required by a bound in this function
@ -659,13 +659,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `f32` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -674,13 +674,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `f32` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -689,13 +689,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u32` is smaller than the size of `u64`
|
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>()
| --------------- required by a bound in this function
@ -704,13 +704,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u32` is smaller than the size of `i64`
|
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>()
| --------------- required by a bound in this function
@ -719,13 +719,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u32` is smaller than the size of `f64`
|
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>()
| --------------- required by a bound in this function
@ -734,13 +734,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u32` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -749,13 +749,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u32` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -764,13 +764,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u64` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -779,13 +779,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u64` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -794,13 +794,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i64` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -809,13 +809,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i64` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -824,13 +824,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `f64` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -839,13 +839,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `f64` is smaller than the size of `i128`
|
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>()
| --------------- 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`
--> $DIR/numbers.rs:65:40
--> $DIR/numbers.rs:64:40
|
LL | assert::is_transmutable::< i8, i16>();
| ^^^ The size of `i8` is smaller than the size of `i16`
|
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>()
| --------------- required by a bound in this function
@ -14,13 +14,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i8` is smaller than the size of `u16`
|
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>()
| --------------- required by a bound in this function
@ -29,13 +29,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i8` is smaller than the size of `i32`
|
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>()
| --------------- required by a bound in this function
@ -44,13 +44,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i8` is smaller than the size of `f32`
|
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>()
| --------------- required by a bound in this function
@ -59,13 +59,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i8` is smaller than the size of `u32`
|
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>()
| --------------- required by a bound in this function
@ -74,13 +74,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i8` is smaller than the size of `u64`
|
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>()
| --------------- required by a bound in this function
@ -89,13 +89,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i8` is smaller than the size of `i64`
|
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>()
| --------------- required by a bound in this function
@ -104,13 +104,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i8` is smaller than the size of `f64`
|
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>()
| --------------- required by a bound in this function
@ -119,13 +119,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i8` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -134,13 +134,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i8` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -149,13 +149,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `i16`
|
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>()
| --------------- required by a bound in this function
@ -164,13 +164,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `u16`
|
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>()
| --------------- required by a bound in this function
@ -179,13 +179,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `i32`
|
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>()
| --------------- required by a bound in this function
@ -194,13 +194,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `f32`
|
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>()
| --------------- required by a bound in this function
@ -209,13 +209,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `u32`
|
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>()
| --------------- required by a bound in this function
@ -224,13 +224,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `u64`
|
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>()
| --------------- required by a bound in this function
@ -239,13 +239,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `i64`
|
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>()
| --------------- required by a bound in this function
@ -254,13 +254,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u8` is smaller than the size of `f64`
|
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>()
| --------------- required by a bound in this function
@ -269,13 +269,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u8` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -284,13 +284,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u8` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -299,13 +299,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i16` is smaller than the size of `i32`
|
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>()
| --------------- required by a bound in this function
@ -314,13 +314,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i16` is smaller than the size of `f32`
|
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>()
| --------------- required by a bound in this function
@ -329,13 +329,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i16` is smaller than the size of `u32`
|
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>()
| --------------- required by a bound in this function
@ -344,13 +344,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i16` is smaller than the size of `u64`
|
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>()
| --------------- required by a bound in this function
@ -359,13 +359,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i16` is smaller than the size of `i64`
|
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>()
| --------------- required by a bound in this function
@ -374,13 +374,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i16` is smaller than the size of `f64`
|
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>()
| --------------- required by a bound in this function
@ -389,13 +389,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i16` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -404,13 +404,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i16` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -419,13 +419,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u16` is smaller than the size of `i32`
|
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>()
| --------------- required by a bound in this function
@ -434,13 +434,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u16` is smaller than the size of `f32`
|
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>()
| --------------- required by a bound in this function
@ -449,13 +449,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u16` is smaller than the size of `u32`
|
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>()
| --------------- required by a bound in this function
@ -464,13 +464,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u16` is smaller than the size of `u64`
|
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>()
| --------------- required by a bound in this function
@ -479,13 +479,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u16` is smaller than the size of `i64`
|
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>()
| --------------- required by a bound in this function
@ -494,13 +494,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u16` is smaller than the size of `f64`
|
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>()
| --------------- required by a bound in this function
@ -509,13 +509,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u16` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -524,13 +524,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u16` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -539,13 +539,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i32` is smaller than the size of `u64`
|
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>()
| --------------- required by a bound in this function
@ -554,13 +554,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i32` is smaller than the size of `i64`
|
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>()
| --------------- required by a bound in this function
@ -569,13 +569,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `i32` is smaller than the size of `f64`
|
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>()
| --------------- required by a bound in this function
@ -584,13 +584,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i32` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -599,13 +599,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i32` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -614,13 +614,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `f32` is smaller than the size of `u64`
|
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>()
| --------------- required by a bound in this function
@ -629,13 +629,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `f32` is smaller than the size of `i64`
|
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>()
| --------------- required by a bound in this function
@ -644,13 +644,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `f32` is smaller than the size of `f64`
|
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>()
| --------------- required by a bound in this function
@ -659,13 +659,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `f32` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -674,13 +674,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `f32` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -689,13 +689,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u32` is smaller than the size of `u64`
|
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>()
| --------------- required by a bound in this function
@ -704,13 +704,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u32` is smaller than the size of `i64`
|
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>()
| --------------- required by a bound in this function
@ -719,13 +719,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^ The size of `u32` is smaller than the size of `f64`
|
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>()
| --------------- required by a bound in this function
@ -734,13 +734,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u32` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -749,13 +749,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u32` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -764,13 +764,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u64` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -779,13 +779,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `u64` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -794,13 +794,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i64` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -809,13 +809,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `i64` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function
@ -824,13 +824,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `f64` is smaller than the size of `u128`
|
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>()
| --------------- required by a bound in this function
@ -839,13 +839,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
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>();
| ^^^^ The size of `f64` is smaller than the size of `i128`
|
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>()
| --------------- required by a bound in this function

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

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

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

@ -4,7 +4,6 @@
#![feature(transmutability)]
#![feature(marker_trait_attr)]
#![allow(dead_code)]
#![allow(incomplete_features)]
mod assert {
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)]
#![allow(incomplete_features)]
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 `()`
--> $DIR/issue-65384.rs:10:1
--> $DIR/issue-65384.rs:9:1
|
LL | impl MyTrait for () {}
| ------------------- first implementation here