mir: use attribute over -Z polymorphize-errors

davidtwco · davidtwco · commit b1f8bd635696 · 2020-07-20T19:35:35.000+01:00
This commit replaces the `-Z polymorphize-errors` debugging flag with a
`#[rustc_polymorphize_error]` attribute for use on functions.

Signed-off-by: David Wood &lt;david@davidtw.co&gt;
diff --git a/src/librustc_feature/builtin_attrs.rs b/src/librustc_feature/builtin_attrs.rs
@@ -568,6 +568,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     ),
     rustc_attr!(TEST, rustc_synthetic, AssumedUsed, template!(Word)),
     rustc_attr!(TEST, rustc_symbol_name, AssumedUsed, template!(Word)),
+    rustc_attr!(TEST, rustc_polymorphize_error, AssumedUsed, template!(Word)),
     rustc_attr!(TEST, rustc_def_path, AssumedUsed, template!(Word)),
     rustc_attr!(TEST, rustc_mir, AssumedUsed, template!(List: "arg1, arg2, ...")),
     rustc_attr!(TEST, rustc_dump_program_clauses, AssumedUsed, template!(Word)),
diff --git a/src/librustc_mir/monomorphize/polymorphize.rs b/src/librustc_mir/monomorphize/polymorphize.rs
@@ -16,6 +16,7 @@ use rustc_middle::ty::{
     query::Providers,
     Const, Ty, TyCtxt,
 };
+use rustc_span::symbol::sym;
 use std::convert::TryInto;
 
 /// Provide implementations of queries relating to polymorphization analysis.
@@ -77,7 +78,7 @@ fn unused_generic_params(tcx: TyCtxt<'_>, def_id: DefId) -> u64 {
 
     // Emit errors for debugging and testing if enabled.
     let is_full = unused_parameters == 0;
-    if tcx.sess.opts.debugging_opts.polymorphize_errors && !is_full {
+    if !is_full {
         emit_unused_generic_params_error(tcx, def_id, generics, unused_parameters);
     }
 
@@ -169,16 +170,17 @@ fn mark_used_by_predicates<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, used_paramete
     }
 }
 
