4 files changed, 45 insertions, 20 deletions

diff --git a/crates/ra_syntax/src/validation/byte.rs b/crates/ra_syntax/src/validation/byte.rs
index 43c0d7edd..d0897eeed 100644
--- a/crates/ra_syntax/src/validation/byte.rs
+++ b/crates/ra_syntax/src/validation/byte.rs
@@ -2,7 +2,7 @@
 
 use crate::{
     ast::{self, AstNode},
-    string_lexing::{self, CharComponentKind},
+    string_lexing::{self, StringComponentKind},
     TextRange,
     validation::char,
     yellow::{
@@ -27,6 +27,13 @@ pub(super) fn validate_byte_node(node: ast::Byte, errors: &mut Vec<SyntaxError>)
         errors.push(SyntaxError::new(UnclosedByte, literal_range));
     }
 
+    if let Some(range) = components.suffix {
+        errors.push(SyntaxError::new(
+            InvalidSuffix,
+            range + literal_range.start(),
+        ));
+    }
+
     if len == 0 {
         errors.push(SyntaxError::new(EmptyByte, literal_range));
     }
@@ -38,11 +45,11 @@ pub(super) fn validate_byte_node(node: ast::Byte, errors: &mut Vec<SyntaxError>)
 
 pub(super) fn validate_byte_component(
     text: &str,
-    kind: CharComponentKind,
+    kind: StringComponentKind,
     range: TextRange,
     errors: &mut Vec<SyntaxError>,
 ) {
-    use self::CharComponentKind::*;
+    use self::StringComponentKind::*;
     match kind {
         AsciiEscape => validate_byte_escape(text, range, errors),
         AsciiCodeEscape => validate_byte_code_escape(text, range, errors),
@@ -63,6 +70,7 @@ pub(super) fn validate_byte_component(
                 errors.push(SyntaxError::new(ByteOutOfRange, range));
             }
         }
+        IgnoreNewline => { /* always valid */ }
     }
 }
 
diff --git a/crates/ra_syntax/src/validation/byte_string.rs b/crates/ra_syntax/src/validation/byte_string.rs
index 7b830e97c..f7a4fb156 100644
--- a/crates/ra_syntax/src/validation/byte_string.rs
+++ b/crates/ra_syntax/src/validation/byte_string.rs
@@ -17,21 +17,28 @@ pub(crate) fn validate_byte_string_node(node: ast::ByteString, errors: &mut Vec<
         let range = component.range + literal_range.start();
 
         match component.kind {
-            StringComponentKind::Char(kind) => {
+            StringComponentKind::IgnoreNewline => { /* always valid */ }
+            _ => {
                 // Chars must escape \t, \n and \r codepoints, but strings don't
                 let text = &literal_text[component.range];
                 match text {
                     "\t" | "\n" | "\r" => { /* always valid */ }
-                    _ => byte::validate_byte_component(text, kind, range, errors),
+                    _ => byte::validate_byte_component(text, component.kind, range, errors),
                 }
             }
-            StringComponentKind::IgnoreNewline => { /* always valid */ }
         }
     }
 
     if !components.has_closing_quote {
         errors.push(SyntaxError::new(UnclosedString, literal_range));
     }
+
+    if let Some(range) = components.suffix {
+        errors.push(SyntaxError::new(
+            InvalidSuffix,
+            range + literal_range.start(),
+        ));
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/ra_syntax/src/validation/char.rs b/crates/ra_syntax/src/validation/char.rs
index 4728c85e6..19cd3830f 100644
--- a/crates/ra_syntax/src/validation/char.rs
+++ b/crates/ra_syntax/src/validation/char.rs
@@ -6,7 +6,7 @@ use arrayvec::ArrayString;
 
 use crate::{
     ast::{self, AstNode},
-    string_lexing::{self, CharComponentKind},
+    string_lexing::{self, StringComponentKind},
     TextRange,
     yellow::{
         SyntaxError,
@@ -30,6 +30,13 @@ pub(super) fn validate_char_node(node: ast::Char, errors: &mut Vec<SyntaxError>)
         errors.push(SyntaxError::new(UnclosedChar, literal_range));
     }
 
+    if let Some(range) = components.suffix {
+        errors.push(SyntaxError::new(
+            InvalidSuffix,
+            range + literal_range.start(),
+        ));
+    }
+
     if len == 0 {
         errors.push(SyntaxError::new(EmptyChar, literal_range));
     }
@@ -41,12 +48,12 @@ pub(super) fn validate_char_node(node: ast::Char, errors: &mut Vec<SyntaxError>)
 
 pub(super) fn validate_char_component(
     text: &str,
-    kind: CharComponentKind,
+    kind: StringComponentKind,
     range: TextRange,
     errors: &mut Vec<SyntaxError>,
 ) {
     // Validate escapes
-    use self::CharComponentKind::*;
+    use self::StringComponentKind::*;
     match kind {
         AsciiEscape => validate_ascii_escape(text, range, errors),
         AsciiCodeEscape => validate_ascii_code_escape(text, range, errors),
@@ -57,6 +64,7 @@ pub(super) fn validate_char_component(
                 errors.push(SyntaxError::new(UnescapedCodepoint, range));
             }
         }
+        StringComponentKind::IgnoreNewline => { /* always valid */ }
     }
 }
 
diff --git a/crates/ra_syntax/src/validation/string.rs b/crates/ra_syntax/src/validation/string.rs
index 089879d15..1371bb1f0 100644
--- a/crates/ra_syntax/src/validation/string.rs
+++ b/crates/ra_syntax/src/validation/string.rs
@@ -1,6 +1,6 @@
 use crate::{
     ast::{self, AstNode},
-    string_lexing::{self, StringComponentKind},
+    string_lexing,
     yellow::{
         SyntaxError,
         SyntaxErrorKind::*,
@@ -16,22 +16,24 @@ pub(crate) fn validate_string_node(node: ast::String, errors: &mut Vec<SyntaxErr
     for component in &mut components {
         let range = component.range + literal_range.start();
 
-        match component.kind {
-            StringComponentKind::Char(kind) => {
-                // Chars must escape \t, \n and \r codepoints, but strings don't
-                let text = &literal_text[component.range];
-                match text {
-                    "\t" | "\n" | "\r" => { /* always valid */ }
-                    _ => char::validate_char_component(text, kind, range, errors),
-                }
-            }
-            StringComponentKind::IgnoreNewline => { /* always valid */ }
+        // Chars must escape \t, \n and \r codepoints, but strings don't
+        let text = &literal_text[component.range];
+        match text {
+            "\t" | "\n" | "\r" => { /* always valid */ }
+            _ => char::validate_char_component(text, component.kind, range, errors),
         }
     }
 
     if !components.has_closing_quote {
         errors.push(SyntaxError::new(UnclosedString, literal_range));
     }
+
+    if let Some(range) = components.suffix {
+        errors.push(SyntaxError::new(
+            InvalidSuffix,
+            range + literal_range.start(),
+        ));
+    }
 }
 
 #[cfg(test)]