Existing rules Do not use integer type as divisor has problems

[rcseacord]

There are some problems with this rule. First, I don't understand the title. You can't have integer division?

The examples don't seem to compile. Issues in the code

Missing use statement for std::num::NonZero.

Improper use of match inside if let — the syntax is invalid.

You’re trying to use divisor of type NonZero directly in division — NonZero doesn’t implement Copy or Deref, and you need to access its value.

result is defined twice: once inside the if let and again after. This will cause confusion or a scope error.

Missing semicolon at the end of the second match.

The logic around handling division by zero (from x) is unclear and risky — you try both NonZero::new(x) and checked_rem(x) with x = 0.

Fixed Version of the Program
use std::num::NonZeroU32;

fn main() {
    let x = 0;

    // Safe division using NonZeroU32
    if let Some(nonzero_divisor) = NonZeroU32::new(x) {
        let result = 5 / nonzero_divisor.get();
        println!("Division result: {}", result);
    } else {
        println!("Cannot divide by zero using NonZeroU32.");
    }

    // Safe remainder using checked_rem
    let remainder_result = match 5u32.checked_rem(x) {
        None => 0,
        Some(r) => r,
    };

    println!("Remainder result: {}", remainder_result);
}

[felix91gr]

@rcseacord thanks for the checks!

The examples don't seem to compile.

Yeah, that's our bad. We're still figuring out how the code snippets should be presented and if they should always compile (ie be self-contained) or not (and be assumed to be part of a larger thing, with some parts if that thing being elided).

If I recall correctly, we're mostly erring on them being self-contained, but there are finer details to figure out in the implementation. PR #91 has a WIP implementation.

---

First, I don't understand the title. You can't have integer division?

Yes and no. The title is very literal: "Do not use integer type as divisor", meaning that

• Division (and Remainder) has two operators.
• One of them, let's say d, is the Divisor.
• The rule asks the user to not perform Division with d being of an integer type (meaning iN or uN).

The reasoning is in the body of the rule, so we'll skip it.

The way the rule suggests to perform integer division is to use either the checked_ APIs or to use the NonZero<T> types.

---

You’re trying to use divisor of type NonZero directly in division — NonZero doesn’t implement Copy or Deref, and you need to access its value.

That's weird. NonZero does implement Copy . It doesn't implement Deref, but that's okay - Deref doesn't make sense for a type that's not a reference to something.

On the other hand, whenever T is a primitive integer type, it always implements Div<NonZero<T>>. That's why one can do this sort of operation:

// a : T
// nzd : NonZero<T>
a / nzd;

The same is true for the Remainder operation.

So something else must be going on.

---

The logic around handling division by zero (from x) is unclear and risky — you try both NonZero::new(x) and checked_rem(x) with x = 0.

Maybe we should have a more detailed example (or comments).

The reason why those are safe is that both of those operations won't ever panic:

• if NonZero::new is called with a zero input, it will return None. The division will then never be attempted, because we'll never construct a NonZero value and instead go into the None branch of the block.
• if checked_rem is called with a zero input, it will return None. We do this instead of panicking, and we get to decide what to do if the divisor was zero.

So yeah, this probably needs a lot more description in the code snippet.

Extra:

I should add that the confusing nature of this example is compounded by the fact that we still don't have a way to have multiple code examples of each kind (N compliant examples and M non-compliant examples). We're currently restricted to having exactly 1 of both, so the author was forced to cram more than one example in the same block :(

If you know some Sphinx, we could use some help.

(otherwise whenever I'm done with the work I'm doing wrt Clippy lints and INT rules, I reckon I'll get to it myself... I have to learn to configure Sphinx eventually)

[felix91gr]

Addendum: in this playground I made a couple months ago (excuse the no_mangle and inline(never) directives; I did that to test what kind of assembly they'd generate) I show how the different ways to do division that are addressed in the guideline look:

• Normal Division
• Using checked_ APIs
• Using NonZero<T> types

Playground