Enum Fix 

pub enum Fix {
    None,
    Simple(String),
    WithImport {
        import: String,
        pattern: String,
        replacement: String,
    },
}

Type of fix that can be applied to resolve an issue.

Represents different kinds of automatic fixes that analyzers can provide.

Examples

use cargo_quality::analyzer::Fix;

let simple_fix = Fix::Simple("let x = 42;".to_string());
assert!(simple_fix.is_available());
assert_eq!(simple_fix.as_simple(), Some("let x = 42;"));

let import_fix = Fix::WithImport {
    import:      "use std::fs::read;".to_string(),
    pattern:     "std::fs::read".to_string(),
    replacement: "read".to_string()
};
assert!(import_fix.is_available());
assert_eq!(
    import_fix.as_import(),
    Some(("use std::fs::read;", "std::fs::read", "read"))
);

Variants

None

No automatic fix available

Simple(String)

Simple line replacement

Replace the entire line with the provided string.

Note: Reserved for future analyzers that need simple line replacements.

WithImport

Fix requiring import addition

Adds an import statement and replaces the line.

Fields

import: String

Import statement to add (e.g., “use std::fs::read_to_string;”)

pattern: String

Pattern to find in original line (e.g., “std::fs::read_to_string”)

replacement: String

Replacement for the pattern (e.g., “read_to_string”)

Implementations

impl Fix

pub fn is_available(&self) -> bool

Checks if fix is available.

Returns

true if fix can be applied automatically

pub fn as_simple(&self) -> Option<&str>

Returns simple replacement string if available.

Returns

Option<&str> - Replacement string for simple fixes

pub fn as_import(&self) -> Option<(&str, &str, &str)>

Returns import, pattern, and replacement for import-based fixes.

Returns

Option<(&str, &str, &str)> - (import, pattern, replacement) tuple

Trait Implementations

impl Clone for Fix

fn clone(&self) -> Fix

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Fix

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Fix

fn eq(&self, other: &Fix) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Fix