From e0514c484bf5bc38764b2a5fb2b729b01044db87 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Fri, 13 Oct 2023 20:24:39 -0700
Subject: [PATCH 01/63] Add machine applicable diagnostic

---
 Cargo.lock                                    |  1 +
 selene-lib/Cargo.toml                         |  1 +
 selene-lib/src/lints.rs                       | 20 +++++
 selene-lib/src/lints/empty_loop.rs            |  3 +-
 selene-lib/src/lints/test_util.rs             | 64 +++++++++++++++-
 .../lints/empty_loop/empty_loop.fixed.diff    | 74 +++++++++++++++++++
 .../empty_loop/empty_loop_comments.fixed.diff | 73 ++++++++++++++++++
 7 files changed, 233 insertions(+), 3 deletions(-)
 create mode 100644 selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff
 create mode 100644 selene-lib/tests/lints/empty_loop/empty_loop_comments.fixed.diff

diff --git a/Cargo.lock b/Cargo.lock
index 0309ef6b..ab5be762 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -966,6 +966,7 @@ version = "0.25.0"
 dependencies = [
  "codespan",
  "codespan-reporting",
+ "diff",
  "full_moon",
  "id-arena",
  "if_chain",
diff --git a/selene-lib/Cargo.toml b/selene-lib/Cargo.toml
index 96f8ce6e..44c58138 100644
--- a/selene-lib/Cargo.toml
+++ b/selene-lib/Cargo.toml
@@ -12,6 +12,7 @@ edition.workspace = true
 [dependencies]
 codespan = "0.11"
 codespan-reporting = "0.11"
+diff = "0.1.13"
 full_moon.workspace = true
 id-arena = "2.2"
 if_chain = "1.0.2"
diff --git a/selene-lib/src/lints.rs b/selene-lib/src/lints.rs
index fa42553c..f09ebf9b 100644
--- a/selene-lib/src/lints.rs
+++ b/selene-lib/src/lints.rs
@@ -96,6 +96,7 @@ pub struct Diagnostic {
     pub notes: Vec<String>,
     pub primary_label: Label,
     pub secondary_labels: Vec<Label>,
+    pub fixed_code: Option<String>,
 }
 
 impl Diagnostic {
@@ -104,6 +105,7 @@ impl Diagnostic {
             code,
             message,
             primary_label,
+            fixed_code: None,
 
             notes: Vec::new(),
             secondary_labels: Vec::new(),
@@ -123,6 +125,24 @@ impl Diagnostic {
             notes,
             primary_label,
             secondary_labels,
+            fixed_code: None,
+        }
+    }
+
+    pub fn new_fix(
+        code: &'static str,
+        message: String,
+        primary_label: Label,
+        fixed_code: String,
+    ) -> Self {
+        Self {
+            code,
+            message,
+            primary_label,
+            fixed_code: Some(fixed_code),
+
+            notes: Vec::new(),
+            secondary_labels: Vec::new(),
         }
     }
 
diff --git a/selene-lib/src/lints/empty_loop.rs b/selene-lib/src/lints/empty_loop.rs
index df35d62e..c82efdac 100644
--- a/selene-lib/src/lints/empty_loop.rs
+++ b/selene-lib/src/lints/empty_loop.rs
@@ -54,10 +54,11 @@ impl Lint for EmptyLoopLint {
                 }
             })
             .map(|position| {
-                Diagnostic::new(
+                Diagnostic::new_fix(
                     "empty_loop",
                     "empty loop block".to_owned(),
                     Label::new(position),
+                    String::new(),
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index 2d044cd5..acab0a8d 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -1,4 +1,4 @@
-use super::{AstContext, Context, Lint};
+use super::{AstContext, Context, Diagnostic, Lint};
 use crate::{
     test_util::{get_standard_library, PrettyString},
     StandardLibrary,
@@ -34,6 +34,58 @@ impl Default for TestUtilConfig {
     }
 }
 
+fn replace_code_range(code: &str, start: usize, end: usize, replacement: &str) -> String {
+    if start > end || end > code.len() {
+        return code.to_string();
+    }
+
+    return format!("{}{}{}", &code[..start], replacement, &code[end..]);
+}
+
+// Assumes diagnostics is sorted by starting ranges and that there are no overlapping ranges
+fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<Diagnostic>) -> String {
+    let mut bytes_offset = 0;
+
+    let new_code = diagnostics
+        .iter()
+        .fold(code.to_string(), |code, diagnostic| {
+            if diagnostic.fixed_code.is_some() {
+                let new_code = replace_code_range(
+                    code.as_str(),
+                    (diagnostic.primary_label.range.0 as isize + bytes_offset as isize) as usize,
+                    (diagnostic.primary_label.range.1 as isize + bytes_offset as isize) as usize,
+                    &diagnostic.fixed_code.clone().unwrap().as_str(),
+                );
+
+                bytes_offset += diagnostic.fixed_code.as_ref().unwrap().len() as isize
+                    - (diagnostic.primary_label.range.1 - diagnostic.primary_label.range.0)
+                        as isize;
+
+                new_code
+            } else {
+                code
+            }
+        });
+
+    full_moon::parse(&new_code).expect("Failed to parse fixed code");
+
+    new_code
+}
+
+fn generate_diff(source1: &str, source2: &str) -> String {
+    let mut result = String::new();
+
+    for line in diff::lines(source1, source2) {
+        match line {
+            diff::Result::Left(l) => result.push_str(&format!("-{}\n", l)),
+            diff::Result::Both(l, _) => result.push_str(&format!(" {}\n", l)),
+            diff::Result::Right(r) => result.push_str(&format!("+{}\n", r)),
+        }
+    }
+
+    result
+}
+
 pub fn test_lint_config_with_output<
     C: DeserializeOwned,
     E: std::error::Error,
@@ -73,12 +125,20 @@ pub fn test_lint_config_with_output<
     );
 
     let mut files = codespan::Files::new();
-    let source_id = files.add(format!("{test_name}.lua"), lua_source);
+    let source_id = files.add(format!("{test_name}.lua"), lua_source.clone());
 
     diagnostics.sort_by_key(|diagnostic| diagnostic.primary_label.range);
 
     let mut output = termcolor::NoColor::new(Vec::new());
 
+    let fixed_lua_code = apply_diagnostics_fixes(&lua_source, &diagnostics);
+    if let Err(e) = fs::write(
+        &path_base.with_file_name(format!("{}.fixed.diff", test_name)),
+        generate_diff(lua_source.as_str(), fixed_lua_code.as_str()),
+    ) {
+        eprintln!("Failed to write to file: {}", e);
+    }
+
     for diagnostic in diagnostics
         .into_iter()
         .map(|diagnostic| diagnostic.into_codespan_diagnostic(source_id, CodespanSeverity::Error))
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..f190ae84
--- /dev/null
+++ b/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff
@@ -0,0 +1,74 @@
+ for _ = 1, 10 do
+     return "Should not warn"
+ end
+ 
+ for _ = 1, 10 do
+     print("Should not warn")
+ end
+ 
+-for _ = 1, 10 do
+-    -- Should warn
+-end
+ 
+-for _ = 1, 10 do
+-    --[[
+-    Should warn
+-    ]]
+-end
+ 
+-for _ = 1, 10 do
+ 
+ 
+-    
+-end
+ 
++
+ for _ in pairs({}) do
+     return "Should not warn"
+ end
+ 
+-for _ in pairs({}) do
+-end
+ 
++
+ for _ in ipairs({}) do
+     return "Should not warn"
+ end
+ 
+-for _ in ipairs({}) do
+-end
+ 
++
+ for _ in {} do
+     return "Should not warn"
+ end
+ 
+-for _ in {} do
+-end
+ 
++
+ for _ in a() do
+     return "Should not warn"
+ end
+ 
+-for _ in a() do
+-end
+ 
++
+ while true do
+     return "Should not warn"
+ end
+ 
+-while true do
+-end
+ 
++
+ repeat
+     return "Should not warn"
+ until true
+ 
+-repeat
+-until true
++
+ -- comment here shouldn't break anything
+ 
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..6ddbff5b
--- /dev/null
+++ b/selene-lib/tests/lints/empty_loop/empty_loop_comments.fixed.diff
@@ -0,0 +1,73 @@
+ 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
+ 
+-for _ = 1, 10 do
+ 
+ 
+-
+-end
+-
+ for _ in pairs({}) do
+     return "Should not warn"
+ end
+ 
+-for _ in pairs({}) do
+-end
+ 
++
+ for _ in ipairs({}) do
+     return "Should not warn"
+ end
+ 
+-for _ in ipairs({}) do
+-end
+ 
++
+ for _ in {} do
+     return "Should not warn"
+ end
+ 
+-for _ in {} do
+-end
+ 
++
+ for _ in a() do
+     return "Should not warn"
+ end
+ 
+-for _ in a() do
+-end
+ 
++
+ while true do
+     return "Should not warn"
+ end
+ 
+-while true do
+-end
+ 
++
+ repeat
+     return "Should not warn"
+ until true
+ 
+-repeat
+-until true
++
+ -- comment here shouldn't break anything
+ 

From d617ee649edf692269828244165fc059f206942b Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Fri, 13 Oct 2023 20:59:58 -0700
Subject: [PATCH 02/63] Test with pretty_assertions

---
 Cargo.lock                                    |  8 ++++-
 Cargo.toml                                    | 36 +++++++++----------
 selene-lib/Cargo.toml                         |  2 +-
 selene-lib/src/lints/test_util.rs             | 30 ++++++++++------
 .../lints/empty_loop/empty_loop.fixed.diff    |  1 -
 .../empty_loop/empty_loop_comments.fixed.diff |  7 ++--
 6 files changed, 48 insertions(+), 36 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ab5be762..6785f076 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -966,7 +966,6 @@ version = "0.25.0"
 dependencies = [
  "codespan",
  "codespan-reporting",
- "diff",
  "full_moon",
  "id-arena",
  "if_chain",
@@ -979,6 +978,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_yaml",
+ "similar",
  "termcolor",
  "toml",
 ]
@@ -1051,6 +1051,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 df846898..97581cf8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,18 +1,18 @@
-[workspace]
-
-members = ["selene", "selene-lib"]
-
-[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.18.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"
\ No newline at end of file
+[workspace]
+
+members = ["selene", "selene-lib"]
+
+[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.18.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/selene-lib/Cargo.toml b/selene-lib/Cargo.toml
index 44c58138..9811f638 100644
--- a/selene-lib/Cargo.toml
+++ b/selene-lib/Cargo.toml
@@ -12,7 +12,6 @@ edition.workspace = true
 [dependencies]
 codespan = "0.11"
 codespan-reporting = "0.11"
-diff = "0.1.13"
 full_moon.workspace = true
 id-arena = "2.2"
 if_chain = "1.0.2"
@@ -23,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/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index acab0a8d..e55bdd8b 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -3,6 +3,7 @@ use crate::{
     test_util::{get_standard_library, PrettyString},
     StandardLibrary,
 };
+use similar::{ChangeTag, TextDiff};
 use std::{
     fs,
     io::Write,
@@ -75,12 +76,13 @@ fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<Diagnostic>) -> String
 fn generate_diff(source1: &str, source2: &str) -> String {
     let mut result = String::new();
 
-    for line in diff::lines(source1, source2) {
-        match line {
-            diff::Result::Left(l) => result.push_str(&format!("-{}\n", l)),
-            diff::Result::Both(l, _) => result.push_str(&format!(" {}\n", l)),
-            diff::Result::Right(r) => result.push_str(&format!("+{}\n", r)),
-        }
+    for change in TextDiff::from_lines(source1, source2).iter_all_changes() {
+        let sign = match change.tag() {
+            ChangeTag::Delete => "-",
+            ChangeTag::Insert => "+",
+            ChangeTag::Equal => " ",
+        };
+        result.push_str(&format!("{}{}", sign, change.value()));
     }
 
     result
@@ -132,11 +134,17 @@ pub fn test_lint_config_with_output<
     let mut output = termcolor::NoColor::new(Vec::new());
 
     let fixed_lua_code = apply_diagnostics_fixes(&lua_source, &diagnostics);
-    if let Err(e) = fs::write(
-        &path_base.with_file_name(format!("{}.fixed.diff", test_name)),
-        generate_diff(lua_source.as_str(), fixed_lua_code.as_str()),
-    ) {
-        eprintln!("Failed to write to file: {}", e);
+    let fixed_diff = generate_diff(&lua_source, &fixed_lua_code);
+    let diff_output_path = path_base.with_extension("fixed.diff");
+
+    if let Ok(expected) = fs::read_to_string(&diff_output_path) {
+        pretty_assertions::assert_eq!(PrettyString(&expected), PrettyString(&fixed_diff));
+    } 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");
     }
 
     for diagnostic in diagnostics
diff --git a/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff b/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff
index f190ae84..0edc5d4a 100644
--- a/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff
+++ b/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff
@@ -71,4 +71,3 @@
 -until true
 +
  -- comment here shouldn't break anything
- 
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
index 6ddbff5b..498d8198 100644
--- a/selene-lib/tests/lints/empty_loop/empty_loop_comments.fixed.diff
+++ b/selene-lib/tests/lints/empty_loop/empty_loop_comments.fixed.diff
@@ -17,11 +17,11 @@
  end
  
 -for _ = 1, 10 do
- 
- 
 -
--end
 -
+ 
+-end
+ 
  for _ in pairs({}) do
      return "Should not warn"
  end
@@ -70,4 +70,3 @@
 -until true
 +
  -- comment here shouldn't break anything
- 

From 6684025e04063a128148251d81e9c83414b1f677 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Fri, 13 Oct 2023 21:07:58 -0700
Subject: [PATCH 03/63] Remove autoformatted change

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 97581cf8..f84cc876 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,4 +15,4 @@ full_moon = "0.18.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"
+profiling = "1.0.7"
\ No newline at end of file

From 3679fb0e5d7ad94ab9caecbdabb773dd1644a751 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Fri, 13 Oct 2023 21:12:56 -0700
Subject: [PATCH 04/63] Use if let

---
 selene-lib/src/lints/test_util.rs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index e55bdd8b..e921b93a 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -50,18 +50,16 @@ fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<Diagnostic>) -> String
     let new_code = diagnostics
         .iter()
         .fold(code.to_string(), |code, diagnostic| {
-            if diagnostic.fixed_code.is_some() {
+            if let Some(fixed) = &diagnostic.fixed_code {
+                let (start, end) = diagnostic.primary_label.range;
                 let new_code = replace_code_range(
                     code.as_str(),
-                    (diagnostic.primary_label.range.0 as isize + bytes_offset as isize) as usize,
-                    (diagnostic.primary_label.range.1 as isize + bytes_offset as isize) as usize,
-                    &diagnostic.fixed_code.clone().unwrap().as_str(),
+                    (start as isize + bytes_offset as isize) as usize,
+                    (end as isize + bytes_offset as isize) as usize,
+                    &fixed.as_str(),
                 );
 
-                bytes_offset += diagnostic.fixed_code.as_ref().unwrap().len() as isize
-                    - (diagnostic.primary_label.range.1 - diagnostic.primary_label.range.0)
-                        as isize;
-
+                bytes_offset += fixed.len() as isize - (end - start) as isize;
                 new_code
             } else {
                 code

From bd9f42b290b1386ad38418395503469dea35ff93 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 09:58:29 -0700
Subject: [PATCH 05/63] Fix unused variable with underscore

---
 selene-lib/src/lints.rs                       | 18 +++++++
 selene-lib/src/lints/unused_variable.rs       |  3 +-
 .../lints/unused_variable/blocks.fixed.diff   | 25 ++++++++++
 .../unused_variable/edge_cases.fixed.diff     | 10 ++++
 .../unused_variable/explicit_self.fixed.diff  |  5 ++
 .../function_overriding.fixed.diff            |  1 +
 .../generic_for_shadowing.fixed.diff          |  5 ++
 .../tests/lints/unused_variable/if.fixed.diff | 18 +++++++
 .../lints/unused_variable/ignore.fixed.diff   |  1 +
 .../lints/unused_variable/locals.fixed.diff   | 33 +++++++++++++
 .../mutating_functions.fixed.diff             |  3 ++
 .../lints/unused_variable/observes.fixed.diff | 49 +++++++++++++++++++
 .../unused_variable/overriding.fixed.diff     | 28 +++++++++++
 .../lints/unused_variable/self.fixed.diff     |  7 +++
 .../unused_variable/self_ignored.fixed.diff   |  5 ++
 .../unused_variable/shadowing.fixed.diff      | 11 +++++
 .../lints/unused_variable/types.fixed.diff    |  4 ++
 .../lints/unused_variable/varargs.fixed.diff  | 10 ++++
 .../unused_variable/write_only.fixed.diff     | 18 +++++++
 19 files changed, 253 insertions(+), 1 deletion(-)
 create mode 100644 selene-lib/tests/lints/unused_variable/blocks.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/explicit_self.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/function_overriding.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/generic_for_shadowing.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/if.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/ignore.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/locals.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/mutating_functions.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/observes.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/overriding.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/self.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/self_ignored.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/shadowing.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/types.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/varargs.fixed.diff
 create mode 100644 selene-lib/tests/lints/unused_variable/write_only.fixed.diff

diff --git a/selene-lib/src/lints.rs b/selene-lib/src/lints.rs
index f09ebf9b..fa4a1824 100644
--- a/selene-lib/src/lints.rs
+++ b/selene-lib/src/lints.rs
@@ -146,6 +146,24 @@ impl Diagnostic {
         }
     }
 
+    pub fn new_complete_fix(
+        code: &'static str,
+        message: String,
+        primary_label: Label,
+        notes: Vec<String>,
+        secondary_labels: Vec<Label>,
+        fixed_code: String,
+    ) -> Self {
+        Self {
+            code,
+            message,
+            notes,
+            primary_label,
+            secondary_labels,
+            fixed_code: Some(fixed_code),
+        }
+    }
+
     pub fn into_codespan_diagnostic(
         self,
         file_id: codespan::FileId,
diff --git a/selene-lib/src/lints/unused_variable.rs b/selene-lib/src/lints/unused_variable.rs
index c60c932d..975b936c 100644
--- a/selene-lib/src/lints/unused_variable.rs
+++ b/selene-lib/src/lints/unused_variable.rs
@@ -169,7 +169,7 @@ impl Lint for UnusedVariableLint {
 
                 let write_only = !analyzed_references.is_empty();
 
-                diagnostics.push(Diagnostic::new_complete(
+                diagnostics.push(Diagnostic::new_complete_fix(
                     "unused_variable",
                     if write_only {
                         format!("{} is assigned a value, but never used", variable.name)
@@ -188,6 +188,7 @@ impl Lint for UnusedVariableLint {
                             }
                         })
                         .collect(),
+                    format!("_{}", variable.name),
                 ));
             };
         }
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..5308ebc1
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/blocks.fixed.diff
@@ -0,0 +1,25 @@
+ -- Functions
+-local function unusedFunction()
+-    local unusedVariableA = 1
+-    local unusedVariableB = 1
++local function _unusedFunction()
++    local _unusedVariableA = 1
++    local _unusedVariableB = 1
+ end
+ 
+ print(unusedVariableB)
+-local overidden = true
++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..414306c0
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff
@@ -0,0 +1,10 @@
+ local foo = 1
+-local foo = foo + 1
+-local bar = bar
++local _foo = foo + 1
++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..437f1f7b
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/explicit_self.fixed.diff
@@ -0,0 +1,5 @@
+-local function foo(self)
++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..2c506de0
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/function_overriding.fixed.diff
@@ -0,0 +1 @@
+ function global.name() end
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..2c55b24a
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/generic_for_shadowing.fixed.diff
@@ -0,0 +1,5 @@
+ return function(foo, ...)
+     for _, foo in pairs({ foo, ... }) do
+         print(foo)
+     end
+ end
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..70f902f4
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/if.fixed.diff
@@ -0,0 +1,18 @@
+ if 1 then
+-    local localA
++    local _localA
+ elseif 2 then
+-    local localB
++    local _localB
+     print(localA)
+ elseif 3 then
+-    local localC
++    local _localC
+     print(localB)
+ else
+-    local localD
++    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..48a8d5f2
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/ignore.fixed.diff
@@ -0,0 +1 @@
+ local _ = 0
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..ea6cec85
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/locals.fixed.diff
@@ -0,0 +1,33 @@
+ -- Unused
+-local localA, localB
++local _localA, _localB
+ 
+ -- Used
+ local localC = 1
+ print(localC)
+ 
+ -- Mutated, but never read
+-local localD = 1
++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
+-local localI = { localH }
++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..80480088
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/mutating_functions.fixed.diff
@@ -0,0 +1,3 @@
+ local noSideEffects = call()
+ 
+ function noSideEffects.foo() end
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..64c364f0
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/observes.fixed.diff
@@ -0,0 +1,49 @@
+-local writtenOnlyA = {}
++local _writtenOnlyA = {}
+ table.insert(writtenOnlyA, 3)
+ 
+ local readA = {}
+ print(table.insert(readA, 3))
+ 
+ -- Make sure doing it inside other statements doesn't trigger false negatives
+ print(function()
+-	local writtenOnlyB = {}
++	local _writtenOnlyB = {}
+ 	table.insert(writtenOnlyB, 1)
+ 
+ 	local readB = {}
+ 	return table.insert(readB, 1)
+ end)
+ 
+ if true then
+-	local writtenOnlyC = {}
++	local _writtenOnlyC = {}
+ 	table.insert(writtenOnlyC, 1)
+ 
+ 	local readC = {}
+ 	print(table.insert(readC, 1))
+ end
+ 
+ local insertButReadLater = {}
+ table.insert(insertButReadLater, 1)
+ print(insertButReadLater)
+ 
+ local ambiguous = external()
+ table.insert(ambiguous, 1)
+ 
+ local rooms = {
+ 	boss = {},
+ }
+ 
+ for index, room in pairs(rooms) do
+ 	table.insert(room, 1)
+ 
+ 	local roomByIndex = rooms[index]
+ 	table.insert(roomByIndex, 2)
+ end
+ 
+ local nested = {
+ 	key = external(),
+ }
+ 
+ table.insert(nested.key, 1)
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..0c85012a
--- /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
+-local function foo()
++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..2af9eef6
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/self.fixed.diff
@@ -0,0 +1,7 @@
+ local Foo = {}
+ 
+-function Foo:A() end
++function Foo:_self() end
+ function Foo.B() end
+ 
+ return Foo
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..3d05c3f4
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/self_ignored.fixed.diff
@@ -0,0 +1,5 @@
+ local Foo = {}
+ 
+ function Foo:A() end
+ 
+ return Foo
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..32cf84b3
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/shadowing.fixed.diff
@@ -0,0 +1,11 @@
+ local x = 0
+ 
+ repeat
+     x = x + wait()
+ until x >= 5
+ 
+ local x = 0
+ 
+ repeat
+     x = x + wait()
+ until x >= 5
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..6774b006
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/types.fixed.diff
@@ -0,0 +1,4 @@
+ local types = require(script.types)
+ 
+-local value: types.something
++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..a492f9dc
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/varargs.fixed.diff
@@ -0,0 +1,10 @@
+ local function foo(...)
+     call(...)
+ end
+ 
+-local function bar(...)
++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..f0652f88
--- /dev/null
+++ b/selene-lib/tests/lints/unused_variable/write_only.fixed.diff
@@ -0,0 +1,18 @@
+-local bad1 = {}
++local _bad1 = {}
+ bad1.x = 1
+ bad1.y = 2
+ bad1["z"] = 1
+ 
+ local badButNotYetImplemented = { x = {} }
+ badButNotYetImplemented.x.y = 1
+ 
+ local okay1 = ok()
+ okay1.x = 1
+ okay1.y = 2
+ 
+ local okay2 = { x = ok() }
+ okay2.x.y = 1
+ 
+ local okay3 = {}
+ okay3.x().y = 1

From 5b31d46841060818ecd955c55b14eb36908e7619 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 10:18:58 -0700
Subject: [PATCH 06/63] Change fixed_code to option and fix self unused
 variable fix

---
 selene-lib/src/lint_filtering.rs              |  3 ++
 selene-lib/src/lints.rs                       | 41 +++----------------
 selene-lib/src/lints/almost_swapped.rs        |  1 +
 selene-lib/src/lints/bad_string_escape.rs     |  6 +++
 selene-lib/src/lints/compare_nan.rs           |  1 +
 .../src/lints/constant_table_comparison.rs    |  1 +
 selene-lib/src/lints/deprecated.rs            |  1 +
 selene-lib/src/lints/divide_by_zero.rs        |  1 +
 selene-lib/src/lints/duplicate_keys.rs        |  1 +
 selene-lib/src/lints/empty_if.rs              |  1 +
 selene-lib/src/lints/empty_loop.rs            |  4 +-
 selene-lib/src/lints/global_usage.rs          |  1 +
 .../src/lints/high_cyclomatic_complexity.rs   |  1 +
 selene-lib/src/lints/if_same_then_else.rs     |  1 +
 selene-lib/src/lints/ifs_same_cond.rs         |  1 +
 selene-lib/src/lints/manual_table_clone.rs    |  1 +
 selene-lib/src/lints/mismatched_arg_count.rs  |  1 +
 selene-lib/src/lints/mixed_table.rs           |  1 +
 selene-lib/src/lints/multiple_statements.rs   |  1 +
 selene-lib/src/lints/must_use.rs              |  1 +
 selene-lib/src/lints/parenthese_conditions.rs |  1 +
 .../roblox_incorrect_color3_new_bounds.rs     |  1 +
 .../src/lints/roblox_incorrect_roact_usage.rs |  4 ++
 .../src/lints/roblox_suspicious_udim2_new.rs  |  3 +-
 selene-lib/src/lints/shadowing.rs             |  1 +
 selene-lib/src/lints/standard_library.rs      |  8 ++++
 .../src/lints/suspicious_reverse_loop.rs      |  1 +
 .../src/lints/type_check_inside_call.rs       |  1 +
 .../src/lints/unbalanced_assignments.rs       |  2 +
 selene-lib/src/lints/undefined_variable.rs    |  1 +
 selene-lib/src/lints/unscoped_variables.rs    |  1 +
 selene-lib/src/lints/unused_variable.rs       | 12 ++++--
 .../lints/unused_variable/self.fixed.diff     |  2 +-
 .../tests/lints/unused_variable/self.stderr   |  4 +-
 34 files changed, 68 insertions(+), 44 deletions(-)

diff --git a/selene-lib/src/lint_filtering.rs b/selene-lib/src/lint_filtering.rs
index 447437fa..57ae87b7 100644
--- a/selene-lib/src/lint_filtering.rs
+++ b/selene-lib/src/lint_filtering.rs
@@ -149,6 +149,7 @@ impl NodeVisitor for FilterVisitor {
                                     trivia_start_position.bytes(),
                                     trivia_end_position.bytes(),
                                 )),
+                                None,
                             ))
                         }
                     }));
@@ -223,6 +224,7 @@ pub fn filter_diagnostics(
                                 (first_code.0.bytes(), first_code.1.bytes()),
                                 "global filter must be before this".to_owned(),
                             )],
+                            None,
                         ));
 
                         continue;
@@ -244,6 +246,7 @@ pub fn filter_diagnostics(
                                     possibly_conflicting.comment_range,
                                     "conflicts with this".to_owned(),
                                 )],
+                                None,
                             ));
                         }
                     }
diff --git a/selene-lib/src/lints.rs b/selene-lib/src/lints.rs
index fa4a1824..5dcf0735 100644
--- a/selene-lib/src/lints.rs
+++ b/selene-lib/src/lints.rs
@@ -100,59 +100,30 @@ pub struct Diagnostic {
 }
 
 impl Diagnostic {
-    pub fn new(code: &'static str, message: String, primary_label: Label) -> Self {
-        Self {
-            code,
-            message,
-            primary_label,
-            fixed_code: None,
-
-            notes: Vec::new(),
-            secondary_labels: Vec::new(),
-        }
-    }
-
-    pub fn new_complete(
+    pub fn new(
         code: &'static str,
         message: String,
         primary_label: Label,
-        notes: Vec<String>,
-        secondary_labels: Vec<Label>,
+        fixed_code: Option<String>,
     ) -> Self {
         Self {
             code,
             message,
-            notes,
             primary_label,
-            secondary_labels,
-            fixed_code: None,
-        }
-    }
-
-    pub fn new_fix(
-        code: &'static str,
-        message: String,
-        primary_label: Label,
-        fixed_code: String,
-    ) -> Self {
-        Self {
-            code,
-            message,
-            primary_label,
-            fixed_code: Some(fixed_code),
+            fixed_code,
 
             notes: Vec::new(),
             secondary_labels: Vec::new(),
         }
     }
 
-    pub fn new_complete_fix(
+    pub fn new_complete(
         code: &'static str,
         message: String,
         primary_label: Label,
         notes: Vec<String>,
         secondary_labels: Vec<Label>,
-        fixed_code: String,
+        fixed_code: Option<String>,
     ) -> Self {
         Self {
             code,
@@ -160,7 +131,7 @@ impl Diagnostic {
             notes,
             primary_label,
             secondary_labels,
-            fixed_code: Some(fixed_code),
+            fixed_code,
         }
     }
 
diff --git a/selene-lib/src/lints/almost_swapped.rs b/selene-lib/src/lints/almost_swapped.rs
index b0cdfff4..3376d9b4 100644
--- a/selene-lib/src/lints/almost_swapped.rs
+++ b/selene-lib/src/lints/almost_swapped.rs
@@ -45,6 +45,7 @@ impl Lint for AlmostSwappedLint {
                         name2 = almost_swap.names.1,
                     )],
                     Vec::new(),
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/bad_string_escape.rs b/selene-lib/src/lints/bad_string_escape.rs
index a6f631ec..001f5c7e 100644
--- a/selene-lib/src/lints/bad_string_escape.rs
+++ b/selene-lib/src/lints/bad_string_escape.rs
@@ -50,11 +50,13 @@ impl Lint for BadStringEscapeLint {
                     "bad_string_escape",
                     "string escape sequence doesn't exist".to_owned(),
                     Label::new(sequence.range.to_owned()),
+                    None,
                 ),
                 ReasonWhy::Malformed => Diagnostic::new(
                     "bad_string_escape",
                     "string escape sequence is malformed".to_owned(),
                     Label::new(sequence.range.to_owned()),
+                    None,
                 ),
                 ReasonWhy::DecimalTooHigh => Diagnostic::new_complete(
                     "bad_string_escape",
@@ -65,6 +67,7 @@ impl Lint for BadStringEscapeLint {
                             .to_owned(),
                     ],
                     Vec::new(),
+                    None,
                 ),
                 ReasonWhy::CodepointTooHigh => Diagnostic::new_complete(
                     "bad_string_escape",
@@ -75,18 +78,21 @@ impl Lint for BadStringEscapeLint {
                             .to_owned(),
                     ],
                     Vec::new(),
+                    None,
                 ),
                 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()),
+                    None,
                 ),
                 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()),
+                    None,
                 ),
             })
             .collect()
diff --git a/selene-lib/src/lints/compare_nan.rs b/selene-lib/src/lints/compare_nan.rs
index a7173074..64b5d9b1 100644
--- a/selene-lib/src/lints/compare_nan.rs
+++ b/selene-lib/src/lints/compare_nan.rs
@@ -40,6 +40,7 @@ impl Lint for CompareNanLint {
                         operator = comparisons.operator,
                     )],
                     Vec::new(),
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/constant_table_comparison.rs b/selene-lib/src/lints/constant_table_comparison.rs
index 73f690c1..112e9f5c 100644
--- a/selene-lib/src/lints/constant_table_comparison.rs
+++ b/selene-lib/src/lints/constant_table_comparison.rs
@@ -59,6 +59,7 @@ impl Lint for ConstantTableComparisonLint {
                         Vec::new()
                     },
                     Vec::new(),
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/deprecated.rs b/selene-lib/src/lints/deprecated.rs
index 46644444..e26aeca8 100644
--- a/selene-lib/src/lints/deprecated.rs
+++ b/selene-lib/src/lints/deprecated.rs
@@ -128,6 +128,7 @@ impl<'a> DeprecatedVisitor<'a> {
                 Label::from_node(node, None),
                 notes,
                 Vec::new(),
+                None,
             ));
         }
     }
diff --git a/selene-lib/src/lints/divide_by_zero.rs b/selene-lib/src/lints/divide_by_zero.rs
index a7191a3f..50ce7c4a 100644
--- a/selene-lib/src/lints/divide_by_zero.rs
+++ b/selene-lib/src/lints/divide_by_zero.rs
@@ -35,6 +35,7 @@ impl Lint for DivideByZeroLint {
                     "divide_by_zero",
                     "dividing by zero is not allowed, use math.huge instead".to_owned(),
                     Label::new(*position),
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/duplicate_keys.rs b/selene-lib/src/lints/duplicate_keys.rs
index a519b82d..5d161f81 100644
--- a/selene-lib/src/lints/duplicate_keys.rs
+++ b/selene-lib/src/lints/duplicate_keys.rs
@@ -42,6 +42,7 @@ impl Lint for DuplicateKeysLint {
                         duplicate.original_declaration,
                         format!("`{}` originally declared here", duplicate.name),
                     )],
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/empty_if.rs b/selene-lib/src/lints/empty_if.rs
index 581f134f..2f06add8 100644
--- a/selene-lib/src/lints/empty_if.rs
+++ b/selene-lib/src/lints/empty_if.rs
@@ -63,6 +63,7 @@ impl Lint for EmptyIfLint {
                     }
                     .to_owned(),
                     Label::new(position.0),
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/empty_loop.rs b/selene-lib/src/lints/empty_loop.rs
index c82efdac..45aff668 100644
--- a/selene-lib/src/lints/empty_loop.rs
+++ b/selene-lib/src/lints/empty_loop.rs
@@ -54,11 +54,11 @@ impl Lint for EmptyLoopLint {
                 }
             })
             .map(|position| {
-                Diagnostic::new_fix(
+                Diagnostic::new(
                     "empty_loop",
                     "empty loop block".to_owned(),
                     Label::new(position),
-                    String::new(),
+                    Some(String::new()),
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/global_usage.rs b/selene-lib/src/lints/global_usage.rs
index ee170c2b..f35984cd 100644
--- a/selene-lib/src/lints/global_usage.rs
+++ b/selene-lib/src/lints/global_usage.rs
@@ -76,6 +76,7 @@ impl Lint for GlobalLint {
                         reference.name
                     ),
                     Label::new(reference.identifier),
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/high_cyclomatic_complexity.rs b/selene-lib/src/lints/high_cyclomatic_complexity.rs
index d3dd36d7..0dfa1a21 100644
--- a/selene-lib/src/lints/high_cyclomatic_complexity.rs
+++ b/selene-lib/src/lints/high_cyclomatic_complexity.rs
@@ -58,6 +58,7 @@ impl Lint for HighCyclomaticComplexityLint {
                         self.config.maximum_complexity
                     ),
                     Label::new(position),
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/if_same_then_else.rs b/selene-lib/src/lints/if_same_then_else.rs
index 502e1bbf..32fb3305 100644
--- a/selene-lib/src/lints/if_same_then_else.rs
+++ b/selene-lib/src/lints/if_same_then_else.rs
@@ -41,6 +41,7 @@ impl Lint for IfSameThenElseLint {
                         position.1,
                         "note: same as this".to_owned(),
                     )],
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/ifs_same_cond.rs b/selene-lib/src/lints/ifs_same_cond.rs
index 2e02080a..96aafc0d 100644
--- a/selene-lib/src/lints/ifs_same_cond.rs
+++ b/selene-lib/src/lints/ifs_same_cond.rs
@@ -41,6 +41,7 @@ impl Lint for IfsSameCondLint {
                         position.1,
                         "note: same as this".to_owned(),
                     )],
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/manual_table_clone.rs b/selene-lib/src/lints/manual_table_clone.rs
index 73b0b198..2af4dbba 100644
--- a/selene-lib/src/lints/manual_table_clone.rs
+++ b/selene-lib/src/lints/manual_table_clone.rs
@@ -84,6 +84,7 @@ impl ManualTableCloneMatch {
             } else {
                 Vec::new()
             },
+            None,
         )
     }
 }
