From 71120ef1e5cb885ee45e6148970db6ce93ce1aca Mon Sep 17 00:00:00 2001 From: Matthias Krüger Date: Sun, 19 Aug 2018 15:30:23 +0200 Subject: Fix typos found by codespell. --- src/libsyntax/parse/parser.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 345464c6664..b6d876ebc9e 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -3535,8 +3535,8 @@ impl<'a> Parser<'a> { if arm_start_lines.lines[0].end_col == expr_lines.lines[0].end_col && expr_lines.lines.len() == 2 && self.token == token::FatArrow => { - // We check wether there's any trailing code in the parse span, if there - // isn't, we very likely have the following: + // We check whether there's any trailing code in the parse span, + // if there isn't, we very likely have the following: // // X | &Y => "y" // | -- - missing comma @@ -3934,7 +3934,7 @@ impl<'a> Parser<'a> { } /// A wrapper around `parse_pat` with some special error handling for the - /// "top-level" patterns in a match arm, `for` loop, `let`, &c. (in contast + /// "top-level" patterns in a match arm, `for` loop, `let`, &c. (in contrast /// to subpatterns within such). fn parse_top_level_pat(&mut self) -> PResult<'a, P> { let pat = self.parse_pat()?; @@ -4322,7 +4322,7 @@ impl<'a> Parser<'a> { // If `break_on_semi` is `Break`, then we will stop consuming tokens after // finding (and consuming) a `;` outside of `{}` or `[]` (note that this is // approximate - it can mean we break too early due to macros, but that - // shoud only lead to sub-optimal recovery, not inaccurate parsing). + // should only lead to sub-optimal recovery, not inaccurate parsing). // // If `break_on_block` is `Break`, then we will stop consuming tokens // after finding (and consuming) a brace-delimited block. @@ -4887,7 +4887,7 @@ impl<'a> Parser<'a> { fn parse_generic_bounds_common(&mut self, allow_plus: bool) -> PResult<'a, GenericBounds> { let mut bounds = Vec::new(); loop { - // This needs to be syncronized with `Token::can_begin_bound`. + // This needs to be synchronized with `Token::can_begin_bound`. let is_bound_start = self.check_path() || self.check_lifetime() || self.check(&token::Question) || self.check_keyword(keywords::For) || -- cgit 1.4.1-3-g733a5 From 5bf2ad3018de1f5a94bed2685211f3694f94249c Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Sun, 19 Aug 2018 21:25:08 -0700 Subject: syntax: Optimize some literal parsing Currently in the `wasm-bindgen` project we have a very very large crate that's procedurally generated, `web-sys`. To generate this crate we parse all of a browser's WebIDL and we then generate bindings for all of the APIs contained within. The resulting Rust file is 18MB large (wow!) and currently takes a very long time to compile in debug mode. On the nightly compiler a *debug* build takes 90s for the crate to finish. I was curious what was taking so long and upon investigating a *massive* portion of the time was spent in the `lit_token` method of the compiler, primarily formatting strings via `format!`. Upon some more investigation it looks like the `byte_str_lit` was allocating an error message once per byte, causing a very large number of allocations to happen for large literals, of which wasm-bindgen generates quite a few (some are MB large). This commit fixes the issue by lazily allocating the error message, only doing so if the error message is actually needed (which should be never). As a result, the debug mode compilation time for our `web-sys` crate decreased from 90s to 20s, a very nice improvement! (although we've still got some work to do). --- src/libsyntax/parse/mod.rs | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) (limited to 'src/libsyntax/parse') diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index d029509f0c1..2795d5c8f91 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -532,7 +532,7 @@ fn byte_lit(lit: &str) -> (u8, usize) { fn byte_str_lit(lit: &str) -> Lrc> { let mut res = Vec::with_capacity(lit.len()); - let error = |i| format!("lexer should have rejected {} at {}", lit, i); + let error = |i| panic!("lexer should have rejected {} at {}", lit, i); /// Eat everything up to a non-whitespace fn eat>(it: &mut iter::Peekable) { @@ -551,12 +551,11 @@ fn byte_str_lit(lit: &str) -> Lrc> { loop { match chars.next() { Some((i, b'\\')) => { - let em = error(i); - match chars.peek().expect(&em).1 { + match chars.peek().unwrap_or_else(|| error(i)).1 { b'\n' => eat(&mut chars), b'\r' => { chars.next(); - if chars.peek().expect(&em).1 != b'\n' { + if chars.peek().unwrap_or_else(|| error(i)).1 != b'\n' { panic!("lexer accepted bare CR"); } eat(&mut chars); @@ -573,8 +572,7 @@ fn byte_str_lit(lit: &str) -> Lrc> { } }, Some((i, b'\r')) => { - let em = error(i); - if chars.peek().expect(&em).1 != b'\n' { + if chars.peek().unwrap_or_else(|| error(i)).1 != b'\n' { panic!("lexer accepted bare CR"); } chars.next(); -- cgit 1.4.1-3-g733a5