diff --git a/CHANGELOG.md b/CHANGELOG.md
index cff1241e..20904890 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -18,6 +18,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 - Added `bit32.byteswap` to Luau standard library
 - Added `buffer` library to Luau standard library
 - Added `SharedTable` to Roblox standard library
+- Added new [`--fix`](https://kampfkarren.github.io/selene/cli/usage.html#fix) flag, which will automatically apply lint suggestions.
 
 ### Changed
 - Updated internal parser, which includes floor division (`//`), more correct parsing of string interpolation with double braces, and better parsing of `\z` escapes.
diff --git a/Cargo.lock b/Cargo.lock
index 93740fe7..0debea82 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -992,6 +992,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_yaml",
+ "similar",
  "termcolor",
  "toml",
 ]
@@ -1064,6 +1065,12 @@ dependencies = [
  "lazy_static",
 ]
 
+[[package]]
+name = "similar"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2aeaf503862c419d66959f5d7ca015337d864e9c49485d771b732e2a20453597"
+
 [[package]]
 name = "smallvec"
 version = "1.10.0"
diff --git a/Cargo.toml b/Cargo.toml
index 383ee1ae..6e20337b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,18 +1,18 @@
-[workspace]
-members = ["selene", "selene-lib"]
-resolver = "2"
-
-[workspace.package]
-version = "0.25.0"
-authors = ["Kampfkarren <kampfkarren@gmail.com>"]
-edition = "2021"
-homepage = "https://kampfkarren.github.io/selene/"
-license = "MPL-2.0"
-repository = "https://github.com/Kampfkarren/selene"
-
-[workspace.dependencies]
-full_moon = "0.19.0"
-toml = "0.7.2"
-
-# Do not update this without confirming profiling uses the same version of tracy-client as selene
-profiling = "1.0.7"
+[workspace]
+members = ["selene", "selene-lib"]
+resolver = "2"
+
+[workspace.package]
+version = "0.25.0"
+authors = ["Kampfkarren <kampfkarren@gmail.com>"]
+edition = "2021"
+homepage = "https://kampfkarren.github.io/selene/"
+license = "MPL-2.0"
+repository = "https://github.com/Kampfkarren/selene"
+
+[workspace.dependencies]
+full_moon = "0.19.0"
+toml = "0.7.2"
+
+# Do not update this without confirming profiling uses the same version of tracy-client as selene
+profiling = "1.0.7"
diff --git a/docs/src/cli/usage.md b/docs/src/cli/usage.md
index 25eb5855..770f0325 100644
--- a/docs/src/cli/usage.md
+++ b/docs/src/cli/usage.md
@@ -9,6 +9,7 @@ USAGE:
 FLAGS:
         --allow-warnings    Pass when only warnings occur
         --no-exclude        Ignore excludes defined in config
+        --fix               Automatically fix applicable lint warnings
     -h, --help              Prints help information
     -n, --no-summary        Suppress summary information
     -q, --quiet             Display only the necessary information. Equivalent to --display-style="quiet"
