lower ExprKind::Use, LogicalOp::Or and UnOp::Not

Co-authored-by: Abdulaziz Ghuloum <aghuloum@gmail.com>

Author: dingxiangfei2009

compiler/rustc_mir_build/src/build/matches/mod.rs

@@ -64,6 +64,43 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                 rhs_then_block.unit()
             }
+            ExprKind::LogicalOp { op: LogicalOp::Or, lhs, rhs } => {
+                let local_scope = this.local_scope();
+                let (lhs_success_block, failure_block) =
+                    this.in_if_then_scope(local_scope, expr_span, |this| {
+                        this.then_else_break(
+                            block,
+                            &this.thir[lhs],
+                            temp_scope_override,
+                            local_scope,
+                            variable_source_info,
+                        )
+                    });
+                let rhs_success_block = unpack!(this.then_else_break(
+                    failure_block,
+                    &this.thir[rhs],
+                    temp_scope_override,
+                    break_scope,
+                    variable_source_info,
+                ));
+                this.cfg.goto(lhs_success_block, variable_source_info, rhs_success_block);
+                rhs_success_block.unit()
+            }
+            ExprKind::Unary { op: UnOp::Not, arg } => {
+                let local_scope = this.local_scope();
+                let (success_block, failure_block) =
+                    this.in_if_then_scope(local_scope, expr_span, |this| {
+                        this.then_else_break(
+                            block,
+                            &this.thir[arg],
+                            temp_scope_override,
+                            local_scope,
+                            variable_source_info,
+                        )
+                    });
+                this.break_for_else(success_block, break_scope, variable_source_info);
+                failure_block.unit()
+            }
             ExprKind::Scope { region_scope, lint_level, value } => {
                 let region_scope = (region_scope, this.source_info(expr_span));
                 this.in_scope(region_scope, lint_level, |this| {
@@ -76,6 +113,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     )
                 })
             }
+            ExprKind::Use { source } => this.then_else_break(
+                block,
+                &this.thir[source],
+                temp_scope_override,
+                break_scope,
+                variable_source_info,
+            ),
             ExprKind::Let { expr, ref pat } => this.lower_let_expr(
                 block,
                 &this.thir[expr],

tests/mir-opt/bool_compare.opt1.InstSimplify.diff

@@ -13,16 +13,17 @@
           _3 = _1;
 -         _2 = Ne(move _3, const true);
 +         _2 = Not(move _3);
-          StorageDead(_3);
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
       }
 
       bb1: {
+          StorageDead(_3);
           _0 = const 0_u32;
           goto -> bb3;
       }
 
       bb2: {
+          StorageDead(_3);
           _0 = const 1_u32;
           goto -> bb3;
       }

tests/mir-opt/bool_compare.opt2.InstSimplify.diff

@@ -13,16 +13,17 @@
           _3 = _1;
 -         _2 = Ne(const true, move _3);
 +         _2 = Not(move _3);
-          StorageDead(_3);
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
       }
 
       bb1: {
+          StorageDead(_3);
           _0 = const 0_u32;
           goto -> bb3;
       }
 
       bb2: {
+          StorageDead(_3);
           _0 = const 1_u32;
           goto -> bb3;
       }

tests/mir-opt/bool_compare.opt3.InstSimplify.diff

@@ -13,16 +13,17 @@
           _3 = _1;
 -         _2 = Eq(move _3, const false);
 +         _2 = Not(move _3);
-          StorageDead(_3);
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
       }
 
       bb1: {
+          StorageDead(_3);
           _0 = const 0_u32;
           goto -> bb3;
       }
 
       bb2: {
+          StorageDead(_3);
           _0 = const 1_u32;
           goto -> bb3;
       }

tests/mir-opt/bool_compare.opt4.InstSimplify.diff

@@ -13,16 +13,17 @@
           _3 = _1;
 -         _2 = Eq(const false, move _3);
 +         _2 = Not(move _3);
-          StorageDead(_3);
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
       }
 
       bb1: {
+          StorageDead(_3);
           _0 = const 0_u32;
           goto -> bb3;
       }
 
       bb2: {
+          StorageDead(_3);
           _0 = const 1_u32;
           goto -> bb3;
       }

tests/mir-opt/building/logical_or_in_conditional.test_complex.built.after.mir

