Apply suggestions from code review

Co-Authored-By: bjorn3 <bjorn3@users.noreply.github.com>

diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index e342ca9dfd04603cccbc4150fc14ef2a3302ece2..8ee3a78c64d1b790e8f6477f298d8a6649ab6263 100644 (file)
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -194,7 +194,7 @@ pub(crate) fn highlight(
             let token = sema.descend_into_macros(token.clone());
             let parent = token.parent();
 
-            // Check if macro takes a format string and remeber it for highlighting later.
+            // Check if macro takes a format string and remember it for highlighting later.
             // The macros that accept a format string expand to a compiler builtin macros
             // `format_args` and `format_args_nl`.
             if let Some(fmt_macro_call) = parent.parent().and_then(ast::MacroCall::cast) {
@@ -233,8 +233,7 @@ pub(crate) fn highlight(
             }
         }
 
-        let is_format_string =
-            format_string.as_ref().map(|fs| fs == &element_to_highlight).unwrap_or_default();
+        let is_format_string = format_string.as_ref() == Some(&element_to_highlight);
 
         if let Some((highlight, binding_hash)) =
             highlight_element(&sema, &mut bindings_shadow_count, element_to_highlight.clone())
@@ -245,7 +244,7 @@ pub(crate) fn highlight(
             {
                 stack.push();
                 if is_format_string {
-                    string.lex_format_specifier(&mut |piece_range, kind| {
+                    string.lex_format_specifier(|piece_range, kind| {
                         let highlight = match kind {
                             FormatSpecifier::Open
                             | FormatSpecifier::Close

diff --git a/crates/ra_syntax/src/ast/tokens.rs b/crates/ra_syntax/src/ast/tokens.rs
index ec3b4e55386c1d7cf89e204af2e1768407beddad..3e5c56b192d5c23693afacfcca510054a965068c 100644 (file)
--- a/crates/ra_syntax/src/ast/tokens.rs
+++ b/crates/ra_syntax/src/ast/tokens.rs
@@ -192,7 +192,7 @@ pub enum FormatSpecifier {
 }
 
 pub trait HasFormatSpecifier: AstToken {
-    fn lex_format_specifier<F>(&self, callback: &mut F)
+    fn lex_format_specifier<F>(&self, mut callback: F)
     where
         F: FnMut(TextRange, FormatSpecifier),
     {
@@ -217,21 +217,15 @@ fn lex_format_specifier<F>(&self, callback: &mut F)
                         FormatSpecifier::Open,
                     );
 
-                    let next_char = if let Some(c) = chars.clone().next() {
-                        c
-                    } else {
-                        break;
-                    };
-
                     // check for integer/identifier
-                    match next_char {
+                    match chars.clone().next().unwrap_or_default() {
                         '0'..='9' => {
                             // integer
-                            read_integer(&mut chars, initial_len, callback);
+                            read_integer(&mut chars, initial_len, &mut callback);
                         }
                         'a'..='z' | 'A'..='Z' | '_' => {
                             // identifier
-                            read_identifier(&mut chars, initial_len, callback);
+                            read_identifier(&mut chars, initial_len, &mut callback);
                         }
                         _ => {}
                     }
@@ -241,7 +235,7 @@ fn lex_format_specifier<F>(&self, callback: &mut F)
                             &mut chars,
                             initial_len,
                             FormatSpecifier::Colon,
-                            callback,
+                            &mut callback,
                         );
 
                         // check for fill/align
@@ -255,13 +249,13 @@ fn lex_format_specifier<F>(&self, callback: &mut F)
                                     &mut chars,
                                     initial_len,
                                     FormatSpecifier::Fill,
-                                    callback,
+                                    &mut callback,
                                 );
                                 skip_char_and_emit(
                                     &mut chars,
                                     initial_len,
                                     FormatSpecifier::Align,
-                                    callback,
+                                    &mut callback,
                                 );
                             }
                             _ => match first {
@@ -270,7 +264,7 @@ fn lex_format_specifier<F>(&self, callback: &mut F)
                                         &mut chars,
                                         initial_len,
                                         FormatSpecifier::Align,
-                                        callback,
+                                        &mut callback,
                                     );
                                 }
                                 _ => {}
@@ -284,7 +278,7 @@ fn lex_format_specifier<F>(&self, callback: &mut F)
                                     &mut chars,
                                     initial_len,
                                     FormatSpecifier::Sign,
-                                    callback,
+                                    &mut callback,
                                 );
                             }
                             _ => {}
@@ -296,7 +290,7 @@ fn lex_format_specifier<F>(&self, callback: &mut F)
                                 &mut chars,
                                 initial_len,
                                 FormatSpecifier::NumberSign,
-                                callback,
+                                &mut callback,
                             );
                         }
 
@@ -310,25 +304,25 @@ fn lex_format_specifier<F>(&self, callback: &mut F)
                                 &mut chars,
                                 initial_len,
                                 FormatSpecifier::Zero,
-                                callback,
+                                &mut callback,
                             );
                         }
 
                         // width
                         match chars.clone().next().unwrap_or_default() {
                             '0'..='9' => {
-                                read_integer(&mut chars, initial_len, callback);
+                                read_integer(&mut chars, initial_len, &mut callback);
                                 if chars.clone().next() == Some('$') {
                                     skip_char_and_emit(
                                         &mut chars,
                                         initial_len,
                                         FormatSpecifier::DollarSign,
-                                        callback,
+                                        &mut callback,
                                     );
                                 }
                             }
                             'a'..='z' | 'A'..='Z' | '_' => {
-                                read_identifier(&mut chars, initial_len, callback);
+                                read_identifier(&mut chars, initial_len, &mut callback);
                                 if chars.clone().next() != Some('$') {
                                     continue;
                                 }
@@ -336,7 +330,7 @@ fn lex_format_specifier<F>(&self, callback: &mut F)
                                     &mut chars,
                                     initial_len,
                                     FormatSpecifier::DollarSign,
-                                    callback,
+                                    &mut callback,
                                 );
                             }
                             _ => {}
@@ -348,7 +342,7 @@ fn lex_format_specifier<F>(&self, callback: &mut F)
                                 &mut chars,
                                 initial_len,
                                 FormatSpecifier::Dot,
-                                callback,
+                                &mut callback,
                             );
 
                             match chars.clone().next().unwrap_or_default() {
@@ -357,22 +351,22 @@ fn lex_format_specifier<F>(&self, callback: &mut F)
                                         &mut chars,
                                         initial_len,
                                         FormatSpecifier::Asterisk,
-                                        callback,
+                                        &mut callback,
                                     );
                                 }
                                 '0'..='9' => {
-                                    read_integer(&mut chars, initial_len, callback);
+                                    read_integer(&mut chars, initial_len, &mut callback);
                                     if chars.clone().next() == Some('$') {
                                         skip_char_and_emit(
                                             &mut chars,
                                             initial_len,
                                             FormatSpecifier::DollarSign,
-                                            callback,
+                                            &mut callback,
                                         );
                                     }
                                 }
                                 'a'..='z' | 'A'..='Z' | '_' => {
-                                    read_identifier(&mut chars, initial_len, callback);
+                                    read_identifier(&mut chars, initial_len, &mut callback);
                                     if chars.clone().next() != Some('$') {
                                         continue;
                                     }
@@ -380,7 +374,7 @@ fn lex_format_specifier<F>(&self, callback: &mut F)
                                         &mut chars,
                                         initial_len,
                                         FormatSpecifier::DollarSign,
-                                        callback,
+                                        &mut callback,
                                     );
                                 }
                                 _ => {
@@ -396,11 +390,11 @@ fn lex_format_specifier<F>(&self, callback: &mut F)
                                     &mut chars,
                                     initial_len,
                                     FormatSpecifier::QuestionMark,
-                                    callback,
+                                    &mut callback,
                                 );
                             }
                             'a'..='z' | 'A'..='Z' | '_' => {
-                                read_identifier(&mut chars, initial_len, callback);
+                                read_identifier(&mut chars, initial_len, &mut callback);
                             }
                             _ => {}
                         }
@@ -416,7 +410,12 @@ fn lex_format_specifier<F>(&self, callback: &mut F)
                         // Escaped format end specifier, `}}`
                         continue;
                     }
-                    skip_char_and_emit(&mut chars, initial_len, FormatSpecifier::Close, callback);
+                    skip_char_and_emit(
+                        &mut chars,
+                        initial_len,
+                        FormatSpecifier::Close,
+                        &mut callback,
+                    );
                 }
                 _ => {
                     while let Some(next_char) = chars.clone().next() {