@@ -76,6 +77,10 @@ Results:
 0 parse errors
 ```
 
+**--fix** *fix*
+
+Automatically applies lint suggestions. Since this can be potentially destructive, it's not allowed when there are uncommitted changes. This safety mechanism can be ignored by including `--allow-dirty` to allow unstaged changes or `--allow-staged` to allow only staged changes.
+
 **--num-threads** *num-threads*
 
 Specifies the number of threads for selene to use. Defaults to however many cores your CPU has. If you type `selene --help`, you can see this number because it will show as the default for you.
diff --git a/selene-lib/Cargo.toml b/selene-lib/Cargo.toml
index 96f8ce6e..9811f638 100644
--- a/selene-lib/Cargo.toml
+++ b/selene-lib/Cargo.toml
@@ -22,6 +22,7 @@ profiling.workspace = true
 regex = "1.7.1"
 serde = "1.0.152"
 serde_yaml = "0.9.16"
+similar = "2.3.0"
 toml.workspace = true
 
 [dev-dependencies]
diff --git a/selene-lib/src/lib.rs b/selene-lib/src/lib.rs
index 77bb09c3..56948be8 100644
--- a/selene-lib/src/lib.rs
+++ b/selene-lib/src/lib.rs
@@ -229,10 +229,10 @@ macro_rules! use_lints {
                 })
             }
 
-            pub fn test_on(&self, ast: &Ast) -> Vec<CheckerDiagnostic> {
+            pub fn test_on(&self, ast: &Ast, code: &String) -> Vec<CheckerDiagnostic> {
                 let mut diagnostics = Vec::new();
 
-                let ast_context = AstContext::from_ast(ast);
+                let ast_context = AstContext::from_ast(ast, &code.to_string());
 
                 macro_rules! check_lint {
                     ($name:ident) => {
diff --git a/selene-lib/src/lint_filtering.rs b/selene-lib/src/lint_filtering.rs
index 447437fa..e814e9d3 100644
--- a/selene-lib/src/lint_filtering.rs
+++ b/selene-lib/src/lint_filtering.rs
@@ -4,7 +4,7 @@ use crate::{
         visit_nodes::{NodeVisitor, VisitorType},
     },
     lint_exists,
-    lints::{Diagnostic, Label, Severity},
+    lints::{Applicability, Diagnostic, Label, Severity},
     CheckerDiagnostic, LintVariation,
 };
 use full_moon::{ast::Ast, node::Node, tokenizer::TokenType};
@@ -149,6 +149,8 @@ impl NodeVisitor for FilterVisitor {
                                     trivia_start_position.bytes(),
                                     trivia_end_position.bytes(),
                                 )),
+                                None,
+                                Applicability::Unspecified,
                             ))
                         }
                     }));
@@ -223,6 +225,8 @@ pub fn filter_diagnostics(
                                 (first_code.0.bytes(), first_code.1.bytes()),
                                 "global filter must be before this".to_owned(),
                             )],
+                            None,
+                            Applicability::Unspecified,
                         ));
 
                         continue;
@@ -244,6 +248,8 @@ pub fn filter_diagnostics(
                                     possibly_conflicting.comment_range,
                                     "conflicts with this".to_owned(),
                                 )],
+                                None,
+                                Applicability::Unspecified,
                             ));
                         }
                     }
diff --git a/selene-lib/src/lints.rs b/selene-lib/src/lints.rs
index fa42553c..78e951a9 100644
--- a/selene-lib/src/lints.rs
+++ b/selene-lib/src/lints.rs
@@ -89,6 +89,27 @@ pub enum Severity {
     Warning,
 }
 
+/// Indicates the confidence in the correctness of a suggestion
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Applicability {
+    /// The suggestion is definitely what the user intended, or maintains the exact meaning of the code
+    ///
+    /// The suggestion is safe to be automatically applied
+    MachineApplicable,
+
+    /// The suggestion is probably what the user intended, but may not maintain the exact meaning of the code
+    ///
+    /// The suggestion generates valid code when applied
+    MaybeIncorrect,
+
+    /// The suggestion is probably what the user intended, but may not maintain the exact meaning of the code
+    ///
+    /// The suggestion does not generate valid code when applied
+    HasPlaceholders,
+
+    Unspecified,
+}
+
 #[derive(Debug)]
 pub struct Diagnostic {
     pub code: &'static str,
@@ -96,14 +117,38 @@ pub struct Diagnostic {
     pub notes: Vec<String>,
     pub primary_label: Label,
     pub secondary_labels: Vec<Label>,
+    pub suggestion: Option<String>,
+    pub applicability: Applicability,
 }
 
 impl Diagnostic {
-    pub fn new(code: &'static str, message: String, primary_label: Label) -> Self {
+    pub fn new(
+        code: &'static str,
+        message: String,
+        primary_label: Label,
+        suggestion: Option<String>,
+        applicability: Applicability,
+    ) -> Self {
+        let mut label = primary_label;
+        if let Some(ref suggestion_str) = suggestion {
+            if label.message.is_none() {
+                label = Label::new_with_message(
+                    label.range,
+                    if suggestion_str.is_empty() {
+                        "consider removing this".to_string()
+                    } else {
+                        format!("try: `{suggestion_str}`")
+                    },
+                );
+            }
+        };
+
         Self {
             code,
             message,
-            primary_label,
+            primary_label: label,
+            suggestion,
+            applicability,
 
             notes: Vec::new(),
             secondary_labels: Vec::new(),
@@ -116,6 +161,8 @@ impl Diagnostic {
         primary_label: Label,
         notes: Vec<String>,
         secondary_labels: Vec<Label>,
+        suggestion: Option<String>,
+        applicability: Applicability,
     ) -> Self {
         Self {
             code,
@@ -123,6 +170,8 @@ impl Diagnostic {
             notes,
             primary_label,
             secondary_labels,
+            suggestion,
+            applicability,
         }
     }
 
@@ -147,9 +196,107 @@ impl Diagnostic {
         }
     }
 
+    #[must_use]
     pub fn start_position(&self) -> u32 {
         self.primary_label.range.0
     }
+
+    #[must_use]
+    pub fn has_machine_applicable_fix(&self) -> bool {
+        self.suggestion.is_some() && self.applicability == Applicability::MachineApplicable
+    }
+
+    #[must_use]
+    pub fn has_maybe_incorrect_fix(&self) -> bool {
+        self.suggestion.is_some() && self.applicability == Applicability::MaybeIncorrect
+    }
+
+    /// After applying suggestions, calls `get_new_diagnostics` and reruns to ensure fixes didn't produce new errors
+    pub fn get_applied_suggestions_code<F>(
+        code: &str,
+        diagnostics: &[&Diagnostic],
+        get_new_diagnostics: F,
+    ) -> String
+    where
+        F: Fn(&str) -> Vec<Diagnostic>,
+    {
+        let mut chosen_diagnostics = Self::get_independent_suggestions(diagnostics);
+        let mut owned_diagnostics_ref;
+        let mut owned_diagnostics;
+
+        let mut fixed_code = code.to_string();
+
+        while !chosen_diagnostics.is_empty() {
+            let mut bytes_offset = 0;
+
+            for diagnostic in chosen_diagnostics {
+                if let Some(suggestion) = &diagnostic.suggestion {
+                    let (start, end) = diagnostic.primary_label.range;
+
+                    // This conversion can theoretically overflow, but it's tied to string length so the user
+                    // would face memory constraints of such large strings long before this is an issue
+                    let start_with_offset = start as isize + bytes_offset;
+                    let end_with_offset = end as isize + bytes_offset;
+
+                    fixed_code = format!(
+                        "{}{}{}",
+                        // Conversion is safe as this algorithm guarantees range + offset will never be negative
+                        &fixed_code[..start_with_offset as usize],
+                        suggestion.as_str(),
+                        &fixed_code[(end_with_offset as usize)..]
+                    );
+
+                    bytes_offset +=
+                        suggestion.len() as isize - (end_with_offset - start_with_offset);
+                }
+            }
+
+            owned_diagnostics = get_new_diagnostics(&fixed_code);
+            owned_diagnostics_ref = owned_diagnostics.iter().collect::<Vec<_>>();
+            chosen_diagnostics = Self::get_independent_suggestions(&owned_diagnostics_ref);
+        }
+
+        fixed_code
+    }
+
+    /// * Chooses all disjoint suggestions
+    /// * If a suggestion is completely contained inside others, uses the innermost one and discards the outer ones
+    /// * If suggestions partially overlap, chooses the one that starts first and discard the other ones
+    fn get_independent_suggestions<'a>(diagnostics: &'a [&'a Diagnostic]) -> Vec<&'a Diagnostic> {
+        let mut sorted_diagnostics = diagnostics
+            .iter()
+            .filter(|&&diagnostic| {
+                diagnostic.has_machine_applicable_fix() || diagnostic.has_maybe_incorrect_fix()
+            })
+            .copied()
+            .collect::<Vec<_>>();
+        sorted_diagnostics.sort_by_key(|diagnostic| diagnostic.start_position());
+
+        let mut chosen_diagnostics = Vec::new();
+
+        let mut candidate = match sorted_diagnostics.first() {
+            Some(first) => *first,
+            None => return Vec::new(),
+        };
+
+        for &diagnostic in sorted_diagnostics.iter().skip(1) {
+            let this_range = diagnostic.primary_label.range;
+
+            if this_range.1 <= candidate.primary_label.range.1 {
+                // Completely contained inside
+                candidate = diagnostic;
+            } else if this_range.0 <= candidate.primary_label.range.1 {
+                // Partially overlapping
+                continue;
+            } else {
+                chosen_diagnostics.push(candidate);
+                candidate = diagnostic;
+            }
+        }
+        chosen_diagnostics.push(candidate);
+
+        chosen_diagnostics
+    }
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -234,12 +381,17 @@ impl Context {
 #[derive(Debug)]
 pub struct AstContext {
     pub scope_manager: ScopeManager,
+
+    // Converting ast -> code should probably come from the parser, but this should be ok as a temporary solution
+    pub code: String,
 }
 
 impl AstContext {
-    pub fn from_ast(ast: &Ast) -> Self {
+    #[must_use]
+    pub fn from_ast(ast: &Ast, code: &String) -> Self {
         Self {
             scope_manager: ScopeManager::new(ast),
+            code: code.to_string(),
         }
     }
 }
diff --git a/selene-lib/src/lints/almost_swapped.rs b/selene-lib/src/lints/almost_swapped.rs
index b0cdfff4..a62c2dea 100644
--- a/selene-lib/src/lints/almost_swapped.rs
+++ b/selene-lib/src/lints/almost_swapped.rs
@@ -31,7 +31,7 @@ impl Lint for AlmostSwappedLint {
             .almost_swaps
             .iter()
             .map(|almost_swap| {
-                Diagnostic::new_complete(
+                Diagnostic::new(
                     "almost_swapped",
                     format!(
                         "this looks like you are trying to swap `{}` and `{}`",
@@ -39,12 +39,14 @@ impl Lint for AlmostSwappedLint {
                         (almost_swap.names.1),
                     ),
                     Label::new(almost_swap.range),
-                    vec![format!(
-                        "try: `{name1}, {name2} = {name2}, {name1}`",
+                    Some(format!(
+                        "{name1}, {name2} = {name2}, {name1}",
                         name1 = almost_swap.names.0,
                         name2 = almost_swap.names.1,
-                    )],
-                    Vec::new(),
+                    )),
+                    // FIXME: Ideally `MaybeIncorrect`, but the end range for swapping `t[1]` and `t[2]`
+                    // currently doesn't include the closing `]`
+                    Applicability::HasPlaceholders,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/bad_string_escape.rs b/selene-lib/src/lints/bad_string_escape.rs
index dc4284ea..4d433d3f 100644
--- a/selene-lib/src/lints/bad_string_escape.rs
+++ b/selene-lib/src/lints/bad_string_escape.rs
@@ -50,11 +50,15 @@ impl Lint for BadStringEscapeLint {
                     "bad_string_escape",
                     "string escape sequence doesn't exist".to_owned(),
                     Label::new(sequence.range.to_owned()),
+                    None,
+                    Applicability::Unspecified,
                 ),
                 ReasonWhy::Malformed => Diagnostic::new(
                     "bad_string_escape",
                     "string escape sequence is malformed".to_owned(),
                     Label::new(sequence.range.to_owned()),
+                    None,
+                    Applicability::Unspecified,
                 ),
                 ReasonWhy::DecimalTooHigh => Diagnostic::new_complete(
                     "bad_string_escape",
@@ -65,6 +69,8 @@ impl Lint for BadStringEscapeLint {
                             .to_owned(),
                     ],
                     Vec::new(),
+                    None,
+                    Applicability::Unspecified,
                 ),
                 ReasonWhy::CodepointTooHigh => Diagnostic::new_complete(
                     "bad_string_escape",
@@ -75,18 +81,24 @@ impl Lint for BadStringEscapeLint {
                             .to_owned(),
                     ],
                     Vec::new(),
+                    None,
+                    Applicability::Unspecified,
                 ),
                 ReasonWhy::DoubleInSingle => Diagnostic::new(
                     "bad_string_escape",
                     "double quotes do not have to be escaped when inside single quoted strings"
                         .to_owned(),
                     Label::new(sequence.range.to_owned()),
+                    Some("\"".to_string()),
+                    Applicability::MachineApplicable,
                 ),
                 ReasonWhy::SingleInDouble => Diagnostic::new(
                     "bad_string_escape",
                     "single quotes do not have to be escaped when inside double quoted strings"
                         .to_owned(),
                     Label::new(sequence.range.to_owned()),
+                    Some("'".to_string()),
+                    Applicability::MachineApplicable,
                 ),
             })
             .collect()
diff --git a/selene-lib/src/lints/compare_nan.rs b/selene-lib/src/lints/compare_nan.rs
index fab90bd7..1f11eba2 100644
--- a/selene-lib/src/lints/compare_nan.rs
+++ b/selene-lib/src/lints/compare_nan.rs
@@ -30,16 +30,18 @@ impl Lint for CompareNanLint {
             .comparisons
             .iter()
             .map(|comparisons| {
-                Diagnostic::new_complete(
+                let suggestion = format!(
+                    "{variable} {operator} {variable}",
+                    variable = comparisons.variable,
+                    operator = comparisons.operator,
+                );
+
+                Diagnostic::new(
                     "compare_nan",
                     "comparing things to nan directly is not allowed".to_owned(),
                     Label::new(comparisons.range),
-                    vec![format!(
-                        "try: `{variable} {operator} {variable}` instead",
-                        variable = comparisons.variable,
-                        operator = comparisons.operator,
-                    )],
-                    Vec::new(),
+                    Some(suggestion),
+                    Applicability::MaybeIncorrect,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/constant_table_comparison.rs b/selene-lib/src/lints/constant_table_comparison.rs
index 27c1676e..c1647f32 100644
--- a/selene-lib/src/lints/constant_table_comparison.rs
+++ b/selene-lib/src/lints/constant_table_comparison.rs
@@ -32,33 +32,33 @@ impl Lint for ConstantTableComparisonLint {
             .comparisons
             .iter()
             .map(|comparison| {
-                Diagnostic::new_complete(
+                let suggestion = comparison.empty_side.as_ref().map(|empty_side| {
+                    format!(
+                        "next({}) {} nil",
+                        match empty_side {
+                            EmptyComparison::CheckEmpty(side) => match side {
+                                EmptyComparisonSide::Left => &comparison.rhs,
+                                EmptyComparisonSide::Right => &comparison.lhs,
+                            },
+
+                            EmptyComparison::CheckNotEmpty(side) => match side {
+                                EmptyComparisonSide::Left => &comparison.rhs,
+                                EmptyComparisonSide::Right => &comparison.lhs,
+                            },
+                        },
+                        match empty_side {
+                            EmptyComparison::CheckEmpty(_) => "==",
+                            EmptyComparison::CheckNotEmpty(_) => "~=",
+                        }
+                    )
+                });
+
+                Diagnostic::new(
                     "constant_table_comparison",
                     "comparing to a constant table will always fail".to_owned(),
                     Label::new(comparison.range),
-                    if let Some(empty_side) = comparison.empty_side {
-                        vec![format!(
-                            "try: `next({}) {} nil`",
-                            match empty_side {
-                                EmptyComparison::CheckEmpty(side) => match side {
-                                    EmptyComparisonSide::Left => &comparison.rhs,
-                                    EmptyComparisonSide::Right => &comparison.lhs,
-                                },
-
-                                EmptyComparison::CheckNotEmpty(side) => match side {
-                                    EmptyComparisonSide::Left => &comparison.rhs,
-                                    EmptyComparisonSide::Right => &comparison.lhs,
-                                },
-                            },
-                            match empty_side {
-                                EmptyComparison::CheckEmpty(_) => "==",
-                                EmptyComparison::CheckNotEmpty(_) => "~=",
-                            }
-                        )]
-                    } else {
-                        Vec::new()
-                    },
-                    Vec::new(),
+                    suggestion.clone(),
+                    Applicability::MaybeIncorrect,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/deprecated.rs b/selene-lib/src/lints/deprecated.rs
index 46644444..96d7cfb0 100644
--- a/selene-lib/src/lints/deprecated.rs
+++ b/selene-lib/src/lints/deprecated.rs
@@ -115,8 +115,11 @@ impl<'a> DeprecatedVisitor<'a> {
 
             let mut notes = vec![deprecated.message.to_owned()];
 
+            let mut suggestion = None;
+
             if let Some(replace_with) = deprecated.try_instead(parameters) {
                 notes.push(format!("try: {replace_with}"));
+                suggestion = Some(replace_with);
             }
 
             self.diagnostics.push(Diagnostic::new_complete(
@@ -128,6 +131,8 @@ impl<'a> DeprecatedVisitor<'a> {
                 Label::from_node(node, None),
                 notes,
                 Vec::new(),
+                suggestion,
+                Applicability::MaybeIncorrect,
             ));
         }
     }
diff --git a/selene-lib/src/lints/divide_by_zero.rs b/selene-lib/src/lints/divide_by_zero.rs
index 4aa228ab..1a10ab6e 100644
--- a/selene-lib/src/lints/divide_by_zero.rs
+++ b/selene-lib/src/lints/divide_by_zero.rs
@@ -33,8 +33,10 @@ impl Lint for DivideByZeroLint {
             .map(|position| {
                 Diagnostic::new(
                     "divide_by_zero",
-                    "dividing by zero is not allowed, use math.huge instead".to_owned(),
+                    "dividing by zero is not readable".to_owned(),
                     Label::new(*position),
+                    Some("math.huge()".to_string()),
+                    Applicability::MachineApplicable,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/duplicate_keys.rs b/selene-lib/src/lints/duplicate_keys.rs
index 3bcf72ed..9ad26619 100644
--- a/selene-lib/src/lints/duplicate_keys.rs
+++ b/selene-lib/src/lints/duplicate_keys.rs
@@ -42,6 +42,8 @@ impl Lint for DuplicateKeysLint {
                         duplicate.original_declaration,
                         format!("`{}` originally declared here", duplicate.name),
                     )],
+                    None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/empty_if.rs b/selene-lib/src/lints/empty_if.rs
index 581f134f..df59d5d7 100644
--- a/selene-lib/src/lints/empty_if.rs
+++ b/selene-lib/src/lints/empty_if.rs
@@ -63,6 +63,8 @@ impl Lint for EmptyIfLint {
                     }
                     .to_owned(),
                     Label::new(position.0),
+                    None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/empty_loop.rs b/selene-lib/src/lints/empty_loop.rs
index df35d62e..d793059e 100644
--- a/selene-lib/src/lints/empty_loop.rs
+++ b/selene-lib/src/lints/empty_loop.rs
@@ -58,6 +58,8 @@ impl Lint for EmptyLoopLint {
                     "empty_loop",
                     "empty loop block".to_owned(),
                     Label::new(position),
+                    Some(String::new()),
+                    Applicability::MaybeIncorrect,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/global_usage.rs b/selene-lib/src/lints/global_usage.rs
index ee170c2b..9d5158c1 100644
--- a/selene-lib/src/lints/global_usage.rs
+++ b/selene-lib/src/lints/global_usage.rs
@@ -76,6 +76,8 @@ impl Lint for GlobalLint {
                         reference.name
                     ),
                     Label::new(reference.identifier),
+                    None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/high_cyclomatic_complexity.rs b/selene-lib/src/lints/high_cyclomatic_complexity.rs
index adee8e28..4cf2d56e 100644
--- a/selene-lib/src/lints/high_cyclomatic_complexity.rs
+++ b/selene-lib/src/lints/high_cyclomatic_complexity.rs
@@ -58,6 +58,8 @@ impl Lint for HighCyclomaticComplexityLint {
                         self.config.maximum_complexity
                     ),
                     Label::new(position),
+                    None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/if_same_then_else.rs b/selene-lib/src/lints/if_same_then_else.rs
index c8874b9c..b77a9246 100644
--- a/selene-lib/src/lints/if_same_then_else.rs
+++ b/selene-lib/src/lints/if_same_then_else.rs
@@ -41,6 +41,8 @@ impl Lint for IfSameThenElseLint {
                         position.1,
                         "note: same as this".to_owned(),
                     )],
+                    None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/ifs_same_cond.rs b/selene-lib/src/lints/ifs_same_cond.rs
index 2e02080a..dd40bb0d 100644
--- a/selene-lib/src/lints/ifs_same_cond.rs
+++ b/selene-lib/src/lints/ifs_same_cond.rs
@@ -41,6 +41,8 @@ impl Lint for IfsSameCondLint {
                         position.1,
                         "note: same as this".to_owned(),
                     )],
+                    None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/manual_table_clone.rs b/selene-lib/src/lints/manual_table_clone.rs
index c5e7c1a6..48a72b83 100644
--- a/selene-lib/src/lints/manual_table_clone.rs
+++ b/selene-lib/src/lints/manual_table_clone.rs
@@ -84,6 +84,8 @@ impl ManualTableCloneMatch {
             } else {
                 Vec::new()
             },
+            None,
+            Applicability::Unspecified,
         )
     }
 }
diff --git a/selene-lib/src/lints/mismatched_arg_count.rs b/selene-lib/src/lints/mismatched_arg_count.rs
index a22f0c88..76abc03c 100644
--- a/selene-lib/src/lints/mismatched_arg_count.rs
+++ b/selene-lib/src/lints/mismatched_arg_count.rs
@@ -72,6 +72,8 @@ impl Lint for MismatchedArgCountLint {
                             )
                         })
                         .collect(),
+                    None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/mixed_table.rs b/selene-lib/src/lints/mixed_table.rs
index 4a588abf..d53b065c 100644
--- a/selene-lib/src/lints/mixed_table.rs
+++ b/selene-lib/src/lints/mixed_table.rs
@@ -34,6 +34,8 @@ impl Lint for MixedTableLint {
                 Label::new(mixed_table.range),
                 vec!["help: change this table to either an array or dictionary".to_owned()],
                 Vec::new(),
+                None,
+                Applicability::Unspecified,
             ));
         }
 
diff --git a/selene-lib/src/lints/multiple_statements.rs b/selene-lib/src/lints/multiple_statements.rs
index e137b553..858bd3bf 100644
--- a/selene-lib/src/lints/multiple_statements.rs
+++ b/selene-lib/src/lints/multiple_statements.rs
@@ -53,6 +53,8 @@ impl Lint for MultipleStatementsLint {
                     "multiple_statements",
                     "only one statement per line is allowed".to_owned(),
                     Label::new(*position),
+                    None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/must_use.rs b/selene-lib/src/lints/must_use.rs
index 3ab9d04f..5a01f19e 100644
--- a/selene-lib/src/lints/must_use.rs
+++ b/selene-lib/src/lints/must_use.rs
@@ -48,6 +48,8 @@ impl Lint for MustUseLint {
                     function_call_stmt.call_name_path.join(".")
                 ),
                 Label::new(function_call_stmt.call_prefix_range),
+                None,
+                Applicability::Unspecified,
             ));
         }
 
diff --git a/selene-lib/src/lints/parenthese_conditions.rs b/selene-lib/src/lints/parenthese_conditions.rs
index fd0f13b4..d82df1c1 100644
--- a/selene-lib/src/lints/parenthese_conditions.rs
+++ b/selene-lib/src/lints/parenthese_conditions.rs
@@ -20,7 +20,7 @@ impl Lint for ParentheseConditionsLint {
         Ok(ParentheseConditionsLint)
     }
 
-    fn pass(&self, ast: &Ast, _: &Context, _: &AstContext) -> Vec<Diagnostic> {
+    fn pass(&self, ast: &Ast, _: &Context, context: &AstContext) -> Vec<Diagnostic> {
         let mut visitor = ParentheseConditionsVisitor {
             positions: Vec::new(),
         };
@@ -35,6 +35,8 @@ impl Lint for ParentheseConditionsLint {
                     "parenthese_conditions",
                     "lua does not require parentheses around conditions".to_owned(),
                     Label::new(*position),
+                    Some(context.code[position.0 + 1..position.1 - 1].to_string()),
+                    Applicability::MachineApplicable,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/roblox_incorrect_color3_new_bounds.rs b/selene-lib/src/lints/roblox_incorrect_color3_new_bounds.rs
index 866d9864..8e82c35b 100644
--- a/selene-lib/src/lints/roblox_incorrect_color3_new_bounds.rs
+++ b/selene-lib/src/lints/roblox_incorrect_color3_new_bounds.rs
@@ -39,6 +39,8 @@ impl Lint for Color3BoundsLint {
                     Label::new(*position),
                     vec!["help: did you mean to use Color3.fromRGB instead?".to_owned()],
                     Vec::new(),
+                    None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/roblox_incorrect_roact_usage.rs b/selene-lib/src/lints/roblox_incorrect_roact_usage.rs
index 94c02362..08a02c16 100644
--- a/selene-lib/src/lints/roblox_incorrect_roact_usage.rs
+++ b/selene-lib/src/lints/roblox_incorrect_roact_usage.rs
@@ -90,6 +90,8 @@ impl Lint for IncorrectRoactUsageLint {
                     invalid_event.event_name, invalid_event.class_name
                 ),
                 Label::new(invalid_event.range),
+                None,
+                Applicability::Unspecified,
             ));
         }
 
@@ -109,6 +111,8 @@ impl Lint for IncorrectRoactUsageLint {
                             invalid_property.create_element_expression,
                         )],
                         Vec::new(),
+                        None,
+                        Applicability::Unspecified,
                     ));
                 }
                 _ => {
@@ -119,6 +123,8 @@ impl Lint for IncorrectRoactUsageLint {
                             invalid_property.property_name, invalid_property.class_name
                         ),
                         Label::new(invalid_property.range),
+                        None,
+                        Applicability::Unspecified,
                     ));
                 }
             }
@@ -129,6 +135,8 @@ impl Lint for IncorrectRoactUsageLint {
                 "roblox_incorrect_roact_usage",
                 format!("`{}` is not a valid class", unknown_class.name),
                 Label::new(unknown_class.range),
+                None,
+                Applicability::Unspecified,
             ));
         }
 
diff --git a/selene-lib/src/lints/roblox_suspicious_udim2_new.rs b/selene-lib/src/lints/roblox_suspicious_udim2_new.rs
index a29d0550..81f670de 100644
--- a/selene-lib/src/lints/roblox_suspicious_udim2_new.rs
+++ b/selene-lib/src/lints/roblox_suspicious_udim2_new.rs
@@ -34,9 +34,17 @@ fn create_diagnostic(mismatch: &MismatchedArgCount) -> Diagnostic {
             }
             .to_owned()],
             Vec::new(),
+            None,
+            Applicability::Unspecified,
         )
     } else {
-        Diagnostic::new(code, message, primary_label)
+        Diagnostic::new(
+            code,
+            message,
+            primary_label,
+            None,
+            Applicability::Unspecified,
+        )
     }
 }
 
diff --git a/selene-lib/src/lints/shadowing.rs b/selene-lib/src/lints/shadowing.rs
index 6bbf8358..f9fe160a 100644
--- a/selene-lib/src/lints/shadowing.rs
+++ b/selene-lib/src/lints/shadowing.rs
@@ -69,6 +69,8 @@ impl Lint for ShadowingLint {
                         shadow.first_defined,
                         "previously defined here".to_owned(),
                     )],
+                    None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/standard_library.rs b/selene-lib/src/lints/standard_library.rs
index 6c4942c6..68796673 100644
--- a/selene-lib/src/lints/standard_library.rs
+++ b/selene-lib/src/lints/standard_library.rs
@@ -260,6 +260,8 @@ impl StandardLibraryVisitor<'_> {
                     self.user_set_standard_library,
                 ),
                 Vec::new(),
+                None,
+                Applicability::Unspecified,
             ));
         }
     }
@@ -318,6 +320,8 @@ impl Visitor for StandardLibraryVisitor<'_> {
                                     Label::new((range.0.bytes(), range.1.bytes())),
                                     Vec::new(),
                                     Vec::new(),
+                                    None,
+                                    Applicability::Unspecified,
                                 ));
                             }
 
@@ -355,6 +359,8 @@ impl Visitor for StandardLibraryVisitor<'_> {
                             Label::new((range.0.bytes(), range.1.bytes())),
                             Vec::new(),
                             Vec::new(),
+                            None,
+                            Applicability::Unspecified,
                         ));
                     }
                 }
@@ -435,6 +441,8 @@ impl Visitor for StandardLibraryVisitor<'_> {
                         name_path.join("."),
                     ),
                     Label::from_node(call, None),
+                    None,
+                    Applicability::Unspecified,
                 ));
 
                 return;
@@ -463,7 +471,7 @@ impl Visitor for StandardLibraryVisitor<'_> {
 
             let name = name_path.pop().unwrap();
 
-            self.diagnostics.push(Diagnostic::new_complete(
+            self.diagnostics.push(Diagnostic::new(
                 "incorrect_standard_library_use",
                 format!(
                     "standard library function `{}{}{}` {}",
@@ -473,13 +481,13 @@ impl Visitor for StandardLibraryVisitor<'_> {
                     problem,
                 ),
                 Label::from_node(call, None),
-                vec![format!(
-                    "try: {}{}{}(...)",
+                Some(format!(
+                    "{}{}{}(...)",
                     name_path.join("."),
                     use_instead,
                     name
-                )],
-                Vec::new(),
+                )),
+                Applicability::HasPlaceholders,
             ));
 
             return;
@@ -558,6 +566,8 @@ impl Visitor for StandardLibraryVisitor<'_> {
                             Label::from_node(call, None),
                             message.iter().cloned().collect(),
                             Vec::new(),
+                            None,
+                            Applicability::Unspecified,
                         ));
                     }
 
@@ -595,6 +605,8 @@ impl Visitor for StandardLibraryVisitor<'_> {
                 Label::from_node(call, None),
                 required_param_message,
                 Vec::new(),
+                None,
+                Applicability::Unspecified,
             ));
         }
 
@@ -629,6 +641,8 @@ impl Visitor for StandardLibraryVisitor<'_> {
                                 passed_type.type_name()
                             ),
                         ),
+                        None,
+                        Applicability::Unspecified,
                     ));
                 }
             }
diff --git a/selene-lib/src/lints/suspicious_reverse_loop.rs b/selene-lib/src/lints/suspicious_reverse_loop.rs
index 8fbb153e..37ada923 100644
--- a/selene-lib/src/lints/suspicious_reverse_loop.rs
+++ b/selene-lib/src/lints/suspicious_reverse_loop.rs
@@ -37,6 +37,8 @@ impl Lint for SuspiciousReverseLoopLint {
                     Label::new(*position),
                     vec!["help: try adding `, -1` after `1`".to_owned()],
                     Vec::new(),
+                    None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index 2d044cd5..c4b2d7c8 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -1,8 +1,9 @@
-use super::{AstContext, Context, Lint};
+use super::{Applicability, AstContext, Context, Diagnostic, Lint};
 use crate::{
     test_util::{get_standard_library, PrettyString},
     StandardLibrary,
 };
+use similar::{ChangeTag, TextDiff};
 use std::{
     fs,
     io::Write,
@@ -34,6 +35,63 @@ impl Default for TestUtilConfig {
     }
 }
 
+/// Returns empty string if there are no diffs
+fn generate_diff(source1: &str, source2: &str, diagnostics: &[&Diagnostic]) -> String {
+    let mut result = String::new();
+    let mut has_changes = false;
+    let mut byte_offset = 0;
+    let mut prev_non_insert_applicability_prefix = "    ";
+
+    for change in TextDiff::from_lines(source1, source2).iter_all_changes() {
+        let change_length = change.value().len() as u32;
+
+        let change_end_byte = byte_offset + change_length;
+
+        let mut applicability_prefix = "    ";
+        for diagnostic in diagnostics {
+            let (start, end) = diagnostic.primary_label.range;
+            if start < change_end_byte && end > byte_offset {
+                if diagnostic.applicability == Applicability::MachineApplicable {
+                    applicability_prefix = "[MA]";
+                    break;
+                } else if diagnostic.applicability == Applicability::MaybeIncorrect {
+                    applicability_prefix = "[MI]";
+                    break;
+                }
+            }
+        }
+
+        if change.tag() == ChangeTag::Insert {
+            applicability_prefix = prev_non_insert_applicability_prefix;
+        }
+
+        let sign = match change.tag() {
+            ChangeTag::Delete => {
+                has_changes = true;
+                format!("-{}", applicability_prefix)
+            }
+            ChangeTag::Insert => {
+                has_changes = true;
+                format!("+{}", applicability_prefix)
+            }
+            ChangeTag::Equal => "     ".to_string(),
+        };
+
+        result.push_str(&format!("{} {}", sign, change.value()));
+
+        if change.tag() != ChangeTag::Insert {
+            byte_offset = change_end_byte;
+            prev_non_insert_applicability_prefix = applicability_prefix;
+        }
+    }
+
+    if has_changes {
+        result
+    } else {
+        "".to_string()
+    }
+}
+
 pub fn test_lint_config_with_output<
     C: DeserializeOwned,
     E: std::error::Error,
@@ -59,23 +117,91 @@ pub fn test_lint_config_with_output<
         fs::read_to_string(path_base.with_extension("lua")).expect("Cannot find lua file");
 
     let ast = full_moon::parse(&lua_source).expect("Cannot parse lua file");
-    let mut diagnostics = lint.pass(
-        &ast,
-        &Context {
-            standard_library: config.standard_library,
-            user_set_standard_library: if standard_library_is_set {
-                Some(vec!["test-set".to_owned()])
-            } else {
-                None
-            },
+
+    let context = Context {
+        standard_library: config.standard_library,
+        user_set_standard_library: if standard_library_is_set {
+            Some(vec!["test-set".to_owned()])
+        } else {
+            None
+        },
+    };
+
+    let mut diagnostics = lint.pass(&ast, &context, &AstContext::from_ast(&ast, &lua_source));
+    diagnostics.sort_by_key(|diagnostic| diagnostic.primary_label.range);
+
+    let mut suggestion = lua_source.to_string();
+    let mut fixed_diagnostics = diagnostics
+        .iter()
+        .filter(|diagnostic| {
+            diagnostic.suggestion.is_some()
+                && (diagnostic.applicability == Applicability::MachineApplicable
+                    || diagnostic.applicability == Applicability::MaybeIncorrect)
+        })
+        .collect::<Vec<_>>();
+
+    suggestion = Diagnostic::get_applied_suggestions_code(
+        suggestion.as_str(),
+        &fixed_diagnostics,
+        |new_code| {
+            let fixed_ast = full_moon::parse(new_code).unwrap_or_else(|_| {
+                panic!(
+                    "Fixer generated invalid code:\n\
+                        ----------------\n\
+                        {}\n\
+                        ----------------\n",
+                    new_code
+                )
+            });
+            lint.pass(
+                &fixed_ast,
+                &context,
+                &AstContext::from_ast(&fixed_ast, &new_code.to_string()),
+            )
         },
-        &AstContext::from_ast(&ast),
     );
 
-    let mut files = codespan::Files::new();
-    let source_id = files.add(format!("{test_name}.lua"), lua_source);
+    let fixed_ast = full_moon::parse(&suggestion).unwrap_or_else(|_| {
+        panic!(
+            "Fixer generated invalid code:\n\
+                ----------------\n\
+                {}\n\
+                ----------------\n",
+            suggestion
+        )
+    });
+    let lint_results = lint.pass(
+        &fixed_ast,
+        &context,
+        &AstContext::from_ast(&fixed_ast, &suggestion),
+    );
+    fixed_diagnostics = lint_results.iter().collect::<Vec<_>>();
+    fixed_diagnostics.sort_by_key(|diagnostic| diagnostic.start_position());
 
-    diagnostics.sort_by_key(|diagnostic| diagnostic.primary_label.range);
+    let fixed_diff = generate_diff(
+        &lua_source,
+        &suggestion,
+        &diagnostics.iter().collect::<Vec<_>>(),
+    );
+    let diff_output_path = path_base.with_extension("fixed.diff");
+
+    if let Ok(expected) = fs::read_to_string(&diff_output_path) {
+        pretty_assertions::assert_str_eq!(
+            // Must normalize newline characters otherwise testing on windows locally passes but fails
+            // in github actions environment
+            &expected.replace("\r\n", "\n"),
+            &fixed_diff.replace("\r\n", "\n")
+        );
+    } else {
+        let mut output_file =
+            fs::File::create(diff_output_path).expect("couldn't create fixed.diff output file");
+        output_file
+            .write_all(fixed_diff.as_bytes())
+            .expect("couldn't write fixed.diff to output file.");
+    }
+
+    let mut files = codespan::Files::new();
+    let source_id = files.add(format!("{test_name}.lua"), lua_source.clone());
 
     let mut output = termcolor::NoColor::new(Vec::new());
 
@@ -96,7 +222,10 @@ pub fn test_lint_config_with_output<
     let output_path = path_base.with_extension(output_extension);
 
     if let Ok(expected) = fs::read_to_string(&output_path) {
-        pretty_assertions::assert_eq!(PrettyString(&expected), PrettyString(stderr));
+        pretty_assertions::assert_eq!(
+            PrettyString(&expected.replace("\r\n", "\n")),
+            PrettyString(&stderr.to_string().replace("\r\n", "\n"))
+        );
     } else {
         let mut output_file = fs::File::create(output_path).expect("couldn't create output file");
         output_file
diff --git a/selene-lib/src/lints/type_check_inside_call.rs b/selene-lib/src/lints/type_check_inside_call.rs
index 987efd10..c88a50da 100644
--- a/selene-lib/src/lints/type_check_inside_call.rs
+++ b/selene-lib/src/lints/type_check_inside_call.rs
@@ -38,6 +38,8 @@ impl Lint for TypeCheckInsideCallLint {
                     Label::new(*position),
                     vec!["note: this will always return `boolean`".to_owned()],
                     Vec::new(),
+                    None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/unbalanced_assignments.rs b/selene-lib/src/lints/unbalanced_assignments.rs
index df1db4b2..67dbaf38 100644
--- a/selene-lib/src/lints/unbalanced_assignments.rs
+++ b/selene-lib/src/lints/unbalanced_assignments.rs
@@ -37,6 +37,8 @@ impl Lint for UnbalancedAssignmentsLint {
                         "unbalanced_assignments",
                         "too many values on the right side of the assignment".to_owned(),
                         Label::new(assignment.range),
+                        None,
+                        Applicability::Unspecified,
                     )
                 } else {
                     let secondary_labels = match assignment.first_call {
@@ -56,6 +58,8 @@ impl Lint for UnbalancedAssignmentsLint {
                         Label::new(assignment.range),
                         Vec::new(),
                         secondary_labels,
+                        None,
+                        Applicability::Unspecified,
                     )
                 }
             })
diff --git a/selene-lib/src/lints/undefined_variable.rs b/selene-lib/src/lints/undefined_variable.rs
index b96027a5..225465f7 100644
--- a/selene-lib/src/lints/undefined_variable.rs
+++ b/selene-lib/src/lints/undefined_variable.rs
@@ -48,6 +48,8 @@ impl Lint for UndefinedVariableLint {
                         &context.user_set_standard_library,
                     ),
                     Vec::new(),
+                    None,
+                    Applicability::Unspecified,
                 ));
             }
         }
diff --git a/selene-lib/src/lints/unscoped_variables.rs b/selene-lib/src/lints/unscoped_variables.rs
index db6f3d1f..44d1f976 100644
--- a/selene-lib/src/lints/unscoped_variables.rs
+++ b/selene-lib/src/lints/unscoped_variables.rs
@@ -60,6 +60,8 @@ impl Lint for UnscopedVariablesLint {
                         reference.name
                     ),
                     Label::new(reference.identifier),
+                    Some(format!("local {}", reference.name)),
+                    Applicability::MaybeIncorrect,
                 ));
             }
         }
diff --git a/selene-lib/src/lints/unused_variable.rs b/selene-lib/src/lints/unused_variable.rs
index c60c932d..00662cd8 100644
--- a/selene-lib/src/lints/unused_variable.rs
+++ b/selene-lib/src/lints/unused_variable.rs
@@ -156,6 +156,10 @@ impl Lint for UnusedVariableLint {
                 .any(|reference| reference == &AnalyzedReference::Read)
             {
                 let mut notes = Vec::new();
+                let mut report_range = variable.identifiers[0];
+
+                let mut suggestion = Some(format!("_{}", variable.name));
+                let mut applicability = Applicability::MachineApplicable;
 
                 if variable.is_self {
                     if self.allow_unused_self {
@@ -165,6 +169,27 @@ impl Lint for UnusedVariableLint {
                     notes.push("`self` is implicitly defined when defining a method".to_owned());
                     notes
                         .push("if you don't need it, consider using `.` instead of `:`".to_owned());
+
+                    if let Some(colon_position) =
+                        ast_context.code[..variable.identifiers[0].0].rfind(':')
+                    {
+                        report_range = (colon_position, colon_position + 1);
+
+                        // Applying fix by changing `:` to `.` would break any existing methods calls
+                        applicability = Applicability::MaybeIncorrect;
+                        suggestion = Some(".".to_string());
+                    }
+                }
+
+                // Applying fix would cause existing references to reference a nonexistent variable. It's possible to
+                // also rename those references as well. Clippy just doesn't apply a fix at all in these cases.
+                if variable.references.iter().any(|reference| {
+                    ast_context.scope_manager.references[*reference]
+                        .identifier
+                        .0
+                        != variable.identifiers[0].0
+                }) {
+                    suggestion = None;
                 }
 
                 let write_only = !analyzed_references.is_empty();
@@ -176,7 +201,7 @@ impl Lint for UnusedVariableLint {
                     } else {
                         format!("{} is defined, but never used", variable.name)
                     },
-                    Label::new(variable.identifiers[0]),
+                    Label::new(report_range),
                     notes,
                     analyzed_references
                         .into_iter()
@@ -188,6 +213,8 @@ impl Lint for UnusedVariableLint {
                             }
                         })
                         .collect(),
+                    suggestion,
+                    applicability,
                 ));
             };
         }
diff --git a/selene-lib/src/test_util.rs b/selene-lib/src/test_util.rs
index c1eec257..547181d8 100644
--- a/selene-lib/src/test_util.rs
+++ b/selene-lib/src/test_util.rs
@@ -61,7 +61,7 @@ pub fn test_full_run_config_with_output(
 
     let ast = full_moon::parse(&lua_source).expect("Cannot parse lua file");
 
-    let mut diagnostics = checker.test_on(&ast);
+    let mut diagnostics = checker.test_on(&ast, &lua_source);
 
     let mut files = codespan::Files::new();
     let source_id = files.add(format!("{test_name}.lua"), lua_source);
diff --git a/selene-lib/tests/checker.rs b/selene-lib/tests/checker.rs
index 00a6cf9d..4b658809 100644
--- a/selene-lib/tests/checker.rs
+++ b/selene-lib/tests/checker.rs
@@ -62,6 +62,9 @@ fn uses_lint_variation_allow() {
     .unwrap();
 
     assert!(checker
-        .test_on(&parse("if true then\n\treturn\nend").unwrap())
+        .test_on(
+            &parse("if true then\n\treturn\nend").unwrap(),
+            &"".to_string()
+        )
         .is_empty());
 }
diff --git a/selene-lib/tests/lints/almost_swapped/almost_swapped.fixed.diff b/selene-lib/tests/lints/almost_swapped/almost_swapped.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/almost_swapped/almost_swapped.stderr b/selene-lib/tests/lints/almost_swapped/almost_swapped.stderr
index 56639b2f..5e80fba3 100644
--- a/selene-lib/tests/lints/almost_swapped/almost_swapped.stderr
+++ b/selene-lib/tests/lints/almost_swapped/almost_swapped.stderr
@@ -3,25 +3,19 @@ error[almost_swapped]: this looks like you are trying to swap `a` and `b`
   │  
 3 │ ╭ a = b
 4 │ │ b = a
-  │ ╰─────^
-  │  
-  = try: `a, b = b, a`
+  │ ╰─────^ try: `a, b = b, a`
 
 error[almost_swapped]: this looks like you are trying to swap `t[1]` and `t[2]`
   ┌─ almost_swapped.lua:8:1
   │  
 8 │ ╭ t[1] = t[2]
 9 │ │ t[2] = t[1]
-  │ ╰──────────^
-  │  
-  = try: `t[1], t[2] = t[2], t[1]`
+  │ ╰──────────^ try: `t[1], t[2] = t[2], t[1]`
 
 error[almost_swapped]: this looks like you are trying to swap `a` and `b`
    ┌─ almost_swapped.lua:15:1
    │  
 15 │ ╭ a = b
 16 │ │ b = a
-   │ ╰─────^
-   │  
-   = try: `a, b = b, a`
+   │ ╰─────^ try: `a, b = b, a`
 
diff --git a/selene-lib/tests/lints/almost_swapped/panic.fixed.diff b/selene-lib/tests/lints/almost_swapped/panic.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/bad_string_escape/lua51_string_escapes.fixed.diff b/selene-lib/tests/lints/bad_string_escape/lua51_string_escapes.fixed.diff
new file mode 100644
index 00000000..8f44ac33
--- /dev/null
+++ b/selene-lib/tests/lints/bad_string_escape/lua51_string_escapes.fixed.diff
@@ -0,0 +1,41 @@
+      local x = "\a"
+      local x = "\b"
+      local x = "\f"
+      local x = "\n"
+      local x = "\r"
+      local x = "\t"
+      local x = "\v"
+      local x = "\""
+      local x = "\\"
+      
+-[MA] local x = "\'\""
++[MA] local x = "'\""
+      
+-[MA] local x = '\"\''
++[MA] local x = '"\''
+      
+      local x = "\97"
+      
+      -- local x = "\ -- Full-moon doesn't like this style of string
+      -- "
+      
+      local bad = "\z"
+      
+      local bad2 = "\x1\x10"
+      
+      local bad3 = "\u{1337}\u{1234\u{1337}"
+      
+      local bad4 = "\u{10ffff}\u{110000}"
+      
+      local bad5 = "\m"
+      
+      local bad6 = "\999"
+      
+      local bad7 = "\u{ffffffffff}"
+      
+      local good = [[\z\x1\u{1234\u{110000}\m\"\'\999]]
+      
+      -- See: Issue #292
+      local decimal_decimal_hex = "\01B"
+      local decimal_hex = "\1B"
+      local all_hex = "\aaa"
\ No newline at end of file
diff --git a/selene-lib/tests/lints/bad_string_escape/lua51_string_escapes.stderr b/selene-lib/tests/lints/bad_string_escape/lua51_string_escapes.stderr
index dedd73f2..0de21348 100644
--- a/selene-lib/tests/lints/bad_string_escape/lua51_string_escapes.stderr
+++ b/selene-lib/tests/lints/bad_string_escape/lua51_string_escapes.stderr
@@ -2,13 +2,13 @@ error[bad_string_escape]: single quotes do not have to be escaped when inside do
    ┌─ lua51_string_escapes.lua:11:12
    │
 11 │ local x = "\'\""
-   │            ^^
+   │            ^^ try: `'`
 
 error[bad_string_escape]: double quotes do not have to be escaped when inside single quoted strings
    ┌─ lua51_string_escapes.lua:13:12
    │
 13 │ local x = '\"\''
