Don't warn on unused arguments in unimplemented functions

[bugaevc]

The following code:

fn foo(arg: i32) {
    todo!()
}

fn main() {
    foo(35);
}

(playground)

Currently emits a warning:

warning: unused variable: `arg`
 --> src/main.rs:1:8
  |
1 | fn foo(arg: i32) {
  |        ^^^ help: if this is intentional, prefix it with an underscore: `_arg`
  |
  = note: `#[warn(unused_variables)]` on by default

warning: 1 warning emitted

But todo!() clearly indicates that the argument is unused neither because it's intended to be ignored (in which case it'd be appropriate to rename it to _arg), nor because the author forgot to use it — but simply because the relevant code to use it has not been written yet.

Since todo!() itself does not trigger any warnings (meaning, rustc is fine with trying to compile code with parts that are explicitly not implemented yet), it doesn't seem appropriate to warn about unused variables that are "covered" by todo!().

[Dylan-DPC]

Closing this since it is intended based on the comment here

[Vlad-Shcherbina]

That comment says that usages in unreachable parts of the code don't count. This makes sense as an intended behavior.

And saying that the function with the body made of a single unreachable()! doesn't use its arguments is a consistent interpretation of the original general rule. Though it has nothing to do with unreachable()!. The function with an empty body would not use its arguments for the exact same reason (because there are no occurences of the variables in the reachable parts of the function body).

However, this issue is not about the general rule being implemented incorrectly. It's an observation that the general rule, in this particular case, leads to suboptimal developer experience.

So it's worth at least considering making an exception from the rule for this case.