diff --git a/selene-lib/src/lints/mismatched_arg_count.rs b/selene-lib/src/lints/mismatched_arg_count.rs
index 4bb96002..2efdc13d 100644
--- a/selene-lib/src/lints/mismatched_arg_count.rs
+++ b/selene-lib/src/lints/mismatched_arg_count.rs
@@ -72,6 +72,7 @@ impl Lint for MismatchedArgCountLint {
                             )
                         })
                         .collect(),
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/mixed_table.rs b/selene-lib/src/lints/mixed_table.rs
index 4a588abf..2ce691cb 100644
--- a/selene-lib/src/lints/mixed_table.rs
+++ b/selene-lib/src/lints/mixed_table.rs
@@ -34,6 +34,7 @@ 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,
             ));
         }
 
diff --git a/selene-lib/src/lints/multiple_statements.rs b/selene-lib/src/lints/multiple_statements.rs
index e137b553..8d319b67 100644
--- a/selene-lib/src/lints/multiple_statements.rs
+++ b/selene-lib/src/lints/multiple_statements.rs
@@ -53,6 +53,7 @@ impl Lint for MultipleStatementsLint {
                     "multiple_statements",
                     "only one statement per line is allowed".to_owned(),
                     Label::new(*position),
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/must_use.rs b/selene-lib/src/lints/must_use.rs
index 3ab9d04f..01c1bff0 100644
--- a/selene-lib/src/lints/must_use.rs
+++ b/selene-lib/src/lints/must_use.rs
@@ -48,6 +48,7 @@ impl Lint for MustUseLint {
                     function_call_stmt.call_name_path.join(".")
                 ),
                 Label::new(function_call_stmt.call_prefix_range),
+                None,
             ));
         }
 
diff --git a/selene-lib/src/lints/parenthese_conditions.rs b/selene-lib/src/lints/parenthese_conditions.rs
index 6beeb0c7..c8f2711c 100644
--- a/selene-lib/src/lints/parenthese_conditions.rs
+++ b/selene-lib/src/lints/parenthese_conditions.rs
@@ -35,6 +35,7 @@ impl Lint for ParentheseConditionsLint {
                     "parenthese_conditions",
                     "lua does not require parentheses around conditions".to_owned(),
                     Label::new(*position),
+                    None,
                 )
             })
             .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..de4e02d7 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,7 @@ impl Lint for Color3BoundsLint {
                     Label::new(*position),
                     vec!["help: did you mean to use Color3.fromRGB instead?".to_owned()],
                     Vec::new(),
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/roblox_incorrect_roact_usage.rs b/selene-lib/src/lints/roblox_incorrect_roact_usage.rs
index 1d2adfc2..a4118fbc 100644
--- a/selene-lib/src/lints/roblox_incorrect_roact_usage.rs
+++ b/selene-lib/src/lints/roblox_incorrect_roact_usage.rs
@@ -93,6 +93,7 @@ impl Lint for IncorrectRoactUsageLint {
                     invalid_event.event_name, invalid_event.class_name
                 ),
                 Label::new(invalid_event.range),
+                None,
             ));
         }
 
@@ -112,6 +113,7 @@ impl Lint for IncorrectRoactUsageLint {
                             invalid_property.create_element_expression,
                         )],
                         Vec::new(),
+                        None,
                     ));
                 }
                 _ => {
@@ -122,6 +124,7 @@ impl Lint for IncorrectRoactUsageLint {
                             invalid_property.property_name, invalid_property.class_name
                         ),
                         Label::new(invalid_property.range),
+                        None,
                     ));
                 }
             }
@@ -132,6 +135,7 @@ impl Lint for IncorrectRoactUsageLint {
                 "roblox_incorrect_roact_usage",
                 format!("`{}` is not a valid class", unknown_class.name),
                 Label::new(unknown_class.range),
+                None,
             ));
         }
 
diff --git a/selene-lib/src/lints/roblox_suspicious_udim2_new.rs b/selene-lib/src/lints/roblox_suspicious_udim2_new.rs
index 66a06479..3ed4d865 100644
--- a/selene-lib/src/lints/roblox_suspicious_udim2_new.rs
+++ b/selene-lib/src/lints/roblox_suspicious_udim2_new.rs
@@ -34,9 +34,10 @@ fn create_diagnostic(mismatch: &MismatchedArgCount) -> Diagnostic {
             }
             .to_owned()],
             Vec::new(),
+            None,
         )
     } else {
-        Diagnostic::new(code, message, primary_label)
+        Diagnostic::new(code, message, primary_label, None)
     }
 }
 
diff --git a/selene-lib/src/lints/shadowing.rs b/selene-lib/src/lints/shadowing.rs
index 6bbf8358..06fd7add 100644
--- a/selene-lib/src/lints/shadowing.rs
+++ b/selene-lib/src/lints/shadowing.rs
@@ -69,6 +69,7 @@ impl Lint for ShadowingLint {
                         shadow.first_defined,
                         "previously defined here".to_owned(),
                     )],
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/standard_library.rs b/selene-lib/src/lints/standard_library.rs
index f5e0aa99..539b42eb 100644
--- a/selene-lib/src/lints/standard_library.rs
+++ b/selene-lib/src/lints/standard_library.rs
@@ -252,6 +252,7 @@ impl StandardLibraryVisitor<'_> {
                     self.user_set_standard_library,
                 ),
                 Vec::new(),
+                None,
             ));
         }
     }
@@ -310,6 +311,7 @@ impl Visitor for StandardLibraryVisitor<'_> {
                                     Label::new((range.0.bytes(), range.1.bytes())),
                                     Vec::new(),
                                     Vec::new(),
+                                    None,
                                 ));
                             }
 
@@ -347,6 +349,7 @@ impl Visitor for StandardLibraryVisitor<'_> {
                             Label::new((range.0.bytes(), range.1.bytes())),
                             Vec::new(),
                             Vec::new(),
+                            None,
                         ));
                     }
                 }
@@ -427,6 +430,7 @@ impl Visitor for StandardLibraryVisitor<'_> {
                         name_path.join("."),
                     ),
                     Label::from_node(call, None),
+                    None,
                 ));
 
                 return;
@@ -472,6 +476,7 @@ impl Visitor for StandardLibraryVisitor<'_> {
                     name
                 )],
                 Vec::new(),
+                None,
             ));
 
             return;
@@ -552,6 +557,7 @@ impl Visitor for StandardLibraryVisitor<'_> {
                             Label::from_node(call, None),
                             message.iter().cloned().collect(),
                             Vec::new(),
+                            None,
                         ));
                     }
 
@@ -589,6 +595,7 @@ impl Visitor for StandardLibraryVisitor<'_> {
                 Label::from_node(call, None),
                 required_param_message,
                 Vec::new(),
+                None,
             ));
         }
 
@@ -623,6 +630,7 @@ impl Visitor for StandardLibraryVisitor<'_> {
                                 passed_type.type_name()
                             ),
                         ),
+                        None,
                     ));
                 }
             }
diff --git a/selene-lib/src/lints/suspicious_reverse_loop.rs b/selene-lib/src/lints/suspicious_reverse_loop.rs
index 473590ca..dddaf990 100644
--- a/selene-lib/src/lints/suspicious_reverse_loop.rs
+++ b/selene-lib/src/lints/suspicious_reverse_loop.rs
@@ -37,6 +37,7 @@ impl Lint for SuspiciousReverseLoopLint {
                     Label::new(*position),
                     vec!["help: try adding `, -1` after `1`".to_owned()],
                     Vec::new(),
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/type_check_inside_call.rs b/selene-lib/src/lints/type_check_inside_call.rs
index 148232bf..f9b5cba3 100644
--- a/selene-lib/src/lints/type_check_inside_call.rs
+++ b/selene-lib/src/lints/type_check_inside_call.rs
@@ -38,6 +38,7 @@ impl Lint for TypeCheckInsideCallLint {
                     Label::new(*position),
                     vec!["note: this will always return `boolean`".to_owned()],
                     Vec::new(),
+                    None,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/unbalanced_assignments.rs b/selene-lib/src/lints/unbalanced_assignments.rs
index 7ebdedf1..15d42389 100644
--- a/selene-lib/src/lints/unbalanced_assignments.rs
+++ b/selene-lib/src/lints/unbalanced_assignments.rs
@@ -37,6 +37,7 @@ impl Lint for UnbalancedAssignmentsLint {
                         "unbalanced_assignments",
                         "too many values on the right side of the assignment".to_owned(),
                         Label::new(assignment.range),
+                        None,
                     )
                 } else {
                     let secondary_labels = match assignment.first_call {
@@ -56,6 +57,7 @@ impl Lint for UnbalancedAssignmentsLint {
                         Label::new(assignment.range),
                         Vec::new(),
                         secondary_labels,
+                        None,
                     )
                 }
             })
diff --git a/selene-lib/src/lints/undefined_variable.rs b/selene-lib/src/lints/undefined_variable.rs
index b96027a5..ec42467f 100644
--- a/selene-lib/src/lints/undefined_variable.rs
+++ b/selene-lib/src/lints/undefined_variable.rs
@@ -48,6 +48,7 @@ impl Lint for UndefinedVariableLint {
                         &context.user_set_standard_library,
                     ),
                     Vec::new(),
+                    None,
                 ));
             }
         }
diff --git a/selene-lib/src/lints/unscoped_variables.rs b/selene-lib/src/lints/unscoped_variables.rs
index db6f3d1f..5c8f4bae 100644
--- a/selene-lib/src/lints/unscoped_variables.rs
+++ b/selene-lib/src/lints/unscoped_variables.rs
@@ -60,6 +60,7 @@ impl Lint for UnscopedVariablesLint {
                         reference.name
                     ),
                     Label::new(reference.identifier),
+                    None,
                 ));
             }
         }
diff --git a/selene-lib/src/lints/unused_variable.rs b/selene-lib/src/lints/unused_variable.rs
index 975b936c..b9191b46 100644
--- a/selene-lib/src/lints/unused_variable.rs
+++ b/selene-lib/src/lints/unused_variable.rs
@@ -157,6 +157,9 @@ impl Lint for UnusedVariableLint {
             {
                 let mut notes = Vec::new();
 
+                let mut variable_range = variable.identifiers[0];
+                let mut fixed_code = format!("_{}", variable.name);
+
                 if variable.is_self {
                     if self.allow_unused_self {
                         continue;
@@ -165,18 +168,21 @@ 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());
+
+                    variable_range = (variable_range.0 - 1, variable_range.0);
+                    fixed_code = ".".to_string();
                 }
 
                 let write_only = !analyzed_references.is_empty();
 
-                diagnostics.push(Diagnostic::new_complete_fix(
+                diagnostics.push(Diagnostic::new_complete(
                     "unused_variable",
                     if write_only {
                         format!("{} is assigned a value, but never used", variable.name)
                     } else {
                         format!("{} is defined, but never used", variable.name)
                     },
-                    Label::new(variable.identifiers[0]),
+                    Label::new(variable_range),
                     notes,
                     analyzed_references
                         .into_iter()
@@ -188,7 +194,7 @@ impl Lint for UnusedVariableLint {
                             }
                         })
                         .collect(),
-                    format!("_{}", variable.name),
+                    Some(fixed_code),
                 ));
             };
         }
diff --git a/selene-lib/tests/lints/unused_variable/self.fixed.diff b/selene-lib/tests/lints/unused_variable/self.fixed.diff
index 2af9eef6..034e4abe 100644
--- a/selene-lib/tests/lints/unused_variable/self.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/self.fixed.diff
@@ -1,7 +1,7 @@
  local Foo = {}
  
 -function Foo:A() end
-+function Foo:_self() end
++function Foo.A() end
  function Foo.B() 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..7d8d3207 100644
--- a/selene-lib/tests/lints/unused_variable/self.stderr
+++ b/selene-lib/tests/lints/unused_variable/self.stderr
@@ -1,8 +1,8 @@
 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 `:`

From 5451778d518dc216df034a50aa14eb0bbf5cb0b8 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 10:47:27 -0700
Subject: [PATCH 07/63] Fix unused_variable self cases where there is a
 whitespace

---
 selene-lib/src/lints/unused_variable.rs       | 28 ++++++++++++++++---
 .../lints/unused_variable/self.fixed.diff     |  4 ++-
 .../tests/lints/unused_variable/self.lua      |  3 +-
 .../tests/lints/unused_variable/self.stderr   |  9 ++++++
 4 files changed, 38 insertions(+), 6 deletions(-)

diff --git a/selene-lib/src/lints/unused_variable.rs b/selene-lib/src/lints/unused_variable.rs
index b9191b46..efd9f159 100644
--- a/selene-lib/src/lints/unused_variable.rs
+++ b/selene-lib/src/lints/unused_variable.rs
@@ -1,11 +1,15 @@
 use crate::{
-    ast_util::scopes::AssignedValue,
+    ast_util::{range, scopes::AssignedValue},
     standard_library::{Field, FieldKind, Observes},
 };
 
 use super::*;
 
-use full_moon::ast::Ast;
+use full_moon::{
+    ast::Ast,
+    node::Node,
+    tokenizer::{Symbol, TokenType},
+};
 use regex::Regex;
 use serde::Deserialize;
 
@@ -51,7 +55,7 @@ impl Lint for UnusedVariableLint {
         })
     }
 
