bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Auto merge of #140043 - ChrisDenton:rollup-vwf0s9j, r=ChrisDenton

Browse source 
Rollup of 8 pull requests

Successful merges:

 - #138934 (support config extensions)
 - #139091 (Rewrite on_unimplemented format string parser.)
 - #139753 (Make `#[naked]` an unsafe attribute)
 - #139762 (Don't assemble non-env/bound candidates if projection is rigid)
 - #139834 (Don't canonicalize crate paths)
 - #139868 (Move `pal::env` to `std::sys::env_consts`)
 - #139978 (Add citool command for generating a test dashboard)
 - #139995 (Clean UI tests 4 of n)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2025-04-20 02:08:02 +00:00
commit 49e5e4e3a5
138 changed files with 2861 additions and 1624 deletions
Download patch file Download diff file Expand all files Collapse all files

4
tests/assembly/naked-functions/aarch64-naked-fn-no-bti-prolog.rs
View file

@ -13,8 +13,8 @@ use std::arch::naked_asm;
// LLVM implements this via making sure of that, even for functions with the naked attribute.
// So, we must emit an appropriate instruction instead!
#[no_mangle]
#[naked]
pub unsafe extern "C" fn _hlt() -> ! {
#[unsafe(naked)]
pub extern "C" fn _hlt() -> ! {
// CHECK-NOT: hint #34
// CHECK: hlt #0x1
naked_asm!("hlt #1")

4
tests/assembly/naked-functions/aix.rs
View file

@ -29,7 +29,7 @@ use minicore::*;
// CHECK-LABEL: blr:
// CHECK: blr
#[no_mangle]
#[naked]
unsafe extern "C" fn blr() {
#[unsafe(naked)]
extern "C" fn blr() {
naked_asm!("blr")
}

60
tests/assembly/naked-functions/wasm32.rs
View file

@ -22,8 +22,8 @@ use minicore::*;
// CHECK-NOT: .size
// CHECK: end_function
#[no_mangle]
#[naked]
unsafe extern "C" fn nop() {
#[unsafe(naked)]
extern "C" fn nop() {
naked_asm!("nop")
}
@ -34,11 +34,11 @@ unsafe extern "C" fn nop() {
// CHECK-NOT: .size
// CHECK: end_function
#[no_mangle]
#[naked]
#[unsafe(naked)]
#[linkage = "weak"]
// wasm functions cannot be aligned, so this has no effect
#[repr(align(32))]
unsafe extern "C" fn weak_aligned_nop() {
extern "C" fn weak_aligned_nop() {
naked_asm!("nop")
}
@ -51,48 +51,48 @@ unsafe extern "C" fn weak_aligned_nop() {
//
// CHECK-NEXT: end_function
#[no_mangle]
#[naked]
unsafe extern "C" fn fn_i8_i8(num: i8) -> i8 {
#[unsafe(naked)]
extern "C" fn fn_i8_i8(num: i8) -> i8 {
naked_asm!("local.get 0", "local.get 0", "i32.mul")
}
// CHECK-LABEL: fn_i8_i8_i8:
// CHECK: .functype fn_i8_i8_i8 (i32, i32) -> (i32)
#[no_mangle]
#[naked]
unsafe extern "C" fn fn_i8_i8_i8(a: i8, b: i8) -> i8 {
#[unsafe(naked)]
extern "C" fn fn_i8_i8_i8(a: i8, b: i8) -> i8 {
naked_asm!("local.get 1", "local.get 0", "i32.mul")
}
// CHECK-LABEL: fn_unit_i8:
// CHECK: .functype fn_unit_i8 () -> (i32)
#[no_mangle]
#[naked]
unsafe extern "C" fn fn_unit_i8() -> i8 {
#[unsafe(naked)]
extern "C" fn fn_unit_i8() -> i8 {
naked_asm!("i32.const 42")
}
// CHECK-LABEL: fn_i8_unit:
// CHECK: .functype fn_i8_unit (i32) -> ()
#[no_mangle]
#[naked]
unsafe extern "C" fn fn_i8_unit(_: i8) {
#[unsafe(naked)]
extern "C" fn fn_i8_unit(_: i8) {
naked_asm!("nop")
}
// CHECK-LABEL: fn_i32_i32:
// CHECK: .functype fn_i32_i32 (i32) -> (i32)
#[no_mangle]
#[naked]
unsafe extern "C" fn fn_i32_i32(num: i32) -> i32 {
#[unsafe(naked)]
extern "C" fn fn_i32_i32(num: i32) -> i32 {
naked_asm!("local.get 0", "local.get 0", "i32.mul")
}
// CHECK-LABEL: fn_i64_i64:
// CHECK: .functype fn_i64_i64 (i64) -> (i64)
#[no_mangle]
#[naked]
unsafe extern "C" fn fn_i64_i64(num: i64) -> i64 {
#[unsafe(naked)]
extern "C" fn fn_i64_i64(num: i64) -> i64 {
naked_asm!("local.get 0", "local.get 0", "i64.mul")
}
@ -101,8 +101,8 @@ unsafe extern "C" fn fn_i64_i64(num: i64) -> i64 {
// wasm64-unknown: .functype fn_i128_i128 (i64, i64, i64) -> ()
#[allow(improper_ctypes_definitions)]
#[no_mangle]
#[naked]
unsafe extern "C" fn fn_i128_i128(num: i128) -> i128 {
#[unsafe(naked)]
extern "C" fn fn_i128_i128(num: i128) -> i128 {
naked_asm!(
"local.get 0",
"local.get 2",
@ -117,8 +117,8 @@ unsafe extern "C" fn fn_i128_i128(num: i128) -> i128 {
// wasm32-wasip1: .functype fn_f128_f128 (i32, i64, i64) -> ()
// wasm64-unknown: .functype fn_f128_f128 (i64, i64, i64) -> ()
#[no_mangle]
#[naked]
unsafe extern "C" fn fn_f128_f128(num: f128) -> f128 {
#[unsafe(naked)]
extern "C" fn fn_f128_f128(num: f128) -> f128 {
naked_asm!(
"local.get 0",
"local.get 2",
@ -139,8 +139,8 @@ struct Compound {
// wasm32-wasip1: .functype fn_compound_compound (i32, i32) -> ()
// wasm64-unknown: .functype fn_compound_compound (i64, i64) -> ()
#[no_mangle]
#[naked]
unsafe extern "C" fn fn_compound_compound(_: Compound) -> Compound {
#[unsafe(naked)]
extern "C" fn fn_compound_compound(_: Compound) -> Compound {
// this is the wasm32-wasip1 assembly
naked_asm!(
"local.get 0",
@ -160,8 +160,8 @@ struct WrapperI32(i32);
// CHECK-LABEL: fn_wrapperi32_wrapperi32:
// CHECK: .functype fn_wrapperi32_wrapperi32 (i32) -> (i32)
#[no_mangle]
#[naked]
unsafe extern "C" fn fn_wrapperi32_wrapperi32(_: WrapperI32) -> WrapperI32 {
#[unsafe(naked)]
extern "C" fn fn_wrapperi32_wrapperi32(_: WrapperI32) -> WrapperI32 {
naked_asm!("local.get 0")
}
@ -171,8 +171,8 @@ struct WrapperI64(i64);
// CHECK-LABEL: fn_wrapperi64_wrapperi64:
// CHECK: .functype fn_wrapperi64_wrapperi64 (i64) -> (i64)
#[no_mangle]
#[naked]
unsafe extern "C" fn fn_wrapperi64_wrapperi64(_: WrapperI64) -> WrapperI64 {
#[unsafe(naked)]
extern "C" fn fn_wrapperi64_wrapperi64(_: WrapperI64) -> WrapperI64 {
naked_asm!("local.get 0")
}
@ -182,8 +182,8 @@ struct WrapperF32(f32);
// CHECK-LABEL: fn_wrapperf32_wrapperf32:
// CHECK: .functype fn_wrapperf32_wrapperf32 (f32) -> (f32)
#[no_mangle]
#[naked]
unsafe extern "C" fn fn_wrapperf32_wrapperf32(_: WrapperF32) -> WrapperF32 {
#[unsafe(naked)]
extern "C" fn fn_wrapperf32_wrapperf32(_: WrapperF32) -> WrapperF32 {
naked_asm!("local.get 0")
}
@ -193,7 +193,7 @@ struct WrapperF64(f64);
// CHECK-LABEL: fn_wrapperf64_wrapperf64:
// CHECK: .functype fn_wrapperf64_wrapperf64 (f64) -> (f64)
#[no_mangle]
#[naked]
unsafe extern "C" fn fn_wrapperf64_wrapperf64(_: WrapperF64) -> WrapperF64 {
#[unsafe(naked)]
extern "C" fn fn_wrapperf64_wrapperf64(_: WrapperF64) -> WrapperF64 {
naked_asm!("local.get 0")
}

4
tests/assembly/naked-functions/x86_64-naked-fn-no-cet-prolog.rs
View file

@ -13,8 +13,8 @@ use std::arch::naked_asm;
// works by using an instruction for each possible landing site,
// and LLVM implements this via making sure of that.
#[no_mangle]
#[naked]
pub unsafe extern "sysv64" fn will_halt() -> ! {
#[unsafe(naked)]
pub extern "sysv64" fn will_halt() -> ! {
// CHECK-NOT: endbr{{32|64}}
// CHECK: hlt
naked_asm!("hlt")

6
tests/codegen/cffi/c-variadic-naked.rs
View file

@ -8,11 +8,9 @@
#![feature(naked_functions)]
#![no_std]
#[naked]
#[unsafe(naked)]
pub unsafe extern "C" fn c_variadic(_: usize, _: ...) {
// CHECK-NOT: va_start
// CHECK-NOT: alloca
core::arch::naked_asm! {
"ret",
}
core::arch::naked_asm!("ret")
}

4
tests/codegen/naked-asan.rs
View file

@ -13,10 +13,10 @@ pub fn caller() {
}
// CHECK: declare x86_intrcc void @page_fault_handler(ptr {{.*}}, i64{{.*}}){{.*}}#[[ATTRS:[0-9]+]]
#[naked]
#[unsafe(naked)]
#[no_mangle]
pub extern "x86-interrupt" fn page_fault_handler(_: u64, _: u64) {
unsafe { core::arch::naked_asm!("ud2") };
core::arch::naked_asm!("ud2")
}
// CHECK: #[[ATTRS]] =

6
tests/codegen/naked-fn/aligned.rs
View file

@ -10,8 +10,8 @@ use std::arch::naked_asm;
// CHECK-LABEL: naked_empty:
#[repr(align(16))]
#[no_mangle]
#[naked]
pub unsafe extern "C" fn naked_empty() {
#[unsafe(naked)]
pub extern "C" fn naked_empty() {
// CHECK: ret
naked_asm!("ret");
naked_asm!("ret")
}

46
tests/codegen/naked-fn/generics.rs
View file

@ -28,21 +28,19 @@ fn test(x: u64) {
// CHECK: add rax, 1
// CHECK: add rax, 42
#[naked]
#[unsafe(naked)]
pub extern "C" fn using_const_generics<const N: u64>(x: u64) -> u64 {
const M: u64 = 42;
unsafe {
naked_asm!(
"xor rax, rax",
"add rax, rdi",
"add rax, {}",
"add rax, {}",
"ret",
const N,
const M,
)
}
naked_asm!(
"xor rax, rax",
"add rax, rdi",
"add rax, {}",
"add rax, {}",
"ret",
const N,
const M,
)
}
trait Invert {
@ -60,16 +58,14 @@ impl Invert for i64 {
// CHECK: call
// CHECK: ret
#[naked]
#[unsafe(naked)]
#[no_mangle]
pub extern "C" fn generic_function<T: Invert>(x: i64) -> i64 {
unsafe {
naked_asm!(
"call {}",
"ret",
sym <T as Invert>::invert,
)
}
naked_asm!(
"call {}",
"ret",
sym <T as Invert>::invert,
)
}
#[derive(Copy, Clone)]
@ -81,10 +77,10 @@ struct Foo(u64);
// CHECK: mov rax, rdi
impl Foo {
#[naked]
#[unsafe(naked)]
#[no_mangle]
extern "C" fn method(self) -> u64 {
unsafe { naked_asm!("mov rax, rdi", "ret") }
naked_asm!("mov rax, rdi", "ret")
}
}
@ -97,10 +93,10 @@ trait Bar {
}
impl Bar for Foo {
#[naked]
#[unsafe(naked)]
#[no_mangle]
extern "C" fn trait_method(self) -> u64 {
unsafe { naked_asm!("mov rax, rdi", "ret") }
naked_asm!("mov rax, rdi", "ret")
}
}
@ -109,7 +105,7 @@ impl Bar for Foo {
// CHECK: lea rax, [rdi + rsi]
// this previously ICE'd, see https://github.com/rust-lang/rust/issues/124375
#[naked]
#[unsafe(naked)]
#[no_mangle]
pub unsafe extern "C" fn naked_with_args_and_return(a: isize, b: isize) -> isize {
naked_asm!("lea rax, [rdi + rsi]", "ret");

12
tests/codegen/naked-fn/instruction-set.rs
View file

@ -20,8 +20,8 @@ use minicore::*;
// arm-mode: .arm
// thumb-mode: .thumb
#[no_mangle]
#[naked]
unsafe extern "C" fn test_unspecified() {
#[unsafe(naked)]
extern "C" fn test_unspecified() {
naked_asm!("bx lr");
}
@ -33,9 +33,9 @@ unsafe extern "C" fn test_unspecified() {
// arm-mode: .arm
// thumb-mode: .thumb
#[no_mangle]
#[naked]
#[unsafe(naked)]
#[instruction_set(arm::t32)]
unsafe extern "C" fn test_thumb() {
extern "C" fn test_thumb() {
naked_asm!("bx lr");
}
@ -46,8 +46,8 @@ unsafe extern "C" fn test_thumb() {
// arm-mode: .arm
// thumb-mode: .thumb
#[no_mangle]
#[naked]
#[unsafe(naked)]
#[instruction_set(arm::a32)]
unsafe extern "C" fn test_arm() {
extern "C" fn test_arm() {
naked_asm!("bx lr");
}

16
tests/codegen/naked-fn/min-function-alignment.rs
View file

@ -9,24 +9,24 @@
//
// CHECK: .balign 16
#[no_mangle]
#[naked]
pub unsafe extern "C" fn naked_no_explicit_align() {
#[unsafe(naked)]
pub extern "C" fn naked_no_explicit_align() {
core::arch::naked_asm!("ret")
}
// CHECK: .balign 16
#[no_mangle]
#[repr(align(8))]
#[naked]
pub unsafe extern "C" fn naked_lower_align() {
#[unsafe(naked)]
pub extern "C" fn naked_lower_align() {
core::arch::naked_asm!("ret")
}
// CHECK: .balign 32
#[no_mangle]
#[repr(align(32))]
#[naked]
pub unsafe extern "C" fn naked_higher_align() {
#[unsafe(naked)]
pub extern "C" fn naked_higher_align() {
core::arch::naked_asm!("ret")
}
@ -38,7 +38,7 @@ pub unsafe extern "C" fn naked_higher_align() {
// CHECK: .balign 16
#[no_mangle]
#[cold]
#[naked]
pub unsafe extern "C" fn no_explicit_align_cold() {
#[unsafe(naked)]
pub extern "C" fn no_explicit_align_cold() {
core::arch::naked_asm!("ret")
}

16
tests/codegen/naked-fn/naked-functions.rs
View file

@ -60,8 +60,8 @@ use minicore::*;
// linux,win: .att_syntax
#[no_mangle]
#[naked]
pub unsafe extern "C" fn naked_empty() {
#[unsafe(naked)]
pub extern "C" fn naked_empty() {
#[cfg(not(all(target_arch = "arm", target_feature = "thumb-mode")))]
naked_asm!("ret");
@ -114,8 +114,8 @@ pub unsafe extern "C" fn naked_empty() {
// linux,win: .att_syntax
#[no_mangle]
#[naked]
pub unsafe extern "C" fn naked_with_args_and_return(a: isize, b: isize) -> isize {
#[unsafe(naked)]
pub extern "C" fn naked_with_args_and_return(a: isize, b: isize) -> isize {
#[cfg(any(target_os = "windows", target_os = "linux"))]
{
naked_asm!("lea rax, [rdi + rsi]", "ret")
@ -138,9 +138,9 @@ pub unsafe extern "C" fn naked_with_args_and_return(a: isize, b: isize) -> isize
// thumb: .pushsection .text.some_different_name,\22ax\22, %progbits
// CHECK-LABEL: test_link_section:
#[no_mangle]
#[naked]
#[unsafe(naked)]
#[link_section = ".text.some_different_name"]
pub unsafe extern "C" fn test_link_section() {
pub extern "C" fn test_link_section() {
#[cfg(not(all(target_arch = "arm", target_feature = "thumb-mode")))]
naked_asm!("ret");
@ -159,7 +159,7 @@ pub unsafe extern "C" fn test_link_section() {
// win_i686-LABEL: @fastcall_cc@4:
#[cfg(target_os = "windows")]
#[no_mangle]
#[naked]
pub unsafe extern "fastcall" fn fastcall_cc(x: i32) -> i32 {
#[unsafe(naked)]
pub extern "fastcall" fn fastcall_cc(x: i32) -> i32 {
naked_asm!("ret");
}

20
tests/crashes/130627.rs
View file

@ -1,20 +0,0 @@
//@ known-bug: #130627
#![feature(trait_alias)]
trait Test {}
#[diagnostic::on_unimplemented(
message="message",
label="label",
note="note"
)]
trait Alias = Test;
// Use trait alias as bound on type parameter.
fn foo<T: Alias>(v: &T) {
}
pub fn main() {
foo(&1);
}

6
tests/run-make/crate-loading-multiple-candidates/crateresolve1-1.rs Normal file
View file

@ -0,0 +1,6 @@
#![crate_name = "crateresolve1"]
#![crate_type = "lib"]
pub fn f() -> isize {
10
}

6
tests/run-make/crate-loading-multiple-candidates/crateresolve1-2.rs Normal file
View file

@ -0,0 +1,6 @@
#![crate_name = "crateresolve1"]
#![crate_type = "lib"]
pub fn f() -> isize {
20
}

3
tests/run-make/crate-loading-multiple-candidates/multiple-candidates.rs Normal file
View file

@ -0,0 +1,3 @@
extern crate crateresolve1;
fn main() {}

12
tests/run-make/crate-loading-multiple-candidates/multiple-candidates.stderr Normal file
View file

@ -0,0 +1,12 @@
error[E0464]: multiple candidates for `rlib` dependency `crateresolve1` found
--> multiple-candidates.rs:1:1
|
LL | extern crate crateresolve1;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: candidate #1: ./mylibs/libcrateresolve1-1.rlib
= note: candidate #2: ./mylibs/libcrateresolve1-2.rlib
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0464`.

34
tests/run-make/crate-loading-multiple-candidates/rmake.rs Normal file
View file

@ -0,0 +1,34 @@
//@ needs-symlink
//@ ignore-cross-compile
// Tests that the multiple candidate dependencies diagnostic prints relative
// paths if a relative library path was passed in.
use run_make_support::{bare_rustc, diff, rfs, rustc};
fn main() {
// Check that relative paths are preserved in the diagnostic
rfs::create_dir("mylibs");
rustc().input("crateresolve1-1.rs").out_dir("mylibs").extra_filename("-1").run();
rustc().input("crateresolve1-2.rs").out_dir("mylibs").extra_filename("-2").run();
check("./mylibs");
// Check that symlinks aren't followed when printing the diagnostic
rfs::rename("mylibs", "original");
rfs::symlink_dir("original", "mylibs");
check("./mylibs");
}
fn check(library_path: &str) {
let out = rustc()
.input("multiple-candidates.rs")
.library_search_path(library_path)
.ui_testing()
.run_fail()
.stderr_utf8();
diff()
.expected_file("multiple-candidates.stderr")
.normalize(r"\\", "/")
.actual_text("(rustc)", &out)
.run();
}

20
tests/run-make/naked-symbol-visibility/a_rust_dylib.rs
View file

@ -26,9 +26,9 @@ extern "C" fn private_vanilla() -> u32 {
42
}
#[naked]
#[unsafe(naked)]
extern "C" fn private_naked() -> u32 {
unsafe { naked_asm!("mov rax, 42", "ret") }
naked_asm!("mov rax, 42", "ret")
}
#[no_mangle]
@ -36,19 +36,19 @@ pub extern "C" fn public_vanilla() -> u32 {
42
}
#[naked]
#[unsafe(naked)]
#[no_mangle]
pub extern "C" fn public_naked_nongeneric() -> u32 {
unsafe { naked_asm!("mov rax, 42", "ret") }
naked_asm!("mov rax, 42", "ret")
}
pub extern "C" fn public_vanilla_generic<T: TraitWithConst>() -> u32 {
T::COUNT
}
#[naked]
#[unsafe(naked)]
pub extern "C" fn public_naked_generic<T: TraitWithConst>() -> u32 {
unsafe { naked_asm!("mov rax, {}", "ret", const T::COUNT) }
naked_asm!("mov rax, {}", "ret", const T::COUNT)
}
#[linkage = "external"]
@ -56,10 +56,10 @@ extern "C" fn vanilla_external_linkage() -> u32 {
42
}
#[naked]
#[unsafe(naked)]
#[linkage = "external"]
extern "C" fn naked_external_linkage() -> u32 {
unsafe { naked_asm!("mov rax, 42", "ret") }
naked_asm!("mov rax, 42", "ret")
}
#[cfg(not(windows))]
@ -68,11 +68,11 @@ extern "C" fn vanilla_weak_linkage() -> u32 {
42
}
#[naked]
#[unsafe(naked)]
#[cfg(not(windows))]
#[linkage = "weak"]
extern "C" fn naked_weak_linkage() -> u32 {
unsafe { naked_asm!("mov rax, 42", "ret") }
naked_asm!("mov rax, 42", "ret")
}
// functions that are declared in an `extern "C"` block are currently not exported

10
tests/ui/argument-suggestions/exotic-calls.rs
View file

@ -1,8 +1,18 @@
//! Checks variations of E0057, which is the incorrect number of agruments passed into a closure
//@ check-fail
fn foo<T: Fn()>(t: T) {
t(1i32);
//~^ ERROR function takes 0 arguments but 1 argument was supplied
}
/// Regression test for <https://github.com/rust-lang/rust/issues/16939>
fn foo2<T: Fn()>(f: T) {
|t| f(t);
//~^ ERROR function takes 0 arguments but 1 argument was supplied
}
fn bar(t: impl Fn()) {
t(1i32);
//~^ ERROR function takes 0 arguments but 1 argument was supplied

35
tests/ui/argument-suggestions/exotic-calls.stderr
View file

@ -1,11 +1,11 @@
error[E0057]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/exotic-calls.rs:2:5
--> $DIR/exotic-calls.rs:6:5
|
LL | t(1i32);
| ^ ---- unexpected argument of type `i32`
|
note: callable defined here
--> $DIR/exotic-calls.rs:1:11
--> $DIR/exotic-calls.rs:5:11
|
LL | fn foo<T: Fn()>(t: T) {
| ^^^^
@ -16,13 +16,30 @@ LL + t();
|
error[E0057]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/exotic-calls.rs:7:5
--> $DIR/exotic-calls.rs:12:9
|
LL | |t| f(t);
| ^ - unexpected argument
|
note: callable defined here
--> $DIR/exotic-calls.rs:11:12
|
LL | fn foo2<T: Fn()>(f: T) {
| ^^^^
help: remove the extra argument
|
LL - |t| f(t);
LL + |t| f();
|
error[E0057]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/exotic-calls.rs:17:5
|
LL | t(1i32);
| ^ ---- unexpected argument of type `i32`
|
note: type parameter defined here
--> $DIR/exotic-calls.rs:6:11
--> $DIR/exotic-calls.rs:16:11
|
LL | fn bar(t: impl Fn()) {
| ^^^^^^^^^
@ -33,13 +50,13 @@ LL + t();
|
error[E0057]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/exotic-calls.rs:16:5
--> $DIR/exotic-calls.rs:26:5
|
LL | baz()(1i32)
| ^^^^^ ---- unexpected argument of type `i32`
|
note: opaque type defined here
--> $DIR/exotic-calls.rs:11:13
--> $DIR/exotic-calls.rs:21:13
|
LL | fn baz() -> impl Fn() {
| ^^^^^^^^^
@ -50,13 +67,13 @@ LL + baz()()
|
error[E0057]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/exotic-calls.rs:22:5
--> $DIR/exotic-calls.rs:32:5
|
LL | x(1i32);
| ^ ---- unexpected argument of type `i32`
|
note: closure defined here
--> $DIR/exotic-calls.rs:21:13
--> $DIR/exotic-calls.rs:31:13
|
LL | let x = || {};
| ^^
@ -66,6 +83,6 @@ LL - x(1i32);
LL + x();
|
error: aborting due to 4 previous errors
error: aborting due to 5 previous errors
For more information about this error, try `rustc --explain E0057`.

16
tests/ui/asm/naked-asm-outside-naked-fn.rs
View file

@ -12,24 +12,24 @@ fn main() {
test1();
}
#[naked]
#[unsafe(naked)]
extern "C" fn test1() {
unsafe { naked_asm!("") }
naked_asm!("")
}
extern "C" fn test2() {
unsafe { naked_asm!("") }
//~^ ERROR the `naked_asm!` macro can only be used in functions marked with `#[naked]`
naked_asm!("")
//~^ ERROR the `naked_asm!` macro can only be used in functions marked with `#[unsafe(naked)]`
}
extern "C" fn test3() {
unsafe { (|| naked_asm!(""))() }
//~^ ERROR the `naked_asm!` macro can only be used in functions marked with `#[naked]`
(|| naked_asm!(""))()
//~^ ERROR the `naked_asm!` macro can only be used in functions marked with `#[unsafe(naked)]`
}
fn test4() {
async move {
unsafe { naked_asm!("") } ;
//~^ ERROR the `naked_asm!` macro can only be used in functions marked with `#[naked]`
naked_asm!("");
//~^ ERROR the `naked_asm!` macro can only be used in functions marked with `#[unsafe(naked)]`
};
}

24
tests/ui/asm/naked-asm-outside-naked-fn.stderr
View file

@ -1,20 +1,20 @@
error: the `naked_asm!` macro can only be used in functions marked with `#[naked]`
--> $DIR/naked-asm-outside-naked-fn.rs:21:14
error: the `naked_asm!` macro can only be used in functions marked with `#[unsafe(naked)]`
--> $DIR/naked-asm-outside-naked-fn.rs:21:5
|
LL | unsafe { naked_asm!("") }
| ^^^^^^^^^^^^^^
LL | naked_asm!("")
| ^^^^^^^^^^^^^^
error: the `naked_asm!` macro can only be used in functions marked with `#[naked]`
--> $DIR/naked-asm-outside-naked-fn.rs:26:18
error: the `naked_asm!` macro can only be used in functions marked with `#[unsafe(naked)]`
--> $DIR/naked-asm-outside-naked-fn.rs:26:9
|
LL | unsafe { (|| naked_asm!(""))() }
| ^^^^^^^^^^^^^^
LL | (|| naked_asm!(""))()
| ^^^^^^^^^^^^^^
error: the `naked_asm!` macro can only be used in functions marked with `#[naked]`
--> $DIR/naked-asm-outside-naked-fn.rs:32:19
error: the `naked_asm!` macro can only be used in functions marked with `#[unsafe(naked)]`
--> $DIR/naked-asm-outside-naked-fn.rs:32:9
|
LL | unsafe { naked_asm!("") } ;
| ^^^^^^^^^^^^^^
LL | naked_asm!("");
| ^^^^^^^^^^^^^^
error: aborting due to 3 previous errors

6
tests/ui/asm/naked-functions-ffi.rs
View file

@ -5,11 +5,9 @@
use std::arch::naked_asm;
#[naked]
#[unsafe(naked)]
pub extern "C" fn naked(p: char) -> u128 {
//~^ WARN uses type `char`
//~| WARN uses type `u128`
unsafe {
naked_asm!("");
}
naked_asm!("")
}

20
tests/ui/asm/naked-functions-inline.rs
View file

@ -4,35 +4,35 @@
use std::arch::naked_asm;
#[naked]
pub unsafe extern "C" fn inline_none() {
#[unsafe(naked)]
pub extern "C" fn inline_none() {
naked_asm!("");
}
#[naked]
#[unsafe(naked)]
#[inline]
//~^ ERROR [E0736]
pub unsafe extern "C" fn inline_hint() {
pub extern "C" fn inline_hint() {
naked_asm!("");
}
#[naked]
#[unsafe(naked)]
#[inline(always)]
//~^ ERROR [E0736]
pub unsafe extern "C" fn inline_always() {
pub extern "C" fn inline_always() {
naked_asm!("");
}
#[naked]
#[unsafe(naked)]
#[inline(never)]
//~^ ERROR [E0736]
pub unsafe extern "C" fn inline_never() {
pub extern "C" fn inline_never() {
naked_asm!("");
}
#[naked]
#[unsafe(naked)]
#[cfg_attr(all(), inline(never))]
//~^ ERROR [E0736]
pub unsafe extern "C" fn conditional_inline_never() {
pub extern "C" fn conditional_inline_never() {
naked_asm!("");
}

32
tests/ui/asm/naked-functions-inline.stderr
View file

@ -1,34 +1,34 @@
error[E0736]: attribute incompatible with `#[naked]`
error[E0736]: attribute incompatible with `#[unsafe(naked)]`
--> $DIR/naked-functions-inline.rs:13:1
|
LL | #[naked]
| -------- function marked with `#[naked]` here
LL | #[unsafe(naked)]
| ---------------- function marked with `#[unsafe(naked)]` here
LL | #[inline]
| ^^^^^^^^^ the `inline` attribute is incompatible with `#[naked]`
| ^^^^^^^^^ the `inline` attribute is incompatible with `#[unsafe(naked)]`
error[E0736]: attribute incompatible with `#[naked]`
error[E0736]: attribute incompatible with `#[unsafe(naked)]`
--> $DIR/naked-functions-inline.rs:20:1
|
LL | #[naked]
| -------- function marked with `#[naked]` here
LL | #[unsafe(naked)]
| ---------------- function marked with `#[unsafe(naked)]` here
LL | #[inline(always)]
| ^^^^^^^^^^^^^^^^^ the `inline` attribute is incompatible with `#[naked]`
| ^^^^^^^^^^^^^^^^^ the `inline` attribute is incompatible with `#[unsafe(naked)]`
error[E0736]: attribute incompatible with `#[naked]`
error[E0736]: attribute incompatible with `#[unsafe(naked)]`
--> $DIR/naked-functions-inline.rs:27:1
|
LL | #[naked]
| -------- function marked with `#[naked]` here
LL | #[unsafe(naked)]
| ---------------- function marked with `#[unsafe(naked)]` here
LL | #[inline(never)]
| ^^^^^^^^^^^^^^^^ the `inline` attribute is incompatible with `#[naked]`
| ^^^^^^^^^^^^^^^^ the `inline` attribute is incompatible with `#[unsafe(naked)]`
error[E0736]: attribute incompatible with `#[naked]`
error[E0736]: attribute incompatible with `#[unsafe(naked)]`
--> $DIR/naked-functions-inline.rs:34:19
|
LL | #[naked]
| -------- function marked with `#[naked]` here
LL | #[unsafe(naked)]
| ---------------- function marked with `#[unsafe(naked)]` here
LL | #[cfg_attr(all(), inline(never))]
| ^^^^^^^^^^^^^ the `inline` attribute is incompatible with `#[naked]`
| ^^^^^^^^^^^^^ the `inline` attribute is incompatible with `#[unsafe(naked)]`
error: aborting due to 4 previous errors

8
tests/ui/asm/naked-functions-instruction-set.rs
View file

@ -12,15 +12,15 @@ extern crate minicore;
use minicore::*;
#[no_mangle]
#[naked]
#[unsafe(naked)]
#[instruction_set(arm::t32)]
unsafe extern "C" fn test_thumb() {
extern "C" fn test_thumb() {
naked_asm!("bx lr");
}
#[no_mangle]
#[naked]
#[unsafe(naked)]
#[instruction_set(arm::a32)]
unsafe extern "C" fn test_arm() {
extern "C" fn test_arm() {
naked_asm!("bx lr");
}

12
tests/ui/asm/naked-functions-rustic-abi.rs
View file

@ -11,17 +11,17 @@
use std::arch::{asm, naked_asm};
#[naked]
pub unsafe fn rust_implicit() {
#[unsafe(naked)]
pub fn rust_implicit() {
naked_asm!("ret");
}
#[naked]
pub unsafe extern "Rust" fn rust_explicit() {
#[unsafe(naked)]
pub extern "Rust" fn rust_explicit() {
naked_asm!("ret");
}
#[naked]
pub unsafe extern "rust-cold" fn rust_cold() {
#[unsafe(naked)]
pub extern "rust-cold" fn rust_cold() {
naked_asm!("ret");
}

12
tests/ui/asm/naked-functions-target-feature.rs
View file

@ -8,14 +8,14 @@ use std::arch::{asm, naked_asm};
#[cfg(target_arch = "x86_64")]
#[target_feature(enable = "sse2")]
#[naked]
pub unsafe extern "C" fn compatible_target_feature() {
naked_asm!("");
#[unsafe(naked)]
pub extern "C" fn compatible_target_feature() {
naked_asm!("ret");
}
#[cfg(target_arch = "aarch64")]
#[target_feature(enable = "neon")]
#[naked]
pub unsafe extern "C" fn compatible_target_feature() {
naked_asm!("");
#[unsafe(naked)]
pub extern "C" fn compatible_target_feature() {
naked_asm!("ret");
}

16
tests/ui/asm/naked-functions-testattrs.rs
View file

@ -8,31 +8,31 @@
use std::arch::naked_asm;
#[test]
#[naked]
#[unsafe(naked)]
//~^ ERROR [E0736]
extern "C" fn test_naked() {
unsafe { naked_asm!("") };
naked_asm!("")
}
#[should_panic]
#[test]
#[naked]
#[unsafe(naked)]
//~^ ERROR [E0736]
extern "C" fn test_naked_should_panic() {
unsafe { naked_asm!("") };
naked_asm!("")
}
#[ignore]
#[test]
#[naked]
#[unsafe(naked)]
//~^ ERROR [E0736]
extern "C" fn test_naked_ignore() {
unsafe { naked_asm!("") };
naked_asm!("")
}
#[bench]
#[naked]
#[unsafe(naked)]
//~^ ERROR [E0736]
extern "C" fn bench_naked() {
unsafe { naked_asm!("") };
naked_asm!("")
}

24
tests/ui/asm/naked-functions-testattrs.stderr
View file

@ -1,34 +1,34 @@
error[E0736]: cannot use `#[naked]` with testing attributes
error[E0736]: cannot use `#[unsafe(naked)]` with testing attributes
--> $DIR/naked-functions-testattrs.rs:11:1
|
LL | #[test]
| ------- function marked with testing attribute here
LL | #[naked]
| ^^^^^^^^ `#[naked]` is incompatible with testing attributes
LL | #[unsafe(naked)]
| ^^^^^^^^^^^^^^^^ `#[unsafe(naked)]` is incompatible with testing attributes
error[E0736]: cannot use `#[naked]` with testing attributes
error[E0736]: cannot use `#[unsafe(naked)]` with testing attributes
--> $DIR/naked-functions-testattrs.rs:19:1
|
LL | #[test]
| ------- function marked with testing attribute here
LL | #[naked]
| ^^^^^^^^ `#[naked]` is incompatible with testing attributes
LL | #[unsafe(naked)]
| ^^^^^^^^^^^^^^^^ `#[unsafe(naked)]` is incompatible with testing attributes
error[E0736]: cannot use `#[naked]` with testing attributes
error[E0736]: cannot use `#[unsafe(naked)]` with testing attributes
--> $DIR/naked-functions-testattrs.rs:27:1
|
LL | #[test]
| ------- function marked with testing attribute here
LL | #[naked]
| ^^^^^^^^ `#[naked]` is incompatible with testing attributes
LL | #[unsafe(naked)]
| ^^^^^^^^^^^^^^^^ `#[unsafe(naked)]` is incompatible with testing attributes
error[E0736]: cannot use `#[naked]` with testing attributes
error[E0736]: cannot use `#[unsafe(naked)]` with testing attributes
--> $DIR/naked-functions-testattrs.rs:34:1
|
LL | #[bench]
| -------- function marked with testing attribute here
LL | #[naked]
| ^^^^^^^^ `#[naked]` is incompatible with testing attributes
LL | #[unsafe(naked)]
| ^^^^^^^^^^^^^^^^ `#[unsafe(naked)]` is incompatible with testing attributes
error: aborting due to 4 previous errors

30
tests/ui/asm/naked-functions-unused.rs
View file

@ -64,44 +64,34 @@ pub mod normal {
pub mod naked {
use std::arch::naked_asm;
#[naked]
#[unsafe(naked)]
pub extern "C" fn function(a: usize, b: usize) -> usize {
unsafe {
naked_asm!("");
}
naked_asm!("")
}
pub struct Naked;
impl Naked {
#[naked]
#[unsafe(naked)]
pub extern "C" fn associated(a: usize, b: usize) -> usize {
unsafe {
naked_asm!("");
}
naked_asm!("")
}
#[naked]
#[unsafe(naked)]
pub extern "C" fn method(&self, a: usize, b: usize) -> usize {
unsafe {
naked_asm!("");
}
naked_asm!("")
}
}
impl super::Trait for Naked {
#[naked]
#[unsafe(naked)]
extern "C" fn trait_associated(a: usize, b: usize) -> usize {
unsafe {
naked_asm!("");
}
naked_asm!("")
}
#[naked]
#[unsafe(naked)]
extern "C" fn trait_method(&self, a: usize, b: usize) -> usize {
unsafe {
naked_asm!("");
}
naked_asm!("")
}
}
}

62
tests/ui/asm/naked-functions.rs
View file

@ -9,8 +9,8 @@
use std::arch::{asm, naked_asm};
#[unsafe(naked)]
pub unsafe extern "C" fn inline_asm_macro() {
asm!("", options(raw));
pub extern "C" fn inline_asm_macro() {
unsafe { asm!("", options(raw)) };
//~^ERROR the `asm!` macro is not allowed in naked functions
}
@ -21,7 +21,7 @@ pub struct P {
}
#[unsafe(naked)]
pub unsafe extern "C" fn patterns(
pub extern "C" fn patterns(
mut a: u32,
//~^ ERROR patterns not allowed in naked function parameters
&b: &i32,
@ -35,7 +35,7 @@ pub unsafe extern "C" fn patterns(
}
#[unsafe(naked)]
pub unsafe extern "C" fn inc(a: u32) -> u32 {
pub extern "C" fn inc(a: u32) -> u32 {
//~^ ERROR naked functions must contain a single `naked_asm!` invocation
a + 1
//~^ ERROR referencing function parameters is not allowed in naked functions
@ -43,19 +43,19 @@ pub unsafe extern "C" fn inc(a: u32) -> u32 {
#[unsafe(naked)]
#[allow(asm_sub_register)]
pub unsafe extern "C" fn inc_asm(a: u32) -> u32 {
pub extern "C" fn inc_asm(a: u32) -> u32 {
naked_asm!("/* {0} */", in(reg) a)
//~^ ERROR the `in` operand cannot be used with `naked_asm!`
}
#[unsafe(naked)]
pub unsafe extern "C" fn inc_closure(a: u32) -> u32 {
pub extern "C" fn inc_closure(a: u32) -> u32 {
//~^ ERROR naked functions must contain a single `naked_asm!` invocation
(|| a + 1)()
}
#[unsafe(naked)]
pub unsafe extern "C" fn unsupported_operands() {
pub extern "C" fn unsupported_operands() {
//~^ ERROR naked functions must contain a single `naked_asm!` invocation
let mut a = 0usize;
let mut b = 0usize;
@ -84,11 +84,10 @@ pub extern "C" fn missing_assembly() {
#[unsafe(naked)]
pub extern "C" fn too_many_asm_blocks() {
//~^ ERROR naked functions must contain a single `naked_asm!` invocation
unsafe {
naked_asm!("", options(noreturn));
//~^ ERROR the `noreturn` option cannot be used with `naked_asm!`
naked_asm!("");
}
naked_asm!("", options(noreturn));
//~^ ERROR the `noreturn` option cannot be used with `naked_asm!`
naked_asm!("");
}
pub fn outer(x: u32) -> extern "C" fn(usize) -> usize {
@ -124,49 +123,44 @@ unsafe extern "C" fn invalid_may_unwind() {
#[unsafe(naked)]
pub extern "C" fn valid_a<T>() -> T {
unsafe {
naked_asm!("");
}
naked_asm!("");
}
#[unsafe(naked)]
pub extern "C" fn valid_b() {
unsafe {
{
{
{
naked_asm!("");
};
naked_asm!("");
};
}
};
}
#[unsafe(naked)]
pub unsafe extern "C" fn valid_c() {
pub extern "C" fn valid_c() {
naked_asm!("");
}
#[cfg(target_arch = "x86_64")]
#[unsafe(naked)]
pub unsafe extern "C" fn valid_att_syntax() {
pub extern "C" fn valid_att_syntax() {
naked_asm!("", options(att_syntax));
}
#[unsafe(naked)]
#[unsafe(naked)]
pub unsafe extern "C" fn allow_compile_error(a: u32) -> u32 {
pub extern "C" fn allow_compile_error(a: u32) -> u32 {
compile_error!("this is a user specified error")
//~^ ERROR this is a user specified error
}
#[unsafe(naked)]
pub unsafe extern "C" fn allow_compile_error_and_asm(a: u32) -> u32 {
pub extern "C" fn allow_compile_error_and_asm(a: u32) -> u32 {
compile_error!("this is a user specified error");
//~^ ERROR this is a user specified error
naked_asm!("")
}
#[unsafe(naked)]
pub unsafe extern "C" fn invalid_asm_syntax(a: u32) -> u32 {
pub extern "C" fn invalid_asm_syntax(a: u32) -> u32 {
naked_asm!(invalid_syntax)
//~^ ERROR asm template must be a string literal
}
@ -174,7 +168,7 @@ pub unsafe extern "C" fn invalid_asm_syntax(a: u32) -> u32 {
#[cfg(target_arch = "x86_64")]
#[cfg_attr(target_pointer_width = "64", no_mangle)]
#[unsafe(naked)]
pub unsafe extern "C" fn compatible_cfg_attributes() {
pub extern "C" fn compatible_cfg_attributes() {
naked_asm!("", options(att_syntax));
}
@ -183,20 +177,20 @@ pub unsafe extern "C" fn compatible_cfg_attributes() {
#[deny(dead_code)]
#[forbid(dead_code)]
#[unsafe(naked)]
pub unsafe extern "C" fn compatible_diagnostic_attributes() {
pub extern "C" fn compatible_diagnostic_attributes() {
naked_asm!("", options(raw));
}
#[deprecated = "test"]
#[unsafe(naked)]
pub unsafe extern "C" fn compatible_deprecated_attributes() {
pub extern "C" fn compatible_deprecated_attributes() {
naked_asm!("", options(raw));
}
#[cfg(target_arch = "x86_64")]
#[must_use]
#[unsafe(naked)]
pub unsafe extern "C" fn compatible_must_use_attributes() -> u64 {
pub extern "C" fn compatible_must_use_attributes() -> u64 {
naked_asm!(
"
mov rax, 42
@ -208,13 +202,13 @@ pub unsafe extern "C" fn compatible_must_use_attributes() -> u64 {
#[export_name = "exported_function_name"]
#[link_section = ".custom_section"]
#[unsafe(naked)]
pub unsafe extern "C" fn compatible_ffi_attributes_1() {
pub extern "C" fn compatible_ffi_attributes_1() {
naked_asm!("", options(raw));
}
#[cold]
#[unsafe(naked)]
pub unsafe extern "C" fn compatible_codegen_attributes() {
pub extern "C" fn compatible_codegen_attributes() {
naked_asm!("", options(raw));
}
@ -223,12 +217,12 @@ pub unsafe extern "C" fn compatible_codegen_attributes() {
// a normal comment
#[doc(alias = "ADocAlias")]
#[unsafe(naked)]
pub unsafe extern "C" fn compatible_doc_attributes() {
pub extern "C" fn compatible_doc_attributes() {
naked_asm!("", options(raw));
}
#[linkage = "external"]
#[unsafe(naked)]
pub unsafe extern "C" fn compatible_linkage() {
pub extern "C" fn compatible_linkage() {
naked_asm!("", options(raw));
}

50
tests/ui/asm/naked-functions.stderr
View file

@ -11,70 +11,70 @@ LL | in(reg) a,
| ^^ the `in` operand is not meaningful for global-scoped inline assembly, remove it
error: the `noreturn` option cannot be used with `naked_asm!`
--> $DIR/naked-functions.rs:88:32
--> $DIR/naked-functions.rs:88:28
|
LL | naked_asm!("", options(noreturn));
| ^^^^^^^^ the `noreturn` option is not meaningful for global-scoped inline assembly
LL | naked_asm!("", options(noreturn));
| ^^^^^^^^ the `noreturn` option is not meaningful for global-scoped inline assembly
error: the `nomem` option cannot be used with `naked_asm!`
--> $DIR/naked-functions.rs:106:28
--> $DIR/naked-functions.rs:105:28
|
LL | naked_asm!("", options(nomem, preserves_flags));
| ^^^^^ the `nomem` option is not meaningful for global-scoped inline assembly
error: the `preserves_flags` option cannot be used with `naked_asm!`
--> $DIR/naked-functions.rs:106:35
--> $DIR/naked-functions.rs:105:35
|
LL | naked_asm!("", options(nomem, preserves_flags));
| ^^^^^^^^^^^^^^^ the `preserves_flags` option is not meaningful for global-scoped inline assembly
error: the `readonly` option cannot be used with `naked_asm!`
--> $DIR/naked-functions.rs:113:28
--> $DIR/naked-functions.rs:112:28
|
LL | naked_asm!("", options(readonly, nostack), options(pure));
| ^^^^^^^^ the `readonly` option is not meaningful for global-scoped inline assembly
error: the `nostack` option cannot be used with `naked_asm!`
--> $DIR/naked-functions.rs:113:38
--> $DIR/naked-functions.rs:112:38
|
LL | naked_asm!("", options(readonly, nostack), options(pure));
| ^^^^^^^ the `nostack` option is not meaningful for global-scoped inline assembly
error: the `pure` option cannot be used with `naked_asm!`
--> $DIR/naked-functions.rs:113:56
--> $DIR/naked-functions.rs:112:56
|
LL | naked_asm!("", options(readonly, nostack), options(pure));
| ^^^^ the `pure` option is not meaningful for global-scoped inline assembly
error: the `may_unwind` option cannot be used with `naked_asm!`
--> $DIR/naked-functions.rs:121:28
--> $DIR/naked-functions.rs:120:28
|
LL | naked_asm!("", options(may_unwind));
| ^^^^^^^^^^ the `may_unwind` option is not meaningful for global-scoped inline assembly
error: this is a user specified error
--> $DIR/naked-functions.rs:157:5
--> $DIR/naked-functions.rs:151:5
|
LL | compile_error!("this is a user specified error")
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: this is a user specified error
--> $DIR/naked-functions.rs:163:5
--> $DIR/naked-functions.rs:157:5
|
LL | compile_error!("this is a user specified error");
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: asm template must be a string literal
--> $DIR/naked-functions.rs:170:16
--> $DIR/naked-functions.rs:164:16
|
LL | naked_asm!(invalid_syntax)
| ^^^^^^^^^^^^^^
error[E0787]: the `asm!` macro is not allowed in naked functions
--> $DIR/naked-functions.rs:13:5
--> $DIR/naked-functions.rs:13:14
|
LL | asm!("", options(raw));
| ^^^^^^^^^^^^^^^^^^^^^^ consider using the `naked_asm!` macro instead
LL | unsafe { asm!("", options(raw)) };
| ^^^^^^^^^^^^^^^^^^^^^^ consider using the `naked_asm!` macro instead
error: patterns not allowed in naked function parameters
--> $DIR/naked-functions.rs:25:5
@ -111,8 +111,8 @@ LL | a + 1
error[E0787]: naked functions must contain a single `naked_asm!` invocation
--> $DIR/naked-functions.rs:38:1
|
LL | pub unsafe extern "C" fn inc(a: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | pub extern "C" fn inc(a: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL |
LL | a + 1
| ----- not allowed in naked functions
@ -120,8 +120,8 @@ LL | a + 1
error[E0787]: naked functions must contain a single `naked_asm!` invocation
--> $DIR/naked-functions.rs:52:1
|
LL | pub unsafe extern "C" fn inc_closure(a: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | pub extern "C" fn inc_closure(a: u32) -> u32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL |
LL | (|| a + 1)()
| ------------ not allowed in naked functions
@ -129,8 +129,8 @@ LL | (|| a + 1)()
error[E0787]: naked functions must contain a single `naked_asm!` invocation
--> $DIR/naked-functions.rs:58:1
|
LL | pub unsafe extern "C" fn unsupported_operands() {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | pub extern "C" fn unsupported_operands() {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL |
LL | let mut a = 0usize;
| ------------------- not allowed in naked functions
@ -155,11 +155,11 @@ error[E0787]: naked functions must contain a single `naked_asm!` invocation
LL | pub extern "C" fn too_many_asm_blocks() {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
...
LL | naked_asm!("");
| -------------- multiple `naked_asm!` invocations are not allowed in naked functions
LL | naked_asm!("");
| -------------- multiple `naked_asm!` invocations are not allowed in naked functions
error: referencing function parameters is not allowed in naked functions
--> $DIR/naked-functions.rs:98:11
--> $DIR/naked-functions.rs:97:11
|
LL | *&y
| ^
@ -167,7 +167,7 @@ LL | *&y
= help: follow the calling convention in asm block to use parameters
error[E0787]: naked functions must contain a single `naked_asm!` invocation
--> $DIR/naked-functions.rs:96:5
--> $DIR/naked-functions.rs:95:5
|
LL | pub extern "C" fn inner(y: usize) -> usize {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

28
tests/ui/asm/naked-invalid-attr.rs
View file

@ -1,17 +1,17 @@
// Checks that #[naked] attribute can be placed on function definitions only.
// Checks that #[unsafe(naked)] attribute can be placed on function definitions only.
//
//@ needs-asm-support
#![feature(naked_functions)]
#![naked] //~ ERROR should be applied to a function definition
#![unsafe(naked)] //~ ERROR should be applied to a function definition
use std::arch::naked_asm;
extern "C" {
#[naked] //~ ERROR should be applied to a function definition
#[unsafe(naked)] //~ ERROR should be applied to a function definition
fn f();
}
#[naked] //~ ERROR should be applied to a function definition
#[unsafe(naked)] //~ ERROR should be applied to a function definition
#[repr(C)]
struct S {
a: u32,
@ -19,35 +19,35 @@ struct S {
}
trait Invoke {
#[naked] //~ ERROR should be applied to a function definition
#[unsafe(naked)] //~ ERROR should be applied to a function definition
extern "C" fn invoke(&self);
}
impl Invoke for S {
#[naked]
#[unsafe(naked)]
extern "C" fn invoke(&self) {
unsafe { naked_asm!("") }
naked_asm!("")
}
}
#[naked]
#[unsafe(naked)]
extern "C" fn ok() {
unsafe { naked_asm!("") }
naked_asm!("")
}
impl S {
#[naked]
#[unsafe(naked)]
extern "C" fn g() {
unsafe { naked_asm!("") }
naked_asm!("")
}
#[naked]
#[unsafe(naked)]
extern "C" fn h(&self) {
unsafe { naked_asm!("") }
naked_asm!("")
}
}
fn main() {
#[naked] //~ ERROR should be applied to a function definition
#[unsafe(naked)] //~ ERROR should be applied to a function definition
|| {};
}

20
tests/ui/asm/naked-invalid-attr.stderr
View file

@ -1,8 +1,8 @@
error: attribute should be applied to a function definition
--> $DIR/naked-invalid-attr.rs:14:1
|
LL | #[naked]
| ^^^^^^^^
LL | #[unsafe(naked)]
| ^^^^^^^^^^^^^^^^
LL | #[repr(C)]
LL | / struct S {
LL | | a: u32,
@ -13,32 +13,32 @@ LL | | }
error: attribute should be applied to a function definition
--> $DIR/naked-invalid-attr.rs:51:5
|
LL | #[naked]
| ^^^^^^^^
LL | #[unsafe(naked)]
| ^^^^^^^^^^^^^^^^
LL | || {};
| ----- not a function definition
error: attribute should be applied to a function definition
--> $DIR/naked-invalid-attr.rs:22:5
|
LL | #[naked]
| ^^^^^^^^
LL | #[unsafe(naked)]
| ^^^^^^^^^^^^^^^^
LL | extern "C" fn invoke(&self);
| ---------------------------- not a function definition
error: attribute should be applied to a function definition
--> $DIR/naked-invalid-attr.rs:10:5
|
LL | #[naked]
| ^^^^^^^^
LL | #[unsafe(naked)]
| ^^^^^^^^^^^^^^^^
LL | fn f();
| ------- not a function definition
error: attribute should be applied to a function definition
--> $DIR/naked-invalid-attr.rs:5:1
|
LL | #![naked]
| ^^^^^^^^^ cannot be applied to crates
LL | #![unsafe(naked)]
| ^^^^^^^^^^^^^^^^^ cannot be applied to crates
error: aborting due to 5 previous errors

20
tests/ui/asm/naked-with-invalid-repr-attr.rs
View file

@ -6,43 +6,43 @@ use std::arch::naked_asm;
#[repr(C)]
//~^ ERROR attribute should be applied to a struct, enum, or union [E0517]
#[naked]
#[unsafe(naked)]
extern "C" fn example1() {
//~^ NOTE not a struct, enum, or union
unsafe { naked_asm!("") }
naked_asm!("")
}
#[repr(transparent)]
//~^ ERROR attribute should be applied to a struct, enum, or union [E0517]
#[naked]
#[unsafe(naked)]
extern "C" fn example2() {
//~^ NOTE not a struct, enum, or union
unsafe { naked_asm!("") }
naked_asm!("")
}
#[repr(align(16), C)]
//~^ ERROR attribute should be applied to a struct, enum, or union [E0517]
#[naked]
#[unsafe(naked)]
extern "C" fn example3() {
//~^ NOTE not a struct, enum, or union
unsafe { naked_asm!("") }
naked_asm!("")
}
// note: two errors because of packed and C
#[repr(C, packed)]
//~^ ERROR attribute should be applied to a struct or union [E0517]
//~| ERROR attribute should be applied to a struct, enum, or union [E0517]
#[naked]
#[unsafe(naked)]
extern "C" fn example4() {
//~^ NOTE not a struct, enum, or union
//~| NOTE not a struct or union
unsafe { naked_asm!("") }
naked_asm!("")
}
#[repr(u8)]
//~^ ERROR attribute should be applied to an enum [E0517]
#[naked]
#[unsafe(naked)]
extern "C" fn example5() {
//~^ NOTE not an enum
unsafe { naked_asm!("") }
naked_asm!("")
}

12
tests/ui/asm/naked-with-invalid-repr-attr.stderr
View file

@ -6,7 +6,7 @@ LL | #[repr(C)]
...
LL | / extern "C" fn example1() {
LL | |
LL | | unsafe { naked_asm!("") }
LL | | naked_asm!("")
LL | | }
| |_- not a struct, enum, or union
@ -18,7 +18,7 @@ LL | #[repr(transparent)]
...
LL | / extern "C" fn example2() {
LL | |
LL | | unsafe { naked_asm!("") }
LL | | naked_asm!("")
LL | | }
| |_- not a struct, enum, or union
@ -30,7 +30,7 @@ LL | #[repr(align(16), C)]
...
LL | / extern "C" fn example3() {
LL | |
LL | | unsafe { naked_asm!("") }
LL | | naked_asm!("")
LL | | }
| |_- not a struct, enum, or union
@ -43,7 +43,7 @@ LL | #[repr(C, packed)]
LL | / extern "C" fn example4() {
LL | |
LL | |
LL | | unsafe { naked_asm!("") }
LL | | naked_asm!("")
LL | | }
| |_- not a struct, enum, or union
@ -56,7 +56,7 @@ LL | #[repr(C, packed)]
LL | / extern "C" fn example4() {
LL | |
LL | |
LL | | unsafe { naked_asm!("") }
LL | | naked_asm!("")
LL | | }
| |_- not a struct or union
@ -68,7 +68,7 @@ LL | #[repr(u8)]
...
LL | / extern "C" fn example5() {
LL | |
LL | | unsafe { naked_asm!("") }
LL | | naked_asm!("")
LL | | }
| |_- not an enum

16
tests/ui/asm/named-asm-labels.rs
View file

@ -175,9 +175,9 @@ fn main() {
// Trigger on naked fns too, even though they can't be inlined, reusing a
// label or LTO can cause labels to break
#[naked]
#[unsafe(naked)]
pub extern "C" fn foo() -> i32 {
unsafe { naked_asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1) }
naked_asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1)
//~^ ERROR avoid using named labels
}
@ -188,21 +188,21 @@ pub extern "C" fn bar() {
//~^ ERROR avoid using named labels
}
#[naked]
#[unsafe(naked)]
pub extern "C" fn aaa() {
fn _local() {}
unsafe { naked_asm!(".Laaa: nop; ret;") } //~ ERROR avoid using named labels
naked_asm!(".Laaa: nop; ret;") //~ ERROR avoid using named labels
}
pub fn normal() {
fn _local1() {}
#[naked]
#[unsafe(naked)]
pub extern "C" fn bbb() {
fn _very_local() {}
unsafe { naked_asm!(".Lbbb: nop; ret;") } //~ ERROR avoid using named labels
naked_asm!(".Lbbb: nop; ret;") //~ ERROR avoid using named labels
}
fn _local2() {}
@ -219,8 +219,8 @@ fn closures() {
};
|| {
#[naked]
unsafe extern "C" fn _nested() {
#[unsafe(naked)]
extern "C" fn _nested() {
naked_asm!("ret;");
}

18
tests/ui/asm/named-asm-labels.stderr
View file

@ -475,10 +475,10 @@ LL | #[warn(named_asm_labels)]
| ^^^^^^^^^^^^^^^^
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:180:26
--> $DIR/named-asm-labels.rs:180:17
|
LL | unsafe { naked_asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1) }
| ^^^^^
LL | naked_asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1)
| ^^^^^
|
= help: only local labels of the form `<number>:` should be used in inline asm
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
@ -493,19 +493,19 @@ LL | unsafe { asm!(".Lbar: mov rax, {}; ret;", "nop", const 1, options(noret
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:195:26
--> $DIR/named-asm-labels.rs:195:17
|
LL | unsafe { naked_asm!(".Laaa: nop; ret;") }
| ^^^^^
LL | naked_asm!(".Laaa: nop; ret;")
| ^^^^^
|
= help: only local labels of the form `<number>:` should be used in inline asm
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
error: avoid using named labels in inline assembly
--> $DIR/named-asm-labels.rs:205:30
--> $DIR/named-asm-labels.rs:205:21
|
LL | unsafe { naked_asm!(".Lbbb: nop; ret;") }
| ^^^^^
LL | naked_asm!(".Lbbb: nop; ret;")
| ^^^^^
|
= help: only local labels of the form `<number>:` should be used in inline asm
= note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information

54
tests/ui/codegen/ref-dyn-trait-in-structs-and-enums.rs Normal file
View file

@ -0,0 +1,54 @@
//! Regression test for an LLVM assertion that used to be hit when:
//!
//! - There's a generic enum contained within a tuple struct
//! - When the tuple struct is parameterized by some lifetime `'a`
//! - The enum is concretized with its type argument being a reference to a trait object (of
//! lifetime `'a`)
//!
//! Issue: <https://github.com/rust-lang/rust/issues/9719>
//@ build-pass
// Dummy trait implemented for `isize` to use in the test cases
pub trait MyTrait {
fn dummy(&self) {}
}
impl MyTrait for isize {}
// `&dyn MyTrait` contained in enum variant
pub struct EnumRefDynTrait<'a>(Enum<&'a (dyn MyTrait + 'a)>);
pub enum Enum<T> {
Variant(T),
}
fn enum_dyn_trait() {
let x: isize = 42;
let y = EnumRefDynTrait(Enum::Variant(&x as &dyn MyTrait));
let _ = y;
}
// `&dyn MyTrait` contained behind `Option` in named field of struct
struct RefDynTraitNamed<'a> {
x: Option<&'a (dyn MyTrait + 'a)>,
}
fn named_option_dyn_trait() {
let x: isize = 42;
let y = RefDynTraitNamed { x: Some(&x as &dyn MyTrait) };
let _ = y;
}
// `&dyn MyTrait` contained behind `Option` in unnamed field of struct
pub struct RefDynTraitUnnamed<'a>(Option<&'a (dyn MyTrait + 'a)>);
fn unnamed_option_dyn_trait() {
let x: isize = 42;
let y = RefDynTraitUnnamed(Some(&x as &dyn MyTrait));
let _ = y;
}
pub fn main() {
enum_dyn_trait();
named_option_dyn_trait();
unnamed_option_dyn_trait();
}

17
tests/ui/diagnostic_namespace/on_impl_trait.rs Normal file
View file

@ -0,0 +1,17 @@
// used to ICE, see <https://github.com/rust-lang/rust/issues/130627>
// Instead it should just ignore the diagnostic attribute
#![feature(trait_alias)]
trait Test {}
#[diagnostic::on_unimplemented(message = "blah", label = "blah", note = "blah")]
//~^ WARN `#[diagnostic::on_unimplemented]` can only be applied to trait definitions
trait Alias = Test;
// Use trait alias as bound on type parameter.
fn foo<T: Alias>(v: &T) {}
pub fn main() {
foo(&1);
//~^ ERROR the trait bound `{integer}: Alias` is not satisfied
}

31
tests/ui/diagnostic_namespace/on_impl_trait.stderr Normal file
View file

@ -0,0 +1,31 @@
warning: `#[diagnostic::on_unimplemented]` can only be applied to trait definitions
--> $DIR/on_impl_trait.rs:7:1
|
LL | #[diagnostic::on_unimplemented(message = "blah", label = "blah", note = "blah")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
error[E0277]: the trait bound `{integer}: Alias` is not satisfied
--> $DIR/on_impl_trait.rs:15:9
|
LL | foo(&1);
| --- ^^ the trait `Test` is not implemented for `{integer}`
| |
| required by a bound introduced by this call
|
help: this trait has no implementations, consider adding one
--> $DIR/on_impl_trait.rs:5:1
|
LL | trait Test {}
| ^^^^^^^^^^
= note: required for `{integer}` to implement `Alias`
note: required by a bound in `foo`
--> $DIR/on_impl_trait.rs:12:11
|
LL | fn foo<T: Alias>(v: &T) {}
| ^^^^^ required by this bound in `foo`
error: aborting due to 1 previous error; 1 warning emitted
For more information about this error, try `rustc --explain E0277`.

48
tests/ui/diagnostic_namespace/on_unimplemented/broken_format.stderr
View file

@ -1,52 +1,52 @@
warning: unmatched `}` found
--> $DIR/broken_format.rs:2:32
--> $DIR/broken_format.rs:2:42
|
LL | #[diagnostic::on_unimplemented(message = "{{Test } thing")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^
|
= note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
warning: positional format arguments are not allowed here
--> $DIR/broken_format.rs:7:32
--> $DIR/broken_format.rs:7:49
|
LL | #[diagnostic::on_unimplemented(message = "Test {}")]
| ^^^^^^^^^^^^^^^^^^^
| ^
|
= help: only named format arguments with the name of one of the generic types are allowed in this context
warning: positional format arguments are not allowed here
--> $DIR/broken_format.rs:12:32
--> $DIR/broken_format.rs:12:49
|
LL | #[diagnostic::on_unimplemented(message = "Test {1:}")]
| ^^^^^^^^^^^^^^^^^^^^^
| ^
|
= help: only named format arguments with the name of one of the generic types are allowed in this context
warning: invalid format specifier
--> $DIR/broken_format.rs:17:32
--> $DIR/broken_format.rs:17:42
|
LL | #[diagnostic::on_unimplemented(message = "Test {Self:123}")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^
|
= help: no format specifier are supported in this position
warning: expected `}`, found `!`
--> $DIR/broken_format.rs:22:32
--> $DIR/broken_format.rs:22:42
|
LL | #[diagnostic::on_unimplemented(message = "Test {Self:!}")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^
warning: unmatched `}` found
--> $DIR/broken_format.rs:22:32
--> $DIR/broken_format.rs:22:42
|
LL | #[diagnostic::on_unimplemented(message = "Test {Self:!}")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^
warning: unmatched `}` found
--> $DIR/broken_format.rs:2:32
--> $DIR/broken_format.rs:2:42
|
LL | #[diagnostic::on_unimplemented(message = "{{Test } thing")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
@ -70,10 +70,10 @@ LL | fn check_1(_: impl ImportantTrait1) {}
| ^^^^^^^^^^^^^^^ required by this bound in `check_1`
warning: positional format arguments are not allowed here
--> $DIR/broken_format.rs:7:32
--> $DIR/broken_format.rs:7:49
|
LL | #[diagnostic::on_unimplemented(message = "Test {}")]
| ^^^^^^^^^^^^^^^^^^^
| ^
|
= help: only named format arguments with the name of one of the generic types are allowed in this context
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
@ -98,10 +98,10 @@ LL | fn check_2(_: impl ImportantTrait2) {}
| ^^^^^^^^^^^^^^^ required by this bound in `check_2`
warning: positional format arguments are not allowed here
--> $DIR/broken_format.rs:12:32
--> $DIR/broken_format.rs:12:49
|
LL | #[diagnostic::on_unimplemented(message = "Test {1:}")]
| ^^^^^^^^^^^^^^^^^^^^^
| ^
|
= help: only named format arguments with the name of one of the generic types are allowed in this context
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
@ -126,10 +126,10 @@ LL | fn check_3(_: impl ImportantTrait3) {}
| ^^^^^^^^^^^^^^^ required by this bound in `check_3`
warning: invalid format specifier
--> $DIR/broken_format.rs:17:32
--> $DIR/broken_format.rs:17:42
|
LL | #[diagnostic::on_unimplemented(message = "Test {Self:123}")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^
|
= help: no format specifier are supported in this position
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
@ -154,18 +154,18 @@ LL | fn check_4(_: impl ImportantTrait4) {}
| ^^^^^^^^^^^^^^^ required by this bound in `check_4`
warning: expected `}`, found `!`
--> $DIR/broken_format.rs:22:32
--> $DIR/broken_format.rs:22:42
|
LL | #[diagnostic::on_unimplemented(message = "Test {Self:!}")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
warning: unmatched `}` found
--> $DIR/broken_format.rs:22:32
--> $DIR/broken_format.rs:22:42
|
LL | #[diagnostic::on_unimplemented(message = "Test {Self:!}")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`

80
tests/ui/diagnostic_namespace/on_unimplemented/do_not_accept_options_of_the_internal_rustc_attribute.stderr
View file

@ -39,82 +39,82 @@ LL | #[diagnostic::on_unimplemented = "Message"]
= help: only `message`, `note` and `label` are allowed as options
warning: there is no parameter `from_desugaring` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:17
|
LL | message = "{from_desugaring}{direct}{cause}{integral}{integer}",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
warning: there is no parameter `direct` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:34
|
LL | message = "{from_desugaring}{direct}{cause}{integral}{integer}",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
warning: there is no parameter `cause` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:42
|
LL | message = "{from_desugaring}{direct}{cause}{integral}{integer}",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
warning: there is no parameter `integral` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:49
|
LL | message = "{from_desugaring}{direct}{cause}{integral}{integer}",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
warning: there is no parameter `integer` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:59
|
LL | message = "{from_desugaring}{direct}{cause}{integral}{integer}",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
warning: there is no parameter `float` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:15
|
LL | label = "{float}{_Self}{crate_local}{Trait}{ItemContext}"
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
warning: there is no parameter `_Self` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:22
|
LL | label = "{float}{_Self}{crate_local}{Trait}{ItemContext}"
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
warning: there is no parameter `crate_local` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:29
|
LL | label = "{float}{_Self}{crate_local}{Trait}{ItemContext}"
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
warning: there is no parameter `Trait` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:42
|
LL | label = "{float}{_Self}{crate_local}{Trait}{ItemContext}"
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
warning: there is no parameter `ItemContext` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:49
|
LL | label = "{float}{_Self}{crate_local}{Trait}{ItemContext}"
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
@ -191,91 +191,91 @@ LL | fn takes_bar(_: impl Bar) {}
| ^^^ required by this bound in `takes_bar`
warning: there is no parameter `from_desugaring` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:17
|
LL | message = "{from_desugaring}{direct}{cause}{integral}{integer}",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
warning: there is no parameter `direct` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:34
|
LL | message = "{from_desugaring}{direct}{cause}{integral}{integer}",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
warning: there is no parameter `cause` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:42
|
LL | message = "{from_desugaring}{direct}{cause}{integral}{integer}",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
warning: there is no parameter `integral` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:49
|
LL | message = "{from_desugaring}{direct}{cause}{integral}{integer}",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
warning: there is no parameter `integer` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:33:59
|
LL | message = "{from_desugaring}{direct}{cause}{integral}{integer}",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
warning: there is no parameter `float` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:15
|
LL | label = "{float}{_Self}{crate_local}{Trait}{ItemContext}"
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
warning: there is no parameter `_Self` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:22
|
LL | label = "{float}{_Self}{crate_local}{Trait}{ItemContext}"
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
warning: there is no parameter `crate_local` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:29
|
LL | label = "{float}{_Self}{crate_local}{Trait}{ItemContext}"
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
warning: there is no parameter `Trait` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:42
|
LL | label = "{float}{_Self}{crate_local}{Trait}{ItemContext}"
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
warning: there is no parameter `ItemContext` on trait `Baz`
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:5
--> $DIR/do_not_accept_options_of_the_internal_rustc_attribute.rs:44:49
|
LL | label = "{float}{_Self}{crate_local}{Trait}{ItemContext}"
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`

8
tests/ui/diagnostic_namespace/on_unimplemented/do_not_fail_parsing_on_invalid_options_1.stderr
View file

@ -47,10 +47,10 @@ LL | #[diagnostic::on_unimplemented]
= help: at least one of the `message`, `note` and `label` options are expected
warning: there is no parameter `DoesNotExist` on trait `Test`
--> $DIR/do_not_fail_parsing_on_invalid_options_1.rs:31:32
--> $DIR/do_not_fail_parsing_on_invalid_options_1.rs:31:44
|
LL | #[diagnostic::on_unimplemented(message = "{DoesNotExist}")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
@ -167,10 +167,10 @@ LL | fn take_whatever(_: impl Whatever) {}
| ^^^^^^^^ required by this bound in `take_whatever`
warning: there is no parameter `DoesNotExist` on trait `Test`
--> $DIR/do_not_fail_parsing_on_invalid_options_1.rs:31:32
--> $DIR/do_not_fail_parsing_on_invalid_options_1.rs:31:44
|
LL | #[diagnostic::on_unimplemented(message = "{DoesNotExist}")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^
|
= help: expect either a generic argument name or `{Self}` as format argument
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`

6
tests/ui/feature-gates/feature-gate-naked_functions.rs
View file

@ -3,20 +3,18 @@
use std::arch::naked_asm;
//~^ ERROR use of unstable library feature `naked_functions`
#[naked]
#[naked] //~ ERROR unsafe attribute used without unsafe
//~^ ERROR the `#[naked]` attribute is an experimental feature
extern "C" fn naked() {
naked_asm!("")
//~^ ERROR use of unstable library feature `naked_functions`
//~| ERROR: requires unsafe
}
#[naked]
#[naked] //~ ERROR unsafe attribute used without unsafe
//~^ ERROR the `#[naked]` attribute is an experimental feature
extern "C" fn naked_2() -> isize {
naked_asm!("")
//~^ ERROR use of unstable library feature `naked_functions`
//~| ERROR: requires unsafe
}
fn main() {}

45
tests/ui/feature-gates/feature-gate-naked_functions.stderr
View file

@ -9,7 +9,7 @@ LL | naked_asm!("")
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: use of unstable library feature `naked_functions`
--> $DIR/feature-gate-naked_functions.rs:17:5
--> $DIR/feature-gate-naked_functions.rs:16:5
|
LL | naked_asm!("")
| ^^^^^^^^^
@ -18,6 +18,28 @@ LL | naked_asm!("")
= help: add `#![feature(naked_functions)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error: unsafe attribute used without unsafe
--> $DIR/feature-gate-naked_functions.rs:6:3
|
LL | #[naked]
| ^^^^^ usage of unsafe attribute
|
help: wrap the attribute in `unsafe(...)`
|
LL | #[unsafe(naked)]
| +++++++ +
error: unsafe attribute used without unsafe
--> $DIR/feature-gate-naked_functions.rs:13:3
|
LL | #[naked]
| ^^^^^ usage of unsafe attribute
|
help: wrap the attribute in `unsafe(...)`
|
LL | #[unsafe(naked)]
| +++++++ +
error[E0658]: the `#[naked]` attribute is an experimental feature
--> $DIR/feature-gate-naked_functions.rs:6:1
|
@ -29,7 +51,7 @@ LL | #[naked]
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: the `#[naked]` attribute is an experimental feature
--> $DIR/feature-gate-naked_functions.rs:14:1
--> $DIR/feature-gate-naked_functions.rs:13:1
|
LL | #[naked]
| ^^^^^^^^
@ -48,23 +70,6 @@ LL | use std::arch::naked_asm;
= help: add `#![feature(naked_functions)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0133]: use of inline assembly is unsafe and requires unsafe function or block
--> $DIR/feature-gate-naked_functions.rs:9:5
|
LL | naked_asm!("")
| ^^^^^^^^^^^^^^ use of inline assembly
|
= note: inline assembly is entirely unchecked and can cause undefined behavior
error[E0133]: use of inline assembly is unsafe and requires unsafe function or block
--> $DIR/feature-gate-naked_functions.rs:17:5
|
LL | naked_asm!("")
| ^^^^^^^^^^^^^^ use of inline assembly
|
= note: inline assembly is entirely unchecked and can cause undefined behavior
error: aborting due to 7 previous errors
Some errors have detailed explanations: E0133, E0658.
For more information about an error, try `rustc --explain E0133`.
For more information about this error, try `rustc --explain E0658`.

6
tests/ui/feature-gates/feature-gate-naked_functions_rustic_abi.rs
View file

@ -5,19 +5,19 @@
use std::arch::naked_asm;
#[naked]
#[unsafe(naked)]
pub unsafe fn rust_implicit() {
//~^ ERROR `#[naked]` is currently unstable on `extern "Rust"` functions
naked_asm!("ret");
}
#[naked]
#[unsafe(naked)]
pub unsafe extern "Rust" fn rust_explicit() {
//~^ ERROR `#[naked]` is currently unstable on `extern "Rust"` functions
naked_asm!("ret");
}
#[naked]
#[unsafe(naked)]
pub unsafe extern "rust-cold" fn rust_cold() {
//~^ ERROR `#[naked]` is currently unstable on `extern "rust-cold"` functions
naked_asm!("ret");

2
tests/ui/feature-gates/feature-gate-naked_functions_target_feature.rs
View file

@ -5,7 +5,7 @@
use std::arch::naked_asm;
#[naked]
#[unsafe(naked)]
#[target_feature(enable = "avx2")]
//~^ ERROR: `#[target_feature(/* ... */)]` is currently unstable on `#[naked]` functions
extern "C" fn naked() {

34
tests/ui/impl-unused-tps.stderr
View file

@ -7,23 +7,6 @@ LL | impl<T> Foo<T> for [isize; 0] {
LL | impl<T, U> Foo<T> for U {
| ^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `[isize; 0]`
error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
--> $DIR/impl-unused-tps.rs:32:9
|
LL | impl<T, U> Bar for T {
| ^ unconstrained type parameter
error[E0119]: conflicting implementations of trait `Bar`
--> $DIR/impl-unused-tps.rs:40:1
|
LL | impl<T, U> Bar for T {
| -------------------- first implementation here
...
LL | / impl<T, U> Bar for T
LL | | where
LL | | T: Bar<Out = U>,
| |____________________^ conflicting implementation
error[E0119]: conflicting implementations of trait `Foo<[isize; 0]>` for type `[isize; 0]`
--> $DIR/impl-unused-tps.rs:49:1
|
@ -52,6 +35,12 @@ error[E0207]: the type parameter `U` is not constrained by the impl trait, self
LL | impl<T, U> Foo<T> for [isize; 1] {
| ^ unconstrained type parameter
error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
--> $DIR/impl-unused-tps.rs:32:9
|
LL | impl<T, U> Bar for T {
| ^ unconstrained type parameter
error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
--> $DIR/impl-unused-tps.rs:40:9
|
@ -70,6 +59,17 @@ error[E0207]: the type parameter `V` is not constrained by the impl trait, self
LL | impl<T, U, V> Foo<T> for T
| ^ unconstrained type parameter
error[E0119]: conflicting implementations of trait `Bar`
--> $DIR/impl-unused-tps.rs:40:1
|
LL | impl<T, U> Bar for T {
| -------------------- first implementation here
...
LL | / impl<T, U> Bar for T
LL | | where
LL | | T: Bar<Out = U>,
| |____________________^ conflicting implementation
error: aborting due to 9 previous errors
Some errors have detailed explanations: E0119, E0207.

25
tests/ui/issues/auxiliary/issue-14421.rs
View file

@ -1,25 +0,0 @@
#![crate_type="lib"]
#![deny(warnings)]
#![allow(dead_code)]
pub use src::aliases::B;
pub use src::hidden_core::make;
mod src {
pub mod aliases {
use super::hidden_core::A;
pub type B = A<f32>;
}
pub mod hidden_core {
use super::aliases::B;
pub struct A<T> { t: T }
pub fn make() -> B { A { t: 1.0 } }
impl<T> A<T> {
pub fn foo(&mut self) { println!("called foo"); }
}
}
}

15
tests/ui/issues/issue-14421.rs
View file

@ -1,15 +0,0 @@
//@ run-pass
#![allow(non_snake_case)]
//@ aux-build:issue-14421.rs
extern crate issue_14421 as bug_lib;
use bug_lib::B;
use bug_lib::make;
pub fn main() {
let mut an_A: B = make();
an_A.foo();
}

8
tests/ui/issues/issue-16939.rs
View file

@ -1,8 +0,0 @@
// Make sure we don't ICE when making an overloaded call with the
// wrong arity.
fn _foo<F: Fn()> (f: F) {
|t| f(t); //~ ERROR E0057
}
fn main() {}

20
tests/ui/issues/issue-16939.stderr
View file

@ -1,20 +0,0 @@
error[E0057]: this function takes 0 arguments but 1 argument was supplied
--> $DIR/issue-16939.rs:5:9
|
LL | |t| f(t);
| ^ - unexpected argument
|
note: callable defined here
--> $DIR/issue-16939.rs:4:12
|
LL | fn _foo<F: Fn()> (f: F) {
| ^^^^
help: remove the extra argument
|
LL - |t| f(t);
LL + |t| f();
|
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0057`.

59
tests/ui/issues/issue-23808.rs
View file

@ -1,59 +0,0 @@
//@ run-pass
#![deny(dead_code)]
// use different types / traits to test all combinations
trait Const {
const C: ();
}
trait StaticFn {
fn sfn();
}
struct ConstStruct;
struct StaticFnStruct;
enum ConstEnum {}
enum StaticFnEnum {}
struct AliasedConstStruct;
struct AliasedStaticFnStruct;
enum AliasedConstEnum {}
enum AliasedStaticFnEnum {}
type AliasConstStruct = AliasedConstStruct;
type AliasStaticFnStruct = AliasedStaticFnStruct;
type AliasConstEnum = AliasedConstEnum;
type AliasStaticFnEnum = AliasedStaticFnEnum;
macro_rules! impl_Const {($($T:ident),*) => {$(
impl Const for $T {
const C: () = ();
}
)*}}
macro_rules! impl_StaticFn {($($T:ident),*) => {$(
impl StaticFn for $T {
fn sfn() {}
}
)*}}
impl_Const!(ConstStruct, ConstEnum, AliasedConstStruct, AliasedConstEnum);
impl_StaticFn!(StaticFnStruct, StaticFnEnum, AliasedStaticFnStruct, AliasedStaticFnEnum);
fn main() {
let () = ConstStruct::C;
let () = ConstEnum::C;
StaticFnStruct::sfn();
StaticFnEnum::sfn();
let () = AliasConstStruct::C;
let () = AliasConstEnum::C;
AliasStaticFnStruct::sfn();
AliasStaticFnEnum::sfn();
}

40
tests/ui/issues/issue-9719.rs
View file

@ -1,40 +0,0 @@
//@ build-pass
#![allow(dead_code)]
mod a {
pub enum Enum<T> {
A(T),
}
pub trait X {
fn dummy(&self) { }
}
impl X for isize {}
pub struct Z<'a>(Enum<&'a (dyn X + 'a)>);
fn foo() { let x: isize = 42; let z = Z(Enum::A(&x as &dyn X)); let _ = z; }
}
mod b {
trait X {
fn dummy(&self) { }
}
impl X for isize {}
struct Y<'a>{
x:Option<&'a (dyn X + 'a)>,
}
fn bar() {
let x: isize = 42;
let _y = Y { x: Some(&x as &dyn X) };
}
}
mod c {
pub trait X { fn f(&self); }
impl X for isize { fn f(&self) {} }
pub struct Z<'a>(Option<&'a (dyn X + 'a)>);
fn main() { let x: isize = 42; let z = Z(Some(&x as &dyn X)); let _ = z; }
}
pub fn main() {}

33
tests/ui/lint/dead-code/auxiliary/no-dead-code-reexported-types-across-crates.rs Normal file
View file

@ -0,0 +1,33 @@
//! Auxilary file for testing `dead_code` lint. This crate is compiled as a library and exposes
//! aliased types. When used externally, there should not be warnings of `dead_code`
//!
//! Issue: <https://github.com/rust-lang/rust/issues/14421>
// Expose internal types to be used in external test
pub use src::aliases::ExposedType;
pub use src::hidden_core::new;
mod src {
pub mod aliases {
use super::hidden_core::InternalStruct;
pub type ExposedType = InternalStruct<f32>;
}
pub mod hidden_core {
use super::aliases::ExposedType;
pub struct InternalStruct<T> {
_x: T,
}
pub fn new() -> ExposedType {
InternalStruct { _x: 1.0 }
}
impl<T> InternalStruct<T> {
pub fn foo(&mut self) {
println!("called foo");
}
}
}
}

61
tests/ui/lint/dead-code/no-dead-code-for-static-trait-impl.rs Normal file
View file

@ -0,0 +1,61 @@
//! Regression test to ensure false positive `dead_code` diagnostic warnings are not triggered for
//! structs and enums that implement static trait functions or use associated constants.
//!
//! Aliased versions of all cases are also tested
//!
//! Issue: <https://github.com/rust-lang/rust/issues/23808>
//@ check-pass
#![deny(dead_code)]
trait Const {
const C: ();
}
trait StaticFn {
fn sfn();
}
macro_rules! impl_const {($($T:ident),*) => {$(
impl Const for $T {
const C: () = ();
}
)*}}
macro_rules! impl_static_fn {($($T:ident),*) => {$(
impl StaticFn for $T {
fn sfn() {}
}
)*}}
struct ConstStruct;
enum ConstEnum {}
struct AliasedConstStruct;
type AliasConstStruct = AliasedConstStruct;
enum AliasedConstEnum {}
type AliasConstEnum = AliasedConstEnum;
impl_const!(ConstStruct, ConstEnum, AliasedConstStruct, AliasedConstEnum);
struct StaticFnStruct;
enum StaticFnEnum {}
struct AliasedStaticFnStruct;
type AliasStaticFnStruct = AliasedStaticFnStruct;
enum AliasedStaticFnEnum {}
type AliasStaticFnEnum = AliasedStaticFnEnum;
impl_static_fn!(StaticFnStruct, StaticFnEnum, AliasedStaticFnStruct, AliasedStaticFnEnum);
fn main() {
// Use the associated constant for all the types, they should be considered "used"
let () = ConstStruct::C;
let () = ConstEnum::C;
let () = AliasConstStruct::C;
let () = AliasConstEnum::C;
// Use the associated static function for all the types, they should be considered "used"
StaticFnStruct::sfn();
StaticFnEnum::sfn();
AliasStaticFnStruct::sfn();
AliasStaticFnEnum::sfn();
}

17
tests/ui/lint/dead-code/no-dead-code-reexported-types-across-crates.rs Normal file
View file

@ -0,0 +1,17 @@
//! Regression test to ensure that `dead_code` warning does not get triggered when using re-exported
//! types that are exposed from a different crate
//!
//! Issue: <https://github.com/rust-lang/rust/issues/14421>
//@ check-pass
//@ aux-build:no-dead-code-reexported-types-across-crates.rs
extern crate no_dead_code_reexported_types_across_crates as bug_lib;
use bug_lib::ExposedType;
use bug_lib::new;
pub fn main() {
let mut x: ExposedType = new();
x.foo();
}

4
tests/ui/on-unimplemented/bad-annotation.rs
View file

@ -20,12 +20,12 @@ trait BadAnnotation1
{}
#[rustc_on_unimplemented = "Unimplemented trait error on `{Self}` with params `<{A},{B},{C}>`"]
//~^ ERROR there is no parameter `C` on trait `BadAnnotation2`
//~^ ERROR cannot find parameter C on this trait
trait BadAnnotation2<A,B>
{}
#[rustc_on_unimplemented = "Unimplemented trait error on `{Self}` with params `<{A},{B},{}>`"]
//~^ ERROR only named generic parameters are allowed
//~^ ERROR positional format arguments are not allowed here
trait BadAnnotation3<A,B>
{}

12
tests/ui/on-unimplemented/bad-annotation.stderr
View file

@ -11,17 +11,17 @@ LL | #[rustc_on_unimplemented = "message"]
LL | #[rustc_on_unimplemented(/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...")]
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
error[E0230]: there is no parameter `C` on trait `BadAnnotation2`
--> $DIR/bad-annotation.rs:22:1
error[E0230]: cannot find parameter C on this trait
--> $DIR/bad-annotation.rs:22:90
|
LL | #[rustc_on_unimplemented = "Unimplemented trait error on `{Self}` with params `<{A},{B},{C}>`"]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^
error[E0231]: only named generic parameters are allowed
--> $DIR/bad-annotation.rs:27:1
error[E0231]: positional format arguments are not allowed here
--> $DIR/bad-annotation.rs:27:90
|
LL | #[rustc_on_unimplemented = "Unimplemented trait error on `{Self}` with params `<{A},{B},{}>`"]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^
error[E0232]: this attribute must have a valid value
--> $DIR/bad-annotation.rs:32:26

15
tests/ui/on-unimplemented/impl-substs.rs
View file

@ -1,15 +0,0 @@
#![feature(rustc_attrs)]
trait Foo<A> {
fn foo(self);
}
#[rustc_on_unimplemented = "an impl did not match: {A} {B} {C}"]
impl<A, B, C> Foo<A> for (A, B, C) {
fn foo(self) {}
}
fn main() {
Foo::<usize>::foo((1i32, 1i32, 1i32));
//~^ ERROR the trait bound `(i32, i32, i32): Foo<usize>` is not satisfied
}

15
tests/ui/on-unimplemented/impl-substs.stderr
View file

@ -1,15 +0,0 @@
error[E0277]: the trait bound `(i32, i32, i32): Foo<usize>` is not satisfied
--> $DIR/impl-substs.rs:13:23
|
LL | Foo::<usize>::foo((1i32, 1i32, 1i32));
| ----------------- ^^^^^^^^^^^^^^^^^^ an impl did not match: usize _ _
| |
| required by a bound introduced by this call
|
= help: the trait `Foo<usize>` is not implemented for `(i32, i32, i32)`
but trait `Foo<i32>` is implemented for it
= help: for that trait implementation, expected `i32`, found `usize`
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0277`.

8
tests/ui/on-unimplemented/issue-104140.rs
View file

@ -1,8 +0,0 @@
#![feature(rustc_attrs)]
trait Foo {}
#[rustc_on_unimplemented] //~ ERROR malformed `rustc_on_unimplemented` attribute input
impl Foo for u32 {}
fn main() {}

15
tests/ui/on-unimplemented/issue-104140.stderr
View file

@ -1,15 +0,0 @@
error: malformed `rustc_on_unimplemented` attribute input
--> $DIR/issue-104140.rs:5:1
|
LL | #[rustc_on_unimplemented]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
help: the following are the possible correct uses
|
LL | #[rustc_on_unimplemented = "message"]
| +++++++++++
LL | #[rustc_on_unimplemented(/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...")]
| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
error: aborting due to 1 previous error

42
tests/ui/on-unimplemented/multiple-impls.rs
View file

@ -1,42 +0,0 @@
// Test if the on_unimplemented message override works
#![feature(rustc_attrs)]
struct Foo<T>(T);
struct Bar<T>(T);
#[rustc_on_unimplemented = "trait message"]
trait Index<Idx: ?Sized> {
type Output: ?Sized;
fn index(&self, index: Idx) -> &Self::Output;
}
#[rustc_on_unimplemented = "on impl for Foo"]
impl Index<Foo<usize>> for [i32] {
type Output = i32;
fn index(&self, _index: Foo<usize>) -> &i32 {
loop {}
}
}
#[rustc_on_unimplemented = "on impl for Bar"]
impl Index<Bar<usize>> for [i32] {
type Output = i32;
fn index(&self, _index: Bar<usize>) -> &i32 {
loop {}
}
}
fn main() {
Index::index(&[] as &[i32], 2u32);
//~^ ERROR E0277
//~| ERROR E0277
Index::index(&[] as &[i32], Foo(2u32));
//~^ ERROR E0277
//~| ERROR E0277
Index::index(&[] as &[i32], Bar(2u32));
//~^ ERROR E0277
//~| ERROR E0277
}

75
tests/ui/on-unimplemented/multiple-impls.stderr
View file

@ -1,75 +0,0 @@
error[E0277]: the trait bound `[i32]: Index<u32>` is not satisfied
--> $DIR/multiple-impls.rs:33:33
|
LL | Index::index(&[] as &[i32], 2u32);
| ------------ ^^^^ trait message
| |
| required by a bound introduced by this call
|
= help: the trait `Index<u32>` is not implemented for `[i32]`
= help: the following other types implement trait `Index<Idx>`:
`[i32]` implements `Index<Bar<usize>>`
`[i32]` implements `Index<Foo<usize>>`
error[E0277]: the trait bound `[i32]: Index<Foo<u32>>` is not satisfied
--> $DIR/multiple-impls.rs:36:33
|
LL | Index::index(&[] as &[i32], Foo(2u32));
| ------------ ^^^^^^^^^ on impl for Foo
| |
| required by a bound introduced by this call
|
= help: the trait `Index<Foo<u32>>` is not implemented for `[i32]`
= help: the following other types implement trait `Index<Idx>`:
`[i32]` implements `Index<Bar<usize>>`
`[i32]` implements `Index<Foo<usize>>`
error[E0277]: the trait bound `[i32]: Index<Bar<u32>>` is not satisfied
--> $DIR/multiple-impls.rs:39:33
|
LL | Index::index(&[] as &[i32], Bar(2u32));
| ------------ ^^^^^^^^^ on impl for Bar
| |
| required by a bound introduced by this call
|
= help: the trait `Index<Bar<u32>>` is not implemented for `[i32]`
= help: the following other types implement trait `Index<Idx>`:
`[i32]` implements `Index<Bar<usize>>`
`[i32]` implements `Index<Foo<usize>>`
error[E0277]: the trait bound `[i32]: Index<u32>` is not satisfied
--> $DIR/multiple-impls.rs:33:5
|
LL | Index::index(&[] as &[i32], 2u32);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ trait message
|
= help: the trait `Index<u32>` is not implemented for `[i32]`
= help: the following other types implement trait `Index<Idx>`:
`[i32]` implements `Index<Bar<usize>>`
`[i32]` implements `Index<Foo<usize>>`
error[E0277]: the trait bound `[i32]: Index<Foo<u32>>` is not satisfied
--> $DIR/multiple-impls.rs:36:5
|
LL | Index::index(&[] as &[i32], Foo(2u32));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ on impl for Foo
|
= help: the trait `Index<Foo<u32>>` is not implemented for `[i32]`
= help: the following other types implement trait `Index<Idx>`:
`[i32]` implements `Index<Bar<usize>>`
`[i32]` implements `Index<Foo<usize>>`
error[E0277]: the trait bound `[i32]: Index<Bar<u32>>` is not satisfied
--> $DIR/multiple-impls.rs:39:5
|
LL | Index::index(&[] as &[i32], Bar(2u32));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ on impl for Bar
|
= help: the trait `Index<Bar<u32>>` is not implemented for `[i32]`
= help: the following other types implement trait `Index<Idx>`:
`[i32]` implements `Index<Bar<usize>>`
`[i32]` implements `Index<Foo<usize>>`
error: aborting due to 6 previous errors
For more information about this error, try `rustc --explain E0277`.

25
tests/ui/on-unimplemented/on-impl.rs
View file

@ -1,25 +0,0 @@
// Test if the on_unimplemented message override works
#![feature(rustc_attrs)]
#[rustc_on_unimplemented = "invalid"]
trait Index<Idx: ?Sized> {
type Output: ?Sized;
fn index(&self, index: Idx) -> &Self::Output;
}
#[rustc_on_unimplemented = "a usize is required to index into a slice"]
impl Index<usize> for [i32] {
type Output = i32;
fn index(&self, index: usize) -> &i32 {
&self[index]
}
}
fn main() {
Index::<u32>::index(&[1, 2, 3] as &[i32], 2u32);
//~^ ERROR E0277
//~| ERROR E0277
}

25
tests/ui/on-unimplemented/on-impl.stderr
View file

@ -1,25 +0,0 @@
error[E0277]: the trait bound `[i32]: Index<u32>` is not satisfied
--> $DIR/on-impl.rs:22:47
|
LL | Index::<u32>::index(&[1, 2, 3] as &[i32], 2u32);
| ------------------- ^^^^ a usize is required to index into a slice
| |
| required by a bound introduced by this call
|
= help: the trait `Index<u32>` is not implemented for `[i32]`
but trait `Index<usize>` is implemented for it
= help: for that trait implementation, expected `usize`, found `u32`
error[E0277]: the trait bound `[i32]: Index<u32>` is not satisfied
--> $DIR/on-impl.rs:22:5
|
LL | Index::<u32>::index(&[1, 2, 3] as &[i32], 2u32);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ a usize is required to index into a slice
|
= help: the trait `Index<u32>` is not implemented for `[i32]`
but trait `Index<usize>` is implemented for it
= help: for that trait implementation, expected `usize`, found `u32`
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0277`.

14
tests/ui/on-unimplemented/use_self_no_underscore.rs Normal file
View file

@ -0,0 +1,14 @@
#![feature(rustc_attrs)]
#[rustc_on_unimplemented(on(
all(A = "{integer}", any(Self = "[{integral}; _]",)),
message = "an array of type `{Self}` cannot be built directly from an iterator",
))]
pub trait FromIterator<A>: Sized {
fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self;
}
fn main() {
let iter = 0..42_8;
let x: [u8; 8] = FromIterator::from_iter(iter);
//~^ ERROR an array of type `[u8; 8]` cannot be built directly from an iterator
}

15
tests/ui/on-unimplemented/use_self_no_underscore.stderr Normal file
View file

@ -0,0 +1,15 @@
error[E0277]: an array of type `[u8; 8]` cannot be built directly from an iterator
--> $DIR/use_self_no_underscore.rs:12:22
|
LL | let x: [u8; 8] = FromIterator::from_iter(iter);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `FromIterator<{integer}>` is not implemented for `[u8; 8]`
|
help: this trait has no implementations, consider adding one
--> $DIR/use_self_no_underscore.rs:7:1
|
LL | pub trait FromIterator<A>: Sized {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0277`.

4
tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.rs
View file

@ -5,7 +5,7 @@ use std::arch::naked_asm;
#[track_caller] //~ ERROR [E0736]
//~^ ERROR `#[track_caller]` requires Rust ABI
#[naked]
#[unsafe(naked)]
extern "C" fn f() {
unsafe {
naked_asm!("");
@ -17,7 +17,7 @@ struct S;
impl S {
#[track_caller] //~ ERROR [E0736]
//~^ ERROR `#[track_caller]` requires Rust ABI
#[naked]
#[unsafe(naked)]
extern "C" fn g() {
unsafe {
naked_asm!("");

16
tests/ui/rfcs/rfc-2091-track-caller/error-with-naked.stderr
View file

@ -1,20 +1,20 @@
error[E0736]: attribute incompatible with `#[naked]`
error[E0736]: attribute incompatible with `#[unsafe(naked)]`
--> $DIR/error-with-naked.rs:6:1
|
LL | #[track_caller]
| ^^^^^^^^^^^^^^^ the `track_caller` attribute is incompatible with `#[naked]`
| ^^^^^^^^^^^^^^^ the `track_caller` attribute is incompatible with `#[unsafe(naked)]`
LL |
LL | #[naked]
| -------- function marked with `#[naked]` here
LL | #[unsafe(naked)]
| ---------------- function marked with `#[unsafe(naked)]` here
error[E0736]: attribute incompatible with `#[naked]`
error[E0736]: attribute incompatible with `#[unsafe(naked)]`
--> $DIR/error-with-naked.rs:18:5
|
LL | #[track_caller]
| ^^^^^^^^^^^^^^^ the `track_caller` attribute is incompatible with `#[naked]`
| ^^^^^^^^^^^^^^^ the `track_caller` attribute is incompatible with `#[unsafe(naked)]`
LL |
LL | #[naked]
| -------- function marked with `#[naked]` here
LL | #[unsafe(naked)]
| ---------------- function marked with `#[unsafe(naked)]` here
error[E0737]: `#[track_caller]` requires Rust ABI
--> $DIR/error-with-naked.rs:6:1

32
tests/ui/traits/next-solver/rpitit-cycle-due-to-rigid.rs Normal file
View file

@ -0,0 +1,32 @@
//@ compile-flags: -Znext-solver
//@ check-pass
//@ edition: 2024
// Ensure we don't end up in a query cycle due to trying to assemble an impl candidate
// for an RPITIT normalizes-to goal, even though that impl candidate would *necessarily*
// be made rigid by a where clause. This query cycle is thus avoidable by not assembling
// that impl candidate which we *know* we are going to throw away anyways.
use std::future::Future;
pub trait ReactiveFunction: Send {
type Output;
fn invoke(self) -> Self::Output;
}
trait AttributeValue {
fn resolve(self) -> impl Future<Output = ()> + Send;
}
impl<F, V> AttributeValue for F
where
F: ReactiveFunction<Output = V>,
V: AttributeValue,
{
async fn resolve(self) {
self.invoke().resolve().await
}
}
fn main() {}