unfork DDC's copy of most SDK libraries

pkg/dev_compiler/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.
 
 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) {
   var self = path.relative(path.fromUri(Platform.script));
-  if (argv.length < 2) {
+  if (argv.length < 3) {
     var toolDir = path.relative(path.dirname(path.fromUri(Platform.script)));
 
-    var inputExample = path.join(toolDir, 'input_sdk');
+    var inputExample = path.join(toolDir, '..', '..', '..');
+    var patchExample = path.join(toolDir, 'input_sdk');
     var outExample =
         path.relative(path.normalize(path.join('gen', 'patched_sdk')));
 
-    print('Usage: $self INPUT_DIR OUTPUT_DIR');
+    print('Usage: $self INPUT_SDK_DIR PATCH_DIR OUTPUT_DIR');
     print('For example:');
-    print('\$ $self $inputExample $outExample');
+    print('\$ $self $inputExample $patchExample $outExample');
     exit(1);
   }
 
   var selfModifyTime = new File(self).lastModifiedSync().millisecondsSinceEpoch;
 
-  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 inputDir = argv[0];
+  var patchDir = argv[1];
+  var sdkLibIn = path.join(inputDir, 'sdk', 'lib');
+  var patchIn = path.join(patchDir, 'patch');
+  var privateIn = path.join(patchDir, 'private');
+  var sdkOut = path.join(argv[2], 'lib');
 
-  var INTERNAL_PATH = '_internal/compiler/js_lib/';
+  var INTERNAL_PATH = '_internal/js_runtime/lib/';
 
   // Copy libraries.dart and version
-  var libContents = new File(path.join(sdkLibIn, '_internal', 'libraries.dart'))
-      .readAsStringSync();
+  var librariesDart = path.join(patchDir, 'libraries.dart');
+  var libContents = new File(librariesDart).readAsStringSync();
+  // TODO(jmesserly): can we remove this?
   _writeSync(path.join(sdkOut, '_internal', 'libraries.dart'), libContents);
   _writeSync(
       path.join(
           sdkOut, '_internal', 'sdk_library_metadata', 'lib', 'libraries.dart'),
       libContents);
   _writeSync(path.join(sdkOut, '..', 'version'),
-      new File(path.join(sdkLibIn, '..', 'version')).readAsStringSync());
+      new File(path.join(inputDir, 'tools', '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;
 
     var libraryOut = path.join(sdkLibIn, library.path);
+    var libraryOverride = path.join(patchDir, 'lib', library.path);
     var libraryIn;
     if (library.path.contains(INTERNAL_PATH)) {
       libraryIn =
           path.join(privateIn, library.path.replaceAll(INTERNAL_PATH, ''));
+    } else if (new File(libraryOverride).existsSync()) {
+      libraryIn = libraryOverride;
     } else {
       libraryIn = libraryOut;
     }
 
     var libraryFile = new File(libraryIn);
     if (libraryFile.existsSync()) {
       var outPaths = <String>[libraryOut];
       var libraryContents = libraryFile.readAsStringSync();
 
       int inputModifyTime = math.max(selfModifyTime,
@@ skipping 40 matching lines @@
       }
 
       if (needsUpdate) {
         var contents = <String>[libraryContents];
         contents.addAll(partFiles.map((f) => f.readAsStringSync()));
         if (patchExists) {
           var patchContents = patchFile.readAsStringSync();
           contents = _patchLibrary(contents, patchContents);
         }
 
-        for (var i = 0; i < outPaths.length; i++) {
-          _writeSync(outPaths[i], contents[i]);
+        if (contents != null) {
+          for (var i = 0; i < outPaths.length; i++) {
+            _writeSync(outPaths[i], contents[i]);
+          }
+        } else {
+          exitCode = 2;
         }
       }
     }
   }
 }
 
 /// 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);
@@ skipping 21 matching lines @@
 /// 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) {
   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);
 
   // Merge `external` declarations with the corresponding `@patch` code.
+  bool failed = false;
   for (var partContent in partsContents) {
     var partEdits = new StringEditBuffer(partContent);
     var partUnit = parseCompilationUnit(partContent);
-    partUnit.accept(new PatchApplier(partEdits, patchFinder));
+    var patcher = new PatchApplier(partEdits, patchFinder);
+    partUnit.accept(patcher);
+    if (!failed) failed = patcher.patchWasMissing;
     results.add(partEdits);
   }
+  if (failed) return null;
   return new List<String>.from(results.map((e) => e.toString()));
 }
 
 /// Merge `@patch` declarations into `external` declarations.
 class PatchApplier extends GeneralizingAstVisitor {
   final StringEditBuffer edits;
   final PatchFinder patch;
 
   bool _isLibrary = true; // until proven otherwise.
+  bool patchWasMissing = false;
 
   PatchApplier(this.edits, this.patch);
 
   @override
   visitCompilationUnit(CompilationUnit node) {
     super.visitCompilationUnit(node);
     if (_isLibrary) _mergeUnpatched(node);
   }
 
   void _merge(AstNode node, int pos) {
@@ skipping 56 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) {
       print('warning: patch not found for $name: $node');
+      patchWasMissing = true;
       return;
     }
 
     Annotation patchMeta = patchNode.metadata.lastWhere(_isPatchAnnotation);
     int start = patchMeta.endToken.next.offset;
     var code = patch.contents.substring(start, patchNode.end);
 
     // Const factory constructors can't be legally parsed from the patch file,
     // so we need to omit the "const" there, but still preserve it.
     if (node is ConstructorDeclaration &&
@@ skipping 167 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;
 }