Precompile immutable dependencies on "pub get".

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

 library pub.entrypoint;
 import 'dart:async';
 import 'package:path/path.dart' as path;
 import 'package:barback/barback.dart';
 import 'barback/asset_environment.dart';
 import 'io.dart';
 import 'lock_file.dart';
 import 'log.dart' as log;
 import 'package.dart';
 import 'package_graph.dart';
@@ skipping 22 matching lines @@
       _lockFile = new LockFile.empty();
     } else {
       _lockFile = new LockFile.load(lockFilePath, cache.sources);
     }
     return _lockFile;
   }
   String get pubspecPath => path.join(root.dir, 'pubspec.yaml');
   String get lockFilePath => path.join(root.dir, '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();
+              log.fine(
+                  "dependencies to precompile: ${dependenciesToPrecompile}");
+              log.fine("changed: ${changed}");
+              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();
     var binDir = path.join('.pub', 'bin');
     var sdkVersionPath = path.join(binDir, 'sdk-version');
     var sdkMatches =
         fileExists(sdkVersionPath) &&
         readTextFile(sdkVersionPath) == "${sdk.version}\n";
     if (!sdkMatches) changed = null;
     return loadPackageGraph().then((graph) {
@@ skipping 30 matching lines @@
           }));
         });
       });
     });
   }
   List<AssetId> _executablesForPackage(PackageGraph graph, String packageName,
       Set<String> changed) {
     var package = graph.packages[packageName];
     var binDir = path.join(package.dir, '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(
         (executable) =>
             fileExists(
                 path.join(
                     '.pub',
                     'bin',
                     packageName,
                     "${path.url.basename(executable.path)}.snapshot")));
@@ skipping 128 matching lines @@
       fileAndSubfiles.addAll(_listDirWithoutPackages(file));
       return fileAndSubfiles;
     }));
   }
   void _linkOrDeleteSecondaryPackageDir(String dir) {
     var symlink = path.join(dir, 'packages');
     if (entryExists(symlink)) deleteEntry(symlink);
     if (_packageSymlinks) createSymlink(packagesDir, symlink, relative: true);
   }
 }