-    fn pass(&self, _: &Ast, context: &Context, ast_context: &AstContext) -> Vec<Diagnostic> {
+    fn pass(&self, ast: &Ast, context: &Context, ast_context: &AstContext) -> Vec<Diagnostic> {
         let mut diagnostics = Vec::new();
 
         for (_, variable) in ast_context
@@ -169,7 +173,23 @@ impl Lint for UnusedVariableLint {
                     notes
                         .push("if you don't need it, consider using `.` instead of `:`".to_owned());
 
-                    variable_range = (variable_range.0 - 1, variable_range.0);
+                    // This is a very hacky and fragile way to get the colon in the function call. Can we do better?
+                    // We can't just use variable start - 1 due to cases like `function a: b() end`
+                    let mut last_colon_start = 0;
+                    for token in ast.tokens() {
+                        let start_position: usize = range(token).0;
+                        if start_position >= variable_range.0 {
+                            break;
+                        }
+
+                        if let TokenType::Symbol { symbol } = token.token().token_type() {
+                            if *symbol == Symbol::Colon {
+                                last_colon_start = range(token).0;
+                            }
+                        }
+                    }
+
+                    variable_range = (last_colon_start, last_colon_start + 1);
                     fixed_code = ".".to_string();
                 }
 
diff --git a/selene-lib/tests/lints/unused_variable/self.fixed.diff b/selene-lib/tests/lints/unused_variable/self.fixed.diff
index 034e4abe..9b348fb6 100644
--- a/selene-lib/tests/lints/unused_variable/self.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/self.fixed.diff
@@ -1,7 +1,9 @@
  local Foo = {}
  
 -function Foo:A() end
+-function Foo   :   B() end
 +function Foo.A() end
- function Foo.B() end
++function Foo   .   B() end
+ 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..ccc45f5c 100644
--- a/selene-lib/tests/lints/unused_variable/self.lua
+++ b/selene-lib/tests/lints/unused_variable/self.lua
@@ -1,6 +1,7 @@
 local Foo = {}
 
 function Foo:A() end
-function Foo.B() 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 7d8d3207..6b67596f 100644
--- a/selene-lib/tests/lints/unused_variable/self.stderr
+++ b/selene-lib/tests/lints/unused_variable/self.stderr
@@ -7,3 +7,12 @@ error[unused_variable]: self is defined, but never used
   = `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:4:16
+  │
+4 │ function Foo   :   B() end
+  │                ^
+  │
+  = `self` is implicitly defined when defining a method
+  = if you don't need it, consider using `.` instead of `:`
+

From cf88f73048537d05808c5bbced40f8e412530308 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 10:58:34 -0700
Subject: [PATCH 08/63] Skip fix with unused self in method call

---
 selene-lib/src/lints/unused_variable.rs       | 37 ++++---------------
 .../lints/unused_variable/self.fixed.diff     |  7 +---
 .../tests/lints/unused_variable/self.lua      |  3 +-
 .../tests/lints/unused_variable/self.stderr   | 13 +------
 4 files changed, 13 insertions(+), 47 deletions(-)

diff --git a/selene-lib/src/lints/unused_variable.rs b/selene-lib/src/lints/unused_variable.rs
index efd9f159..71a0e613 100644
--- a/selene-lib/src/lints/unused_variable.rs
+++ b/selene-lib/src/lints/unused_variable.rs
@@ -1,15 +1,11 @@
 use crate::{
-    ast_util::{range, scopes::AssignedValue},
+    ast_util::scopes::AssignedValue,
     standard_library::{Field, FieldKind, Observes},
 };
 
 use super::*;
 
-use full_moon::{
-    ast::Ast,
-    node::Node,
-    tokenizer::{Symbol, TokenType},
-};
+use full_moon::ast::Ast;
 use regex::Regex;
 use serde::Deserialize;
 
@@ -55,7 +51,7 @@ impl Lint for UnusedVariableLint {
         })
     }
 
-    fn pass(&self, ast: &Ast, context: &Context, ast_context: &AstContext) -> Vec<Diagnostic> {
+    fn pass(&self, _: &Ast, context: &Context, ast_context: &AstContext) -> Vec<Diagnostic> {
         let mut diagnostics = Vec::new();
 
         for (_, variable) in ast_context
@@ -161,8 +157,7 @@ impl Lint for UnusedVariableLint {
             {
                 let mut notes = Vec::new();
 
-                let mut variable_range = variable.identifiers[0];
-                let mut fixed_code = format!("_{}", variable.name);
+                let mut fixed_code = Some(format!("_{}", variable.name));
 
                 if variable.is_self {
                     if self.allow_unused_self {
@@ -173,24 +168,8 @@ impl Lint for UnusedVariableLint {
                     notes
                         .push("if you don't need it, consider using `.` instead of `:`".to_owned());
 
-                    // This is a very hacky and fragile way to get the colon in the function call. Can we do better?
-                    // We can't just use variable start - 1 due to cases like `function a: b() end`
-                    let mut last_colon_start = 0;
-                    for token in ast.tokens() {
-                        let start_position: usize = range(token).0;
-                        if start_position >= variable_range.0 {
-                            break;
-                        }
-
-                        if let TokenType::Symbol { symbol } = token.token().token_type() {
-                            if *symbol == Symbol::Colon {
-                                last_colon_start = range(token).0;
-                            }
-                        }
-                    }
-
-                    variable_range = (last_colon_start, last_colon_start + 1);
-                    fixed_code = ".".to_string();
+                    // Applying fix by changing `:` to `.` would break any existing methods calls
+                    fixed_code = None;
                 }
 
                 let write_only = !analyzed_references.is_empty();
@@ -202,7 +181,7 @@ impl Lint for UnusedVariableLint {
                     } else {
                         format!("{} is defined, but never used", variable.name)
                     },
-                    Label::new(variable_range),
+                    Label::new(variable.identifiers[0]),
                     notes,
                     analyzed_references
                         .into_iter()
@@ -214,7 +193,7 @@ impl Lint for UnusedVariableLint {
                             }
                         })
                         .collect(),
-                    Some(fixed_code),
+                    fixed_code,
                 ));
             };
         }
diff --git a/selene-lib/tests/lints/unused_variable/self.fixed.diff b/selene-lib/tests/lints/unused_variable/self.fixed.diff
index 9b348fb6..924d1a20 100644
--- a/selene-lib/tests/lints/unused_variable/self.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/self.fixed.diff
@@ -1,9 +1,6 @@
  local Foo = {}
  
--function Foo:A() end
--function Foo   :   B() end
-+function Foo.A() end
-+function Foo   .   B() end
- function Foo.C() end
+ function Foo:A() end
+ function Foo.B() end
  
  return Foo
diff --git a/selene-lib/tests/lints/unused_variable/self.lua b/selene-lib/tests/lints/unused_variable/self.lua
index ccc45f5c..15a3ca8a 100644
--- a/selene-lib/tests/lints/unused_variable/self.lua
+++ b/selene-lib/tests/lints/unused_variable/self.lua
@@ -1,7 +1,6 @@
 local Foo = {}
 
 function Foo:A() end
-function Foo   :   B() end
-function Foo.C() end
+function Foo.B() end
 
 return Foo
diff --git a/selene-lib/tests/lints/unused_variable/self.stderr b/selene-lib/tests/lints/unused_variable/self.stderr
index 6b67596f..7f7eda99 100644
--- a/selene-lib/tests/lints/unused_variable/self.stderr
+++ b/selene-lib/tests/lints/unused_variable/self.stderr
@@ -1,17 +1,8 @@
 error[unused_variable]: self is defined, but never used
-  ┌─ self.lua:3:13
+  ┌─ self.lua:3:14
   │
 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:4:16
-  │
-4 │ function Foo   :   B() end
-  │                ^
+  │              ^
   │
   = `self` is implicitly defined when defining a method
   = if you don't need it, consider using `.` instead of `:`

From 71614585f5a36e0a8f196db10cce610b9ab2da23 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 11:21:58 -0700
Subject: [PATCH 09/63] Skip fixing unused variable when they have references

---
 selene-lib/src/lints/unused_variable.rs                  | 7 +++++++
 selene-lib/tests/lints/unused_variable/blocks.fixed.diff | 9 +++------
 .../tests/lints/unused_variable/edge_cases.fixed.diff    | 6 ++----
 selene-lib/tests/lints/unused_variable/locals.fixed.diff | 6 ++----
 .../tests/lints/unused_variable/observes.fixed.diff      | 9 +++------
 .../tests/lints/unused_variable/write_only.fixed.diff    | 3 +--
 6 files changed, 18 insertions(+), 22 deletions(-)

diff --git a/selene-lib/src/lints/unused_variable.rs b/selene-lib/src/lints/unused_variable.rs
index 71a0e613..2f5da454 100644
--- a/selene-lib/src/lints/unused_variable.rs
+++ b/selene-lib/src/lints/unused_variable.rs
@@ -172,6 +172,13 @@ impl Lint for UnusedVariableLint {
                     fixed_code = None;
                 }
 
+                // Applying fix would cause references to reference the old variable. It's possible to also rename those
+                // references as well, but we'd need to check each of their scopes for potentially colliding variables.
+                // Cargo just doesn't apply a fix in these cases.
+                if !variable.references.is_empty() {
+                    fixed_code = None;
+                }
+
                 let write_only = !analyzed_references.is_empty();
 
                 diagnostics.push(Diagnostic::new_complete(
diff --git a/selene-lib/tests/lints/unused_variable/blocks.fixed.diff b/selene-lib/tests/lints/unused_variable/blocks.fixed.diff
index 5308ebc1..402db837 100644
--- a/selene-lib/tests/lints/unused_variable/blocks.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/blocks.fixed.diff
@@ -1,15 +1,12 @@
  -- Functions
 -local function unusedFunction()
--    local unusedVariableA = 1
--    local unusedVariableB = 1
 +local function _unusedFunction()
-+    local _unusedVariableA = 1
-+    local _unusedVariableB = 1
+     local unusedVariableA = 1
+     local unusedVariableB = 1
  end
  
  print(unusedVariableB)
--local overidden = true
-+local _overidden = true
+ local overidden = true
  
  local function overridesIt()
      local overidden = false
diff --git a/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff b/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff
index 414306c0..8565d0c6 100644
--- a/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff
@@ -1,8 +1,6 @@
  local foo = 1
--local foo = foo + 1
--local bar = bar
-+local _foo = foo + 1
-+local _bar = bar
+ local foo = foo + 1
+ local bar = bar
  
  -- The variables inside of a repeat...until are accessible from the until statement
  repeat
diff --git a/selene-lib/tests/lints/unused_variable/locals.fixed.diff b/selene-lib/tests/lints/unused_variable/locals.fixed.diff
index ea6cec85..6bcc77e7 100644
--- a/selene-lib/tests/lints/unused_variable/locals.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/locals.fixed.diff
@@ -7,8 +7,7 @@
  print(localC)
  
  -- Mutated, but never read
--local localD = 1
-+local _localD = 1
+ local localD = 1
  localD = 2
  localD = 3
  
@@ -29,5 +28,4 @@
  
  -- Put into a table
  local localH = 1
--local localI = { localH }
-+local _localI = { localH }
+ local localI = { localH }
diff --git a/selene-lib/tests/lints/unused_variable/observes.fixed.diff b/selene-lib/tests/lints/unused_variable/observes.fixed.diff
index 64c364f0..e62cc6fa 100644
--- a/selene-lib/tests/lints/unused_variable/observes.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/observes.fixed.diff
@@ -1,5 +1,4 @@
--local writtenOnlyA = {}
-+local _writtenOnlyA = {}
+ local writtenOnlyA = {}
  table.insert(writtenOnlyA, 3)
  
  local readA = {}
@@ -7,8 +6,7 @@
  
  -- Make sure doing it inside other statements doesn't trigger false negatives
  print(function()
--	local writtenOnlyB = {}
-+	local _writtenOnlyB = {}
+ 	local writtenOnlyB = {}
  	table.insert(writtenOnlyB, 1)
  
  	local readB = {}
@@ -16,8 +14,7 @@
  end)
  
  if true then
--	local writtenOnlyC = {}
-+	local _writtenOnlyC = {}
+ 	local writtenOnlyC = {}
  	table.insert(writtenOnlyC, 1)
  
  	local readC = {}
diff --git a/selene-lib/tests/lints/unused_variable/write_only.fixed.diff b/selene-lib/tests/lints/unused_variable/write_only.fixed.diff
index f0652f88..47262952 100644
--- a/selene-lib/tests/lints/unused_variable/write_only.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/write_only.fixed.diff
@@ -1,5 +1,4 @@
--local bad1 = {}
-+local _bad1 = {}
+ local bad1 = {}
  bad1.x = 1
  bad1.y = 2
  bad1["z"] = 1

From 679cd8c0465bbafe9b167f216ab295f6d4fa1aa0 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 12:31:56 -0700
Subject: [PATCH 10/63] Add fix option

---
 docs/src/cli/usage.md             |  1 +
 selene-lib/src/lints/test_util.rs |  4 +-
 selene/src/main.rs                | 73 ++++++++++++++++++++++++++++---
 selene/src/opts.rs                |  3 ++
 4 files changed, 72 insertions(+), 9 deletions(-)

diff --git a/docs/src/cli/usage.md b/docs/src/cli/usage.md
index 25eb5855..fc7f0a79 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 applies some lint suggestions
     -h, --help              Prints help information
     -n, --no-summary        Suppress summary information
     -q, --quiet             Display only the necessary information. Equivalent to --display-style="quiet"
diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index e921b93a..8ac4199b 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -44,7 +44,7 @@ fn replace_code_range(code: &str, start: usize, end: usize, replacement: &str) -
 }
 
 // Assumes diagnostics is sorted by starting ranges and that there are no overlapping ranges
-fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<Diagnostic>) -> String {
+fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<&Diagnostic>) -> String {
     let mut bytes_offset = 0;
 
     let new_code = diagnostics
@@ -131,7 +131,7 @@ pub fn test_lint_config_with_output<
 
     let mut output = termcolor::NoColor::new(Vec::new());
 
-    let fixed_lua_code = apply_diagnostics_fixes(&lua_source, &diagnostics);
+    let fixed_lua_code = apply_diagnostics_fixes(&lua_source, &diagnostics.iter().collect());
     let fixed_diff = generate_diff(&lua_source, &fixed_lua_code);
     let diff_output_path = path_base.with_extension("fixed.diff");
 
diff --git a/selene/src/main.rs b/selene/src/main.rs
index 610aeb8a..d3d4b26c 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -11,11 +11,15 @@ use std::{
 
 use codespan_reporting::{
     diagnostic::{
-        Diagnostic as CodespanDiagnostic, Label as CodespanLabel, Severity as CodespanSeverity,
+        self, Diagnostic as CodespanDiagnostic, Label as CodespanLabel,
+        Severity as CodespanSeverity,
     },
     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;
@@ -178,7 +182,50 @@ fn emit_codespan_locked(
     emit_codespan(&mut stdout, files, diagnostic);
 }
 
-fn read<R: Read>(checker: &Checker<toml::value::Value>, filename: &Path, mut reader: R) {
+fn replace_code_range(code: &str, start: usize, end: usize, replacement: &str) -> String {
+    if start > end || end > code.len() {
+        return code.to_string();
+    }
+
+    return format!("{}{}{}", &code[..start], replacement, &code[end..]);
+}
+
+// Assumes diagnostics is sorted by starting ranges and that there are no overlapping ranges
+// This is just copied from `test_util`. Can we get a better abstraction?
+// FIXME: handle the overlapping ranges
+fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<&Diagnostic>) -> String {
+    let mut bytes_offset = 0;
+
+    let new_code = diagnostics
+        .iter()
+        .fold(code.to_string(), |code, diagnostic| {
+            if let Some(fixed) = &diagnostic.fixed_code {
+                let (start, end) = diagnostic.primary_label.range;
+                let new_code = replace_code_range(
+                    code.as_str(),
+                    (start as isize + bytes_offset as isize) as usize,
+                    (end as isize + bytes_offset as isize) as usize,
+                    &fixed.as_str(),
+                );
+
+                bytes_offset += fixed.len() as isize - (end - start) as isize;
+                new_code
+            } else {
+                code
+            }
+        });
+
+    full_moon::parse(&new_code).expect("Failed to parse fixed code");
+
+    new_code
+}
+
+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!(
@@ -288,6 +335,17 @@ fn read<R: Read>(checker: &Checker<toml::value::Value>, filename: &Path, mut rea
     let stdout = termcolor::StandardStream::stdout(get_color());
     let mut stdout = stdout.lock();
 
+    if is_fix {
+        let fixed_code = apply_diagnostics_fixes(
+            contents.as_ref(),
+            &diagnostics
+                .iter()
+                .map(|diagnostic| &diagnostic.diagnostic)
+                .collect(),
+        );
+        let _ = fs::write(filename, fixed_code);
+    }
+
     for diagnostic in diagnostics {
         if opts.luacheck {
             // Existing Luacheck consumers presumably use --formatter plain
@@ -376,7 +434,7 @@ fn read<R: Read>(checker: &Checker<toml::value::Value>, filename: &Path, mut rea
     }
 }
 
-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 +446,7 @@ fn read_file(checker: &Checker<toml::value::Value>, filename: &Path) {
                 return;
             }
         },
+        is_fix,
     );
 }
 
@@ -608,7 +667,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 +681,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 +705,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) => {
diff --git a/selene/src/opts.rs b/selene/src/opts.rs
index 1ce1bbb7..8f83a3b1 100644
--- a/selene/src/opts.rs
+++ b/selene/src/opts.rs
@@ -69,6 +69,9 @@ pub struct Options {
 
     #[structopt(long)]
     pub no_exclude: bool,
+
+    #[structopt(long)]
+    pub fix: bool,
 }
 
 impl Options {

From 0560a8616e5b71024125d60e6e111eb6cb329dc2 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 12:55:36 -0700
Subject: [PATCH 11/63] Abort fix with changes in working directory

---
 docs/src/cli/usage.md |  2 +-
 selene/src/main.rs    | 36 ++++++++++++++++++++++++++++++++++++
 selene/src/opts.rs    | 10 ++++++++++
 3 files changed, 47 insertions(+), 1 deletion(-)

diff --git a/docs/src/cli/usage.md b/docs/src/cli/usage.md
index fc7f0a79..aac76636 100644
--- a/docs/src/cli/usage.md
+++ b/docs/src/cli/usage.md
@@ -9,7 +9,7 @@ USAGE:
 FLAGS:
         --allow-warnings    Pass when only warnings occur
         --no-exclude        Ignore excludes defined in config
-        --fix               Automatically applies some lint suggestions
+        --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"
diff --git a/selene/src/main.rs b/selene/src/main.rs
index d3d4b26c..2516b2e2 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,
@@ -553,6 +554,17 @@ fn start(mut options: opts::Options) {
         None => {}
     }
 
+    if options.fix && !options.allow_dirty {
+        if 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) => {
@@ -830,6 +842,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.chars().nth(0) != Some(' '))
+}
+
 #[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 8f83a3b1..58c13ebb 100644
--- a/selene/src/opts.rs
+++ b/selene/src/opts.rs
@@ -72,6 +72,16 @@ pub struct Options {
 
     #[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 {

From 5417142c7666dce048dea13e52f0d28e18e84164 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 15:08:55 -0700
Subject: [PATCH 12/63] Handle conflicting fixes

---
 selene-lib/src/lints/test_util.rs | 78 ++++++++++++++++++++++---------
 selene/src/main.rs                | 73 ++++++++++++++++++++++-------
 2 files changed, 112 insertions(+), 39 deletions(-)

diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index 8ac4199b..4e1b2eaf 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -43,11 +43,34 @@ fn replace_code_range(code: &str, start: usize, end: usize, replacement: &str) -
     return format!("{}{}{}", &code[..start], replacement, &code[end..]);
 }
 
-// Assumes diagnostics is sorted by starting ranges and that there are no overlapping ranges
+/// Assumes diagnostics is sorted by starting positions
+///
+/// 1. Applies all disjoint fixes
+/// 1. If a fix is completely contained inside another fix, uses the inner one and discard the outer one
+/// 2. If fixes partially overlap, chooses the fix that starts first and discard the other one
 fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<&Diagnostic>) -> String {
+    let mut chosen_diagnostics = Vec::new();
+
+    let mut candidate = diagnostics[0];
+    for diagnostic in 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);
+
     let mut bytes_offset = 0;
 
-    let new_code = diagnostics
+    let new_code = chosen_diagnostics
         .iter()
         .fold(code.to_string(), |code, diagnostic| {
             if let Some(fixed) = &diagnostic.fixed_code {
@@ -66,8 +89,6 @@ fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<&Diagnostic>) -> String
             }
         });
 
-    full_moon::parse(&new_code).expect("Failed to parse fixed code");
-
     new_code
 }
 
@@ -111,28 +132,38 @@ 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
-            },
-        },
-        &AstContext::from_ast(&ast),
-    );
 
-    let mut files = codespan::Files::new();
-    let source_id = files.add(format!("{test_name}.lua"), lua_source.clone());
+    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));
     diagnostics.sort_by_key(|diagnostic| diagnostic.primary_label.range);
 
-    let mut output = termcolor::NoColor::new(Vec::new());
+    let mut fixed_code = lua_source.to_string();
+    let mut fixed_diagnostics = diagnostics.iter().collect::<Vec<_>>();
+    let mut lint_results;
 
-    let fixed_lua_code = apply_diagnostics_fixes(&lua_source, &diagnostics.iter().collect());
-    let fixed_diff = generate_diff(&lua_source, &fixed_lua_code);
+    // To handle potential conflicts with different lint suggestions, we apply conflicting fixes one at a time.
+    // Then we re-evaluate the lints with the new code until there are no more fixes to apply
+    while fixed_diagnostics
+        .iter()
+        .any(|diagnostic| diagnostic.fixed_code.is_some())
+    {
+        fixed_code = apply_diagnostics_fixes(fixed_code.as_str(), &fixed_diagnostics);
+
+        let fixed_ast = full_moon::parse(&fixed_code).expect("Fix generated invalid code");
+        lint_results = lint.pass(&fixed_ast, &context, &AstContext::from_ast(&fixed_ast));
+        fixed_diagnostics = lint_results.iter().collect::<Vec<_>>();
+        fixed_diagnostics.sort_by_key(|diagnostic| diagnostic.primary_label.range);
+    }
+
+    let fixed_diff = generate_diff(&lua_source, &fixed_code);
     let diff_output_path = path_base.with_extension("fixed.diff");
 
     if let Ok(expected) = fs::read_to_string(&diff_output_path) {
@@ -145,6 +176,11 @@ pub fn test_lint_config_with_output<
             .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());
+
     for diagnostic in diagnostics
         .into_iter()
         .map(|diagnostic| diagnostic.into_codespan_diagnostic(source_id, CodespanSeverity::Error))
diff --git a/selene/src/main.rs b/selene/src/main.rs
index 2516b2e2..3a804e2e 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -12,8 +12,7 @@ use std::{
 
 use codespan_reporting::{
     diagnostic::{
-        self, Diagnostic as CodespanDiagnostic, Label as CodespanLabel,
-        Severity as CodespanSeverity,
+        Diagnostic as CodespanDiagnostic, Label as CodespanLabel, Severity as CodespanSeverity,
     },
     term::DisplayStyle as CodespanDisplayStyle,
 };
@@ -191,13 +190,36 @@ fn replace_code_range(code: &str, start: usize, end: usize, replacement: &str) -
     return format!("{}{}{}", &code[..start], replacement, &code[end..]);
 }
 
-// Assumes diagnostics is sorted by starting ranges and that there are no overlapping ranges
+/// Assumes diagnostics is sorted by starting positions
+///
+/// 1. Applies all disjoint fixes
+/// 1. If a fix is completely contained inside another fix, uses the inner one and discard the outer one
+/// 2. If fixes partially overlap, chooses the fix that starts first and discard the other one
+///
 // This is just copied from `test_util`. Can we get a better abstraction?
-// FIXME: handle the overlapping ranges
 fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<&Diagnostic>) -> String {
+    let mut chosen_diagnostics = Vec::new();
+
+    let mut candidate = diagnostics[0];
+    for diagnostic in 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);
+
     let mut bytes_offset = 0;
 
-    let new_code = diagnostics
+    let new_code = chosen_diagnostics
         .iter()
         .fold(code.to_string(), |code, diagnostic| {
             if let Some(fixed) = &diagnostic.fixed_code {
@@ -216,8 +238,6 @@ fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<&Diagnostic>) -> String
             }
         });
 
-    full_moon::parse(&new_code).expect("Failed to parse fixed code");
-
     new_code
 }
 
@@ -321,6 +341,34 @@ fn read<R: Read>(
     let mut diagnostics = checker.test_on(&ast);
     diagnostics.sort_by_key(|diagnostic| diagnostic.diagnostic.start_position());
 
+    if is_fix {
+        let mut fixed_code = contents.as_ref().to_string();
+
+        // To handle potential conflicts with different lint suggestions, we apply conflicting fixes one at a time.
+        // Then we re-evaluate the lints with the new code until there are no more fixes to apply
+        while diagnostics
+            .iter()
+            .any(|diagnostic| diagnostic.diagnostic.fixed_code.is_some())
+        {
+            fixed_code = apply_diagnostics_fixes(
+                fixed_code.as_str(),
+                &diagnostics
+                    .iter()
+                    .map(|diagnostic| &diagnostic.diagnostic)
+                    .collect(),
+            );
+
+            let fixed_ast = full_moon::parse(&fixed_code).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);
+            diagnostics.sort_by_key(|diagnostic| diagnostic.diagnostic.start_position());
+        }
+
+        let _ = fs::write(filename, fixed_code);
+    }
+
     let (mut errors, mut warnings) = (0, 0);
     for diagnostic in &diagnostics {
         match diagnostic.severity {
@@ -336,17 +384,6 @@ fn read<R: Read>(
     let stdout = termcolor::StandardStream::stdout(get_color());
     let mut stdout = stdout.lock();
 
-    if is_fix {
-        let fixed_code = apply_diagnostics_fixes(
-            contents.as_ref(),
-            &diagnostics
-                .iter()
-                .map(|diagnostic| &diagnostic.diagnostic)
-                .collect(),
-        );
-        let _ = fs::write(filename, fixed_code);
-    }
-
     for diagnostic in diagnostics {
         if opts.luacheck {
             // Existing Luacheck consumers presumably use --formatter plain

From c49e080d52aa01c4705383b4b87283d4c4c0508d Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 15:23:25 -0700
Subject: [PATCH 13/63] Fix unused variable false negative with fixer

---
 selene-lib/src/lints/unused_variable.rs             | 13 +++++++++----
 .../tests/lints/unused_variable/blocks.fixed.diff   |  9 ++++++---
 .../lints/unused_variable/edge_cases.fixed.diff     |  6 ++++--
 .../tests/lints/unused_variable/locals.fixed.diff   |  3 ++-
 4 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/selene-lib/src/lints/unused_variable.rs b/selene-lib/src/lints/unused_variable.rs
index 2f5da454..13007e2f 100644
--- a/selene-lib/src/lints/unused_variable.rs
+++ b/selene-lib/src/lints/unused_variable.rs
@@ -172,10 +172,15 @@ impl Lint for UnusedVariableLint {
                     fixed_code = None;
                 }
 
-                // Applying fix would cause references to reference the old variable. It's possible to also rename those
-                // references as well, but we'd need to check each of their scopes for potentially colliding variables.
-                // Cargo just doesn't apply a fix in these cases.
-                if !variable.references.is_empty() {
+                // Applying fix would cause existing references to reference a nonexistent variable. It's possible to
+                // also rename those references as well, but we'd need to check each of their scopes for potentially
+                // colliding variables. Cargo 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
+                }) {
                     fixed_code = None;
                 }
 
diff --git a/selene-lib/tests/lints/unused_variable/blocks.fixed.diff b/selene-lib/tests/lints/unused_variable/blocks.fixed.diff
index 402db837..5308ebc1 100644
--- a/selene-lib/tests/lints/unused_variable/blocks.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/blocks.fixed.diff
@@ -1,12 +1,15 @@
  -- Functions
 -local function unusedFunction()
+-    local unusedVariableA = 1
+-    local unusedVariableB = 1
 +local function _unusedFunction()
-     local unusedVariableA = 1
-     local unusedVariableB = 1
++    local _unusedVariableA = 1
++    local _unusedVariableB = 1
  end
  
  print(unusedVariableB)
- local overidden = true
+-local overidden = true
++local _overidden = true
  
  local function overridesIt()
      local overidden = false
diff --git a/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff b/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff
index 8565d0c6..414306c0 100644
--- a/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff
@@ -1,6 +1,8 @@
  local foo = 1
- local foo = foo + 1
- local bar = bar
+-local foo = foo + 1
+-local bar = bar
++local _foo = foo + 1
++local _bar = bar
  
  -- The variables inside of a repeat...until are accessible from the until statement
  repeat
diff --git a/selene-lib/tests/lints/unused_variable/locals.fixed.diff b/selene-lib/tests/lints/unused_variable/locals.fixed.diff
index 6bcc77e7..b5522fcd 100644
--- a/selene-lib/tests/lints/unused_variable/locals.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/locals.fixed.diff
@@ -28,4 +28,5 @@
  
  -- Put into a table
  local localH = 1
- local localI = { localH }
+-local localI = { localH }
++local _localI = { localH }

From 63ad3ebf454f4e47dc401a1e58d367e22e8b80dc Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 15:54:23 -0700
Subject: [PATCH 14/63] Fix clippy

---
 selene/src/main.rs | 29 +++++++++++++++--------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/selene/src/main.rs b/selene/src/main.rs
index 3a804e2e..b9147781 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -187,7 +187,7 @@ fn replace_code_range(code: &str, start: usize, end: usize, replacement: &str) -
         return code.to_string();
     }
 
-    return format!("{}{}{}", &code[..start], replacement, &code[end..]);
+    format!("{}{}{}", &code[..start], replacement, &code[end..])
 }
 
 /// Assumes diagnostics is sorted by starting positions
@@ -226,9 +226,9 @@ fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<&Diagnostic>) -> String
                 let (start, end) = diagnostic.primary_label.range;
                 let new_code = replace_code_range(
                     code.as_str(),
-                    (start as isize + bytes_offset as isize) as usize,
-                    (end as isize + bytes_offset as isize) as usize,
-                    &fixed.as_str(),
+                    (start as isize + bytes_offset) as usize,
+                    (end as isize + bytes_offset) as usize,
+                    fixed.as_str(),
                 );
 
                 bytes_offset += fixed.len() as isize - (end - start) as isize;
@@ -591,15 +591,16 @@ fn start(mut options: opts::Options) {
         None => {}
     }
 
-    if options.fix && !options.allow_dirty {
-        if 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);
-        }
+    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>) =
@@ -900,7 +901,7 @@ fn has_staged_changes() -> bool {
 
     let stdout = String::from_utf8(output.stdout).expect("Failed to convert git output to string");
 
-    stdout.lines().any(|line| line.chars().nth(0) != Some(' '))
+    stdout.lines().any(|line| !line.starts_with(' '))
 }
 
 #[cfg(feature = "roblox")]

From 1c519dc07f351df09bc0a3075031a937dda60da8 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 16:07:37 -0700
Subject: [PATCH 15/63] Add compare_nan fixer

---
 selene-lib/src/lints/compare_nan.rs           | 14 ++++----
 .../compare_nan/compare_nan_if.fixed.diff     | 34 +++++++++++++++++++
 .../compare_nan_variables.fixed.diff          | 15 ++++++++
 3 files changed, 57 insertions(+), 6 deletions(-)
 create mode 100644 selene-lib/tests/lints/compare_nan/compare_nan_if.fixed.diff
 create mode 100644 selene-lib/tests/lints/compare_nan/compare_nan_variables.fixed.diff

diff --git a/selene-lib/src/lints/compare_nan.rs b/selene-lib/src/lints/compare_nan.rs
index 64b5d9b1..cceda680 100644
--- a/selene-lib/src/lints/compare_nan.rs
+++ b/selene-lib/src/lints/compare_nan.rs
@@ -30,17 +30,19 @@ impl Lint for CompareNanLint {
             .comparisons
             .iter()
             .map(|comparisons| {
+                let fixed_code = format!(
+                    "{variable} {operator} {variable}",
+                    variable = comparisons.variable,
+                    operator = comparisons.operator,
+                );
+
                 Diagnostic::new_complete(
                     "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![format!("try: `{}` instead", fixed_code.clone())],
                     Vec::new(),
-                    None,
+                    Some(fixed_code),
                 )
             })
             .collect()
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..9f868d40
--- /dev/null
+++ b/selene-lib/tests/lints/compare_nan/compare_nan_if.fixed.diff
@@ -0,0 +1,34 @@
+-if x == 0/0 then
++if x ~= x then
+ end
+ 
+-if x ~= 0/0 then
++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_variables.fixed.diff b/selene-lib/tests/lints/compare_nan/compare_nan_variables.fixed.diff
new file mode 100644
index 00000000..59b83e46
--- /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
+-local _ = x ~= 0/0
+-local _ = x == 0/0
++local _ = x == x
++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

From 47afa03f8b54d915440f0229a5a6a276150122f6 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 16:16:26 -0700
Subject: [PATCH 16/63] Add deprecated fixer

---
 selene-lib/src/lints/deprecated.rs                         | 5 ++++-
 .../tests/lints/deprecated/deprecated_fields.fixed.diff    | 3 +++
 .../tests/lints/deprecated/deprecated_functions.fixed.diff | 5 +++++
 .../tests/lints/deprecated/specific_allow.fixed.diff       | 7 +++++++
 .../deprecated/toml_forwards_compatibility.fixed.diff      | 2 ++
 5 files changed, 21 insertions(+), 1 deletion(-)
 create mode 100644 selene-lib/tests/lints/deprecated/deprecated_fields.fixed.diff
 create mode 100644 selene-lib/tests/lints/deprecated/deprecated_functions.fixed.diff
 create mode 100644 selene-lib/tests/lints/deprecated/specific_allow.fixed.diff
 create mode 100644 selene-lib/tests/lints/deprecated/toml_forwards_compatibility.fixed.diff

diff --git a/selene-lib/src/lints/deprecated.rs b/selene-lib/src/lints/deprecated.rs
index e26aeca8..9a3343c7 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 fixed_code = None;
+
             if let Some(replace_with) = deprecated.try_instead(parameters) {
                 notes.push(format!("try: {replace_with}"));
+                fixed_code = Some(replace_with);
             }
 
             self.diagnostics.push(Diagnostic::new_complete(
@@ -128,7 +131,7 @@ impl<'a> DeprecatedVisitor<'a> {
                 Label::from_node(node, None),
                 notes,
                 Vec::new(),
-                None,
+                fixed_code,
             ));
         }
     }
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..17b208a5
--- /dev/null
+++ b/selene-lib/tests/lints/deprecated/deprecated_fields.fixed.diff
@@ -0,0 +1,3 @@
+ local _ = this.is_deprecated
+ local _ = all_of_this.is_deprecated
+ local _ = all_of_this.even.deeper.is_deprecated
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..11fc9787
--- /dev/null
+++ b/selene-lib/tests/lints/deprecated/deprecated_functions.fixed.diff
@@ -0,0 +1,5 @@
+ table.foreach({}, function(k, v) end)
+-print(table.getn(x))
++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..e25f2dd2
--- /dev/null
+++ b/selene-lib/tests/lints/deprecated/specific_allow.fixed.diff
@@ -0,0 +1,7 @@
+ deprecated_allowed()
+ deprecated_blocked()
+ 
+ more.deprecated_allowed()
+ wow.extra.deprecated_allowed()
+ 
+ deprecated_allowed.more()
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..5b08ed21
--- /dev/null
+++ b/selene-lib/tests/lints/deprecated/toml_forwards_compatibility.fixed.diff
@@ -0,0 +1,2 @@
+ -- Tests that the old TOML format is unchanged
+ print(this_is.deprecated)

From 2b90c542f253fa029cc14d326a06a4a6c135c5c0 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 17:20:14 -0700
Subject: [PATCH 17/63] Add fixer to paranthese lint

---
 selene-lib/src/lib.rs                             |  4 ++--
 selene-lib/src/lints.rs                           |  6 +++++-
 selene-lib/src/lints/parenthese_conditions.rs     |  4 ++--
 selene-lib/src/lints/test_util.rs                 |  8 ++++++--
 selene-lib/src/test_util.rs                       |  2 +-
 selene-lib/tests/checker.rs                       |  5 ++++-
 .../parenthese_conditions.fixed.diff              | 15 +++++++++++++++
 selene/src/main.rs                                |  4 ++--
 8 files changed, 37 insertions(+), 11 deletions(-)
 create mode 100644 selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff

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/lints.rs b/selene-lib/src/lints.rs
index 5dcf0735..45578caa 100644
--- a/selene-lib/src/lints.rs
+++ b/selene-lib/src/lints.rs
@@ -243,12 +243,16 @@ 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 {
+    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/parenthese_conditions.rs b/selene-lib/src/lints/parenthese_conditions.rs
index c8f2711c..8eb87aef 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,7 +35,7 @@ impl Lint for ParentheseConditionsLint {
                     "parenthese_conditions",
                     "lua does not require parentheses around conditions".to_owned(),
                     Label::new(*position),
-                    None,
+                    Some(context.code[position.0 + 1..position.1 - 1].to_string()),
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index 4e1b2eaf..cd73048e 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -142,7 +142,7 @@ pub fn test_lint_config_with_output<
         },
     };
 
-    let mut diagnostics = lint.pass(&ast, &context, &AstContext::from_ast(&ast));
+    let mut diagnostics = lint.pass(&ast, &context, &AstContext::from_ast(&ast, &lua_source));
     diagnostics.sort_by_key(|diagnostic| diagnostic.primary_label.range);
 
     let mut fixed_code = lua_source.to_string();
@@ -158,7 +158,11 @@ pub fn test_lint_config_with_output<
         fixed_code = apply_diagnostics_fixes(fixed_code.as_str(), &fixed_diagnostics);
 
         let fixed_ast = full_moon::parse(&fixed_code).expect("Fix generated invalid code");
-        lint_results = lint.pass(&fixed_ast, &context, &AstContext::from_ast(&fixed_ast));
+        lint_results = lint.pass(
+            &fixed_ast,
+            &context,
+            &AstContext::from_ast(&fixed_ast, &lua_source),
+        );
         fixed_diagnostics = lint_results.iter().collect::<Vec<_>>();
         fixed_diagnostics.sort_by_key(|diagnostic| diagnostic.primary_label.range);
     }
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/parenthese_conditions/parenthese_conditions.fixed.diff b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
new file mode 100644
index 00000000..2ae62d0a
--- /dev/null
+++ b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
@@ -0,0 +1,15 @@
+ if x then end
+ if (x) then end
+ 
+ if (x) then
+ elseif y then
+ elseif (z) then
+ end
+ 
+ while true do end
+ while (true) do end
+ 
+ repeat until false
+ repeat until (false)
+ 
+ while (true) and false do end
diff --git a/selene/src/main.rs b/selene/src/main.rs
index b9147781..6dd6a873 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -338,7 +338,7 @@ fn read<R: Read>(
         }
     };
 
-    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());
 
     if is_fix {
@@ -362,7 +362,7 @@ fn read<R: Read>(
                 "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);
+            diagnostics = checker.test_on(&fixed_ast, &fixed_code);
             diagnostics.sort_by_key(|diagnostic| diagnostic.diagnostic.start_position());
         }
 

From cbf3a3ec3d77d4b61e21d3c7da99a09a152c6f77 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 17:23:41 -0700
Subject: [PATCH 18/63] Fix diff for parenthese

---
 .../parenthese_conditions.fixed.diff              | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
index 2ae62d0a..18794b1b 100644
--- a/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
+++ b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
@@ -1,15 +1,20 @@
  if x then end
- if (x) then end
+-if (x) then end
++if x then end
  
- if (x) then
+-if (x) then
++if x then
  elseif y then
- elseif (z) then
+-elseif (z) then
++elseif z then
  end
  
  while true do end
- while (true) do end
+-while (true) do end
++while true do end
  
  repeat until false
- repeat until (false)
+-repeat until (false)
++repeat until false
  
  while (true) and false do end

From ff5d606ec7fa7db3f4cd82fa6be1c4fc2c3f39d3 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 17:49:32 -0700
Subject: [PATCH 19/63] Fix test

---
 selene-lib/src/lints/test_util.rs                 | 14 ++++++++++----
 .../parenthese_conditions.fixed.diff              |  7 +++++++
 .../parenthese_conditions.lua                     |  4 ++++
 .../parenthese_conditions.stderr                  | 15 +++++++++++++++
 selene/src/main.rs                                |  1 +
 5 files changed, 37 insertions(+), 4 deletions(-)

diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index cd73048e..36dd2f44 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -157,14 +157,20 @@ pub fn test_lint_config_with_output<
     {
         fixed_code = apply_diagnostics_fixes(fixed_code.as_str(), &fixed_diagnostics);
 
-        let fixed_ast = full_moon::parse(&fixed_code).expect("Fix generated invalid code");
+        let fixed_ast = full_moon::parse(&fixed_code).expect(&format!(
+            "Fixer generated invalid code:\n\
+            ----------------\n\
+            {}\n\
+            ----------------\n",
+            fixed_code
+        ));
         lint_results = lint.pass(
             &fixed_ast,
             &context,
-            &AstContext::from_ast(&fixed_ast, &lua_source),
+            &AstContext::from_ast(&fixed_ast, &fixed_code),
         );
         fixed_diagnostics = lint_results.iter().collect::<Vec<_>>();
-        fixed_diagnostics.sort_by_key(|diagnostic| diagnostic.primary_label.range);
+        fixed_diagnostics.sort_by_key(|diagnostic| diagnostic.start_position());
     }
 
     let fixed_diff = generate_diff(&lua_source, &fixed_code);
@@ -177,7 +183,7 @@ pub fn test_lint_config_with_output<
             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");
+            .expect("couldn't write fixed.diff to output file.");
     }
 
     let mut files = codespan::Files::new();
diff --git a/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
index 18794b1b..71268175 100644
--- a/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
+++ b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
@@ -18,3 +18,10 @@
 +repeat until false
  
  while (true) and false do end
+ 
+-if ((function()
+-    if (x) then end
+-end)()) then end
++if (function()
++    if x then end
++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..74913130 100644
--- a/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.stderr
+++ b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.stderr
@@ -28,3 +28,18 @@ error[parenthese_conditions]: lua does not require parentheses around conditions
 13 │ repeat until (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
+   │ ╰───────^
+
+error[parenthese_conditions]: lua does not require parentheses around conditions
+   ┌─ parenthese_conditions.lua:18:8
+   │
+18 │     if (x) then end
+   │        ^^^
+
diff --git a/selene/src/main.rs b/selene/src/main.rs
index 6dd6a873..fd01cd0c 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -367,6 +367,7 @@ fn read<R: Read>(
         }
 
         let _ = fs::write(filename, fixed_code);
+        return;
     }
 
     let (mut errors, mut warnings) = (0, 0);

From c7d371bac7a40aba76e334f3d99e41f0b08395b6 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 18:13:24 -0700
Subject: [PATCH 20/63] Fix iterations

---
 selene-lib/src/lints/test_util.rs |  7 +++++--
 selene/src/main.rs                | 11 +++++++++++
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index 36dd2f44..4cd6e8d7 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -40,7 +40,7 @@ fn replace_code_range(code: &str, start: usize, end: usize, replacement: &str) -
         return code.to_string();
     }
 
-    return format!("{}{}{}", &code[..start], replacement, &code[end..]);
+    format!("{}{}{}", &code[..start], replacement, &code[end..])
 }
 
 /// Assumes diagnostics is sorted by starting positions
@@ -146,7 +146,10 @@ pub fn test_lint_config_with_output<
     diagnostics.sort_by_key(|diagnostic| diagnostic.primary_label.range);
 
     let mut fixed_code = lua_source.to_string();
-    let mut fixed_diagnostics = diagnostics.iter().collect::<Vec<_>>();
+    let mut fixed_diagnostics = diagnostics
+        .iter()
+        .filter(|diagnostic| diagnostic.fixed_code.is_some())
+        .collect::<Vec<_>>();
     let mut lint_results;
 
     // To handle potential conflicts with different lint suggestions, we apply conflicting fixes one at a time.
diff --git a/selene/src/main.rs b/selene/src/main.rs
index fd01cd0c..ba2995bb 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -238,6 +238,8 @@ fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<&Diagnostic>) -> String
             }
         });
 
+    println!("{}", chosen_diagnostics.iter().count());
+
     new_code
 }
 
@@ -355,9 +357,18 @@ fn read<R: Read>(
                 &diagnostics
                     .iter()
                     .map(|diagnostic| &diagnostic.diagnostic)
+                    .filter(|diagnostic| diagnostic.fixed_code.is_some())
                     .collect(),
             );
 
+            println!(
+                "Fixer generated invalid code:\n\
+                ----------------\n\
+                {}\n\
+                ----------------\n",
+                fixed_code
+            );
+
             let fixed_ast = full_moon::parse(&fixed_code).expect(
                 "selene tried applying lint suggestions, but it generated invalid code that could not be parsed; \
                 this is likely a selene bug",

From 0addbc86b6b6c2a5589005ce6a350be1d02579a5 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 18:20:07 -0700
Subject: [PATCH 21/63] Remove debugging print

---
 selene/src/main.rs | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/selene/src/main.rs b/selene/src/main.rs
index ba2995bb..c821270d 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -238,8 +238,6 @@ fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<&Diagnostic>) -> String
             }
         });
 
-    println!("{}", chosen_diagnostics.iter().count());
-
     new_code
 }
 
@@ -361,14 +359,6 @@ fn read<R: Read>(
                     .collect(),
             );
 
-            println!(
-                "Fixer generated invalid code:\n\
-                ----------------\n\
-                {}\n\
-                ----------------\n",
-                fixed_code
-            );
-
             let fixed_ast = full_moon::parse(&fixed_code).expect(
                 "selene tried applying lint suggestions, but it generated invalid code that could not be parsed; \
                 this is likely a selene bug",

From 5f3a84b5f4d7208c88d38efb2e365639b868e481 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 21:06:54 -0700
Subject: [PATCH 22/63] Pretty print

---
 selene/src/main.rs | 41 ++++++++++++++++++++++++++++++++++++-----
 1 file changed, 36 insertions(+), 5 deletions(-)

diff --git a/selene/src/main.rs b/selene/src/main.rs
index c821270d..ec662ac4 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -197,7 +197,7 @@ fn replace_code_range(code: &str, start: usize, end: usize, replacement: &str) -
 /// 2. If fixes partially overlap, chooses the fix that starts first and discard the other one
 ///
 // This is just copied from `test_util`. Can we get a better abstraction?
-fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<&Diagnostic>) -> String {
+fn apply_diagnostics_fixes(code: &str, diagnostics: &[&Diagnostic]) -> String {
     let mut chosen_diagnostics = Vec::new();
 
     let mut candidate = diagnostics[0];
@@ -341,8 +341,12 @@ fn read<R: Read>(
     let mut diagnostics = checker.test_on(&ast, &contents.as_ref().to_string());
     diagnostics.sort_by_key(|diagnostic| diagnostic.diagnostic.start_position());
 
+    let mut fixed_code = contents.as_ref().to_string();
     if is_fix {
-        let mut fixed_code = contents.as_ref().to_string();
+        let num_fixes = diagnostics
+            .iter()
+            .filter(|diagnostic| diagnostic.diagnostic.fixed_code.is_some())
+            .count();
 
         // To handle potential conflicts with different lint suggestions, we apply conflicting fixes one at a time.
         // Then we re-evaluate the lints with the new code until there are no more fixes to apply
@@ -356,7 +360,7 @@ fn read<R: Read>(
                     .iter()
                     .map(|diagnostic| &diagnostic.diagnostic)
                     .filter(|diagnostic| diagnostic.fixed_code.is_some())
-                    .collect(),
+                    .collect::<Vec<_>>(),
             );
 
             let fixed_ast = full_moon::parse(&fixed_code).expect(
@@ -367,8 +371,35 @@ fn read<R: Read>(
             diagnostics.sort_by_key(|diagnostic| diagnostic.diagnostic.start_position());
         }
 
-        let _ = fs::write(filename, fixed_code);
-        return;
+        if num_fixes > 0 {
+            if fs::write(filename, fixed_code.clone()).is_ok() {
+                files.update(source_id, &fixed_code);
+
+                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(),
+                    if num_fixes == 1 {
+                        "1 fix".to_string()
+                    } else {
+                        format!("{} fixes", num_fixes)
+                    }
+                );
+
+                drop(stdout);
+            } else {
+                error(format!("failed to write to {}", filename.display()).as_str());
+                std::process::exit(1);
+            }
+        }
     }
 
     let (mut errors, mut warnings) = (0, 0);

From 26c3c76cb2acfce757a54772d464a9a5eac117ba Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 21:35:25 -0700
Subject: [PATCH 23/63] Update docs

---
 CHANGELOG.md                            | 1 +
 docs/src/cli/usage.md                   | 4 ++++
 selene-lib/src/lints/unused_variable.rs | 2 +-
 3 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b6015620..0705e666 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 - Added `no-exclude` cli flag to disable excludes.
 - When given in standard library format, additional information now shows up in `incorrect_standard_library_use` missing required parameter errors.
 - Added new [`mixed_table` lint](https://kampfkarren.github.io/selene/lints/mixed_table.html), which will warn against mixed tables.
+- Added new [`fix`](https://kampfkarren.github.io/selene/cli/usage.html#fix) flag, which will automatically apply lint suggestions.
 
 ### Fixed
 - `string.pack` and `string.unpack` now have proper function signatures in the Lua 5.3 standard library.
diff --git a/docs/src/cli/usage.md b/docs/src/cli/usage.md
index aac76636..10bf11b7 100644
--- a/docs/src/cli/usage.md
+++ b/docs/src/cli/usage.md
@@ -77,6 +77,10 @@ Results:
 0 parse errors
 ```
 
+**--fix** *fix*
+
+Automatically applies lint suggestions. Because this can be potentially destructive, it's not allowed by default when there are uncommitted changes. This safety can be ignored by including `--allow-dirty` to allow with 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/src/lints/unused_variable.rs b/selene-lib/src/lints/unused_variable.rs
index 13007e2f..9e3b1f0a 100644
--- a/selene-lib/src/lints/unused_variable.rs
+++ b/selene-lib/src/lints/unused_variable.rs
@@ -174,7 +174,7 @@ impl Lint for UnusedVariableLint {
 
                 // Applying fix would cause existing references to reference a nonexistent variable. It's possible to
                 // also rename those references as well, but we'd need to check each of their scopes for potentially
-                // colliding variables. Cargo just doesn't apply a fix at all in these cases.
+                // colliding variables. 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

From 31bf18e1d402f35209b099a35d5cda5c2df6c4b6 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 14 Oct 2023 21:37:10 -0700
Subject: [PATCH 24/63] Update docs

---
 docs/src/cli/usage.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/src/cli/usage.md b/docs/src/cli/usage.md
index 10bf11b7..770f0325 100644
--- a/docs/src/cli/usage.md
+++ b/docs/src/cli/usage.md
@@ -79,7 +79,7 @@ Results:
 
 **--fix** *fix*
 
-Automatically applies lint suggestions. Because this can be potentially destructive, it's not allowed by default when there are uncommitted changes. This safety can be ignored by including `--allow-dirty` to allow with unstaged changes or `--allow-staged` to allow only staged changes.
+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*
 

From e145e82f1c925b3137b2a5fe41d604a6c8b6e62d Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sun, 15 Oct 2023 13:28:51 -0700
Subject: [PATCH 25/63] Add vscode extension support

---
 selene-vscode/src/extension.ts             | 53 +++++++++++++++++++++-
 selene-vscode/src/structures/diagnostic.ts | 12 +++++
 selene/src/json_output.rs                  |  3 ++
 selene/src/main.rs                         | 13 ++++--
 4 files changed, 75 insertions(+), 6 deletions(-)

diff --git a/selene-vscode/src/extension.ts b/selene-vscode/src/extension.ts
index 4edad143..e1c72572 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,42 @@ enum RunType {
     OnIdle = "onIdle",
 }
 
+class SeleneCodeActionProvider implements vscode.CodeActionProvider {
+    public provideCodeActions(
+        document: vscode.TextDocument,
+        _range: vscode.Range | vscode.Selection,
+        context: vscode.CodeActionContext,
+        _token: vscode.CancellationToken,
+    ): vscode.ProviderResult<vscode.Command[] | vscode.CodeAction[]> {
+        // You can retrieve the diagnostic from the context, then decide what action to provide.
+        const codeActions: vscode.CodeAction[] = []
+
+        for (const diagnostic of context.diagnostics) {
+            if (
+                diagnostic instanceof SeleneDiagnostic &&
+                diagnostic.fixed_code
+            ) {
+                const action = new vscode.CodeAction(
+                    `fix: ${diagnostic.message}`,
+                    vscode.CodeActionKind.QuickFix,
+                )
+                action.diagnostics = [diagnostic]
+
+                action.edit = new vscode.WorkspaceEdit()
+                action.edit.replace(
+                    document.uri,
+                    diagnostic.range,
+                    diagnostic.fixed_code,
+                )
+
+                codeActions.push(action)
+            }
+        }
+
+        return codeActions
+    }
+}
+
 function labelToRange(
     document: vscode.TextDocument,
     label: Label,
@@ -73,6 +114,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 +252,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.fixed_code,
             )
 
             diagnostic.source = `selene::${data.code}`
diff --git a/selene-vscode/src/structures/diagnostic.ts b/selene-vscode/src/structures/diagnostic.ts
index 37dcf8ae..e3e67d77 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,14 @@ export interface Diagnostic {
     notes: string[]
     primary_label: Label
     secondary_labels: Label[]
+    fixed_code: string
+}
+
+export class SeleneDiagnostic extends vscode.Diagnostic {
+    fixed_code?: string;
+
+    constructor(range: vscode.Range, message: string, severity: vscode.DiagnosticSeverity, fixed_code?: string) {
+        super(range, message, severity);
+        this.fixed_code = fixed_code;
+    }
 }
diff --git a/selene/src/json_output.rs b/selene/src/json_output.rs
index ed238842..da27acc8 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>,
+    fixed_code: 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>,
+    fixed_code: 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(),
+        fixed_code,
     }
 }
 
diff --git a/selene/src/main.rs b/selene/src/main.rs
index ec662ac4..d64eeda8 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -130,6 +130,7 @@ fn emit_codespan(
     writer: &mut impl termcolor::WriteColor,
     files: &codespan::Files<&str>,
     diagnostic: &CodespanDiagnostic<codespan::FileId>,
+    fixed_code: Option<String>,
 ) {
     let lock = OPTIONS.read().unwrap();
     let opts = lock.as_ref().unwrap();
@@ -148,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, fixed_code
+                ))
+                .unwrap()
             )
             .unwrap();
         }
