How to disable unused code warnings in Rust?

rust compiler-warnings

struct SemanticDirection;

fn main() {}

warning: struct is never used: `SemanticDirection`
 --> src/main.rs:1:1
  |
1 | struct SemanticDirection;
  | ^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: #[warn(dead_code)] on by default

I will turn these warnings back on for anything serious, but I am just tinkering with the language and this is driving me bats.

I tried adding #[allow(dead_code)] to my code, but that did not work.

Serid

You can either:

Add an allow attribute on a struct, module, function, etc.: #[allow(dead_code)] struct SemanticDirection;

Add a crate-level allow attribute; notice the !: #![allow(dead_code)]

Pass it to rustc: rustc -A dead_code main.rs

Pass it using cargo via the RUSTFLAGS environment variable: RUSTFLAGS="$RUSTFLAGS -A dead_code" cargo build

Note that the last one will trigger recompilation of everything.

The last one works best IMO. Also adding -A unused_variables can be helpful to prevent dealing with with placing _ in front of everything.

#![allow(dead_code)] also have to go before any code otherwise rust gives some cryptic error.

Shepmaster

Another way to disable this warning is to prefix the identifier by _:

struct _UnusedStruct {
    _unused_field: i32,
}

fn main() {
    let _unused_variable = 10;
}

This can be useful, for instance, with an SDL window:

let _window = video_subsystem.window("Rust SDL2 demo", 800, 600);

Prefixing with an underscore is different from using a lone underscore as the name. Doing the following will immediately destroy the window, which is unlikely to be the intended behavior.

let _ = video_subsystem.window("Rust SDL2 demo", 800, 600);

That "assigning to underscore will destroy it" behavior seems odd (though I don't doubt you're correct). Do you have a reference for it?

@MichaelAnderson See "RAII. You might want to have a variable exist for its destructor side effect, but not use it otherwise. It is not possible to use simply _ for this use-case, as _ is not a variable binding and the value would be dropped at the end of the statement." from stackoverflow.com/a/48361729/109618

using let _ = the value would be dropped at the end of the statement, not the end of the block

If you want to read more about why, the reason is that the X in let X = Y is an irrefutable pattern (i.e. it's like a match arm that can be proved to never be wrong at compile time) and, like with refutable patterns, _ is a wildcard that doesn't bind anything to a variable. That's why and how you can do let (x, y) = foo(); and other sorts of unpacking like that. It's just another kind of irrefutable pattern.

M. Hamza Rajput

Put these two lines on the top of the file.

#![allow(dead_code)]
#![allow(unused_variables)]

what's the difference those two? #[allow(dead_code)] not works but #![allow(dead_code)] works.

@jwkoo the ! makes it apply to the entire crate

Replace with #![allow(dead_code, unused)] ;-)

Victor Basso

Making the code public also stops the warnings; you'll need to make the enclosing mod's public too.

This makes sense when you're writing a library: your code is "unused" internally because it's intended to be used by client code.

I think this does not work if the crate contains both a main.rs and a lib.rs, and the main.rs does not use the function under question.

Muhammed Moussa

also as an addition: rust provides four levels of lints (allow, warn, deny, forbid).

https://doc.rust-lang.org/rustc/lints/levels.html#lint-levels

crimsondamask

You can always disable unused variables/functions by adding an (_) to the variable name, like so:

let _variable = vec![0; 10];

antoyo's answer already covers this approach.

PPP

For unused functions, you should make the function public, but watch out. If the struct isn't public, then you'll still get the error as in here:

//this should be public also
struct A{
   A{}
}

impl A {
    pub fn new() -> A {

    }
}

Or if you don't want it to be public, you should put #[allow(unused)]

davidsbro

using features

#[cfg(feature = "dead_code")]

note: "dead_code" can be replaced by any word.

I have never seen cfg/feature used like this. Can you explain how this works, or is it documented somewhere?

How to disable unused code warnings in Rust?

Follow WeChat

Want to stay one step ahead of the latest teleworks?

相似问题

Platform

Support

Contact US