Add support for patching parts.

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 11 matching lines @@
  */
 class SdkPatcher {
   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.
-   *
-   * If [addNewTopLevelDeclarations] is `true`, then the [unit] is the
-   * defining unit of a library, so new top-level declarations should be
-   * added to this unit.  For parts new declarations may be added only to the
-   * patched classes.
-   *
-   * TODO(scheglov) auto-detect [addNewTopLevelDeclarations]
    */
-  void patch(FolderBasedDartSdk sdk, int platform,
-      AnalysisErrorListener errorListener, Source source, CompilationUnit unit,
-      {bool addNewTopLevelDeclarations: true}) {
+  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 has the "dart" scheme: $uri');

[Brian Wilkerson, 2016/10/13 21:05:31]

"has" --> "have"

+      }
+      List<String> uriSegments = uri.pathSegments;
+      libraryUriStr = 'dart:${uriSegments.first}';
+      isLibraryDefiningUnit = uriSegments.length == 1;
+    }
     // Prepare the patch files to apply.
     List<String> patchPaths;
     {
-      // TODO(scheglov) add support for patching parts
-      String uriStr = source.uri.toString();
-      SdkLibrary sdkLibrary = sdk.getSdkLibrary(uriStr);
+      SdkLibrary sdkLibrary = sdk.getSdkLibrary(libraryUriStr);
       if (sdkLibrary == null) {
         throw new ArgumentError(
-            'The library $uriStr is not defined in the SDK.');
+            'The library $libraryUriStr is not defined in the SDK.');
       }
       patchPaths = sdkLibrary.getPatches(platform);
     }
 
     bool strongMode = sdk.analysisOptions.strongMode;
     Context pathContext = sdk.resourceProvider.pathContext;
     for (String path in patchPaths) {
       String pathInLib = pathContext.joinAll(path.split('/'));
       File patchFile = sdk.libraryDirectory.getChildAssumingFile(pathInLib);
       if (!patchFile.exists) {
         throw new ArgumentError(
             'The patch file ${patchFile.path} for $source does not exist.');
       }
       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(unit, patchUnit, addNewTopLevelDeclarations);
+      if (isLibraryDefiningUnit) {
+        _patchDirectives(source, unit, patchSource, patchUnit);
+      }
+      _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 (!Identifier.isPrivateName(name)) {
@@ skipping 109 matching lines @@
         String className = patchClass.name.name;
         _failInPatch('contains an unsupported class member in $className',
             patchMember.offset);
       }
     }
     // Append new class members.
     _appendToNodeList(
         baseClass.members, membersToAppend, baseClass.leftBracket);
   }
 
-  void _patchDirectives(
-      Source baseSource,
-      CompilationUnit baseUnit,
-      Source patchSource,
-      CompilationUnit patchUnit,
-      bool addNewTopLevelDeclarations) {
+  void _patchDirectives(Source baseSource, CompilationUnit baseUnit,
+      Source patchSource, CompilationUnit patchUnit) {
     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(CompilationUnit baseUnit,
-      CompilationUnit patchUnit, bool addNewTopLevelDeclarations) {
+      CompilationUnit patchUnit, bool appendNewTopLevelDeclarations) {
     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) {
               // 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) {
+        } else if (appendNewTopLevelDeclarations) {
           _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.
-    _appendToNodeList(baseUnit.declarations, declarationsToAppend,
-        baseUnit.endToken.previous);
+    if (appendNewTopLevelDeclarations) {
+      _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;
 
@@ skipping 45 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);
   }
 }