Add support for patching constructors.

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 109 matching lines @@
               FunctionBody oldBody = baseMember.body;
               FunctionBody newBody = patchMember.body;
               _replaceNodeTokens(oldBody, newBody);
               baseMember.body = newBody;
             }
           }
         } else {
           _failIfPublicName(patchMember, name);
           membersToAppend.add(patchMember);
         }
+      } else if (patchMember is ConstructorDeclaration) {
+        String name = patchMember.name?.name;
+        if (_hasPatchAnnotation(patchMember.metadata)) {
+          for (ClassMember baseMember in baseClass.members) {
+            if (baseMember is ConstructorDeclaration &&
+                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);
+              }
+              // Factory vs. generative.
+              if (baseMember.factoryKeyword == null &&
+                  patchMember.factoryKeyword != null) {
+                _failInPatch(
+                    'attempts to replace generative constructor with a factory one',
+                    patchMember.offset);
+              } else if (baseMember.factoryKeyword != null &&
+                  patchMember.factoryKeyword == null) {
+                _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.');
+              }
+              // 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
+                    .setNext(patchInitializers.beginToken.previous);
+                baseInitializers.addAll(patchInitializers);
+                patchBody.endToken.setNext(baseBody.endToken.next);
+              } else {
+                _replaceNodeTokens(baseBody, patchBody);
+              }
+              // Replace the body.
+              baseMember.body = patchBody;
+            }
+          }
+        } else {
+          if (name == null) {
+            if (!Identifier.isPrivateName(baseClass.name.name)) {
+              _failInPatch(
+                  'contains an unnamed public constructor', patchMember.offset);
+            }
+          } 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);
       lastToken.setNext(newMember.beginToken);
@@ skipping 124 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);
   }
 }