Use precompiled dependencies in pub.

sdk/lib/_internal/pub_generated/lib/src/entrypoint.dart

Index: sdk/lib/_internal/pub_generated/lib/src/entrypoint.dart
diff --git a/sdk/lib/_internal/pub_generated/lib/src/entrypoint.dart b/sdk/lib/_internal/pub_generated/lib/src/entrypoint.dart
index 128734492b88ebeba577699ddaed802bde3db276..4489a8790c1da87b17faab8a476a73f161caee55 100644
--- a/sdk/lib/_internal/pub_generated/lib/src/entrypoint.dart
+++ b/sdk/lib/_internal/pub_generated/lib/src/entrypoint.dart
@@ -25,7 +25,7 @@ class Entrypoint {
         _packageSymlinks = packageSymlinks;
   Entrypoint.inMemory(this.root, this._lockFile, this.cache)
       : _packageSymlinks = false;
-  String get packagesDir => path.join(root.dir, 'packages');
+  String get packagesDir => root.path('packages');
   bool get lockFileExists => _lockFile != null || entryExists(lockFilePath);
   LockFile get lockFile {
     if (_lockFile != null) return _lockFile;
@@ -36,44 +36,252 @@ class Entrypoint {
     }
     return _lockFile;
   }
-  String get pubspecPath => path.join(root.dir, 'pubspec.yaml');
-  String get lockFilePath => path.join(root.dir, 'pubspec.lock');
+  String get pubspecPath => root.path('pubspec.yaml');
+  String get lockFilePath => root.path('pubspec.lock');
   Future acquireDependencies(SolveType type, {List<String> useLatest,
       bool dryRun: false}) {
-    return syncFuture(() {
-      return resolveVersions(
-          type,
-          cache.sources,
-          root,
-          lockFile: lockFile,
-          useLatest: useLatest);
-    }).then((result) {
-      if (!result.succeeded) throw result.error;
-      result.showReport(type);
-      if (dryRun) {
-        result.summarizeChanges(type, dryRun: dryRun);
-        return null;
+    final completer0 = new Completer();
+    scheduleMicrotask(() {
+      try {
+        resolveVersions(
+            type,
+            cache.sources,
+            root,
+            lockFile: lockFile,
+            useLatest: useLatest).then((x0) {
+          try {
+            var result = x0;
+            join0() {
+              result.showReport(type);
+              join1() {
+                join2() {
+                  Future.wait(result.packages.map(_get)).then((x1) {
+                    try {
+                      var ids = x1;
+                      _saveLockFile(ids);
+                      join3() {
+                        _linkOrDeleteSecondaryPackageDirs();
+                        result.summarizeChanges(type, dryRun: dryRun);
+                        loadPackageGraph(result).then((x2) {
+                          try {
+                            var packageGraph = x2;
+                            packageGraph.loadTransformerCache().clearIfOutdated(
+                                result.changedPackages);
+                            completer0.complete(
+                                precompileDependencies(changed: result.changedPackages).then(((_) {
+                              return precompileExecutables(
+                                  changed: result.changedPackages);
+                            })).catchError(((error, stackTrace) {
+                              log.exception(error, stackTrace);
+                            })));
+                          } catch (e2) {
+                            completer0.completeError(e2);
+                          }
+                        }, onError: (e3) {
+                          completer0.completeError(e3);
+                        });
+                      }
+                      if (_packageSymlinks) {
+                        _linkSelf();
+                        join3();
+                      } else {
+                        join3();
+                      }
+                    } catch (e1) {
+                      completer0.completeError(e1);
+                    }
+                  }, onError: (e4) {
+                    completer0.completeError(e4);
+                  });
+                }
+                if (_packageSymlinks) {
+                  cleanDir(packagesDir);
+                  join2();
+                } else {
+                  deleteEntry(packagesDir);
+                  join2();
+                }
+              }
+              if (dryRun) {
+                result.summarizeChanges(type, dryRun: dryRun);
+                completer0.complete(null);
+              } else {
+                join1();
+              }
+            }
+            if (!result.succeeded) {
+              completer0.completeError(result.error);
+            } else {
+              join0();
+            }
+          } catch (e0) {
+            completer0.completeError(e0);
+          }
+        }, onError: (e5) {
+          completer0.completeError(e5);
+        });
+      } catch (e6) {
+        completer0.completeError(e6);
       }
-      if (_packageSymlinks) {
-        cleanDir(packagesDir);
-      } else {
-        deleteEntry(packagesDir);
+    });
+    return completer0.future;
+  }
+  Future precompileDependencies({Iterable<String> changed}) {
+    final completer0 = new Completer();
+    scheduleMicrotask(() {
+      try {
+        join0() {
+          loadPackageGraph().then((x0) {
+            try {
+              var graph = x0;
+              var depsDir = path.join('.pub', 'deps', 'debug');
+              var dependenciesToPrecompile =
+                  graph.packages.values.where(((package) {
+                if (package.pubspec.transformers.isEmpty) return false;
+                if (graph.isPackageMutable(package.name)) return false;
+                if (!dirExists(path.join(depsDir, package.name))) return true;
+                if (changed == null) return true;
+                return overlaps(
+                    graph.transitiveDependencies(
+                        package.name).map((package) => package.name).toSet(),
+                    changed);
+              })).map(((package) => package.name)).toSet();
+              join1() {
+                log.progress("Precompiling dependencies", (() {
+                  final completer0 = new Completer();
+                  scheduleMicrotask(() {
+                    try {
+                      var packagesToLoad = unionAll(
+                          dependenciesToPrecompile.map(
+                              graph.transitiveDependencies)).map(((package) => package.name)).toSet();
+                      AssetEnvironment.create(
+                          this,
+                          BarbackMode.DEBUG,
+                          packages: packagesToLoad,
+                          useDart2JS: false).then((x0) {
+                        try {
+                          var environment = x0;
+                          environment.barback.errors.listen(((_) {}));
+                          var it0 = dependenciesToPrecompile.iterator;
+                          break0(x4) {
+                            environment.barback.getAllAssets().then((x1) {
+                              try {
+                                var assets = x1;
+                                waitAndPrintErrors(assets.map(((asset) {
+                                  final completer0 = new Completer();
+                                  scheduleMicrotask(() {
+                                    try {
+                                      join0() {
+                                        var destPath =
+                                            path.join(depsDir, asset.id.package, path.fromUri(asset.id.path));
+                                        ensureDir(path.dirname(destPath));
+                                        createFileFromStream(
+                                            asset.read(),
+                                            destPath).then((x0) {
+                                          try {
+                                            x0;
+                                            completer0.complete(null);
+                                          } catch (e0) {
+                                            completer0.completeError(e0);
+                                          }
+                                        }, onError: (e1) {
+                                          completer0.completeError(e1);
+                                        });
+                                      }
+                                      if (!dependenciesToPrecompile.contains(
+                                          asset.id.package)) {
+                                        completer0.complete(null);
+                                      } else {
+                                        join0();
+                                      }
+                                    } catch (e2) {
+                                      completer0.completeError(e2);
+                                    }
+                                  });
+                                  return completer0.future;
+                                }))).then((x2) {
+                                  try {
+                                    x2;
+                                    log.message(
+                                        "Precompiled " +
+                                            toSentence(ordered(dependenciesToPrecompile).map(log.bold)) +
+                                            ".");
+                                    completer0.complete(null);
+                                  } catch (e2) {
+                                    completer0.completeError(e2);
+                                  }
+                                }, onError: (e3) {
+                                  completer0.completeError(e3);
+                                });
+                              } catch (e1) {
+                                completer0.completeError(e1);
+                              }
+                            }, onError: (e4) {
+                              completer0.completeError(e4);
+                            });
+                          }
+                          continue0(x5) {
+                            if (it0.moveNext()) {
+                              Future.wait([]).then((x3) {
+                                var package = it0.current;
+                                cleanDir(path.join(depsDir, package));
+                                continue0(null);
+                              });
+                            } else {
+                              break0(null);
+                            }
+                          }
+                          continue0(null);
+                        } catch (e0) {
+                          completer0.completeError(e0);
+                        }
+                      }, onError: (e5) {
+                        completer0.completeError(e5);
+                      });
+                    } catch (e6) {
+                      completer0.completeError(e6);
+                    }
+                  });
+                  return completer0.future;
+                })).catchError(((error) {
+                  for (var package in dependenciesToPrecompile) {
+                    deleteEntry(path.join(depsDir, package));
+                  }
+                  throw error;
+                })).then((x1) {
+                  try {
+                    x1;
+                    completer0.complete(null);
+                  } catch (e1) {
+                    completer0.completeError(e1);
+                  }
+                }, onError: (e2) {
+                  completer0.completeError(e2);
+                });
+              }
+              if (dependenciesToPrecompile.isEmpty) {
+                completer0.complete(null);
+              } else {
+                join1();
+              }
+            } catch (e0) {
+              completer0.completeError(e0);
+            }
+          }, onError: (e3) {
+            completer0.completeError(e3);
+          });
+        }
+        if (changed != null) {
+          changed = changed.toSet();
+          join0();
+        } else {
+          join0();
+        }
+      } catch (e4) {
+        completer0.completeError(e4);
       }
-      return Future.wait(result.packages.map(_get)).then((ids) {
-        _saveLockFile(ids);
-        if (_packageSymlinks) _linkSelf();
-        _linkOrDeleteSecondaryPackageDirs();
-        result.summarizeChanges(type, dryRun: dryRun);
-        return loadPackageGraph(result);
-      }).then((packageGraph) {
-        packageGraph.loadTransformerCache().clearIfOutdated(
-            result.changedPackages);
-        return precompileExecutables(
-            changed: result.changedPackages).catchError((error, stackTrace) {
-          log.exception(error, stackTrace);
-        });
-      });
     });
+    return completer0.future;
   }
   Future precompileExecutables({Iterable<String> changed}) {
     if (changed != null) changed = changed.toSet();
@@ -122,17 +330,13 @@ class Entrypoint {
   List<AssetId> _executablesForPackage(PackageGraph graph, String packageName,
       Set<String> changed) {
     var package = graph.packages[packageName];
-    var binDir = path.join(package.dir, 'bin');
+    var binDir = package.path('bin');
     if (!dirExists(binDir)) return [];
-    var deps = graph.transitiveDependencies(packageName);
-    var hasUncachedDependency = deps.any((package) {
-      var source = cache.sources[graph.lockFile.packages[package.name].source];
-      return source is! CachedSource;
-    });
-    if (hasUncachedDependency) return [];
+    if (graph.isPackageMutable(packageName)) return [];
     var executables = package.executableIds;
     if (changed == null) return executables;
-    if (deps.any((package) => changed.contains(package.name))) {
+    if (graph.transitiveDependencies(
+        packageName).any((package) => changed.contains(package.name))) {
       return executables;
     }
     var executablesExist = executables.every(
@@ -239,7 +443,7 @@ class Entrypoint {
   }
   void _saveLockFile(List<PackageId> packageIds) {
     _lockFile = new LockFile(packageIds);
-    var lockFilePath = path.join(root.dir, 'pubspec.lock');
+    var lockFilePath = root.path('pubspec.lock');
     writeTextFile(lockFilePath, _lockFile.serialize(root.dir, cache.sources));
   }
   void _linkSelf() {
@@ -254,10 +458,10 @@ class Entrypoint {
         relative: true);
   }
   void _linkOrDeleteSecondaryPackageDirs() {
-    var binDir = path.join(root.dir, 'bin');
+    var binDir = root.path('bin');
     if (dirExists(binDir)) _linkOrDeleteSecondaryPackageDir(binDir);
     for (var dir in ['benchmark', 'example', 'test', 'tool', 'web']) {
-      _linkOrDeleteSecondaryPackageDirsRecursively(path.join(root.dir, dir));
+      _linkOrDeleteSecondaryPackageDirsRecursively(root.path(dir));
     }
   }
   void _linkOrDeleteSecondaryPackageDirsRecursively(String dir) {