Lint

Author: cptartur

crates/cheatnet/src/runtime_extensions/forge_runtime_extension/file_operations.rs

@@ -26,7 +26,7 @@ pub(super) fn read_json(path: String) -> Result<Vec<Felt>, EnhancedHintError> {
     let content = read_to_string(&path)?;
 
     let json: Map<String, Value> = serde_json::from_str(&content)
-        .map_err(|e| anyhow!("Parse JSON error: {} , in file {path}", e.to_string()))?;
+        .map_err(|e| anyhow!("Parse JSON error: {e} , in file {path}"))?;
     let data = flatten(&json);
 
     let mut result = vec![];

crates/configuration/src/lib.rs

@@ -49,7 +49,7 @@ pub fn get_profile(
     match get_with_ownership(tool_config, profile_name) {
         Some(profile_value) => Ok(profile_value),
         None if profile_name == "default" => Ok(serde_json::Value::Object(Map::default())),
-        None => Err(anyhow!("Profile [{}] not found in config", profile_name)),
+        None => Err(anyhow!("Profile [{profile_name}] not found in config")),
     }
 }
 

crates/data-transformer/src/transformer/mod.rs

@@ -55,9 +55,7 @@ fn process(
 
     ensure!(
         n_inputs == n_arguments,
-        "Invalid number of arguments: passed {}, expected {}",
-        n_arguments,
-        n_inputs,
+        "Invalid number of arguments: passed {n_arguments}, expected {n_inputs}",
     );
 
     function

crates/data-transformer/src/transformer/sierra_abi/complex_types.rs

@@ -49,11 +49,7 @@ fn validate_path_argument(
     if *path_argument.last().unwrap() != param_type.split("::").last().unwrap()
         && path_argument_joined != param_type
     {
-        bail!(
-            r#"Invalid argument type, expected "{}", got "{}""#,
-            param_type,
-            path_argument_joined
-        )
+        bail!(r#"Invalid argument type, expected "{param_type}", got "{path_argument_joined}""#,)
     }
     Ok(())
 }
@@ -236,8 +232,7 @@ impl SupportedCalldataKind for ExprStructCtorCall {
         {
             // TODO add message which arguments are invalid (Issue #2549)
             bail!(
-                r"Arguments in constructor invocation for struct {} do not match struct arguments in ABI",
-                expected_type
+                r"Arguments in constructor invocation for struct {expected_type} do not match struct arguments in ABI",
             )
         }
 
@@ -281,11 +276,7 @@ impl SupportedCalldataKind for ExprPath {
             find_enum_variant_position(enum_variant_name, enum_path, abi)?;
 
         if enum_variant.r#type != "()" {
-            bail!(
-                r#"Couldn't find variant "{}" in enum "{}""#,
-                enum_variant_name,
-                enum_path_joined
-            )
+            bail!(r#"Couldn't find variant "{enum_variant_name}" in enum "{enum_path_joined}""#,)
         }
 
         Ok(AllowedCalldataArgument::Enum(CalldataEnum::new(
@@ -337,10 +328,7 @@ impl SupportedCalldataKind for ExprListParenthesized {
         db: &SimpleParserDatabase,
     ) -> Result<AllowedCalldataArgument> {
         let Expr::Tuple(tuple) = parse_expression(expected_type, db)? else {
-            bail!(
-                r#"Invalid argument type, expected "{}", got tuple"#,
-                expected_type
-            );
+            bail!(r#"Invalid argument type, expected "{expected_type}", got tuple"#,);
         };
 
         let tuple_types = tuple

crates/data-transformer/src/transformer/sierra_abi/literals.rs

@@ -52,22 +52,18 @@ impl SupportedCalldataKind for ExprUnary {
         };
 
         match self.op(db) {
-            UnaryOperator::Not(_) => bail!(
-                "Invalid unary operator in expression !{} , only - allowed, got !",
-                value
-            ),
-            UnaryOperator::Desnap(_) => bail!(
-                "Invalid unary operator in expression *{} , only - allowed, got *",
-                value
-            ),
-            UnaryOperator::BitNot(_) => bail!(
-                "Invalid unary operator in expression ~{} , only - allowed, got ~",
-                value
-            ),
-            UnaryOperator::At(_) => bail!(
-                "Invalid unary operator in expression @{} , only - allowed, got @",
-                value
-            ),
+            UnaryOperator::Not(_) => {
+                bail!("Invalid unary operator in expression !{value} , only - allowed, got !",)
+            }
+            UnaryOperator::Desnap(_) => {
+                bail!("Invalid unary operator in expression *{value} , only - allowed, got *",)
+            }
+            UnaryOperator::BitNot(_) => {
+                bail!("Invalid unary operator in expression ~{value} , only - allowed, got ~",)
+            }
+            UnaryOperator::At(_) => {
+                bail!("Invalid unary operator in expression @{value} , only - allowed, got @",)
+            }
             UnaryOperator::Minus(_) => {}
         }
 

crates/data-transformer/src/transformer/sierra_abi/macros.rs

@@ -23,10 +23,7 @@ impl SupportedCalldataKind for ExprInlineMacro {
 
         // We do not expect any other expression in proper ABI
         let Expr::Path(path) = parse_expression(expected_type, db)? else {
-            bail!(
-                "Unexpected expression encountered in ABI: {}. ABI may be invalid",
-                expected_type
-            );
+            bail!("Unexpected expression encountered in ABI: {expected_type}. ABI may be invalid",);
         };
 
         let type_parameters_from_abi = path
@@ -68,7 +65,7 @@ impl SupportedCalldataKind for ExprInlineMacro {
 
         // Check by string; A proper array type in ABI looks exactly like this
         if !expected_type.contains("core::array::Array") {
-            bail!(r#"Expected "{}", got array"#, expected_type);
+            bail!(r#"Expected "{expected_type}", got array"#);
         }
 
         // Array should have exactly one type parameter. ABI is invalid otherwise

crates/data-transformer/src/transformer/sierra_abi/parsing.rs

@@ -68,10 +68,7 @@ pub fn parse_inline_macro(
         Simple(simple) => {
             let macro_name = simple.ident(db).text(db);
             if macro_name != "array" {
-                bail!(
-                    r#"Invalid macro name, expected "array![]", got "{}""#,
-                    macro_name
-                )
+                bail!(r#"Invalid macro name, expected "array![]", got "{macro_name}""#,)
             }
         }
         PathSegment::WithGenericArgs(_) => {

crates/docs/src/utils.rs

@@ -53,9 +53,9 @@ pub fn print_ignored_snippet_message(snippet: &Snippet) {
 
 fn get_canonical_path(relative_path: &str) -> Result<String> {
     Ok(Utf8PathBuf::from_str(relative_path)
-        .map_err(|e| anyhow!("Failed to create Utf8PathBuf: {}", e))?
+        .map_err(|e| anyhow!("Failed to create Utf8PathBuf: {e}"))?
         .canonicalize_utf8()
-        .map_err(|e| anyhow!("Failed to canonicalize path: {}", e))?
+        .map_err(|e| anyhow!("Failed to canonicalize path: {e}"))?
         .to_string())
 }
 

crates/sncast/src/lib.rs

@@ -682,8 +682,8 @@ pub fn raise_if_empty(value: &str, value_name: &str) -> Result<()> {
 
 pub fn check_account_file_exists(accounts_file_path: &Utf8PathBuf) -> Result<()> {
     if !accounts_file_path.exists() {
-        bail! {"Accounts file = {} does not exist! If you do not have an account create one with `account create` command \
-        or if you're using a custom accounts file, make sure to supply correct path to it with `--accounts-file` argument.", accounts_file_path}
+        bail! {"Accounts file = {accounts_file_path} does not exist! If you do not have an account create one with `account create` command \
+        or if you're using a custom accounts file, make sure to supply correct path to it with `--accounts-file` argument." }
     }
     Ok(())
 }

crates/sncast/src/starknet_commands/account/deploy.rs

@@ -322,8 +322,7 @@ where
     match result {
         Err(AccountFactoryError::Provider(error)) => match error {
             StarknetError(ClassHashNotFound) => Err(anyhow!(
-                "Provided class hash {:#x} does not exist",
-                class_hash,
+                "Provided class hash {class_hash:#x} does not exist",
             )),
             _ => Err(handle_rpc_error(error)),
         },