Wrapped long lines of code.

Author: Alexander Regueiro

src/libsyntax/ext/tt/macro_rules.rs

@@ -237,7 +237,12 @@ pub fn compile(sess: &ParseSess, features: &Features, def: &ast::Item) -> Syntax
             s.iter().map(|m| {
                 if let MatchedNonterminal(ref nt) = *m {
                     if let NtTT(ref tt) = **nt {
-                        let tt = quoted::parse(tt.clone().into(), false, true, sess, features, &def.attrs)
+                        let tt = quoted::parse(tt.clone().into(),
+                                               false,
+                                               true,
+                                               sess,
+                                               features,
+                                               &def.attrs)
                             .pop().unwrap();
                         valid &= check_lhs_nt_follows(sess, features, &def.attrs, &tt);
                         return tt;
@@ -254,7 +259,12 @@ pub fn compile(sess: &ParseSess, features: &Features, def: &ast::Item) -> Syntax
             s.iter().map(|m| {
                 if let MatchedNonterminal(ref nt) = *m {
                     if let NtTT(ref tt) = **nt {
-                        return quoted::parse(tt.clone().into(), !body.legacy, false, sess, features, &def.attrs)
+                        return quoted::parse(tt.clone().into(),
+                                             !body.legacy,
+                                             false,
+                                             sess,
+                                             features,
+                                             &def.attrs)
                             .pop().unwrap();
                     }
                 }

src/libsyntax/ext/tt/quoted.rs

@@ -204,7 +204,13 @@ pub fn parse(
     while let Some(tree) = trees.next() {
         // Given the parsed tree, if there is a metavar and we are expecting matchers, actually
         // parse out the matcher (i.e. in `$id:ident` this would parse the `:` and `ident`).
-        let tree = parse_tree(tree, &mut trees, hygiene_optout, expect_matchers, sess, features, attrs);
+        let tree = parse_tree(tree,
+                              &mut trees,
+                              hygiene_optout,
+                              expect_matchers,
+                              sess,
+                              features,
+                              attrs);
         match tree {
             TokenTree::MetaVar(start_sp, ident, _) if expect_matchers => {
                 let span = match trees.next() {
@@ -273,7 +279,14 @@ where
         tokenstream::TokenTree::Token(span, token::Pound) if hygiene_optout => match trees.peek() {
             Some(tokenstream::TokenTree::Token(_, token::Dollar)) => {
                 if let tokenstream::TokenTree::Token(span, token::Dollar) = trees.next().unwrap() {
-                    parse_meta_var(true, span, trees, hygiene_optout, expect_matchers, sess, features, attrs)
+                    parse_meta_var(true,
+                                   span,
+                                   trees,
+                                   hygiene_optout,
+                                   expect_matchers,
+                                   sess,
+                                   features,
+                                   attrs)
                 } else {
                     unreachable!();
                 }
@@ -302,7 +315,14 @@ where
 
         // `tree` is a `$` token. Look at the next token in `trees`.
         tokenstream::TokenTree::Token(span, token::Dollar) =>
-            parse_meta_var(false, span, trees, hygiene_optout, expect_matchers, sess, features, attrs),
+            parse_meta_var(false,
+                           span,
+                           trees,
+                           hygiene_optout,
+                           expect_matchers,
+                           sess,
+                           features,
+                           attrs),
 
         // `tree` is an arbitrary token. Keep it.
         tokenstream::TokenTree::Token(span, tok) => TokenTree::Token(span, tok, false),
@@ -313,7 +333,12 @@ where
             span,
             Lrc::new(Delimited {
                 delim: delimited.delim,
-                tts: parse(delimited.tts.into(), hygiene_optout, expect_matchers, sess, features, attrs),
+                tts: parse(delimited.tts.into(),
+                           hygiene_optout,
+                           expect_matchers,
+                           sess,
+                           features,
+                           attrs),
             }),
         ),
     }
@@ -344,7 +369,14 @@ where
                 sess.span_diagnostic.span_err(span, &msg);
             }
             // Parse the contents of the sequence itself
-            let sequence = parse(delimited.tts.into(), hygiene_optout, expect_matchers, sess, features, attrs);
+            let sequence = parse(
+                delimited.tts.into(),
+                hygiene_optout,
+                expect_matchers,
+                sess,
+                features,
+                attrs
+            );
             // Get the Kleene operator and optional separator
             let (separator, op) = parse_sep_and_kleene_op(trees, span, sess, features, attrs);
             // Count the number of captured "names" (i.e. named metavars)

src/libsyntax/ext/tt/transcribe.rs

@@ -182,19 +182,19 @@ pub fn transcribe(cx: &ExtCtxt,
                 let sp = sp.with_ctxt(sp_ctxt.apply_mark(cx.current_expansion.mark));
 
                 let update_ident_ctxt = |ident: Ident| {
-                    let ident_ctxt = if escape_hygiene {
-                        cx.call_site().ctxt()
+                    let new_span = if escape_hygiene {
+                        cx.call_site()
                     } else {
-                        ident.ctxt.apply_mark(cx.current_expansion.mark)
+                        ident.span.apply_mark(cx.current_expansion.mark)
                     };
-                    Ident { ctxt: ident_ctxt, ..ident }
+                    Ident::new(ident.name, new_span)
                 };
 
                 let result_tok = match tok {
                     token::Ident(ident, is_raw) =>
                         TokenTree::Token(sp, token::Ident(update_ident_ctxt(ident), is_raw)),
                     token::Lifetime(ident) =>
-                        TokenTree::Token(sp, token::Lifetime(ident)),
+                        TokenTree::Token(sp, token::Lifetime()),
                     _ => {
                         let mut marker = Marker(cx.current_expansion.mark);
                         noop_fold_tt(TokenTree::Token(sp, tok), &mut marker)