Allow new public names in patches for the dart:_internal library.

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';
 import 'package:analyzer/src/dart/scanner/reader.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:meta/meta.dart';
 import 'package:path/src/context.dart';
 
 /**
  * [SdkPatcher] applies patches to SDK [CompilationUnit].
  */
 class SdkPatcher {
+  bool _allowNewPublicNames;
   String _baseDesc;
   String _patchDesc;
   CompilationUnit _patchUnit;
 
   /**
    * Patch the given [unit] of a SDK [source] with the patches defined in
    * the [sdk] for the given [platform].  Throw [ArgumentError] if a patch
    * file cannot be read, or the contents violates rules for patch files.
    */
   void patch(
       FolderBasedDartSdk sdk,
       int platform,
       AnalysisErrorListener errorListener,
       Source source,
       CompilationUnit unit) {
     // Process URI.
     String libraryUriStr;
     bool isLibraryDefiningUnit;
     {
       Uri uri = source.uri;
       if (uri.scheme != 'dart') {
         throw new ArgumentError(
             'The URI of the unit to patch must have the "dart" scheme: $uri');
       }
       List<String> uriSegments = uri.pathSegments;
-      libraryUriStr = 'dart:${uriSegments.first}';
+      String libraryName = uriSegments.first;
+      libraryUriStr = 'dart:$libraryName';
       isLibraryDefiningUnit = uriSegments.length == 1;
+      _allowNewPublicNames = libraryName == '_internal';
     }
     // Prepare the patch files to apply.
     List<String> patchPaths;
     {
       SdkLibrary sdkLibrary = sdk.getSdkLibrary(libraryUriStr);
       if (sdkLibrary == null) {
         throw new ArgumentError(
             'The library $libraryUriStr is not defined in the SDK.');
       }
       patchPaths = sdkLibrary.getPatches(platform);
@@ skipping 22 matching lines @@
       _patchTopLevelDeclarations(unit, patchUnit, isLibraryDefiningUnit);
     }
   }
 
   void _failExternalKeyword(String name, int offset) {
     throw new ArgumentError(
         'The keyword "external" was expected for "$name" in $_baseDesc @ $offset.');
   }
 
   void _failIfPublicName(AstNode node, String name) {
+    if (_allowNewPublicNames) {
+      return;
+    }
     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.');
   }
@@ skipping 11 matching lines @@
       if (patchMember is FieldDeclaration) {
         if (_hasPatchAnnotation(patchMember.metadata)) {
           _failInPatch('attempts to patch a field', patchMember.offset);
         }
         List<VariableDeclaration> fields = patchMember.fields.variables;
         if (fields.length != 1) {
           _failInPatch('contains a field declaration with more than one field',
               patchMember.offset);
         }
         String name = fields[0].name.name;
-        if (!Identifier.isPrivateName(className) &&
+        if (!_allowNewPublicNames &&
+            !Identifier.isPrivateName(className) &&
             !Identifier.isPrivateName(name)) {
-          // TODO(scheglov) allow adding public fields into dart:_internal
           _failInPatch('contains a public field', patchMember.offset);
         }
         membersToAppend.add(patchMember);
       } else 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.
@@ skipping 62 matching lines @@
                 patchBody.endToken.setNext(baseBody.endToken.next);
               } else {
                 _replaceNodeTokens(baseBody, patchBody);
               }
               // Replace the body.
               baseMember.body = patchBody;
             }
           }
         } else {
           if (name == null) {
-            if (!Identifier.isPrivateName(className)) {
+            if (!_allowNewPublicNames && !Identifier.isPrivateName(className)) {
               _failInPatch(
                   'contains an unnamed public constructor', patchMember.offset);
             }
           } else {
             _failIfPublicName(patchMember, name);
           }
           membersToAppend.add(patchMember);
         }
       } else {
         String className = patchClass.name.name;
@@ skipping 136 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);
   }
 }