Use precompiled dependencies in pub.

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

 // Copyright (c) 2012, 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.
 
 library pub.entrypoint;
 
 import 'dart:async';
 
 import 'package:path/path.dart' as path;
 import 'package:barback/barback.dart';
@@ skipping 55 matching lines @@
   Entrypoint(String rootDir, SystemCache cache, {bool packageSymlinks: true})
       : root = new Package.load(null, rootDir, cache.sources),
         cache = cache,
         _packageSymlinks = packageSymlinks;
 
   /// Creates an entrypoint given package and lockfile objects.
   Entrypoint.inMemory(this.root, this._lockFile, this.cache)
       : _packageSymlinks = false;
 
   /// The path to the entrypoint's "packages" directory.
-  String get packagesDir => path.join(root.dir, 'packages');
+  String get packagesDir => root.path('packages');
 
   /// `true` if the entrypoint package currently has a lock file.
   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;
   }
 
   /// The path to the entrypoint package's pubspec.
-  String get pubspecPath => path.join(root.dir, 'pubspec.yaml');
+  String get pubspecPath => root.path('pubspec.yaml');
 
   /// The path to the entrypoint package's lockfile.
-  String get lockFilePath => path.join(root.dir, 'pubspec.lock');
+  String get lockFilePath => root.path('pubspec.lock');
 
   /// Gets all dependencies of the [root] package.
   ///
   /// Performs version resolution according to [SolveType].
   ///
   /// [useLatest], if provided, defines a list of packages that will be
   /// unlocked and forced to their latest versions. If [upgradeAll] is
   /// true, the previous lockfile is ignored and all packages are re-resolved
   /// from scratch. Otherwise, it will attempt to preserve the versions of all
   /// previously locked packages.
@@ skipping 75 matching lines @@
           changed);
     }).map((package) => package.name).toSet();
 
     if (dependenciesToPrecompile.isEmpty) return;
 
     await log.progress("Precompiling dependencies", () async {
       var packagesToLoad =
           unionAll(dependenciesToPrecompile.map(graph.transitiveDependencies))
           .map((package) => package.name).toSet();
 
+      for (var package in dependenciesToPrecompile) {
+        deleteEntry(path.join(depsDir, package));
+      }
+
       var environment = await AssetEnvironment.create(this, BarbackMode.DEBUG,
           packages: packagesToLoad, useDart2JS: false);
 
       /// Ignore barback errors since they'll be emitted via [getAllAssets]
       /// below.
       environment.barback.errors.listen((_) {});
 
-      for (var package in dependenciesToPrecompile) {
-        cleanDir(path.join(depsDir, package));
-      }
-
       // TODO(nweiz): only get assets from [dependenciesToPrecompile] so as not
       // to trigger unnecessary lazy transformers.
       var assets = await environment.barback.getAllAssets();
       await waitAndPrintErrors(assets.map((asset) async {
         if (!dependenciesToPrecompile.contains(asset.id.package)) return;
 
         var destPath = path.join(
             depsDir, asset.id.package, path.fromUri(asset.id.path));
         ensureDir(path.dirname(destPath));
         await createFileFromStream(asset.read(), destPath);
@@ skipping 71 matching lines @@
   }
 
   /// Returns the list of all executable assets for [packageName] that should be
   /// precompiled.
   ///
   /// If [changed] isn't `null`, executables for [packageName] will only be
   /// compiled if they might depend on a package in [changed].
   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 we don't know which packages were changed, always precompile the
     // executables.
     if (changed == null) return executables;
 
     // If any of the package's dependencies changed, recompile the executables.
@@ skipping 153 matching lines @@
       }
     }).then((graph) {
       _packageGraph = graph;
       return graph;
     });
   }
 
   /// Saves a list of concrete package versions to the `pubspec.lock` file.
   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));
   }
 
   /// Creates a self-referential symlink in the `packages` directory that allows
   /// a package to import its own files using `package:`.
   void _linkSelf() {
     var linkPath = path.join(packagesDir, root.name);
     // Create the symlink if it doesn't exist.
     if (entryExists(linkPath)) return;
     ensureDir(packagesDir);
     createPackageSymlink(root.name, root.dir, linkPath,
         isSelfLink: true, relative: true);
   }
 
   /// If [packageSymlinks] is true, add "packages" directories to the whitelist
   /// of directories that may contain Dart entrypoints.
   ///
   /// Otherwise, delete any "packages" directories in the whitelist of
   /// directories that may contain Dart entrypoints.
   void _linkOrDeleteSecondaryPackageDirs() {
     // Only the main "bin" directory gets a "packages" directory, not its
     // subdirectories.
-    var binDir = path.join(root.dir, 'bin');
+    var binDir = root.path('bin');
     if (dirExists(binDir)) _linkOrDeleteSecondaryPackageDir(binDir);
 
     // The others get "packages" directories in subdirectories too.
     for (var dir in ['benchmark', 'example', 'test', 'tool', 'web']) {
-      _linkOrDeleteSecondaryPackageDirsRecursively(path.join(root.dir, dir));
+      _linkOrDeleteSecondaryPackageDirsRecursively(root.path(dir));
     }
  }
 
   /// If [packageSymlinks] is true, creates a symlink to the "packages"
   /// directory in [dir] and all its subdirectories.
   ///
   /// Otherwise, deletes any "packages" directories in [dir] and all its
   /// subdirectories.
   void _linkOrDeleteSecondaryPackageDirsRecursively(String dir) {
     if (!dirExists(dir)) return;
@@ skipping 19 matching lines @@
   /// If [packageSymlinks] is true, creates a symlink to the "packages"
   /// directory in [dir].
   ///
   /// Otherwise, deletes a "packages" directories in [dir] if one exists.
   void _linkOrDeleteSecondaryPackageDir(String dir) {
     var symlink = path.join(dir, 'packages');
     if (entryExists(symlink)) deleteEntry(symlink);
     if (_packageSymlinks) createSymlink(packagesDir, symlink, relative: true);
   }
 }