Moved cli frontend of the cairo linter to scarb command

[wawel37]

No description provided.

[wawel37]

FYI, will change the cairo-toolchain-xtasks version after we merge this

[maciektr]

I think this should work in a slightly different way.

1. Compilation units should be deduplicated per package, as there is no need to lint both lib and starknet-contract targets and each of them will get own CU.
2. To handle tests:

For unit tests (i.e. those defined in module tree under src dir), whether tests will be checked or not is decided purely by cfg attrs. If you want to run checks of those, choose package CU with test target kind. When not, choose lib/starknet-contract/any available.

For integration tests (i.e. those in tests dir), to find integration tests CU of the package you should:

• Take package you want to lint
• Find target of this package with target kind test and test-type param set to integration
• Take name of this target from previous step
• Use this name and package id to construct new package id with

  scarb/scarb/src/core/package/id.rs

  Line 37 in fefeab6

  pub fn for_test_target(self, target_name: SmolStr) -> Self {

• Find CU with main package id equal to the one from previous step

We cannot rely on format!("{}_integrationtest" though, while this happens to be the default name we add in auto-detected test targets, it can also be changed in Scarb manifest file (by defining the test target manually).

3. Note, that if package relies on procedural macros, we need to compile them before linting the package. This means we need to take compilation units of those proc macro packages and run ops::compile_unit on them. See how scarb check does this:

   scarb/scarb/src/ops/compile.rs

   Lines 242 to 274 in fefeab6

   	// Select proc macro units that need to be compiled for Cairo compilation units.
   	let required_plugins = units
   	.iter()
   	.flat_map(|unit| match unit {
   	CompilationUnit::Cairo(unit) => unit
   	.cairo_plugins
   	.iter()
   	.map(|p| p.package.id)
   	.collect_vec(),
   	_ => Vec::new(),
   	})
   	.collect::<HashSet<PackageId>>();
   	// We guarantee that proc-macro units are always processed first,
   	// so that all required plugins are compiled before we start checking Cairo units.
   	let units = units.into_iter().sorted_by_key(|unit| {
   	if matches!(unit, CompilationUnit::ProcMacro(_)) {
   	0
   	} else {
   	1
   	}
   	});
   	for unit in units {
   	if matches!(unit, CompilationUnit::ProcMacro(_))
   	&& required_plugins.contains(&unit.main_package_id())
   	{
   	compile_unit(unit, ws)?;
   	} else {
   	check_unit(unit, ws)?;
   	}
   	}
   	Ok(())

[maciektr]

Note this would also check package units tests - see my previous comment.

[wawel37]

Moved the fixing logic back to cairo-lint-core. software-mansion/cairo-lint#179. As soon as it's merged, will upgrade the deps here in Scarb

[maciektr]

@wawel37 Maybe we could calculate the change in cairo-lint-core and write to file here in Scarb? Wdyt?

[wawel37]

@wawel37 Maybe we could calculate the change in cairo-lint-core and write to file here in Scarb? Wdyt?

TBH I've thought about it. I think both of the solutions are good. I mean, if we put the logic of mutating the files back in the Scarb, the responsibility of fixing will be separated to 2 different places but on the other hand everything that mutates files will stay within Scarb logic.

tl;dr:
I don't have a strong opinion on that. Maybe @mkaput got some opinion on that?