Get rid of RootSource.

utils/pub/package.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 package;
 
 import 'dart:async';
 import 'io.dart';
 import 'pubspec.dart';
 import 'source.dart';
@@ skipping 64 matching lines @@
 /// information to correctly install the package.
 ///
 /// Note that it's possible for multiple distinct package IDs to point to
 /// different directories that happen to contain identical packages. For
 /// example, the same package may be available from multiple sources. As far as
 /// Pub is concerned, those packages are different.
 class PackageId implements Comparable {
   /// The name of the package being identified.
   final String name;
 
-  /// The [Source] used to look up this package given its [description].
+  /// The [Source] used to look up this package given its [description]. If
+  /// this is a root package ID, this will be `null`.

[Jennifer Messerly, 2013/01/24 23:24:37]

fwiw, I think Kathy suggested not using code font for `null`, as a general
desire to avoid too much code font. Up to you though. I might be misremembering
this.

[Bob Nystrom, 2013/01/25 18:22:50]

I think you're remembering right, though I personally do prefer using code font
for literals. I like a little visual style variation and I think code font can
be important to disambiguate use-mention in cases where a literal is a valid
word like "this".

   final Source source;
 
   /// The package's version.
   final Version version;
 
   /// The metadata used by the package's [source] to identify and locate it. It
   /// contains whatever [Source]-specific data it needs to be able to install
   /// the package. For example, the description of a git sourced package might
   /// by the URL "git://github.com/dart/uilib.git".
   final description;
 
   PackageId(this.name, this.source, this.version, this.description);
 
+  /// Whether this ID identifies the root package.
+  bool get isRoot => source == null;
+
   int get hashCode => name.hashCode ^
-                      source.name.hashCode ^
+                      (source != null ? source.name.hashCode : 0) ^

[Jennifer Messerly, 2013/01/24 23:24:37]

Another idea here: you could make Source.hashCode return its name.hashCode:

    class Source { ...; int get hashCode => name.hashCode; }

Then change this one to be:

    int get hashCode => name.hashCode ^ source.hashCode ^ version.hashCode


That might be cleaner? Basically, exploit the fact that "null.hashCode" works in
Dart :)

[Bob Nystrom, 2013/01/25 18:22:50]

Great idea! Done.

                       version.hashCode;
 
   bool operator ==(other) {
     if (other is! PackageId) return false;
     // TODO(rnystrom): We're assuming here the name/version/source tuple is
     // enough to uniquely identify the package and that we don't need to delve
     // into the description.
     return other.name == name &&
-           other.source.name == source.name &&
+           other.source == source &&

[Jennifer Messerly, 2013/01/24 23:24:37]

just checking, source already implements reasonable equality operator? Or do we
know that identity semantics work for it?

[Bob Nystrom, 2013/01/25 18:22:50]

I'm relying on identity here. Sources are effectively singletons and weird
things would happen if you had more than one source of the same type.

            other.version == version;
   }
 
   String toString() {
+    if (isRoot) return "$name $version (root)";
     if (source.isDefault) return "$name $version";
     return "$name $version from $source";
   }
 
   int compareTo(Comparable other) {
     if (other is! PackageId) throw new ArgumentError(other);
 
     var sourceComp = source.name.compareTo(other.source.name);
     if (sourceComp != 0) return sourceComp;
 
@@ skipping 10 matching lines @@
   Future<PackageId> get resolved => source.resolveId(this);
 }
 
 /// A reference to a package. Unlike a [PackageId], a PackageRef may not
 /// unambiguously refer to a single package. It may describe a range of allowed
 /// packages.
 class PackageRef {
   /// The name of the package being identified.
   final String name;
 
-  /// The [Source] used to look up the package.
+  /// The [Source] used to look up the package. If this refers to a root
+  /// package, this will be `null`.
   final Source source;
 
   /// The allowed package versions.
   final VersionConstraint constraint;
 
   /// The metadata used to identify the package being referenced. The
   /// interpretation of this will vary based on the [source].
   final description;
 
   PackageRef(this.name, this.source, this.constraint, this.description);
 
-  String toString() => "$name $constraint from $source ($description)";
+  /// Creates a reference to the given root package.
+  PackageRef.root(Package package)
+      : name = package.name,
+        source = null,
+        constraint = package.version,
+        description = package.name;
+
+  /// Whether this refers to the root package.
+  bool get isRoot => source == null;
+
+  String toString() {
+    if (isRoot) return "$name $constraint (root)";
+    return "$name $constraint from $source ($description)";
+  }
 
   /// Returns a [PackageId] generated from this [PackageRef] with the given
   /// concrete version.
   PackageId atVersion(Version version) =>
     new PackageId(name, source, version, description);
 }
 
 class PubspecNotFoundException implements Exception {
   final String name;
 
@@ skipping 13 matching lines @@
 
 class PubspecNameMismatchException implements Exception {
   final String expectedName;
   final String actualName;
 
   PubspecNameMismatchException(this.expectedName, this.actualName);
 
   String toString() => 'The name you specified for your dependency, '
     '"$expectedName", doesn\'t match the name "$actualName" in its pubspec.';
 }