-/// Emit an error for the function represented by `def_id`, labelling each generic parameter which
-/// was unused.
+/// Emit errors for the function annotated by `#[rustc_polymorphize_error]`, labelling each generic
+/// parameter which was unused.
 fn emit_unused_generic_params_error<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: DefId,
     generics: &'tcx ty::Generics,
     unused_parameters: u64,
 ) {
     debug!("emit_unused_generic_params_error: def_id={:?}", def_id);
-    if !def_id.is_local() {
+    let base_def_id = tcx.closure_base_def_id(def_id);
+    if !tcx.get_attrs(base_def_id).iter().any(|a| a.check_name(sym::rustc_polymorphize_error)) {
         return;
     }
 
diff --git a/src/librustc_session/options.rs b/src/librustc_session/options.rs
@@ -951,8 +951,6 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
         "enable polonius-based borrow-checker (default: no)"),
     polymorphize: bool = (true, parse_bool, [TRACKED],
           "perform polymorphization analysis"),
-    polymorphize_errors: bool = (false, parse_bool, [TRACKED],
-          "emit errors from polymorphization analysis for debugging"),
     pre_link_arg: (/* redirected to pre_link_args */) = ((), parse_string_push, [UNTRACKED],
         "a single extra argument to prepend the linker invocation (can be used several times)"),
     pre_link_args: Vec<String> = (Vec::new(), parse_list, [UNTRACKED],
diff --git a/src/librustc_span/symbol.rs b/src/librustc_span/symbol.rs
@@ -921,6 +921,7 @@ symbols! {
         rustc_peek_liveness,
         rustc_peek_maybe_init,
         rustc_peek_maybe_uninit,
+        rustc_polymorphize_error,
         rustc_private,
         rustc_proc_macro_decls,
         rustc_promotable,
diff --git a/src/test/ui/polymorphization/const_parameters/closures.rs b/src/test/ui/polymorphization/const_parameters/closures.rs
@@ -1,33 +1,36 @@
 // build-fail
-// compile-flags: -Zpolymorphize-errors
-#![feature(const_generics)]
+#![feature(const_generics, rustc_attrs)]
 //~^ WARN the feature `const_generics` is incomplete
 
 // This test checks that the polymorphization analysis correctly detects unused const
 // parameters in closures.
 
 // Function doesn't have any generic parameters to be unused.
+#[rustc_polymorphize_error]
 pub fn no_parameters() {
     let _ = || {};
 }
 
 // Function has an unused generic parameter in parent and closure.
+#[rustc_polymorphize_error]
 pub fn unused<const T: usize>() -> usize {
-//~^ ERROR item has unused generic parameters
+    //~^ ERROR item has unused generic parameters
     let add_one = |x: usize| x + 1;
-//~^ ERROR item has unused generic parameters
+    //~^ ERROR item has unused generic parameters
     add_one(3)
 }
 
 // Function has an unused generic parameter in closure, but not in parent.
+#[rustc_polymorphize_error]
 pub fn used_parent<const T: usize>() -> usize {
     let x: usize = T;
     let add_one = |x: usize| x + 1;
-//~^ ERROR item has unused generic parameters
+    //~^ ERROR item has unused generic parameters
     x + add_one(3)
 }
 
 // Function uses generic parameter in value of a binding in closure.
+#[rustc_polymorphize_error]
 pub fn used_binding<const T: usize>() -> usize {
     let x = || {
         let y: usize = T;
@@ -38,14 +41,16 @@ pub fn used_binding<const T: usize>() -> usize {
 }
 
 // Closure uses a value as an upvar, which used the generic parameter.
+#[rustc_polymorphize_error]
 pub fn unused_upvar<const T: usize>() -> usize {
     let x: usize = T;
     let y = || x;
-//~^ ERROR item has unused generic parameters
+    //~^ ERROR item has unused generic parameters
     y()
 }
 
 // Closure uses generic parameter in substitutions to another function.
+#[rustc_polymorphize_error]
 pub fn used_substs<const T: usize>() -> usize {
     let x = || unused::<T>();
     x()
diff --git a/src/test/ui/polymorphization/const_parameters/closures.stderr b/src/test/ui/polymorphization/const_parameters/closures.stderr
@@ -1,14 +1,14 @@
 warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/closures.rs:3:12
+  --> $DIR/closures.rs:2:12
    |
-LL | #![feature(const_generics)]
+LL | #![feature(const_generics, rustc_attrs)]
    |            ^^^^^^^^^^^^^^
    |
    = note: `#[warn(incomplete_features)]` on by default
    = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
 
 error: item has unused generic parameters
-  --> $DIR/closures.rs:17:19
+  --> $DIR/closures.rs:18:19
    |
 LL | pub fn unused<const T: usize>() -> usize {
    |                     - generic parameter `T` is unused
@@ -17,13 +17,13 @@ LL |     let add_one = |x: usize| x + 1;
    |                   ^^^^^^^^^^^^^^^^
 
 error: item has unused generic parameters
-  --> $DIR/closures.rs:15:8
+  --> $DIR/closures.rs:16:8
    |
 LL | pub fn unused<const T: usize>() -> usize {
    |        ^^^^^^       - generic parameter `T` is unused
 
 error: item has unused generic parameters
-  --> $DIR/closures.rs:25:19
+  --> $DIR/closures.rs:27:19
    |
 LL | pub fn used_parent<const T: usize>() -> usize {
    |                          - generic parameter `T` is unused
@@ -32,7 +32,7 @@ LL |     let add_one = |x: usize| x + 1;
    |                   ^^^^^^^^^^^^^^^^
 
 error: item has unused generic parameters
-  --> $DIR/closures.rs:43:13
+  --> $DIR/closures.rs:47:13
    |
 LL | pub fn unused_upvar<const T: usize>() -> usize {
    |                           - generic parameter `T` is unused
diff --git a/src/test/ui/polymorphization/const_parameters/functions.rs b/src/test/ui/polymorphization/const_parameters/functions.rs
@@ -1,26 +1,29 @@
 // build-fail
-// compile-flags: -Zpolymorphize-errors
-#![feature(const_generics)]
+#![feature(const_generics, rustc_attrs)]
 //~^ WARN the feature `const_generics` is incomplete
 
 // This test checks that the polymorphization analysis correctly detects unused const
 // parameters in functions.
 
 // Function doesn't have any generic parameters to be unused.
+#[rustc_polymorphize_error]
 pub fn no_parameters() {}
 
 // Function has an unused generic parameter.
+#[rustc_polymorphize_error]
 pub fn unused<const T: usize>() {
-//~^ ERROR item has unused generic parameters
+    //~^ ERROR item has unused generic parameters
 }
 
 // Function uses generic parameter in value of a binding.
+#[rustc_polymorphize_error]
 pub fn used_binding<const T: usize>() -> usize {
     let x: usize = T;
     x
 }
 
 // Function uses generic parameter in substitutions to another function.
+#[rustc_polymorphize_error]
 pub fn used_substs<const T: usize>() {
     unused::<T>()
 }
diff --git a/src/test/ui/polymorphization/const_parameters/functions.stderr b/src/test/ui/polymorphization/const_parameters/functions.stderr
@@ -1,14 +1,14 @@
 warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/functions.rs:3:12
+  --> $DIR/functions.rs:2:12
    |
-LL | #![feature(const_generics)]
+LL | #![feature(const_generics, rustc_attrs)]
    |            ^^^^^^^^^^^^^^
    |
    = note: `#[warn(incomplete_features)]` on by default
    = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
 
 error: item has unused generic parameters
-  --> $DIR/functions.rs:13:8
+  --> $DIR/functions.rs:14:8
    |
 LL | pub fn unused<const T: usize>() {
    |        ^^^^^^       - generic parameter `T` is unused
diff --git a/src/test/ui/polymorphization/generators.rs b/src/test/ui/polymorphization/generators.rs
@@ -1,6 +1,5 @@
 // build-fail
-// compile-flags: -Zpolymorphize-errors
-#![feature(const_generics, generators, generator_trait)]
+#![feature(const_generics, generators, generator_trait, rustc_attrs)]
 //~^ WARN the feature `const_generics` is incomplete
 
 use std::marker::Unpin;
@@ -30,6 +29,7 @@ where
 
 // This test checks that the polymorphization analysis functions on generators.
 
+#[rustc_polymorphize_error]
 pub fn unused_type<T>() -> impl Generator<(), Yield = u32, Return = u32> + Unpin {
     //~^ ERROR item has unused generic parameters
     || {
@@ -39,20 +39,23 @@ pub fn unused_type<T>() -> impl Generator<(), Yield = u32, Return = u32> + Unpin
     }
 }
 
+#[rustc_polymorphize_error]
 pub fn used_type_in_yield<Y: Default>() -> impl Generator<(), Yield = Y, Return = u32> + Unpin {
     || {
         yield Y::default();
         2
     }
 }
 
+#[rustc_polymorphize_error]
 pub fn used_type_in_return<R: Default>() -> impl Generator<(), Yield = u32, Return = R> + Unpin {
     || {
         yield 3;
         R::default()
     }
 }
 
+#[rustc_polymorphize_error]
 pub fn unused_const<const T: u32>() -> impl Generator<(), Yield = u32, Return = u32> + Unpin {
     //~^ ERROR item has unused generic parameters
     || {
@@ -62,6 +65,7 @@ pub fn unused_const<const T: u32>() -> impl Generator<(), Yield = u32, Return =
     }
 }
 
+#[rustc_polymorphize_error]
 pub fn used_const_in_yield<const Y: u32>() -> impl Generator<(), Yield = u32, Return = u32> + Unpin
 {
     || {
@@ -70,6 +74,7 @@ pub fn used_const_in_yield<const Y: u32>() -> impl Generator<(), Yield = u32, Re
     }
 }
 
+#[rustc_polymorphize_error]
 pub fn used_const_in_return<const R: u32>() -> impl Generator<(), Yield = u32, Return = u32> + Unpin
 {
     || {
diff --git a/src/test/ui/polymorphization/generators.stderr b/src/test/ui/polymorphization/generators.stderr
@@ -1,7 +1,7 @@
 warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/generators.rs:3:12
+  --> $DIR/generators.rs:2:12
    |
-LL | #![feature(const_generics, generators, generator_trait)]
+LL | #![feature(const_generics, generators, generator_trait, rustc_attrs)]
    |            ^^^^^^^^^^^^^^
    |
    = note: `#[warn(incomplete_features)]` on by default
@@ -27,7 +27,7 @@ LL | pub fn unused_type<T>() -> impl Generator<(), Yield = u32, Return = u32> +
    |        ^^^^^^^^^^^ - generic parameter `T` is unused
 
 error: item has unused generic parameters
-  --> $DIR/generators.rs:58:5
+  --> $DIR/generators.rs:61:5
    |
 LL |   pub fn unused_const<const T: u32>() -> impl Generator<(), Yield = u32, Return = u32> + Unpin {
    |                             - generic parameter `T` is unused
@@ -40,7 +40,7 @@ LL | |     }
    | |_____^
 
 error: item has unused generic parameters
-  --> $DIR/generators.rs:56:8
+  --> $DIR/generators.rs:59:8
    |
 LL | pub fn unused_const<const T: u32>() -> impl Generator<(), Yield = u32, Return = u32> + Unpin {
    |        ^^^^^^^^^^^^       - generic parameter `T` is unused
diff --git a/src/test/ui/polymorphization/lifetimes.rs b/src/test/ui/polymorphization/lifetimes.rs
@@ -1,18 +1,20 @@
 // build-fail
-// compile-flags: -Zpolymorphize-errors
+#![feature(rustc_attrs)]
 
 // This test checks that the polymorphization analysis doesn't break when the
 // function/closure doesn't just have generic parameters.
 
 // Function has an unused generic parameter.
+#[rustc_polymorphize_error]
 pub fn unused<'a, T>(_: &'a u32) {
-//~^ ERROR item has unused generic parameters
+    //~^ ERROR item has unused generic parameters
 }
 
+#[rustc_polymorphize_error]
 pub fn used<'a, T: Default>(_: &'a u32) -> u32 {
     let _: T = Default::default();
     let add_one = |x: u32| x + 1;
-//~^ ERROR item has unused generic parameters
+    //~^ ERROR item has unused generic parameters
     add_one(3)
 }
 
diff --git a/src/test/ui/polymorphization/lifetimes.stderr b/src/test/ui/polymorphization/lifetimes.stderr
@@ -1,11 +1,11 @@
 error: item has unused generic parameters
-  --> $DIR/lifetimes.rs:8:8
+  --> $DIR/lifetimes.rs:9:8
    |
 LL | pub fn unused<'a, T>(_: &'a u32) {
    |        ^^^^^^     - generic parameter `T` is unused
 
 error: item has unused generic parameters
-  --> $DIR/lifetimes.rs:14:19
+  --> $DIR/lifetimes.rs:16:19
    |
 LL | pub fn used<'a, T: Default>(_: &'a u32) -> u32 {
    |                 - generic parameter `T` is unused
diff --git a/src/test/ui/polymorphization/predicates.rs b/src/test/ui/polymorphization/predicates.rs
@@ -1,13 +1,15 @@
 // build-fail
-// compile-flags: -Zpolymorphize-errors
+#![feature(rustc_attrs)]
 
 // This test checks that `T` is considered used in `foo`, because it is used in a predicate for
 // `I`, which is used.
 
+#[rustc_polymorphize_error]
 fn bar<I>() {
-//~^ ERROR item has unused generic parameters
+    //~^ ERROR item has unused generic parameters
 }
 
+#[rustc_polymorphize_error]
 fn foo<I, T>(_: I)
 where
     I: Iterator<Item = T>,
diff --git a/src/test/ui/polymorphization/predicates.stderr b/src/test/ui/polymorphization/predicates.stderr
@@ -1,5 +1,5 @@
 error: item has unused generic parameters
-  --> $DIR/predicates.rs:7:4
+  --> $DIR/predicates.rs:8:4
    |
 LL | fn bar<I>() {
    |    ^^^ - generic parameter `I` is unused
diff --git a/src/test/ui/polymorphization/too-many-generic-params.rs b/src/test/ui/polymorphization/too-many-generic-params.rs
@@ -1,9 +1,10 @@
 // build-pass
-// compile-flags: -Zpolymorphize-errors
+#![feature(rustc_attrs)]
 
 // This test checks that the analysis doesn't panic when there are >64 generic parameters, but
 // instead considers those parameters used.
 
+#[rustc_polymorphize_error]
 fn bar<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA,
        AB, AC, AD, AE, AF, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW,
        AX, AY, AZ, BA, BB, BC, BD, BE, BF, BG, BH, BI, BJ, BK, BL>()
diff --git a/src/test/ui/polymorphization/type_parameters/closures.rs b/src/test/ui/polymorphization/type_parameters/closures.rs
diff --git a/src/test/ui/polymorphization/type_parameters/closures.stderr b/src/test/ui/polymorphization/type_parameters/closures.stderr
diff --git a/src/test/ui/polymorphization/type_parameters/functions.rs b/src/test/ui/polymorphization/type_parameters/functions.rs
diff --git a/src/test/ui/polymorphization/type_parameters/functions.stderr b/src/test/ui/polymorphization/type_parameters/functions.stderr
diff --git a/src/test/ui/polymorphization/unsized_cast.rs b/src/test/ui/polymorphization/unsized_cast.rs
diff --git a/src/test/ui/polymorphization/unsized_cast.stderr b/src/test/ui/polymorphization/unsized_cast.stderr

Original file line number	Diff line number	Diff line change
`@@ -1,14 +1,14 @@`
`1`	`1`	warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes
`2`		`- --> $DIR/functions.rs:3:12`
	`2`	`+ --> $DIR/functions.rs:2:12`
`3`	`3`	`\|`
`4`		`-LL \| #![feature(const_generics)]`
	`4`	`+LL \| #![feature(const_generics, rustc_attrs)]`
`5`	`5`	`\| ^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= note: `#[warn(incomplete_features)]` on by default
`8`	`8`	`= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information`
`9`	`9`
`10`	`10`	`error: item has unused generic parameters`
`11`		`- --> $DIR/functions.rs:13:8`
	`11`	`+ --> $DIR/functions.rs:14:8`
`12`	`12`	`\|`
`13`	`13`	`LL \| pub fn unused<const T: usize>() {`
`14`	`14`	\| ^^^^^^ - generic parameter `T` is unused
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`// build-fail`
`2`		`-// compile-flags: -Zpolymorphize-errors`
`3`		`-#![feature(const_generics, generators, generator_trait)]`
	`2`	`+#![feature(const_generics, generators, generator_trait, rustc_attrs)]`
`4`	`3`	//~^ WARN the feature `const_generics` is incomplete
`5`	`4`
`6`	`5`	`use std::marker::Unpin;`
`@@ -30,6 +29,7 @@ where`
`30`	`29`
`31`	`30`	`// This test checks that the polymorphization analysis functions on generators.`
`32`	`31`
	`32`	`+#[rustc_polymorphize_error]`
`33`	`33`	`pub fn unused_type<T>() -> impl Generator<(), Yield = u32, Return = u32> + Unpin {`
`34`	`34`	`//~^ ERROR item has unused generic parameters`
`35`	`35`	`\|\| {`
`@@ -39,20 +39,23 @@ pub fn unused_type<T>() -> impl Generator<(), Yield = u32, Return = u32> + Unpin`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
	`42`	`+#[rustc_polymorphize_error]`
`42`	`43`	`pub fn used_type_in_yield<Y: Default>() -> impl Generator<(), Yield = Y, Return = u32> + Unpin {`
`43`	`44`	`\|\| {`
`44`	`45`	`yield Y::default();`
`45`	`46`	`2`
`46`	`47`	`}`
`47`	`48`	`}`
`48`	`49`
	`50`	`+#[rustc_polymorphize_error]`
`49`	`51`	`pub fn used_type_in_return<R: Default>() -> impl Generator<(), Yield = u32, Return = R> + Unpin {`
`50`	`52`	`\|\| {`
`51`	`53`	`yield 3;`
`52`	`54`	`R::default()`
`53`	`55`	`}`
`54`	`56`	`}`
`55`	`57`
	`58`	`+#[rustc_polymorphize_error]`
`56`	`59`	`pub fn unused_const<const T: u32>() -> impl Generator<(), Yield = u32, Return = u32> + Unpin {`
`57`	`60`	`//~^ ERROR item has unused generic parameters`
`58`	`61`	`\|\| {`
`@@ -62,6 +65,7 @@ pub fn unused_const<const T: u32>() -> impl Generator<(), Yield = u32, Return =`
`62`	`65`	`}`
`63`	`66`	`}`
`64`	`67`
	`68`	`+#[rustc_polymorphize_error]`
`65`	`69`	`pub fn used_const_in_yield<const Y: u32>() -> impl Generator<(), Yield = u32, Return = u32> + Unpin`
`66`	`70`	`{`
`67`	`71`	`\|\| {`
`@@ -70,6 +74,7 @@ pub fn used_const_in_yield<const Y: u32>() -> impl Generator<(), Yield = u32, Re`
`70`	`74`	`}`
`71`	`75`	`}`
`72`	`76`
	`77`	`+#[rustc_polymorphize_error]`
`73`	`78`	`pub fn used_const_in_return<const R: u32>() -> impl Generator<(), Yield = u32, Return = u32> + Unpin`
`74`	`79`	`{`
`75`	`80`	`\|\| {`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes
`2`		`- --> $DIR/generators.rs:3:12`
	`2`	`+ --> $DIR/generators.rs:2:12`
`3`	`3`	`\|`
`4`		`-LL \| #![feature(const_generics, generators, generator_trait)]`
	`4`	`+LL \| #![feature(const_generics, generators, generator_trait, rustc_attrs)]`
`5`	`5`	`\| ^^^^^^^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= note: `#[warn(incomplete_features)]` on by default
`@@ -27,7 +27,7 @@ LL \| pub fn unused_type<T>() -> impl Generator<(), Yield = u32, Return = u32> +`
`27`	`27`	\| ^^^^^^^^^^^ - generic parameter `T` is unused
`28`	`28`
`29`	`29`	`error: item has unused generic parameters`
`30`		`- --> $DIR/generators.rs:58:5`
	`30`	`+ --> $DIR/generators.rs:61:5`
`31`	`31`	`\|`
`32`	`32`	`LL \| pub fn unused_const<const T: u32>() -> impl Generator<(), Yield = u32, Return = u32> + Unpin {`
`33`	`33`	\| - generic parameter `T` is unused
`@@ -40,7 +40,7 @@ LL \| \| }`
`40`	`40`	`\| \|_____^`
`41`	`41`
`42`	`42`	`error: item has unused generic parameters`
`43`		`- --> $DIR/generators.rs:56:8`
	`43`	`+ --> $DIR/generators.rs:59:8`
`44`	`44`	`\|`
`45`	`45`	`LL \| pub fn unused_const<const T: u32>() -> impl Generator<(), Yield = u32, Return = u32> + Unpin {`
`46`	`46`	\| ^^^^^^^^^^^^ - generic parameter `T` is unused