-   │            ^^
+   │            ^^ try: `"`
 
 error[bad_string_escape]: string escape sequence doesn't exist
    ┌─ lua51_string_escapes.lua:20:14
diff --git a/selene-lib/tests/lints/bad_string_escape/roblox_string_escapes.fixed.diff b/selene-lib/tests/lints/bad_string_escape/roblox_string_escapes.fixed.diff
new file mode 100644
index 00000000..8f44ac33
--- /dev/null
+++ b/selene-lib/tests/lints/bad_string_escape/roblox_string_escapes.fixed.diff
@@ -0,0 +1,41 @@
+      local x = "\a"
+      local x = "\b"
+      local x = "\f"
+      local x = "\n"
+      local x = "\r"
+      local x = "\t"
+      local x = "\v"
+      local x = "\""
+      local x = "\\"
+      
+-[MA] local x = "\'\""
++[MA] local x = "'\""
+      
+-[MA] local x = '\"\''
++[MA] local x = '"\''
+      
+      local x = "\97"
+      
+      -- local x = "\ -- Full-moon doesn't like this style of string
+      -- "
+      
+      local bad = "\z"
+      
+      local bad2 = "\x1\x10"
+      
+      local bad3 = "\u{1337}\u{1234\u{1337}"
+      
+      local bad4 = "\u{10ffff}\u{110000}"
+      
+      local bad5 = "\m"
+      
+      local bad6 = "\999"
+      
+      local bad7 = "\u{ffffffffff}"
+      
+      local good = [[\z\x1\u{1234\u{110000}\m\"\'\999]]
+      
+      -- See: Issue #292
+      local decimal_decimal_hex = "\01B"
+      local decimal_hex = "\1B"
+      local all_hex = "\aaa"
\ No newline at end of file
diff --git a/selene-lib/tests/lints/bad_string_escape/roblox_string_escapes.stderr b/selene-lib/tests/lints/bad_string_escape/roblox_string_escapes.stderr
index a9ac189d..3a42a730 100644
--- a/selene-lib/tests/lints/bad_string_escape/roblox_string_escapes.stderr
+++ b/selene-lib/tests/lints/bad_string_escape/roblox_string_escapes.stderr
@@ -2,13 +2,13 @@ error[bad_string_escape]: single quotes do not have to be escaped when inside do
    ┌─ roblox_string_escapes.lua:11:12
    │
 11 │ local x = "\'\""
-   │            ^^
+   │            ^^ try: `'`
 
 error[bad_string_escape]: double quotes do not have to be escaped when inside single quoted strings
    ┌─ roblox_string_escapes.lua:13:12
    │
 13 │ local x = '\"\''
-   │            ^^
+   │            ^^ try: `"`
 
 error[bad_string_escape]: string escape sequence is malformed
    ┌─ roblox_string_escapes.lua:22:15
diff --git a/selene-lib/tests/lints/compare_nan/compare_nan_if.fixed.diff b/selene-lib/tests/lints/compare_nan/compare_nan_if.fixed.diff
new file mode 100644
index 00000000..81558f9f
--- /dev/null
+++ b/selene-lib/tests/lints/compare_nan/compare_nan_if.fixed.diff
@@ -0,0 +1,34 @@
+-[MI] if x == 0/0 then
++[MI] if x ~= x then
+      end
+      
+-[MI] if x ~= 0/0 then
++[MI] if x == x then
+      end
+      
+      if x ~= x then
+      end
+      
+      if x >= 0/0 then
+      end
+      
+      if 1 == 0/0 then
+      end
+      
+      if 1 ~= 0/0 then
+      end
+      
+      if 1 + 0/0 then
+      end
+      
+      if y.foo() == 0/0 then
+      end
+      
+      if y.bar() ~= 0/0 then
+      end
+      
+      if x == 1 then
+      end
+      
+      if 1 == 0 then
+      end
\ No newline at end of file
diff --git a/selene-lib/tests/lints/compare_nan/compare_nan_if.stderr b/selene-lib/tests/lints/compare_nan/compare_nan_if.stderr
index 97045662..b03b390c 100644
--- a/selene-lib/tests/lints/compare_nan/compare_nan_if.stderr
+++ b/selene-lib/tests/lints/compare_nan/compare_nan_if.stderr
@@ -2,15 +2,11 @@ error[compare_nan]: comparing things to nan directly is not allowed
   ┌─ compare_nan_if.lua:1:4
   │
 1 │ if x == 0/0 then
-  │    ^^^^^^^^
-  │
-  = try: `x ~= x` instead
+  │    ^^^^^^^^ try: `x ~= x`
 
 error[compare_nan]: comparing things to nan directly is not allowed
   ┌─ compare_nan_if.lua:4:4
   │
 4 │ if x ~= 0/0 then
-  │    ^^^^^^^^
-  │
-  = try: `x == x` instead
+  │    ^^^^^^^^ try: `x == x`
 
diff --git a/selene-lib/tests/lints/compare_nan/compare_nan_variables.fixed.diff b/selene-lib/tests/lints/compare_nan/compare_nan_variables.fixed.diff
new file mode 100644
index 00000000..0983d217
--- /dev/null
+++ b/selene-lib/tests/lints/compare_nan/compare_nan_variables.fixed.diff
@@ -0,0 +1,15 @@
+      local _ = 0/0
+      local _ = 1 ~= 0/0
+      local _ = 2 == 0/0
+      local _ = 3 + 0/0
+      local _ = 4 >= 0/0
+-[MI] local _ = x ~= 0/0
+-[MI] local _ = x == 0/0
++[MI] local _ = x == x
++[MI] local _ = x ~= x
+      local _ = x >= 0/0
+      local _ = y.foo() == 0/0
+      local _ = y.bar() ~= 0/0
+      
+      local _ = x == 1
+      local _ = 1 == 0
\ No newline at end of file
diff --git a/selene-lib/tests/lints/compare_nan/compare_nan_variables.stderr b/selene-lib/tests/lints/compare_nan/compare_nan_variables.stderr
index 0aca91c0..53248bc8 100644
--- a/selene-lib/tests/lints/compare_nan/compare_nan_variables.stderr
+++ b/selene-lib/tests/lints/compare_nan/compare_nan_variables.stderr
@@ -2,15 +2,11 @@ error[compare_nan]: comparing things to nan directly is not allowed
   ┌─ compare_nan_variables.lua:6:11
   │
 6 │ local _ = x ~= 0/0
-  │           ^^^^^^^^
-  │
-  = try: `x == x` instead
+  │           ^^^^^^^^ try: `x == x`
 
 error[compare_nan]: comparing things to nan directly is not allowed
   ┌─ compare_nan_variables.lua:7:11
   │
 7 │ local _ = x == 0/0
-  │           ^^^^^^^^
-  │
-  = try: `x ~= x` instead
+  │           ^^^^^^^^ try: `x ~= x`
 
diff --git a/selene-lib/tests/lints/constant_table_comparison/constant_table_comparison.fixed.diff b/selene-lib/tests/lints/constant_table_comparison/constant_table_comparison.fixed.diff
new file mode 100644
index 00000000..48d54c34
--- /dev/null
+++ b/selene-lib/tests/lints/constant_table_comparison/constant_table_comparison.fixed.diff
@@ -0,0 +1,20 @@
+      print(x == { "a", "b", "c" })
+      print({ "a", "b", "c" } == x)
+      
+-[MI] print(x == {})
+-[MI] print({} == x)
+-[MI] print(x ~= {})
+-[MI] print({} ~= x)
++[MI] print(next(x) == nil)
++[MI] print(next(x) == nil)
++[MI] print(next(x) ~= nil)
++[MI] print(next(x) ~= nil)
+      
+      print({ "a", "b", "c" } == { "a", "b", "c" })
+      print({ "a", "b", "c" } == {})
+      print({} == {})
+      
+      print( -- my cool table
+-[MI] 	t == {}
++[MI] 	next(t) == nil
+      )
diff --git a/selene-lib/tests/lints/constant_table_comparison/constant_table_comparison.stderr b/selene-lib/tests/lints/constant_table_comparison/constant_table_comparison.stderr
index 9b7c509d..dc027047 100644
--- a/selene-lib/tests/lints/constant_table_comparison/constant_table_comparison.stderr
+++ b/selene-lib/tests/lints/constant_table_comparison/constant_table_comparison.stderr
@@ -14,33 +14,25 @@ error[constant_table_comparison]: comparing to a constant table will always fail
   ┌─ constant_table_comparison.lua:4:7
   │
 4 │ print(x == {})
-  │       ^^^^^^^
-  │
-  = try: `next(x) == nil`
+  │       ^^^^^^^ try: `next(x) == nil`
 
 error[constant_table_comparison]: comparing to a constant table will always fail
   ┌─ constant_table_comparison.lua:5:7
   │
 5 │ print({} == x)
-  │       ^^^^^^^
-  │
-  = try: `next(x) == nil`
+  │       ^^^^^^^ try: `next(x) == nil`
 
 error[constant_table_comparison]: comparing to a constant table will always fail
   ┌─ constant_table_comparison.lua:6:7
   │
 6 │ print(x ~= {})
-  │       ^^^^^^^
-  │
-  = try: `next(x) ~= nil`
+  │       ^^^^^^^ try: `next(x) ~= nil`
 
 error[constant_table_comparison]: comparing to a constant table will always fail
   ┌─ constant_table_comparison.lua:7:7
   │
 7 │ print({} ~= x)
-  │       ^^^^^^^
-  │
-  = try: `next(x) ~= nil`
+  │       ^^^^^^^ try: `next(x) ~= nil`
 
 error[constant_table_comparison]: comparing to a constant table will always fail
   ┌─ constant_table_comparison.lua:9:7
@@ -64,7 +56,5 @@ error[constant_table_comparison]: comparing to a constant table will always fail
    ┌─ constant_table_comparison.lua:14:2
    │
 14 │     t == {}
-   │     ^^^^^^^
-   │
-   = try: `next(t) == nil`
+   │     ^^^^^^^ try: `next(t) == nil`
 
diff --git a/selene-lib/tests/lints/deprecated/deprecated_fields.fixed.diff b/selene-lib/tests/lints/deprecated/deprecated_fields.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/deprecated/deprecated_functions.fixed.diff b/selene-lib/tests/lints/deprecated/deprecated_functions.fixed.diff
new file mode 100644
index 00000000..d7659a2f
--- /dev/null
+++ b/selene-lib/tests/lints/deprecated/deprecated_functions.fixed.diff
@@ -0,0 +1,5 @@
+      table.foreach({}, function(k, v) end)
+-[MI] print(table.getn(x))
++[MI] print(#x)
+      
+      table.foreach({}, 3)
diff --git a/selene-lib/tests/lints/deprecated/specific_allow.fixed.diff b/selene-lib/tests/lints/deprecated/specific_allow.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/deprecated/toml_forwards_compatibility.fixed.diff b/selene-lib/tests/lints/deprecated/toml_forwards_compatibility.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/divide_by_zero/divide_by_zero.fixed.diff b/selene-lib/tests/lints/divide_by_zero/divide_by_zero.fixed.diff
new file mode 100644
index 00000000..f258874f
--- /dev/null
+++ b/selene-lib/tests/lints/divide_by_zero/divide_by_zero.fixed.diff
@@ -0,0 +1,8 @@
+      local _ = 3 / 2
+-[MA] local _ = 5 / 0
++[MA] local _ = math.huge()
+      local _ = 0 / 5
+-[MA] local _ = x / 0
++[MA] local _ = math.huge()
+      local _ = 0 / 0
+-[MA] local _ = -1 / 0+[MA] local _ = math.huge()
\ No newline at end of file
diff --git a/selene-lib/tests/lints/divide_by_zero/divide_by_zero.stderr b/selene-lib/tests/lints/divide_by_zero/divide_by_zero.stderr
index 67b56525..4d4a0eb2 100644
--- a/selene-lib/tests/lints/divide_by_zero/divide_by_zero.stderr
+++ b/selene-lib/tests/lints/divide_by_zero/divide_by_zero.stderr
@@ -1,18 +1,18 @@
-error[divide_by_zero]: dividing by zero is not allowed, use math.huge instead
+error[divide_by_zero]: dividing by zero is not readable
   ┌─ divide_by_zero.lua:2:11
   │
 2 │ local _ = 5 / 0
-  │           ^^^^^
+  │           ^^^^^ try: `math.huge()`
 
-error[divide_by_zero]: dividing by zero is not allowed, use math.huge instead
+error[divide_by_zero]: dividing by zero is not readable
   ┌─ divide_by_zero.lua:4:11
   │
 4 │ local _ = x / 0
-  │           ^^^^^
+  │           ^^^^^ try: `math.huge()`
 
-error[divide_by_zero]: dividing by zero is not allowed, use math.huge instead
+error[divide_by_zero]: dividing by zero is not readable
   ┌─ divide_by_zero.lua:6:11
   │
 6 │ local _ = -1 / 0
-  │           ^^^^^^
+  │           ^^^^^^ try: `math.huge()`
 
diff --git a/selene-lib/tests/lints/duplicate_keys/duplicate_keys.fixed.diff b/selene-lib/tests/lints/duplicate_keys/duplicate_keys.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/duplicate_keys/number_indices.fixed.diff b/selene-lib/tests/lints/duplicate_keys/number_indices.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/empty_if/empty_if.fixed.diff b/selene-lib/tests/lints/empty_if/empty_if.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/empty_if/empty_if_comments.fixed.diff b/selene-lib/tests/lints/empty_if/empty_if_comments.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff b/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff
new file mode 100644
index 00000000..d378474b
--- /dev/null
+++ b/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff
@@ -0,0 +1,73 @@
+      for _ = 1, 10 do
+          return "Should not warn"
+      end
+      
+      for _ = 1, 10 do
+          print("Should not warn")
+      end
+      
+-[MI] for _ = 1, 10 do
+-[MI]     -- Should warn
+-[MI] end
+      
+-[MI] for _ = 1, 10 do
+-[MI]     --[[
+-[MI]     Should warn
+-[MI]     ]]
+-[MI] end
+      
+-[MI] for _ = 1, 10 do
+      
+      
+-[MI]     
+-[MI] end
+      
++     
+      for _ in pairs({}) do
+          return "Should not warn"
+      end
+      
+-[MI] for _ in pairs({}) do
+-[MI] end
+      
++     
+      for _ in ipairs({}) do
+          return "Should not warn"
+      end
+      
+-[MI] for _ in ipairs({}) do
+-[MI] end
+      
++     
+      for _ in {} do
+          return "Should not warn"
+      end
+      
+-[MI] for _ in {} do
+-[MI] end
+      
++     
+      for _ in a() do
+          return "Should not warn"
+      end
+      
+-[MI] for _ in a() do
+-[MI] end
+      
++     
+      while true do
+          return "Should not warn"
+      end
+      
+-[MI] while true do
+-[MI] end
+      
++     
+      repeat
+          return "Should not warn"
+      until true
+      
+-[MI] repeat
+-[MI] until true
++[MI] 
+      -- comment here shouldn't break anything
diff --git a/selene-lib/tests/lints/empty_loop/empty_loop.stderr b/selene-lib/tests/lints/empty_loop/empty_loop.stderr
index de0edc12..a7ae85a5 100644
--- a/selene-lib/tests/lints/empty_loop/empty_loop.stderr
+++ b/selene-lib/tests/lints/empty_loop/empty_loop.stderr
@@ -4,7 +4,7 @@ error[empty_loop]: empty loop block
  9 │ ╭ for _ = 1, 10 do
 10 │ │     -- Should warn
 11 │ │ end
-   │ ╰───^
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:13:1
@@ -14,7 +14,7 @@ error[empty_loop]: empty loop block
 15 │ │     Should warn
 16 │ │     ]]
 17 │ │ end
-   │ ╰───^
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:19:1
@@ -24,47 +24,47 @@ error[empty_loop]: empty loop block
 21 │ │ 
 22 │ │     
 23 │ │ end
-   │ ╰───^
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:29:1
    │  
 29 │ ╭ for _ in pairs({}) do
 30 │ │ end
-   │ ╰───^
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:36:1
    │  
 36 │ ╭ for _ in ipairs({}) do
 37 │ │ end
-   │ ╰───^
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:43:1
    │  
 43 │ ╭ for _ in {} do
 44 │ │ end
-   │ ╰───^
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:50:1
    │  
 50 │ ╭ for _ in a() do
 51 │ │ end
-   │ ╰───^
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:57:1
    │  
 57 │ ╭ while true do
 58 │ │ end
-   │ ╰───^
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:64:1
    │  
 64 │ ╭ repeat
 65 │ │ until true
-   │ ╰──────────^
+   │ ╰──────────^ consider removing this
 
diff --git a/selene-lib/tests/lints/empty_loop/empty_loop_comments.fixed.diff b/selene-lib/tests/lints/empty_loop/empty_loop_comments.fixed.diff
new file mode 100644
index 00000000..58ef60e3
--- /dev/null
+++ b/selene-lib/tests/lints/empty_loop/empty_loop_comments.fixed.diff
@@ -0,0 +1,72 @@
+      for _ = 1, 10 do
+          return "Should not warn"
+      end
+      
+      for _ = 1, 10 do
+          print("Should not warn")
+      end
+      
+      for _ = 1, 10 do
+          -- Should not warn
+      end
+      
+      for _ = 1, 10 do
+          --[[
+          Should not warn
+          ]]
+      end
+      
+-[MI] for _ = 1, 10 do
+-[MI] 
+-[MI] 
+      
+-[MI] end
+      
+      for _ in pairs({}) do
+          return "Should not warn"
+      end
+      
+-[MI] for _ in pairs({}) do
+-[MI] end
+      
++     
+      for _ in ipairs({}) do
+          return "Should not warn"
+      end
+      
+-[MI] for _ in ipairs({}) do
+-[MI] end
+      
++     
+      for _ in {} do
+          return "Should not warn"
+      end
+      
+-[MI] for _ in {} do
+-[MI] end
+      
++     
+      for _ in a() do
+          return "Should not warn"
+      end
+      
+-[MI] for _ in a() do
+-[MI] end
+      
++     
+      while true do
+          return "Should not warn"
+      end
+      
+-[MI] while true do
+-[MI] end
+      
++     
+      repeat
+          return "Should not warn"
+      until true
+      
+-[MI] repeat
+-[MI] until true
++[MI] 
+      -- comment here shouldn't break anything
diff --git a/selene-lib/tests/lints/empty_loop/empty_loop_comments.stderr b/selene-lib/tests/lints/empty_loop/empty_loop_comments.stderr
index 9128ae0f..07a7f053 100644
--- a/selene-lib/tests/lints/empty_loop/empty_loop_comments.stderr
+++ b/selene-lib/tests/lints/empty_loop/empty_loop_comments.stderr
@@ -6,47 +6,47 @@ error[empty_loop]: empty loop block
 21 │ │ 
 22 │ │ 
 23 │ │ end
-   │ ╰───^
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:29:1
    │  
 29 │ ╭ for _ in pairs({}) do
 30 │ │ end
-   │ ╰───^
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:36:1
    │  
 36 │ ╭ for _ in ipairs({}) do
 37 │ │ end
-   │ ╰───^
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:43:1
    │  
 43 │ ╭ for _ in {} do
 44 │ │ end
-   │ ╰───^
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:50:1
    │  
 50 │ ╭ for _ in a() do
 51 │ │ end
-   │ ╰───^
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:57:1
    │  
 57 │ ╭ while true do
 58 │ │ end
-   │ ╰───^
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:64:1
    │  
 64 │ ╭ repeat
 65 │ │ until true
-   │ ╰──────────^
+   │ ╰──────────^ consider removing this
 
diff --git a/selene-lib/tests/lints/global_usage/global_usage.fixed.diff b/selene-lib/tests/lints/global_usage/global_usage.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/global_usage/global_usage_ignore.fixed.diff b/selene-lib/tests/lints/global_usage/global_usage_ignore.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/high_cyclomatic_complexity/complex_var_expressions.fixed.diff b/selene-lib/tests/lints/high_cyclomatic_complexity/complex_var_expressions.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/high_cyclomatic_complexity/high_cyclomatic_complexity.fixed.diff b/selene-lib/tests/lints/high_cyclomatic_complexity/high_cyclomatic_complexity.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/high_cyclomatic_complexity/lua51_basic_complexity.fixed.diff b/selene-lib/tests/lints/high_cyclomatic_complexity/lua51_basic_complexity.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/if_same_then_else/if_same_then_else.fixed.diff b/selene-lib/tests/lints/if_same_then_else/if_same_then_else.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/ifs_same_cond/ifs_same_cond.fixed.diff b/selene-lib/tests/lints/ifs_same_cond/ifs_same_cond.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/manual_table_clone/false_positive.fixed.diff b/selene-lib/tests/lints/manual_table_clone/false_positive.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/manual_table_clone/manual_table_clone.fixed.diff b/selene-lib/tests/lints/manual_table_clone/manual_table_clone.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/mismatched_arg_count/alternative_function_definition.fixed.diff b/selene-lib/tests/lints/mismatched_arg_count/alternative_function_definition.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/mismatched_arg_count/call_side_effects.fixed.diff b/selene-lib/tests/lints/mismatched_arg_count/call_side_effects.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/mismatched_arg_count/definition_location.fixed.diff b/selene-lib/tests/lints/mismatched_arg_count/definition_location.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/mismatched_arg_count/mismatched_arg_count.fixed.diff b/selene-lib/tests/lints/mismatched_arg_count/mismatched_arg_count.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/mismatched_arg_count/multiple_definition_locations.fixed.diff b/selene-lib/tests/lints/mismatched_arg_count/multiple_definition_locations.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/mismatched_arg_count/reassigned_variables.fixed.diff b/selene-lib/tests/lints/mismatched_arg_count/reassigned_variables.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/mismatched_arg_count/reassigned_variables_2.fixed.diff b/selene-lib/tests/lints/mismatched_arg_count/reassigned_variables_2.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/mismatched_arg_count/shadowing_variables.fixed.diff b/selene-lib/tests/lints/mismatched_arg_count/shadowing_variables.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/mismatched_arg_count/variable_function_def.fixed.diff b/selene-lib/tests/lints/mismatched_arg_count/variable_function_def.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/mixed_table/mixed_table.fixed.diff b/selene-lib/tests/lints/mixed_table/mixed_table.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/multiple_statements/multiple_statements.fixed.diff b/selene-lib/tests/lints/multiple_statements/multiple_statements.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/multiple_statements/one_line_if_allow.fixed.diff b/selene-lib/tests/lints/multiple_statements/one_line_if_allow.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/multiple_statements/one_line_if_break_return_only.fixed.diff b/selene-lib/tests/lints/multiple_statements/one_line_if_break_return_only.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/multiple_statements/one_line_if_deny.fixed.diff b/selene-lib/tests/lints/multiple_statements/one_line_if_deny.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/must_use/must_use.fixed.diff b/selene-lib/tests/lints/must_use/must_use.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
new file mode 100644
index 00000000..dd98fffa
--- /dev/null
+++ b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
@@ -0,0 +1,27 @@
+      if x then end
+-[MA] if (x) then end
++[MA] if x then end
+      
+-[MA] if (x) then
++[MA] if x then
+      elseif y then
+-[MA] elseif (z) then
++[MA] elseif z then
+      end
+      
+      while true do end
+-[MA] while (true) do end
++[MA] while true do end
+      
+      repeat until false
+-[MA] repeat until (false)
++[MA] repeat until false
+      
+      while (true) and false do end
+      
+-[MA] if ((function()
+-[MA]     if (x) then end
+-[MA] end)()) then end
++[MA] if (function()
++[MA]     if x then end
++[MA] end)() then end
diff --git a/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.lua b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.lua
index 2bd3c768..ddcdac22 100644
--- a/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.lua
+++ b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.lua
@@ -13,3 +13,7 @@ repeat until false
 repeat until (false)
 
 while (true) and false do end
+
+if ((function()
+    if (x) then end
+end)()) then end
diff --git a/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.stderr b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.stderr
index 7dc8edf4..607683ce 100644
--- a/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.stderr
+++ b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.stderr
@@ -2,29 +2,46 @@ error[parenthese_conditions]: lua does not require parentheses around conditions
   ┌─ parenthese_conditions.lua:2:4
   │
 2 │ if (x) then end
-  │    ^^^
+  │    ^^^ try: `x`
 
 error[parenthese_conditions]: lua does not require parentheses around conditions
   ┌─ parenthese_conditions.lua:4:4
   │
 4 │ if (x) then
-  │    ^^^
+  │    ^^^ try: `x`
 
 error[parenthese_conditions]: lua does not require parentheses around conditions
   ┌─ parenthese_conditions.lua:6:8
   │
 6 │ elseif (z) then
-  │        ^^^
+  │        ^^^ try: `z`
 
 error[parenthese_conditions]: lua does not require parentheses around conditions
    ┌─ parenthese_conditions.lua:10:7
    │
 10 │ while (true) do end
-   │       ^^^^^^
+   │       ^^^^^^ try: `true`
 
 error[parenthese_conditions]: lua does not require parentheses around conditions
    ┌─ parenthese_conditions.lua:13:14
    │
 13 │ repeat until (false)
-   │              ^^^^^^^
+   │              ^^^^^^^ try: `false`
+
+error[parenthese_conditions]: lua does not require parentheses around conditions
+   ┌─ parenthese_conditions.lua:17:4
+   │  
+17 │   if ((function()
+   │ ╭────^
+18 │ │     if (x) then end
+19 │ │ end)()) then end
+   │ ╰───────^ try: `(function()
+    if (x) then end
+end)()`
+
+error[parenthese_conditions]: lua does not require parentheses around conditions
+   ┌─ parenthese_conditions.lua:18:8
+   │
+18 │     if (x) then end
+   │        ^^^ try: `x`
 
diff --git a/selene-lib/tests/lints/roblox_incorrect_color3_new_bounds/roblox_incorrect_color3_new_bounds.fixed.diff b/selene-lib/tests/lints/roblox_incorrect_color3_new_bounds/roblox_incorrect_color3_new_bounds.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/roblox_incorrect_roact_usage/mixed_roact_react_usage.fixed.diff b/selene-lib/tests/lints/roblox_incorrect_roact_usage/mixed_roact_react_usage.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/roblox_incorrect_roact_usage/old_roblox_std.fixed.diff b/selene-lib/tests/lints/roblox_incorrect_roact_usage/old_roblox_std.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/roblox_incorrect_roact_usage/roblox_incorrect_react_usage.fixed.diff b/selene-lib/tests/lints/roblox_incorrect_roact_usage/roblox_incorrect_react_usage.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/roblox_incorrect_roact_usage/roblox_incorrect_roact_usage.fixed.diff b/selene-lib/tests/lints/roblox_incorrect_roact_usage/roblox_incorrect_roact_usage.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/roblox_suspicious_udim2_new/roblox_suspicious_udim2_new.fixed.diff b/selene-lib/tests/lints/roblox_suspicious_udim2_new/roblox_suspicious_udim2_new.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/shadowing/empty_else.fixed.diff b/selene-lib/tests/lints/shadowing/empty_else.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/shadowing/shadowing.fixed.diff b/selene-lib/tests/lints/shadowing/shadowing.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/any.fixed.diff b/selene-lib/tests/lints/standard_library/any.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/assert.fixed.diff b/selene-lib/tests/lints/standard_library/assert.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/bad_call_signatures.fixed.diff b/selene-lib/tests/lints/standard_library/bad_call_signatures.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/callable_metatables.fixed.diff b/selene-lib/tests/lints/standard_library/callable_metatables.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/complex.fixed.diff b/selene-lib/tests/lints/standard_library/complex.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/constants.fixed.diff b/selene-lib/tests/lints/standard_library/constants.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/if_expressions.fixed.diff b/selene-lib/tests/lints/standard_library/if_expressions.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/lua52.fixed.diff b/selene-lib/tests/lints/standard_library/lua52.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/math_on_types.fixed.diff b/selene-lib/tests/lints/standard_library/math_on_types.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/method_call.fixed.diff b/selene-lib/tests/lints/standard_library/method_call.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/method_call.stderr b/selene-lib/tests/lints/standard_library/method_call.stderr
index fdbe503e..b74f94a5 100644
--- a/selene-lib/tests/lints/standard_library/method_call.stderr
+++ b/selene-lib/tests/lints/standard_library/method_call.stderr
@@ -8,9 +8,7 @@ error[incorrect_standard_library_use]: standard library function `foo.bar` is a
   ┌─ method_call.lua:3:1
   │
 3 │ foo.bar()
-  │ ^^^^^^^^^
-  │
-  = try: foo:bar(...)
+  │ ^^^^^^^^^ try: `foo:bar(...)`
 
 error[incorrect_standard_library_use]: standard library global `foo` does not contain the field `baz`
   ┌─ method_call.lua:4:1
diff --git a/selene-lib/tests/lints/standard_library/required.fixed.diff b/selene-lib/tests/lints/standard_library/required.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/shadowing.fixed.diff b/selene-lib/tests/lints/standard_library/shadowing.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/string_interpolation.fixed.diff b/selene-lib/tests/lints/standard_library/string_interpolation.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/ternary.fixed.diff b/selene-lib/tests/lints/standard_library/ternary.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/unknown_property.fixed.diff b/selene-lib/tests/lints/standard_library/unknown_property.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/unpack_function_arguments.fixed.diff b/selene-lib/tests/lints/standard_library/unpack_function_arguments.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/vararg.fixed.diff b/selene-lib/tests/lints/standard_library/vararg.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/wildcard.fixed.diff b/selene-lib/tests/lints/standard_library/wildcard.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/wildcard_structs.fixed.diff b/selene-lib/tests/lints/standard_library/wildcard_structs.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/standard_library/writing.fixed.diff b/selene-lib/tests/lints/standard_library/writing.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/suspicious_reverse_loop/suspicious_reverse_loop.fixed.diff b/selene-lib/tests/lints/suspicious_reverse_loop/suspicious_reverse_loop.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/type_check_inside_call/type_check_inside_call.fixed.diff b/selene-lib/tests/lints/type_check_inside_call/type_check_inside_call.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/unbalanced_assignments/unbalanced_assignments.fixed.diff b/selene-lib/tests/lints/unbalanced_assignments/unbalanced_assignments.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/undefined_variable/basic.fixed.diff b/selene-lib/tests/lints/undefined_variable/basic.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/undefined_variable/compound_assignments.fixed.diff b/selene-lib/tests/lints/undefined_variable/compound_assignments.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/undefined_variable/function_overriding.fixed.diff b/selene-lib/tests/lints/undefined_variable/function_overriding.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/undefined_variable/hoisting.fixed.diff b/selene-lib/tests/lints/undefined_variable/hoisting.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/undefined_variable/self.fixed.diff b/selene-lib/tests/lints/undefined_variable/self.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/undefined_variable/shadowing.fixed.diff b/selene-lib/tests/lints/undefined_variable/shadowing.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/undefined_variable/string_interpolation.fixed.diff b/selene-lib/tests/lints/undefined_variable/string_interpolation.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/undefined_variable/varargs.fixed.diff b/selene-lib/tests/lints/undefined_variable/varargs.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/unscoped_variables/function_overriding.fixed.diff b/selene-lib/tests/lints/unscoped_variables/function_overriding.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/unscoped_variables/unscoped_variables.fixed.diff b/selene-lib/tests/lints/unscoped_variables/unscoped_variables.fixed.diff
new file mode 100644
index 00000000..6338e4ee
--- /dev/null
+++ b/selene-lib/tests/lints/unscoped_variables/unscoped_variables.fixed.diff
@@ -0,0 +1,16 @@
+-[MI] bar = true
++[MI] local bar = true
+      
+      local foo = 1
+      foo = 2
+      
+      local bar = 1
+      bar = 2
+      
+      pcall(function()
+          foo = 3
+-[MI]     baz = 1
++[MI]     local baz = 1
+      end)
+      
+      _ = 3
diff --git a/selene-lib/tests/lints/unscoped_variables/unscoped_variables.stderr b/selene-lib/tests/lints/unscoped_variables/unscoped_variables.stderr
index 77102010..541568a5 100644
--- a/selene-lib/tests/lints/unscoped_variables/unscoped_variables.stderr
+++ b/selene-lib/tests/lints/unscoped_variables/unscoped_variables.stderr
@@ -2,11 +2,11 @@ error[unscoped_variables]: `bar` is not declared locally, and will be available
   ┌─ unscoped_variables.lua:1:1
   │
 1 │ bar = true
-  │ ^^^
+  │ ^^^ try: `local bar`
 
 error[unscoped_variables]: `baz` is not declared locally, and will be available in every scope
    ┌─ unscoped_variables.lua:11:5
    │
 11 │     baz = 1
-   │     ^^^
+   │     ^^^ try: `local baz`
 
diff --git a/selene-lib/tests/lints/unused_variable/blocks.fixed.diff b/selene-lib/tests/lints/unused_variable/blocks.fixed.diff
new file mode 100644
index 00000000..7ad71a34
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/blocks.fixed.diff
@@ -0,0 +1,25 @@
+      -- Functions
+-[MA] local function unusedFunction()
+-[MA]     local unusedVariableA = 1
+-[MA]     local unusedVariableB = 1
++[MA] local function _unusedFunction()
++[MA]     local _unusedVariableA = 1
++[MA]     local _unusedVariableB = 1
+      end
+      
+      print(unusedVariableB)
+-[MA] local overidden = true
++[MA] local _overidden = true
+      
+      local function overridesIt()
+          local overidden = false
+          print(overidden)
+      end
+      
+      overridesIt()
+      
+      -- Anonymous functions
+      local a = 1
+      print(function()
+          _G.foo = a
+      end)
diff --git a/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff b/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff
new file mode 100644
index 00000000..e7a381e0
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff
@@ -0,0 +1,10 @@
+      local foo = 1
+-[MA] local foo = foo + 1
+-[MA] local bar = bar
++[MA] local _foo = foo + 1
++[MA] local _bar = bar
+      
+      -- The variables inside of a repeat...until are accessible from the until statement
+      repeat
+          local baz
+      until baz
diff --git a/selene-lib/tests/lints/unused_variable/explicit_self.fixed.diff b/selene-lib/tests/lints/unused_variable/explicit_self.fixed.diff
new file mode 100644
index 00000000..2b0a5447
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/explicit_self.fixed.diff
@@ -0,0 +1,5 @@
+-[MA] local function foo(self)
++[MA] local function foo(_self)
+      end
+      
+      foo()
diff --git a/selene-lib/tests/lints/unused_variable/function_overriding.fixed.diff b/selene-lib/tests/lints/unused_variable/function_overriding.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/unused_variable/generic_for_shadowing.fixed.diff b/selene-lib/tests/lints/unused_variable/generic_for_shadowing.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/unused_variable/if.fixed.diff b/selene-lib/tests/lints/unused_variable/if.fixed.diff
new file mode 100644
index 00000000..53817d4d
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/if.fixed.diff
@@ -0,0 +1,18 @@
+      if 1 then
+-[MA]     local localA
++[MA]     local _localA
+      elseif 2 then
+-[MA]     local localB
++[MA]     local _localB
+          print(localA)
+      elseif 3 then
+-[MA]     local localC
++[MA]     local _localC
+          print(localB)
+      else
+-[MA]     local localD
++[MA]     local _localD
+          print(localC)
+      end
+      
+      print(localA, localB, localC, localD)
diff --git a/selene-lib/tests/lints/unused_variable/ignore.fixed.diff b/selene-lib/tests/lints/unused_variable/ignore.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/unused_variable/locals.fixed.diff b/selene-lib/tests/lints/unused_variable/locals.fixed.diff
new file mode 100644
index 00000000..573d4626
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/locals.fixed.diff
@@ -0,0 +1,32 @@
+      -- Unused
+-[MA] local localA, localB
++[MA] local _localA, _localB
+      
+      -- Used
+      local localC = 1
+      print(localC)
+      
+      -- Mutated, but never read
+      local localD = 1
+      localD = 2
+      localD = 3
+      
+      -- Read, mutated, read
+      local localE = 1
+      print(localE)
+      localE = 2
+      print(localE)
+      
+      -- Read, mutated, unread
+      local localF = 1
+      print(localF)
+      localF = 2
+      
+      -- Called function
+      local localG = function() end
+      localG()
+      
+      -- Put into a table
+      local localH = 1
+-[MA] local localI = { localH }
++[MA] local _localI = { localH }
diff --git a/selene-lib/tests/lints/unused_variable/mutating_functions.fixed.diff b/selene-lib/tests/lints/unused_variable/mutating_functions.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/unused_variable/observes.fixed.diff b/selene-lib/tests/lints/unused_variable/observes.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/unused_variable/overriding.fixed.diff b/selene-lib/tests/lints/unused_variable/overriding.fixed.diff
new file mode 100644
index 00000000..4b7517e8
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/overriding.fixed.diff
@@ -0,0 +1,28 @@
+      local a = 1
+      
+      -- Variables defined inside the function should still lint
+-[MA] local function foo()
++[MA] local function _foo()
+          local b = 1
+          if true then
+              b = b + 1
+      
+              local c = 1
+              if true then
+                  c = c + 1
+              end
+          end
+      
+          local d = 1
+          return function()
+              return d
+          end, function()
+              d = d + 1
+          end
+      end
+      
+      return function()
+          return a
+      end, function(arg)
+          a = arg
+      end
diff --git a/selene-lib/tests/lints/unused_variable/self.fixed.diff b/selene-lib/tests/lints/unused_variable/self.fixed.diff
new file mode 100644
index 00000000..122a9dbe
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/self.fixed.diff
@@ -0,0 +1,9 @@
+      local Foo = {}
+      
+-[MI] function Foo:A() end
++[MI] function Foo.A() end
+      function Foo.B() end
+-[MI] function Foo    :    C() end
++[MI] function Foo    .    C() end
+      
+      return Foo
diff --git a/selene-lib/tests/lints/unused_variable/self.lua b/selene-lib/tests/lints/unused_variable/self.lua
index 15a3ca8a..2bb2b976 100644
--- a/selene-lib/tests/lints/unused_variable/self.lua
+++ b/selene-lib/tests/lints/unused_variable/self.lua
@@ -2,5 +2,6 @@ local Foo = {}
 
 function Foo:A() end
 function Foo.B() end
+function Foo    :    C() end
 
 return Foo
diff --git a/selene-lib/tests/lints/unused_variable/self.stderr b/selene-lib/tests/lints/unused_variable/self.stderr
index 7f7eda99..40f81522 100644
--- a/selene-lib/tests/lints/unused_variable/self.stderr
+++ b/selene-lib/tests/lints/unused_variable/self.stderr
@@ -1,8 +1,17 @@
 error[unused_variable]: self is defined, but never used
-  ┌─ self.lua:3:14
+  ┌─ self.lua:3:13
   │
 3 │ function Foo:A() end
-  │              ^
+  │             ^
+  │
+  = `self` is implicitly defined when defining a method
+  = if you don't need it, consider using `.` instead of `:`
+
+error[unused_variable]: self is defined, but never used
+  ┌─ self.lua:5:17
+  │
+5 │ function Foo    :    C() end
+  │                 ^
   │
   = `self` is implicitly defined when defining a method
   = if you don't need it, consider using `.` instead of `:`
diff --git a/selene-lib/tests/lints/unused_variable/self_ignored.fixed.diff b/selene-lib/tests/lints/unused_variable/self_ignored.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/unused_variable/shadowing.fixed.diff b/selene-lib/tests/lints/unused_variable/shadowing.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-lib/tests/lints/unused_variable/types.fixed.diff b/selene-lib/tests/lints/unused_variable/types.fixed.diff
new file mode 100644
index 00000000..13af7878
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/types.fixed.diff
@@ -0,0 +1,4 @@
+      local types = require(script.types)
+      
+-[MA] local value: types.something
++[MA] local _value: types.something
diff --git a/selene-lib/tests/lints/unused_variable/varargs.fixed.diff b/selene-lib/tests/lints/unused_variable/varargs.fixed.diff
new file mode 100644
index 00000000..b5e847b7
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/varargs.fixed.diff
@@ -0,0 +1,10 @@
+      local function foo(...)
+          call(...)
+      end
+      
+-[MA] local function bar(...)
++[MA] local function _bar(...)
+          call(...)
+      end
+      
+      foo()
diff --git a/selene-lib/tests/lints/unused_variable/write_only.fixed.diff b/selene-lib/tests/lints/unused_variable/write_only.fixed.diff
new file mode 100644
index 00000000..e69de29b
diff --git a/selene-vscode/src/extension.ts b/selene-vscode/src/extension.ts
index 4edad143..221759d6 100644
--- a/selene-vscode/src/extension.ts
+++ b/selene-vscode/src/extension.ts
@@ -3,7 +3,12 @@ import * as selene from "./selene"
 import * as timers from "timers"
 import * as util from "./util"
 import * as vscode from "vscode"
-import { Diagnostic, Severity, Label } from "./structures/diagnostic"
+import {
+    Diagnostic,
+    Severity,
+    Label,
+    SeleneDiagnostic,
+} from "./structures/diagnostic"
 import { Output } from "./structures/output"
 import { lintConfig } from "./configLint"
 import { byteToCharMap } from "./byteToCharMap"
@@ -18,6 +23,40 @@ enum RunType {
     OnIdle = "onIdle",
 }
 
+class SeleneCodeActionProvider implements vscode.CodeActionProvider {
+    public provideCodeActions(
+        document: vscode.TextDocument,
+        _range: vscode.Range | vscode.Selection,
+        context: vscode.CodeActionContext,
+    ): vscode.ProviderResult<vscode.Command[] | vscode.CodeAction[]> {
+        const codeActions: vscode.CodeAction[] = []
+
+        for (const diagnostic of context.diagnostics) {
+            if (
+                diagnostic instanceof SeleneDiagnostic &&
+                diagnostic.suggestion
+            ) {
+                const action = new vscode.CodeAction(
+                    diagnostic.message,
+                    vscode.CodeActionKind.QuickFix,
+                )
+                action.diagnostics = [diagnostic]
+
+                action.edit = new vscode.WorkspaceEdit()
+                action.edit.replace(
+                    document.uri,
+                    diagnostic.range,
+                    diagnostic.suggestion,
+                )
+
+                codeActions.push(action)
+            }
+        }
+
+        return codeActions
+    }
+}
+
 function labelToRange(
     document: vscode.TextDocument,
     label: Label,
@@ -73,6 +112,13 @@ export async function activate(
 
     await trySelene
 
+    context.subscriptions.push(
+        vscode.languages.registerCodeActionsProvider(
+            "lua",
+            new SeleneCodeActionProvider(),
+        ),
+    )
+
     context.subscriptions.push(
         vscode.commands.registerCommand("selene.reinstall", () => {
             trySelene = util
@@ -204,12 +250,13 @@ export async function activate(
                 message += `\n${data.notes.map((note) => `note: ${note}\n`)}`
             }
 
-            const diagnostic = new vscode.Diagnostic(
+            const diagnostic = new SeleneDiagnostic(
                 labelToRange(document, data.primary_label, byteOffsetMap),
                 message,
                 data.severity === Severity.Error
                     ? vscode.DiagnosticSeverity.Error
                     : vscode.DiagnosticSeverity.Warning,
+                data.suggestion,
             )
 
             diagnostic.source = `selene::${data.code}`
diff --git a/selene-vscode/src/structures/diagnostic.ts b/selene-vscode/src/structures/diagnostic.ts
index 37dcf8ae..4e3f23ac 100644
--- a/selene-vscode/src/structures/diagnostic.ts
+++ b/selene-vscode/src/structures/diagnostic.ts
@@ -1,3 +1,5 @@
+import * as vscode from "vscode"
+
 export interface Label {
     message: string
     span: {
@@ -18,4 +20,19 @@ export interface Diagnostic {
     notes: string[]
     primary_label: Label
     secondary_labels: Label[]
+    suggestion: string
+}
+
+export class SeleneDiagnostic extends vscode.Diagnostic {
+    suggestion?: string
+
+    constructor(
+        range: vscode.Range,
+        message: string,
+        severity: vscode.DiagnosticSeverity,
+        suggestion?: string,
+    ) {
+        super(range, message, severity)
+        this.suggestion = suggestion
+    }
 }
diff --git a/selene/src/json_output.rs b/selene/src/json_output.rs
index ed238842..e65dcdcd 100644
--- a/selene/src/json_output.rs
+++ b/selene/src/json_output.rs
@@ -30,6 +30,7 @@ pub struct JsonDiagnostic {
     primary_label: Label,
     notes: Vec<String>,
     secondary_labels: Vec<Label>,
+    suggestion: Option<String>,
 }
 
 #[derive(Serialize)]
@@ -77,6 +78,7 @@ fn label_to_serializable(
 pub fn diagnostic_to_json(
     diagnostic: &CodespanDiagnostic<codespan::FileId>,
     files: &codespan::Files<&str>,
+    suggestion: Option<String>,
 ) -> JsonDiagnostic {
     let label = diagnostic.labels.first().expect("no labels passed");
     let filename = files.name(label.file_id).to_string_lossy().into_owned();
@@ -93,6 +95,7 @@ pub fn diagnostic_to_json(
             .filter(|label| label.style == LabelStyle::Secondary)
             .map(|label| label_to_serializable(&filename, label, files))
             .collect(),
+        suggestion,
     }
 }
 
diff --git a/selene/src/main.rs b/selene/src/main.rs
index 610aeb8a..98f490f5 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -3,6 +3,7 @@ use std::{
     fmt, fs,
     io::{self, Read, Write},
     path::{Path, PathBuf},
+    process::Command,
     sync::{
         atomic::{AtomicUsize, Ordering},
         Arc, RwLock,
@@ -15,7 +16,10 @@ use codespan_reporting::{
     },
     term::DisplayStyle as CodespanDisplayStyle,
 };
-use selene_lib::{lints::Severity, *};
+use selene_lib::{
+    lints::{Diagnostic, Severity},
+    *,
+};
 use structopt::{clap, StructOpt};
 use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 use threadpool::ThreadPool;
@@ -126,6 +130,7 @@ fn emit_codespan(
     writer: &mut impl termcolor::WriteColor,
     files: &codespan::Files<&str>,
     diagnostic: &CodespanDiagnostic<codespan::FileId>,
+    suggestion: Option<String>,
 ) {
     let lock = OPTIONS.read().unwrap();
     let opts = lock.as_ref().unwrap();
@@ -144,7 +149,10 @@ fn emit_codespan(
             writeln!(
                 writer,
                 "{}",
-                serde_json::to_string(&json_output::diagnostic_to_json(diagnostic, files)).unwrap()
+                serde_json::to_string(&json_output::diagnostic_to_json(
+                    diagnostic, files, suggestion
+                ))
+                .unwrap()
             )
             .unwrap();
         }
@@ -154,7 +162,7 @@ fn emit_codespan(
                 writer,
                 "{}",
                 serde_json::to_string(&json_output::JsonOutput::Diagnostic(
-                    json_output::diagnostic_to_json(diagnostic, files)
+                    json_output::diagnostic_to_json(diagnostic, files, suggestion)
                 ))
                 .unwrap()
             )
@@ -175,10 +183,15 @@ fn emit_codespan_locked(
     let stdout = termcolor::StandardStream::stdout(get_color());
     let mut stdout = stdout.lock();
 
-    emit_codespan(&mut stdout, files, diagnostic);
+    emit_codespan(&mut stdout, files, diagnostic, None);
 }
 
-fn read<R: Read>(checker: &Checker<toml::value::Value>, filename: &Path, mut reader: R) {
+fn read<R: Read>(
+    checker: &Checker<toml::value::Value>,
+    filename: &Path,
+    mut reader: R,
+    is_fix: bool,
+) {
     let mut buffer = Vec::new();
     if let Err(error) = reader.read_to_end(&mut buffer) {
         error!(
@@ -270,9 +283,79 @@ fn read<R: Read>(checker: &Checker<toml::value::Value>, filename: &Path, mut rea
         }
     };
 
-    let mut diagnostics = checker.test_on(&ast);
+    let mut diagnostics = checker.test_on(&ast, &contents.as_ref().to_string());
     diagnostics.sort_by_key(|diagnostic| diagnostic.diagnostic.start_position());
 
+    let mut suggestion = contents.as_ref().to_string();
+    if is_fix {
+        // This only counts the number of inital automatic fixes. Additional fixes caused by a previous fix won't
+        // be counted
+        let num_fixes = diagnostics
+            .iter()
+            .filter(|diagnostic| diagnostic.diagnostic.has_machine_applicable_fix())
+            .count();
+
+        suggestion = Diagnostic::get_applied_suggestions_code(
+            suggestion.as_str(),
+            &diagnostics
+                .iter()
+                .filter(|diagnostic| diagnostic.diagnostic.has_machine_applicable_fix())
+                .map(|diagnostic| &diagnostic.diagnostic)
+                .collect::<Vec<_>>(),
+            |new_code| {
+                let new_ast = full_moon::parse(new_code).expect(
+                    "selene tried applying lint suggestions, but it generated invalid code that could not be parsed; \
+                    this is likely a selene bug",
+                );
+
+                checker
+                    .test_on(&new_ast, &new_code.to_string())
+                    .into_iter()
+                    .filter(|diagnostic| diagnostic.diagnostic.has_machine_applicable_fix())
+                    .map(|diagnostic| diagnostic.diagnostic)
+                    .collect::<Vec<_>>()
+            },
+        );
+
+        let fixed_ast = full_moon::parse(&suggestion).expect(
+                "selene tried applying lint suggestions, but it generated invalid code that could not be parsed; \
+                this is likely a selene bug",
+            );
+        diagnostics = checker.test_on(&fixed_ast, &suggestion);
+        diagnostics.sort_by_key(|diagnostic| diagnostic.diagnostic.start_position());
+
+        if num_fixes > 0 {
+            if fs::write(filename, suggestion.clone()).is_ok() {
+                files.update(source_id, &suggestion);
+
+                let stdout = StandardStream::stdout(get_color());
+                let mut stdout = stdout.lock();
+                let _ =
+                    stdout.set_color(ColorSpec::new().set_fg(Some(Color::Green)).set_bold(true));
+
+                print!("fixed ");
+
+                let _ = stdout.reset();
+
+                println!(
+                    "{} ({} {})",
+                    filename.display(),
+                    num_fixes,
+                    if num_fixes == 1 {
+                        "fix".to_string()
+                    } else {
+                        "fixes".to_string()
+                    }
+                );
+
+                drop(stdout);
+            } else {
+                error(format!("failed to write to {}", filename.display()).as_str());
+                std::process::exit(1);
+            }
+        }
+    }
+
     let (mut errors, mut warnings) = (0, 0);
     for diagnostic in &diagnostics {
         match diagnostic.severity {
@@ -362,6 +445,7 @@ fn read<R: Read>(checker: &Checker<toml::value::Value>, filename: &Path, mut rea
                 write(&mut stack, new_start).unwrap();
             }
         } else {
+            let suggestion = diagnostic.diagnostic.suggestion.clone();
             let diagnostic = diagnostic.diagnostic.into_codespan_diagnostic(
                 source_id,
                 match diagnostic.severity {
@@ -371,12 +455,12 @@ fn read<R: Read>(checker: &Checker<toml::value::Value>, filename: &Path, mut rea
                 },
             );
 
-            emit_codespan(&mut stdout, &files, &diagnostic);
+            emit_codespan(&mut stdout, &files, &diagnostic, suggestion);
         }
     }
 }
 
-fn read_file(checker: &Checker<toml::value::Value>, filename: &Path) {
+fn read_file(checker: &Checker<toml::value::Value>, filename: &Path, is_fix: bool) {
     read(
         checker,
         filename,
@@ -388,6 +472,7 @@ fn read_file(checker: &Checker<toml::value::Value>, filename: &Path) {
                 return;
             }
         },
+        is_fix,
     );
 }
 
@@ -494,6 +579,18 @@ fn start(mut options: opts::Options) {
         None => {}
     }
 
+    if options.fix
+        && !options.allow_dirty
+        && (has_unstaged_changes() || (!options.allow_staged && has_staged_changes()))
+    {
+        error(
+            "the working directory of this package has uncommitted changes, and `selene --fix` can potentially \
+            perform destructive changes; if you'd like to suppress this error pass `--allow-dirty`, `--allow-staged`, \
+            or commit the changes"
+        );
+        std::process::exit(1);
+    }
+
     let (config, config_directory): (CheckerConfig<toml::value::Value>, Option<PathBuf>) =
         match options.config {
             Some(config_file) => {
@@ -608,7 +705,7 @@ fn start(mut options: opts::Options) {
     for filename in &options.files {
         if filename == "-" {
             let checker = Arc::clone(&checker);
-            pool.execute(move || read(&checker, Path::new("-"), io::stdin().lock()));
+            pool.execute(move || read(&checker, Path::new("-"), io::stdin().lock(), options.fix));
             continue;
         }
 
@@ -622,7 +719,7 @@ fn start(mut options: opts::Options) {
                         continue;
                     }
 
-                    pool.execute(move || read_file(&checker, Path::new(&filename)));
+                    pool.execute(move || read_file(&checker, Path::new(&filename), options.fix));
                 } else if metadata.is_dir() {
                     for pattern in &options.pattern {
                         let glob = match glob::glob(&format!(
@@ -646,7 +743,7 @@ fn start(mut options: opts::Options) {
 
                                     let checker = Arc::clone(&checker);
 
-                                    pool.execute(move || read_file(&checker, &path));
+                                    pool.execute(move || read_file(&checker, &path, options.fix));
                                 }
 
                                 Err(error) => {
@@ -771,6 +868,30 @@ fn get_opts_safe(mut args: Vec<OsString>, luacheck: bool) -> Result<opts::Option
     }
 }
 
+fn has_unstaged_changes() -> bool {
+    let output = Command::new("git")
+        .arg("status")
+        .arg("--porcelain")
+        .output()
+        .expect("Failed to execute git");
+
+    let stdout = String::from_utf8(output.stdout).expect("Failed to convert git output to string");
+
+    stdout.lines().any(|line| line.chars().nth(1) != Some(' '))
+}
+
+fn has_staged_changes() -> bool {
+    let output = Command::new("git")
+        .arg("status")
+        .arg("--porcelain")
+        .output()
+        .expect("Failed to execute git");
+
+    let stdout = String::from_utf8(output.stdout).expect("Failed to convert git output to string");
+
+    stdout.lines().any(|line| !line.starts_with(' '))
+}
+
 #[cfg(feature = "roblox")]
 fn generate_roblox_std() -> color_eyre::Result<StandardLibrary> {
     let (contents, std) = roblox::RobloxGenerator::generate()?;
diff --git a/selene/src/opts.rs b/selene/src/opts.rs
index 1ce1bbb7..58c13ebb 100644
--- a/selene/src/opts.rs
+++ b/selene/src/opts.rs
@@ -69,6 +69,19 @@ pub struct Options {
 
     #[structopt(long)]
     pub no_exclude: bool,
+
+    #[structopt(long)]
+    pub fix: bool,
+
+    // Fix code even if the working directory has changes
+    // Only used with `fix`
+    #[structopt(long, hidden(true))]
+    pub allow_dirty: bool,
+
+    // Fix code even if the working directory has staged changes
+    // Only used with `fix`
+    #[structopt(long, hidden(true))]
+    pub allow_staged: bool,
 }
 
 impl Options {