Merge more Kernel infrastructure from kernel_sdk SDK fork.

tools/patch_sdk.dart

 #!/usr/bin/env dart
 // Copyright (c) 2015, 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.
 
 /// Command line tool to merge the SDK libraries and our patch files.
 /// This is currently designed as an offline tool, but we could automate it.
 
 import 'dart:io';
 import 'dart:math' as math;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:path/path.dart' as path;
 
 void main(List<String> argv) {
-  if (argv.length < 2) {
-    var self = path.relative(path.fromUri(Platform.script));
-    var toolDir = path.relative(path.dirname(path.fromUri(Platform.script)));
+  var base = path.fromUri(Platform.script);
+  var dartDir = path.dirname(path.dirname(path.absolute(base)));
 
-    var inputExample = path.join(toolDir, 'input_sdk');
+  if (argv.length != 4 ||
+      !argv.isEmpty && argv.first != 'vm' && argv.first != 'ddc') {
+    var self = path.relative(base);
+    print('Usage: $self MODE SDK_DIR PATCH_DIR OUTPUT_DIR');
+    print('MODE must be one of ddc or vm.');
+
+    var toolDir = path.relative(path.dirname(base));
+    var sdkExample = path.join(toolDir, 'input_sdk');
+    var patchExample = path.join(sdkExample, 'patch');
     var outExample =
         path.relative(path.normalize(path.join('gen', 'patched_sdk')));
+    print('For example:');
+    print('\$ $self ddc $sdkExample $patchExample $outExample');
 
-    print('Usage: $self INPUT_DIR OUTPUT_DIR');
-    print('For example:');
-    print('\$ $self $inputExample $outExample');
+    var repositoryDir = path.relative(path.dirname(path.dirname(base)));
+    sdkExample = path.relative(path.join(repositoryDir, 'sdk'));
+    patchExample = path.relative(path.join(repositoryDir, 'out', 'DebugX64',
+                                           'obj', 'gen', 'patch'));
+    outExample = path.relative(path.join(repositoryDir, 'out', 'DebugX64',
+                                         'obj', 'gen', 'patched_sdk'));
+    print('or:');
+    print('\$ $self vm $sdkExample $patchExample $outExample');
+
     exit(1);
   }
 
-  var input = argv[0];
+  var mode = argv[0];
+  var input = argv[1];
   var sdkLibIn = path.join(input, 'lib');
-  var patchIn = path.join(input, 'patch');
+  var patchIn = argv[2];
+  var sdkOut = path.join(argv[3], 'lib');
+
   var privateIn = path.join(input, 'private');
-  var sdkOut = path.join(argv[1], 'lib');
-
   var INTERNAL_PATH = '_internal/compiler/js_lib/';
 
   // Copy libraries.dart and version
-  var libContents = new File(path.join(sdkLibIn, '_internal', 'libraries.dart'))
-      .readAsStringSync();
-  _writeSync(path.join(sdkOut, '_internal', 'libraries.dart'), libContents);
+  var libContents = new File(path.join(sdkLibIn, '_internal',
+      'sdk_library_metadata', 'lib', 'libraries.dart')).readAsStringSync();
   _writeSync(
       path.join(
           sdkOut, '_internal', 'sdk_library_metadata', 'lib', 'libraries.dart'),
       libContents);
-  _writeSync(path.join(sdkOut, '..', 'version'),
-      new File(path.join(sdkLibIn, '..', 'version')).readAsStringSync());
+  if (mode == 'ddc') {
+    _writeSync(path.join(sdkOut, '..', 'version'),
+        new File(path.join(sdkLibIn, '..', 'version')).readAsStringSync());
+  }
 
   // Parse libraries.dart
   var sdkLibraries = _getSdkLibraries(libContents);
 
   // Enumerate core libraries and apply patches
   for (SdkLibrary library in sdkLibraries) {
     // TODO(jmesserly): analyzer does not handle the default case of
     // "both platforms" correctly, and treats it as being supported on neither.
-    // So instead we skip explicitly marked as VM libs.
-    if (library.isVmLibrary) continue;
+    // So instead we skip explicitly marked as either VM or dart2js libs.
+    if (mode == 'ddc' ? libary.isVmLibrary : library.isDart2JsLibrary) {
+      continue;
+    }
 
     var libraryOut = path.join(sdkLibIn, library.path);
     var libraryIn;
-    if (library.path.contains(INTERNAL_PATH)) {
+    if (mode == 'vm' && library.path.contains('typed_data.dart')) {
+      // dart:typed_data is unlike the other libraries in the SDK. The VM does
+      // not apply a patch to the base SDK implementation of the library.
+      // Instead, the VM provides a replacement implementation and ignores the
+      // sources in the SDK.
+      libraryIn =
+          path.join(dartDir, 'runtime', 'lib', 'typed_data.dart');
+    } else if (mode == 'ddc' && library.path.contains(INTERNAL_PATH)) {
       libraryIn =
           path.join(privateIn, library.path.replaceAll(INTERNAL_PATH, ''));
     } else {
       libraryIn = libraryOut;
     }
 
     var libraryFile = new File(libraryIn);
     if (libraryFile.existsSync()) {
       var outPaths = <String>[libraryOut];
       var libraryContents = libraryFile.readAsStringSync();
@@ skipping 39 matching lines @@
           needsUpdate = true;
           break;
         }
       }
 
       if (needsUpdate) {
         var contents = <String>[libraryContents];
         contents.addAll(partFiles.map((f) => f.readAsStringSync()));
         if (patchExists) {
           var patchContents = patchFile.readAsStringSync();
-          contents = _patchLibrary(contents, patchContents);
+          contents = _patchLibrary(
+              patchFile.toString(), contents, patchContents);
         }
 
         for (var i = 0; i < outPaths.length; i++) {
           _writeSync(outPaths[i], contents[i]);
         }
       }
     }
   }
+  if (mode == 'vm') {
+    for (var tuple in [['nativewrappers', 'nativewrappers.dart'],
+                       ['_builtin', 'builtin.dart']]) {
+      var vmLibrary = tuple[0];
+      var dartFile = tuple[1];
+
+      // The "dart:_builtin" library is only available for the DartVM.
+      var builtinLibraryIn  = path.join(dartDir, 'runtime', 'bin', dartFile);
+      var builtinLibraryOut = path.join(sdkOut, vmLibrary, '${vmLibrary}.dart');
+      _writeSync(builtinLibraryOut, new File(builtinLibraryIn).readAsStringSync());
+    }
+
+    for (var file in ['loader.dart', 'server.dart', 'vmservice_io.dart']) {
+      var libraryIn  = path.join(dartDir, 'runtime', 'bin', 'vmservice', file);
+      var libraryOut = path.join(sdkOut, 'vmservice_io', file);
+      _writeSync(libraryOut, new File(libraryIn).readAsStringSync());
+    }
+  }
 }
 
 /// Writes a file, creating the directory if needed.
 void _writeSync(String filePath, String contents) {
   var outDir = new Directory(path.dirname(filePath));
   if (!outDir.existsSync()) outDir.createSync(recursive: true);
 
   new File(filePath).writeAsStringSync(contents);
 }
 
 /// Merges dart:* library code with code from *_patch.dart file.
 ///
 /// Takes a list of the library's parts contents, with the main library contents
 /// first in the list, and the contents of the patch file.
 ///
 /// The result will have `@patch` implementations merged into the correct place
 /// (e.g. the class or top-level function declaration) and all other
 /// declarations introduced by the patch will be placed into the main library
 /// file.
 ///
 /// This is purely a syntactic transformation. Unlike dart2js patch files, there
 /// is no semantic meaning given to the *_patch files, and they do not magically
 /// get their own library scope, etc.
 ///
 /// Editorializing: the dart2js approach requires a Dart front end such as
 /// package:analyzer to semantically model a feature beyond what is specified
 /// in the Dart language. Since this feature is only for the convenience of
 /// writing the dart:* libraries, and not a tool given to Dart developers, it
 /// seems like a non-ideal situation. Instead we keep the preprocessing simple.
