review updates

Author: x17jiri

compiler/rustc_codegen_cranelift/src/base.rs

@@ -814,7 +814,7 @@ fn codegen_stmt<'tcx>(
         StatementKind::Coverage { .. } => fx.tcx.dcx().fatal("-Zcoverage is unimplemented"),
         StatementKind::Intrinsic(ref intrinsic) => match &**intrinsic {
             // We ignore `assume` intrinsics, they are only useful for optimizations
-            NonDivergingIntrinsic::Assume(_) => {}
+            NonDivergingIntrinsic::Assume(_) | NonDivergingIntrinsic::Expect(..) => {}
             NonDivergingIntrinsic::CopyNonOverlapping(mir::CopyNonOverlapping {
                 src,
                 dst,

compiler/rustc_codegen_cranelift/src/constant.rs

@@ -503,7 +503,9 @@ pub(crate) fn mir_operand_get_const_val<'tcx>(
                         }
                         StatementKind::Intrinsic(ref intrinsic) => match **intrinsic {
                             NonDivergingIntrinsic::CopyNonOverlapping(..) => return None,
-                            NonDivergingIntrinsic::Assume(..) => {}
+
+                            NonDivergingIntrinsic::Assume(..)
+                            | NonDivergingIntrinsic::Expect(..) => {}
                         },
                         // conservative handling
                         StatementKind::Assign(_)

compiler/rustc_codegen_gcc/src/builder.rs

@@ -27,6 +27,7 @@ use rustc_codegen_ssa::traits::{
     BaseTypeMethods,
     BuilderMethods,
     ConstMethods,
+    ExpectKind,
     LayoutTypeMethods,
     HasCodegen,
     OverflowOp,
@@ -454,26 +455,26 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         self.llbb().end_with_conditional(None, cond, then_block, else_block)
     }
 
-    /* FIXME: implement
     fn cond_br_with_expect(
         &mut self,
-        cond: &'ll Value,
-        then_llbb: &'ll BasicBlock,
-        else_llbb: &'ll BasicBlock,
-        expect: ExpectKind,
+        cond: RValue<'gcc>,
+        then_block: Block<'gcc>,
+        else_block: Block<'gcc>,
+        _expect: ExpectKind,
     ) {
-        // emit expectation
+        /*
+        // FIXME: emit expectation
         match expect {
             ExpectKind::None => {}
             ExpectKind::True => self.expect(cond.immediate(), true),
             ExpectKind::False => self.expect(cond.immediate(), false),
             ExpectKind::Unpredictable => {} // FIXME
         }
+        */
 
         // emit the branch instruction
         self.llbb().end_with_conditional(None, cond, then_block, else_block)
     }
-    */
 
     fn switch(&mut self, value: RValue<'gcc>, default_block: Block<'gcc>, cases: impl ExactSizeIterator<Item = (u128, Block<'gcc>)>) {
         let mut gcc_cases = vec![];

src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs

@@ -213,7 +213,9 @@ fn check_statement<'tcx>(
             check_place(tcx, **place, span, body)
         },
 
-        StatementKind::Intrinsic(box NonDivergingIntrinsic::Assume(op)) => check_operand(tcx, op, span, body),
+        StatementKind::Intrinsic(box NonDivergingIntrinsic::Assume(op))
+        | StatementKind::Intrinsic(box NonDivergingIntrinsic::Expect(op, ..))
+        => check_operand(tcx, op, span, body),
 
         StatementKind::Intrinsic(box NonDivergingIntrinsic::CopyNonOverlapping(
             rustc_middle::mir::CopyNonOverlapping { dst, src, count },