diff --git a/src/Sema.zig b/src/Sema.zig
index f1d140520c..5fd1c1ce4c 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -11202,6 +11202,21 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(block, lhs_src, casted_lhs);
     const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(block, rhs_src, casted_rhs);
 
+    if ((lhs_ty.zigTypeTag() == .ComptimeFloat and rhs_ty.zigTypeTag() == .ComptimeInt) or
+        (lhs_ty.zigTypeTag() == .ComptimeInt and rhs_ty.zigTypeTag() == .ComptimeFloat))
+    {
+        // If it makes a difference whether we coerce to ints or floats before doing the division, error.
+        // If lhs % rhs is 0, it doesn't matter.
+        const lhs_val = maybe_lhs_val orelse unreachable;
+        const rhs_val = maybe_rhs_val orelse unreachable;
+        const rem = lhs_val.floatRem(rhs_val, resolved_type, sema.arena, target) catch unreachable;
+        if (rem.compareWithZero(.neq)) {
+            return sema.fail(block, src, "ambiguous coercion of division operands '{s}' and '{s}'; non-zero remainder '{}'", .{
+                @tagName(lhs_ty.tag()), @tagName(rhs_ty.tag()), rem.fmtValue(resolved_type, sema.mod),
+            });
+        }
+    }
+
     // TODO: emit compile error when .div is used on integers and there would be an
     // ambiguous result between div_floor and div_trunc.
 
diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig
index c057f7a842..a5eb25d4f5 100644
--- a/test/behavior/floatop.zig
+++ b/test/behavior/floatop.zig
@@ -194,8 +194,8 @@ fn testSin() !void {
         const eps = epsForType(ty);
         try expect(@sin(@as(ty, 0)) == 0);
         try expect(math.approxEqAbs(ty, @sin(@as(ty, std.math.pi)), 0, eps));
-        try expect(math.approxEqAbs(ty, @sin(@as(ty, std.math.pi / 2)), 1, eps));
-        try expect(math.approxEqAbs(ty, @sin(@as(ty, std.math.pi / 4)), 0.7071067811865475, eps));
+        try expect(math.approxEqAbs(ty, @sin(@as(ty, std.math.pi / 2.0)), 1, eps));
+        try expect(math.approxEqAbs(ty, @sin(@as(ty, std.math.pi / 4.0)), 0.7071067811865475, eps));
     }
 
     {
@@ -228,8 +228,8 @@ fn testCos() !void {
         const eps = epsForType(ty);
         try expect(@cos(@as(ty, 0)) == 1);
         try expect(math.approxEqAbs(ty, @cos(@as(ty, std.math.pi)), -1, eps));
-        try expect(math.approxEqAbs(ty, @cos(@as(ty, std.math.pi / 2)), 0, eps));
-        try expect(math.approxEqAbs(ty, @cos(@as(ty, std.math.pi / 4)), 0.7071067811865475, eps));
+        try expect(math.approxEqAbs(ty, @cos(@as(ty, std.math.pi / 2.0)), 0, eps));
+        try expect(math.approxEqAbs(ty, @cos(@as(ty, std.math.pi / 4.0)), 0.7071067811865475, eps));
     }
 
     {
diff --git a/test/cases/compile_errors/ambiguous_coercion_of_division_operands.zig b/test/cases/compile_errors/ambiguous_coercion_of_division_operands.zig
new file mode 100644
index 0000000000..f3e51a1bed
--- /dev/null
+++ b/test/cases/compile_errors/ambiguous_coercion_of_division_operands.zig
@@ -0,0 +1,23 @@
+export fn entry1() void {
+    var f: f32 = 54.0 / 5;
+    _ = f;
+}
+export fn entry2() void {
+    var f: f32 = 54 / 5.0;
+    _ = f;
+}
+export fn entry3() void {
+    var f: f32 = 55.0 / 5;
+    _ = f;
+}
+export fn entry4() void {
+    var f: f32 = 55 / 5.0;
+    _ = f;
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:23: error: ambiguous coercion of division operands 'comptime_float' and 'comptime_int'; non-zero remainder '4'
+// :6:21: error: ambiguous coercion of division operands 'comptime_int' and 'comptime_float'; non-zero remainder '4'