src/test/codegen-units/polymorphization/unused_type_parameters.rs

   1 // compile-flags:-Zpolymorphize=on -Zprint-mono-items=lazy -Copt-level=1
   2
   3 #![crate_type = "rlib"]
   4
   5 // This test checks that the polymorphization analysis correctly reduces the
   6 // generated mono items.
   7
   8 mod functions {
   9     // Function doesn't have any type parameters to be unused.
  10     pub fn no_parameters() {}
  11
  12 //~ MONO_ITEM fn functions::no_parameters
  13
  14     // Function has an unused type parameter.
  15     pub fn unused<T>() {
  16     }
  17
  18 //~ MONO_ITEM fn functions::unused::<T>
  19
  20     // Function uses type parameter in value of a binding.
  21     pub fn used_binding_value<T: Default>() {
  22         let _: T = Default::default();
  23     }
  24
  25 //~ MONO_ITEM fn functions::used_binding_value::<u32>
  26 //~ MONO_ITEM fn functions::used_binding_value::<u64>
  27
  28     // Function uses type parameter in type of a binding.
  29     pub fn used_binding_type<T>() {
  30         let _: Option<T> = None;
  31     }
  32
  33 //~ MONO_ITEM fn functions::used_binding_type::<u32>
  34 //~ MONO_ITEM fn functions::used_binding_type::<u64>
  35
  36     // Function uses type parameter in argument.
  37     pub fn used_argument<T>(_: T) {
  38     }
  39
  40 //~ MONO_ITEM fn functions::used_argument::<u32>
  41 //~ MONO_ITEM fn functions::used_argument::<u64>
  42 //
  43     // Function uses type parameter in substitutions to another function.
  44     pub fn used_substs<T>() {
  45         unused::<T>()
  46     }
  47
  48 //~ MONO_ITEM fn functions::used_substs::<u32>
  49 //~ MONO_ITEM fn functions::used_substs::<u64>
  50 }
  51
  52
  53 mod closures {
  54     // Function doesn't have any type parameters to be unused.
  55     pub fn no_parameters() {
  56         let _ = || {};
  57     }
  58
  59 //~ MONO_ITEM fn closures::no_parameters
  60
  61     // Function has an unused type parameter in parent and closure.
  62     pub fn unused<T>() -> u32 {
  63         let add_one = |x: u32| x + 1;
  64         add_one(3)
  65     }
  66
  67 //~ MONO_ITEM fn closures::unused::<T>::{closure#0}
  68 //~ MONO_ITEM fn closures::unused::<T>
  69
  70     // Function has an unused type parameter in closure, but not in parent.
  71     pub fn used_parent<T: Default>() -> u32 {
  72         let _: T = Default::default();
  73         let add_one = |x: u32| x + 1;
  74         add_one(3)
  75     }
  76
  77 //~ MONO_ITEM fn closures::used_parent::<T>::{closure#0}
  78 //~ MONO_ITEM fn closures::used_parent::<u32>
  79 //~ MONO_ITEM fn closures::used_parent::<u64>
  80
  81     // Function uses type parameter in value of a binding in closure.
  82     pub fn used_binding_value<T: Default>() -> T {
  83         let x = || {
  84             let y: T = Default::default();
  85             y
  86         };
  87
  88         x()
  89     }
  90
  91 //~ MONO_ITEM fn closures::used_binding_value::<u32>::{closure#0}
  92 //~ MONO_ITEM fn closures::used_binding_value::<u64>::{closure#0}
  93 //~ MONO_ITEM fn closures::used_binding_value::<u32>
  94 //~ MONO_ITEM fn closures::used_binding_value::<u64>
  95
  96     // Function uses type parameter in type of a binding in closure.
  97     pub fn used_binding_type<T>() -> Option<T> {
  98         let x = || {
  99             let y: Option<T> = None;
 100             y
 101         };
 102
 103         x()
 104     }
 105
 106 //~ MONO_ITEM fn closures::used_binding_type::<u32>::{closure#0}
 107 //~ MONO_ITEM fn closures::used_binding_type::<u64>::{closure#0}
 108 //~ MONO_ITEM fn closures::used_binding_type::<u32>
 109 //~ MONO_ITEM fn closures::used_binding_type::<u64>
 110
 111     // Function and closure uses type parameter in argument.
 112     pub fn used_argument<T>(t: T) -> u32 {
 113         let x = |_: T| 3;
 114         x(t)
 115     }
 116
 117 //~ MONO_ITEM fn closures::used_argument::<u32>::{closure#0}
 118 //~ MONO_ITEM fn closures::used_argument::<u64>::{closure#0}
 119 //~ MONO_ITEM fn closures::used_argument::<u32>
 120 //~ MONO_ITEM fn closures::used_argument::<u64>
 121
 122     // Closure uses type parameter in argument.
 123     pub fn used_argument_closure<T: Default>() -> u32 {
 124         let t: T = Default::default();
 125         let x = |_: T| 3;
 126         x(t)
 127     }
 128
 129 //~ MONO_ITEM fn closures::used_argument_closure::<u32>::{closure#0}
 130 //~ MONO_ITEM fn closures::used_argument_closure::<u64>::{closure#0}
 131 //~ MONO_ITEM fn closures::used_argument_closure::<u32>
 132 //~ MONO_ITEM fn closures::used_argument_closure::<u64>
 133
 134     // Closure uses type parameter as upvar.
 135     pub fn used_upvar<T: Default>() -> T {
 136         let x: T = Default::default();
 137         let y = || x;
 138         y()
 139     }
 140
 141 //~ MONO_ITEM fn closures::used_upvar::<u32>::{closure#0}
 142 //~ MONO_ITEM fn closures::used_upvar::<u64>::{closure#0}
 143 //~ MONO_ITEM fn closures::used_upvar::<u32>
 144 //~ MONO_ITEM fn closures::used_upvar::<u64>
 145
 146     // Closure uses type parameter in substitutions to another function.
 147     pub fn used_substs<T>() {
 148         let x = || super::functions::unused::<T>();
 149         x()
 150     }
 151
 152 //~ MONO_ITEM fn closures::used_substs::<u32>::{closure#0}
 153 //~ MONO_ITEM fn closures::used_substs::<u64>::{closure#0}
 154 //~ MONO_ITEM fn closures::used_substs::<u32>
 155 //~ MONO_ITEM fn closures::used_substs::<u64>
 156 }
 157
 158 mod methods {
 159     pub struct Foo<F>(F);
 160
 161     impl<F: Default> Foo<F> {
 162         // Function has an unused type parameter from impl.
 163         pub fn unused_impl() {
 164         }
 165
 166 //~ MONO_ITEM fn methods::Foo::<F>::unused_impl
 167
 168         // Function has an unused type parameter from impl and fn.
 169         pub fn unused_both<G: Default>() {
 170         }
 171
 172 //~ MONO_ITEM fn methods::Foo::<F>::unused_both::<G>
 173
 174         // Function uses type parameter from impl.
 175         pub fn used_impl() {
 176             let _: F = Default::default();
 177         }
 178
 179 //~ MONO_ITEM fn methods::Foo::<u32>::used_impl
 180 //~ MONO_ITEM fn methods::Foo::<u64>::used_impl
 181
 182         // Function uses type parameter from impl.
 183         pub fn used_fn<G: Default>() {
 184             let _: G = Default::default();
 185         }
 186
 187 //~ MONO_ITEM fn methods::Foo::<F>::used_fn::<u32>
 188 //~ MONO_ITEM fn methods::Foo::<F>::used_fn::<u64>
 189
 190         // Function uses type parameter from impl.
 191         pub fn used_both<G: Default>() {
 192             let _: F = Default::default();
 193             let _: G = Default::default();
 194         }
 195
 196 //~ MONO_ITEM fn methods::Foo::<u32>::used_both::<u32>
 197 //~ MONO_ITEM fn methods::Foo::<u64>::used_both::<u64>
 198
 199         // Function uses type parameter in substitutions to another function.
 200         pub fn used_substs() {
 201             super::functions::unused::<F>()
 202         }
 203
 204 //~ MONO_ITEM fn methods::Foo::<u32>::used_substs
 205 //~ MONO_ITEM fn methods::Foo::<u64>::used_substs
 206
 207         // Function has an unused type parameter from impl and fn.
 208         pub fn closure_unused_all<G: Default>() -> u32 {
 209             let add_one = |x: u32| x + 1;
 210             add_one(3)
 211         }
 212
 213 //~ MONO_ITEM fn methods::Foo::<F>::closure_unused_all::<G>::{closure#0}
 214 //~ MONO_ITEM fn methods::Foo::<F>::closure_unused_all::<G>
 215
 216         // Function uses type parameter from impl and fn in closure.
 217         pub fn closure_used_both<G: Default>() -> u32 {
 218             let add_one = |x: u32| {
 219                 let _: F = Default::default();
 220                 let _: G = Default::default();
 221                 x + 1
 222             };
 223
 224             add_one(3)
 225         }
 226
 227 //~ MONO_ITEM fn methods::Foo::<u32>::closure_used_both::<u32>::{closure#0}
 228 //~ MONO_ITEM fn methods::Foo::<u64>::closure_used_both::<u64>::{closure#0}
 229 //~ MONO_ITEM fn methods::Foo::<u32>::closure_used_both::<u32>
 230 //~ MONO_ITEM fn methods::Foo::<u64>::closure_used_both::<u64>
 231
 232         // Function uses type parameter from fn in closure.
 233         pub fn closure_used_fn<G: Default>() -> u32 {
 234             let add_one = |x: u32| {
 235                 let _: G = Default::default();
 236                 x + 1
 237             };
 238
 239             add_one(3)
 240         }
 241
 242 //~ MONO_ITEM fn methods::Foo::<F>::closure_used_fn::<u32>::{closure#0}
 243 //~ MONO_ITEM fn methods::Foo::<F>::closure_used_fn::<u64>::{closure#0}
 244 //~ MONO_ITEM fn methods::Foo::<F>::closure_used_fn::<u32>
 245 //~ MONO_ITEM fn methods::Foo::<F>::closure_used_fn::<u64>
 246
 247         // Function uses type parameter from impl in closure.
 248         pub fn closure_used_impl<G: Default>() -> u32 {
 249             let add_one = |x: u32| {
 250                 let _: F = Default::default();
 251                 x + 1
 252             };
 253
 254             add_one(3)
 255         }
 256
 257 //~ MONO_ITEM fn methods::Foo::<u32>::closure_used_impl::<G>::{closure#0}
 258 //~ MONO_ITEM fn methods::Foo::<u64>::closure_used_impl::<G>::{closure#0}
 259 //~ MONO_ITEM fn methods::Foo::<u32>::closure_used_impl::<G>
 260 //~ MONO_ITEM fn methods::Foo::<u64>::closure_used_impl::<G>
 261
 262         // Closure uses type parameter in substitutions to another function.
 263         pub fn closure_used_substs() {
 264             let x = || super::functions::unused::<F>();
 265             x()
 266         }
 267
 268 //~ MONO_ITEM fn methods::Foo::<u32>::closure_used_substs::{closure#0}
 269 //~ MONO_ITEM fn methods::Foo::<u64>::closure_used_substs::{closure#0}
 270 //~ MONO_ITEM fn methods::Foo::<u32>::closure_used_substs
 271 //~ MONO_ITEM fn methods::Foo::<u64>::closure_used_substs
 272     }
 273 }
 274
 275
 276
 277 fn dispatch<T: Default>() {
 278     functions::no_parameters();
 279     functions::unused::<T>();
 280     functions::used_binding_value::<T>();
 281     functions::used_binding_type::<T>();
 282     functions::used_argument::<T>(Default::default());
 283     functions::used_substs::<T>();
 284
 285     closures::no_parameters();
 286     let _ = closures::unused::<T>();
 287     let _ = closures::used_parent::<T>();
 288     let _ = closures::used_binding_value::<T>();
 289     let _ = closures::used_binding_type::<T>();
 290     let _ = closures::used_argument::<T>(Default::default());
 291     let _ = closures::used_argument_closure::<T>();
 292     let _ = closures::used_upvar::<T>();
 293     let _ = closures::used_substs::<T>();
 294
 295     methods::Foo::<T>::unused_impl();
 296     methods::Foo::<T>::unused_both::<T>();
 297     methods::Foo::<T>::used_impl();
 298     methods::Foo::<T>::used_fn::<T>();
 299     methods::Foo::<T>::used_both::<T>();
 300     methods::Foo::<T>::used_substs();
 301     let _ = methods::Foo::<T>::closure_unused_all::<T>();
 302     let _ = methods::Foo::<T>::closure_used_both::<T>();
 303     let _ = methods::Foo::<T>::closure_used_impl::<T>();
 304     let _ = methods::Foo::<T>::closure_used_fn::<T>();
 305     let _ = methods::Foo::<T>::closure_used_substs();
 306 }
 307
 308 //~ MONO_ITEM fn dispatch::<u32>
 309 //~ MONO_ITEM fn dispatch::<u64>
 310
 311 pub fn foo() {
 312     // Generate two copies of each function to check that where the type parameter is unused,
 313     // there is only a single copy.
 314     dispatch::<u32>();
 315     dispatch::<u64>();
 316 }
 317
 318 //~ MONO_ITEM fn foo @@ unused_type_parameters-cgu.0[External]
 319
 320 // These are all the items that aren't relevant to the test.
 321 //~ MONO_ITEM fn <u32 as std::default::Default>::default
 322 //~ MONO_ITEM fn <u64 as std::default::Default>::default