Migrate pub away from throwing strings.

utils/pub/source.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 source;
 
 import 'dart:async';
 
 import 'package:pathos/path.dart' as path;
 
@@ skipping 62 matching lines @@
   }
 
   /// Loads the (possibly remote) pubspec for the package version identified by
   /// [id]. This may be called for packages that have not yet been installed
   /// during the version resolution process.
   ///
   /// For cached sources, by default this uses [installToSystemCache] to get the
   /// pubspec. There is no default implementation for non-cached sources; they
   /// must implement it manually.
   Future<Pubspec> describe(PackageId id) {
-    if (!shouldCache) throw "Source $name must implement describe(id).";
+    if (!shouldCache) {
+      throw new UnimplementedError("Source $name must implement describe(id).");
+    }
     return installToSystemCache(id).then((package) => package.pubspec);
   }
 
   /// Installs the package identified by [id] to [path]. Returns a [Future] that
   /// completes when the installation was finished. The [Future] should resolve
   /// to true if the package was found in the source and false if it wasn't. For
   /// all other error conditions, it should complete with an exception.
   ///
   /// [path] is guaranteed not to exist, and its parent directory is guaranteed
   /// to exist.
   ///
   /// Note that [path] may be deleted. If re-installing a package that has
   /// already been installed would be costly or impossible,
   /// [installToSystemCache] should be implemented instead of [install].
   ///
   /// This doesn't need to be implemented if [installToSystemCache] is
   /// implemented.
   Future<bool> install(PackageId id, String path) {
-    throw "Either install or installToSystemCache must be implemented for "
-        "source $name.";
+    throw new UnimplementedError("Either install or installToSystemCache must "
+        "be implemented for source $name.");
   }
 
   /// Installs the package identified by [id] to the system cache. This is only
   /// called for sources with [shouldCache] set to true.
   ///
   /// By default, this uses [systemCacheDirectory] and [install].
   Future<Package> installToSystemCache(PackageId id) {
     var packageDir;
     return systemCacheDirectory(id).then((p) {
       packageDir = p;
 
       // See if it's already cached.
       if (dirExists(packageDir)) {
         if (!_isCachedPackageCorrupted(packageDir)) return true;
         // Busted, so wipe out the package and reinstall.
         deleteEntry(packageDir);
       }
 
       ensureDir(path.dirname(packageDir));
       return install(id, packageDir);
     }).then((found) {
-      if (!found) throw 'Package $id not found.';
+      if (!found) fail('Package $id not found.');
       return new Package.load(id.name, packageDir, systemCache.sources);
     });
   }
 
   /// Since pub generates symlinks that point into the system cache (in
   /// particular, targeting the "lib" directories of cached packages), it's
   /// possible to accidentally break cached packages if something traverses
   /// that symlink.
   ///
   /// This tries to determine if the cached package at [packageDir] has been
@@ skipping 67 matching lines @@
   /// The returned [PackageId] may have a description field that's invalid
   /// according to [parseDescription], although it must still be serializable
   /// to JSON and YAML. It must also be equal to [id] according to
   /// [descriptionsEqual].
   ///
   /// By default, this just returns [id].
   Future<PackageId> resolveId(PackageId id) => new Future.value(id);
   
   /// Returns the [Package]s that have been installed in the system cache.
   List<Package> getCachedPackages() {
-    if (shouldCache) throw "Source $name must implement this.";
+    if (shouldCache) {
+      throw new UnimplementedError("Source $name must implement this.");
+    }
   }
 
   /// Returns the source's name.
   String toString() => name;
 }