Use backtracking when solving dependency constraints.

utils/pub/log.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.
 
 /// Message logging.
 library log;
 
 import 'dart:async';
 
 import 'io.dart';
@@ skipping 18 matching lines @@
   /// though possibly in a degraded fashion.
   static const WARNING = const Level._("WARN");
 
   /// A message intended specifically to be shown to the user.
   static const MESSAGE = const Level._("MSG ");
 
   /// Some interaction with the external world occurred, such as a network
   /// operation, process spawning, or file IO.
   static const IO = const Level._("IO  ");
 
+  /// Incremental output during pub's version constraint solver.
+  static const SOLVER = const Level._("SLVR");
+
   /// Fine-grained and verbose additional information. Can be used to provide
   /// program state context for other logs (such as what pub was doing when an
   /// IO operation occurred) or just more detail for an operation.
   static const FINE = const Level._("FINE");
 
   const Level._(this.name);
   final String name;
 
   String toString() => name;
   int get hashCode => name.hashCode;
 }
 
 /// A single log entry.
 class Entry {
   final Level level;
   final List<String> lines;
 
   Entry(this.level, this.lines);
 }
 
+/// Returns `true` if [level] is being recorded in some way.
+bool isEnabled(Level level) => _loggers != null && _loggers[level] != null;
+
 /// Logs [message] at [Level.ERROR].
 void error(message) => write(Level.ERROR, message);
 
 /// Logs [message] at [Level.WARNING].
 void warning(message) => write(Level.WARNING, message);
 
 /// Logs [message] at [Level.MESSAGE].
 void message(message) => write(Level.MESSAGE, message);
 
 /// Logs [message] at [Level.IO].
 void io(message) => write(Level.IO, message);
 
+/// Logs [message] at [Level.SOLVER].
+void solver(message) => write(Level.SOLVER, message);
+
 /// Logs [message] at [Level.FINE].
 void fine(message) => write(Level.FINE, message);
 
 /// Logs [message] at [level].
 void write(Level level, message) {
   if (_loggers.isEmpty) showNormal();
 
   var lines = splitLines(message.toString());
   var entry = new Entry(level, lines);
 
@@ skipping 80 matching lines @@
   }
   stderrSink.add('---- End log transcript ----\n'.codeUnits);
 }
 
 /// Sets the verbosity to "normal", which shows errors, warnings, and messages.
 void showNormal() {
   _loggers[Level.ERROR]   = _logToStderr;
   _loggers[Level.WARNING] = _logToStderr;
   _loggers[Level.MESSAGE] = _logToStdout;
   _loggers[Level.IO]      = null;
+  _loggers[Level.SOLVER]  = null;
   _loggers[Level.FINE]    = null;
 }
 
 /// Sets the verbosity to "io", which shows errors, warnings, messages, and IO
 /// event logs.
 void showIO() {
   _loggers[Level.ERROR]   = _logToStderrWithLabel;
   _loggers[Level.WARNING] = _logToStderrWithLabel;
   _loggers[Level.MESSAGE] = _logToStdoutWithLabel;
   _loggers[Level.IO]      = _logToStderrWithLabel;
+  _loggers[Level.SOLVER]  = null;
   _loggers[Level.FINE]    = null;
 }
 
+/// Sets the verbosity to "solver", which shows errors, warnings, messages, and
+/// solver logs.
+void showSolver() {
+  _loggers[Level.ERROR]   = _logToStderr;
+  _loggers[Level.WARNING] = _logToStderr;
+  _loggers[Level.MESSAGE] = _logToStdout;
+  _loggers[Level.IO]      = null;
+  _loggers[Level.SOLVER]  = _logToStdout;
+  _loggers[Level.FINE]    = null;
+}
+
 /// Sets the verbosity to "all", which logs ALL the things.
 void showAll() {
   _loggers[Level.ERROR]   = _logToStderrWithLabel;
   _loggers[Level.WARNING] = _logToStderrWithLabel;
   _loggers[Level.MESSAGE] = _logToStdoutWithLabel;
   _loggers[Level.IO]      = _logToStderrWithLabel;
+  _loggers[Level.SOLVER]  = _logToStderrWithLabel;
   _loggers[Level.FINE]    = _logToStderrWithLabel;
 }
 
 /// Log function that prints the message to stdout.
 void _logToStdout(Entry entry) {
   _logToStream(stdoutSink, entry, showLabel: false);
 }
 
 /// Log function that prints the message to stdout with the level name.
 void _logToStdoutWithLabel(Entry entry) {
@@ skipping 21 matching lines @@
         sink.add('    | '.codeUnits);
       }
     }
 
     sink.add(line.codeUnits);
     sink.add('\n'.codeUnits);
 
     firstLine = false;
   }
 }