Filter out builtin lint passes that don't need to be run

compiler/rustc_index/src/idx.rs

@@ -43,3 +43,15 @@ impl Idx for u32 {
         self as usize
     }
 }
+
+impl Idx for u8 {
+    #[inline]
+    fn new(idx: usize) -> Self {
+        assert!(idx <= u8::MAX as usize);
+        idx as u8
+    }
+    #[inline]
+    fn index(self) -> usize {
+        self as usize
+    }
+}

compiler/rustc_lint/src/late.rs

@@ -302,12 +302,12 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas
 // `check_foo` method in `$methods` within this pass simply calls `check_foo`
 // once per `$pass`. Compare with `declare_combined_late_lint_pass`, which is
 // similar, but combines lint passes at compile time.
-struct RuntimeCombinedLateLintPass<'a, 'tcx> {
-    passes: &'a mut [LateLintPassObject<'tcx>],
+struct RuntimeCombinedLateLintPass<'tcx> {
+    passes: Vec<LateLintPassObject<'tcx>>,
 }
 
 #[allow(rustc::lint_pass_impl_without_macro)]
-impl LintPass for RuntimeCombinedLateLintPass<'_, '_> {
+impl LintPass for RuntimeCombinedLateLintPass<'_> {
     fn name(&self) -> &'static str {
         panic!()
     }
