Support float in conditions.

Author: hkalbasi

co2_hir/src/ty.rs

@@ -378,6 +378,7 @@ pub(crate) fn is_condition_ty(ty: Ty) -> bool {
             RigidTy::Bool
                 | RigidTy::Int(_)
                 | RigidTy::Uint(_)
+                | RigidTy::Float(_)
                 | RigidTy::RawPtr(_, _)
                 | RigidTy::FnPtr(_)
                 | RigidTy::FnDef(_, _)

co2_mir/src/operand.rs

@@ -1580,6 +1580,32 @@ impl Builder<'_, '_> {
             });
             return MirOperand::Copy(place(bool_local));
         }
+        if dst_is_bool && src_is_float {
+            let TyKind::RigidTy(RigidTy::Float(float_ty)) = src_ty.kind() else {
+                unreachable!("src_is_float implies float type");
+            };
+            let zero = MirOperand::Constant(ConstOperand {
+                span,
+                user_ty: None,
+                const_: MirConst::try_from_float(0.0, float_ty).expect("failed to build float zero"),
+            });
+            let bool_local = self.new_temp(Ty::bool_ty(), Mutability::Mut, span);
+            self.stmts.push(MirStatement {
+                kind: MirStatementKind::Assign(
+                    place(bool_local),
+                    Rvalue::BinaryOp(
+                        rustc_public_generative::rustc_public::mir::BinOp::Ne,
+                        inner_op,
+                        zero,
+                    ),
+                ),
+                source_info: SourceInfo {
+                    span,
+                    scope: self.current_scope(),
+                },
+            });
+            return MirOperand::Copy(place(bool_local));
+        }
         if src_is_int && dst_is_int {
             let tmp = self.new_temp(dst_ty, Mutability::Mut, span);
             self.stmts.push(MirStatement {

rustc_public_generative/src/internal.rs

@@ -2207,11 +2207,9 @@ impl<S: CrateGeneratorState> InterfaceCallbacks<S> {
             let sigs = ItemSignatureInfo::from_hir_structure(&hir_structure);
             {
                 let mut guard = gate.state.try_lock().unwrap();
-                guard.defined_crate.advance_to_stage2(
-                    sigs.clone(),
-                    state,
-                    context.clone(),
-                );
+                guard
+                    .defined_crate
+                    .advance_to_stage2(sigs.clone(), state, context.clone());
             }
             if should_patch_cached_resolutions(tcx) {
                 augment_cached_generated_resolutions(tcx);

tests/c/float/condition.c

@@ -0,0 +1,129 @@
+//@ mode: c
+//@ run-status: 0
+
+#include <assert.h>
+#include <math.h>
+#include <float.h>
+
+int main(void)
+{
+    /* Basic truth values */
+    assert((0.0 ? 0 : 1) == 1);
+    assert((-0.0 ? 0 : 1) == 1);
+    assert((1.0 ? 1 : 0) == 1);
+    assert((-1.0 ? 1 : 0) == 1);
+
+    /* Smallest values */
+    assert((DBL_MIN ? 1 : 0) == 1);
+
+#if __STDC_VERSION__ >= 201112L
+    assert((DBL_TRUE_MIN ? 1 : 0) == 1);
+#endif
+
+    /* Infinity and NaN */
+    assert((INFINITY ? 1 : 0) == 1);
+    assert((-INFINITY ? 1 : 0) == 1);
+    assert((NAN ? 1 : 0) == 1);
+
+    /* if */
+    {
+        int x = 0;
+        if (3.14)
+            x = 1;
+        assert(x == 1);
+
+        x = 0;
+        if (0.0)
+            x = 1;
+        else
+            x = 2;
+        assert(x == 2);
+    }
+
+    /* while */
+    {
+        int n = 0;
+        while (2.0) {
+            ++n;
+            break;
+        }
+        assert(n == 1);
+
+        n = 0;
+        while (0.0)
+            ++n;
+        assert(n == 0);
+    }
+
+    /* do-while */
+    {
+        int n = 0;
+        do {
+            ++n;
+        } while (0.0);
+        assert(n == 1);
+
+        n = 0;
+        do {
+            ++n;
+        } while (2.0 && n < 3);
+        assert(n == 3);
+    }
+
+    /* for */
+    {
+        int n = 0;
+        for (; 1.0; ) {
+            ++n;
+            break;
+        }
+        assert(n == 1);
+
+        n = 0;
+        for (; 0.0; )
+            ++n;
+        assert(n == 0);
+    }
+
+    /* switch using ?: whose condition is floating-point */
+    {
+        switch (0.5 ? 10 : 20) {
+        case 10:
+            break;
+        default:
+            assert(0);
+        }
+
+        switch (0.0 ? 10 : 20) {
+        case 20:
+            break;
+        default:
+            assert(0);
+        }
+
+        switch (NAN ? 1 : 2) {
+        case 1:
+            break;
+        default:
+            assert(0);
+        }
+    }
+
+    /* Nested conditional operators */
+    assert((0.0 ? 1 : 2.0 ? 3 : 4) == 3);
+    assert((0.0 ? 1 : 0.0 ? 3 : 4) == 4);
+    assert((NAN ? 5 : 6) == 5);
+
+    /* Volatile values (prevent over-optimization) */
+    {
+        volatile double z = 0.0;
+        volatile double o = 1.0;
+
+        assert((o ? 1 : 0) == 1);
+        assert((z ? 1 : 0) == 0);
+        assert(((o / z) ? 1 : 0) == 1); /* +inf */
+        assert(((z / z) ? 1 : 0) == 1); /* NaN */
+    }
+
+    return 0;
+}