Add implicit constraints from pub onto stack_trace and source_maps.

sdk/lib/_internal/pub/lib/src/solver/backtracking_solver.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.
 
 /// A back-tracking depth-first solver.
 ///
 /// Attempts to find the best solution for a root package's transitive
 /// dependency graph, where a "solution" is a set of concrete package versions.
 /// A valid solution will select concrete versions for every package reached
 /// from the root package's dependency graph, and each of those packages will
@@ skipping 516 matching lines @@
   /// Desctructively modifies [deps]. Completes to a list of packages if the
   /// traversal is complete. Completes it to an error if a failure occurred.
   /// Otherwise, recurses.
   Future<List<PackageId>> _traverseDeps(PackageId depender,
       DependencyQueue deps) {
     // Move onto the next package if we've traversed all of these references.
     if (deps.isEmpty) return _traversePackage();
 
     return resetStack(() {
       return deps.advance().then((dep) {
-        _validateDependency(dep, depender);
-
-        // Add the dependency.
-        var dependencies = _getDependencies(dep.name);
-        dependencies.add(new Dependency(depender.name, depender.version, dep));
-
-        // If the package is barback, pub has an implicit version constraint on
-        // it since pub itself uses barback too. Note that we don't check for
-        // the hosted source here because we still want to do this even when
-        // people on the Dart team are on the bleeding edge and have a path
-        // dependency on the tip version of barback in the Dart repo.
-        //
-        // The length check here is to ensure we only add the barback
-        // dependency once.
-        if (dep.name == "barback" && dependencies.length == 1) {
-          _solver.logSolve('add implicit ${barback.supportedVersions} pub '
-              'dependency on barback');
-
-          // Use the same source and description as the explicit dependency.
-          // That way, this doesn't fail with a source/desc conflict if users
-          // (like Dart team members) use things like a path dependency to
-          // find barback.
-          var barbackDep = new PackageDep(dep.name, dep.source,
-              barback.supportedVersions, dep.description);
-          dependencies.add(new Dependency("pub itself", null, barbackDep));
-        }
-
-        var constraint = _getConstraint(dep.name);
-
-        // See if it's possible for a package to match that constraint.
-        if (constraint.isEmpty) {
-          var constraints = _getDependencies(dep.name)
-              .map((dep) => "  ${dep.dep.constraint} from ${dep.depender}")
-              .join('\n');
-          _solver.logSolve(
-              'disjoint constraints on ${dep.name}:\n$constraints');
-          throw new DisjointConstraintException(dep.name, dependencies);
-        }
-
-        var selected = _validateSelected(dep, constraint);
-        if (selected != null) {
-          // The selected package version is good, so enqueue it to traverse
-          // into it.
-          _packages.add(selected);
-          return _traverseDeps(depender, deps);
-        }
-
-        // We haven't selected a version. Try all of the versions that match
-        // the constraints we currently have for this package.
-        var locked = _getValidLocked(dep.name);
-
-        return VersionQueue.create(locked,
-            () => _getAllowedVersions(dep)).then((versions) {
-          _packages.add(_solver.select(versions));
+        var dependency = new Dependency(depender.name, depender.version, dep);
+        return _registerDependency(dependency).then((_) {
+          if (dep.name == "barback") return _addImplicitDependencies();
         });
       }).then((_) => _traverseDeps(depender, deps));
     });
   }
 
+  /// Register [dependency]'s constraints on the package it depends on and
+  /// enqueues the package for processing if necessary.
+  Future _registerDependency(Dependency dependency) {
+    return syncFuture(() {
+      _validateDependency(dependency);
+
+      var dep = dependency.dep;
+      var dependencies = _getDependencies(dep.name);
+      dependencies.add(dependency);
+
+      var constraint = _getConstraint(dep.name);
+
+      // See if it's possible for a package to match that constraint.
+      if (constraint.isEmpty) {
+        var constraints = dependencies
+            .map((dep) => "  ${dep.dep.constraint} from ${dep.depender}")
+            .join('\n');
+        _solver.logSolve(
+            'disjoint constraints on ${dep.name}:\n$constraints');
+        throw new DisjointConstraintException(dep.name, dependencies);
+      }
+
+      var selected = _validateSelected(dep, constraint);
+      if (selected != null) {
+        // The selected package version is good, so enqueue it to traverse
+        // into it.
+        _packages.add(selected);
+        return null;
+      }
+
+      // We haven't selected a version. Try all of the versions that match
+      // the constraints we currently have for this package.
+      var locked = _getValidLocked(dep.name);
+
+      return VersionQueue.create(locked, () {
+        return _getAllowedVersions(dep);
+      }).then((versions) => _packages.add(_solver.select(versions)));
+    });
+  }
+
   /// Gets all versions of [dep] that match the current constraints placed on
   /// it.
   Future<Iterable<PackageId>> _getAllowedVersions(PackageDep dep) {
     var constraint = _getConstraint(dep.name);
     return _solver.cache.getVersions(dep.toRef()).then((versions) {
       var allowed = versions.where((id) => constraint.allows(id.version));
 
       if (allowed.isEmpty) {
         _solver.logSolve('no versions for ${dep.name} match $constraint');
         throw new NoVersionException(dep.name, null, constraint,
@@ skipping 20 matching lines @@
 
       throw error;
     });
   }
 
   /// Ensures that dependency [dep] from [depender] is consistent with the
   /// other dependencies on the same package.
   ///
   /// Throws a [SolveFailure] exception if not. Only validates sources and
   /// descriptions, not the version.
-  void _validateDependency(PackageDep dep, PackageId depender) {
+  void _validateDependency(Dependency dependency) {
+    var dep = dependency.dep;
+
     // Make sure the dependencies agree on source and description.
     var required = _getRequired(dep.name);
     if (required == null) return;
 
     // Make sure all of the existing sources match the new reference.
     if (required.dep.source != dep.source) {
       _solver.logSolve('source mismatch on ${dep.name}: ${required.dep.source} '
                        '!= ${dep.source}');
-      throw new SourceMismatchException(dep.name,
-          [required, new Dependency(depender.name, depender.version, dep)]);
+      throw new SourceMismatchException(dep.name, [required, dependency]);
     }
 
     // Make sure all of the existing descriptions match the new reference.
     var source = _solver.sources[dep.source];
     if (!source.descriptionsEqual(dep.description, required.dep.description)) {
       _solver.logSolve('description mismatch on ${dep.name}: '
                        '${required.dep.description} != ${dep.description}');
-      throw new DescriptionMismatchException(dep.name,
-          [required, new Dependency(depender.name, depender.version, dep)]);
+      throw new DescriptionMismatchException(dep.name, [required, dependency]);
     }
   }
 
   /// Validates the currently selected package against the new dependency that
   /// [dep] and [constraint] place on it.
   ///
   /// Returns `null` if there is no currently selected package, throws a
   /// [SolveFailure] if the new reference it not does not allow the previously
   /// selected version, or returns the selected package if successful.
   PackageId _validateSelected(PackageDep dep, VersionConstraint constraint) {
     var selected = _solver.getSelected(dep.name);
     if (selected == null) return null;
 
     // Make sure it meets the constraint.
     if (!dep.constraint.allows(selected.version)) {
       _solver.logSolve('selection $selected does not match $constraint');
       throw new NoVersionException(dep.name, selected.version, constraint,
                                    _getDependencies(dep.name));
     }
 
     return selected;
   }
 
+  /// Register pub's implicit dependencies.
+  ///
+  /// Pub has an implicit version constraint on barback and various other
+  /// packages used in barback's plugin isolate.
+  Future _addImplicitDependencies() {
+    /// Ensure we only add the barback dependency once.
+    if (_getDependencies("barback").length != 1) return new Future.value();
+
+    return Future.wait(barback.pubConstraints.keys.map((depName) {
+      var constraint = barback.pubConstraints[depName];
+      _solver.logSolve('add implicit $constraint pub dependency on '
+          '$depName');
+
+      var override = _solver._overrides[depName];

[Bob Nystrom, 2014/06/26 16:37:33]

Nice. I didn't remember that the solver already has to track the overrides.

+
+      // Use the same source and description as the dependency override if
+      // one exists.

[Bob Nystrom, 2014/06/26 16:37:33]

Document that this is mainly for the bots.

[nweiz, 2014/06/26 20:03:48]

Done.

+      var pubDep = override == null ?
+          new PackageDep(depName, "hosted", constraint, depName) :
+          override.withConstraint(constraint);
+      return _registerDependency(new Dependency("pub itself", null, pubDep));
+    }));
+  }
+
   /// Gets the list of dependencies for package [name].
   ///
   /// Creates an empty list if needed.
   List<Dependency> _getDependencies(String name) {
     return _dependencies.putIfAbsent(name, () => <Dependency>[]);
   }
 
   /// Gets a "required" reference to the package [name].
   ///
   /// This is the first non-root dependency on that package. All dependencies
@@ skipping 56 matching lines @@
 ///
 /// Throws a [SolveFailure] if not.
 void _validateSdkConstraint(Pubspec pubspec) {
   if (pubspec.environment.sdkVersion.allows(sdk.version)) return;
 
   throw new BadSdkVersionException(pubspec.name,
       'Package ${pubspec.name} requires SDK version '
       '${pubspec.environment.sdkVersion} but the current SDK is '
       '${sdk.version}.');
 }