Patch token stream when replace/add nodes.

pkg/analyzer/lib/src/dart/sdk/patch.dart

 // Copyright (c) 2016, 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.
 
 library analyzer.src.dart.sdk.patch;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/file_system/file_system.dart';
@@ skipping 114 matching lines @@
     for (CompilationUnitMember patchDeclaration in patchUnit.declarations) {
       if (patchDeclaration is FunctionDeclaration) {
         String name = patchDeclaration.name.name;
         if (_hasPatchAnnotation(patchDeclaration.metadata)) {
           for (CompilationUnitMember baseDeclaration in baseUnit.declarations) {
             if (patchDeclaration is FunctionDeclaration &&
                 baseDeclaration is FunctionDeclaration &&
                 baseDeclaration.name.name == name) {
               if (_hasPatchAnnotation(patchDeclaration.metadata)) {
                 // Remove the "external" keyword.
-                if (baseDeclaration.externalKeyword != null) {
+                Token externalKeyword = baseDeclaration.externalKeyword;
+                if (externalKeyword != null) {
                   baseDeclaration.externalKeyword = null;
+                  _removeToken(externalKeyword);
                 } else {
                   _failExternalKeyword(
                       baseSource, name, baseDeclaration.offset);
                 }
                 // Replace the body.
-                baseDeclaration.functionExpression.body =
-                    patchDeclaration.functionExpression.body;
+                FunctionExpression oldExpr = baseDeclaration.functionExpression;
+                FunctionBody newBody = patchDeclaration.functionExpression.body;
+                _replaceNodeTokens(oldExpr.body, newBody);
+                oldExpr.body = newBody;
               }
             }
           }
         } else if (addNewTopLevelDeclarations) {
           _failIfPublicName(patchDeclaration, name);
           declarationsToAppend.add(patchDeclaration);
         }
       } else if (patchDeclaration is FunctionTypeAlias) {
         if (patchDeclaration.metadata.isNotEmpty) {
           _failInPatch('contains a function type alias with an annotation',
               patchDeclaration.offset);
         }
         _failIfPublicName(patchDeclaration, patchDeclaration.name.name);
         declarationsToAppend.add(patchDeclaration);
       } else {
         _failInPatch('contains an unsupported top-level declaration',
             patchDeclaration.offset);
       }
     }
     // Append new top-level declarations.
-    baseUnit.declarations.addAll(declarationsToAppend);
+    Token lastToken = baseUnit.endToken.previous;
+    for (CompilationUnitMember newDeclaration in declarationsToAppend) {
+      newDeclaration.endToken.setNext(lastToken.next);
+      lastToken.setNext(newDeclaration.beginToken);
+      baseUnit.declarations.add(newDeclaration);
+      lastToken = newDeclaration.endToken;
+    }
   }
 
   /**
    * Parse the given [source] into AST.
    */
   @visibleForTesting
   static CompilationUnit parse(
       Source source, bool strong, AnalysisErrorListener errorListener) {
     String code = source.contents.data;
 
@@ skipping 14 matching lines @@
    * Return `true` if [metadata] has the `@patch` annotation.
    */
   static bool _hasPatchAnnotation(List<Annotation> metadata) {
     return metadata.any((annotation) {
       Identifier name = annotation.name;
       return annotation.constructorName == null &&
           name is SimpleIdentifier &&
           name.name == 'patch';
     });
   }
+
+  /**
+   * Remove the [token] from the stream.
+   */
+  static void _removeToken(Token token) {
+    token.previous.setNext(token.next);
+  }
+
+  /**
+   * Replace tokens of the [oldNode] with tokens of the [newNode].
+   */
+  static void _replaceNodeTokens(AstNode oldNode, AstNode newNode) {
+    oldNode.beginToken.previous.setNext(newNode.beginToken);
+    newNode.endToken.setNext(oldNode.endToken.next);
+  }
 }