Minor clean-ups to token_stream_rewriter.dart.

pkg/front_end/lib/src/fasta/parser/token_stream_rewriter.dart

 // Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:front_end/src/fasta/errors.dart';
 import 'package:front_end/src/fasta/scanner/precedence.dart';
 import 'package:front_end/src/fasta/scanner/token.dart';
 
 /// Provides the capability of inserting tokens into a token stream by rewriting
 /// the previous token to point to the inserted token.
@@ skipping 26 matching lines @@
   /// Inserts [newToken] into the token stream just before [insertionPoint], and
   /// fixes up all "next" and "previous" pointers.
   ///
   /// Caller is required to ensure that [insertionPoint] is actually present in
   /// the token stream.
   void insertTokenBefore(Token newToken, Token insertionPoint) {
     Token previous = _findPreviousToken(insertionPoint);
     _lastPreviousToken = previous;
     newToken.next = insertionPoint;
     previous.next = newToken;
-    // Note: even though previousToken is deprecated, we need to hook it up in
-    // case any uses of it remain.  Once previousToken is removed it should be
-    // safe to remove the code below.
-    insertionPoint.previousToken = newToken;
-    newToken.previousToken = previous;
+    {
+      // Note: even though previousToken is deprecated, we need to hook it up in
+      // case any uses of it remain.  Once previousToken is removed it should be
+      // safe to remove this block of code.
+      insertionPoint.previousToken = newToken;
+      newToken.previousToken = previous;
+    }
   }
 
   /// Finds the token that immediately precedes [target].
   Token _findPreviousToken(Token target) {
     // First see if the target has a previous token pointer.  If it does, then
     // we can find the previous token with no extra effort.  Note: it's ok that
     // we're accessing the deprecated member previousToken here, because we have
     // a fallback if it is not available.  Once previousToken is removed, we can
     // remove the "if" test below, and always use the fallback code.
     if (target.previousToken != null) {
@@ skipping 12 matching lines @@
     Token previous = _scanForPreviousToken(target, _head);
     if (previous == null) {
       internalError('Could not find previous token');
     }
     return previous;
   }
 
   /// Searches for the token that immediately precedes [target], using [pos] as
   /// a starting point.
   ///
-  /// Uses heuristics to skip matching {}, [], (), and <> if possible.
+  /// Uses heuristics to skip matching `{}`, `[]`, `()`, and `<>` if possible.
   ///
   /// If no such token is found, returns `null`.
   Token _scanForPreviousToken(Token target, Token pos) {
     while (!identical(pos.next, target)) {
       Token nextPos;
       if (pos is BeginGroupToken &&
           pos.endGroup != null &&
           pos.endGroup.charOffset < target.charOffset) {
         nextPos = pos.endGroup;
       } else {
         nextPos = pos.next;
         if (nextPos == null || nextPos.charOffset > target.charOffset) {
           return null;
         }
       }
       pos = nextPos;
     }
     return pos;
   }
 }