@@ -158,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, fixed_code)
                 ))
                 .unwrap()
             )
@@ -179,7 +183,7 @@ 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 replace_code_range(code: &str, start: usize, end: usize, replacement: &str) -> String {
@@ -491,6 +495,7 @@ fn read<R: Read>(
                 write(&mut stack, new_start).unwrap();
             }
         } else {
+            let fixed_code = diagnostic.diagnostic.fixed_code.clone();
             let diagnostic = diagnostic.diagnostic.into_codespan_diagnostic(
                 source_id,
                 match diagnostic.severity {
@@ -500,7 +505,7 @@ fn read<R: Read>(
                 },
             );
 
-            emit_codespan(&mut stdout, &files, &diagnostic);
+            emit_codespan(&mut stdout, &files, &diagnostic, fixed_code);
         }
     }
 }

From c8df0819bcbc5c0cfffbe96b0f68415606ef5f14 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sun, 15 Oct 2023 13:32:00 -0700
Subject: [PATCH 26/63] Remove comment

---
 selene-vscode/src/extension.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/selene-vscode/src/extension.ts b/selene-vscode/src/extension.ts
index e1c72572..6a5f22fd 100644
--- a/selene-vscode/src/extension.ts
+++ b/selene-vscode/src/extension.ts
@@ -30,7 +30,6 @@ class SeleneCodeActionProvider implements vscode.CodeActionProvider {
         context: vscode.CodeActionContext,
         _token: vscode.CancellationToken,
     ): vscode.ProviderResult<vscode.Command[] | vscode.CodeAction[]> {
-        // You can retrieve the diagnostic from the context, then decide what action to provide.
         const codeActions: vscode.CodeAction[] = []
 
         for (const diagnostic of context.diagnostics) {

From 5a52738102b4e8ecbe02ef48117464a720889238 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sun, 15 Oct 2023 14:16:21 -0700
Subject: [PATCH 27/63] Add machine applicability

---
 selene-lib/src/lint_filtering.rs              |  5 +++-
 selene-lib/src/lints.rs                       | 26 +++++++++++++++++++
 selene-lib/src/lints/almost_swapped.rs        |  1 +
 selene-lib/src/lints/bad_string_escape.rs     |  6 +++++
 selene-lib/src/lints/compare_nan.rs           |  1 +
 .../src/lints/constant_table_comparison.rs    |  1 +
 selene-lib/src/lints/deprecated.rs            |  1 +
 selene-lib/src/lints/divide_by_zero.rs        |  1 +
 selene-lib/src/lints/duplicate_keys.rs        |  1 +
 selene-lib/src/lints/empty_if.rs              |  1 +
 selene-lib/src/lints/empty_loop.rs            |  1 +
 selene-lib/src/lints/global_usage.rs          |  1 +
 .../src/lints/high_cyclomatic_complexity.rs   |  1 +
 selene-lib/src/lints/if_same_then_else.rs     |  1 +
 selene-lib/src/lints/ifs_same_cond.rs         |  1 +
 selene-lib/src/lints/manual_table_clone.rs    |  1 +
 selene-lib/src/lints/mismatched_arg_count.rs  |  1 +
 selene-lib/src/lints/mixed_table.rs           |  1 +
 selene-lib/src/lints/multiple_statements.rs   |  1 +
 selene-lib/src/lints/must_use.rs              |  1 +
 selene-lib/src/lints/parenthese_conditions.rs |  1 +
 .../roblox_incorrect_color3_new_bounds.rs     |  1 +
 .../src/lints/roblox_incorrect_roact_usage.rs |  4 +++
 .../src/lints/roblox_suspicious_udim2_new.rs  |  9 ++++++-
 selene-lib/src/lints/shadowing.rs             |  1 +
 selene-lib/src/lints/standard_library.rs      |  8 ++++++
 .../src/lints/suspicious_reverse_loop.rs      |  1 +
 .../src/lints/type_check_inside_call.rs       |  1 +
 .../src/lints/unbalanced_assignments.rs       |  2 ++
 selene-lib/src/lints/undefined_variable.rs    |  1 +
 selene-lib/src/lints/unscoped_variables.rs    |  1 +
 selene-lib/src/lints/unused_variable.rs       |  1 +
 selene/src/main.rs                            | 20 +++++++++-----
 33 files changed, 96 insertions(+), 9 deletions(-)

diff --git a/selene-lib/src/lint_filtering.rs b/selene-lib/src/lint_filtering.rs
index 57ae87b7..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};
@@ -150,6 +150,7 @@ impl NodeVisitor for FilterVisitor {
                                     trivia_end_position.bytes(),
                                 )),
                                 None,
+                                Applicability::Unspecified,
                             ))
                         }
                     }));
@@ -225,6 +226,7 @@ pub fn filter_diagnostics(
                                 "global filter must be before this".to_owned(),
                             )],
                             None,
+                            Applicability::Unspecified,
                         ));
 
                         continue;
@@ -247,6 +249,7 @@ pub fn filter_diagnostics(
                                     "conflicts with this".to_owned(),
                                 )],
                                 None,
+                                Applicability::Unspecified,
                             ));
                         }
                     }
diff --git a/selene-lib/src/lints.rs b/selene-lib/src/lints.rs
index 45578caa..1189071d 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,
@@ -97,6 +118,7 @@ pub struct Diagnostic {
     pub primary_label: Label,
     pub secondary_labels: Vec<Label>,
     pub fixed_code: Option<String>,
+    pub applicability: Applicability,
 }
 
 impl Diagnostic {
@@ -105,12 +127,14 @@ impl Diagnostic {
         message: String,
         primary_label: Label,
         fixed_code: Option<String>,
+        applicability: Applicability,
     ) -> Self {
         Self {
             code,
             message,
             primary_label,
             fixed_code,
+            applicability,
 
             notes: Vec::new(),
             secondary_labels: Vec::new(),
@@ -124,6 +148,7 @@ impl Diagnostic {
         notes: Vec<String>,
         secondary_labels: Vec<Label>,
         fixed_code: Option<String>,
+        applicability: Applicability,
     ) -> Self {
         Self {
             code,
@@ -132,6 +157,7 @@ impl Diagnostic {
             primary_label,
             secondary_labels,
             fixed_code,
+            applicability,
         }
     }
 
diff --git a/selene-lib/src/lints/almost_swapped.rs b/selene-lib/src/lints/almost_swapped.rs
index 3376d9b4..10c81372 100644
--- a/selene-lib/src/lints/almost_swapped.rs
+++ b/selene-lib/src/lints/almost_swapped.rs
@@ -46,6 +46,7 @@ impl Lint for AlmostSwappedLint {
                     )],
                     Vec::new(),
                     None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/bad_string_escape.rs b/selene-lib/src/lints/bad_string_escape.rs
index 001f5c7e..55c8cae5 100644
--- a/selene-lib/src/lints/bad_string_escape.rs
+++ b/selene-lib/src/lints/bad_string_escape.rs
@@ -51,12 +51,14 @@ impl Lint for BadStringEscapeLint {
                     "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",
@@ -68,6 +70,7 @@ impl Lint for BadStringEscapeLint {
                     ],
                     Vec::new(),
                     None,
+                    Applicability::Unspecified,
                 ),
                 ReasonWhy::CodepointTooHigh => Diagnostic::new_complete(
                     "bad_string_escape",
@@ -79,6 +82,7 @@ impl Lint for BadStringEscapeLint {
                     ],
                     Vec::new(),
                     None,
+                    Applicability::Unspecified,
                 ),
                 ReasonWhy::DoubleInSingle => Diagnostic::new(
                     "bad_string_escape",
@@ -86,6 +90,7 @@ impl Lint for BadStringEscapeLint {
                         .to_owned(),
                     Label::new(sequence.range.to_owned()),
                     None,
+                    Applicability::Unspecified,
                 ),
                 ReasonWhy::SingleInDouble => Diagnostic::new(
                     "bad_string_escape",
@@ -93,6 +98,7 @@ impl Lint for BadStringEscapeLint {
                         .to_owned(),
                     Label::new(sequence.range.to_owned()),
                     None,
+                    Applicability::Unspecified,
                 ),
             })
             .collect()
diff --git a/selene-lib/src/lints/compare_nan.rs b/selene-lib/src/lints/compare_nan.rs
index cceda680..9b05cb2f 100644
--- a/selene-lib/src/lints/compare_nan.rs
+++ b/selene-lib/src/lints/compare_nan.rs
@@ -43,6 +43,7 @@ impl Lint for CompareNanLint {
                     vec![format!("try: `{}` instead", fixed_code.clone())],
                     Vec::new(),
                     Some(fixed_code),
+                    Applicability::MaybeIncorrect,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/constant_table_comparison.rs b/selene-lib/src/lints/constant_table_comparison.rs
index 112e9f5c..b19cb53a 100644
--- a/selene-lib/src/lints/constant_table_comparison.rs
+++ b/selene-lib/src/lints/constant_table_comparison.rs
@@ -60,6 +60,7 @@ impl Lint for ConstantTableComparisonLint {
                     },
                     Vec::new(),
                     None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/deprecated.rs b/selene-lib/src/lints/deprecated.rs
index 9a3343c7..95d01f38 100644
--- a/selene-lib/src/lints/deprecated.rs
+++ b/selene-lib/src/lints/deprecated.rs
@@ -132,6 +132,7 @@ impl<'a> DeprecatedVisitor<'a> {
                 notes,
                 Vec::new(),
                 fixed_code,
+                Applicability::MachineApplicable,
             ));
         }
     }
diff --git a/selene-lib/src/lints/divide_by_zero.rs b/selene-lib/src/lints/divide_by_zero.rs
index 50ce7c4a..65a81c9d 100644
--- a/selene-lib/src/lints/divide_by_zero.rs
+++ b/selene-lib/src/lints/divide_by_zero.rs
@@ -36,6 +36,7 @@ impl Lint for DivideByZeroLint {
                     "dividing by zero is not allowed, use math.huge instead".to_owned(),
                     Label::new(*position),
                     None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/duplicate_keys.rs b/selene-lib/src/lints/duplicate_keys.rs
index 5d161f81..015b3f3c 100644
--- a/selene-lib/src/lints/duplicate_keys.rs
+++ b/selene-lib/src/lints/duplicate_keys.rs
@@ -43,6 +43,7 @@ impl Lint for DuplicateKeysLint {
                         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 2f06add8..df59d5d7 100644
--- a/selene-lib/src/lints/empty_if.rs
+++ b/selene-lib/src/lints/empty_if.rs
@@ -64,6 +64,7 @@ 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 45aff668..d793059e 100644
--- a/selene-lib/src/lints/empty_loop.rs
+++ b/selene-lib/src/lints/empty_loop.rs
@@ -59,6 +59,7 @@ impl Lint for EmptyLoopLint {
                     "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 f35984cd..9d5158c1 100644
--- a/selene-lib/src/lints/global_usage.rs
+++ b/selene-lib/src/lints/global_usage.rs
@@ -77,6 +77,7 @@ impl Lint for GlobalLint {
                     ),
                     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 0dfa1a21..095f7930 100644
--- a/selene-lib/src/lints/high_cyclomatic_complexity.rs
+++ b/selene-lib/src/lints/high_cyclomatic_complexity.rs
@@ -59,6 +59,7 @@ impl Lint for HighCyclomaticComplexityLint {
                     ),
                     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 32fb3305..8486490f 100644
--- a/selene-lib/src/lints/if_same_then_else.rs
+++ b/selene-lib/src/lints/if_same_then_else.rs
@@ -42,6 +42,7 @@ impl Lint for IfSameThenElseLint {
                         "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 96aafc0d..dd40bb0d 100644
--- a/selene-lib/src/lints/ifs_same_cond.rs
+++ b/selene-lib/src/lints/ifs_same_cond.rs
@@ -42,6 +42,7 @@ impl Lint for IfsSameCondLint {
                         "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 2af4dbba..f2dc5e16 100644
--- a/selene-lib/src/lints/manual_table_clone.rs
+++ b/selene-lib/src/lints/manual_table_clone.rs
@@ -85,6 +85,7 @@ impl ManualTableCloneMatch {
                 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 2efdc13d..43ccd8f7 100644
--- a/selene-lib/src/lints/mismatched_arg_count.rs
+++ b/selene-lib/src/lints/mismatched_arg_count.rs
@@ -73,6 +73,7 @@ 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 2ce691cb..d53b065c 100644
--- a/selene-lib/src/lints/mixed_table.rs
+++ b/selene-lib/src/lints/mixed_table.rs
@@ -35,6 +35,7 @@ impl Lint for MixedTableLint {
                 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 8d319b67..858bd3bf 100644
--- a/selene-lib/src/lints/multiple_statements.rs
+++ b/selene-lib/src/lints/multiple_statements.rs
@@ -54,6 +54,7 @@ impl Lint for MultipleStatementsLint {
                     "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 01c1bff0..5a01f19e 100644
--- a/selene-lib/src/lints/must_use.rs
+++ b/selene-lib/src/lints/must_use.rs
@@ -49,6 +49,7 @@ impl Lint for MustUseLint {
                 ),
                 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 8eb87aef..f8fae46f 100644
--- a/selene-lib/src/lints/parenthese_conditions.rs
+++ b/selene-lib/src/lints/parenthese_conditions.rs
@@ -36,6 +36,7 @@ impl Lint for ParentheseConditionsLint {
                     "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 de4e02d7..8e82c35b 100644
--- a/selene-lib/src/lints/roblox_incorrect_color3_new_bounds.rs
+++ b/selene-lib/src/lints/roblox_incorrect_color3_new_bounds.rs
@@ -40,6 +40,7 @@ impl Lint for Color3BoundsLint {
                     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 a4118fbc..6aae7cb1 100644
--- a/selene-lib/src/lints/roblox_incorrect_roact_usage.rs
+++ b/selene-lib/src/lints/roblox_incorrect_roact_usage.rs
@@ -94,6 +94,7 @@ impl Lint for IncorrectRoactUsageLint {
                 ),
                 Label::new(invalid_event.range),
                 None,
+                Applicability::Unspecified,
             ));
         }
 
@@ -114,6 +115,7 @@ impl Lint for IncorrectRoactUsageLint {
                         )],
                         Vec::new(),
                         None,
+                        Applicability::Unspecified,
                     ));
                 }
                 _ => {
@@ -125,6 +127,7 @@ impl Lint for IncorrectRoactUsageLint {
                         ),
                         Label::new(invalid_property.range),
                         None,
+                        Applicability::Unspecified,
                     ));
                 }
             }
@@ -136,6 +139,7 @@ impl Lint for IncorrectRoactUsageLint {
                 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 3ed4d865..59f801c1 100644
--- a/selene-lib/src/lints/roblox_suspicious_udim2_new.rs
+++ b/selene-lib/src/lints/roblox_suspicious_udim2_new.rs
@@ -35,9 +35,16 @@ fn create_diagnostic(mismatch: &MismatchedArgCount) -> Diagnostic {
             .to_owned()],
             Vec::new(),
             None,
+            Applicability::Unspecified,
         )
     } else {
-        Diagnostic::new(code, message, primary_label, None)
+        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 06fd7add..f9fe160a 100644
--- a/selene-lib/src/lints/shadowing.rs
+++ b/selene-lib/src/lints/shadowing.rs
@@ -70,6 +70,7 @@ impl Lint for ShadowingLint {
                         "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 539b42eb..c1b3e405 100644
--- a/selene-lib/src/lints/standard_library.rs
+++ b/selene-lib/src/lints/standard_library.rs
@@ -253,6 +253,7 @@ impl StandardLibraryVisitor<'_> {
                 ),
                 Vec::new(),
                 None,
+                Applicability::Unspecified,
             ));
         }
     }
@@ -312,6 +313,7 @@ impl Visitor for StandardLibraryVisitor<'_> {
                                     Vec::new(),
                                     Vec::new(),
                                     None,
+                                    Applicability::Unspecified,
                                 ));
                             }
 
@@ -350,6 +352,7 @@ impl Visitor for StandardLibraryVisitor<'_> {
                             Vec::new(),
                             Vec::new(),
                             None,
+                            Applicability::Unspecified,
                         ));
                     }
                 }
@@ -431,6 +434,7 @@ impl Visitor for StandardLibraryVisitor<'_> {
                     ),
                     Label::from_node(call, None),
                     None,
+                    Applicability::Unspecified,
                 ));
 
                 return;
@@ -477,6 +481,7 @@ impl Visitor for StandardLibraryVisitor<'_> {
                 )],
                 Vec::new(),
                 None,
+                Applicability::Unspecified,
             ));
 
             return;
@@ -558,6 +563,7 @@ impl Visitor for StandardLibraryVisitor<'_> {
                             message.iter().cloned().collect(),
                             Vec::new(),
                             None,
+                            Applicability::Unspecified,
                         ));
                     }
 
@@ -596,6 +602,7 @@ impl Visitor for StandardLibraryVisitor<'_> {
                 required_param_message,
                 Vec::new(),
                 None,
+                Applicability::Unspecified,
             ));
         }
 
@@ -631,6 +638,7 @@ impl Visitor for StandardLibraryVisitor<'_> {
                             ),
                         ),
                         None,
+                        Applicability::Unspecified,
                     ));
                 }
             }
diff --git a/selene-lib/src/lints/suspicious_reverse_loop.rs b/selene-lib/src/lints/suspicious_reverse_loop.rs
index dddaf990..4b070970 100644
--- a/selene-lib/src/lints/suspicious_reverse_loop.rs
+++ b/selene-lib/src/lints/suspicious_reverse_loop.rs
@@ -38,6 +38,7 @@ impl Lint for SuspiciousReverseLoopLint {
                     vec!["help: try adding `, -1` after `1`".to_owned()],
                     Vec::new(),
                     None,
+                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/type_check_inside_call.rs b/selene-lib/src/lints/type_check_inside_call.rs
index f9b5cba3..f06fad59 100644
--- a/selene-lib/src/lints/type_check_inside_call.rs
+++ b/selene-lib/src/lints/type_check_inside_call.rs
@@ -39,6 +39,7 @@ impl Lint for TypeCheckInsideCallLint {
                     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 15d42389..68d31f3d 100644
--- a/selene-lib/src/lints/unbalanced_assignments.rs
+++ b/selene-lib/src/lints/unbalanced_assignments.rs
@@ -38,6 +38,7 @@ impl Lint for UnbalancedAssignmentsLint {
                         "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 {
@@ -58,6 +59,7 @@ impl Lint for UnbalancedAssignmentsLint {
                         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 ec42467f..225465f7 100644
--- a/selene-lib/src/lints/undefined_variable.rs
+++ b/selene-lib/src/lints/undefined_variable.rs
@@ -49,6 +49,7 @@ impl Lint for UndefinedVariableLint {
                     ),
                     Vec::new(),
                     None,
+                    Applicability::Unspecified,
                 ));
             }
         }
diff --git a/selene-lib/src/lints/unscoped_variables.rs b/selene-lib/src/lints/unscoped_variables.rs
index 5c8f4bae..ccf83125 100644
--- a/selene-lib/src/lints/unscoped_variables.rs
+++ b/selene-lib/src/lints/unscoped_variables.rs
@@ -61,6 +61,7 @@ impl Lint for UnscopedVariablesLint {
                     ),
                     Label::new(reference.identifier),
                     None,
+                    Applicability::Unspecified,
                 ));
             }
         }
diff --git a/selene-lib/src/lints/unused_variable.rs b/selene-lib/src/lints/unused_variable.rs
index 9e3b1f0a..067c48ff 100644
--- a/selene-lib/src/lints/unused_variable.rs
+++ b/selene-lib/src/lints/unused_variable.rs
@@ -206,6 +206,7 @@ impl Lint for UnusedVariableLint {
                         })
                         .collect(),
                     fixed_code,
+                    Applicability::MachineApplicable,
                 ));
             };
         }
diff --git a/selene/src/main.rs b/selene/src/main.rs
index d64eeda8..ea5828f6 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -17,7 +17,7 @@ use codespan_reporting::{
     term::DisplayStyle as CodespanDisplayStyle,
 };
 use selene_lib::{
-    lints::{Diagnostic, Severity},
+    lints::{Applicability, Diagnostic, Severity},
     *,
 };
 use structopt::{clap, StructOpt};
@@ -349,21 +349,27 @@ fn read<R: Read>(
     if is_fix {
         let num_fixes = diagnostics
             .iter()
-            .filter(|diagnostic| diagnostic.diagnostic.fixed_code.is_some())
+            .filter(|diagnostic| {
+                diagnostic.diagnostic.fixed_code.is_some()
+                    && diagnostic.diagnostic.applicability == Applicability::MachineApplicable
+            })
             .count();
 
         // To handle potential conflicts with different lint suggestions, we apply conflicting fixes one at a time.
         // Then we re-evaluate the lints with the new code until there are no more fixes to apply
-        while diagnostics
-            .iter()
-            .any(|diagnostic| diagnostic.diagnostic.fixed_code.is_some())
-        {
+        while diagnostics.iter().any(|diagnostic| {
+            diagnostic.diagnostic.fixed_code.is_some()
+                && diagnostic.diagnostic.applicability == Applicability::MachineApplicable
+        }) {
             fixed_code = apply_diagnostics_fixes(
                 fixed_code.as_str(),
                 &diagnostics
                     .iter()
                     .map(|diagnostic| &diagnostic.diagnostic)
-                    .filter(|diagnostic| diagnostic.fixed_code.is_some())
+                    .filter(|diagnostic| {
+                        diagnostic.fixed_code.is_some()
+                            && diagnostic.applicability == Applicability::MachineApplicable
+                    })
                     .collect::<Vec<_>>(),
             );
 

From c8d19198d3c55b0eb1d79e7cbb64a7e4efb0a1d9 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sun, 15 Oct 2023 14:58:16 -0700
Subject: [PATCH 28/63] Standardize try message for code suggestion

---
 selene-lib/src/lints.rs                       |  8 ++-
 selene-lib/src/lints/almost_swapped.rs        | 14 +++---
 selene-lib/src/lints/compare_nan.rs           |  4 +-
 .../src/lints/constant_table_comparison.rs    | 50 ++++++++++---------
 selene-lib/src/lints/standard_library.rs      | 12 ++---
 selene-lib/src/lints/test_util.rs             | 41 ++++++++-------
 .../almost_swapped/almost_swapped.fixed.diff  | 16 ++++++
 .../lints/almost_swapped/panic.fixed.diff     |  1 +
 .../lints/compare_nan/compare_nan_if.stderr   |  4 +-
 .../compare_nan/compare_nan_variables.stderr  |  4 +-
 .../constant_table_comparison.fixed.diff      | 20 ++++++++
 .../old_roblox_std.fixed.diff                 |  1 +
 .../lints/standard_library/any.fixed.diff     |  6 +++
 .../lints/standard_library/assert.fixed.diff  |  9 ++++
 .../bad_call_signatures.fixed.diff            | 20 ++++++++
 .../callable_metatables.fixed.diff            |  2 +
 .../lints/standard_library/complex.fixed.diff |  3 ++
 .../standard_library/constants.fixed.diff     |  9 ++++
 .../if_expressions.fixed.diff                 |  5 ++
 .../lints/standard_library/lua52.fixed.diff   |  2 +
 .../standard_library/math_on_types.fixed.diff |  2 +
 .../standard_library/method_call.fixed.diff   |  4 ++
 .../lints/standard_library/method_call.stderr |  2 +-
 .../standard_library/required.fixed.diff      | 11 ++++
 .../standard_library/shadowing.fixed.diff     | 11 ++++
 .../string_interpolation.fixed.diff           |  7 +++
 .../lints/standard_library/ternary.fixed.diff |  3 ++
 .../unknown_property.fixed.diff               |  9 ++++
 .../unpack_function_arguments.fixed.diff      | 12 +++++
 .../lints/standard_library/vararg.fixed.diff  |  3 ++
 .../standard_library/wildcard.fixed.diff      | 12 +++++
 .../wildcard_structs.fixed.diff               |  6 +++
 .../lints/standard_library/writing.fixed.diff |  6 +++
 33 files changed, 255 insertions(+), 64 deletions(-)
 create mode 100644 selene-lib/tests/lints/almost_swapped/almost_swapped.fixed.diff
 create mode 100644 selene-lib/tests/lints/almost_swapped/panic.fixed.diff
 create mode 100644 selene-lib/tests/lints/constant_table_comparison/constant_table_comparison.fixed.diff
 create mode 100644 selene-lib/tests/lints/roblox_incorrect_roact_usage/old_roblox_std.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/any.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/assert.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/bad_call_signatures.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/callable_metatables.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/complex.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/constants.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/if_expressions.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/lua52.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/math_on_types.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/method_call.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/required.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/shadowing.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/string_interpolation.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/ternary.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/unknown_property.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/unpack_function_arguments.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/vararg.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/wildcard.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/wildcard_structs.fixed.diff
 create mode 100644 selene-lib/tests/lints/standard_library/writing.fixed.diff

diff --git a/selene-lib/src/lints.rs b/selene-lib/src/lints.rs
index 1189071d..3949dbdd 100644
--- a/selene-lib/src/lints.rs
+++ b/selene-lib/src/lints.rs
@@ -129,14 +129,20 @@ impl Diagnostic {
         fixed_code: Option<String>,
         applicability: Applicability,
     ) -> Self {
+        let notes = if let Some(ref fixed_code_str) = fixed_code {
+            vec![format!("try: `{}`", fixed_code_str)]
+        } else {
+            Vec::new()
+        };
+
         Self {
             code,
             message,
             primary_label,
             fixed_code,
             applicability,
+            notes,
 
-            notes: Vec::new(),
             secondary_labels: Vec::new(),
         }
     }
diff --git a/selene-lib/src/lints/almost_swapped.rs b/selene-lib/src/lints/almost_swapped.rs
index 10c81372..7ed9eb91 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,14 +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(),
-                    None,
-                    Applicability::Unspecified,
+                    )),
+                    // FIXME: Ideally `MaybeIncorrect`, but cannot because the end range of swapping `t[1]` and `t[2]`
+                    // doesn't include the closing `]`
+                    Applicability::HasPlaceholders,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/compare_nan.rs b/selene-lib/src/lints/compare_nan.rs
index 9b05cb2f..56527a78 100644
--- a/selene-lib/src/lints/compare_nan.rs
+++ b/selene-lib/src/lints/compare_nan.rs
@@ -36,12 +36,10 @@ impl Lint for CompareNanLint {
                     operator = comparisons.operator,
                 );
 
-                Diagnostic::new_complete(
+                Diagnostic::new(
                     "compare_nan",
                     "comparing things to nan directly is not allowed".to_owned(),
                     Label::new(comparisons.range),
-                    vec![format!("try: `{}` instead", fixed_code.clone())],
-                    Vec::new(),
                     Some(fixed_code),
                     Applicability::MaybeIncorrect,
                 )
diff --git a/selene-lib/src/lints/constant_table_comparison.rs b/selene-lib/src/lints/constant_table_comparison.rs
index b19cb53a..356c84b8 100644
--- a/selene-lib/src/lints/constant_table_comparison.rs
+++ b/selene-lib/src/lints/constant_table_comparison.rs
@@ -32,35 +32,37 @@ 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(_) => "~=",
-                            }
-                        )]
+                    suggestion.clone(),
+                    if suggestion.is_some() {
+                        Applicability::MaybeIncorrect
                     } else {
-                        Vec::new()
+                        Applicability::Unspecified
                     },
-                    Vec::new(),
-                    None,
-                    Applicability::Unspecified,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/standard_library.rs b/selene-lib/src/lints/standard_library.rs
index c1b3e405..2a0795e8 100644
--- a/selene-lib/src/lints/standard_library.rs
+++ b/selene-lib/src/lints/standard_library.rs
@@ -463,7 +463,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,15 +473,13 @@ impl Visitor for StandardLibraryVisitor<'_> {
                     problem,
                 ),
                 Label::from_node(call, None),
-                vec![format!(
-                    "try: {}{}{}(...)",
+                Some(format!(
+                    "{}{}{}(...)",
                     name_path.join("."),
                     use_instead,
                     name
-                )],
-                Vec::new(),
-                None,
-                Applicability::Unspecified,
+                )),
+                Applicability::HasPlaceholders,
             ));
 
             return;
diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index 4cd6e8d7..0000da1b 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -1,4 +1,4 @@
-use super::{AstContext, Context, Diagnostic, Lint};
+use super::{Applicability, AstContext, Context, Diagnostic, Lint};
 use crate::{
     test_util::{get_standard_library, PrettyString},
     StandardLibrary,
@@ -48,7 +48,7 @@ fn replace_code_range(code: &str, start: usize, end: usize, replacement: &str) -
 /// 1. Applies all disjoint fixes
 /// 1. If a fix is completely contained inside another fix, uses the inner one and discard the outer one
 /// 2. If fixes partially overlap, chooses the fix that starts first and discard the other one
-fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<&Diagnostic>) -> String {
+fn apply_diagnostics_fixes(code: &str, diagnostics: &[&Diagnostic]) -> String {
     let mut chosen_diagnostics = Vec::new();
 
     let mut candidate = diagnostics[0];
@@ -77,9 +77,9 @@ fn apply_diagnostics_fixes(code: &str, diagnostics: &Vec<&Diagnostic>) -> String
                 let (start, end) = diagnostic.primary_label.range;
                 let new_code = replace_code_range(
                     code.as_str(),
-                    (start as isize + bytes_offset as isize) as usize,
-                    (end as isize + bytes_offset as isize) as usize,
-                    &fixed.as_str(),
+                    (start as isize + bytes_offset) as usize,
+                    (end as isize + bytes_offset) as usize,
+                    fixed.as_str(),
                 );
 
                 bytes_offset += fixed.len() as isize - (end - start) as isize;
@@ -148,25 +148,32 @@ pub fn test_lint_config_with_output<
     let mut fixed_code = lua_source.to_string();
     let mut fixed_diagnostics = diagnostics
         .iter()
-        .filter(|diagnostic| diagnostic.fixed_code.is_some())
+        .filter(|diagnostic| {
+            diagnostic.fixed_code.is_some()
+                && (diagnostic.applicability == Applicability::MachineApplicable
+                    || diagnostic.applicability == Applicability::MaybeIncorrect)
+        })
         .collect::<Vec<_>>();
     let mut lint_results;
 
     // To handle potential conflicts with different lint suggestions, we apply conflicting fixes one at a time.
     // Then we re-evaluate the lints with the new code until there are no more fixes to apply
-    while fixed_diagnostics
-        .iter()
-        .any(|diagnostic| diagnostic.fixed_code.is_some())
-    {
+    while fixed_diagnostics.iter().any(|diagnostic| {
+        diagnostic.fixed_code.is_some()
+            && (diagnostic.applicability == Applicability::MachineApplicable
+                || diagnostic.applicability == Applicability::MaybeIncorrect)
+    }) {
         fixed_code = apply_diagnostics_fixes(fixed_code.as_str(), &fixed_diagnostics);
 
-        let fixed_ast = full_moon::parse(&fixed_code).expect(&format!(
-            "Fixer generated invalid code:\n\
-            ----------------\n\
-            {}\n\
-            ----------------\n",
-            fixed_code
-        ));
+        let fixed_ast = full_moon::parse(&fixed_code).unwrap_or_else(|_| {
+            panic!(
+                "Fixer generated invalid code:\n\
+                ----------------\n\
+                {}\n\
+                ----------------\n",
+                fixed_code
+            )
+        });
         lint_results = lint.pass(
             &fixed_ast,
             &context,
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..fb054179
--- /dev/null
+++ b/selene-lib/tests/lints/almost_swapped/almost_swapped.fixed.diff
@@ -0,0 +1,16 @@
+ x, y = y, x
+ 
+ a = b
+ b = a
+ 
+ t[1], t[2] = t[2], t[1]
+ 
+ t[1] = t[2]
+ t[2] = t[1]
+ 
+ foo().a = foo().b
+ foo().b = foo().a
+ 
+ -- We use a weird hack so this comment might break something, oh no!
+ 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..1c06c479
--- /dev/null
+++ b/selene-lib/tests/lints/almost_swapped/panic.fixed.diff
@@ -0,0 +1 @@
+ foo = "bar"
\ 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..34d34c6f 100644
--- a/selene-lib/tests/lints/compare_nan/compare_nan_if.stderr
+++ b/selene-lib/tests/lints/compare_nan/compare_nan_if.stderr
@@ -4,7 +4,7 @@ error[compare_nan]: comparing things to nan directly is not allowed
 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
@@ -12,5 +12,5 @@ error[compare_nan]: comparing things to nan directly is not allowed
 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.stderr b/selene-lib/tests/lints/compare_nan/compare_nan_variables.stderr
index 0aca91c0..776c66bb 100644
--- a/selene-lib/tests/lints/compare_nan/compare_nan_variables.stderr
+++ b/selene-lib/tests/lints/compare_nan/compare_nan_variables.stderr
@@ -4,7 +4,7 @@ error[compare_nan]: comparing things to nan directly is not allowed
 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
@@ -12,5 +12,5 @@ error[compare_nan]: comparing things to nan directly is not allowed
 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..b1004f99
--- /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)
+ 
+-print(x == {})
+-print({} == x)
+-print(x ~= {})
+-print({} ~= x)
++print(next(x) == nil)
++print(next(x) == nil)
++print(next(x) ~= nil)
++print(next(x) ~= nil)
+ 
+ print({ "a", "b", "c" } == { "a", "b", "c" })
+ print({ "a", "b", "c" } == {})
+ print({} == {})
+ 
+ print( -- my cool table
+-	t == {}
++	next(t) == nil
+ )
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..58f63e35
--- /dev/null
+++ b/selene-lib/tests/lints/roblox_incorrect_roact_usage/old_roblox_std.fixed.diff
@@ -0,0 +1 @@
+ Roact.createElement("Frame")
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..06562162
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/any.fixed.diff
@@ -0,0 +1,6 @@
+ print(foo)
+ print(foo.x)
+ print(foo.x.y.z)
+ print(foo:x())
+ foo.x = 1
+ foo.x.y = 2
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..fbbdbff8
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/assert.fixed.diff
@@ -0,0 +1,9 @@
+ assert(true, "message")
+ assert(call())
+ assert(call(), "this is ok")
+ assert(...)
+ 
+ assert(true)
+ assert(true, "message", call())
+ assert(true, "message", ...)
+ assert()
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..54b6bf98
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/bad_call_signatures.fixed.diff
@@ -0,0 +1,20 @@
+ print()
+ print("a", 2, "c")
+ math.sin(3)
+ math.sin(1 + 1)
+ math.random()
+ math.random(1)
+ print "hello"
+ --
+ math.sin("i'd like the sine of three, please")
+ math.floor(3.5, "remember to make sure it's 3 :)")
+ math.sin "pi"
+ --
+ local variable = 3
+ math.sin(variable)
+ math.sin(variable, variable)
+ --
+ math.max(2)
+ math.pi()
+ string.format(-2, "foo")
+ string.format(1 + 1)
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..5e87e357
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/callable_metatables.fixed.diff
@@ -0,0 +1,2 @@
+ expect.extend({})
+ expect(1).to.be.ok()
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..061e23c9
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/complex.fixed.diff
@@ -0,0 +1,3 @@
+ print(require("foo").bar)
+ print(coroutine.wrap(print)())
+ getmetatable({}).__index = function() end
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..1c730fc6
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/constants.fixed.diff
@@ -0,0 +1,9 @@
+ collectgarbage("count")
+ collectgarbage "count"
+ 
+ collectgarbage("doge")
+ collectgarbage(1)
+ 
+ collectgarbage("coun" .. "t")
+ 
+ collectgarbage()
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..7a9eed3d
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/if_expressions.fixed.diff
@@ -0,0 +1,5 @@
+ math.floor(if x then 1 else 2)
+ math.floor(if x then "a" else "b")
+ 
+ -- TODO: Let's try to capture this, right now the entire expression just resolves to no type
+ math.floor(if x then 1 else "a")
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..c48a08c3
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/lua52.fixed.diff
@@ -0,0 +1,2 @@
+ table.unpack({})
+ setfenv() -- This would error if it was defined, since setfenv requires an argument
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..e64677c8
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/math_on_types.fixed.diff
@@ -0,0 +1,2 @@
+ usesType(x * 0.5)
+ usesType(0.5 * x)
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..3612cd65
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/method_call.fixed.diff
@@ -0,0 +1,4 @@
+ foo:bar(1)
+ foo:bar("a")
+ foo.bar()
+ foo:baz()
diff --git a/selene-lib/tests/lints/standard_library/method_call.stderr b/selene-lib/tests/lints/standard_library/method_call.stderr
index fdbe503e..804b2f80 100644
--- a/selene-lib/tests/lints/standard_library/method_call.stderr
+++ b/selene-lib/tests/lints/standard_library/method_call.stderr
@@ -10,7 +10,7 @@ error[incorrect_standard_library_use]: standard library function `foo.bar` is a
 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..b11db297
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/required.fixed.diff
@@ -0,0 +1,11 @@
+ -- ipairs requires an argument--this should fail.
+ ipairs()
+ 
+ -- setmetatable requires a first argument, but not a second one. this should still fail.
+ setmetatable()
+ 
+ -- This, however, should not.
+ setmetatable({})
+ 
+ -- nil counts as filling in an unrequired argument.
+ setmetatable({}, nil)
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..d8219f6c
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/shadowing.fixed.diff
@@ -0,0 +1,11 @@
+ local math = {}
+ math.dog = 1
+ math.sin = print
+ 
+ math.sin("hi" + math.dog)
+ 
+ function foo(table)
+     table.insert()
+ end
+ 
+ table.insert()
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..8e566826
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/string_interpolation.fixed.diff
@@ -0,0 +1,7 @@
+ collectgarbage(`count`)
+ collectgarbage(`ohno`)
+ 
+ string.upper(`foo`)
+ string.upper(`foo{"bar"}`)
+ 
+ math.floor(`oh no`)
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..aec00402
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/ternary.fixed.diff
@@ -0,0 +1,3 @@
+ math.floor(r > 1 and 1 or 0)
+ math.floor(r > 1 + 1)
+ math.floor(not flag and 1 or 0)
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..1e58a8ea
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/unknown_property.fixed.diff
@@ -0,0 +1,9 @@
+ print("3.14 = ", math.pie)
+ print(print.foo)
+ print(math.huge.big)
+ math.call()
+ 
+ -- These aren't correct, but they should be covered under a different lint
+ call()
+ local _ = bad
+ print(foo.bar)
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..1bbff94f
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/unpack_function_arguments.fixed.diff
@@ -0,0 +1,12 @@
+ -- Since functions can pass multiple parameters through a function if they're the last ones to be called,
+ -- selene needs to be able to recognize this and not error.
+ 
+ -- This should not lint, since `unpack(stuff)` could pass in multiple parameters.
+ math.max(unpack(stuff))
+ 
+ -- This should lint, since functions only pass multiple parameters if they are the last argument.
+ -- debug.setlocal is used because it takes three required parameters.
+ debug.setlocal(unpack(stuff), 2)
+ 
+ -- This is still wrong since it has too many parameters.
+ string.upper("text", unpack(stuff))
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..c31aa369
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/vararg.fixed.diff
@@ -0,0 +1,3 @@
+ return function(...)
+     table.insert(...)
+ end
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..5b5d9bc1
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/wildcard.fixed.diff
@@ -0,0 +1,12 @@
+ script.ClassName = 3
+ 
+ script.Name = "Script"
+ script.Name.UhOh = "Oops"
+ 
+ script.Child = "Oops"
+ script.Child.Name = "Okay"
+ 
+ script.Child.Grandchild.Name = "Okay"
+ 
+ print(x.y.z)
+ print(x.y.fail)
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..d56adb03
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/wildcard_structs.fixed.diff
@@ -0,0 +1,6 @@
+ script.Name = "Okay"
+ script.Child = "Oops"
+ script.Child.Name = "Okay"
+ script.Child.Name.UhOh = "Oops"
+ script.Child.Grandchild = "Oops"
+ script.Child.Grandchild.Name = "Okay"
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..883e4744
--- /dev/null
+++ b/selene-lib/tests/lints/standard_library/writing.fixed.diff
@@ -0,0 +1,6 @@
+ _G.foo = true
+ print(_G.foo)
+ _G = {}
+ 
+ math.pi = 3
+ math.foo = 4

From 4c10d3e22d76db21121b52bb23e32f29db39b132 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sun, 15 Oct 2023 15:23:41 -0700
Subject: [PATCH 29/63] Remove diff code when there are no changes

---
 selene-lib/src/lints/test_util.rs             | 18 ++++++--
 .../almost_swapped/almost_swapped.fixed.diff  | 16 -------
 .../lints/almost_swapped/panic.fixed.diff     |  1 -
 .../lua51_string_escapes.fixed.diff           |  0
 .../roblox_string_escapes.fixed.diff          |  0
 .../deprecated/deprecated_fields.fixed.diff   |  3 --
 .../deprecated/specific_allow.fixed.diff      |  7 ---
 .../toml_forwards_compatibility.fixed.diff    |  2 -
 .../divide_by_zero/divide_by_zero.fixed.diff  |  0
 .../duplicate_keys/duplicate_keys.fixed.diff  |  0
 .../duplicate_keys/number_indices.fixed.diff  |  0
 .../tests/lints/empty_if/empty_if.fixed.diff  |  0
 .../empty_if/empty_if_comments.fixed.diff     |  0
 .../tests/lints/empty_loop/empty_loop.stderr  | 18 ++++++++
 .../empty_loop/empty_loop_comments.stderr     | 14 ++++++
 .../global_usage/global_usage.fixed.diff      |  0
 .../global_usage_ignore.fixed.diff            |  0
 .../complex_var_expressions.fixed.diff        |  0
 .../high_cyclomatic_complexity.fixed.diff     |  0
 .../lua51_basic_complexity.fixed.diff         |  0
 .../if_same_then_else.fixed.diff              |  0
 .../ifs_same_cond/ifs_same_cond.fixed.diff    |  0
 .../false_positive.fixed.diff                 |  0
 .../manual_table_clone.fixed.diff             |  0
 ...alternative_function_definition.fixed.diff |  0
 .../call_side_effects.fixed.diff              |  0
 .../definition_location.fixed.diff            |  0
 .../mismatched_arg_count.fixed.diff           |  0
 .../multiple_definition_locations.fixed.diff  |  0
 .../reassigned_variables.fixed.diff           |  0
 .../reassigned_variables_2.fixed.diff         |  0
 .../shadowing_variables.fixed.diff            |  0
 .../variable_function_def.fixed.diff          |  0
 .../lints/mixed_table/mixed_table.fixed.diff  |  0
 .../multiple_statements.fixed.diff            |  0
 .../one_line_if_allow.fixed.diff              |  0
 .../one_line_if_break_return_only.fixed.diff  |  0
 .../one_line_if_deny.fixed.diff               |  0
 .../tests/lints/must_use/must_use.fixed.diff  |  0
 .../parenthese_conditions.stderr              | 16 +++++++
 ...lox_incorrect_color3_new_bounds.fixed.diff |  0
 .../mixed_roact_react_usage.fixed.diff        |  0
 .../old_roblox_std.fixed.diff                 |  1 -
 .../roblox_incorrect_react_usage.fixed.diff   |  0
 .../roblox_incorrect_roact_usage.fixed.diff   |  0
 .../roblox_suspicious_udim2_new.fixed.diff    |  0
 .../lints/shadowing/empty_else.fixed.diff     |  0
 .../lints/shadowing/shadowing.fixed.diff      |  0
 .../lints/standard_library/any.fixed.diff     |  6 ---
 .../lints/standard_library/assert.fixed.diff  |  9 ----
 .../bad_call_signatures.fixed.diff            | 20 --------
 .../callable_metatables.fixed.diff            |  2 -
 .../lints/standard_library/complex.fixed.diff |  3 --
 .../standard_library/constants.fixed.diff     |  9 ----
 .../if_expressions.fixed.diff                 |  5 --
 .../lints/standard_library/lua52.fixed.diff   |  2 -
 .../standard_library/math_on_types.fixed.diff |  2 -
 .../standard_library/method_call.fixed.diff   |  4 --
 .../standard_library/required.fixed.diff      | 11 -----
 .../standard_library/shadowing.fixed.diff     | 11 -----
 .../string_interpolation.fixed.diff           |  7 ---
 .../lints/standard_library/ternary.fixed.diff |  3 --
 .../unknown_property.fixed.diff               |  9 ----
 .../unpack_function_arguments.fixed.diff      | 12 -----
 .../lints/standard_library/vararg.fixed.diff  |  3 --
 .../standard_library/wildcard.fixed.diff      | 12 -----
 .../wildcard_structs.fixed.diff               |  6 ---
 .../lints/standard_library/writing.fixed.diff |  6 ---
 .../suspicious_reverse_loop.fixed.diff        |  0
 .../type_check_inside_call.fixed.diff         |  0
 .../unbalanced_assignments.fixed.diff         |  0
 .../lints/undefined_variable/basic.fixed.diff |  0
 .../compound_assignments.fixed.diff           |  0
 .../function_overriding.fixed.diff            |  0
 .../undefined_variable/hoisting.fixed.diff    |  0
 .../lints/undefined_variable/self.fixed.diff  |  0
 .../undefined_variable/shadowing.fixed.diff   |  0
 .../string_interpolation.fixed.diff           |  0
 .../undefined_variable/varargs.fixed.diff     |  0
 .../function_overriding.fixed.diff            |  0
 .../unscoped_variables.fixed.diff             |  0
 .../function_overriding.fixed.diff            |  1 -
 .../generic_for_shadowing.fixed.diff          |  5 --
 .../lints/unused_variable/ignore.fixed.diff   |  1 -
 .../mutating_functions.fixed.diff             |  3 --
 .../lints/unused_variable/observes.fixed.diff | 46 -------------------
 .../lints/unused_variable/self.fixed.diff     |  6 ---
 .../unused_variable/self_ignored.fixed.diff   |  5 --
 .../unused_variable/shadowing.fixed.diff      | 11 -----
 .../unused_variable/write_only.fixed.diff     | 17 -------
 90 files changed, 63 insertions(+), 270 deletions(-)
 create mode 100644 selene-lib/tests/lints/bad_string_escape/lua51_string_escapes.fixed.diff
 create mode 100644 selene-lib/tests/lints/bad_string_escape/roblox_string_escapes.fixed.diff
 create mode 100644 selene-lib/tests/lints/divide_by_zero/divide_by_zero.fixed.diff
 create mode 100644 selene-lib/tests/lints/duplicate_keys/duplicate_keys.fixed.diff
 create mode 100644 selene-lib/tests/lints/duplicate_keys/number_indices.fixed.diff
 create mode 100644 selene-lib/tests/lints/empty_if/empty_if.fixed.diff
 create mode 100644 selene-lib/tests/lints/empty_if/empty_if_comments.fixed.diff
 create mode 100644 selene-lib/tests/lints/global_usage/global_usage.fixed.diff
 create mode 100644 selene-lib/tests/lints/global_usage/global_usage_ignore.fixed.diff
 create mode 100644 selene-lib/tests/lints/high_cyclomatic_complexity/complex_var_expressions.fixed.diff
 create mode 100644 selene-lib/tests/lints/high_cyclomatic_complexity/high_cyclomatic_complexity.fixed.diff
 create mode 100644 selene-lib/tests/lints/high_cyclomatic_complexity/lua51_basic_complexity.fixed.diff
 create mode 100644 selene-lib/tests/lints/if_same_then_else/if_same_then_else.fixed.diff
 create mode 100644 selene-lib/tests/lints/ifs_same_cond/ifs_same_cond.fixed.diff
 create mode 100644 selene-lib/tests/lints/manual_table_clone/false_positive.fixed.diff
 create mode 100644 selene-lib/tests/lints/manual_table_clone/manual_table_clone.fixed.diff
 create mode 100644 selene-lib/tests/lints/mismatched_arg_count/alternative_function_definition.fixed.diff
 create mode 100644 selene-lib/tests/lints/mismatched_arg_count/call_side_effects.fixed.diff
 create mode 100644 selene-lib/tests/lints/mismatched_arg_count/definition_location.fixed.diff
 create mode 100644 selene-lib/tests/lints/mismatched_arg_count/mismatched_arg_count.fixed.diff
 create mode 100644 selene-lib/tests/lints/mismatched_arg_count/multiple_definition_locations.fixed.diff
 create mode 100644 selene-lib/tests/lints/mismatched_arg_count/reassigned_variables.fixed.diff
 create mode 100644 selene-lib/tests/lints/mismatched_arg_count/reassigned_variables_2.fixed.diff
 create mode 100644 selene-lib/tests/lints/mismatched_arg_count/shadowing_variables.fixed.diff
 create mode 100644 selene-lib/tests/lints/mismatched_arg_count/variable_function_def.fixed.diff
 create mode 100644 selene-lib/tests/lints/mixed_table/mixed_table.fixed.diff
 create mode 100644 selene-lib/tests/lints/multiple_statements/multiple_statements.fixed.diff
 create mode 100644 selene-lib/tests/lints/multiple_statements/one_line_if_allow.fixed.diff
 create mode 100644 selene-lib/tests/lints/multiple_statements/one_line_if_break_return_only.fixed.diff
 create mode 100644 selene-lib/tests/lints/multiple_statements/one_line_if_deny.fixed.diff
 create mode 100644 selene-lib/tests/lints/must_use/must_use.fixed.diff
 create mode 100644 selene-lib/tests/lints/roblox_incorrect_color3_new_bounds/roblox_incorrect_color3_new_bounds.fixed.diff
 create mode 100644 selene-lib/tests/lints/roblox_incorrect_roact_usage/mixed_roact_react_usage.fixed.diff
 create mode 100644 selene-lib/tests/lints/roblox_incorrect_roact_usage/roblox_incorrect_react_usage.fixed.diff
 create mode 100644 selene-lib/tests/lints/roblox_incorrect_roact_usage/roblox_incorrect_roact_usage.fixed.diff
 create mode 100644 selene-lib/tests/lints/roblox_suspicious_udim2_new/roblox_suspicious_udim2_new.fixed.diff
 create mode 100644 selene-lib/tests/lints/shadowing/empty_else.fixed.diff
 create mode 100644 selene-lib/tests/lints/shadowing/shadowing.fixed.diff
 create mode 100644 selene-lib/tests/lints/suspicious_reverse_loop/suspicious_reverse_loop.fixed.diff
 create mode 100644 selene-lib/tests/lints/type_check_inside_call/type_check_inside_call.fixed.diff
 create mode 100644 selene-lib/tests/lints/unbalanced_assignments/unbalanced_assignments.fixed.diff
 create mode 100644 selene-lib/tests/lints/undefined_variable/basic.fixed.diff
 create mode 100644 selene-lib/tests/lints/undefined_variable/compound_assignments.fixed.diff
 create mode 100644 selene-lib/tests/lints/undefined_variable/function_overriding.fixed.diff
 create mode 100644 selene-lib/tests/lints/undefined_variable/hoisting.fixed.diff
 create mode 100644 selene-lib/tests/lints/undefined_variable/self.fixed.diff
 create mode 100644 selene-lib/tests/lints/undefined_variable/shadowing.fixed.diff
 create mode 100644 selene-lib/tests/lints/undefined_variable/string_interpolation.fixed.diff
 create mode 100644 selene-lib/tests/lints/undefined_variable/varargs.fixed.diff
 create mode 100644 selene-lib/tests/lints/unscoped_variables/function_overriding.fixed.diff
 create mode 100644 selene-lib/tests/lints/unscoped_variables/unscoped_variables.fixed.diff

diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index 0000da1b..7a218994 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -92,19 +92,31 @@ fn apply_diagnostics_fixes(code: &str, diagnostics: &[&Diagnostic]) -> String {
     new_code
 }
 
+/// Returns empty string if there are no diffs
 fn generate_diff(source1: &str, source2: &str) -> String {
     let mut result = String::new();
+    let mut has_changes = false;
 
     for change in TextDiff::from_lines(source1, source2).iter_all_changes() {
         let sign = match change.tag() {
-            ChangeTag::Delete => "-",
-            ChangeTag::Insert => "+",
+            ChangeTag::Delete => {
+                has_changes = true;
+                "-"
+            }
+            ChangeTag::Insert => {
+                has_changes = true;
+                "+"
+            }
             ChangeTag::Equal => " ",
         };
         result.push_str(&format!("{}{}", sign, change.value()));
     }
 
-    result
+    if has_changes {
+        result
+    } else {
+        "".to_string()
+    }
 }
 
 pub fn test_lint_config_with_output<
diff --git a/selene-lib/tests/lints/almost_swapped/almost_swapped.fixed.diff b/selene-lib/tests/lints/almost_swapped/almost_swapped.fixed.diff
index fb054179..e69de29b 100644
--- a/selene-lib/tests/lints/almost_swapped/almost_swapped.fixed.diff
+++ b/selene-lib/tests/lints/almost_swapped/almost_swapped.fixed.diff
@@ -1,16 +0,0 @@
- x, y = y, x
- 
- a = b
- b = a
- 
- t[1], t[2] = t[2], t[1]
- 
- t[1] = t[2]
- t[2] = t[1]
- 
- foo().a = foo().b
- foo().b = foo().a
- 
- -- We use a weird hack so this comment might break something, oh no!
- 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
index 1c06c479..e69de29b 100644
--- a/selene-lib/tests/lints/almost_swapped/panic.fixed.diff
+++ b/selene-lib/tests/lints/almost_swapped/panic.fixed.diff
@@ -1 +0,0 @@
- foo = "bar"
\ No newline at end of file
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..e69de29b
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..e69de29b
diff --git a/selene-lib/tests/lints/deprecated/deprecated_fields.fixed.diff b/selene-lib/tests/lints/deprecated/deprecated_fields.fixed.diff
index 17b208a5..e69de29b 100644
--- a/selene-lib/tests/lints/deprecated/deprecated_fields.fixed.diff
+++ b/selene-lib/tests/lints/deprecated/deprecated_fields.fixed.diff
@@ -1,3 +0,0 @@
- local _ = this.is_deprecated
- local _ = all_of_this.is_deprecated
- local _ = all_of_this.even.deeper.is_deprecated
diff --git a/selene-lib/tests/lints/deprecated/specific_allow.fixed.diff b/selene-lib/tests/lints/deprecated/specific_allow.fixed.diff
index e25f2dd2..e69de29b 100644
--- a/selene-lib/tests/lints/deprecated/specific_allow.fixed.diff
+++ b/selene-lib/tests/lints/deprecated/specific_allow.fixed.diff
@@ -1,7 +0,0 @@
- deprecated_allowed()
- deprecated_blocked()
- 
- more.deprecated_allowed()
- wow.extra.deprecated_allowed()
- 
- deprecated_allowed.more()
diff --git a/selene-lib/tests/lints/deprecated/toml_forwards_compatibility.fixed.diff b/selene-lib/tests/lints/deprecated/toml_forwards_compatibility.fixed.diff
index 5b08ed21..e69de29b 100644
--- a/selene-lib/tests/lints/deprecated/toml_forwards_compatibility.fixed.diff
+++ b/selene-lib/tests/lints/deprecated/toml_forwards_compatibility.fixed.diff
@@ -1,2 +0,0 @@
- -- Tests that the old TOML format is unchanged
- print(this_is.deprecated)
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..e69de29b
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.stderr b/selene-lib/tests/lints/empty_loop/empty_loop.stderr
index de0edc12..183daa8f 100644
--- a/selene-lib/tests/lints/empty_loop/empty_loop.stderr
+++ b/selene-lib/tests/lints/empty_loop/empty_loop.stderr
@@ -5,6 +5,8 @@ error[empty_loop]: empty loop block
 10 │ │     -- Should warn
 11 │ │ end
    │ ╰───^
+   │  
+   = try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:13:1
@@ -15,6 +17,8 @@ error[empty_loop]: empty loop block
 16 │ │     ]]
 17 │ │ end
    │ ╰───^
+   │  
+   = try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:19:1
@@ -25,6 +29,8 @@ error[empty_loop]: empty loop block
 22 │ │     
 23 │ │ end
    │ ╰───^
+   │  
+   = try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:29:1
@@ -32,6 +38,8 @@ error[empty_loop]: empty loop block
 29 │ ╭ for _ in pairs({}) do
 30 │ │ end
    │ ╰───^
+   │  
+   = try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:36:1
@@ -39,6 +47,8 @@ error[empty_loop]: empty loop block
 36 │ ╭ for _ in ipairs({}) do
 37 │ │ end
    │ ╰───^
+   │  
+   = try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:43:1
@@ -46,6 +56,8 @@ error[empty_loop]: empty loop block
 43 │ ╭ for _ in {} do
 44 │ │ end
    │ ╰───^
+   │  
+   = try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:50:1
@@ -53,6 +65,8 @@ error[empty_loop]: empty loop block
 50 │ ╭ for _ in a() do
 51 │ │ end
    │ ╰───^
+   │  
+   = try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:57:1
@@ -60,6 +74,8 @@ error[empty_loop]: empty loop block
 57 │ ╭ while true do
 58 │ │ end
    │ ╰───^
+   │  
+   = try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:64:1
@@ -67,4 +83,6 @@ error[empty_loop]: empty loop block
 64 │ ╭ repeat
 65 │ │ until true
    │ ╰──────────^
+   │  
+   = try: ``
 
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..405eda83 100644
--- a/selene-lib/tests/lints/empty_loop/empty_loop_comments.stderr
+++ b/selene-lib/tests/lints/empty_loop/empty_loop_comments.stderr
@@ -7,6 +7,8 @@ error[empty_loop]: empty loop block
 22 │ │ 
 23 │ │ end
    │ ╰───^
+   │  
+   = try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:29:1
@@ -14,6 +16,8 @@ error[empty_loop]: empty loop block
 29 │ ╭ for _ in pairs({}) do
 30 │ │ end
    │ ╰───^
+   │  
+   = try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:36:1
@@ -21,6 +25,8 @@ error[empty_loop]: empty loop block
 36 │ ╭ for _ in ipairs({}) do
 37 │ │ end
    │ ╰───^
+   │  
+   = try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:43:1
@@ -28,6 +34,8 @@ error[empty_loop]: empty loop block
 43 │ ╭ for _ in {} do
 44 │ │ end
    │ ╰───^
+   │  
+   = try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:50:1
@@ -35,6 +43,8 @@ error[empty_loop]: empty loop block
 50 │ ╭ for _ in a() do
 51 │ │ end
    │ ╰───^
+   │  
+   = try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:57:1
@@ -42,6 +52,8 @@ error[empty_loop]: empty loop block
 57 │ ╭ while true do
 58 │ │ end
    │ ╰───^
+   │  
+   = try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:64:1
@@ -49,4 +61,6 @@ error[empty_loop]: empty loop block
 64 │ ╭ repeat
 65 │ │ until true
    │ ╰──────────^
+   │  
+   = try: ``
 
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.stderr b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.stderr
index 74913130..f42e84f6 100644
--- a/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.stderr
+++ b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.stderr
@@ -3,30 +3,40 @@ error[parenthese_conditions]: lua does not require parentheses around conditions
   │
 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
@@ -36,10 +46,16 @@ error[parenthese_conditions]: lua does not require parentheses around conditions
 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
index 58f63e35..e69de29b 100644
--- 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
@@ -1 +0,0 @@
- Roact.createElement("Frame")
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
index 06562162..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/any.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/any.fixed.diff
@@ -1,6 +0,0 @@
- print(foo)
- print(foo.x)
- print(foo.x.y.z)
- print(foo:x())
- foo.x = 1
- foo.x.y = 2
diff --git a/selene-lib/tests/lints/standard_library/assert.fixed.diff b/selene-lib/tests/lints/standard_library/assert.fixed.diff
index fbbdbff8..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/assert.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/assert.fixed.diff
@@ -1,9 +0,0 @@
- assert(true, "message")
- assert(call())
- assert(call(), "this is ok")
- assert(...)
- 
- assert(true)
- assert(true, "message", call())
- assert(true, "message", ...)
- assert()
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
index 54b6bf98..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/bad_call_signatures.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/bad_call_signatures.fixed.diff
@@ -1,20 +0,0 @@
- print()
- print("a", 2, "c")
- math.sin(3)
- math.sin(1 + 1)
- math.random()
- math.random(1)
- print "hello"
- --
- math.sin("i'd like the sine of three, please")
- math.floor(3.5, "remember to make sure it's 3 :)")
- math.sin "pi"
- --
- local variable = 3
- math.sin(variable)
- math.sin(variable, variable)
- --
- math.max(2)
- math.pi()
- string.format(-2, "foo")
- string.format(1 + 1)
diff --git a/selene-lib/tests/lints/standard_library/callable_metatables.fixed.diff b/selene-lib/tests/lints/standard_library/callable_metatables.fixed.diff
index 5e87e357..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/callable_metatables.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/callable_metatables.fixed.diff
@@ -1,2 +0,0 @@
- expect.extend({})
- expect(1).to.be.ok()
diff --git a/selene-lib/tests/lints/standard_library/complex.fixed.diff b/selene-lib/tests/lints/standard_library/complex.fixed.diff
index 061e23c9..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/complex.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/complex.fixed.diff
@@ -1,3 +0,0 @@
- print(require("foo").bar)
- print(coroutine.wrap(print)())
- getmetatable({}).__index = function() end
diff --git a/selene-lib/tests/lints/standard_library/constants.fixed.diff b/selene-lib/tests/lints/standard_library/constants.fixed.diff
index 1c730fc6..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/constants.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/constants.fixed.diff
@@ -1,9 +0,0 @@
- collectgarbage("count")
- collectgarbage "count"
- 
- collectgarbage("doge")
- collectgarbage(1)
- 
- collectgarbage("coun" .. "t")
- 
- collectgarbage()
diff --git a/selene-lib/tests/lints/standard_library/if_expressions.fixed.diff b/selene-lib/tests/lints/standard_library/if_expressions.fixed.diff
index 7a9eed3d..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/if_expressions.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/if_expressions.fixed.diff
@@ -1,5 +0,0 @@
- math.floor(if x then 1 else 2)
- math.floor(if x then "a" else "b")
- 
- -- TODO: Let's try to capture this, right now the entire expression just resolves to no type
- math.floor(if x then 1 else "a")
diff --git a/selene-lib/tests/lints/standard_library/lua52.fixed.diff b/selene-lib/tests/lints/standard_library/lua52.fixed.diff
index c48a08c3..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/lua52.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/lua52.fixed.diff
@@ -1,2 +0,0 @@
- table.unpack({})
- setfenv() -- This would error if it was defined, since setfenv requires an argument
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
index e64677c8..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/math_on_types.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/math_on_types.fixed.diff
@@ -1,2 +0,0 @@
- usesType(x * 0.5)
- usesType(0.5 * x)
diff --git a/selene-lib/tests/lints/standard_library/method_call.fixed.diff b/selene-lib/tests/lints/standard_library/method_call.fixed.diff
index 3612cd65..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/method_call.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/method_call.fixed.diff
@@ -1,4 +0,0 @@
- foo:bar(1)
- foo:bar("a")
- foo.bar()
- foo:baz()
diff --git a/selene-lib/tests/lints/standard_library/required.fixed.diff b/selene-lib/tests/lints/standard_library/required.fixed.diff
index b11db297..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/required.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/required.fixed.diff
@@ -1,11 +0,0 @@
- -- ipairs requires an argument--this should fail.
- ipairs()
- 
- -- setmetatable requires a first argument, but not a second one. this should still fail.
- setmetatable()
- 
- -- This, however, should not.
- setmetatable({})
- 
- -- nil counts as filling in an unrequired argument.
- setmetatable({}, nil)
diff --git a/selene-lib/tests/lints/standard_library/shadowing.fixed.diff b/selene-lib/tests/lints/standard_library/shadowing.fixed.diff
index d8219f6c..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/shadowing.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/shadowing.fixed.diff
@@ -1,11 +0,0 @@
- local math = {}
- math.dog = 1
- math.sin = print
- 
- math.sin("hi" + math.dog)
- 
- function foo(table)
-     table.insert()
- end
- 
- table.insert()
diff --git a/selene-lib/tests/lints/standard_library/string_interpolation.fixed.diff b/selene-lib/tests/lints/standard_library/string_interpolation.fixed.diff
index 8e566826..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/string_interpolation.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/string_interpolation.fixed.diff
@@ -1,7 +0,0 @@
- collectgarbage(`count`)
- collectgarbage(`ohno`)
- 
- string.upper(`foo`)
- string.upper(`foo{"bar"}`)
- 
- math.floor(`oh no`)
diff --git a/selene-lib/tests/lints/standard_library/ternary.fixed.diff b/selene-lib/tests/lints/standard_library/ternary.fixed.diff
index aec00402..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/ternary.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/ternary.fixed.diff
@@ -1,3 +0,0 @@
- math.floor(r > 1 and 1 or 0)
- math.floor(r > 1 + 1)
- math.floor(not flag and 1 or 0)
diff --git a/selene-lib/tests/lints/standard_library/unknown_property.fixed.diff b/selene-lib/tests/lints/standard_library/unknown_property.fixed.diff
index 1e58a8ea..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/unknown_property.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/unknown_property.fixed.diff
@@ -1,9 +0,0 @@
- print("3.14 = ", math.pie)
- print(print.foo)
- print(math.huge.big)
- math.call()
- 
- -- These aren't correct, but they should be covered under a different lint
- call()
- local _ = bad
- print(foo.bar)
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
index 1bbff94f..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/unpack_function_arguments.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/unpack_function_arguments.fixed.diff
@@ -1,12 +0,0 @@
- -- Since functions can pass multiple parameters through a function if they're the last ones to be called,
- -- selene needs to be able to recognize this and not error.
- 
- -- This should not lint, since `unpack(stuff)` could pass in multiple parameters.
- math.max(unpack(stuff))
- 
- -- This should lint, since functions only pass multiple parameters if they are the last argument.
- -- debug.setlocal is used because it takes three required parameters.
- debug.setlocal(unpack(stuff), 2)
- 
- -- This is still wrong since it has too many parameters.
- string.upper("text", unpack(stuff))
diff --git a/selene-lib/tests/lints/standard_library/vararg.fixed.diff b/selene-lib/tests/lints/standard_library/vararg.fixed.diff
index c31aa369..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/vararg.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/vararg.fixed.diff
@@ -1,3 +0,0 @@
- return function(...)
-     table.insert(...)
- end
diff --git a/selene-lib/tests/lints/standard_library/wildcard.fixed.diff b/selene-lib/tests/lints/standard_library/wildcard.fixed.diff
index 5b5d9bc1..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/wildcard.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/wildcard.fixed.diff
@@ -1,12 +0,0 @@
- script.ClassName = 3
- 
- script.Name = "Script"
- script.Name.UhOh = "Oops"
- 
- script.Child = "Oops"
- script.Child.Name = "Okay"
- 
- script.Child.Grandchild.Name = "Okay"
- 
- print(x.y.z)
- print(x.y.fail)
diff --git a/selene-lib/tests/lints/standard_library/wildcard_structs.fixed.diff b/selene-lib/tests/lints/standard_library/wildcard_structs.fixed.diff
index d56adb03..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/wildcard_structs.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/wildcard_structs.fixed.diff
@@ -1,6 +0,0 @@
- script.Name = "Okay"
- script.Child = "Oops"
- script.Child.Name = "Okay"
- script.Child.Name.UhOh = "Oops"
- script.Child.Grandchild = "Oops"
- script.Child.Grandchild.Name = "Okay"
diff --git a/selene-lib/tests/lints/standard_library/writing.fixed.diff b/selene-lib/tests/lints/standard_library/writing.fixed.diff
index 883e4744..e69de29b 100644
--- a/selene-lib/tests/lints/standard_library/writing.fixed.diff
+++ b/selene-lib/tests/lints/standard_library/writing.fixed.diff
@@ -1,6 +0,0 @@
- _G.foo = true
- print(_G.foo)
- _G = {}
- 
- math.pi = 3
- math.foo = 4
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..e69de29b
diff --git a/selene-lib/tests/lints/unused_variable/function_overriding.fixed.diff b/selene-lib/tests/lints/unused_variable/function_overriding.fixed.diff
index 2c506de0..e69de29b 100644
--- a/selene-lib/tests/lints/unused_variable/function_overriding.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/function_overriding.fixed.diff
@@ -1 +0,0 @@
- function global.name() end
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
index 2c55b24a..e69de29b 100644
--- a/selene-lib/tests/lints/unused_variable/generic_for_shadowing.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/generic_for_shadowing.fixed.diff
@@ -1,5 +0,0 @@
- return function(foo, ...)
-     for _, foo in pairs({ foo, ... }) do
-         print(foo)
-     end
- end
diff --git a/selene-lib/tests/lints/unused_variable/ignore.fixed.diff b/selene-lib/tests/lints/unused_variable/ignore.fixed.diff
index 48a8d5f2..e69de29b 100644
--- a/selene-lib/tests/lints/unused_variable/ignore.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/ignore.fixed.diff
@@ -1 +0,0 @@
- local _ = 0
diff --git a/selene-lib/tests/lints/unused_variable/mutating_functions.fixed.diff b/selene-lib/tests/lints/unused_variable/mutating_functions.fixed.diff
index 80480088..e69de29b 100644
--- a/selene-lib/tests/lints/unused_variable/mutating_functions.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/mutating_functions.fixed.diff
@@ -1,3 +0,0 @@
- local noSideEffects = call()
- 
- function noSideEffects.foo() end
diff --git a/selene-lib/tests/lints/unused_variable/observes.fixed.diff b/selene-lib/tests/lints/unused_variable/observes.fixed.diff
index e62cc6fa..e69de29b 100644
--- a/selene-lib/tests/lints/unused_variable/observes.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/observes.fixed.diff
@@ -1,46 +0,0 @@
- local writtenOnlyA = {}
- table.insert(writtenOnlyA, 3)
- 
- local readA = {}
- print(table.insert(readA, 3))
- 
- -- Make sure doing it inside other statements doesn't trigger false negatives
- print(function()
- 	local writtenOnlyB = {}
- 	table.insert(writtenOnlyB, 1)
- 
- 	local readB = {}
- 	return table.insert(readB, 1)
- end)
- 
- if true then
- 	local writtenOnlyC = {}
- 	table.insert(writtenOnlyC, 1)
- 
- 	local readC = {}
- 	print(table.insert(readC, 1))
- end
- 
- local insertButReadLater = {}
- table.insert(insertButReadLater, 1)
- print(insertButReadLater)
- 
- local ambiguous = external()
- table.insert(ambiguous, 1)
- 
- local rooms = {
- 	boss = {},
- }
- 
- for index, room in pairs(rooms) do
- 	table.insert(room, 1)
- 
- 	local roomByIndex = rooms[index]
- 	table.insert(roomByIndex, 2)
- end
- 
- local nested = {
- 	key = external(),
- }
- 
- table.insert(nested.key, 1)
diff --git a/selene-lib/tests/lints/unused_variable/self.fixed.diff b/selene-lib/tests/lints/unused_variable/self.fixed.diff
index 924d1a20..e69de29b 100644
--- a/selene-lib/tests/lints/unused_variable/self.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/self.fixed.diff
@@ -1,6 +0,0 @@
- local Foo = {}
- 
- function Foo:A() end
- function Foo.B() end
- 
- return Foo
diff --git a/selene-lib/tests/lints/unused_variable/self_ignored.fixed.diff b/selene-lib/tests/lints/unused_variable/self_ignored.fixed.diff
index 3d05c3f4..e69de29b 100644
--- a/selene-lib/tests/lints/unused_variable/self_ignored.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/self_ignored.fixed.diff
@@ -1,5 +0,0 @@
- local Foo = {}
- 
- function Foo:A() end
- 
- return Foo
diff --git a/selene-lib/tests/lints/unused_variable/shadowing.fixed.diff b/selene-lib/tests/lints/unused_variable/shadowing.fixed.diff
index 32cf84b3..e69de29b 100644
--- a/selene-lib/tests/lints/unused_variable/shadowing.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/shadowing.fixed.diff
@@ -1,11 +0,0 @@
- local x = 0
- 
- repeat
-     x = x + wait()
- until x >= 5
- 
- local x = 0
- 
- repeat
-     x = x + wait()
- until x >= 5
diff --git a/selene-lib/tests/lints/unused_variable/write_only.fixed.diff b/selene-lib/tests/lints/unused_variable/write_only.fixed.diff
index 47262952..e69de29b 100644
--- a/selene-lib/tests/lints/unused_variable/write_only.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/write_only.fixed.diff
@@ -1,17 +0,0 @@
- local bad1 = {}
- bad1.x = 1
- bad1.y = 2
- bad1["z"] = 1
- 
- local badButNotYetImplemented = { x = {} }
- badButNotYetImplemented.x.y = 1
- 
- local okay1 = ok()
- okay1.x = 1
- okay1.y = 2
- 
- local okay2 = { x = ok() }
- okay2.x.y = 1
- 
- local okay3 = {}
- okay3.x().y = 1

From 441679f1b72265bc72756b3b5a3629cf6d3fdabe Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sun, 15 Oct 2023 15:25:56 -0700
Subject: [PATCH 30/63] Update comment

---
 selene-lib/src/lints/almost_swapped.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/selene-lib/src/lints/almost_swapped.rs b/selene-lib/src/lints/almost_swapped.rs
index 7ed9eb91..a62c2dea 100644
--- a/selene-lib/src/lints/almost_swapped.rs
+++ b/selene-lib/src/lints/almost_swapped.rs
@@ -44,8 +44,8 @@ impl Lint for AlmostSwappedLint {
                         name1 = almost_swap.names.0,
                         name2 = almost_swap.names.1,
                     )),
-                    // FIXME: Ideally `MaybeIncorrect`, but cannot because the end range of swapping `t[1]` and `t[2]`
-                    // doesn't include the closing `]`
+                    // FIXME: Ideally `MaybeIncorrect`, but the end range for swapping `t[1]` and `t[2]`
+                    // currently doesn't include the closing `]`
                     Applicability::HasPlaceholders,
                 )
             })

