Reject patches that change parameter names/types or return types.

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 81 matching lines @@
     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 _matchParameterLists(FormalParameterList baseParameters,
+      FormalParameterList patchParameters, String context()) {
+    if (baseParameters == null && patchParameters == null) return;
+    if (baseParameters == null || patchParameters == null) {
+      throw new ArgumentError("${context()}, parameter lists don't match");
+    }
+    if (baseParameters.parameters.length != patchParameters.parameters.length) {
+      throw new ArgumentError(
+          '${context()}, parameter lists have different lengths');
+    }
+    for (var i = 0; i < baseParameters.parameters.length; i++) {
+      _matchParameters(baseParameters.parameters[i],
+          patchParameters.parameters[i], () => '${context()}, parameter $i');
+    }
+  }
+
+  void _matchParameters(FormalParameter baseParameter,
+      FormalParameter patchParameter, String whichParameter()) {
+    if (baseParameter.identifier.name != patchParameter.identifier.name) {
+      throw new ArgumentError('${whichParameter()} has different name');
+    }
+    NormalFormalParameter baseParameterWithoutDefault =
+        _withoutDefault(baseParameter);
+    NormalFormalParameter patchParameterWithoutDefault =
+        _withoutDefault(patchParameter);
+    if (baseParameterWithoutDefault is SimpleFormalParameter &&
+        patchParameterWithoutDefault is SimpleFormalParameter) {
+      _matchTypes(baseParameterWithoutDefault.type,
+          patchParameterWithoutDefault.type, () => '${whichParameter()} type');
+    } else if (baseParameterWithoutDefault is FunctionTypedFormalParameter &&
+        patchParameterWithoutDefault is FunctionTypedFormalParameter) {
+      _matchTypes(
+          baseParameterWithoutDefault.returnType,
+          patchParameterWithoutDefault.returnType,
+          () => '${whichParameter()} return type');
+      _matchParameterLists(
+          baseParameterWithoutDefault.parameters,
+          patchParameterWithoutDefault.parameters,
+          () => '${whichParameter()} parameters');
+    } else if (baseParameterWithoutDefault is FieldFormalParameter &&
+        patchParameter is FieldFormalParameter) {
+      throw new ArgumentError(
+          '${whichParameter()} cannot be patched (field formal parameters are not supported)');
+    } else {
+      throw new ArgumentError(
+          '${whichParameter()} mismatch (different parameter kinds)');
+    }
+  }
+
+  void _matchTypes(TypeName baseType, TypeName patchType, String whichType()) {
+    error() => new ArgumentError("${whichType()} doesn't match");
+    if (baseType == null && patchType == null) return;
+    if (baseType == null || patchType == null) throw error();
+    // Match up the types token by token; this is more restrictive than strictly
+    // necessary, but it's easy and sufficient for patching purposes.
+    Token baseToken = baseType.beginToken;
+    Token patchToken = patchType.beginToken;
+    while (true) {
+      if (baseToken.lexeme != patchToken.lexeme) throw error();
+      if (identical(baseToken, baseType.endToken) &&
+          identical(patchToken, patchType.endToken)) {
+        break;
+      }
+      if (identical(baseToken, baseType.endToken) ||
+          identical(patchToken, patchType.endToken)) {
+        throw error();
+      }
+      baseToken = baseToken.next;
+      patchToken = patchToken.next;
+    }
+  }
+
   void _patchClassMembers(
       ClassDeclaration baseClass, ClassDeclaration patchClass) {
     String className = baseClass.name.name;
     List<ClassMember> membersToAppend = [];
     for (ClassMember patchMember in patchClass.members) {
       if (patchMember is FieldDeclaration) {
         if (_hasPatchAnnotation(patchMember.metadata)) {
           _failInPatch('attempts to patch a field', patchMember.offset);
         }
         List<VariableDeclaration> fields = patchMember.fields.variables;
@@ skipping 15 matching lines @@
             if (baseMember is MethodDeclaration &&
                 baseMember.name.name == name) {
               // Remove the "external" keyword.
               Token externalKeyword = baseMember.externalKeyword;
               if (externalKeyword != null) {
                 baseMember.externalKeyword = null;
                 _removeToken(externalKeyword);
               } else {
                 _failExternalKeyword(name, baseMember.offset);
               }
+              _matchParameterLists(
+                  baseMember.parameters,
+                  patchMember.parameters,
+                  () => 'While patching $className.$name');
+              _matchTypes(baseMember.returnType, patchMember.returnType,
+                  () => 'While patching $className.$name, return type');
               // Replace the body.
               FunctionBody oldBody = baseMember.body;
               FunctionBody newBody = patchMember.body;
               _replaceNodeTokens(oldBody, newBody);
               baseMember.body = newBody;
             }
           }
         } else {
           _failIfPublicName(patchMember, name);
           membersToAppend.add(patchMember);
@@ skipping 23 matching lines @@
                 _failInPatch(
                     'attempts to replace factory constructor with a generative one',
                     patchMember.offset);
               }
               // The base constructor should not have initializers.
               if (baseMember.initializers.isNotEmpty) {
                 throw new ArgumentError(
                     'Cannot patch external constructors with initializers '
                     'in $_baseDesc.');
               }
+              _matchParameterLists(
+                  baseMember.parameters, patchMember.parameters, () {
+                String nameSuffix = name == null ? '' : '.$name';
+                return 'While patching $className$nameSuffix';
+              });
               // Prepare nodes.
               FunctionBody baseBody = baseMember.body;
               FunctionBody patchBody = patchMember.body;
               NodeList<ConstructorInitializer> baseInitializers =
                   baseMember.initializers;
               NodeList<ConstructorInitializer> patchInitializers =
                   patchMember.initializers;
               // Replace initializers and link tokens.
               if (patchInitializers.isNotEmpty) {
                 baseMember.parameters.endToken
@@ skipping 53 matching lines @@
                 baseDeclaration is FunctionDeclaration &&
                 baseDeclaration.name.name == name) {
               // Remove the "external" keyword.
               Token externalKeyword = baseDeclaration.externalKeyword;
               if (externalKeyword != null) {
                 baseDeclaration.externalKeyword = null;
                 _removeToken(externalKeyword);
               } else {
                 _failExternalKeyword(name, baseDeclaration.offset);
               }
+              _matchParameterLists(
+                  baseDeclaration.functionExpression.parameters,
+                  patchDeclaration.functionExpression.parameters,
+                  () => 'While patching $name');
+              _matchTypes(
+                  baseDeclaration.returnType,
+                  patchDeclaration.returnType,
+                  () => 'While patching $name, return type');
               // Replace the body.
               FunctionExpression oldExpr = baseDeclaration.functionExpression;
               FunctionBody newBody = patchDeclaration.functionExpression.body;
               _replaceNodeTokens(oldExpr.body, newBody);
               oldExpr.body = newBody;
             }
           }
         } else if (appendNewTopLevelDeclarations) {
           _failIfPublicName(patchDeclaration, name);
           declarationsToAppend.add(patchDeclaration);
@@ skipping 30 matching lines @@
             patchDeclaration.offset);
       }
     }
     // Append new top-level declarations.
     if (appendNewTopLevelDeclarations) {
       _appendToNodeList(baseUnit.declarations, declarationsToAppend,
           baseUnit.endToken.previous);
     }
   }
 
+  NormalFormalParameter _withoutDefault(FormalParameter parameter) {
+    if (parameter is NormalFormalParameter) {
+      return parameter;
+    } else if (parameter is DefaultFormalParameter) {
+      return parameter.parameter;
+    } else {
+      // Should not happen.
+      assert(false);
+      return null;
+    }
+  }
+
   /**
    * 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);
@@ 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);
   }
 }