Adding linting to qsc_formatter and fixing the warnings (#2339)

This PR resolves issue #2276.

There were several straightforward lints that made perfect sense to fix
(e.g. [adding the
must_use](https://rust-lang.github.io/rust-clippy/master/index.html#must_use_candidate)
and the
[backticks](https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown)).

But there were a few that I wasn't sure about:

* too_many_lines: For these, I preferred to allow it rather than fix it.
For the tests, I think that's the right approach. For the `apply_rules`,
it's because I think the method is more readable as a very long
function, especially given that it's the match statement that's taking
up most of the lines.
* match_same_arms: This one also relates to `apply_rules`. My opinion is
that completely fixing the branches ends up going from many
*straightforward* conditions to less (but still many) *complicated*
conditions. So I fixed some of the arms but then disabled the lint for
the rest. If you want, I can fix the rest of the arms instead.
* trivially_copy_pass_by_ref: I'm not 100% sure I agree with removing
the reference and using a copy instead, but clippy probably knows much
better than me, so I listened to it and changed the function parameters
from `&TokenKind` and `&Keyword` to `TokenKind` or `Keyword`.

Author: Morcifer

compiler/qsc_formatter/Cargo.toml

@@ -17,11 +17,13 @@ qsc_frontend = { path = "../qsc_frontend" }
 expect-test = { workspace = true }
 indoc = { workspace = true }
 
+[lints]
+workspace = true
+
 [lib]
 doctest = false
 
 [[bin]]
 name = "qsc_formatter"
 bench = false
 test = false
-

compiler/qsc_formatter/src/bin/qsc_formatter.rs

@@ -101,7 +101,7 @@ impl FileWalker {
             let formatted = format_str(&file_as_string);
             if file_as_string != formatted {
                 match std::fs::write(path, formatted) {
-                    Ok(_) => {
+                    Ok(()) => {
                         self.changed_files.push(path.display().to_string());
                     }
                     Err(e) => {
@@ -139,6 +139,7 @@ impl Display for OutputFormatting {
     }
 }
 
+#[allow(clippy::too_many_lines)]
 fn main() -> Result<(), String> {
     use OutputFormatting::*;
 
@@ -169,7 +170,7 @@ fn main() -> Result<(), String> {
                 "{Passing}Updated {} files:",
                 file_walker.changed_files.len()
             );
-            for f in file_walker.changed_files.iter() {
+            for f in &file_walker.changed_files {
                 println!("\t{Passing}{f}");
             }
             print!("{Reset}");
@@ -181,7 +182,7 @@ fn main() -> Result<(), String> {
             "{Error}{} files are in need of formatting:",
             file_walker.changed_files.len()
         );
-        for f in file_walker.changed_files.iter() {
+        for f in &file_walker.changed_files {
             println!("\t{Error}{f}");
         }
         println!("{Error}Run the formatter with the `--write` option to correct formatting for the above files.{Reset}");
@@ -193,7 +194,7 @@ fn main() -> Result<(), String> {
     }
     if are_skipped_files {
         println!("{Skip}Skipped {} files:", file_walker.skipped_files.len());
-        for f in file_walker.skipped_files.iter() {
+        for f in &file_walker.skipped_files {
             println!("\t{Skip}{f}");
         }
         print!("{Reset}");

compiler/qsc_formatter/src/formatter.rs

@@ -18,6 +18,7 @@ mod tests;
 
 /// Applies formatting rules to the give code str and returns
 /// the formatted string.
+#[must_use]
 pub fn format_str(code: &str) -> String {
     let mut edits = calculate_format_edits(code);
     edits.sort_by_key(|edit| edit.span.hi); // sort edits by their span's hi value from lowest to highest
@@ -34,6 +35,7 @@ pub fn format_str(code: &str) -> String {
 
 /// Applies formatting rules to the given code str, generating edits where
 /// the source code needs to be changed to comply with the format rules.
+#[must_use]
 pub fn calculate_format_edits(code: &str) -> Vec<TextEdit> {
     let tokens = concrete::ConcreteTokenIterator::new(code);
     let mut edits = vec![];
@@ -171,7 +173,7 @@ enum SpecDeclState {
 
 /// Enum for a token's status as a delimiter.
 /// `<` and `>` are delimiters only with type-parameter lists,
-/// which is determined using the TypeParameterListState enum.
+/// which is determined using the `TypeParameterListState` enum.
 #[derive(Clone, Copy)]
 enum Delimiter {
     // The token is an open delimiter. i.e. `{`, `[`, `(`, and sometimes `<`.
@@ -227,6 +229,7 @@ struct Formatter<'a> {
     import_export_state: ImportExportState,
 }
 
+#[allow(clippy::too_many_lines)]
 impl Formatter<'_> {
     fn apply_rules(
         &mut self,
@@ -243,7 +246,7 @@ impl Formatter<'_> {
         // when we get here, neither left nor right should be whitespace
 
         let are_newlines_in_spaces = whitespace.contains('\n');
-        let does_right_required_newline = matches!(&right.kind, Syntax(cooked_right) if is_newline_keyword_or_ampersat(cooked_right));
+        let does_right_required_newline = matches!(right.kind, Syntax(cooked_right) if is_newline_keyword_or_ampersat(cooked_right));
 
         // Save the left token's status as a delimiter before updating the delimiter state
         let left_delim_state = Delimiter::from_concrete_token_kind(
@@ -271,7 +274,8 @@ impl Formatter<'_> {
             matches!(right.kind, Comment),
         );
 
-        match (&left.kind, &right.kind) {
+        #[allow(clippy::match_same_arms)]
+        match (left.kind, right.kind) {
             (Comment | Syntax(DocComment), _) => {
                 // remove whitespace at the ends of comments
                 effect_trim_comment(left, &mut edits, self.code);
@@ -407,19 +411,29 @@ impl Formatter<'_> {
                         self.indent_level,
                     );
                 }
-                (_, Keyword(Keyword::Until))
-                | (_, Keyword(Keyword::In))
-                | (_, Keyword(Keyword::As))
-                | (_, Keyword(Keyword::Elif))
-                | (_, Keyword(Keyword::Else))
-                | (_, Keyword(Keyword::Apply)) => {
+                (
+                    _,
+                    Keyword(
+                        Keyword::Until
+                        | Keyword::In
+                        | Keyword::As
+                        | Keyword::Elif
+                        | Keyword::Else
+                        | Keyword::Apply,
+                    ),
+                ) => {
                     effect_single_space(left, whitespace, right, &mut edits);
                 }
-                (_, Keyword(Keyword::Auto))
-                | (_, Keyword(Keyword::Distribute))
-                | (_, Keyword(Keyword::Intrinsic))
-                | (_, Keyword(Keyword::Invert))
-                | (_, Keyword(Keyword::Slf)) => {
+                (
+                    _,
+                    Keyword(
+                        Keyword::Auto
+                        | Keyword::Distribute
+                        | Keyword::Intrinsic
+                        | Keyword::Invert
+                        | Keyword::Slf,
+                    ),
+                ) => {
                     effect_single_space(left, whitespace, right, &mut edits);
                 }
                 (Close(Delim::Brace), _)
@@ -555,7 +569,7 @@ impl Formatter<'_> {
         }
     }
 
-    /// Updates the type_param_state of the FormatterState based
+    /// Updates the `type_param_state` of the `FormatterState` based
     /// on the left and right token kinds.
     fn update_type_param_state(
         &mut self,
@@ -615,7 +629,7 @@ impl Formatter<'_> {
     }
 
     /// Updates the indent level and manages the `delim_newlines_stack`
-    /// of the FormatterState.
+    /// of the `FormatterState`.
     /// Returns the current newline context.
     fn update_indent_level(
         &mut self,
@@ -678,7 +692,7 @@ fn get_token_contents<'a>(code: &'a str, token: &ConcreteToken) -> &'a str {
 
 // Rule Conditions
 
-fn is_bin_op(cooked: &TokenKind) -> bool {
+fn is_bin_op(cooked: TokenKind) -> bool {
     matches!(
         cooked,
         TokenKind::Bar
@@ -698,16 +712,15 @@ fn is_bin_op(cooked: &TokenKind) -> bool {
             | TokenKind::RArrow
             | TokenKind::WSlash
             | TokenKind::WSlashEq
-            | TokenKind::Keyword(Keyword::And)
-            | TokenKind::Keyword(Keyword::Or)
+            | TokenKind::Keyword(Keyword::And | Keyword::Or)
     )
 }
 
-fn is_prefix_with_space(cooked: &TokenKind) -> bool {
+fn is_prefix_with_space(cooked: TokenKind) -> bool {
     matches!(cooked, TokenKind::TildeTildeTilde)
 }
 
-fn is_prefix_without_space(cooked: &TokenKind) -> bool {
+fn is_prefix_without_space(cooked: TokenKind) -> bool {
     matches!(
         cooked,
         TokenKind::ColonColon
@@ -717,22 +730,22 @@ fn is_prefix_without_space(cooked: &TokenKind) -> bool {
     )
 }
 
-fn is_prefix(cooked: &TokenKind) -> bool {
+fn is_prefix(cooked: TokenKind) -> bool {
     is_prefix_with_space(cooked)
         || is_prefix_without_space(cooked)
         || matches!(cooked, TokenKind::DotDotDot)
 }
 
-fn is_suffix(cooked: &TokenKind) -> bool {
+fn is_suffix(cooked: TokenKind) -> bool {
     matches!(cooked, TokenKind::Bang | TokenKind::Comma)
 }
 
-fn is_prefix_keyword(keyword: &Keyword) -> bool {
+fn is_prefix_keyword(keyword: Keyword) -> bool {
     use Keyword::*;
     matches!(keyword, Not | AdjointUpper | ControlledUpper)
 }
 
-fn is_keyword_value(keyword: &Keyword) -> bool {
+fn is_keyword_value(keyword: Keyword) -> bool {
     use Keyword::*;
     matches!(
         keyword,
@@ -742,7 +755,7 @@ fn is_keyword_value(keyword: &Keyword) -> bool {
     )
 }
 
-fn is_newline_keyword_or_ampersat(cooked: &TokenKind) -> bool {
+fn is_newline_keyword_or_ampersat(cooked: TokenKind) -> bool {
     use Keyword::*;
     matches!(
         cooked,
@@ -770,22 +783,22 @@ fn is_newline_keyword_or_ampersat(cooked: &TokenKind) -> bool {
     )
 }
 
-fn is_starter_keyword(keyword: &Keyword) -> bool {
+fn is_starter_keyword(keyword: Keyword) -> bool {
     use Keyword::*;
     matches!(
         keyword,
         For | While | Repeat | If | Within | New | Return | Fail
     )
 }
 
-fn is_newline_after_brace(cooked: &TokenKind, delim_state: Delimiter) -> bool {
+fn is_newline_after_brace(cooked: TokenKind, delim_state: Delimiter) -> bool {
     is_value_token_right(cooked, delim_state)
         || matches!(cooked, TokenKind::Keyword(keyword) if is_starter_keyword(keyword))
         || matches!(cooked, TokenKind::Keyword(keyword) if is_prefix_keyword(keyword))
 }
 
 /// Note that this does not include interpolated string literals
-fn is_value_lit(cooked: &TokenKind) -> bool {
+fn is_value_lit(cooked: TokenKind) -> bool {
     matches!(
         cooked,
         TokenKind::BigInt(_)
@@ -795,7 +808,7 @@ fn is_value_lit(cooked: &TokenKind) -> bool {
     )
 }
 
-fn is_value_token_left(cooked: &TokenKind, delim_state: Delimiter) -> bool {
+fn is_value_token_left(cooked: TokenKind, delim_state: Delimiter) -> bool {
     // a closed delim represents a value on the left
     if matches!(delim_state, Delimiter::Close) {
         return true;
@@ -811,7 +824,7 @@ fn is_value_token_left(cooked: &TokenKind, delim_state: Delimiter) -> bool {
     }
 }
 
-fn is_value_token_right(cooked: &TokenKind, delim_state: Delimiter) -> bool {
+fn is_value_token_right(cooked: TokenKind, delim_state: Delimiter) -> bool {
     // an open delim represents a value on the right
     if matches!(delim_state, Delimiter::Open) {
         return true;