Extract appending nodes to the list into a helper method.

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 179 matching lines @@
           }
           membersToAppend.add(patchMember);
         }
       } else {
         // TODO(scheglov) support field
         String className = patchClass.name.name;
         _failInPatch('contains an unsupported class member in $className',
             patchMember.offset);
       }
     }
-    // Append new top-level declarations.
-    Token lastToken = baseClass.endToken.previous;
-    for (ClassMember newMember in membersToAppend) {
-      newMember.endToken.setNext(lastToken.next);
-      lastToken.setNext(newMember.beginToken);
-      baseClass.members.add(newMember);
-      lastToken = newMember.endToken;
-    }
+    // Append new class members.
+    _appendToNodeList(
+        baseClass.members, membersToAppend, baseClass.leftBracket);
   }
 
   void _patchDirectives(
       Source baseSource,
       CompilationUnit baseUnit,
       Source patchSource,
       CompilationUnit patchUnit,
       bool addNewTopLevelDeclarations) {
     for (Directive patchDirective in patchUnit.directives) {
       if (patchDirective is ImportDirective) {
@@ skipping 54 matching lines @@
         } else {
           _failIfPublicName(patchDeclaration, patchDeclaration.name.name);
           declarationsToAppend.add(patchDeclaration);
         }
       } else {
         _failInPatch('contains an unsupported top-level declaration',
             patchDeclaration.offset);
       }
     }
     // Append new top-level declarations.
-    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;
-    }
+    _appendToNodeList(baseUnit.declarations, declarationsToAppend,
+        baseUnit.endToken.previous);
   }
 
   /**
    * Parse the given [source] into AST.
    */
   @visibleForTesting
   static CompilationUnit parse(
       Source source, bool strong, AnalysisErrorListener errorListener) {
     String code = source.contents.data;
 
     CharSequenceReader reader = new CharSequenceReader(code);
     Scanner scanner = new Scanner(source, reader, errorListener);
     scanner.scanGenericMethodComments = strong;
     Token token = scanner.tokenize();
     LineInfo lineInfo = new LineInfo(scanner.lineStarts);
 
     Parser parser = new Parser(source, errorListener);
     parser.parseGenericMethodComments = strong;
     CompilationUnit unit = parser.parseCompilationUnit(token);
     unit.lineInfo = lineInfo;
     return unit;
   }
 
   /**
+   * Append [newNodes] to the given [nodes] and attach new tokens to the end
+   * token of the last [nodes] items, or, if it is empty, to [defaultPrevToken].
+   */
+  static void _appendToNodeList(
+      NodeList<AstNode> nodes, List<AstNode> newNodes, Token defaultPrevToken) {
+    Token prevToken = nodes.endToken ?? defaultPrevToken;
+    for (AstNode newNode in newNodes) {
+      newNode.endToken.setNext(prevToken.next);
+      prevToken.setNext(newNode.beginToken);
+      nodes.add(newNode);
+      prevToken = newNode.endToken;
+    }
+  }
+
+  /**
    * 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);
   }
 }