Add support for patching class methods.

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 54 matching lines @@
       Source patchSource = patchFile.createSource();
       CompilationUnit patchUnit = parse(patchSource, strongMode, errorListener);
 
       // Prepare for reporting errors.
       _baseDesc = source.toString();
       _patchDesc = patchFile.path;
       _patchUnit = patchUnit;
 
       _patchDirectives(
           source, unit, patchSource, patchUnit, addNewTopLevelDeclarations);
-      _patchTopLevelDeclarations(
-          source, unit, patchSource, patchUnit, addNewTopLevelDeclarations);
+      _patchTopLevelDeclarations(unit, patchUnit, addNewTopLevelDeclarations);
     }
   }
 
-  void _failExternalKeyword(Source source, String name, int offset) {
+  void _failExternalKeyword(String name, int offset) {
     throw new ArgumentError(
-        'The keyword "external" was expected for "$name" in $source @ $offset.');
+        'The keyword "external" was expected for "$name" in $_baseDesc @ $offset.');
   }
 
   void _failIfPublicName(AstNode node, String name) {
     if (!Identifier.isPrivateName(name)) {
       _failInPatch('contains a public declaration "$name"', node.offset);
     }
   }
 
   void _failInPatch(String message, int offset) {
     String loc = _getLocationDesc3(_patchUnit, offset);
     throw new ArgumentError(
         'The patch file $_patchDesc for $_baseDesc $message at $loc.');
   }
 
   String _getLocationDesc3(CompilationUnit unit, int offset) {
     LineInfo_Location location = unit.lineInfo.getLocation(offset);
     return 'the line ${location.lineNumber}';
   }
 
+  void _patchClassMembers(
+      ClassDeclaration baseClass, ClassDeclaration patchClass) {
+    List<ClassMember> membersToAppend = [];
+    for (ClassMember patchMember in patchClass.members) {
+      if (patchMember is MethodDeclaration) {
+        String name = patchMember.name.name;
+        if (_hasPatchAnnotation(patchMember.metadata)) {
+          for (ClassMember baseMember in baseClass.members) {
+            if (baseMember is MethodDeclaration &&
+                baseMember.name.name == name) {
+              // Remove the "external" keyword.

[Paul Berry, 2016/10/13 19:09:52]

It looks like we have some duplication between this code and the code in
_patchTopLevelDeclarations (everything between here and "baseMember.body =
newBody").  How about extracting a method to share code?

[scheglov, 2016/10/13 20:18:14]

It does not seem practical to me.
Both "externalKeyword" getter and setter are defined in leaf classes
FunctionDeclaration and MethodDeclaration. And there is not much code to share.
Well, we could use callback, but...

+              Token externalKeyword = baseMember.externalKeyword;
+              if (externalKeyword != null) {
+                baseMember.externalKeyword = null;
+                _removeToken(externalKeyword);
+              } else {
+                _failExternalKeyword(name, baseMember.offset);
+              }
+              // Replace the body.
+              FunctionBody oldBody = baseMember.body;
+              FunctionBody newBody = patchMember.body;
+              _replaceNodeTokens(oldBody, newBody);
+              baseMember.body = newBody;
+            }
+          }
+        } else {
+          _failIfPublicName(patchMember, name);
+          membersToAppend.add(patchMember);
+        }
+      } else {
+        // TODO(scheglov) support field
+        // TODO(scheglov) support constructors
+        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);

[Paul Berry, 2016/10/13 19:09:52]

Consider extracting a method for this logic too.

[scheglov, 2016/10/13 20:18:14]

OK
https://codereview.chromium.org/2417053002

+      lastToken.setNext(newMember.beginToken);
+      baseClass.members.add(newMember);
+      lastToken = newMember.endToken;
+    }
+  }
+
   void _patchDirectives(
       Source baseSource,
       CompilationUnit baseUnit,
       Source patchSource,
       CompilationUnit patchUnit,
       bool addNewTopLevelDeclarations) {
     for (Directive patchDirective in patchUnit.directives) {
       if (patchDirective is ImportDirective) {
         baseUnit.directives.add(patchDirective);
       } else {
         _failInPatch('contains an unsupported "$patchDirective" directive',
             patchDirective.offset);
       }
     }
   }
 
-  void _patchTopLevelDeclarations(
-      Source baseSource,
-      CompilationUnit baseUnit,
-      Source patchSource,
-      CompilationUnit patchUnit,
-      bool addNewTopLevelDeclarations) {
+  void _patchTopLevelDeclarations(CompilationUnit baseUnit,
+      CompilationUnit patchUnit, bool addNewTopLevelDeclarations) {
     List<CompilationUnitMember> declarationsToAppend = [];
     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.
-                Token externalKeyword = baseDeclaration.externalKeyword;
-                if (externalKeyword != null) {
-                  baseDeclaration.externalKeyword = null;
-                  _removeToken(externalKeyword);
-                } else {
-                  _failExternalKeyword(
-                      baseSource, name, baseDeclaration.offset);
-                }
-                // Replace the body.
-                FunctionExpression oldExpr = baseDeclaration.functionExpression;
-                FunctionBody newBody = patchDeclaration.functionExpression.body;
-                _replaceNodeTokens(oldExpr.body, newBody);
-                oldExpr.body = newBody;
+              // Remove the "external" keyword.
+              Token externalKeyword = baseDeclaration.externalKeyword;
+              if (externalKeyword != null) {
+                baseDeclaration.externalKeyword = null;
+                _removeToken(externalKeyword);
+              } else {
+                _failExternalKeyword(name, baseDeclaration.offset);
               }
+              // Replace the 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 if (patchDeclaration is ClassDeclaration) {
+        if (_hasPatchAnnotation(patchDeclaration.metadata)) {
+          String name = patchDeclaration.name.name;
+          for (CompilationUnitMember baseDeclaration in baseUnit.declarations) {
+            if (baseDeclaration is ClassDeclaration &&
+                baseDeclaration.name.name == name) {
+              _patchClassMembers(baseDeclaration, patchDeclaration);
+            }
+          }
+        } 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);
@@ skipping 43 matching lines @@
   }
 
   /**
    * 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);
   }
 }