What it does

Checks if a match or if let expression can be simplified using .unwrap_or_default().

Why is this bad?

It can be done in one call with .unwrap_or_default().

Example

let x: Option<Array<u32>> = Some(array![]);
let y: Array<u32> = match x {
    Some(v) => v,
    None => Default::default(),
};

let x: Option<Array<u32>> = Some(ArrayTrait::new());
let y: Vec<Array<u32>> = if let Some(v) = x {
    v
} else {
    Default::default()
};

Use instead:

let x: Option<Array<u32>> = Some(array![]);
let y: Array<u32> = x.unwrap_or_default();

let x: Option<Array<u32>> = Some(ArrayTrait::new());
let y: Array<u32> = x.unwrap_or_default();

(the examples are for arrays but it can work with any type that implements default

closes #74 @0xLucqs This is a draft PR

Implementation

Checks for comparing to an empty slice such as [], and suggests using .is_empty() where applicable.

What it does

Checks for usage of x >= y + 1 or x - 1 >= y (and <=) in a block

Why is this bad?

Readability – better to use > y instead of >= y + 1.

Example

if x >= y + 1 {}

Use instead:

if x > y {}

What it does

Checks for an expression like n & 1 which is less efficient than DivRem::div_rem(n, 2)

Why is this bad

It's less efficient

Example

fn main() {
    let a = 200 & 1;
}

Use instead:

fn main() {
    let a = DivRem::div_rem(200, 2);
}

eq_op base implementation

Is not completed. I still have work to do.

Changes

1. I added a new file for the eq_op lint.
2. I created the comparison directory for the eq_op tests.
3. I added some tests to see the behaviour of the code that I have.
4. I added the lint in the plugin.rs file.

Summary 📌 This PR Resolves: https://github.com/keep-starknet-strange/cairo-lint/issues/87

What it does: This PR introduces a new lint that detects consecutive if statements with the same condition. When two if or else if blocks check the same condition, this could be an indication of a copy & paste error, and this lint helps prevent such mistakes. All tests pass

Write a script to automate the test creation process. The steps are the following:

To create a new test for a lint you need to create a file in the test_files folder and should be named as your lint. The file should have this format:

//! > Test name

//! > cairo_code
fn main() {
    let a: Option<felt252> = Option::Some(1);
}

Then in the test file declare your lint like so:

test_file!(if_let, "Test name");

What it does

Finds patterns that reimplement Option::ok_or.

Why is this bad?

Concise code helps focusing on behavior instead of boilerplate.

Examples

let foo: Option<i32> = None;
let foo = match foo {
    Option::Some(v) => Result::Ok(v),
    Option::None => Result::Err('this is an err'),
}

Use instead:

let foo: Option<i32> = None;
foo.ok_or('this is an err');

Hi @0xLucqs

Here my progress about the issue #37

This PR includes the basic structure with the necessary files to implement the collapsible_if lint. Now, I'll be working on the implementation of the lint and the corresponding tests

Partially addresses #18

Handling all types of imports will require more work. One idea: regrouping all diagnostics, filter them by type (UnusedImport), group them by file, and then for each use statement, re-write it without unused imports.

What it does

Checks for erasing operations, e.g., x * 0.

Why is this bad?

The whole expression can be replaced by zero. This is most likely not the intended outcome and should probably be corrected

Example

let x = 1;
0 / x;
0 * x;
x & 0;

https://rust-lang.github.io/rust-clippy/master/index.html#/erasing_op

Resolves: #119

Catches 8 cases of impossible comparison :

• x > 500 && x < 400
• x > 500 && x <= 400
• x >= 500 && x < 400
• x >= 500 && x <= 400
• x < 400 && x > 500
• x < 400 && x >= 500
• x <= 400 && x > 500
• x <= 400 && x >= 500

• Remove the overhead of adding a lint
• Make sure that the rust compiler will display an error if a new lint is added and it's not added in the allow list
• Make sure diagnostics are not emitted for compiler generated files

Refactor the fixing part of cairo lint to have:

• improve the fixinig logic
• make sure that comments do not disappear when fixing a diagnostic because of the get_text_without_trivia
• properly format the cairo fixed cairo code

thread 'main' panicked at crates/cairo-lint-core/src/lints/manual/helpers.rs:170:81: index out of bounds: the len is 0 but the index is 0

Clone the kakarot repo https://github.com/kkrt-labs/kakarot-ssj/pulls and run scarb-cairo-lint -t --fix

Manual lint fails when the expression in the ExprMatch is a function

Example :

#[derive(Copy, Drop)]
enum Error {
    Error,
}
fn main() {
    let self: u256 = 0; 
    let _self_result: Result<u8, Error> = match self.try_into() {
        Option::Some(value) => Result::Ok(value),
        Option::None => Result::Err(Error::Error)
    };
}

panics with Expected a variable or path in match expression, because self.try_into() is a function and the lint does not support it currently in the fix function