Use precompiled dependencies in pub.

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';
 import 'sdk.dart' as sdk;
 import 'solver/version_solver.dart';
 import 'source/cached.dart';
 import 'system_cache.dart';
 import 'utils.dart';
 class Entrypoint {
   final Package root;
   final SystemCache cache;
   final bool _packageSymlinks;
   LockFile _lockFile;
   PackageGraph _packageGraph;
   Entrypoint(String rootDir, SystemCache cache, {bool packageSymlinks: true})
       : root = new Package.load(null, rootDir, cache.sources),
         cache = cache,
         _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;
     if (!lockFileExists) {
       _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');
+  String get pubspecPath => root.path('pubspec.yaml');
+  String get lockFilePath => root.path('pubspec.lock');
   Future acquireDependencies(SolveType type, {List<String> useLatest,
       bool dryRun: false}) {
     final completer0 = new Completer();
     scheduleMicrotask(() {
       try {
         resolveVersions(
             type,
             cache.sources,
             root,
             lockFile: lockFile,
@@ skipping 96 matching lines @@
                     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) {
+                      var it0 = dependenciesToPrecompile.iterator;
+                      break0(x4) {
+                        AssetEnvironment.create(
+                            this,
+                            BarbackMode.DEBUG,
+                            packages: packagesToLoad,
+                            useDart2JS: false).then((x0) {
+                          try {
+                            var environment = x0;
+                            environment.barback.errors.listen(((_) {}));
                             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));
@@ skipping 35 matching lines @@
                                   }
                                 }, onError: (e3) {
                                   completer0.completeError(e3);
                                 });
                               } catch (e1) {
                                 completer0.completeError(e1);
                               }
                             }, onError: (e4) {
                               completer0.completeError(e4);
                             });
+                          } catch (e0) {
+                            completer0.completeError(e0);
                           }
-                          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);
+                        });
+                      }
+                      continue0(x5) {
+                        if (it0.moveNext()) {
+                          Future.wait([]).then((x3) {
+                            var package = it0.current;
+                            deleteEntry(path.join(depsDir, package));
+                            continue0(null);
+                          });
+                        } else {
+                          break0(null);
                         }
-                      }, onError: (e5) {
-                        completer0.completeError(e5);
-                      });
+                      }
+                      continue0(null);
                     } catch (e6) {
                       completer0.completeError(e6);
                     }
                   });
                   return completer0.future;
                 })).catchError(((error) {
                   for (var package in dependenciesToPrecompile) {
                     deleteEntry(path.join(depsDir, package));
                   }
                   throw error;
@@ skipping 72 matching lines @@
                 dir,
                 executableIds: executables[package]);
           }));
         });
       });
     });
   }
   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 [];
     if (graph.isPackageMutable(packageName)) return [];
     var executables = package.executableIds;
     if (changed == null) return executables;
     if (graph.transitiveDependencies(
         packageName).any((package) => changed.contains(package.name))) {
       return executables;
     }
     var executablesExist = executables.every(
         (executable) =>
@@ skipping 92 matching lines @@
           });
         });
       }
     }).then((graph) {
       _packageGraph = graph;
       return graph;
     });
   }
   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() {
     var linkPath = path.join(packagesDir, root.name);
     if (entryExists(linkPath)) return;
     ensureDir(packagesDir);
     createPackageSymlink(
         root.name,
         root.dir,
         linkPath,
         isSelfLink: true,
         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) {
     if (!dirExists(dir)) return;
     _linkOrDeleteSecondaryPackageDir(dir);
     _listDirWithoutPackages(
         dir).where(dirExists).forEach(_linkOrDeleteSecondaryPackageDir);
   }
   List<String> _listDirWithoutPackages(dir) {
     return flatten(listDir(dir).map((file) {
       if (path.basename(file) == 'packages') return [];
       if (!dirExists(file)) return [];
       var fileAndSubfiles = [file];
       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);
   }
 }