Repository: rust-analyzer/rust-analyzer
Pull request #1584 (2019-07-24 08:47:35)

switch to upstream unescape


Patch:
diff --git a/Cargo.lock b/Cargo.lock
index 7c7836a133..528a332249 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -68,7 +68,7 @@ name = "backtrace-sys"
 version = "0.1.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "cc 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.38 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -150,7 +150,7 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.0.37"
+version = "1.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
@@ -353,7 +353,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.40 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.42 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -443,7 +443,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.40 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.42 (registry+https://github.com/rust-lang/crates.io-index)",
  "synstructure 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -687,7 +687,7 @@ name = "jemalloc-sys"
 version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "cc 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.38 (registry+https://github.com/rust-lang/crates.io-index)",
  "fs_extra 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -886,7 +886,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.40 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.42 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -1006,7 +1006,7 @@ dependencies = [
  "proc-macro-hack 0.5.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.40 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.42 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -1040,7 +1040,7 @@ dependencies = [
  "pest_meta 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.40 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.42 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -1074,7 +1074,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.40 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.42 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -1310,7 +1310,7 @@ dependencies = [
 
 [[package]]
 name = "ra_rustc_lexer"
-version = "0.1.0-pre.1"
+version = "0.1.0-pre.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1322,9 +1322,9 @@ version = "0.1.0"
 dependencies = [
  "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "ra_parser 0.1.0",
- "ra_rustc_lexer 0.1.0-pre.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ra_rustc_lexer 0.1.0-pre.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "ra_text_edit 0.1.0",
- "rowan 0.6.0-pre.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rowan 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "smol_str 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
  "test_utils 0.1.0",
  "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1595,7 +1595,7 @@ dependencies = [
 
 [[package]]
 name = "rowan"
-version = "0.6.0-pre.1"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1653,7 +1653,7 @@ dependencies = [
  "heck 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.40 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.42 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -1703,7 +1703,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.40 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.42 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -1774,7 +1774,7 @@ name = "stacker"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "cc 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cc 1.0.38 (registry+https://github.com/rust-lang/crates.io-index)",
  "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)",
  "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1792,7 +1792,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "syn"
-version = "0.15.40"
+version = "0.15.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1807,7 +1807,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.40 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.42 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -2147,7 +2147,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a7c3dd8985a7111efc5c80b44e23ecdd8c007de8ade3b96595387e812b957cf5"
 "checksum c2-chacha 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7d64d04786e0f528460fc884753cf8dddcc466be308f6026f8e355c41a0e4101"
 "checksum cargo_metadata 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5e904f164f39cae0c3a4f2713eb97a47ba64676a071e99a69ddfef4994694d2c"
-"checksum cc 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)" = "39f75544d7bbaf57560d2168f28fd649ff9c76153874db88bdbdfd839b1a7e7d"
+"checksum cc 1.0.38 (registry+https://github.com/rust-lang/crates.io-index)" = "ce400c638d48ee0e9ab75aef7997609ec57367ccfe1463f21bf53c3eca67bf46"
 "checksum cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "b486ce3ccf7ffd79fdeb678eac06a9e6c09fc88d33836340becb8fffe87c5e33"
 "checksum chalk-engine 0.9.0 (git+https://github.com/rust-lang/chalk.git)" = "<none>"
 "checksum chalk-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git)" = "<none>"
@@ -2259,7 +2259,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum proptest 0.9.4 (registry+https://github.com/rust-lang/crates.io-index)" = "cf147e022eacf0c8a054ab864914a7602618adba841d800a9a9868a5237a529f"
 "checksum quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9274b940887ce9addde99c4eee6b5c44cc494b182b97e73dc8ffdcb3397fd3f0"
 "checksum quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)" = "6ce23b6b870e8f94f81fb0a363d65d86675884b34a09043c81e5562f11c1f8e1"
-"checksum ra_rustc_lexer 0.1.0-pre.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e8d92772f822978a6c9c4657aa61af439e4e635180628b3354049b283b749f1e"
+"checksum ra_rustc_lexer 0.1.0-pre.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6baccda91574dfadd7f8a0bc8f9f110f874b6b484289b2536d3dbf4f0d5d97bb"
 "checksum ra_vfs 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "fb7cd4e302032c5ab514f1c01c89727cd96fd950dd36f9ebee9252df45d9fb1a"
 "checksum rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca"
 "checksum rand 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d47eab0e83d9693d40f825f86948aa16eff6750ead4bdffc4ab95b8b3a7f052c"
@@ -2285,7 +2285,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum relative-path 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0e7790c7f1cc73d831d28dc5a7deb316a006e7848e6a7f467cdb10a0a9e0fb1c"
 "checksum remove_dir_all 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4a83fa3702a688b9359eccba92d153ac33fd2e8462f9e0e3fdf155239ea7792e"
 "checksum ron 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "17f52a24414403f81528b67488cf8edc4eda977d3af1646bb6b106a600ead78f"
-"checksum rowan 0.6.0-pre.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0eeee40f1a2724b7d0d9fa5f73a7804cd2f4c91b37ba9f785d429f31819d60df"
+"checksum rowan 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a796c0517d6969224c42e9ef01356363b0a7c57d10ec986c9a600d075666a5ff"
 "checksum rustc-demangle 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "a7f4dccf6f4891ebcc0c39f9b6eb1a83b9bf5d747cb439ec6fba4f3b977038af"
 "checksum rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7540fc8b0c49f096ee9c961cda096467dce8084bec6bdca2fc83895fd9b28cb8"
 "checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
@@ -2310,7 +2310,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum stacker 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "fb79482f57cf598af52094ec4cc3b3c42499d3ce5bd426f2ac41515b7e57404b"
 "checksum strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
 "checksum superslice 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ab16ced94dbd8a46c82fd81e3ed9a8727dac2977ea869d217bcc4ea1f122e81f"
-"checksum syn 0.15.40 (registry+https://github.com/rust-lang/crates.io-index)" = "bc945221ccf4a7e8c31222b9d1fc77aefdd6638eb901a6ce457a3dc29d4c31e8"
+"checksum syn 0.15.42 (registry+https://github.com/rust-lang/crates.io-index)" = "eadc09306ca51a40555dd6fc2b415538e9e18bc9f870e47b1a524a79fe2dcf5e"
 "checksum synstructure 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)" = "02353edf96d6e4dc81aea2d8490a7e9db177bf8acb0e951c24940bf866cb313f"
 "checksum tempfile 3.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e24d9338a0a5be79593e2fa15a648add6138caa803e2d5bc782c371732ca9"
 "checksum tera 0.11.20 (registry+https://github.com/rust-lang/crates.io-index)" = "4b505279e19d8f7d24b1a9dc58327c9c36174b1a2c7ebdeac70792d017cb64f3"
diff --git a/crates/ra_parser/src/grammar/expressions/atom.rs b/crates/ra_parser/src/grammar/expressions/atom.rs
index d98953a7ef..6bda041416 100644
--- a/crates/ra_parser/src/grammar/expressions/atom.rs
+++ b/crates/ra_parser/src/grammar/expressions/atom.rs
@@ -43,7 +43,6 @@ pub(super) const ATOM_EXPR_FIRST: TokenSet =
         L_BRACK,
         PIPE,
         MOVE_KW,
-        BOX_KW,
         IF_KW,
         WHILE_KW,
         MATCH_KW,
@@ -530,8 +529,6 @@ fn try_block_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 // test box_expr
 // fn foo() {
 //     let x = box 1i32;
-//     let y = (box 1i32, box 2i32);
-//     let z = Foo(box 1i32, box 2i32);
 // }
 fn box_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
     assert!(p.at(T![box]));
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 9ef8dee5d6..40d63ef7ac 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -10,8 +10,8 @@ repository = "https://github.com/rust-analyzer/rust-analyzer"
 [dependencies]
 unicode-xid = "0.1.0"
 itertools = "0.8.0"
-rowan = "0.6.0-pre.1"
-ra_rustc_lexer = { version = "0.1.0-pre.1", features = [ "unicode-xid" ] }
+rowan = "0.6.0"
+ra_rustc_lexer = { version = "0.1.0-pre.2" }
 
 # ideally, `serde` should be enabled by `ra_lsp_server`, but we enable it here
 # to reduce number of compilations
diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs
index e03c02d1ba..1f904434e8 100644
--- a/crates/ra_syntax/src/validation.rs
+++ b/crates/ra_syntax/src/validation.rs
@@ -1,16 +1,99 @@
-mod unescape;
-
 mod block;
 mod field_expr;
 
+use ra_rustc_lexer::unescape;
+
 use crate::{
     algo::visit::{visitor_ctx, VisitorCtx},
-    ast, SyntaxError,
+    ast, SyntaxError, SyntaxErrorKind,
     SyntaxKind::{BYTE, BYTE_STRING, CHAR, STRING},
     SyntaxNode, TextUnit, T,
 };
 
-pub(crate) use unescape::EscapeError;
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum EscapeError {
+    ZeroChars,
+    MoreThanOneChar,
+    LoneSlash,
+    InvalidEscape,
+    BareCarriageReturn,
+    EscapeOnlyChar,
+    TooShortHexEscape,
+    InvalidCharInHexEscape,
+    OutOfRangeHexEscape,
+    NoBraceInUnicodeEscape,
+    InvalidCharInUnicodeEscape,
+    EmptyUnicodeEscape,
+    UnclosedUnicodeEscape,
+    LeadingUnderscoreUnicodeEscape,
+    OverlongUnicodeEscape,
+    LoneSurrogateUnicodeEscape,
+    OutOfRangeUnicodeEscape,
+    UnicodeEscapeInByte,
+    NonAsciiCharInByte,
+}
+
+impl From<ra_rustc_lexer::unescape::EscapeError> for EscapeError {
+    fn from(err: ra_rustc_lexer::unescape::EscapeError) -> Self {
+        match err {
+            ra_rustc_lexer::unescape::EscapeError::ZeroChars => EscapeError::ZeroChars,
+            ra_rustc_lexer::unescape::EscapeError::MoreThanOneChar => EscapeError::MoreThanOneChar,
+            ra_rustc_lexer::unescape::EscapeError::LoneSlash => EscapeError::LoneSlash,
+            ra_rustc_lexer::unescape::EscapeError::InvalidEscape => EscapeError::InvalidEscape,
+            ra_rustc_lexer::unescape::EscapeError::BareCarriageReturn
+            | ra_rustc_lexer::unescape::EscapeError::BareCarriageReturnInRawString => {
+                EscapeError::BareCarriageReturn
+            }
+            ra_rustc_lexer::unescape::EscapeError::EscapeOnlyChar => EscapeError::EscapeOnlyChar,
+            ra_rustc_lexer::unescape::EscapeError::TooShortHexEscape => {
+                EscapeError::TooShortHexEscape
+            }
+            ra_rustc_lexer::unescape::EscapeError::InvalidCharInHexEscape => {
+                EscapeError::InvalidCharInHexEscape
+            }
+            ra_rustc_lexer::unescape::EscapeError::OutOfRangeHexEscape => {
+                EscapeError::OutOfRangeHexEscape
+            }
+            ra_rustc_lexer::unescape::EscapeError::NoBraceInUnicodeEscape => {
+                EscapeError::NoBraceInUnicodeEscape
+            }
+            ra_rustc_lexer::unescape::EscapeError::InvalidCharInUnicodeEscape => {
+                EscapeError::InvalidCharInUnicodeEscape
+            }
+            ra_rustc_lexer::unescape::EscapeError::EmptyUnicodeEscape => {
+                EscapeError::EmptyUnicodeEscape
+            }
+            ra_rustc_lexer::unescape::EscapeError::UnclosedUnicodeEscape => {
+                EscapeError::UnclosedUnicodeEscape
+            }
+            ra_rustc_lexer::unescape::EscapeError::LeadingUnderscoreUnicodeEscape => {
+                EscapeError::LeadingUnderscoreUnicodeEscape
+            }
+            ra_rustc_lexer::unescape::EscapeError::OverlongUnicodeEscape => {
+                EscapeError::OverlongUnicodeEscape
+            }
+            ra_rustc_lexer::unescape::EscapeError::LoneSurrogateUnicodeEscape => {
+                EscapeError::LoneSurrogateUnicodeEscape
+            }
+            ra_rustc_lexer::unescape::EscapeError::OutOfRangeUnicodeEscape => {
+                EscapeError::OutOfRangeUnicodeEscape
+            }
+            ra_rustc_lexer::unescape::EscapeError::UnicodeEscapeInByte => {
+                EscapeError::UnicodeEscapeInByte
+            }
+            ra_rustc_lexer::unescape::EscapeError::NonAsciiCharInByte
+            | ra_rustc_lexer::unescape::EscapeError::NonAsciiCharInByteString => {
+                EscapeError::NonAsciiCharInByte
+            }
+        }
+    }
+}
+
+impl From<ra_rustc_lexer::unescape::EscapeError> for SyntaxErrorKind {
+    fn from(err: ra_rustc_lexer::unescape::EscapeError) -> Self {
+        SyntaxErrorKind::EscapeError(err.into())
+    }
+}
 
 pub(crate) fn validate(root: &SyntaxNode) -> Vec<SyntaxError> {
     let mut errors = Vec::new();
diff --git a/crates/ra_syntax/src/validation/unescape.rs b/crates/ra_syntax/src/validation/unescape.rs
deleted file mode 100644
index 7eed6c6633..0000000000
--- a/crates/ra_syntax/src/validation/unescape.rs
+++ /dev/null
@@ -1,521 +0,0 @@
-//! Utilities for validating  string and char literals and turning them into
-//! values they represent.
-//!
-//! This file is copy-pasted from the compiler
-//!
-//! https://github.com/rust-lang/rust/blob/c6ac57564852cb6e2d0db60f7b46d9eb98d4b449/src/libsyntax/parse/unescape.rs
-//!
-//! Hopefully, we'll share this code in a proper way some day
-
-use std::ops::Range;
-use std::str::Chars;
-
-#[derive(Debug, PartialEq, Eq, Clone, Hash)]
-pub enum EscapeError {
-    ZeroChars,
-    MoreThanOneChar,
-
-    LoneSlash,
-    InvalidEscape,
-    BareCarriageReturn,
-    EscapeOnlyChar,
-
-    TooShortHexEscape,
-    InvalidCharInHexEscape,
-    OutOfRangeHexEscape,
-
-    NoBraceInUnicodeEscape,
-    InvalidCharInUnicodeEscape,
-    EmptyUnicodeEscape,
-    UnclosedUnicodeEscape,
-    LeadingUnderscoreUnicodeEscape,
-    OverlongUnicodeEscape,
-    LoneSurrogateUnicodeEscape,
-    OutOfRangeUnicodeEscape,
-
-    UnicodeEscapeInByte,
-    NonAsciiCharInByte,
-}
-
-/// Takes a contents of a char literal (without quotes), and returns an
-/// unescaped char or an error
-pub(crate) fn unescape_char(literal_text: &str) -> Result<char, (usize, EscapeError)> {
-    let mut chars = literal_text.chars();
-    unescape_char_or_byte(&mut chars, Mode::Char)
-        .map_err(|err| (literal_text.len() - chars.as_str().len(), err))
-}
-
-/// Takes a contents of a string literal (without quotes) and produces a
-/// sequence of escaped characters or errors.
-pub(crate) fn unescape_str<F>(literal_text: &str, callback: &mut F)
-where
-    F: FnMut(Range<usize>, Result<char, EscapeError>),
-{
-    unescape_str_or_byte_str(literal_text, Mode::Str, callback)
-}
-
-pub(crate) fn unescape_byte(literal_text: &str) -> Result<u8, (usize, EscapeError)> {
-    let mut chars = literal_text.chars();
-    unescape_char_or_byte(&mut chars, Mode::Byte)
-        .map(byte_from_char)
-        .map_err(|err| (literal_text.len() - chars.as_str().len(), err))
-}
-
-/// Takes a contents of a string literal (without quotes) and produces a
-/// sequence of escaped characters or errors.
-pub(crate) fn unescape_byte_str<F>(literal_text: &str, callback: &mut F)
-where
-    F: FnMut(Range<usize>, Result<u8, EscapeError>),
-{
-    unescape_str_or_byte_str(literal_text, Mode::ByteStr, &mut |range, char| {
-        callback(range, char.map(byte_from_char))
-    })
-}
-
-#[derive(Debug, Clone, Copy)]
-pub(crate) enum Mode {
-    Char,
-    Str,
-    Byte,
-    ByteStr,
-}
-
-impl Mode {
-    fn in_single_quotes(self) -> bool {
-        match self {
-            Mode::Char | Mode::Byte => true,
-            Mode::Str | Mode::ByteStr => false,
-        }
-    }
-
-    pub(crate) fn in_double_quotes(self) -> bool {
-        !self.in_single_quotes()
-    }
-
-    pub(crate) fn is_bytes(self) -> bool {
-        match self {
-            Mode::Byte | Mode::ByteStr => true,
-            Mode::Char | Mode::Str => false,
-        }
-    }
-}
-
-fn scan_escape(first_char: char, chars: &mut Chars<'_>, mode: Mode) -> Result<char, EscapeError> {
-    if first_char != '\\' {
-        return match first_char {
-            '\t' | '\n' => Err(EscapeError::EscapeOnlyChar),
-            '\r' => Err(if chars.clone().next() == Some('\n') {
-                EscapeError::EscapeOnlyChar
-            } else {
-                EscapeError::BareCarriageReturn
-            }),
-            '\'' if mode.in_single_quotes() => Err(EscapeError::EscapeOnlyChar),
-            '"' if mode.in_double_quotes() => Err(EscapeError::EscapeOnlyChar),
-            _ => {
-                if mode.is_bytes() && !first_char.is_ascii() {
-                    return Err(EscapeError::NonAsciiCharInByte);
-                }
-                Ok(first_char)
-            }
-        };
-    }
-
-    let second_char = chars.next().ok_or(EscapeError::LoneSlash)?;
-
-    let res = match second_char {
-        '"' => '"',
-        'n' => '\n',
-        'r' => '\r',
-        't' => '\t',
-        '\\' => '\\',
-        '\'' => '\'',
-        '0' => '\0',
-
-        'x' => {
-            let hi = chars.next().ok_or(EscapeError::TooShortHexEscape)?;
-            let hi = hi.to_digit(16).ok_or(EscapeError::InvalidCharInHexEscape)?;
-
-            let lo = chars.next().ok_or(EscapeError::TooShortHexEscape)?;
-            let lo = lo.to_digit(16).ok_or(EscapeError::InvalidCharInHexEscape)?;
-
-            let value = hi * 16 + lo;
-
-            if !mode.is_bytes() && !is_ascii(value) {
-                return Err(EscapeError::OutOfRangeHexEscape);
-            }
-            let value = value as u8;
-
-            value as char
-        }
-
-        'u' => {
-            if chars.next() != Some('{') {
-                return Err(EscapeError::NoBraceInUnicodeEscape);
-            }
-
-            let mut n_digits = 1;
-            let mut value: u32 = match chars.next().ok_or(EscapeError::UnclosedUnicodeEscape)? {
-                '_' => return Err(EscapeError::LeadingUnderscoreUnicodeEscape),
-                '}' => return Err(EscapeError::EmptyUnicodeEscape),
-                c => c.to_digit(16).ok_or(EscapeError::InvalidCharInUnicodeEscape)?,
-            };
-
-            loop {
-                match chars.next() {
-                    None => return Err(EscapeError::UnclosedUnicodeEscape),
-                    Some('_') => continue,
-                    Some('}') => {
-                        if n_digits > 6 {
-                            return Err(EscapeError::OverlongUnicodeEscape);
-                        }
-                        if mode.is_bytes() {
-                            return Err(EscapeError::UnicodeEscapeInByte);
-                        }
-
-                        break std::char::from_u32(value).ok_or_else(|| {
-                            if value > 0x0010_FFFF {
-                                EscapeError::OutOfRangeUnicodeEscape
-                            } else {
-                                EscapeError::LoneSurrogateUnicodeEscape
-                            }
-                        })?;
-                    }
-                    Some(c) => {
-                        let digit =
-                            c.to_digit(16).ok_or(EscapeError::InvalidCharInUnicodeEscape)?;
-                        n_digits += 1;
-                        if n_digits > 6 {
-                            continue;
-                        }
-                        let digit = digit as u32;
-                        value = value * 16 + digit;
-                    }
-                };
-            }
-        }
-        _ => return Err(EscapeError::InvalidEscape),
-    };
-    Ok(res)
-}
-
-fn unescape_char_or_byte(chars: &mut Chars<'_>, mode: Mode) -> Result<char, EscapeError> {
-    let first_char = chars.next().ok_or(EscapeError::ZeroChars)?;
-    let res = scan_escape(first_char, chars, mode)?;
-    if chars.next().is_some() {
-        return Err(EscapeError::MoreThanOneChar);
-    }
-    Ok(res)
-}
-
-/// Takes a contents of a string literal (without quotes) and produces a
-/// sequence of escaped characters or errors.
-fn unescape_str_or_byte_str<F>(src: &str, mode: Mode, callback: &mut F)
-where
-    F: FnMut(Range<usize>, Result<char, EscapeError>),
-{
-    assert!(mode.in_double_quotes());
-    let initial_len = src.len();
-    let mut chars = src.chars();
-    while let Some(first_char) = chars.next() {
-        let start = initial_len - chars.as_str().len() - first_char.len_utf8();
-
-        let unescaped_char = match first_char {
-            '\\' => {
-                let (second_char, third_char) = {
-                    let mut chars = chars.clone();
-                    (chars.next(), chars.next())
-                };
-                match (second_char, third_char) {
-                    (Some('\n'), _) | (Some('\r'), Some('\n')) => {
-                        skip_ascii_whitespace(&mut chars);
-                        continue;
-                    }
-                    _ => scan_escape(first_char, &mut chars, mode),
-                }
-            }
-            '\r' => {
-                let second_char = chars.clone().next();
-                if second_char == Some('\n') {
-                    chars.next();
-                    Ok('\n')
-                } else {
-                    scan_escape(first_char, &mut chars, mode)
-                }
-            }
-            '\n' => Ok('\n'),
-            '\t' => Ok('\t'),
-            _ => scan_escape(first_char, &mut chars, mode),
-        };
-        let end = initial_len - chars.as_str().len();
-        callback(start..end, unescaped_char);
-    }
-
-    fn skip_ascii_whitespace(chars: &mut Chars<'_>) {
-        let str = chars.as_str();
-        let first_non_space = str
-            .bytes()
-            .position(|b| b != b' ' && b != b'\t' && b != b'\n' && b != b'\r')
-            .unwrap_or_else(|| str.len());
-        *chars = str[first_non_space..].chars()
-    }
-}
-
-fn byte_from_char(c: char) -> u8 {
-    let res = c as u32;
-    assert!(res <= u32::from(u8::max_value()), "guaranteed because of Mode::Byte");
-    res as u8
-}
-
-fn is_ascii(x: u32) -> bool {
-    x <= 0x7F
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_unescape_char_bad() {
-        fn check(literal_text: &str, expected_error: EscapeError) {
-            let actual_result = unescape_char(literal_text).map_err(|(_offset, err)| err);
-            assert_eq!(actual_result, Err(expected_error));
-        }
-
-        check("", EscapeError::ZeroChars);
-        check(r"\", EscapeError::LoneSlash);
-
-        check("\n", EscapeError::EscapeOnlyChar);
-        check("\r\n", EscapeError::EscapeOnlyChar);
-        check("\t", EscapeError::EscapeOnlyChar);
-        check("'", EscapeError::EscapeOnlyChar);
-        check("\r", EscapeError::BareCarriageReturn);
-
-        check("spam", EscapeError::MoreThanOneChar);
-        check(r"\x0ff", EscapeError::MoreThanOneChar);
-        check(r#"\"a"#, EscapeError::MoreThanOneChar);
-        check(r"\na", EscapeError::MoreThanOneChar);
-        check(r"\ra", EscapeError::MoreThanOneChar);
-        check(r"\ta", EscapeError::MoreThanOneChar);
-        check(r"\\a", EscapeError::MoreThanOneChar);
-        check(r"\'a", EscapeError::MoreThanOneChar);
-        check(r"\0a", EscapeError::MoreThanOneChar);
-        check(r"\u{0}x", EscapeError::MoreThanOneChar);
-        check(r"\u{1F63b}}", EscapeError::MoreThanOneChar);
-
-        check(r"\v", EscapeError::InvalidEscape);
-        check(r"\💩", EscapeError::InvalidEscape);
-        check(r"\●", EscapeError::InvalidEscape);
-
-        check(r"\x", EscapeError::TooShortHexEscape);
-        check(r"\x0", EscapeError::TooShortHexEscape);
-        check(r"\xf", EscapeError::TooShortHexEscape);
-        check(r"\xa", EscapeError::TooShortHexEscape);
-        check(r"\xx", EscapeError::InvalidCharInHexEscape);
-        check(r"\xы", EscapeError::InvalidCharInHexEscape);
-        check(r"\x🦀", EscapeError::InvalidCharInHexEscape);
-        check(r"\xtt", EscapeError::InvalidCharInHexEscape);
-        check(r"\xff", EscapeError::OutOfRangeHexEscape);
-        check(r"\xFF", EscapeError::OutOfRangeHexEscape);
-        check(r"\x80", EscapeError::OutOfRangeHexEscape);
-
-        check(r"\u", EscapeError::NoBraceInUnicodeEscape);
-        check(r"\u[0123]", EscapeError::NoBraceInUnicodeEscape);
-        check(r"\u{0x}", EscapeError::InvalidCharInUnicodeEscape);
-        check(r"\u{", EscapeError::UnclosedUnicodeEscape);
-        check(r"\u{0000", EscapeError::UnclosedUnicodeEscape);
-        check(r"\u{}", EscapeError::EmptyUnicodeEscape);
-        check(r"\u{_0000}", EscapeError::LeadingUnderscoreUnicodeEscape);
-        check(r"\u{0000000}", EscapeError::OverlongUnicodeEscape);
-        check(r"\u{FFFFFF}", EscapeError::OutOfRangeUnicodeEscape);
-        check(r"\u{ffffff}", EscapeError::OutOfRangeUnicodeEscape);
-        check(r"\u{ffffff}", EscapeError::OutOfRangeUnicodeEscape);
-
-        check(r"\u{DC00}", EscapeError::LoneSurrogateUnicodeEscape);
-        check(r"\u{DDDD}", EscapeError::LoneSurrogateUnicodeEscape);
-        check(r"\u{DFFF}", EscapeError::LoneSurrogateUnicodeEscape);
-
-        check(r"\u{D800}", EscapeError::LoneSurrogateUnicodeEscape);
-        check(r"\u{DAAA}", EscapeError::LoneSurrogateUnicodeEscape);
-        check(r"\u{DBFF}", EscapeError::LoneSurrogateUnicodeEscape);
-    }
-
-    #[test]
-    fn test_unescape_char_good() {
-        fn check(literal_text: &str, expected_char: char) {
-            let actual_result = unescape_char(literal_text);
-            assert_eq!(actual_result, Ok(expected_char));
-        }
-
-        check("a", 'a');
-        check("ы", 'ы');
-        check("🦀", '🦀');
-
-        check(r#"\""#, '"');
-        check(r"\n", '\n');
-        check(r"\r", '\r');
-        check(r"\t", '\t');
-        check(r"\\", '\\');
-        check(r"\'", '\'');
-        check(r"\0", '\0');
-
-        check(r"\x00", '\0');
-        check(r"\x5a", 'Z');
-        check(r"\x5A", 'Z');
-        check(r"\x7f", 127 as char);
-
-        check(r"\u{0}", '\0');
-        check(r"\u{000000}", '\0');
-        check(r"\u{41}", 'A');
-        check(r"\u{0041}", 'A');
-        check(r"\u{00_41}", 'A');
-        check(r"\u{4__1__}", 'A');
-        check(r"\u{1F63b}", '😻');
-    }
-
-    #[test]
-    fn test_unescape_str_good() {
-        fn check(literal_text: &str, expected: &str) {
-            let mut buf = Ok(String::with_capacity(literal_text.len()));
-            unescape_str(literal_text, &mut |range, c| {
-                if let Ok(b) = &mut buf {
-                    match c {
-                        Ok(c) => b.push(c),
-                        Err(e) => buf = Err((range, e)),
-                    }
-                }
-            });
-            let buf = buf.as_ref().map(|it| it.as_ref());
-            assert_eq!(buf, Ok(expected))
-        }
-
-        check("foo", "foo");
-        check("", "");
-        check(" \t\n\r\n", " \t\n\n");
-
-        check("hello \\\n     world", "hello world");
-        check("hello \\\r\n     world", "hello world");
-        check("thread's", "thread's")
-    }
-
-    #[test]
-    fn test_unescape_byte_bad() {
-        fn check(literal_text: &str, expected_error: EscapeError) {
-            let actual_result = unescape_byte(literal_text).map_err(|(_offset, err)| err);
-            assert_eq!(actual_result, Err(expected_error));
-        }
-
-        check("", EscapeError::ZeroChars);
-        check(r"\", EscapeError::LoneSlash);
-
-        check("\n", EscapeError::EscapeOnlyChar);
-        check("\r\n", EscapeError::EscapeOnlyChar);
-        check("\t", EscapeError::EscapeOnlyChar);
-        check("'", EscapeError::EscapeOnlyChar);
-        check("\r", EscapeError::BareCarriageReturn);
-
-        check("spam", EscapeError::MoreThanOneChar);
-        check(r"\x0ff", EscapeError::MoreThanOneChar);
-        check(r#"\"a"#, EscapeError::MoreThanOneChar);
-        check(r"\na", EscapeError::MoreThanOneChar);
-        check(r"\ra", EscapeError::MoreThanOneChar);
-        check(r"\ta", EscapeError::MoreThanOneChar);
-        check(r"\\a", EscapeError::MoreThanOneChar);
-        check(r"\'a", EscapeError::MoreThanOneChar);
-        check(r"\0a", EscapeError::MoreThanOneChar);
-
-        check(r"\v", EscapeError::InvalidEscape);
-        check(r"\💩", EscapeError::InvalidEscape);
-        check(r"\●", EscapeError::InvalidEscape);
-
-        check(r"\x", EscapeError::TooShortHexEscape);
-        check(r"\x0", EscapeError::TooShortHexEscape);
-        check(r"\xa", EscapeError::TooShortHexEscape);
-        check(r"\xf", EscapeError::TooShortHexEscape);
-        check(r"\xx", EscapeError::InvalidCharInHexEscape);
-        check(r"\xы", EscapeError::InvalidCharInHexEscape);
-        check(r"\x🦀", EscapeError::InvalidCharInHexEscape);
-        check(r"\xtt", EscapeError::InvalidCharInHexEscape);
-
-        check(r"\u", EscapeError::NoBraceInUnicodeEscape);
-        check(r"\u[0123]", EscapeError::NoBraceInUnicodeEscape);
-        check(r"\u{0x}", EscapeError::InvalidCharInUnicodeEscape);
-        check(r"\u{", EscapeError::UnclosedUnicodeEscape);
-        check(r"\u{0000", EscapeError::UnclosedUnicodeEscape);
-        check(r"\u{}", EscapeError::EmptyUnicodeEscape);
-        check(r"\u{_0000}", EscapeError::LeadingUnderscoreUnicodeEscape);
-        check(r"\u{0000000}", EscapeError::OverlongUnicodeEscape);
-
-        check("ы", EscapeError::NonAsciiCharInByte);
-        check("🦀", EscapeError::NonAsciiCharInByte);
-
-        check(r"\u{0}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{000000}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{41}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{0041}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{00_41}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{4__1__}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{1F63b}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{0}x", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{1F63b}}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{FFFFFF}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{ffffff}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{ffffff}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{DC00}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{DDDD}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{DFFF}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{D800}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{DAAA}", EscapeError::UnicodeEscapeInByte);
-        check(r"\u{DBFF}", EscapeError::UnicodeEscapeInByte);
-    }
-
-    #[test]
-    fn test_unescape_byte_good() {
-        fn check(literal_text: &str, expected_byte: u8) {
-            let actual_result = unescape_byte(literal_text);
-            assert_eq!(actual_result, Ok(expected_byte));
-        }
-
-        check("a", b'a');
-
-        check(r#"\""#, b'"');
-        check(r"\n", b'\n');
-        check(r"\r", b'\r');
-        check(r"\t", b'\t');
-        check(r"\\", b'\\');
-        check(r"\'", b'\'');
-        check(r"\0", b'\0');
-
-        check(r"\x00", b'\0');
-        check(r"\x5a", b'Z');
-        check(r"\x5A", b'Z');
-        check(r"\x7f", 127);
-        check(r"\x80", 128);
-        check(r"\xff", 255);
-        check(r"\xFF", 255);
-    }
-
-    #[test]
-    fn test_unescape_byte_str_good() {
-        fn check(literal_text: &str, expected: &[u8]) {
-            let mut buf = Ok(Vec::with_capacity(literal_text.len()));
-            unescape_byte_str(literal_text, &mut |range, c| {
-                if let Ok(b) = &mut buf {
-                    match c {
-                        Ok(c) => b.push(c),
-                        Err(e) => buf = Err((range, e)),
-                    }
-                }
-            });
-            let buf = buf.as_ref().map(|it| it.as_ref());
-            assert_eq!(buf, Ok(expected))
-        }
-
-        check("foo", b"foo");
-        check("", b"");
-        check(" \t\n\r\n", b" \t\n\n");
-
-        check("hello \\\n     world", b"hello world");
-        check("hello \\\r\n     world", b"hello world");
-        check("thread's", b"thread's")
-    }
-}


Test patch:
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0132_box_expr.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0132_box_expr.rs
index fc9923b713..e69c81e22a 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0132_box_expr.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0132_box_expr.rs
@@ -1,5 +1,3 @@
 fn foo() {
     let x = box 1i32;
-    let y = (box 1i32, box 2i32);
-    let z = Foo(box 1i32, box 2i32);
 }
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0132_box_expr.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0132_box_expr.txt
index 3d22002a14..f4eeb7e24e 100644
--- a/crates/ra_syntax/tests/data/parser/inline/ok/0132_box_expr.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0132_box_expr.txt
@@ -1,5 +1,5 @@
-SOURCE_FILE@[0; 106)
-  FN_DEF@[0; 105)
+SOURCE_FILE@[0; 35)
+  FN_DEF@[0; 34)
     FN_KW@[0; 2) "fn"
     WHITESPACE@[2; 3) " "
     NAME@[3; 6)
@@ -8,7 +8,7 @@ SOURCE_FILE@[0; 106)
       L_PAREN@[6; 7) "("
       R_PAREN@[7; 8) ")"
     WHITESPACE@[8; 9) " "
-    BLOCK@[9; 105)
+    BLOCK@[9; 34)
       L_CURLY@[9; 10) "{"
       WHITESPACE@[10; 15) "\n    "
       LET_STMT@[15; 32)
@@ -26,64 +26,6 @@ SOURCE_FILE@[0; 106)
           LITERAL@[27; 31)
             INT_NUMBER@[27; 31) "1i32"
         SEMI@[31; 32) ";"
-      WHITESPACE@[32; 37) "\n    "
-      LET_STMT@[37; 66)
-        LET_KW@[37; 40) "let"
-        WHITESPACE@[40; 41) " "
-        BIND_PAT@[41; 42)
-          NAME@[41; 42)
-            IDENT@[41; 42) "y"
-        WHITESPACE@[42; 43) " "
-        EQ@[43; 44) "="
-        WHITESPACE@[44; 45) " "
-        TUPLE_EXPR@[45; 65)
-          L_PAREN@[45; 46) "("
-          BOX_EXPR@[46; 54)
-            BOX_KW@[46; 49) "box"
-            WHITESPACE@[49; 50) " "
-            LITERAL@[50; 54)
-              INT_NUMBER@[50; 54) "1i32"
-          COMMA@[54; 55) ","
-          WHITESPACE@[55; 56) " "
-          BOX_EXPR@[56; 64)
-            BOX_KW@[56; 59) "box"
-            WHITESPACE@[59; 60) " "
-            LITERAL@[60; 64)
-              INT_NUMBER@[60; 64) "2i32"
-          R_PAREN@[64; 65) ")"
-        SEMI@[65; 66) ";"
-      WHITESPACE@[66; 71) "\n    "
-      LET_STMT@[71; 103)
-        LET_KW@[71; 74) "let"
-        WHITESPACE@[74; 75) " "
-        BIND_PAT@[75; 76)
-          NAME@[75; 76)
-            IDENT@[75; 76) "z"
-        WHITESPACE@[76; 77) " "
-        EQ@[77; 78) "="
-        WHITESPACE@[78; 79) " "
-        CALL_EXPR@[79; 102)
-          PATH_EXPR@[79; 82)
-            PATH@[79; 82)
-              PATH_SEGMENT@[79; 82)
-                NAME_REF@[79; 82)
-                  IDENT@[79; 82) "Foo"
-          ARG_LIST@[82; 102)
-            L_PAREN@[82; 83) "("
-            BOX_EXPR@[83; 91)
-              BOX_KW@[83; 86) "box"
-              WHITESPACE@[86; 87) " "
-              LITERAL@[87; 91)
-                INT_NUMBER@[87; 91) "1i32"
-            COMMA@[91; 92) ","
-            WHITESPACE@[92; 93) " "
-            BOX_EXPR@[93; 101)
-              BOX_KW@[93; 96) "box"
-              WHITESPACE@[96; 97) " "
-              LITERAL@[97; 101)
-                INT_NUMBER@[97; 101) "2i32"
-            R_PAREN@[101; 102) ")"
-        SEMI@[102; 103) ";"
-      WHITESPACE@[103; 104) "\n"
-      R_CURLY@[104; 105) "}"
-  WHITESPACE@[105; 106) "\n"
+      WHITESPACE@[32; 33) "\n"
+      R_CURLY@[33; 34) "}"
+  WHITESPACE@[34; 35) "\n"