-List<String> _patchLibrary(List<String> partsContents, String patchContents) {
+List<String> _patchLibrary(String name,
+                           List<String> partsContents,
+                           String patchContents) {
   var results = <StringEditBuffer>[];
 
   // Parse the patch first. We'll need to extract bits of this as we go through
   // the other files.
-  var patchFinder = new PatchFinder.parseAndVisit(patchContents);
+  final patchFinder = new PatchFinder.parseAndVisit(name, patchContents);
 
   // Merge `external` declarations with the corresponding `@patch` code.
   for (var partContent in partsContents) {
     var partEdits = new StringEditBuffer(partContent);
     var partUnit = parseCompilationUnit(partContent);
     partUnit.accept(new PatchApplier(partEdits, patchFinder));
     results.add(partEdits);
   }
   return new List<String>.from(results.map((e) => e.toString()));
 }
@@ skipping 95 matching lines @@
 }
 
 class PatchFinder extends GeneralizingAstVisitor {
   final String contents;
   final CompilationUnit unit;
 
   final Map patches = <String, Declaration>{};
   final Map mergeMembers = <String, List<ClassMember>>{};
   final List mergeDeclarations = <CompilationUnitMember>[];
 
-  PatchFinder.parseAndVisit(String contents)
+  PatchFinder.parseAndVisit(String name, String contents)
       : contents = contents,
-        unit = parseCompilationUnit(contents) {
+        unit = parseCompilationUnit(contents, name: name) {
     visitCompilationUnit(unit);
   }
 
   @override
   visitCompilationUnitMember(CompilationUnitMember node) {
     mergeDeclarations.add(node);
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
@@ skipping 27 matching lines @@
   visitFunctionBody(node) {} // skip method bodies
 }
 
 String _qualifiedName(Declaration node) {
   var parent = node.parent;
   var className = '';
   if (parent is ClassDeclaration) {
     className = parent.name.name + '.';
   }
   var name = (node as dynamic).name;
-  return className + (name != null ? name.name : '');
+  name = (name != null ? name.name : '');
+
+  var accessor = '';
+  if (node is MethodDeclaration) {
+    if (node.isGetter) accessor = 'get:';
+    else if (node.isSetter) accessor = 'set:';
+  }
+  return className + accessor + name;
 }
 
 bool _isPatch(AnnotatedNode node) => node.metadata.any(_isPatchAnnotation);
 
 bool _isPatchAnnotation(Annotation m) =>
     m.name.name == 'patch' && m.constructorName == null && m.arguments == null;
 
 /// Editable string buffer.
 ///
 /// Applies a series of edits (insertions, removals, replacements) using
@@ skipping 85 matching lines @@
     if (diff != 0) return diff;
     return end - other.end;
   }
 }
 
 List<SdkLibrary> _getSdkLibraries(String contents) {
   var libraryBuilder = new SdkLibrariesReader_LibraryBuilder(true);
   parseCompilationUnit(contents).accept(libraryBuilder);
   return libraryBuilder.librariesMap.sdkLibraries;
 }