Remove uninit drops right after building MIR.

Author: cjgillot

compiler/rustc_mir_transform/src/lib.rs

@@ -412,6 +412,7 @@ fn mir_built(tcx: TyCtxt<'_>, def: LocalDefId) -> &Steal<Body<'_>> {
             // This used to be part of MIR building,
             // now done separately to separate concerns.
             &lint_and_remove_uninhabited::LintAndRemoveUninhabited,
+            &remove_uninit_drops::RemoveUninitDrops,
             // MIR-level lints.
             &Lint(check_inline::CheckForceInline),
             &Lint(check_call_recursion::CheckCallRecursion),
@@ -649,7 +650,6 @@ fn run_runtime_lowering_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
         &post_analysis_normalize::PostAnalysisNormalize,
         // Calling this after `PostAnalysisNormalize` ensures that we don't deal with opaque types.
         &add_subtyping_projections::Subtyper,
-        &remove_uninit_drops::RemoveUninitDrops,
         &elaborate_drops::ElaborateDrops,
         // Needs to happen after drop elaboration.
         &Lint(check_call_recursion::CheckDropRecursion),

tests/mir-opt/basic_assignment.main.ElaborateDrops.diff

@@ -35,47 +35,23 @@
           StorageLive(_5);
           StorageLive(_6);
           _6 = move _4;
-          goto -> bb1;
-      }
-  
-      bb1: {
           _5 = move _6;
-          goto -> bb3;
-      }
-  
-      bb2 (cleanup): {
-          _5 = move _6;
-          goto -> bb6;
-      }
-  
-      bb3: {
           StorageDead(_6);
           _0 = const ();
-          drop(_5) -> [return: bb4, unwind: bb7];
+-         drop(_5) -> [return: bb1, unwind continue];
++         drop(_5) -> [return: bb1, unwind: bb2];
       }
 
-      bb4: {
+      bb1: {
           StorageDead(_5);
-          goto -> bb5;
-      }
-  
-      bb5: {
           StorageDead(_4);
           StorageDead(_2);
           StorageDead(_1);
           return;
-      }
-  
-      bb6 (cleanup): {
-          drop(_5) -> [return: bb7, unwind terminate(cleanup)];
-      }
-  
-      bb7 (cleanup): {
-          goto -> bb8;
-      }
-  
-      bb8 (cleanup): {
-          resume;
++     }
++ 
++     bb2 (cleanup): {
++         resume;
       }
   }
 

tests/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir

@@ -41,46 +41,21 @@ fn main() -> () {
         StorageLive(_5);
         StorageLive(_6);
         _6 = move _4;
-        drop(_5) -> [return: bb1, unwind: bb2];
-    }
-
-    bb1: {
-        _5 = move _6;
-        drop(_6) -> [return: bb3, unwind: bb6];
-    }
-
-    bb2 (cleanup): {
         _5 = move _6;
-        drop(_6) -> [return: bb6, unwind terminate(cleanup)];
-    }
-
-    bb3: {
         StorageDead(_6);
         _0 = const ();
-        drop(_5) -> [return: bb4, unwind: bb7];
+        drop(_5) -> [return: bb1, unwind: bb2];
     }
 
-    bb4: {
+    bb1: {
         StorageDead(_5);
-        drop(_4) -> [return: bb5, unwind: bb8];
-    }
-
-    bb5: {
         StorageDead(_4);
         StorageDead(_2);
         StorageDead(_1);
         return;
     }
 
-    bb6 (cleanup): {
-        drop(_5) -> [return: bb7, unwind terminate(cleanup)];
-    }
-
-    bb7 (cleanup): {
-        drop(_4) -> [return: bb8, unwind terminate(cleanup)];
-    }
-
-    bb8 (cleanup): {
+    bb2 (cleanup): {
         resume;
     }
 }

tests/mir-opt/box_conditional_drop_allocator.main.ElaborateDrops.diff

@@ -31,11 +31,11 @@
           _2 = HasDrop;
           StorageLive(_3);
           _3 = DropAllocator;
-          _1 = Box::<HasDrop, DropAllocator>::new_in(move _2, move _3) -> [return: bb1, unwind: bb11];
++         _9 = const true;
+          _1 = Box::<HasDrop, DropAllocator>::new_in(move _2, move _3) -> [return: bb1, unwind continue];
       }
 
       bb1: {
-+         _9 = const true;
           StorageDead(_3);
           StorageDead(_2);
           StorageLive(_4);
@@ -47,7 +47,7 @@
           StorageLive(_5);
           StorageLive(_6);
           _6 = move (*_1);
-          _5 = std::mem::drop::<HasDrop>(move _6) -> [return: bb3, unwind: bb9];
+          _5 = std::mem::drop::<HasDrop>(move _6) -> [return: bb3, unwind: bb8];
       }
 
       bb3: {
@@ -75,7 +75,7 @@
       bb6: {
           StorageDead(_4);
 -         drop(_1) -> [return: bb7, unwind continue];
-+         goto -> bb23;
++         goto -> bb19;
       }
 
       bb7: {
@@ -85,98 +85,82 @@
       }
 
       bb8 (cleanup): {
-          goto -> bb10;
+-         drop(_1) -> [return: bb9, unwind terminate(cleanup)];
++         goto -> bb25;
       }
 
       bb9 (cleanup): {
-          goto -> bb10;
-      }
-  
-      bb10 (cleanup): {
--         drop(_1) -> [return: bb13, unwind terminate(cleanup)];
-+         goto -> bb29;
-      }
-  
-      bb11 (cleanup): {
-          goto -> bb12;
-      }
-  
-      bb12 (cleanup): {
-          goto -> bb13;
-      }
-  
-      bb13 (cleanup): {
           resume;
 +     }
 + 
-+     bb14: {
++     bb10: {
 +         _9 = const false;
 +         goto -> bb7;
 +     }
 + 
-+     bb15 (cleanup): {
-+         drop((_1.1: DropAllocator)) -> [return: bb13, unwind terminate(cleanup)];
++     bb11 (cleanup): {
++         drop((_1.1: DropAllocator)) -> [return: bb9, unwind terminate(cleanup)];
 +     }
 + 
-+     bb16 (cleanup): {
-+         switchInt(copy _9) -> [0: bb13, otherwise: bb15];
++     bb12 (cleanup): {
++         switchInt(copy _9) -> [0: bb9, otherwise: bb11];
 +     }
 + 
-+     bb17: {
-+         drop((_1.1: DropAllocator)) -> [return: bb14, unwind: bb13];
++     bb13: {
++         drop((_1.1: DropAllocator)) -> [return: bb10, unwind: bb9];
 +     }
 + 
-+     bb18: {
-+         switchInt(copy _9) -> [0: bb14, otherwise: bb17];
++     bb14: {
++         switchInt(copy _9) -> [0: bb10, otherwise: bb13];
 +     }
 + 
-+     bb19: {
++     bb15: {
 +         _10 = &mut _1;
-+         _11 = <Box<HasDrop, DropAllocator> as Drop>::drop(move _10) -> [return: bb18, unwind: bb16];
++         _11 = <Box<HasDrop, DropAllocator> as Drop>::drop(move _10) -> [return: bb14, unwind: bb12];
 +     }
 + 
-+     bb20 (cleanup): {
++     bb16 (cleanup): {
 +         _12 = &mut _1;
-+         _13 = <Box<HasDrop, DropAllocator> as Drop>::drop(move _12) -> [return: bb16, unwind terminate(cleanup)];
++         _13 = <Box<HasDrop, DropAllocator> as Drop>::drop(move _12) -> [return: bb12, unwind terminate(cleanup)];
 +     }
 + 
-+     bb21: {
-+         goto -> bb19;
++     bb17: {
++         goto -> bb15;
 +     }
 + 
-+     bb22: {
++     bb18: {
 +         _14 = copy ((_1.0: std::ptr::Unique<HasDrop>).0: std::ptr::NonNull<HasDrop>) as *const HasDrop (Transmute);
-+         goto -> bb21;
++         goto -> bb17;
 +     }
 + 
-+     bb23: {
-+         switchInt(copy _9) -> [0: bb18, otherwise: bb22];
++     bb19: {
++         switchInt(copy _9) -> [0: bb14, otherwise: bb18];
 +     }
 + 
-+     bb24 (cleanup): {
-+         drop((_1.1: DropAllocator)) -> [return: bb13, unwind terminate(cleanup)];
++     bb20 (cleanup): {
++         drop((_1.1: DropAllocator)) -> [return: bb9, unwind terminate(cleanup)];
 +     }
 + 
-+     bb25 (cleanup): {
-+         switchInt(copy _9) -> [0: bb13, otherwise: bb24];
++     bb21 (cleanup): {
++         switchInt(copy _9) -> [0: bb9, otherwise: bb20];
 +     }
 + 
-+     bb26 (cleanup): {
++     bb22 (cleanup): {
 +         _15 = &mut _1;
-+         _16 = <Box<HasDrop, DropAllocator> as Drop>::drop(move _15) -> [return: bb25, unwind terminate(cleanup)];
++         _16 = <Box<HasDrop, DropAllocator> as Drop>::drop(move _15) -> [return: bb21, unwind terminate(cleanup)];
 +     }
 + 
-+     bb27 (cleanup): {
-+         goto -> bb26;
++     bb23 (cleanup): {
++         goto -> bb22;
 +     }
 + 
-+     bb28 (cleanup): {
++     bb24 (cleanup): {
 +         _17 = copy ((_1.0: std::ptr::Unique<HasDrop>).0: std::ptr::NonNull<HasDrop>) as *const HasDrop (Transmute);
-+         goto -> bb27;
++         goto -> bb23;
 +     }
 + 
-+     bb29 (cleanup): {
-+         switchInt(copy _9) -> [0: bb25, otherwise: bb28];
++     bb25 (cleanup): {
++         switchInt(copy _9) -> [0: bb21, otherwise: bb24];
       }
   }
 

tests/mir-opt/box_partial_move.maybe_move.ElaborateDrops.diff

@@ -19,70 +19,62 @@
 +         _5 = const true;
           StorageLive(_3);
           _3 = copy _1;
-          switchInt(move _3) -> [0: bb3, otherwise: bb1];
+          switchInt(move _3) -> [0: bb2, otherwise: bb1];
       }
 
       bb1: {
           StorageLive(_4);
 +         _5 = const false;
           _4 = move (*_2);
           _0 = Option::<String>::Some(move _4);
-          goto -> bb2;
-      }
-  
-      bb2: {
           StorageDead(_4);
-          goto -> bb4;
+          goto -> bb3;
       }
 
-      bb3: {
+      bb2: {
           _0 = Option::<String>::None;
-          goto -> bb4;
+          goto -> bb3;
       }
 
-      bb4: {
+      bb3: {
           StorageDead(_3);
--         drop(_2) -> [return: bb5, unwind continue];
-+         goto -> bb13;
+-         drop(_2) -> [return: bb4, unwind continue];
++         goto -> bb11;
       }
 
-      bb5: {
+      bb4: {
           return;
-      }
-  
-      bb6 (cleanup): {
-          drop(_2) -> [return: bb7, unwind terminate(cleanup)];
-      }
-  
-      bb7 (cleanup): {
-          resume;
 +     }
 + 
-+     bb8: {
++     bb5 (cleanup): {
++         resume;
++     }
++ 
++     bb6: {
 +         _6 = &mut _2;
-+         _7 = <Box<String> as Drop>::drop(move _6) -> [return: bb5, unwind: bb7];
++         _7 = <Box<String> as Drop>::drop(move _6) -> [return: bb4, unwind: bb5];
 +     }
 + 
-+     bb9 (cleanup): {
++     bb7 (cleanup): {
 +         _8 = &mut _2;
-+         _9 = <Box<String> as Drop>::drop(move _8) -> [return: bb7, unwind terminate(cleanup)];
++         _9 = <Box<String> as Drop>::drop(move _8) -> [return: bb5, unwind terminate(cleanup)];
 +     }
 + 
-+     bb10: {
-+         goto -> bb12;
++     bb8: {
++         goto -> bb10;
 +     }
 + 
-+     bb11: {
-+         drop((*_10)) -> [return: bb8, unwind: bb9];
++     bb9: {
++         drop((*_10)) -> [return: bb6, unwind: bb7];
 +     }
 + 
-+     bb12: {
-+         switchInt(copy _5) -> [0: bb8, otherwise: bb11];
++     bb10: {
++         switchInt(copy _5) -> [0: bb6, otherwise: bb9];
 +     }
 + 
-+     bb13: {
++     bb11: {
 +         _10 = copy ((_2.0: std::ptr::Unique<std::string::String>).0: std::ptr::NonNull<std::string::String>) as *const std::string::String (Transmute);
-+         goto -> bb10;
++         goto -> bb8;
       }
   }