Rearrange to_internal.

`TokenTree::Punct` is handled outside the `match`. This commits moves it
inside the `match`, avoiding the need for the `return`s and making it
easier to read.

compiler/rustc_expand/src/proc_macro_server.rs

@@ -246,53 +246,8 @@ impl ToInternal<TokenStream> for (TokenTree<TokenStream, Span, Symbol>, &mut Rus
         use rustc_ast::token::*;
 
         let (tree, rustc) = self;
-        let (ch, joint, span) = match tree {
+        match tree {
-            TokenTree::Punct(Punct { ch, joint, span }) => (ch, joint, span),
+            TokenTree::Punct(Punct { ch, joint, span }) => {
-            TokenTree::Group(Group { delimiter, stream, span: DelimSpan { open, close, .. } }) => {
-                return tokenstream::TokenStream::delimited(
-                    tokenstream::DelimSpan { open, close },
-                    delimiter.to_internal(),
-                    stream.unwrap_or_default(),
-                );
-            }
-            TokenTree::Ident(self::Ident { sym, is_raw, span }) => {
-                rustc.sess().symbol_gallery.insert(sym, span);
-                return tokenstream::TokenStream::token_alone(Ident(sym, is_raw), span);
-            }
-            TokenTree::Literal(self::Literal {
-                kind: self::LitKind::Integer,
-                symbol,
-                suffix,
-                span,
-            }) if symbol.as_str().starts_with('-') => {
-                let minus = BinOp(BinOpToken::Minus);
-                let symbol = Symbol::intern(&symbol.as_str()[1..]);
-                let integer = TokenKind::lit(token::Integer, symbol, suffix);
-                let a = tokenstream::TokenTree::token_alone(minus, span);
-                let b = tokenstream::TokenTree::token_alone(integer, span);
-                return [a, b].into_iter().collect();
-            }
-            TokenTree::Literal(self::Literal {
-                kind: self::LitKind::Float,
-                symbol,
-                suffix,
-                span,
-            }) if symbol.as_str().starts_with('-') => {
-                let minus = BinOp(BinOpToken::Minus);
-                let symbol = Symbol::intern(&symbol.as_str()[1..]);
-                let float = TokenKind::lit(token::Float, symbol, suffix);
-                let a = tokenstream::TokenTree::token_alone(minus, span);
-                let b = tokenstream::TokenTree::token_alone(float, span);
-                return [a, b].into_iter().collect();
-            }
-            TokenTree::Literal(self::Literal { kind, symbol, suffix, span }) => {
-                return tokenstream::TokenStream::token_alone(
-                    TokenKind::lit(kind.to_internal(), symbol, suffix),
-                    span,
-                );
-            }
-        };
-
                 let kind = match ch {
                     b'=' => Eq,
                     b'<' => Lt,
@@ -318,13 +273,57 @@ impl ToInternal<TokenStream> for (TokenTree<TokenStream, Span, Symbol>, &mut Rus
                     b'\'' => SingleQuote,
                     _ => unreachable!(),
                 };
-
                 if joint {
                     tokenstream::TokenStream::token_joint(kind, span)
                 } else {
                     tokenstream::TokenStream::token_alone(kind, span)
                 }
             }
+            TokenTree::Group(Group { delimiter, stream, span: DelimSpan { open, close, .. } }) => {
+                tokenstream::TokenStream::delimited(
+                    tokenstream::DelimSpan { open, close },
+                    delimiter.to_internal(),
+                    stream.unwrap_or_default(),
+                )
+            }
+            TokenTree::Ident(self::Ident { sym, is_raw, span }) => {
+                rustc.sess().symbol_gallery.insert(sym, span);
+                tokenstream::TokenStream::token_alone(Ident(sym, is_raw), span)
+            }
+            TokenTree::Literal(self::Literal {
+                kind: self::LitKind::Integer,
+                symbol,
+                suffix,
+                span,
+            }) if symbol.as_str().starts_with('-') => {
+                let minus = BinOp(BinOpToken::Minus);
+                let symbol = Symbol::intern(&symbol.as_str()[1..]);
+                let integer = TokenKind::lit(token::Integer, symbol, suffix);
+                let a = tokenstream::TokenTree::token_alone(minus, span);
+                let b = tokenstream::TokenTree::token_alone(integer, span);
+                [a, b].into_iter().collect()
+            }
+            TokenTree::Literal(self::Literal {
+                kind: self::LitKind::Float,
+                symbol,
+                suffix,
+                span,
+            }) if symbol.as_str().starts_with('-') => {
+                let minus = BinOp(BinOpToken::Minus);
+                let symbol = Symbol::intern(&symbol.as_str()[1..]);
+                let float = TokenKind::lit(token::Float, symbol, suffix);
+                let a = tokenstream::TokenTree::token_alone(minus, span);
+                let b = tokenstream::TokenTree::token_alone(float, span);
+                [a, b].into_iter().collect()
+            }
+            TokenTree::Literal(self::Literal { kind, symbol, suffix, span }) => {
+                tokenstream::TokenStream::token_alone(
+                    TokenKind::lit(kind.to_internal(), symbol, suffix),
+                    span,
+                )
+            }
+        }
+    }
 }
 
 impl ToInternal<rustc_errors::Level> for Level {