@@ -7,22 +7,19 @@ fn test_complex() -> () {
     let mut _3: isize;
     let mut _4: bool;
     let mut _5: bool;
-    let mut _6: bool;
-    let mut _7: bool;
-    let mut _8: u8;
-    let mut _9: Droppy;
-    let mut _10: bool;
-    let mut _11: u8;
-    let mut _12: Droppy;
-    let mut _13: bool;
-    let mut _14: bool;
-    let mut _15: E;
-    let mut _16: isize;
+    let mut _6: u8;
+    let mut _7: Droppy;
+    let mut _8: bool;
+    let mut _9: u8;
+    let mut _10: Droppy;
+    let mut _11: bool;
+    let mut _12: E;
+    let mut _13: isize;
 
     bb0: {
         StorageLive(_1);
         StorageLive(_2);
-        _2 = E::f() -> [return: bb1, unwind: bb27];
+        _2 = E::f() -> [return: bb1, unwind: bb31];
     }
 
     bb1: {
@@ -36,145 +33,154 @@ fn test_complex() -> () {
     }
 
     bb3: {
-        goto -> bb16;
+        goto -> bb19;
     }
 
     bb4: {
         StorageLive(_4);
-        StorageLive(_5);
-        StorageLive(_6);
-        _6 = always_true() -> [return: bb11, unwind: bb27];
+        _4 = always_true() -> [return: bb5, unwind: bb31];
     }
 
     bb5: {
-        _4 = const true;
-        goto -> bb7;
+        switchInt(move _4) -> [0: bb7, otherwise: bb6];
     }
 
     bb6: {
-        StorageLive(_10);
-        StorageLive(_11);
-        StorageLive(_12);
-        _12 = Droppy(const 1_u8);
-        _11 = (_12.0: u8);
-        _10 = Gt(move _11, const 1_u8);
-        drop(_12) -> [return: bb13, unwind: bb27];
+        StorageLive(_5);
+        StorageLive(_6);
+        StorageLive(_7);
+        _7 = Droppy(const 0_u8);
+        _6 = (_7.0: u8);
+        _5 = Gt(move _6, const 0_u8);
+        switchInt(move _5) -> [0: bb9, otherwise: bb8];
     }
 
     bb7: {
-        StorageDead(_10);
-        StorageDead(_5);
-        switchInt(move _4) -> [0: bb15, otherwise: bb14];
+        goto -> bb13;
     }
 
     bb8: {
-        _5 = const false;
-        goto -> bb10;
+        drop(_7) -> [return: bb10, unwind: bb31];
     }
 
     bb9: {
-        StorageLive(_7);
-        StorageLive(_8);
-        StorageLive(_9);
-        _9 = Droppy(const 0_u8);
-        _8 = (_9.0: u8);
-        _7 = Gt(move _8, const 0_u8);
-        drop(_9) -> [return: bb12, unwind: bb27];
+        goto -> bb11;
     }
 
     bb10: {
         StorageDead(_7);
         StorageDead(_6);
-        switchInt(move _5) -> [0: bb6, otherwise: bb5];
+        goto -> bb16;
     }
 
     bb11: {
-        switchInt(move _6) -> [0: bb8, otherwise: bb9];
+        drop(_7) -> [return: bb12, unwind: bb31];
     }
 
     bb12: {
-        StorageDead(_9);
-        StorageDead(_8);
-        _5 = move _7;
-        goto -> bb10;
+        StorageDead(_7);
+        StorageDead(_6);
+        goto -> bb13;
     }
 
     bb13: {
-        StorageDead(_12);
-        StorageDead(_11);
-        _4 = move _10;
-        goto -> bb7;
+        StorageLive(_8);
+        StorageLive(_9);
+        StorageLive(_10);
+        _10 = Droppy(const 1_u8);
+        _9 = (_10.0: u8);
+        _8 = Gt(move _9, const 1_u8);
+        switchInt(move _8) -> [0: bb15, otherwise: bb14];
     }
 
     bb14: {
-        _1 = const ();
-        goto -> bb17;
+        drop(_10) -> [return: bb16, unwind: bb31];
     }
 
     bb15: {
-        goto -> bb16;
+        goto -> bb17;
     }
 
     bb16: {
+        StorageDead(_10);
+        StorageDead(_9);
         _1 = const ();
-        goto -> bb17;
+        goto -> bb20;
     }
 
     bb17: {
-        StorageDead(_4);
-        StorageDead(_2);
-        StorageDead(_1);
-        StorageLive(_13);
-        StorageLive(_14);
-        _14 = always_true() -> [return: bb18, unwind: bb27];
+        drop(_10) -> [return: bb18, unwind: bb31];
     }
 
     bb18: {
-        _13 = Not(move _14);
-        StorageDead(_14);
-        switchInt(move _13) -> [0: bb20, otherwise: bb19];
+        StorageDead(_10);
+        StorageDead(_9);
+        goto -> bb19;
     }
 
     bb19: {
-        StorageLive(_15);
-        _15 = E::f() -> [return: bb21, unwind: bb27];
+        _1 = const ();
+        goto -> bb20;
     }
 
     bb20: {
-        goto -> bb25;
+        StorageDead(_8);
+        StorageDead(_5);
+        StorageDead(_4);
+        StorageDead(_2);
+        StorageDead(_1);
+        StorageLive(_11);
+        _11 = always_true() -> [return: bb21, unwind: bb31];
     }
 
     bb21: {
-        FakeRead(ForMatchedPlace(None), _15);
-        _16 = discriminant(_15);
-        switchInt(move _16) -> [1: bb23, otherwise: bb22];
+        switchInt(move _11) -> [0: bb23, otherwise: bb22];
     }
 
     bb22: {
-        goto -> bb25;
+        goto -> bb29;
     }
 
     bb23: {
-        falseEdge -> [real: bb24, imaginary: bb22];
+        goto -> bb24;
     }
 
     bb24: {
-        _0 = const ();
-        goto -> bb26;
+        StorageLive(_12);
+        _12 = E::f() -> [return: bb25, unwind: bb31];
     }
 
     bb25: {
-        _0 = const ();
-        goto -> bb26;
+        FakeRead(ForMatchedPlace(None), _12);
+        _13 = discriminant(_12);
+        switchInt(move _13) -> [1: bb27, otherwise: bb26];
     }
 
     bb26: {
-        StorageDead(_13);
-        StorageDead(_15);
+        goto -> bb29;
+    }
+
+    bb27: {
+        falseEdge -> [real: bb28, imaginary: bb26];
+    }
+
+    bb28: {
+        _0 = const ();
+        goto -> bb30;
+    }
+
+    bb29: {
+        _0 = const ();
+        goto -> bb30;
+    }
+
+    bb30: {
+        StorageDead(_11);
+        StorageDead(_12);
         return;
     }
 
-    bb27 (cleanup): {
+    bb31 (cleanup): {
         resume;
     }
 }