@@ -318,7 +318,7 @@ impl LintPass for RuntimeCombinedLateLintPass<'_, '_> {
 
 macro_rules! impl_late_lint_pass {
     ([], [$($(#[$attr:meta])* fn $f:ident($($param:ident: $arg:ty),*);)*]) => {
-        impl<'tcx> LateLintPass<'tcx> for RuntimeCombinedLateLintPass<'_, 'tcx> {
+        impl<'tcx> LateLintPass<'tcx> for RuntimeCombinedLateLintPass<'tcx> {
             $(fn $f(&mut self, context: &LateContext<'tcx>, $($param: $arg),*) {
                 for pass in self.passes.iter_mut() {
                     pass.$f(context, $($param),*);
@@ -355,14 +355,14 @@ pub fn late_lint_mod<'tcx, T: LateLintPass<'tcx> + 'tcx>(
         late_lint_mod_inner(tcx, module_def_id, context, builtin_lints);
     } else {
         let builtin_lints = Box::new(builtin_lints) as Box<dyn LateLintPass<'tcx>>;
-        let mut binding = store
+        let passes = store
             .late_module_passes
             .iter()
             .map(|mk_pass| (mk_pass)(tcx))
             .chain(std::iter::once(builtin_lints))
             .collect::<Vec<_>>();
 
-        let pass = RuntimeCombinedLateLintPass { passes: binding.as_mut_slice() };
+        let pass = RuntimeCombinedLateLintPass { passes };
         late_lint_mod_inner(tcx, module_def_id, context, pass);
     }
 }
@@ -393,10 +393,10 @@ fn late_lint_mod_inner<'tcx, T: LateLintPass<'tcx>>(
 
 fn late_lint_crate<'tcx>(tcx: TyCtxt<'tcx>) {
     // Note: `passes` is often empty.
-    let passes: Vec<_> =
+    let unfiltered_passes: Vec<_> =
         unerased_lint_store(tcx.sess).late_passes.iter().map(|mk_pass| (mk_pass)(tcx)).collect();
 
-    if passes.is_empty() {
+    if unfiltered_passes.is_empty() {
         return;
     }
 
@@ -413,7 +413,7 @@ fn late_lint_crate<'tcx>(tcx: TyCtxt<'tcx>) {
 
     let lints_that_dont_need_to_run = tcx.lints_that_dont_need_to_run(());
 
-    let mut filtered_passes: Vec<Box<dyn LateLintPass<'tcx>>> = passes
+    let mut passes: Vec<Box<dyn LateLintPass<'tcx>>> = unfiltered_passes
         .into_iter()
         .filter(|pass| {
             let lints = (**pass).get_lints();
@@ -424,8 +424,8 @@ fn late_lint_crate<'tcx>(tcx: TyCtxt<'tcx>) {
         })
         .collect();
 
-    filtered_passes.push(Box::new(HardwiredLints));
-    let pass = RuntimeCombinedLateLintPass { passes: &mut filtered_passes[..] };
+    passes.push(Box::new(HardwiredLints));
+    let pass = RuntimeCombinedLateLintPass { passes };
     late_lint_crate_inner(tcx, context, pass);
 }
 

compiler/rustc_lint/src/lib.rs

@@ -30,6 +30,7 @@
 #![feature(if_let_guard)]
 #![feature(iter_order_by)]
 #![feature(let_chains)]
+#![feature(macro_metavar_expr)]
 #![feature(rustc_attrs)]
 #![feature(rustdoc_internals)]
 #![feature(trait_upcasting)]
@@ -146,7 +147,7 @@ pub fn provide(providers: &mut Providers) {
 }
 
 fn lint_mod(tcx: TyCtxt<'_>, module_def_id: LocalModDefId) {
-    late_lint_mod(tcx, module_def_id, BuiltinCombinedModuleLateLintPass::new());
+    late_lint_mod(tcx, module_def_id, BuiltinCombinedModuleLateLintPass::new(tcx));
 }
 
 early_lint_methods!(

compiler/rustc_lint/src/passes.rs

@@ -75,7 +75,11 @@ impl LateLintPass<'_> for HardwiredLints {}
 #[macro_export]
 macro_rules! expand_combined_late_lint_pass_method {
     ([$($pass:ident),*], $self: ident, $name: ident, $params:tt) => ({
-        $($self.$pass.$name $params;)*
+        $(
+            if $self.enabled_passes.contains(EnabledPasses::$pass as u8) {
+                $self.$pass.$name $params;
+            }
+        )*
     })
 }
 
@@ -96,15 +100,37 @@ macro_rules! expand_combined_late_lint_pass_methods {
 #[macro_export]
 macro_rules! declare_combined_late_lint_pass {
     ([$v:vis $name:ident, [$($pass:ident: $constructor:expr,)*]], $methods:tt) => (
+        #[repr(u8)]
+        enum EnabledPasses {
+            $($pass,)*
+        }
+
         #[allow(non_snake_case)]
         $v struct $name {
+            enabled_passes: rustc_index::bit_set::DenseBitSet<u8>,
             $($pass: $pass,)*
         }
 
         impl $name {
-            $v fn new() -> Self {
+            #[allow(non_snake_case)]
+            $v fn new<'tcx>(tcx: TyCtxt<'tcx>) -> Self {
+                let mut enabled_passes = rustc_index::bit_set::DenseBitSet::new_filled(${count($pass)});
+                let lints_that_dont_need_to_run = tcx.lints_that_dont_need_to_run(());
+                $(
+                    let $pass = $constructor;
+                    {
+                        let lints = $pass.get_lints();
+                        // If the pass doesn't have a single needed lint, omit it.
+                        if !lints.is_empty()
+                            && lints.iter().all(|lint| lints_that_dont_need_to_run.contains(&LintId::of(lint)))
+                        {
+                            enabled_passes.remove(EnabledPasses::$pass as u8);
+                        }
+                    }
+                )*
                 Self {
-                    $($pass: $constructor,)*
+                    enabled_passes,
+                    $($pass,)*
                 }
             }
 

tests/ui/print_type_sizes/multiple_types.rs

@@ -11,3 +11,8 @@ pub enum Enum {
     Small(SevenBytes),
     Large(FiftyBytes),
 }
+
+fn main() {
+    let x = Enum::Small(SevenBytes([0; 7]));
+    let x = Enum::Large(FiftyBytes([0; 50]));
+}

tests/ui/print_type_sizes/padding.rs

@@ -26,3 +26,9 @@ enum E2 {
     A(i8, i32),
     B(S),
 }
+
+fn main() {
+    let s = S { a: true, b: true, g: 0 };
+    let e1 = E1::A(0, 0);
+    let e2 = E2::A(0, 0);
+}

tests/ui/print_type_sizes/repr-align.rs

@@ -30,3 +30,14 @@ pub struct S {
     c: A,
     d: i8,
 }
+
+fn main() {
+    let s = S {
+        a: 0,
+        b: 0,
+        c: A(0),
+        d: 0,
+    };
+
+    let e = E::A(0);
+}

tests/ui/print_type_sizes/repr_int_c.rs

@@ -17,3 +17,8 @@ enum Repru8 {
     A(u16),
     B,
 }
+
+fn main() {
+    let c = ReprCu8::A(0);
+    let r = Repru8::A(0);
+}

tests/ui/print_type_sizes/variants.rs

@@ -16,3 +16,8 @@ pub enum Enum {
     Small(SevenBytes),
     Large(FiftyBytes),
 }
+
+fn main() {
+    let x = Enum::Small(SevenBytes([0; 7]));
+    let x = Enum::Large(FiftyBytes([0; 50]));
+}