Patch token stream when replace/add nodes.

pkg/analyzer/test/src/dart/sdk/patch_test.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.
 
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/src/dart/sdk/patch.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/util/fast_uri.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
@@ skipping 63 matching lines @@
     patches: {VM_PLATFORM: ['does_not_exists.dart']}),
 };''');
       _createSdk();
       File file = provider.newFile(_p('/sdk/lib/test/test.dart'), '');
       Source source = file.createSource(FastUri.parse('dart:test'));
       CompilationUnit unit = SdkPatcher.parse(source, true, listener);
       patcher.patch(sdk, SdkLibraryImpl.VM_PLATFORM, listener, source, unit);
     }, throwsArgumentError);
   }
 
-  test_topLevel_append() {
-    CompilationUnit unit = _doTopLevelPatching(
-        r'''
-int bar() => 2;
-''',
-        r'''
-int _foo1() => 1;
-int get _foo2 => 1;
-void set _foo3(int val) {}
-''');
-    _assertUnitCode(
-        unit,
-        'int bar() => 2; int _foo1() => 1; '
-        'int get _foo2 => 1; void set _foo3(int val) {}');
-  }
-
   test_topLevel_fail_topLevelVariable() {
     expect(() {
       _doTopLevelPatching(
           r'''
 int foo() => 0;
 ''',
           r'''
 int _bar;
 ''');
     }, throwsArgumentError);
   }
 
+  test_topLevel_function_append() {
+    CompilationUnit unit = _doTopLevelPatching(
+        r'''
+int foo() => 0;
+''',
+        r'''
+int _bar1() => 1;
+int _bar2() => 2;
+''');
+    _assertUnitCode(
+        unit, 'int foo() => 0; int _bar1() => 1; int _bar2() => 2;');
+
+    FunctionDeclaration foo = unit.declarations[0];
+    FunctionDeclaration bar1 = unit.declarations[1];
+    FunctionDeclaration bar2 = unit.declarations[2];
+
+    _assertPrevNextToken(foo.endToken, bar1.beginToken);
+    _assertPrevNextToken(bar1.endToken, bar2.beginToken);
+  }
+
   test_topLevel_function_fail_noExternalKeyword() {
     expect(() {
       _doTopLevelPatching(
           r'''
 int foo();
 ''',
           r'''
 @patch
 int foo() => 1;
 ''');
@@ skipping 11 matching lines @@
 ''');
     }, throwsArgumentError);
   }
 
   test_topLevel_functionTypeAlias_append() {
     CompilationUnit unit = _doTopLevelPatching(
         r'''
 int foo() => 0;
 ''',
         r'''
-typedef int _bar();
+typedef int _bar1();
+typedef int _bar2();
 ''');
-    _assertUnitCode(unit, 'int foo() => 0; typedef int _bar();');
+    _assertUnitCode(
+        unit, 'int foo() => 0; typedef int _bar1(); typedef int _bar2();');
+
+    FunctionDeclaration foo = unit.declarations[0];
+    FunctionTypeAlias bar1 = unit.declarations[1];
+    FunctionTypeAlias bar2 = unit.declarations[2];
+
+    _assertPrevNextToken(foo.endToken, bar1.beginToken);
+    _assertPrevNextToken(bar1.endToken, bar2.beginToken);
+    expect(unit.endToken.type, TokenType.EOF);
+    expect(bar2.endToken.next, same(unit.endToken));
   }
 
   test_topLevel_functionTypeAlias_fail_hasAnnotation() {
     expect(() {
       _doTopLevelPatching(
           r'''
 int foo() => 0;
 ''',
           r'''
 @patch
@@ skipping 18 matching lines @@
     CompilationUnit unit = _doTopLevelPatching(
         r'''
 external int foo();
 int bar() => 2;
 ''',
         r'''
 @patch
 int foo() => 1;
 ''');
     _assertUnitCode(unit, 'int foo() => 1; int bar() => 2;');
+
+    // Prepare functions.
+    FunctionDeclaration foo = unit.declarations[0];
+    FunctionDeclaration bar = unit.declarations[1];
+
+    // The "external" token is removed from the stream.
+    {
+      expect(foo.externalKeyword, isNull);
+      Token token = foo.beginToken;
+      expect(token.lexeme, 'int');
+      expect(token.previous.type, TokenType.EOF);
+    }
+
+    // The body tokens are included into the patched token stream.
+    {
+      FunctionExpression fooExpr = foo.functionExpression;
+      FunctionBody fooBody = fooExpr.body;
+      expect(fooBody.beginToken.previous, same(fooExpr.parameters.endToken));
+      expect(fooBody.endToken.next, same(bar.beginToken));
+    }
   }
 
   test_topLevel_patch_function_blockBody() {
     CompilationUnit unit = _doTopLevelPatching(
         r'''
 external int foo();
 ''',
         r'''
 @patch
 int foo() {int v = 1; return v + 2;}
@@ skipping 53 matching lines @@
     patcher.patch(sdk, SdkLibraryImpl.VM_PLATFORM, listener, source, unit);
     return unit;
   }
 
   String _p(String path) => provider.convertPath(path);
 
   void _setSdkLibraries(String code) {
     provider.newFile(
         _p('/sdk/lib/_internal/sdk_library_metadata/lib/libraries.dart'), code);
   }
+
+  static void _assertPrevNextToken(Token prev, Token next) {
+    expect(prev.next, same(next));
+    expect(next.previous, same(prev));
+  }
 }