From d2bc397efda955a96c759869d387942d1388438e Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sun, 15 Oct 2023 16:19:38 -0700
Subject: [PATCH 31/63] Add machine applicability to each diff line

---
 selene-lib/src/lints/test_util.rs             |  49 +++++-
 .../compare_nan/compare_nan_if.fixed.diff     |  68 ++++----
 .../compare_nan_variables.fixed.diff          |  30 ++--
 .../constant_table_comparison.fixed.diff      |  40 ++---
 .../deprecated_functions.fixed.diff           |  10 +-
 .../lints/empty_loop/empty_loop.fixed.diff    | 146 +++++++++---------
 .../empty_loop/empty_loop_comments.fixed.diff | 144 ++++++++---------
 .../parenthese_conditions.fixed.diff          |  54 +++----
 .../lints/unused_variable/blocks.fixed.diff   |  50 +++---
 .../unused_variable/edge_cases.fixed.diff     |  20 +--
 .../unused_variable/explicit_self.fixed.diff  |  10 +-
 .../tests/lints/unused_variable/if.fixed.diff |  36 ++---
 .../lints/unused_variable/locals.fixed.diff   |  64 ++++----
 .../unused_variable/overriding.fixed.diff     |  56 +++----
 .../lints/unused_variable/types.fixed.diff    |   8 +-
 .../lints/unused_variable/varargs.fixed.diff  |  20 +--
 16 files changed, 420 insertions(+), 385 deletions(-)

diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index 7a218994..f56e1a52 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -11,7 +11,8 @@ use std::{
 };
 
 use codespan_reporting::{
-    diagnostic::Severity as CodespanSeverity, term::Config as CodespanConfig,
+    diagnostic::{self, Severity as CodespanSeverity},
+    term::Config as CodespanConfig,
 };
 
 use serde::de::DeserializeOwned;
@@ -93,23 +94,53 @@ fn apply_diagnostics_fixes(code: &str, diagnostics: &[&Diagnostic]) -> String {
 }
 
 /// Returns empty string if there are no diffs
-fn generate_diff(source1: &str, source2: &str) -> String {
+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 as u32;
+
+        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 => " ",
+            ChangeTag::Equal => "   ".to_string(),
         };
-        result.push_str(&format!("{}{}", sign, change.value()));
+
+        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 {
@@ -195,7 +226,11 @@ pub fn test_lint_config_with_output<
         fixed_diagnostics.sort_by_key(|diagnostic| diagnostic.start_position());
     }
 
-    let fixed_diff = generate_diff(&lua_source, &fixed_code);
+    let fixed_diff = generate_diff(
+        &lua_source,
+        &fixed_code,
+        &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) {
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
index 9f868d40..e11f1451 100644
--- a/selene-lib/tests/lints/compare_nan/compare_nan_if.fixed.diff
+++ b/selene-lib/tests/lints/compare_nan/compare_nan_if.fixed.diff
@@ -1,34 +1,34 @@
--if x == 0/0 then
-+if x ~= x then
- end
- 
--if x ~= 0/0 then
-+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
+-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_variables.fixed.diff b/selene-lib/tests/lints/compare_nan/compare_nan_variables.fixed.diff
index 59b83e46..cc51c712 100644
--- a/selene-lib/tests/lints/compare_nan/compare_nan_variables.fixed.diff
+++ b/selene-lib/tests/lints/compare_nan/compare_nan_variables.fixed.diff
@@ -1,15 +1,15 @@
- local _ = 0/0
- local _ = 1 ~= 0/0
- local _ = 2 == 0/0
- local _ = 3 + 0/0
- local _ = 4 >= 0/0
--local _ = x ~= 0/0
--local _ = x == 0/0
-+local _ = x == x
-+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
+    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/constant_table_comparison/constant_table_comparison.fixed.diff b/selene-lib/tests/lints/constant_table_comparison/constant_table_comparison.fixed.diff
index b1004f99..3824402a 100644
--- 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
@@ -1,20 +1,20 @@
- print(x == { "a", "b", "c" })
- print({ "a", "b", "c" } == x)
- 
--print(x == {})
--print({} == x)
--print(x ~= {})
--print({} ~= x)
-+print(next(x) == nil)
-+print(next(x) == nil)
-+print(next(x) ~= nil)
-+print(next(x) ~= nil)
- 
- print({ "a", "b", "c" } == { "a", "b", "c" })
- print({ "a", "b", "c" } == {})
- print({} == {})
- 
- print( -- my cool table
--	t == {}
-+	next(t) == nil
- )
+    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/deprecated/deprecated_functions.fixed.diff b/selene-lib/tests/lints/deprecated/deprecated_functions.fixed.diff
index 11fc9787..0add791a 100644
--- a/selene-lib/tests/lints/deprecated/deprecated_functions.fixed.diff
+++ b/selene-lib/tests/lints/deprecated/deprecated_functions.fixed.diff
@@ -1,5 +1,5 @@
- table.foreach({}, function(k, v) end)
--print(table.getn(x))
-+print(#x)
- 
- table.foreach({}, 3)
+    table.foreach({}, function(k, v) end)
+-MA print(table.getn(x))
++MA print(#x)
+    
+    table.foreach({}, 3)
diff --git a/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff b/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff
index 0edc5d4a..872cdbcb 100644
--- a/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff
+++ b/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff
@@ -1,73 +1,73 @@
- for _ = 1, 10 do
-     return "Should not warn"
- end
- 
- for _ = 1, 10 do
-     print("Should not warn")
- end
- 
--for _ = 1, 10 do
--    -- Should warn
--end
- 
--for _ = 1, 10 do
--    --[[
--    Should warn
--    ]]
--end
- 
--for _ = 1, 10 do
- 
- 
--    
--end
- 
-+
- for _ in pairs({}) do
-     return "Should not warn"
- end
- 
--for _ in pairs({}) do
--end
- 
-+
- for _ in ipairs({}) do
-     return "Should not warn"
- end
- 
--for _ in ipairs({}) do
--end
- 
-+
- for _ in {} do
-     return "Should not warn"
- end
- 
--for _ in {} do
--end
- 
-+
- for _ in a() do
-     return "Should not warn"
- end
- 
--for _ in a() do
--end
- 
-+
- while true do
-     return "Should not warn"
- end
- 
--while true do
--end
- 
-+
- repeat
-     return "Should not warn"
- until true
- 
--repeat
--until true
-+
- -- comment here shouldn't break anything
+    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_comments.fixed.diff b/selene-lib/tests/lints/empty_loop/empty_loop_comments.fixed.diff
index 498d8198..fcc581e2 100644
--- a/selene-lib/tests/lints/empty_loop/empty_loop_comments.fixed.diff
+++ b/selene-lib/tests/lints/empty_loop/empty_loop_comments.fixed.diff
@@ -1,72 +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
- 
--for _ = 1, 10 do
--
--
- 
--end
- 
- for _ in pairs({}) do
-     return "Should not warn"
- end
- 
--for _ in pairs({}) do
--end
- 
-+
- for _ in ipairs({}) do
-     return "Should not warn"
- end
- 
--for _ in ipairs({}) do
--end
- 
-+
- for _ in {} do
-     return "Should not warn"
- end
- 
--for _ in {} do
--end
- 
-+
- for _ in a() do
-     return "Should not warn"
- end
- 
--for _ in a() do
--end
- 
-+
- while true do
-     return "Should not warn"
- end
- 
--while true do
--end
- 
-+
- repeat
-     return "Should not warn"
- until true
- 
--repeat
--until true
-+
- -- comment here shouldn't break anything
+    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/parenthese_conditions/parenthese_conditions.fixed.diff b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
index 71268175..c1ecbc29 100644
--- a/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
+++ b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
@@ -1,27 +1,27 @@
- if x then end
--if (x) then end
-+if x then end
- 
--if (x) then
-+if x then
- elseif y then
--elseif (z) then
-+elseif z then
- end
- 
- while true do end
--while (true) do end
-+while true do end
- 
- repeat until false
--repeat until (false)
-+repeat until false
- 
- while (true) and false do end
- 
--if ((function()
--    if (x) then end
--end)()) then end
-+if (function()
-+    if x then end
-+end)() then end
+    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/unused_variable/blocks.fixed.diff b/selene-lib/tests/lints/unused_variable/blocks.fixed.diff
index 5308ebc1..6e85cca6 100644
--- a/selene-lib/tests/lints/unused_variable/blocks.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/blocks.fixed.diff
@@ -1,25 +1,25 @@
- -- Functions
--local function unusedFunction()
--    local unusedVariableA = 1
--    local unusedVariableB = 1
-+local function _unusedFunction()
-+    local _unusedVariableA = 1
-+    local _unusedVariableB = 1
- end
- 
- print(unusedVariableB)
--local overidden = true
-+local _overidden = true
- 
- local function overridesIt()
-     local overidden = false
-     print(overidden)
- end
- 
- overridesIt()
- 
- -- Anonymous functions
- local a = 1
- print(function()
-     _G.foo = a
- end)
+    -- 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
index 414306c0..2451f300 100644
--- a/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff
@@ -1,10 +1,10 @@
- local foo = 1
--local foo = foo + 1
--local bar = bar
-+local _foo = foo + 1
-+local _bar = bar
- 
- -- The variables inside of a repeat...until are accessible from the until statement
- repeat
-     local baz
- until baz
+    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
index 437f1f7b..6e60342c 100644
--- a/selene-lib/tests/lints/unused_variable/explicit_self.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/explicit_self.fixed.diff
@@ -1,5 +1,5 @@
--local function foo(self)
-+local function foo(_self)
- end
- 
- foo()
+-MA local function foo(self)
++MA local function foo(_self)
+    end
+    
+    foo()
diff --git a/selene-lib/tests/lints/unused_variable/if.fixed.diff b/selene-lib/tests/lints/unused_variable/if.fixed.diff
index 70f902f4..3b47e37b 100644
--- a/selene-lib/tests/lints/unused_variable/if.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/if.fixed.diff
@@ -1,18 +1,18 @@
- if 1 then
--    local localA
-+    local _localA
- elseif 2 then
--    local localB
-+    local _localB
-     print(localA)
- elseif 3 then
--    local localC
-+    local _localC
-     print(localB)
- else
--    local localD
-+    local _localD
-     print(localC)
- end
- 
- print(localA, localB, localC, localD)
+    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/locals.fixed.diff b/selene-lib/tests/lints/unused_variable/locals.fixed.diff
index b5522fcd..23c369be 100644
--- a/selene-lib/tests/lints/unused_variable/locals.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/locals.fixed.diff
@@ -1,32 +1,32 @@
- -- Unused
--local localA, localB
-+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
--local localI = { localH }
-+local _localI = { localH }
+    -- 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/overriding.fixed.diff b/selene-lib/tests/lints/unused_variable/overriding.fixed.diff
index 0c85012a..a123944a 100644
--- a/selene-lib/tests/lints/unused_variable/overriding.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/overriding.fixed.diff
@@ -1,28 +1,28 @@
- local a = 1
- 
- -- Variables defined inside the function should still lint
--local function foo()
-+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
+    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/types.fixed.diff b/selene-lib/tests/lints/unused_variable/types.fixed.diff
index 6774b006..6b2b1367 100644
--- a/selene-lib/tests/lints/unused_variable/types.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/types.fixed.diff
@@ -1,4 +1,4 @@
- local types = require(script.types)
- 
--local value: types.something
-+local _value: types.something
+    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
index a492f9dc..6de494b0 100644
--- a/selene-lib/tests/lints/unused_variable/varargs.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/varargs.fixed.diff
@@ -1,10 +1,10 @@
- local function foo(...)
-     call(...)
- end
- 
--local function bar(...)
-+local function _bar(...)
-     call(...)
- end
- 
- foo()
+    local function foo(...)
+        call(...)
+    end
+    
+-MA local function bar(...)
++MA local function _bar(...)
+        call(...)
+    end
+    
+    foo()

From 935dfbb0f6ba9d2c3b9578a988aed1a8ba82c830 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sun, 15 Oct 2023 16:21:01 -0700
Subject: [PATCH 32/63] Bracket applicability

---
 selene-lib/src/lints/test_util.rs             |  10 +-
 .../compare_nan/compare_nan_if.fixed.diff     |  68 ++++----
 .../compare_nan_variables.fixed.diff          |  30 ++--
 .../constant_table_comparison.fixed.diff      |  40 ++---
 .../deprecated_functions.fixed.diff           |  10 +-
 .../lints/empty_loop/empty_loop.fixed.diff    | 146 +++++++++---------
 .../empty_loop/empty_loop_comments.fixed.diff | 144 ++++++++---------
 .../parenthese_conditions.fixed.diff          |  54 +++----
 .../lints/unused_variable/blocks.fixed.diff   |  50 +++---
 .../unused_variable/edge_cases.fixed.diff     |  20 +--
 .../unused_variable/explicit_self.fixed.diff  |  10 +-
 .../tests/lints/unused_variable/if.fixed.diff |  36 ++---
 .../lints/unused_variable/locals.fixed.diff   |  64 ++++----
 .../unused_variable/overriding.fixed.diff     |  56 +++----
 .../lints/unused_variable/types.fixed.diff    |   8 +-
 .../lints/unused_variable/varargs.fixed.diff  |  20 +--
 16 files changed, 383 insertions(+), 383 deletions(-)

diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index f56e1a52..ea2141cd 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -98,22 +98,22 @@ fn generate_diff(source1: &str, source2: &str, diagnostics: &[&Diagnostic]) -> S
     let mut result = String::new();
     let mut has_changes = false;
     let mut byte_offset = 0;
-    let mut prev_non_insert_applicability_prefix = "  ";
+    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 as u32;
 
-        let mut applicability_prefix = "  ";
+        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";
+                    applicability_prefix = "[MA]";
                     break;
                 } else if diagnostic.applicability == Applicability::MaybeIncorrect {
-                    applicability_prefix = "MI";
+                    applicability_prefix = "[MI]";
                     break;
                 }
             }
@@ -132,7 +132,7 @@ fn generate_diff(source1: &str, source2: &str, diagnostics: &[&Diagnostic]) -> S
                 has_changes = true;
                 format!("+{}", applicability_prefix)
             }
-            ChangeTag::Equal => "   ".to_string(),
+            ChangeTag::Equal => "     ".to_string(),
         };
 
         result.push_str(&format!("{} {}", sign, change.value()));
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
index e11f1451..81558f9f 100644
--- a/selene-lib/tests/lints/compare_nan/compare_nan_if.fixed.diff
+++ b/selene-lib/tests/lints/compare_nan/compare_nan_if.fixed.diff
@@ -1,34 +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
+-[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_variables.fixed.diff b/selene-lib/tests/lints/compare_nan/compare_nan_variables.fixed.diff
index cc51c712..0983d217 100644
--- a/selene-lib/tests/lints/compare_nan/compare_nan_variables.fixed.diff
+++ b/selene-lib/tests/lints/compare_nan/compare_nan_variables.fixed.diff
@@ -1,15 +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
+      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/constant_table_comparison/constant_table_comparison.fixed.diff b/selene-lib/tests/lints/constant_table_comparison/constant_table_comparison.fixed.diff
index 3824402a..48d54c34 100644
--- 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
@@ -1,20 +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
-    )
+      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/deprecated/deprecated_functions.fixed.diff b/selene-lib/tests/lints/deprecated/deprecated_functions.fixed.diff
index 0add791a..26dbd0dc 100644
--- a/selene-lib/tests/lints/deprecated/deprecated_functions.fixed.diff
+++ b/selene-lib/tests/lints/deprecated/deprecated_functions.fixed.diff
@@ -1,5 +1,5 @@
-    table.foreach({}, function(k, v) end)
--MA print(table.getn(x))
-+MA print(#x)
-    
-    table.foreach({}, 3)
+      table.foreach({}, function(k, v) end)
+-[MA] print(table.getn(x))
++[MA] print(#x)
+      
+      table.foreach({}, 3)
diff --git a/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff b/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff
index 872cdbcb..d378474b 100644
--- a/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff
+++ b/selene-lib/tests/lints/empty_loop/empty_loop.fixed.diff
@@ -1,73 +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
+      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_comments.fixed.diff b/selene-lib/tests/lints/empty_loop/empty_loop_comments.fixed.diff
index fcc581e2..58ef60e3 100644
--- a/selene-lib/tests/lints/empty_loop/empty_loop_comments.fixed.diff
+++ b/selene-lib/tests/lints/empty_loop/empty_loop_comments.fixed.diff
@@ -1,72 +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
+      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/parenthese_conditions/parenthese_conditions.fixed.diff b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
index c1ecbc29..dd98fffa 100644
--- a/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
+++ b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.fixed.diff
@@ -1,27 +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
+      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/unused_variable/blocks.fixed.diff b/selene-lib/tests/lints/unused_variable/blocks.fixed.diff
index 6e85cca6..7ad71a34 100644
--- a/selene-lib/tests/lints/unused_variable/blocks.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/blocks.fixed.diff
@@ -1,25 +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)
+      -- 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
index 2451f300..e7a381e0 100644
--- a/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/edge_cases.fixed.diff
@@ -1,10 +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
+      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
index 6e60342c..2b0a5447 100644
--- a/selene-lib/tests/lints/unused_variable/explicit_self.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/explicit_self.fixed.diff
@@ -1,5 +1,5 @@
--MA local function foo(self)
-+MA local function foo(_self)
-    end
-    
-    foo()
+-[MA] local function foo(self)
++[MA] local function foo(_self)
+      end
+      
+      foo()
diff --git a/selene-lib/tests/lints/unused_variable/if.fixed.diff b/selene-lib/tests/lints/unused_variable/if.fixed.diff
index 3b47e37b..53817d4d 100644
--- a/selene-lib/tests/lints/unused_variable/if.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/if.fixed.diff
@@ -1,18 +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)
+      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/locals.fixed.diff b/selene-lib/tests/lints/unused_variable/locals.fixed.diff
index 23c369be..573d4626 100644
--- a/selene-lib/tests/lints/unused_variable/locals.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/locals.fixed.diff
@@ -1,32 +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 }
+      -- 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/overriding.fixed.diff b/selene-lib/tests/lints/unused_variable/overriding.fixed.diff
index a123944a..4b7517e8 100644
--- a/selene-lib/tests/lints/unused_variable/overriding.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/overriding.fixed.diff
@@ -1,28 +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
+      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/types.fixed.diff b/selene-lib/tests/lints/unused_variable/types.fixed.diff
index 6b2b1367..13af7878 100644
--- a/selene-lib/tests/lints/unused_variable/types.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/types.fixed.diff
@@ -1,4 +1,4 @@
-    local types = require(script.types)
-    
--MA local value: types.something
-+MA local _value: types.something
+      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
index 6de494b0..b5e847b7 100644
--- a/selene-lib/tests/lints/unused_variable/varargs.fixed.diff
+++ b/selene-lib/tests/lints/unused_variable/varargs.fixed.diff
@@ -1,10 +1,10 @@
-    local function foo(...)
-        call(...)
-    end
-    
--MA local function bar(...)
-+MA local function _bar(...)
-        call(...)
-    end
-    
-    foo()
+      local function foo(...)
+          call(...)
+      end
+      
+-[MA] local function bar(...)
++[MA] local function _bar(...)
+          call(...)
+      end
+      
+      foo()

From 3baa606414a6088539cfba898c9cd910f879ec3a Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sun, 15 Oct 2023 18:02:47 -0700
Subject: [PATCH 33/63] Add divide by zero fixer

---
 selene-lib/src/lints/divide_by_zero.rs                    | 6 +++---
 .../tests/lints/divide_by_zero/divide_by_zero.fixed.diff  | 7 +++++++
 .../tests/lints/divide_by_zero/divide_by_zero.stderr      | 8 ++++++--
 3 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/selene-lib/src/lints/divide_by_zero.rs b/selene-lib/src/lints/divide_by_zero.rs
index 65a81c9d..1282afa4 100644
--- a/selene-lib/src/lints/divide_by_zero.rs
+++ b/selene-lib/src/lints/divide_by_zero.rs
@@ -33,10 +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),
-                    None,
-                    Applicability::Unspecified,
+                    Some("math.huge()".to_string()),
+                    Applicability::MachineApplicable,
                 )
             })
             .collect()
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
index e69de29b..2c40568c 100644
--- 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
@@ -0,0 +1,7 @@
+      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
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 b645f171..d20d0485 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,12 +1,16 @@
-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()`
 

From a94b9ac906c29e08ce7385c207caeb4cea3731c9 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sun, 15 Oct 2023 18:07:09 -0700
Subject: [PATCH 34/63] Add unnecessary string escape fixer

---
 selene-lib/src/lints/bad_string_escape.rs     |  8 ++--
 .../lua51_string_escapes.fixed.diff           | 41 +++++++++++++++++++
 .../lua51_string_escapes.stderr               |  4 ++
 .../roblox_string_escapes.fixed.diff          | 41 +++++++++++++++++++
 .../roblox_string_escapes.stderr              |  4 ++
 5 files changed, 94 insertions(+), 4 deletions(-)

diff --git a/selene-lib/src/lints/bad_string_escape.rs b/selene-lib/src/lints/bad_string_escape.rs
index 55c8cae5..f36f6ba8 100644
--- a/selene-lib/src/lints/bad_string_escape.rs
+++ b/selene-lib/src/lints/bad_string_escape.rs
@@ -89,16 +89,16 @@ impl Lint for BadStringEscapeLint {
                     "double quotes do not have to be escaped when inside single quoted strings"
                         .to_owned(),
                     Label::new(sequence.range.to_owned()),
-                    None,
-                    Applicability::Unspecified,
+                    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()),
-                    None,
-                    Applicability::Unspecified,
+                    Some("'".to_string()),
+                    Applicability::MachineApplicable,
                 ),
             })
             .collect()
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
index e69de29b..8f44ac33 100644
--- 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
@@ -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..12508462 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
@@ -3,12 +3,16 @@ error[bad_string_escape]: single quotes do not have to be escaped when inside do
    │
 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
index e69de29b..8f44ac33 100644
--- 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
@@ -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..3c4bc975 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
@@ -3,12 +3,16 @@ error[bad_string_escape]: single quotes do not have to be escaped when inside do
    │
 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

From b395454018edf5505104f7a0763673c3817fa50e Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sun, 15 Oct 2023 18:10:12 -0700
Subject: [PATCH 35/63] Add unscoped variables fixer

---
 selene-lib/src/lints/unscoped_variables.rs       |  4 ++--
 .../unscoped_variables.fixed.diff                | 16 ++++++++++++++++
 .../unscoped_variables/unscoped_variables.stderr |  4 ++++
 3 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/selene-lib/src/lints/unscoped_variables.rs b/selene-lib/src/lints/unscoped_variables.rs
index ccf83125..44d1f976 100644
--- a/selene-lib/src/lints/unscoped_variables.rs
+++ b/selene-lib/src/lints/unscoped_variables.rs
@@ -60,8 +60,8 @@ impl Lint for UnscopedVariablesLint {
                         reference.name
                     ),
                     Label::new(reference.identifier),
-                    None,
-                    Applicability::Unspecified,
+                    Some(format!("local {}", reference.name)),
+                    Applicability::MaybeIncorrect,
                 ));
             }
         }
diff --git a/selene-lib/tests/lints/unscoped_variables/unscoped_variables.fixed.diff b/selene-lib/tests/lints/unscoped_variables/unscoped_variables.fixed.diff
index e69de29b..6338e4ee 100644
--- a/selene-lib/tests/lints/unscoped_variables/unscoped_variables.fixed.diff
+++ 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..b85d4c38 100644
--- a/selene-lib/tests/lints/unscoped_variables/unscoped_variables.stderr
+++ b/selene-lib/tests/lints/unscoped_variables/unscoped_variables.stderr
@@ -3,10 +3,14 @@ error[unscoped_variables]: `bar` is not declared locally, and will be available
   │
 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`
 

From c7e9156e2d12656fce11431532a4615e24579ae4 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Mon, 16 Oct 2023 12:24:10 -0700
Subject: [PATCH 36/63] Create better abstraction

---
 selene-lib/src/lints.rs           | 74 ++++++++++++++++++++++++++++
 selene-lib/src/lints/test_util.rs | 63 ++----------------------
 selene/src/main.rs                | 82 ++++---------------------------
 3 files changed, 86 insertions(+), 133 deletions(-)

diff --git a/selene-lib/src/lints.rs b/selene-lib/src/lints.rs
index 3949dbdd..153cc3a1 100644
--- a/selene-lib/src/lints.rs
+++ b/selene-lib/src/lints.rs
@@ -191,6 +191,80 @@ impl Diagnostic {
     pub fn start_position(&self) -> u32 {
         self.primary_label.range.0
     }
+
+    pub fn has_machine_applicable_fix(&self) -> bool {
+        self.fixed_code.is_some() && self.applicability == Applicability::MachineApplicable
+    }
+
+    /// 1. Applies all disjoint fixes
+    /// 1. If a fix is completely contained inside another fix, uses the inner one and discard the outer one
+    /// 2. If fixes partially overlap, chooses the fix that starts first and discard the other one
+    pub fn get_applied_suggestions_code(code: &str, diagnostics: &[&Diagnostic]) -> String {
+        let mut sorted_diagnostics = diagnostics
+            .iter()
+            .filter(|diagnostic| diagnostic.has_machine_applicable_fix())
+            .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 code.to_string(),
+        };
+
+        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);
+
+        let mut bytes_offset = 0;
+
+        let new_code = chosen_diagnostics
+            .iter()
+            .fold(code.to_string(), |code, diagnostic| {
+                if let Some(fixed) = &diagnostic.fixed_code {
+                    let (start, end) = diagnostic.primary_label.range;
+
+                    // This can theoretically overflow, but the user would face memory constraints
+                    // of such large strings long before
+                    let start_with_offset = start as isize + bytes_offset;
+                    let end_with_offset = end as isize + bytes_offset;
+
+                    let new_code = if start_with_offset > end_with_offset
+                        || end_with_offset > code.len().try_into().unwrap()
+                    {
+                        code.to_string()
+                    } else {
+                        format!(
+                            "{}{}{}",
+                            // Conversion is safe as range with offset will never be negative
+                            &code[..start_with_offset as usize],
+                            fixed.as_str(),
+                            &code[(end_with_offset as usize)..]
+                        )
+                    };
+
+                    bytes_offset += fixed.len() as isize - (end_with_offset - start_with_offset);
+                    new_code
+                } else {
+                    code
+                }
+            });
+
+        new_code
+    }
 }
 
 #[derive(Debug, PartialEq, Eq)]
diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index ea2141cd..de819bb9 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -11,8 +11,7 @@ use std::{
 };
 
 use codespan_reporting::{
-    diagnostic::{self, Severity as CodespanSeverity},
-    term::Config as CodespanConfig,
+    diagnostic::Severity as CodespanSeverity, term::Config as CodespanConfig,
 };
 
 use serde::de::DeserializeOwned;
@@ -36,63 +35,6 @@ impl Default for TestUtilConfig {
     }
 }
 
