Restructured the set up for the compiling function. Also added room for list of additional summarie…

web/web_command.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.
+@JS()
+library dev_compiler.web.web_command;
+
+import 'dart:async';
 import 'dart:html' show HttpRequest;
 import 'dart:convert' show BASE64;
 
 import 'package:analyzer/file_system/file_system.dart'
     show ResourceProvider, ResourceUriResolver;
 import 'package:analyzer/file_system/memory_file_system.dart'
     show MemoryResourceProvider;
 import 'package:analyzer/src/context/cache.dart'
     show AnalysisCache, CachePartition;
 import 'package:analyzer/src/context/context.dart' show AnalysisContextImpl;
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisEngine, TimestampedData;
 import 'package:analyzer/src/generated/sdk.dart'
     show DartSdk, SdkLibrary, SdkLibraryImpl;
 import 'package:analyzer/src/generated/source.dart'
     show DartUriResolver, Source, SourceFactory, UriKind;
 import 'package:analyzer/src/summary/idl.dart' show PackageBundle;
+import 'package:analyzer/src/summary/package_bundle_reader.dart'
+    show
+        SummaryDataStore,
+        InSummaryPackageUriResolver,
+        InputPackagesResultProvider;
 import 'package:analyzer/src/summary/summary_sdk.dart' show SummaryBasedDartSdk;
 
 import 'package:args/command_runner.dart';
 
 import 'package:dev_compiler/src/analyzer/context.dart' show AnalyzerOptions;
 import 'package:dev_compiler/src/compiler/compiler.dart'
     show BuildUnit, CompilerOptions, JSModuleFile, ModuleCompiler;
 
+import 'package:js/js.dart';
+
 typedef void MessageHandler(Object message);
-typedef String CompileFn(String dart);
-typedef void OnLoadFn(CompileFn compile);
 
 /// The command for invoking the modular compiler.
 class WebCompileCommand extends Command {
   get name => 'compile';
   get description => 'Compile a set of Dart files into a JavaScript module.';
   final MessageHandler messageHandler;
-  final OnLoadFn onload;
 
-  WebCompileCommand(this.onload, {MessageHandler messageHandler})
+  WebCompileCommand({MessageHandler messageHandler})
       : this.messageHandler = messageHandler ?? print {
     CompilerOptions.addArguments(argParser);
     AnalyzerOptions.addArguments(argParser);
   }
 
   @override
-  void run() {
-    var request = new HttpRequest();
+  Function run() {
+    return requestSummaries;
+  }
 
-    request.onReadyStateChange.listen((_) {
-      if (request.readyState == HttpRequest.DONE &&
-          (request.status == 200 || request.status == 0)) {
-        var response = request.responseText;
-        var sdkBytes = BASE64.decode(response);
-        var result = setUpCompile(sdkBytes);
-        onload(result);
+  void requestSummaries(
+      String sdkUrl, List<String> summaryUrls, Function callback) {
+    HttpRequest.request(sdkUrl).then((sdkRequest) {
+      if (sdkRequest.readyState == HttpRequest.DONE &&
+          (sdkRequest.status == 200 || sdkRequest.status == 0)) {
+        var sdkResponse = sdkRequest.responseText;
+        var sdkBytes = BASE64.decode(sdkResponse);
+
+        // Map summary URLs to HttpRequests.
+        var summaryRequests = summaryUrls
+            .map((summary) => new Future(() => HttpRequest.request(summary)));
+
+        Future.wait(summaryRequests).then((summaryResponses) {
+          // Map summary responses to summary bytes.
+          var summaryBytes = [];
+          for (var response in summaryResponses) {
+            if (response.readyState == HttpRequest.DONE &&

[Jacob, 2016/08/04 16:27:48]

I don't think these status checks are needed. I believe the future will not
complete in the then clause if a failure case was hit. Instead you need to use
the onError handler of the Future.

[priscillalee, 2016/08/04 17:56:33]

Done.

+                (response.status == 200 || response.status == 0)) {
+              summaryBytes.add(BASE64.decode(response.responseText));
+            }
+          }
+
+          var compileFn = setUpCompile(sdkBytes, summaryBytes);
+          callback(compileFn);
+        });
       }
     });
-
-    request.open('get', 'dart_sdk.sum');
-    request.send();
   }
 
-  CompileFn setUpCompile(List<int> sdkBytes) {
+  Function setUpCompile(List<int> sdkBytes, List<List<int>> summaryBytes) {
     var resourceProvider = new MemoryResourceProvider();
+    var resourceUriResolver = new ResourceUriResolver(resourceProvider);
+
     var packageBundle = new PackageBundle.fromBuffer(sdkBytes);
     var webDartSdk = new SummaryBasedDartSdk.fromBundle(
         true, packageBundle, resourceProvider);
+    var sdkResolver = new DartUriResolver(webDartSdk);
 
-    var sdkResolver = new DartUriResolver(webDartSdk);
-    var fileResolvers = [new ResourceUriResolver(resourceProvider)];
+    var summaryDataStore = new SummaryDataStore([]);
+    for (var bytes in summaryBytes) {
+      var summaryBundle = new PackageBundle.fromBuffer(bytes);
+      summaryDataStore.addBundle('', summaryBundle);
+    }
+    var summaryResolver = new InSummaryPackageUriResolver(summaryDataStore);
+
+    var fileResolvers = [summaryResolver, resourceUriResolver];
 
     var compiler = new ModuleCompiler(
         new AnalyzerOptions(dartSdkPath: '/dart-sdk'),
         sdkResolver: sdkResolver,
         fileResolvers: fileResolvers,
         resourceProvider: resourceProvider);
 
+    compiler.context.resultProvider =
+        new InputPackagesResultProvider(compiler.context, summaryDataStore);
+
     var compilerOptions = new CompilerOptions.fromArguments(argResults);
 
     var number = 0;
 
-    return (String dart) {
+    var compileFn = (String dart) {
       // Create a new virtual File that contains the given Dart source.
       number++;
-      resourceProvider.newFile("/expression$number.dart", dart);
+      resourceProvider.newFile("/expression${number}.dart", dart);
 
-      var unit =
-          new BuildUnit("", "", ["file:///expression$number.dart"], null);
+      var unit = new BuildUnit(
+          "", "", ["file:///expression$number.dart"], (source) => "");
 
       JSModuleFile module = compiler.compile(unit, compilerOptions);
       module.errors.forEach(messageHandler);
 
       if (!module.isValid) throw new CompileErrorException();
       return module.code;
     };
+
+    return allowInterop(compileFn);
   }
 }
 
 /// Thrown when the input source code has errors.
 class CompileErrorException implements Exception {
   toString() => '\nPlease fix all errors before compiling (warnings are okay).';
 }