mirror of
https://github.com/rust-lang/rust.git
synced 2025-10-02 01:22:48 +00:00
8c8225afe8
Previously `-Zprint-mono-items` would override the mono item collection strategy. When debugging one doesn't want to change the behaviour, so this was counter productive. Additionally, the produced behaviour was artificial and might never arise without using the option in the first place (`-Zprint-mono-items=eager` without `-Clink-dead-code`). Finally, the option was incorrectly marked as `UNTRACKED`. Resolve those issues, by turning `-Zprint-mono-items` into a boolean flag that prints results of mono item collection without changing the behaviour of mono item collection. For codegen-units test incorporate `-Zprint-mono-items` flag directly into compiletest tool. Test changes are mechanical. `-Zprint-mono-items=lazy` was removed without additional changes, and `-Zprint-mono-items=eager` was turned into `-Clink-dead-code`. Linking dead code disables internalization, so tests have been updated accordingly.
78 lines
1.1 KiB
Rust
78 lines
1.1 KiB
Rust
//@ compile-flags:-Clink-dead-code
|
|
|
|
#![crate_type = "lib"]
|
|
#![deny(dead_code)]
|
|
|
|
// This test asserts that no codegen items are generated for generic items that
|
|
// are never instantiated in the local crate.
|
|
|
|
pub trait Trait {
|
|
fn foo() {}
|
|
fn bar(&self) {}
|
|
}
|
|
|
|
pub fn foo<T: Copy>(x: T) -> (T, T) {
|
|
(x, x)
|
|
}
|
|
|
|
pub struct Struct<T> {
|
|
x: T,
|
|
}
|
|
|
|
impl<T> Struct<T> {
|
|
pub fn foo(self) -> T {
|
|
self.x
|
|
}
|
|
|
|
pub fn bar() {}
|
|
}
|
|
|
|
pub enum Enum<T> {
|
|
A(T),
|
|
B { x: T },
|
|
}
|
|
|
|
impl<T> Enum<T> {
|
|
pub fn foo(self) -> T {
|
|
match self {
|
|
Enum::A(x) => x,
|
|
Enum::B { x } => x,
|
|
}
|
|
}
|
|
|
|
pub fn bar() {}
|
|
}
|
|
|
|
pub struct TupleStruct<T>(T);
|
|
|
|
impl<T> TupleStruct<T> {
|
|
pub fn foo(self) -> T {
|
|
self.0
|
|
}
|
|
|
|
pub fn bar() {}
|
|
}
|
|
|
|
pub type Pair<T> = (T, T);
|
|
|
|
pub struct NonGeneric {
|
|
x: i32,
|
|
}
|
|
|
|
impl NonGeneric {
|
|
pub fn foo(self) -> i32 {
|
|
self.x
|
|
}
|
|
|
|
pub fn generic_foo<T>(&self, x: T) -> (T, i32) {
|
|
(x, self.x)
|
|
}
|
|
|
|
pub fn generic_bar<T: Copy>(x: T) -> (T, T) {
|
|
(x, x)
|
|
}
|
|
}
|
|
|
|
// Only the non-generic methods should be instantiated:
|
|
//~ MONO_ITEM fn NonGeneric::foo
|