Replace dart_core.js with actual compiled SDK

tool/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.
 library dev_compiler.tool.patch_sdk;
 
 import 'dart:io';
 
 import 'package:analyzer/analyzer.dart';
+import 'package:analyzer/src/generated/sdk.dart';
 import 'package:path/path.dart' as path;
 
-import 'input_sdk/lib/_internal/libraries.dart' as sdk;
+void main(List<String> argv) {

[Jennifer Messerly, 2015/03/19 22:57:34]

These changes aren't really needed, but they let patch_sdk work against more
than one location. Originally I had a separate "min_sdk" folder

+  if (argv.length < 2) {
+    var self = path.relative(Platform.script.path);
+    var toolDir = path.relative(path.dirname(Platform.script.path));
 
-void main(List<String> argv) {
-  var toolDir = path.relative(path.dirname(Platform.script.path));
-  var sdkLibIn = path.join(toolDir, 'input_sdk', 'lib');
-  var patchIn = path.join(toolDir, 'input_sdk', 'patch');
-  var privateIn = path.join(toolDir, 'input_sdk', 'private');
-  var sdkOut =
-      path.normalize(path.join(toolDir, '..', 'test', 'generated_sdk', 'lib'));
+    var inputExample = path.join(toolDir, 'input_sdk');
+    var outExample = path.relative(
+        path.normalize(path.join(toolDir, '..', 'test', 'generated_sdk')));
+
+    print('Usage: $self INPUT_DIR OUTPUT_DIR');
+    print('For example:');
+    print('\$ $self $inputExample $outExample');
+
+    inputExample = path.join(toolDir, 'min_sdk');
+    outExample = path.join(toolDir, 'out', 'min_sdk');
+    print('\$ $self $inputExample $outExample');
+    exit(1);
+  }
+
+  var input = argv[0];
+  var sdkLibIn = path.join(input, 'lib');
+  var patchIn = path.join(input, 'patch');
+  var privateIn = path.join(input, 'private');
+  var sdkOut = path.join(argv[1], 'lib');
   var privateLibOut =
       path.normalize(path.join(sdkOut, '_internal', 'compiler', 'js_lib'));
 
   var INTERNAL_PATH = '_internal/compiler/js_lib/';
 
-  if (argv.isNotEmpty) {
-    print('Usage: ${path.relative(Platform.script.path)}\n');
-    print('input SDK directory: $sdkLibIn');
-    // We can freely make changes to these two.
-    print('input private libs directory: $privateIn');
-    print('input patch directory: $patchIn');
-    print('output SDK directory: $sdkOut');
-    exit(1);
-  }
-
   // Copy libraries.dart and version
-  _writeSync(path.join(sdkOut, '_internal', 'libraries.dart'),
-      new File(path.join(sdkLibIn, '_internal', 'libraries.dart'))
-          .readAsStringSync());
+  var libContents = new File(path.join(sdkLibIn, '_internal', 'libraries.dart'))
+      .readAsStringSync();
+  _writeSync(path.join(sdkOut, '_internal', 'libraries.dart'), libContents);
   _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 (var library in sdk.LIBRARIES.values) {
-    if (library.platforms & sdk.DART2JS_PLATFORM == 0) continue;
+  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;
 
     var libraryOut = path.join(sdkLibIn, library.path);
     var libraryIn;
     if (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 contents = <String>[];
       var paths = <String>[];
       var libraryContents = libraryFile.readAsStringSync();
       paths.add(libraryOut);
       contents.add(libraryContents);
       for (var part in parseDirectives(libraryContents).directives) {
         if (part is PartDirective) {
           var partPath = part.uri.stringValue;
           paths.add(path.join(path.dirname(libraryOut), partPath));
           contents.add(new File(path.join(path.dirname(libraryIn), partPath))
               .readAsStringSync());
         }
       }
 
-      if (library.dart2jsPatchPath != null) {
-        var patchPath = path.join(
-            patchIn, library.dart2jsPatchPath.replaceAll(INTERNAL_PATH, ''));
+      // See if we can find a patch file.
+      var patchPath = path.join(
+          patchIn, path.basenameWithoutExtension(libraryIn) + '_patch.dart');
+
+      if (new File(patchPath).existsSync()) {
         var patchContents = new File(patchPath).readAsStringSync();
-
         contents = _patchLibrary(contents, patchContents);
       }
       for (var i = 0; i < paths.length; i++) {
         var outPath =
             path.join(sdkOut, path.relative(paths[i], from: sdkLibIn));
         _writeSync(outPath, contents[i]);
       }
     }
   }
 }
 
 /// Writes a file, creating the directory if needed.
 void _writeSync(String filePath, String contents) {
-  print('Writing $filePath');
-
   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.
@@ skipping 85 matching lines @@
   }
 
   void _maybePatch(AstNode node) {
     if (node is FieldDeclaration) return;
 
     var externalKeyword = (node as dynamic).externalKeyword;
     if (externalKeyword == null) return;
 
     var name = _qualifiedName(node);
     var patchNode = patch.patches[name];
-    if (patchNode == null) throw 'patch not found for $name: $node';
+    if (patchNode == null) {
+      print('warning: patch not found for $name: $node');
+      return;
+    }
 
     Annotation patchMeta = patchNode.metadata.lastWhere(_isPatchAnnotation);
     int start = patchMeta.endToken.next.offset;
     var code = patch.contents.substring(start, patchNode.end);
 
     // For some node like static fields, the node's offset doesn't include
     // the external keyword. Also starting from the keyword lets us preserve
     // documentation comments.
     edits.replace(externalKeyword.offset, node.end, code);
   }
@@ skipping 40 matching lines @@
       patches[_qualifiedName(node)] = node;
     } else {
       mergeDeclarations.add(node);
     }
   }
 
   @override visitFunctionBody(node) {} // skip method bodies
 }
 
 String _qualifiedName(Declaration node) {
-  assert(node is MethodDeclaration ||
-      node is FunctionDeclaration ||
-      node is ConstructorDeclaration);
-
   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 : '');
 }
 
 bool _isPatch(AnnotatedNode node) => node.metadata.any(_isPatchAnnotation);
@@ skipping 86 matching lines @@
   int get length => end - begin;
 
   String toString() => '(Edit @ $begin,$end: "$replace")';
 
   int compareTo(_StringEdit other) {
     int diff = begin - other.begin;
     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;
+}