-fn replace_code_range(code: &str, start: usize, end: usize, replacement: &str) -> String {
-    if start > end || end > code.len() {
-        return code.to_string();
-    }
-
-    format!("{}{}{}", &code[..start], replacement, &code[end..])
-}
-
-/// Assumes diagnostics is sorted by starting positions
-///
-/// 1. Applies all disjoint fixes
-/// 1. If a fix is completely contained inside another fix, uses the inner one and discard the outer one
-/// 2. If fixes partially overlap, chooses the fix that starts first and discard the other one
-fn apply_diagnostics_fixes(code: &str, diagnostics: &[&Diagnostic]) -> String {
-    let mut chosen_diagnostics = Vec::new();
-
-    let mut candidate = diagnostics[0];
-    for diagnostic in 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);
-
-    let mut bytes_offset = 0;
-
-    let new_code = chosen_diagnostics
-        .iter()
-        .fold(code.to_string(), |code, diagnostic| {
-            if let Some(fixed) = &diagnostic.fixed_code {
-                let (start, end) = diagnostic.primary_label.range;
-                let new_code = replace_code_range(
-                    code.as_str(),
-                    (start as isize + bytes_offset) as usize,
-                    (end as isize + bytes_offset) as usize,
-                    fixed.as_str(),
-                );
-
-                bytes_offset += fixed.len() as isize - (end - start) as isize;
-                new_code
-            } else {
-                code
-            }
-        });
-
-    new_code
-}
-
 /// Returns empty string if there are no diffs
 fn generate_diff(source1: &str, source2: &str, diagnostics: &[&Diagnostic]) -> String {
     let mut result = String::new();
@@ -206,7 +148,8 @@ pub fn test_lint_config_with_output<
             && (diagnostic.applicability == Applicability::MachineApplicable
                 || diagnostic.applicability == Applicability::MaybeIncorrect)
     }) {
-        fixed_code = apply_diagnostics_fixes(fixed_code.as_str(), &fixed_diagnostics);
+        fixed_code =
+            Diagnostic::get_applied_suggestions_code(fixed_code.as_str(), &fixed_diagnostics);
 
         let fixed_ast = full_moon::parse(&fixed_code).unwrap_or_else(|_| {
             panic!(
diff --git a/selene/src/main.rs b/selene/src/main.rs
index ea5828f6..6b2d2f8c 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -17,7 +17,7 @@ use codespan_reporting::{
     term::DisplayStyle as CodespanDisplayStyle,
 };
 use selene_lib::{
-    lints::{Applicability, Diagnostic, Severity},
+    lints::{Diagnostic, Severity},
     *,
 };
 use structopt::{clap, StructOpt};
@@ -186,65 +186,6 @@ fn emit_codespan_locked(
     emit_codespan(&mut stdout, files, diagnostic, None);
 }
 
-fn replace_code_range(code: &str, start: usize, end: usize, replacement: &str) -> String {
-    if start > end || end > code.len() {
-        return code.to_string();
-    }
-
-    format!("{}{}{}", &code[..start], replacement, &code[end..])
-}
-
-/// Assumes diagnostics is sorted by starting positions
-///
-/// 1. Applies all disjoint fixes
-/// 1. If a fix is completely contained inside another fix, uses the inner one and discard the outer one
-/// 2. If fixes partially overlap, chooses the fix that starts first and discard the other one
-///
-// This is just copied from `test_util`. Can we get a better abstraction?
-fn apply_diagnostics_fixes(code: &str, diagnostics: &[&Diagnostic]) -> String {
-    let mut chosen_diagnostics = Vec::new();
-
-    let mut candidate = diagnostics[0];
-    for diagnostic in 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);
-
-    let mut bytes_offset = 0;
-
-    let new_code = chosen_diagnostics
-        .iter()
-        .fold(code.to_string(), |code, diagnostic| {
-            if let Some(fixed) = &diagnostic.fixed_code {
-                let (start, end) = diagnostic.primary_label.range;
-                let new_code = replace_code_range(
-                    code.as_str(),
-                    (start as isize + bytes_offset) as usize,
-                    (end as isize + bytes_offset) as usize,
-                    fixed.as_str(),
-                );
-
-                bytes_offset += fixed.len() as isize - (end - start) as isize;
-                new_code
-            } else {
-                code
-            }
-        });
-
-    new_code
-}
-
 fn read<R: Read>(
     checker: &Checker<toml::value::Value>,
     filename: &Path,
@@ -347,29 +288,24 @@ fn read<R: Read>(
 
     let mut fixed_code = 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.fixed_code.is_some()
-                    && diagnostic.diagnostic.applicability == Applicability::MachineApplicable
-            })
+            .filter(|diagnostic| diagnostic.diagnostic.has_machine_applicable_fix())
             .count();
 
         // To handle potential conflicts with different lint suggestions, we apply conflicting fixes one at a time.
         // Then we re-evaluate the lints with the new code until there are no more fixes to apply
-        while diagnostics.iter().any(|diagnostic| {
-            diagnostic.diagnostic.fixed_code.is_some()
-                && diagnostic.diagnostic.applicability == Applicability::MachineApplicable
-        }) {
-            fixed_code = apply_diagnostics_fixes(
+        while diagnostics
+            .iter()
+            .any(|diagnostic| diagnostic.diagnostic.has_machine_applicable_fix())
+        {
+            fixed_code = Diagnostic::get_applied_suggestions_code(
                 fixed_code.as_str(),
                 &diagnostics
                     .iter()
                     .map(|diagnostic| &diagnostic.diagnostic)
-                    .filter(|diagnostic| {
-                        diagnostic.fixed_code.is_some()
-                            && diagnostic.applicability == Applicability::MachineApplicable
-                    })
                     .collect::<Vec<_>>(),
             );
 

From d5684b8a83da8d6cf9e6c820ed4047c7c6a571d2 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Mon, 16 Oct 2023 12:28:14 -0700
Subject: [PATCH 37/63] Remove unused variable

---
 selene-vscode/src/extension.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/selene-vscode/src/extension.ts b/selene-vscode/src/extension.ts
index 6a5f22fd..fe9de97d 100644
--- a/selene-vscode/src/extension.ts
+++ b/selene-vscode/src/extension.ts
@@ -28,7 +28,6 @@ class SeleneCodeActionProvider implements vscode.CodeActionProvider {
         document: vscode.TextDocument,
         _range: vscode.Range | vscode.Selection,
         context: vscode.CodeActionContext,
-        _token: vscode.CancellationToken,
     ): vscode.ProviderResult<vscode.Command[] | vscode.CodeAction[]> {
         const codeActions: vscode.CodeAction[] = []
 

From ff082cff6088779221c61489bcd1f6d47c076e35 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Mon, 16 Oct 2023 12:31:55 -0700
Subject: [PATCH 38/63] Format ts

---
 selene-vscode/src/structures/diagnostic.ts | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/selene-vscode/src/structures/diagnostic.ts b/selene-vscode/src/structures/diagnostic.ts
index e3e67d77..72d8db1f 100644
--- a/selene-vscode/src/structures/diagnostic.ts
+++ b/selene-vscode/src/structures/diagnostic.ts
@@ -24,10 +24,15 @@ export interface Diagnostic {
 }
 
 export class SeleneDiagnostic extends vscode.Diagnostic {
-    fixed_code?: string;
+    fixed_code?: string
 
-    constructor(range: vscode.Range, message: string, severity: vscode.DiagnosticSeverity, fixed_code?: string) {
-        super(range, message, severity);
-        this.fixed_code = fixed_code;
+    constructor(
+        range: vscode.Range,
+        message: string,
+        severity: vscode.DiagnosticSeverity,
+        fixed_code?: string,
+    ) {
+        super(range, message, severity)
+        this.fixed_code = fixed_code
     }
 }

From a9ed88b600b74f6851b46313c8ec2292c6458137 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Wed, 18 Oct 2023 12:34:14 -0700
Subject: [PATCH 39/63] Move iteration logic to get_applied_suggestions_code

---
 .vscode/launch.json               |  83 +++++++++++++++++++++++
 selene-lib/src/lints.rs           | 107 ++++++++++++++++++------------
 selene-lib/src/lints/test_util.rs |  64 ++++++++++--------
 selene/src/main.rs                |  41 +++++++-----
 4 files changed, 208 insertions(+), 87 deletions(-)
 create mode 100644 .vscode/launch.json

diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 00000000..f93ddc80
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,83 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug executable 'selene'",
+            "cargo": {
+                "args": [
+                    "build",
+                    "--bin=selene",
+                    "--package=selene"
+                ],
+                "filter": {
+                    "name": "selene",
+                    "kind": "bin"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}/selene-lib"
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug unit tests in executable 'selene'",
+            "cargo": {
+                "args": [
+                    "test",
+                    "--no-run",
+                    "--bin=selene",
+                    "--package=selene"
+                ],
+                "filter": {
+                    "name": "selene",
+                    "kind": "bin"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug unit tests in library 'selene-lib'",
+            "cargo": {
+                "args": [
+                    "test",
+                    "--no-run",
+                    "--lib",
+                    "--package=selene-lib"
+                ],
+                "filter": {
+                    "name": "selene-lib",
+                    "kind": "lib"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug integration test 'checker'",
+            "cargo": {
+                "args": [
+                    "test",
+                    "--no-run",
+                    "--test=checker",
+                    "--package=selene-lib"
+                ],
+                "filter": {
+                    "name": "checker",
+                    "kind": "test"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/selene-lib/src/lints.rs b/selene-lib/src/lints.rs
index 153cc3a1..514528b1 100644
--- a/selene-lib/src/lints.rs
+++ b/selene-lib/src/lints.rs
@@ -196,24 +196,79 @@ impl Diagnostic {
         self.fixed_code.is_some() && self.applicability == Applicability::MachineApplicable
     }
 
-    /// 1. Applies all disjoint fixes
-    /// 1. If a fix is completely contained inside another fix, uses the inner one and discard the outer one
-    /// 2. If fixes partially overlap, chooses the fix that starts first and discard the other one
-    pub fn get_applied_suggestions_code(code: &str, diagnostics: &[&Diagnostic]) -> String {
+    pub fn has_maybe_incorrect_fix(&self) -> bool {
+        self.fixed_code.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: Vec<&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.fixed_code {
+                    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())
+            .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 code.to_string(),
+            Some(first) => *first,
+            None => return Vec::new(),
         };
 
-        for diagnostic in sorted_diagnostics.iter().skip(1) {
+        for &diagnostic in sorted_diagnostics.iter().skip(1) {
             let this_range = diagnostic.primary_label.range;
 
             if this_range.1 <= candidate.primary_label.range.1 {
@@ -229,41 +284,7 @@ impl Diagnostic {
         }
         chosen_diagnostics.push(candidate);
 
-        let mut bytes_offset = 0;
-
-        let new_code = chosen_diagnostics
-            .iter()
-            .fold(code.to_string(), |code, diagnostic| {
-                if let Some(fixed) = &diagnostic.fixed_code {
-                    let (start, end) = diagnostic.primary_label.range;
-
-                    // This can theoretically overflow, but the user would face memory constraints
-                    // of such large strings long before
-                    let start_with_offset = start as isize + bytes_offset;
-                    let end_with_offset = end as isize + bytes_offset;
-
-                    let new_code = if start_with_offset > end_with_offset
-                        || end_with_offset > code.len().try_into().unwrap()
-                    {
-                        code.to_string()
-                    } else {
-                        format!(
-                            "{}{}{}",
-                            // Conversion is safe as range with offset will never be negative
-                            &code[..start_with_offset as usize],
-                            fixed.as_str(),
-                            &code[(end_with_offset as usize)..]
-                        )
-                    };
-
-                    bytes_offset += fixed.len() as isize - (end_with_offset - start_with_offset);
-                    new_code
-                } else {
-                    code
-                }
-            });
-
-        new_code
+        chosen_diagnostics
     }
 }
 
diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index de819bb9..8122316e 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -45,7 +45,7 @@ fn generate_diff(source1: &str, source2: &str, diagnostics: &[&Diagnostic]) -> S
     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 as u32;
+        let change_end_byte = byte_offset + change_length;
 
         let mut applicability_prefix = "    ";
         for diagnostic in diagnostics {
@@ -139,35 +139,45 @@ pub fn test_lint_config_with_output<
                     || diagnostic.applicability == Applicability::MaybeIncorrect)
         })
         .collect::<Vec<_>>();
-    let mut lint_results;
-
-    // To handle potential conflicts with different lint suggestions, we apply conflicting fixes one at a time.
-    // Then we re-evaluate the lints with the new code until there are no more fixes to apply
-    while fixed_diagnostics.iter().any(|diagnostic| {
-        diagnostic.fixed_code.is_some()
-            && (diagnostic.applicability == Applicability::MachineApplicable
-                || diagnostic.applicability == Applicability::MaybeIncorrect)
-    }) {
-        fixed_code =
-            Diagnostic::get_applied_suggestions_code(fixed_code.as_str(), &fixed_diagnostics);
-
-        let fixed_ast = full_moon::parse(&fixed_code).unwrap_or_else(|_| {
-            panic!(
-                "Fixer generated invalid code:\n\
+
+    fixed_code = Diagnostic::get_applied_suggestions_code(
+        fixed_code.as_str(),
+        fixed_diagnostics,
+        |new_code| {
+            println!("Fixer generated code:\n{}", 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()),
+            )
+        },
+    );
+
+    let fixed_ast = full_moon::parse(&fixed_code).unwrap_or_else(|_| {
+        panic!(
+            "Fixer generated invalid code:\n\
                 ----------------\n\
                 {}\n\
                 ----------------\n",
-                fixed_code
-            )
-        });
-        lint_results = lint.pass(
-            &fixed_ast,
-            &context,
-            &AstContext::from_ast(&fixed_ast, &fixed_code),
-        );
-        fixed_diagnostics = lint_results.iter().collect::<Vec<_>>();
-        fixed_diagnostics.sort_by_key(|diagnostic| diagnostic.start_position());
-    }
+            fixed_code
+        )
+    });
+    let lint_results = lint.pass(
+        &fixed_ast,
+        &context,
+        &AstContext::from_ast(&fixed_ast, &fixed_code),
+    );
+    fixed_diagnostics = lint_results.iter().collect::<Vec<_>>();
+    fixed_diagnostics.sort_by_key(|diagnostic| diagnostic.start_position());
 
     let fixed_diff = generate_diff(
         &lua_source,
diff --git a/selene/src/main.rs b/selene/src/main.rs
index 6b2d2f8c..375ea57c 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -295,27 +295,34 @@ fn read<R: Read>(
             .filter(|diagnostic| diagnostic.diagnostic.has_machine_applicable_fix())
             .count();
 
-        // To handle potential conflicts with different lint suggestions, we apply conflicting fixes one at a time.
-        // Then we re-evaluate the lints with the new code until there are no more fixes to apply
-        while diagnostics
-            .iter()
-            .any(|diagnostic| diagnostic.diagnostic.has_machine_applicable_fix())
-        {
-            fixed_code = Diagnostic::get_applied_suggestions_code(
-                fixed_code.as_str(),
-                &diagnostics
-                    .iter()
-                    .map(|diagnostic| &diagnostic.diagnostic)
-                    .collect::<Vec<_>>(),
-            );
+        fixed_code = Diagnostic::get_applied_suggestions_code(
+            fixed_code.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",
+                );
 
-            let fixed_ast = full_moon::parse(&fixed_code).expect(
+                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(&fixed_code).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, &fixed_code);
-            diagnostics.sort_by_key(|diagnostic| diagnostic.diagnostic.start_position());
-        }
+        diagnostics = checker.test_on(&fixed_ast, &fixed_code);
+        diagnostics.sort_by_key(|diagnostic| diagnostic.diagnostic.start_position());
 
         if num_fixes > 0 {
             if fs::write(filename, fixed_code.clone()).is_ok() {

From ad168a352876180b7969be378a85435ebdf69be6 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Wed, 18 Oct 2023 12:42:52 -0700
Subject: [PATCH 40/63] Remove unnecessary file

---
 .vscode/launch.json | 83 ---------------------------------------------
 1 file changed, 83 deletions(-)
 delete mode 100644 .vscode/launch.json

diff --git a/.vscode/launch.json b/.vscode/launch.json
deleted file mode 100644
index f93ddc80..00000000
--- a/.vscode/launch.json
+++ /dev/null
@@ -1,83 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug executable 'selene'",
-            "cargo": {
-                "args": [
-                    "build",
-                    "--bin=selene",
-                    "--package=selene"
-                ],
-                "filter": {
-                    "name": "selene",
-                    "kind": "bin"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}/selene-lib"
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug unit tests in executable 'selene'",
-            "cargo": {
-                "args": [
-                    "test",
-                    "--no-run",
-                    "--bin=selene",
-                    "--package=selene"
-                ],
-                "filter": {
-                    "name": "selene",
-                    "kind": "bin"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug unit tests in library 'selene-lib'",
-            "cargo": {
-                "args": [
-                    "test",
-                    "--no-run",
-                    "--lib",
-                    "--package=selene-lib"
-                ],
-                "filter": {
-                    "name": "selene-lib",
-                    "kind": "lib"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug integration test 'checker'",
-            "cargo": {
-                "args": [
-                    "test",
-                    "--no-run",
-                    "--test=checker",
-                    "--package=selene-lib"
-                ],
-                "filter": {
-                    "name": "checker",
-                    "kind": "test"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        }
-    ]
-}
\ No newline at end of file

From 0987940640458c98a1719576fa1bba8839d88e87 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Wed, 18 Oct 2023 12:54:52 -0700
Subject: [PATCH 41/63] Use assert_str_eq

---
 selene-lib/src/lints/test_util.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index 8122316e..50cb9f65 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -187,7 +187,7 @@ pub fn test_lint_config_with_output<
     let diff_output_path = path_base.with_extension("fixed.diff");
 
     if let Ok(expected) = fs::read_to_string(&diff_output_path) {
-        pretty_assertions::assert_eq!(PrettyString(&expected), PrettyString(&fixed_diff));
+        pretty_assertions::assert_str_eq!(&expected, &fixed_diff.as_str());
     } else {
         let mut output_file =
             fs::File::create(diff_output_path).expect("couldn't create fixed.diff output file");

From 0c6a30d96cf3d666a69b31cacb1d7957c7cbf860 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Wed, 18 Oct 2023 13:00:03 -0700
Subject: [PATCH 42/63] Change deprecated to maybeincorrect

---
 selene-lib/src/lints/constant_table_comparison.rs | 6 +-----
 selene-lib/src/lints/deprecated.rs                | 2 +-
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/selene-lib/src/lints/constant_table_comparison.rs b/selene-lib/src/lints/constant_table_comparison.rs
index 356c84b8..087a6dac 100644
--- a/selene-lib/src/lints/constant_table_comparison.rs
+++ b/selene-lib/src/lints/constant_table_comparison.rs
@@ -58,11 +58,7 @@ impl Lint for ConstantTableComparisonLint {
                     "comparing to a constant table will always fail".to_owned(),
                     Label::new(comparison.range),
                     suggestion.clone(),
-                    if suggestion.is_some() {
-                        Applicability::MaybeIncorrect
-                    } else {
-                        Applicability::Unspecified
-                    },
+                    Applicability::MaybeIncorrect,
                 )
             })
             .collect()
diff --git a/selene-lib/src/lints/deprecated.rs b/selene-lib/src/lints/deprecated.rs
index 95d01f38..1d2dd1fb 100644
--- a/selene-lib/src/lints/deprecated.rs
+++ b/selene-lib/src/lints/deprecated.rs
@@ -132,7 +132,7 @@ impl<'a> DeprecatedVisitor<'a> {
                 notes,
                 Vec::new(),
                 fixed_code,
-                Applicability::MachineApplicable,
+                Applicability::MaybeIncorrect,
             ));
         }
     }

From 84f648b4d2749658c26d0694d66f650306a6838c Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Wed, 18 Oct 2023 13:04:34 -0700
Subject: [PATCH 43/63] Update deprecated

---
 selene-lib/src/lints/test_util.rs                             | 1 -
 .../tests/lints/deprecated/deprecated_functions.fixed.diff    | 4 ++--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index 50cb9f65..d904513d 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -144,7 +144,6 @@ pub fn test_lint_config_with_output<
         fixed_code.as_str(),
         fixed_diagnostics,
         |new_code| {
-            println!("Fixer generated code:\n{}", new_code);
             let fixed_ast = full_moon::parse(new_code).unwrap_or_else(|_| {
                 panic!(
                     "Fixer generated invalid code:\n\
diff --git a/selene-lib/tests/lints/deprecated/deprecated_functions.fixed.diff b/selene-lib/tests/lints/deprecated/deprecated_functions.fixed.diff
index 26dbd0dc..d7659a2f 100644
--- a/selene-lib/tests/lints/deprecated/deprecated_functions.fixed.diff
+++ b/selene-lib/tests/lints/deprecated/deprecated_functions.fixed.diff
@@ -1,5 +1,5 @@
       table.foreach({}, function(k, v) end)
--[MA] print(table.getn(x))
-+[MA] print(#x)
+-[MI] print(table.getn(x))
++[MI] print(#x)
       
       table.foreach({}, 3)

From efe42735419c91d591def062da83539c475ca74e Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Wed, 18 Oct 2023 15:33:56 -0700
Subject: [PATCH 44/63] Add newline to expected diff

---
 selene-lib/src/lints/test_util.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index d904513d..1602fbdc 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -186,7 +186,7 @@ pub fn test_lint_config_with_output<
     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!(&expected, &fixed_diff.as_str());
+        pretty_assertions::assert_str_eq!(&(expected + "\n"), &fixed_diff.as_str());
     } else {
         let mut output_file =
             fs::File::create(diff_output_path).expect("couldn't create fixed.diff output file");

From 7d1ae68cd4bb1e549fe0a814c4141262d3befd4f Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Wed, 18 Oct 2023 15:37:53 -0700
Subject: [PATCH 45/63] Remove newline

---
 selene-lib/src/lints/test_util.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index 1602fbdc..478a7ad0 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -186,7 +186,7 @@ pub fn test_lint_config_with_output<
     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!(&(expected + "\n"), &fixed_diff.as_str());
+        pretty_assertions::assert_str_eq!(&expected, &fixed_diff);
     } else {
         let mut output_file =
             fs::File::create(diff_output_path).expect("couldn't create fixed.diff output file");

From 22b2feefc7a3c3f368d5f73d50f6a062a103ac66 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Wed, 18 Oct 2023 16:48:35 -0700
Subject: [PATCH 46/63] Normalize diff string

---
 selene-lib/src/lints/test_util.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index 478a7ad0..4c5640eb 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -186,7 +186,10 @@ pub fn test_lint_config_with_output<
     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!(&expected, &fixed_diff);
+        pretty_assertions::assert_str_eq!(
+            &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");

From 6749c77145c32bc26e1293dc28dfee2da1153601 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Wed, 18 Oct 2023 17:19:52 -0700
Subject: [PATCH 47/63] Add unused self fix

---
 selene-lib/src/lints/test_util.rs             |  2 ++
 selene-lib/src/lints/unused_variable.rs       | 20 +++++++++++++------
 .../lints/unused_variable/self.fixed.diff     |  9 +++++++++
 .../tests/lints/unused_variable/self.lua      |  1 +
 .../tests/lints/unused_variable/self.stderr   | 13 ++++++++++--
 5 files changed, 37 insertions(+), 8 deletions(-)

diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index 4c5640eb..a6a2ab07 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -187,6 +187,8 @@ pub fn test_lint_config_with_output<
 
     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")
         );
diff --git a/selene-lib/src/lints/unused_variable.rs b/selene-lib/src/lints/unused_variable.rs
index 067c48ff..e3f40431 100644
--- a/selene-lib/src/lints/unused_variable.rs
+++ b/selene-lib/src/lints/unused_variable.rs
@@ -156,8 +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 fixed_code = Some(format!("_{}", variable.name));
+                let mut applicability = Applicability::MachineApplicable;
 
                 if variable.is_self {
                     if self.allow_unused_self {
@@ -168,13 +170,19 @@ impl Lint for UnusedVariableLint {
                     notes
                         .push("if you don't need it, consider using `.` instead of `:`".to_owned());
 
-                    // Applying fix by changing `:` to `.` would break any existing methods calls
-                    fixed_code = None;
+                    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;
+                        fixed_code = Some(".".to_string());
+                    }
                 }
 
                 // Applying fix would cause existing references to reference a nonexistent variable. It's possible to
-                // also rename those references as well, but we'd need to check each of their scopes for potentially
-                // colliding variables. Clippy just doesn't apply a fix at all in these cases.
+                // 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
@@ -193,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()
@@ -206,7 +214,7 @@ impl Lint for UnusedVariableLint {
                         })
                         .collect(),
                     fixed_code,
-                    Applicability::MachineApplicable,
+                    applicability,
                 ));
             };
         }
diff --git a/selene-lib/tests/lints/unused_variable/self.fixed.diff b/selene-lib/tests/lints/unused_variable/self.fixed.diff
index e69de29b..122a9dbe 100644
--- a/selene-lib/tests/lints/unused_variable/self.fixed.diff
+++ 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 `:`

From 67b740af88c23df9e5b746e20a5022de70cde85a Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Wed, 18 Oct 2023 17:26:59 -0700
Subject: [PATCH 48/63] Rename fixed_code to suggestion

---
 selene-lib/src/lints.rs                    | 20 +++++++++---------
 selene-lib/src/lints/compare_nan.rs        |  4 ++--
 selene-lib/src/lints/deprecated.rs         |  6 +++---
 selene-lib/src/lints/test_util.rs          | 16 +++++++--------
 selene-lib/src/lints/unused_variable.rs    |  8 ++++----
 selene-vscode/src/extension.ts             |  6 +++---
 selene-vscode/src/structures/diagnostic.ts |  8 ++++----
 selene/src/json_output.rs                  |  6 +++---
 selene/src/main.rs                         | 24 +++++++++++-----------
 9 files changed, 49 insertions(+), 49 deletions(-)

diff --git a/selene-lib/src/lints.rs b/selene-lib/src/lints.rs
index 514528b1..246fde48 100644
--- a/selene-lib/src/lints.rs
+++ b/selene-lib/src/lints.rs
@@ -117,7 +117,7 @@ pub struct Diagnostic {
     pub notes: Vec<String>,
     pub primary_label: Label,
     pub secondary_labels: Vec<Label>,
-    pub fixed_code: Option<String>,
+    pub suggestion: Option<String>,
     pub applicability: Applicability,
 }
 
@@ -126,11 +126,11 @@ impl Diagnostic {
         code: &'static str,
         message: String,
         primary_label: Label,
-        fixed_code: Option<String>,
+        suggestion: Option<String>,
         applicability: Applicability,
     ) -> Self {
-        let notes = if let Some(ref fixed_code_str) = fixed_code {
-            vec![format!("try: `{}`", fixed_code_str)]
+        let notes = if let Some(ref suggestion_str) = suggestion {
+            vec![format!("try: `{}`", suggestion_str)]
         } else {
             Vec::new()
         };
@@ -139,7 +139,7 @@ impl Diagnostic {
             code,
             message,
             primary_label,
-            fixed_code,
+            suggestion,
             applicability,
             notes,
 
@@ -153,7 +153,7 @@ impl Diagnostic {
         primary_label: Label,
         notes: Vec<String>,
         secondary_labels: Vec<Label>,
-        fixed_code: Option<String>,
+        suggestion: Option<String>,
         applicability: Applicability,
     ) -> Self {
         Self {
@@ -162,7 +162,7 @@ impl Diagnostic {
             notes,
             primary_label,
             secondary_labels,
-            fixed_code,
+            suggestion,
             applicability,
         }
     }
@@ -193,11 +193,11 @@ impl Diagnostic {
     }
 
     pub fn has_machine_applicable_fix(&self) -> bool {
-        self.fixed_code.is_some() && self.applicability == Applicability::MachineApplicable
+        self.suggestion.is_some() && self.applicability == Applicability::MachineApplicable
     }
 
     pub fn has_maybe_incorrect_fix(&self) -> bool {
-        self.fixed_code.is_some() && self.applicability == Applicability::MaybeIncorrect
+        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
@@ -219,7 +219,7 @@ impl Diagnostic {
             let mut bytes_offset = 0;
 
             for diagnostic in chosen_diagnostics {
-                if let Some(suggestion) = &diagnostic.fixed_code {
+                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
diff --git a/selene-lib/src/lints/compare_nan.rs b/selene-lib/src/lints/compare_nan.rs
index 56527a78..d7ed4c0c 100644
--- a/selene-lib/src/lints/compare_nan.rs
+++ b/selene-lib/src/lints/compare_nan.rs
@@ -30,7 +30,7 @@ impl Lint for CompareNanLint {
             .comparisons
             .iter()
             .map(|comparisons| {
-                let fixed_code = format!(
+                let suggestion = format!(
                     "{variable} {operator} {variable}",
                     variable = comparisons.variable,
                     operator = comparisons.operator,
@@ -40,7 +40,7 @@ impl Lint for CompareNanLint {
                     "compare_nan",
                     "comparing things to nan directly is not allowed".to_owned(),
                     Label::new(comparisons.range),
-                    Some(fixed_code),
+                    Some(suggestion),
                     Applicability::MaybeIncorrect,
                 )
             })
diff --git a/selene-lib/src/lints/deprecated.rs b/selene-lib/src/lints/deprecated.rs
index 1d2dd1fb..96d7cfb0 100644
--- a/selene-lib/src/lints/deprecated.rs
+++ b/selene-lib/src/lints/deprecated.rs
@@ -115,11 +115,11 @@ impl<'a> DeprecatedVisitor<'a> {
 
             let mut notes = vec![deprecated.message.to_owned()];
 
-            let mut fixed_code = None;
+            let mut suggestion = None;
 
             if let Some(replace_with) = deprecated.try_instead(parameters) {
                 notes.push(format!("try: {replace_with}"));
-                fixed_code = Some(replace_with);
+                suggestion = Some(replace_with);
             }
 
             self.diagnostics.push(Diagnostic::new_complete(
@@ -131,7 +131,7 @@ impl<'a> DeprecatedVisitor<'a> {
                 Label::from_node(node, None),
                 notes,
                 Vec::new(),
-                fixed_code,
+                suggestion,
                 Applicability::MaybeIncorrect,
             ));
         }
diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index a6a2ab07..d14609ed 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -130,18 +130,18 @@ pub fn test_lint_config_with_output<
     let mut diagnostics = lint.pass(&ast, &context, &AstContext::from_ast(&ast, &lua_source));
     diagnostics.sort_by_key(|diagnostic| diagnostic.primary_label.range);
 
-    let mut fixed_code = lua_source.to_string();
+    let mut suggestion = lua_source.to_string();
     let mut fixed_diagnostics = diagnostics
         .iter()
         .filter(|diagnostic| {
-            diagnostic.fixed_code.is_some()
+            diagnostic.suggestion.is_some()
                 && (diagnostic.applicability == Applicability::MachineApplicable
                     || diagnostic.applicability == Applicability::MaybeIncorrect)
         })
         .collect::<Vec<_>>();
 
-    fixed_code = Diagnostic::get_applied_suggestions_code(
-        fixed_code.as_str(),
+    suggestion = Diagnostic::get_applied_suggestions_code(
+        suggestion.as_str(),
         fixed_diagnostics,
         |new_code| {
             let fixed_ast = full_moon::parse(new_code).unwrap_or_else(|_| {
@@ -161,26 +161,26 @@ pub fn test_lint_config_with_output<
         },
     );
 
-    let fixed_ast = full_moon::parse(&fixed_code).unwrap_or_else(|_| {
+    let fixed_ast = full_moon::parse(&suggestion).unwrap_or_else(|_| {
         panic!(
             "Fixer generated invalid code:\n\
                 ----------------\n\
                 {}\n\
                 ----------------\n",
-            fixed_code
+            suggestion
         )
     });
     let lint_results = lint.pass(
         &fixed_ast,
         &context,
-        &AstContext::from_ast(&fixed_ast, &fixed_code),
+        &AstContext::from_ast(&fixed_ast, &suggestion),
     );
     fixed_diagnostics = lint_results.iter().collect::<Vec<_>>();
     fixed_diagnostics.sort_by_key(|diagnostic| diagnostic.start_position());
 
     let fixed_diff = generate_diff(
         &lua_source,
-        &fixed_code,
+        &suggestion,
         &diagnostics.iter().collect::<Vec<_>>(),
     );
     let diff_output_path = path_base.with_extension("fixed.diff");
diff --git a/selene-lib/src/lints/unused_variable.rs b/selene-lib/src/lints/unused_variable.rs
index e3f40431..00662cd8 100644
--- a/selene-lib/src/lints/unused_variable.rs
+++ b/selene-lib/src/lints/unused_variable.rs
@@ -158,7 +158,7 @@ impl Lint for UnusedVariableLint {
                 let mut notes = Vec::new();
                 let mut report_range = variable.identifiers[0];
 
-                let mut fixed_code = Some(format!("_{}", variable.name));
+                let mut suggestion = Some(format!("_{}", variable.name));
                 let mut applicability = Applicability::MachineApplicable;
 
                 if variable.is_self {
@@ -177,7 +177,7 @@ impl Lint for UnusedVariableLint {
 
                         // Applying fix by changing `:` to `.` would break any existing methods calls
                         applicability = Applicability::MaybeIncorrect;
-                        fixed_code = Some(".".to_string());
+                        suggestion = Some(".".to_string());
                     }
                 }
 
@@ -189,7 +189,7 @@ impl Lint for UnusedVariableLint {
                         .0
                         != variable.identifiers[0].0
                 }) {
-                    fixed_code = None;
+                    suggestion = None;
                 }
 
                 let write_only = !analyzed_references.is_empty();
@@ -213,7 +213,7 @@ impl Lint for UnusedVariableLint {
                             }
                         })
                         .collect(),
-                    fixed_code,
+                    suggestion,
                     applicability,
                 ));
             };
diff --git a/selene-vscode/src/extension.ts b/selene-vscode/src/extension.ts
index fe9de97d..23219116 100644
--- a/selene-vscode/src/extension.ts
+++ b/selene-vscode/src/extension.ts
@@ -34,7 +34,7 @@ class SeleneCodeActionProvider implements vscode.CodeActionProvider {
         for (const diagnostic of context.diagnostics) {
             if (
                 diagnostic instanceof SeleneDiagnostic &&
-                diagnostic.fixed_code
+                diagnostic.suggestion
             ) {
                 const action = new vscode.CodeAction(
                     `fix: ${diagnostic.message}`,
@@ -46,7 +46,7 @@ class SeleneCodeActionProvider implements vscode.CodeActionProvider {
                 action.edit.replace(
                     document.uri,
                     diagnostic.range,
-                    diagnostic.fixed_code,
+                    diagnostic.suggestion,
                 )
 
                 codeActions.push(action)
@@ -256,7 +256,7 @@ export async function activate(
                 data.severity === Severity.Error
                     ? vscode.DiagnosticSeverity.Error
                     : vscode.DiagnosticSeverity.Warning,
-                data.fixed_code,
+                data.suggestion,
             )
 
             diagnostic.source = `selene::${data.code}`
diff --git a/selene-vscode/src/structures/diagnostic.ts b/selene-vscode/src/structures/diagnostic.ts
index 72d8db1f..4e3f23ac 100644
--- a/selene-vscode/src/structures/diagnostic.ts
+++ b/selene-vscode/src/structures/diagnostic.ts
@@ -20,19 +20,19 @@ export interface Diagnostic {
     notes: string[]
     primary_label: Label
     secondary_labels: Label[]
-    fixed_code: string
+    suggestion: string
 }
 
 export class SeleneDiagnostic extends vscode.Diagnostic {
-    fixed_code?: string
+    suggestion?: string
 
     constructor(
         range: vscode.Range,
         message: string,
         severity: vscode.DiagnosticSeverity,
-        fixed_code?: string,
+        suggestion?: string,
     ) {
         super(range, message, severity)
-        this.fixed_code = fixed_code
+        this.suggestion = suggestion
     }
 }
diff --git a/selene/src/json_output.rs b/selene/src/json_output.rs
index da27acc8..e65dcdcd 100644
--- a/selene/src/json_output.rs
+++ b/selene/src/json_output.rs
@@ -30,7 +30,7 @@ pub struct JsonDiagnostic {
     primary_label: Label,
     notes: Vec<String>,
     secondary_labels: Vec<Label>,
-    fixed_code: Option<String>,
+    suggestion: Option<String>,
 }
 
 #[derive(Serialize)]
@@ -78,7 +78,7 @@ fn label_to_serializable(
 pub fn diagnostic_to_json(
     diagnostic: &CodespanDiagnostic<codespan::FileId>,
     files: &codespan::Files<&str>,
-    fixed_code: Option<String>,
+    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();
@@ -95,7 +95,7 @@ pub fn diagnostic_to_json(
             .filter(|label| label.style == LabelStyle::Secondary)
             .map(|label| label_to_serializable(&filename, label, files))
             .collect(),
-        fixed_code,
+        suggestion,
     }
 }
 
diff --git a/selene/src/main.rs b/selene/src/main.rs
index 375ea57c..ecc4838f 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -130,7 +130,7 @@ fn emit_codespan(
     writer: &mut impl termcolor::WriteColor,
     files: &codespan::Files<&str>,
     diagnostic: &CodespanDiagnostic<codespan::FileId>,
-    fixed_code: Option<String>,
+    suggestion: Option<String>,
 ) {
     let lock = OPTIONS.read().unwrap();
     let opts = lock.as_ref().unwrap();
@@ -150,7 +150,7 @@ fn emit_codespan(
                 writer,
                 "{}",
                 serde_json::to_string(&json_output::diagnostic_to_json(
-                    diagnostic, files, fixed_code
+                    diagnostic, files, suggestion
                 ))
                 .unwrap()
             )
@@ -162,7 +162,7 @@ fn emit_codespan(
                 writer,
                 "{}",
                 serde_json::to_string(&json_output::JsonOutput::Diagnostic(
-                    json_output::diagnostic_to_json(diagnostic, files, fixed_code)
+                    json_output::diagnostic_to_json(diagnostic, files, suggestion)
                 ))
                 .unwrap()
             )
@@ -286,7 +286,7 @@ fn read<R: Read>(
     let mut diagnostics = checker.test_on(&ast, &contents.as_ref().to_string());
     diagnostics.sort_by_key(|diagnostic| diagnostic.diagnostic.start_position());
 
-    let mut fixed_code = contents.as_ref().to_string();
+    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
@@ -295,8 +295,8 @@ fn read<R: Read>(
             .filter(|diagnostic| diagnostic.diagnostic.has_machine_applicable_fix())
             .count();
 
-        fixed_code = Diagnostic::get_applied_suggestions_code(
-            fixed_code.as_str(),
+        suggestion = Diagnostic::get_applied_suggestions_code(
+            suggestion.as_str(),
             diagnostics
                 .iter()
                 .filter(|diagnostic| diagnostic.diagnostic.has_machine_applicable_fix())
@@ -317,16 +317,16 @@ fn read<R: Read>(
             },
         );
 
-        let fixed_ast = full_moon::parse(&fixed_code).expect(
+        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, &fixed_code);
+        diagnostics = checker.test_on(&fixed_ast, &suggestion);
         diagnostics.sort_by_key(|diagnostic| diagnostic.diagnostic.start_position());
 
         if num_fixes > 0 {
-            if fs::write(filename, fixed_code.clone()).is_ok() {
-                files.update(source_id, &fixed_code);
+            if fs::write(filename, suggestion.clone()).is_ok() {
+                files.update(source_id, &suggestion);
 
                 let stdout = StandardStream::stdout(get_color());
                 let mut stdout = stdout.lock();
@@ -444,7 +444,7 @@ fn read<R: Read>(
                 write(&mut stack, new_start).unwrap();
             }
         } else {
-            let fixed_code = diagnostic.diagnostic.fixed_code.clone();
+            let suggestion = diagnostic.diagnostic.suggestion.clone();
             let diagnostic = diagnostic.diagnostic.into_codespan_diagnostic(
                 source_id,
                 match diagnostic.severity {
@@ -454,7 +454,7 @@ fn read<R: Read>(
                 },
             );
 
-            emit_codespan(&mut stdout, &files, &diagnostic, fixed_code);
+            emit_codespan(&mut stdout, &files, &diagnostic, suggestion);
         }
     }
 }

From f6f01962a66e99e8a5094055b389b1b45d947ab5 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Wed, 18 Oct 2023 17:39:50 -0700
Subject: [PATCH 49/63] Update vscode diagnostics message

---
 selene-vscode/src/extension.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/selene-vscode/src/extension.ts b/selene-vscode/src/extension.ts
index 23219116..221759d6 100644
--- a/selene-vscode/src/extension.ts
+++ b/selene-vscode/src/extension.ts
@@ -37,7 +37,7 @@ class SeleneCodeActionProvider implements vscode.CodeActionProvider {
                 diagnostic.suggestion
             ) {
                 const action = new vscode.CodeAction(
-                    `fix: ${diagnostic.message}`,
+                    diagnostic.message,
                     vscode.CodeActionKind.QuickFix,
                 )
                 action.diagnostics = [diagnostic]

From 0acb630a900edf26ad1fa71977e2e1502ce99014 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Wed, 18 Oct 2023 18:06:04 -0700
Subject: [PATCH 50/63] Move suggestion message to label

---
 selene-lib/src/lints.rs                       | 13 +++----
 .../almost_swapped/almost_swapped.stderr      | 12 ++-----
 .../lua51_string_escapes.stderr               |  8 ++---
 .../roblox_string_escapes.stderr              |  8 ++---
 .../lints/compare_nan/compare_nan_if.stderr   |  8 ++---
 .../compare_nan/compare_nan_variables.stderr  |  8 ++---
 .../constant_table_comparison.stderr          | 20 +++--------
 .../divide_by_zero/divide_by_zero.stderr      |  8 ++---
 .../tests/lints/empty_loop/empty_loop.stderr  | 36 +++++--------------
 .../empty_loop/empty_loop_comments.stderr     | 28 ++++-----------
 .../parenthese_conditions.stderr              | 32 +++++------------
 .../lints/standard_library/method_call.stderr |  4 +--
 .../unscoped_variables.stderr                 |  8 ++---
 13 files changed, 53 insertions(+), 140 deletions(-)

diff --git a/selene-lib/src/lints.rs b/selene-lib/src/lints.rs
index 246fde48..2704ccfa 100644
--- a/selene-lib/src/lints.rs
+++ b/selene-lib/src/lints.rs
@@ -129,20 +129,21 @@ impl Diagnostic {
         suggestion: Option<String>,
         applicability: Applicability,
     ) -> Self {
-        let notes = if let Some(ref suggestion_str) = suggestion {
-            vec![format!("try: `{}`", suggestion_str)]
-        } else {
-            Vec::new()
+        let mut label = primary_label;
+        if let Some(ref suggestion_str) = suggestion {
+            if label.message.is_none() {
+                label = Label::new_with_message(label.range, format!("try: `{}`", suggestion_str));
+            }
         };
 
         Self {
             code,
             message,
-            primary_label,
+            primary_label: label,
             suggestion,
             applicability,
-            notes,
 
+            notes: Vec::new(),
             secondary_labels: Vec::new(),
         }
     }
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/bad_string_escape/lua51_string_escapes.stderr b/selene-lib/tests/lints/bad_string_escape/lua51_string_escapes.stderr
index 12508462..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,17 +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: `'`
+   │            ^^ 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: `"`
+   │            ^^ 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.stderr b/selene-lib/tests/lints/bad_string_escape/roblox_string_escapes.stderr
index 3c4bc975..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,17 +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: `'`
+   │            ^^ 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: `"`
+   │            ^^ 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.stderr b/selene-lib/tests/lints/compare_nan/compare_nan_if.stderr
index 34d34c6f..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`
+  │    ^^^^^^^^ 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`
+  │    ^^^^^^^^ try: `x == x`
 
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 776c66bb..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`
+  │           ^^^^^^^^ 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`
+  │           ^^^^^^^^ try: `x ~= x`
 
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/divide_by_zero/divide_by_zero.stderr b/selene-lib/tests/lints/divide_by_zero/divide_by_zero.stderr
index d20d0485..246657c2 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
@@ -2,15 +2,11 @@ error[divide_by_zero]: dividing by zero is not readable
   ┌─ divide_by_zero.lua:2:11
   │
 2 │ local _ = 5 / 0
-  │           ^^^^^
-  │
-  = try: `math.huge()`
+  │           ^^^^^ try: `math.huge()`
 
 error[divide_by_zero]: dividing by zero is not readable
   ┌─ divide_by_zero.lua:4:11
   │
 4 │ local _ = x / 0
-  │           ^^^^^
-  │
-  = try: `math.huge()`
+  │           ^^^^^ try: `math.huge()`
 
diff --git a/selene-lib/tests/lints/empty_loop/empty_loop.stderr b/selene-lib/tests/lints/empty_loop/empty_loop.stderr
index 183daa8f..d06bdde0 100644
--- a/selene-lib/tests/lints/empty_loop/empty_loop.stderr
+++ b/selene-lib/tests/lints/empty_loop/empty_loop.stderr
@@ -4,9 +4,7 @@ error[empty_loop]: empty loop block
  9 │ ╭ for _ = 1, 10 do
 10 │ │     -- Should warn
 11 │ │ end
-   │ ╰───^
-   │  
-   = try: ``
+   │ ╰───^ try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:13:1
@@ -16,9 +14,7 @@ error[empty_loop]: empty loop block
 15 │ │     Should warn
 16 │ │     ]]
 17 │ │ end
-   │ ╰───^
-   │  
-   = try: ``
+   │ ╰───^ try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:19:1
@@ -28,61 +24,47 @@ error[empty_loop]: empty loop block
 21 │ │ 
 22 │ │     
 23 │ │ end
-   │ ╰───^
-   │  
-   = try: ``
+   │ ╰───^ try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:29:1
    │  
 29 │ ╭ for _ in pairs({}) do
 30 │ │ end
-   │ ╰───^
-   │  
-   = try: ``
+   │ ╰───^ try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:36:1
    │  
 36 │ ╭ for _ in ipairs({}) do
 37 │ │ end
-   │ ╰───^
-   │  
-   = try: ``
+   │ ╰───^ try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:43:1
    │  
 43 │ ╭ for _ in {} do
 44 │ │ end
-   │ ╰───^
-   │  
-   = try: ``
+   │ ╰───^ try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:50:1
    │  
 50 │ ╭ for _ in a() do
 51 │ │ end
-   │ ╰───^
-   │  
-   = try: ``
+   │ ╰───^ try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:57:1
    │  
 57 │ ╭ while true do
 58 │ │ end
-   │ ╰───^
-   │  
-   = try: ``
+   │ ╰───^ try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:64:1
    │  
 64 │ ╭ repeat
 65 │ │ until true
-   │ ╰──────────^
-   │  
-   = try: ``
+   │ ╰──────────^ try: ``
 
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 405eda83..5c244a27 100644
--- a/selene-lib/tests/lints/empty_loop/empty_loop_comments.stderr
+++ b/selene-lib/tests/lints/empty_loop/empty_loop_comments.stderr
@@ -6,61 +6,47 @@ error[empty_loop]: empty loop block
 21 │ │ 
 22 │ │ 
 23 │ │ end
-   │ ╰───^
-   │  
-   = try: ``
+   │ ╰───^ try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:29:1
    │  
 29 │ ╭ for _ in pairs({}) do
 30 │ │ end
-   │ ╰───^
-   │  
-   = try: ``
+   │ ╰───^ try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:36:1
    │  
 36 │ ╭ for _ in ipairs({}) do
 37 │ │ end
-   │ ╰───^
-   │  
-   = try: ``
+   │ ╰───^ try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:43:1
    │  
 43 │ ╭ for _ in {} do
 44 │ │ end
-   │ ╰───^
-   │  
-   = try: ``
+   │ ╰───^ try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:50:1
    │  
 50 │ ╭ for _ in a() do
 51 │ │ end
-   │ ╰───^
-   │  
-   = try: ``
+   │ ╰───^ try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:57:1
    │  
 57 │ ╭ while true do
 58 │ │ end
-   │ ╰───^
-   │  
-   = try: ``
+   │ ╰───^ try: ``
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:64:1
    │  
 64 │ ╭ repeat
 65 │ │ until true
-   │ ╰──────────^
-   │  
-   = try: ``
+   │ ╰──────────^ try: ``
 
diff --git a/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.stderr b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.stderr
index f42e84f6..607683ce 100644
--- a/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.stderr
+++ b/selene-lib/tests/lints/parenthese_conditions/parenthese_conditions.stderr
@@ -2,41 +2,31 @@ error[parenthese_conditions]: lua does not require parentheses around conditions
   ┌─ parenthese_conditions.lua:2:4
   │
 2 │ if (x) then end
-  │    ^^^
-  │
-  = try: `x`
+  │    ^^^ try: `x`
 
 error[parenthese_conditions]: lua does not require parentheses around conditions
   ┌─ parenthese_conditions.lua:4:4
   │
 4 │ if (x) then
-  │    ^^^
-  │
-  = try: `x`
+  │    ^^^ try: `x`
 
 error[parenthese_conditions]: lua does not require parentheses around conditions
   ┌─ parenthese_conditions.lua:6:8
   │
 6 │ elseif (z) then
-  │        ^^^
-  │
-  = try: `z`
+  │        ^^^ try: `z`
 
 error[parenthese_conditions]: lua does not require parentheses around conditions
    ┌─ parenthese_conditions.lua:10:7
    │
 10 │ while (true) do end
-   │       ^^^^^^
-   │
-   = try: `true`
+   │       ^^^^^^ try: `true`
 
 error[parenthese_conditions]: lua does not require parentheses around conditions
    ┌─ parenthese_conditions.lua:13:14
    │
 13 │ repeat until (false)
-   │              ^^^^^^^
-   │
-   = try: `false`
+   │              ^^^^^^^ try: `false`
 
 error[parenthese_conditions]: lua does not require parentheses around conditions
    ┌─ parenthese_conditions.lua:17:4
@@ -45,17 +35,13 @@ error[parenthese_conditions]: lua does not require parentheses around conditions
    │ ╭────^
 18 │ │     if (x) then end
 19 │ │ end)()) then end
-   │ ╰───────^
-   │  
-   = try: `(function()
-         if (x) then end
-     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`
+   │        ^^^ try: `x`
 
diff --git a/selene-lib/tests/lints/standard_library/method_call.stderr b/selene-lib/tests/lints/standard_library/method_call.stderr
index 804b2f80..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/unscoped_variables/unscoped_variables.stderr b/selene-lib/tests/lints/unscoped_variables/unscoped_variables.stderr
index b85d4c38..541568a5 100644
--- a/selene-lib/tests/lints/unscoped_variables/unscoped_variables.stderr
+++ b/selene-lib/tests/lints/unscoped_variables/unscoped_variables.stderr
@@ -2,15 +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`
+  │ ^^^ 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`
+   │     ^^^ try: `local baz`
 

From a345f308fa6590c4a3ee0ea402dadc27aabf5c46 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Wed, 18 Oct 2023 18:13:29 -0700
Subject: [PATCH 51/63] Change ` to better message

---
 selene-lib/src/lints.rs                        |  9 ++++++++-
 .../tests/lints/empty_loop/empty_loop.stderr   | 18 +++++++++---------
 .../empty_loop/empty_loop_comments.stderr      | 14 +++++++-------
 3 files changed, 24 insertions(+), 17 deletions(-)

diff --git a/selene-lib/src/lints.rs b/selene-lib/src/lints.rs
index 2704ccfa..d3ba8989 100644
--- a/selene-lib/src/lints.rs
+++ b/selene-lib/src/lints.rs
@@ -132,7 +132,14 @@ impl Diagnostic {
         let mut label = primary_label;
         if let Some(ref suggestion_str) = suggestion {
             if label.message.is_none() {
-                label = Label::new_with_message(label.range, format!("try: `{}`", suggestion_str));
+                label = Label::new_with_message(
+                    label.range,
+                    if suggestion_str.is_empty() {
+                        "consider removing this".to_string()
+                    } else {
+                        format!("try: `{}`", suggestion_str)
+                    },
+                );
             }
         };
 
diff --git a/selene-lib/tests/lints/empty_loop/empty_loop.stderr b/selene-lib/tests/lints/empty_loop/empty_loop.stderr
index d06bdde0..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
-   │ ╰───^ try: ``
+   │ ╰───^ 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
-   │ ╰───^ try: ``
+   │ ╰───^ 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
-   │ ╰───^ try: ``
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:29:1
    │  
 29 │ ╭ for _ in pairs({}) do
 30 │ │ end
-   │ ╰───^ try: ``
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:36:1
    │  
 36 │ ╭ for _ in ipairs({}) do
 37 │ │ end
-   │ ╰───^ try: ``
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:43:1
    │  
 43 │ ╭ for _ in {} do
 44 │ │ end
-   │ ╰───^ try: ``
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:50:1
    │  
 50 │ ╭ for _ in a() do
 51 │ │ end
-   │ ╰───^ try: ``
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:57:1
    │  
 57 │ ╭ while true do
 58 │ │ end
-   │ ╰───^ try: ``
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop.lua:64:1
    │  
 64 │ ╭ repeat
 65 │ │ until true
-   │ ╰──────────^ try: ``
+   │ ╰──────────^ consider removing this
 
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 5c244a27..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
-   │ ╰───^ try: ``
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:29:1
    │  
 29 │ ╭ for _ in pairs({}) do
 30 │ │ end
-   │ ╰───^ try: ``
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:36:1
    │  
 36 │ ╭ for _ in ipairs({}) do
 37 │ │ end
-   │ ╰───^ try: ``
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:43:1
    │  
 43 │ ╭ for _ in {} do
 44 │ │ end
-   │ ╰───^ try: ``
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:50:1
    │  
 50 │ ╭ for _ in a() do
 51 │ │ end
-   │ ╰───^ try: ``
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:57:1
    │  
 57 │ ╭ while true do
 58 │ │ end
-   │ ╰───^ try: ``
+   │ ╰───^ consider removing this
 
 error[empty_loop]: empty loop block
    ┌─ empty_loop_comments.lua:64:1
    │  
 64 │ ╭ repeat
 65 │ │ until true
-   │ ╰──────────^ try: ``
+   │ ╰──────────^ consider removing this
 

From 0810cc69344fe5b8161d97fdc6dcf9a888666ce6 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Wed, 18 Oct 2023 18:26:34 -0700
Subject: [PATCH 52/63] Normalize assertion strings

---
 selene-lib/src/lints/test_util.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index d14609ed..5216d385 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -222,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

From b3a29dc49dc1599aa2dc09900aa2c6968fb9e7a2 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 21 Oct 2023 14:41:16 -0700
Subject: [PATCH 53/63] Fix clippy error

---
 selene/src/main.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/selene/src/main.rs b/selene/src/main.rs
index ecc4838f..48510682 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -303,7 +303,7 @@ fn read<R: Read>(
                 .map(|diagnostic| &diagnostic.diagnostic)
                 .collect::<Vec<_>>(),
             |new_code| {
-                let new_ast = full_moon::parse(&new_code).expect(
+                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",
                 );

From 23aa26f043e0ea97918d768c3f7e5d43ae3f665e Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 4 Nov 2023 14:48:12 -0700
Subject: [PATCH 54/63] Test

---
 .pre-commit-hooks.yaml | 15 +++++++++++++++
 Dockerfile             | 20 ++++++++++----------
 2 files changed, 25 insertions(+), 10 deletions(-)
 create mode 100644 .pre-commit-hooks.yaml

diff --git a/.pre-commit-hooks.yaml b/.pre-commit-hooks.yaml
new file mode 100644
index 00000000..e4cb7416
--- /dev/null
+++ b/.pre-commit-hooks.yaml
@@ -0,0 +1,15 @@
+- id: selene-system
+  name: selene (system)
+  description: An opinionated Lua code linter
+  entry: selene
+  language: system
+  types:
+      - lua
+
+- id: selene-docker
+  name: selene (docker)
+  description: An opinionated Lua code linter
+  entry: /selene
+  language: docker
+  types:
+      - lua
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
index 5e3abffa..a69bf8ee 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,11 +1,5 @@
 ARG RUST_VERSION="1"
 
-FROM rust:${RUST_VERSION}-bullseye AS selene-builder
-RUN apt-get update && \
-    apt-get upgrade -y && \
-    apt-get install g++ && \
-    cargo install --branch main --git https://github.com/Kampfkarren/selene selene
-
 FROM rust:${RUST_VERSION}-bullseye AS selene-light-builder
 RUN apt-get update && \
     apt-get upgrade -y && \
@@ -20,9 +14,11 @@ FROM rust:${RUST_VERSION}-alpine AS selene-light-musl-builder
 RUN apk add g++ && \
     cargo install --no-default-features --branch main --git https://github.com/Kampfkarren/selene selene
 
-FROM bash AS selene
-COPY --from=selene-builder /usr/local/cargo/bin/selene /
-CMD ["/selene"]
+FROM rust:${RUST_VERSION}-bullseye AS selene-builder
+RUN apt-get update && \
+    apt-get upgrade -y && \
+    apt-get install g++ && \
+    cargo install --branch main --git https://github.com/Kampfkarren/selene selene
 
 FROM bash AS selene-light
 COPY --from=selene-light-builder /usr/local/cargo/bin/selene /
@@ -34,4 +30,8 @@ CMD ["/selene"]
 
 FROM bash AS selene-light-musl
 COPY --from=selene-light-musl-builder /usr/local/cargo/bin/selene /
-CMD ["/selene"]
\ No newline at end of file
+CMD ["/selene"]
+
+FROM bash AS selene
+COPY --from=selene-builder /usr/local/cargo/bin/selene /
+CMD ["/selene"]

From c23ba1133c503f2eb08eb1432038f12d2d8ef05b Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 4 Nov 2023 14:59:33 -0700
Subject: [PATCH 55/63] Test

---
 Dockerfile | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index a69bf8ee..763a7ffa 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,5 +1,11 @@
 ARG RUST_VERSION="1"
 
+FROM rust:${RUST_VERSION}-bullseye AS selene-builder
+RUN apt-get update && \
+    apt-get upgrade -y && \
+    apt-get install g++ && \
+    cargo install --branch main --git https://github.com/Kampfkarren/selene selene
+
 FROM rust:${RUST_VERSION}-bullseye AS selene-light-builder
 RUN apt-get update && \
     apt-get upgrade -y && \
@@ -14,12 +20,6 @@ FROM rust:${RUST_VERSION}-alpine AS selene-light-musl-builder
 RUN apk add g++ && \
     cargo install --no-default-features --branch main --git https://github.com/Kampfkarren/selene selene
 
-FROM rust:${RUST_VERSION}-bullseye AS selene-builder
-RUN apt-get update && \
-    apt-get upgrade -y && \
-    apt-get install g++ && \
-    cargo install --branch main --git https://github.com/Kampfkarren/selene selene
-
 FROM bash AS selene-light
 COPY --from=selene-light-builder /usr/local/cargo/bin/selene /
 CMD ["/selene"]

From 786de0b98429bb6d61723ea91ef40f89b154fae3 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 4 Nov 2023 15:04:45 -0700
Subject: [PATCH 56/63] Test

---
 Dockerfile | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 763a7ffa..fc0cb39c 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,11 +1,5 @@
 ARG RUST_VERSION="1"
 
-FROM rust:${RUST_VERSION}-bullseye AS selene-builder
-RUN apt-get update && \
-    apt-get upgrade -y && \
-    apt-get install g++ && \
-    cargo install --branch main --git https://github.com/Kampfkarren/selene selene
-
 FROM rust:${RUST_VERSION}-bullseye AS selene-light-builder
 RUN apt-get update && \
     apt-get upgrade -y && \
@@ -32,6 +26,12 @@ FROM bash AS selene-light-musl
 COPY --from=selene-light-musl-builder /usr/local/cargo/bin/selene /
 CMD ["/selene"]
 
+FROM rust:${RUST_VERSION}-bullseye AS selene-builder
+RUN apt-get update && \
+    apt-get upgrade -y && \
+    apt-get install g++ && \
+    cargo install --branch main --git https://github.com/Kampfkarren/selene selene
+
 FROM bash AS selene
 COPY --from=selene-builder /usr/local/cargo/bin/selene /
 CMD ["/selene"]

From 4d26ab37d04ca12d3465d46d8c504eeab6039b05 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 4 Nov 2023 15:18:14 -0700
Subject: [PATCH 57/63] Test

---
 Dockerfile | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index fc0cb39c..3e3ac56a 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,37 +1,37 @@
 ARG RUST_VERSION="1"
 
+FROM rust:${RUST_VERSION}-bullseye AS selene-builder
+RUN apt-get update && \
+    apt-get upgrade -y && \
+    apt-get install g++ && \
+    cargo install --branch main --git https://github.com/Kampfkarren/selene selene
+
 FROM rust:${RUST_VERSION}-bullseye AS selene-light-builder
 RUN apt-get update && \
     apt-get upgrade -y && \
     apt-get install g++ && \
     cargo install --no-default-features --branch main --git https://github.com/Kampfkarren/selene selene
 
+FROM rust:${RUST_VERSION}-alpine AS selene-light-musl-builder
+RUN apk add g++ && \
+    cargo install --no-default-features --branch main --git https://github.com/Kampfkarren/selene selene
+
 FROM rust:${RUST_VERSION}-alpine AS selene-musl-builder
 RUN apk add g++ && \
     cargo install --branch main --git https://github.com/Kampfkarren/selene selene
 
-FROM rust:${RUST_VERSION}-alpine AS selene-light-musl-builder
-RUN apk add g++ && \
-    cargo install --no-default-features --branch main --git https://github.com/Kampfkarren/selene selene
+FROM bash AS selene
+COPY --from=selene-builder /usr/local/cargo/bin/selene /
+CMD ["/selene"]
 
 FROM bash AS selene-light
 COPY --from=selene-light-builder /usr/local/cargo/bin/selene /
 CMD ["/selene"]
 
-FROM bash AS selene-musl
-COPY --from=selene-musl-builder /usr/local/cargo/bin/selene /
-CMD ["/selene"]
-
 FROM bash AS selene-light-musl
 COPY --from=selene-light-musl-builder /usr/local/cargo/bin/selene /
 CMD ["/selene"]
 
-FROM rust:${RUST_VERSION}-bullseye AS selene-builder
-RUN apt-get update && \
-    apt-get upgrade -y && \
-    apt-get install g++ && \
-    cargo install --branch main --git https://github.com/Kampfkarren/selene selene
-
-FROM bash AS selene
-COPY --from=selene-builder /usr/local/cargo/bin/selene /
-CMD ["/selene"]
+FROM bash AS selene-musl
+COPY --from=selene-musl-builder /usr/local/cargo/bin/selene /
+CMD ["/selene"]
\ No newline at end of file

From 6155eae1f413dc81b7795f475453044950695ef3 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 11 Nov 2023 08:41:22 -0800
Subject: [PATCH 58/63] Update test

---
 .../tests/lints/divide_by_zero/divide_by_zero.fixed.diff      | 1 +
 selene-lib/tests/lints/divide_by_zero/divide_by_zero.stderr   | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

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
index 2c40568c..f258874f 100644
--- 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
@@ -5,3 +5,4 @@
 -[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 e6bb50c2..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
@@ -10,9 +10,9 @@ error[divide_by_zero]: dividing by zero is not readable
 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()`
 

From feb4cf02dfb0388537f94f254c9ba9e5a0f42d3e Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 11 Nov 2023 08:50:07 -0800
Subject: [PATCH 59/63] Remove file

---
 .pre-commit-hooks.yaml | 15 ---------------
 1 file changed, 15 deletions(-)
 delete mode 100644 .pre-commit-hooks.yaml

diff --git a/.pre-commit-hooks.yaml b/.pre-commit-hooks.yaml
deleted file mode 100644
index e4cb7416..00000000
--- a/.pre-commit-hooks.yaml
+++ /dev/null
@@ -1,15 +0,0 @@
-- id: selene-system
-  name: selene (system)
-  description: An opinionated Lua code linter
-  entry: selene
-  language: system
-  types:
-      - lua
-
-- id: selene-docker
-  name: selene (docker)
-  description: An opinionated Lua code linter
-  entry: /selene
-  language: docker
-  types:
-      - lua
\ No newline at end of file

From df80d2cad40ae33236afa4096a253fd3d876947c Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 11 Nov 2023 08:53:50 -0800
Subject: [PATCH 60/63] Remove change

---
 Dockerfile | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 3e3ac56a..5e3abffa 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -12,14 +12,14 @@ RUN apt-get update && \
     apt-get install g++ && \
     cargo install --no-default-features --branch main --git https://github.com/Kampfkarren/selene selene
 
-FROM rust:${RUST_VERSION}-alpine AS selene-light-musl-builder
-RUN apk add g++ && \
-    cargo install --no-default-features --branch main --git https://github.com/Kampfkarren/selene selene
-
 FROM rust:${RUST_VERSION}-alpine AS selene-musl-builder
 RUN apk add g++ && \
     cargo install --branch main --git https://github.com/Kampfkarren/selene selene
 
+FROM rust:${RUST_VERSION}-alpine AS selene-light-musl-builder
+RUN apk add g++ && \
+    cargo install --no-default-features --branch main --git https://github.com/Kampfkarren/selene selene
+
 FROM bash AS selene
 COPY --from=selene-builder /usr/local/cargo/bin/selene /
 CMD ["/selene"]
@@ -28,10 +28,10 @@ FROM bash AS selene-light
 COPY --from=selene-light-builder /usr/local/cargo/bin/selene /
 CMD ["/selene"]
 
-FROM bash AS selene-light-musl
-COPY --from=selene-light-musl-builder /usr/local/cargo/bin/selene /
-CMD ["/selene"]
-
 FROM bash AS selene-musl
 COPY --from=selene-musl-builder /usr/local/cargo/bin/selene /
+CMD ["/selene"]
+
+FROM bash AS selene-light-musl
+COPY --from=selene-light-musl-builder /usr/local/cargo/bin/selene /
 CMD ["/selene"]
\ No newline at end of file

From 0055e2cd59dd9718698e3069295b53bf944210d3 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 11 Nov 2023 09:05:39 -0800
Subject: [PATCH 61/63] Flatten print format

---
 selene/src/main.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/selene/src/main.rs b/selene/src/main.rs
index 48510682..3a640bf8 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -338,12 +338,13 @@ fn read<R: Read>(
                 let _ = stdout.reset();
 
                 println!(
-                    "{} ({})",
+                    "{} ({} {})",
                     filename.display(),
+                    num_fixes,
                     if num_fixes == 1 {
-                        "1 fix".to_string()
+                        "fix".to_string()
                     } else {
-                        format!("{} fixes", num_fixes)
+                        "fixes".to_string()
                     }
                 );
 

From 038e0622286a929be3ea41c881be77c6d17e003f Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 11 Nov 2023 11:25:34 -0800
Subject: [PATCH 62/63] Fix pedantic clippy

---
 selene-lib/src/lints.rs           | 9 ++++++---
 selene-lib/src/lints/test_util.rs | 2 +-
 selene/src/main.rs                | 2 +-
 3 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/selene-lib/src/lints.rs b/selene-lib/src/lints.rs
index d3ba8989..6f3a1584 100644
--- a/selene-lib/src/lints.rs
+++ b/selene-lib/src/lints.rs
@@ -137,7 +137,7 @@ impl Diagnostic {
                     if suggestion_str.is_empty() {
                         "consider removing this".to_string()
                     } else {
-                        format!("try: `{}`", suggestion_str)
+                        format!("try: `{suggestion_str}`")
                     },
                 );
             }
@@ -196,14 +196,17 @@ 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
     }
@@ -211,13 +214,13 @@ impl Diagnostic {
     /// 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: Vec<&Diagnostic>,
+        diagnostics: &[&Diagnostic],
         get_new_diagnostics: F,
     ) -> String
     where
         F: Fn(&str) -> Vec<Diagnostic>,
     {
-        let mut chosen_diagnostics = Self::get_independent_suggestions(&diagnostics);
+        let mut chosen_diagnostics = Self::get_independent_suggestions(diagnostics);
         let mut owned_diagnostics_ref;
         let mut owned_diagnostics;
 
diff --git a/selene-lib/src/lints/test_util.rs b/selene-lib/src/lints/test_util.rs
index 5216d385..c4b2d7c8 100644
--- a/selene-lib/src/lints/test_util.rs
+++ b/selene-lib/src/lints/test_util.rs
@@ -142,7 +142,7 @@ pub fn test_lint_config_with_output<
 
     suggestion = Diagnostic::get_applied_suggestions_code(
         suggestion.as_str(),
-        fixed_diagnostics,
+        &fixed_diagnostics,
         |new_code| {
             let fixed_ast = full_moon::parse(new_code).unwrap_or_else(|_| {
                 panic!(
diff --git a/selene/src/main.rs b/selene/src/main.rs
index 3a640bf8..98f490f5 100644
--- a/selene/src/main.rs
+++ b/selene/src/main.rs
@@ -297,7 +297,7 @@ fn read<R: Read>(
 
         suggestion = Diagnostic::get_applied_suggestions_code(
             suggestion.as_str(),
-            diagnostics
+            &diagnostics
                 .iter()
                 .filter(|diagnostic| diagnostic.diagnostic.has_machine_applicable_fix())
                 .map(|diagnostic| &diagnostic.diagnostic)

From 9538811fe9d29efacb8fc2cbb2358bd3dc90d262 Mon Sep 17 00:00:00 2001
From: Christopher Chang <51393127+chriscerie@users.noreply.github.com>
Date: Sat, 11 Nov 2023 12:09:31 -0800
Subject: [PATCH 63/63] Add must use

---
 selene-lib/src/lints.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/selene-lib/src/lints.rs b/selene-lib/src/lints.rs
index 6f3a1584..78e951a9 100644
--- a/selene-lib/src/lints.rs
+++ b/selene-lib/src/lints.rs
@@ -387,6 +387,7 @@ pub struct AstContext {
 }
 
 impl AstContext {
+    #[must_use]
     pub fn from_ast(ast: &Ast, code: &String) -> Self {
         Self {
             scope_manager: ScopeManager::new(ast),