File size: 3,613 Bytes
48ca417 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 |
{
"version": "0.2.0",
"configurations": [
{
"type": "lldb",
"request": "launch",
"sourceLanguages": ["rust"],
"name": "Debug SEPARATED",
"cargo": {
"args": ["build", "--bin=separated", "--package=separated"],
"filter": {
"name": "separated",
"kind": "bin"
}
},
"env": {
"CARGO_MANIFEST_DIR": "${workspaceFolder}",
"RUSTFLAGS": "-Clinker=rust-lld.exe -Zshare-generics=n -Zthreads=0",
"PATH": "${env:HOME}/.rustup/toolchains/nightly-x86_64-pc-windows-msvc/bin;${workspaceFolder}/target/debug/deps;${env:PATH}"
},
"args": [],
"cwd": "${workspaceFolder}"
}
]
}
/*
* The `#![allow(clippy::match_same_arms)]` is a Rust attribute that allows a specific lint warning to be ignored.
*
* `#!` is a Rust attribute, which is a way to annotate a module or crate with additional information.
* `allow` is a specific attribute that allows a lint warning to be ignored.
* `clippy::match_same_arms` is the name of the lint warning being allowed.
*
* The `match_same_arms` lint warns when a match expression has multiple arms with the same pattern. For example:
*
* ```rust
match foo {
1 => println!("one"),
1 => println!("also one"), // warning: same arm
}
* ```
*
* In this case, `clippy` would normally warn about the duplicate arm, suggesting that it might be an error.
* By adding the `#![allow(clippy::match_same_arms)]` attribute, you're telling `clippy` to ignore this specific
* warning for the entire crate or module. This can be useful if you intentionally have a match expression with
* duplicate arms, or if you're working on a legacy codebase that hasn't been updated to avoid this pattern.
*
* Note that this attribute only affects the `clippy` linter, and not the standard Rust compiler warnings.
*/
/*
* RUSTFLAGS="-Funsafe-code --cap-lints=warn" cargo check
*
* This command will cause the compilation to fail if unsafe code is detected.
* However, it’s important to note that this method might not be foolproof for all cases,
* as some dependencies might require unsafe code to function correctly, and this could
* lead to false positives or prevent your project from compiling.
*
* Remember, while unsafe code is often necessary for low-level system programming tasks,
* its usage should be minimized and carefully reviewed to maintain the safety guarantees
* that Rust provides.
*/
/*
* The `--cap-lints=warn` flag in Rust is used to set the maximum lint level for the entire project to warn.
*
* This means that even if a lint is defined with a more severe levelsuch as deny or forbid,
* it will only issue a warning rather than causing the compilation to fail. Essentially, this flag ensures that
* no matter what lint levels are specified within the code or by dependencies, they will not exceed a warning level.
*
* This can be particularly useful when compiling a large number of crates, some of which you may not have control over,
* and you want to ensure that lint issues do not prevent the project from building. However, it’s important to note that
* while this flag can help with getting a project to compile, it does not address the underlying issues that the lints are warning about.
* It’s generally a good idea to review and address lint warnings to maintain code quality.
*/
|