Inline a hot closure in from_lit_token.

The change looks big because `rustfmt` rearranges things, but the only
real change is the inlining annotation.

compiler/rustc_ast/src/lib.rs

@@ -16,6 +16,7 @@
 #![feature(min_specialization)]
 #![recursion_limit = "256"]
 #![feature(slice_internals)]
+#![feature(stmt_expr_attributes)]
 
 #[macro_use]
 extern crate rustc_macros;

compiler/rustc_ast/src/util/literal.rs

@@ -56,20 +56,25 @@ impl LitKind {
                 // new symbol because the string in the LitKind is different to the
                 // string in the token.
                 let s = symbol.as_str();
-                let symbol =
+                let symbol = if s.contains(&['\\', '\r']) {
-                    if s.contains(&['\\', '\r']) {
                     let mut buf = String::with_capacity(s.len());
                     let mut error = Ok(());
-                        unescape_literal(&s, Mode::Str, &mut |_, unescaped_char| {
+                    // Force-inlining here is aggressive but the closure is
-                            match unescaped_char {
+                    // called on every char in the string, so it can be
+                    // hot in programs with many long strings.
+                    unescape_literal(
+                        &s,
+                        Mode::Str,
+                        &mut #[inline(always)]
+                        |_, unescaped_char| match unescaped_char {
                             Ok(c) => buf.push(c),
                             Err(err) => {
                                 if err.is_fatal() {
                                     error = Err(LitError::LexerError);
                                 }
                             }
-                            }
+                        },
-                        });
+                    );
                     error?;
                     Symbol::intern(&buf)
                 } else {