Clean up benchmark code.

benchmark/after.dart.txt

-// Copyright (c) 2014, 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 dart_style.benchmark.benchmark;
-
-import 'dart:io';
-
-import 'package:dart_style/dart_style.dart';
-
-const NUM_TRIALS = 100;
-const FORMATS_PER_TRIAL = 30;
-
-void main(List<String> args) {
-  var best = 99999999.0;
-
-  // Run the benchmark several times. This ensures the VM is warmed up and lets
-  // us see how much variance there is.
-  for (var i = 0; i <= NUM_TRIALS; i++) {
-    var start = new DateTime.now();
-
-    // For a single benchmark, format the source multiple times.
-    for (var j = 0; j < FORMATS_PER_TRIAL; j++) {
-      formatSource();
-    }
-
-    var elapsed = new DateTime.now()
-        .difference(start).inMilliseconds / FORMATS_PER_TRIAL;
-
-    // Keep track of the best run so far.
-    if (elapsed >= best) continue;
-    best = elapsed;
-
-    // Don't print the first run. It's always terrible since the VM hasn't
-    // warmed up yet.
-    if (i == 0) continue;
-    printResult("Run ${padLeft('#$i', 3)}", elapsed);
-  }
-
-  printResult("Best   ", best);
-}
-
-void printResult(String label, double time) {
-  print("$label: ${padLeft(time.toStringAsFixed(2), 4)}ms "
-      "${'=' * ((time * 5).toInt())}");
-}
-
-String padLeft(input, int length) {
-  var result = input.toString();
-  if (result.length < length) {
-    result = " " * (length - result.length) + result;
-  }
-
-  return result;
-}
-
-void formatSource() {
-  var formatter = new DartFormatter();
-  var result = formatter.format(source);
-
-  // Sanity check to make sure the output is what we expect and to make sure
-  // the VM doesn't optimize "dead" code away.
-  if (result.length != 29791) {
-    print("Incorrect output (length ${result.length}):\n$result");
-    exit(1);
-  }
-}
-
-const source = r"""
 // 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.solver.backtracking_solver;
 
 import 'dart:async';
 import 'dart:collection' show Queue;
 
 import '../barback.dart' as barback;
@@ skipping 72 matching lines @@
         cache = new PubspecCache(type, sources) {
     for (var package in useLatest) {
       _forceLatest.add(package);
     }
 
     for (var override in root.dependencyOverrides) {
       _overrides[override.name] = override;
     }
 
     // A deeply nested statement that's hard on the formatter.
-    isTwoWay = !isEvent && bindings.isWhole && (isCustomTag ||
-        tag == 'input' && (name == 'value' || name =='checked') ||
-        tag == 'select' && (name == 'selectedindex' || name == 'value') ||
-        tag == 'textarea' && name == 'value');
+    isTwoWay = !isEvent &&
+        bindings.isWhole &&
+        (isCustomTag ||
+            tag == 'input' && (name == 'value' || name == 'checked') ||
+            tag == 'select' && (name == 'selectedindex' || name == 'value') ||
+            tag == 'textarea' && name == 'value');
   }
 
   /// Run the solver.
   ///
   /// Completes with a list of specific package versions if successful or an
   /// error if it failed to find a solution.
   Future<SolveResult> solve() {
     var stopwatch = new Stopwatch();
 
     _logParameters();
 
     // Sort the overrides by package name to make sure they're deterministic.
     var overrides = _overrides.values.toList();
     overrides.sort((a, b) => a.name.compareTo(b.name));
 
     return newFuture(() {
       stopwatch.start();
 
       // Pre-cache the root package's known pubspec.
       cache.cache(new PackageId.root(root), root.pubspec);
 
       _validateSdkConstraint(root.pubspec);
       return _traverseSolution();
     }).then((packages) {
-      var pubspecs = new Map.fromIterable(
-          packages,
-          key: (id) => id.name,
-          value: (id) => cache.getCachedPubspec(id));
+      var pubspecs = new Map.fromIterable(packages,
+          key: (id) => id.name, value: (id) => cache.getCachedPubspec(id));
 
-      return new SolveResult.success(
-          sources,
-          root,
-          lockFile,
-          packages,
-          overrides,
-          pubspecs,
-          _getAvailableVersions(packages),
+      return new SolveResult.success(sources, root, lockFile, packages,
+          overrides, pubspecs, _getAvailableVersions(packages),
           attemptedSolutions);
     }).catchError((error) {
       if (error is! SolveFailure) throw error;
 
       // Wrap a failure in a result so we can attach some other data.
       return new SolveResult.failure(
-          sources,
-          root,
-          lockFile,
-          overrides,
-          error,
-          attemptedSolutions);
+          sources, root, lockFile, overrides, error, attemptedSolutions);
     }).whenComplete(() {
       // Gather some solving metrics.
       var buffer = new StringBuffer();
       buffer.writeln('${runtimeType} took ${stopwatch.elapsed} seconds.');
       buffer.writeln(cache.describeResults());
       log.solver(buffer);
     });
   }
 
   /// Generates a map containing all of the known available versions for each
@@ skipping 346 matching lines @@
         if (override != null) return override;
 
         // Not overridden.
         return dep;
       }).toSet();
 
       // Make sure the package doesn't have any bad dependencies.
       for (var dep in deps) {
         if (!dep.isRoot && _solver.sources[dep.source] is UnknownSource) {
           throw new UnknownSourceException(
-              id.name,
-              [new Dependency(id.name, id.version, dep)]);
+              id.name, [new Dependency(id.name, id.version, dep)]);
         }
       }
 
       return _traverseDeps(id, new DependencyQueue(_solver, deps));
     }).catchError((error) {
       if (error is! PackageNotFoundException) throw error;
 
       // We can only get here if the lockfile refers to a specific package
       // version that doesn't exist (probably because it was yanked).
       throw new NoVersionException(id.name, null, id.version, []);
     });
   }
 
   /// Traverses the references that [depender] depends on, stored in [deps].
   ///
   /// 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) {
+  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) {
         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 new Future.sync(() {
       _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');
+        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;
@@ skipping 12 matching lines @@
   /// 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,
-            _getDependencies(dep.name));
+            dep.name, null, constraint, _getDependencies(dep.name));
       }
 
       // If we're doing an upgrade on this package, only allow the latest
       // version.
       if (_solver._forceLatest.contains(dep.name)) allowed = [allowed.first];
 
       // Remove the locked version, if any, since that was already handled.
       var locked = _getValidLocked(dep.name);
       if (locked != null) {
         allowed = allowed.where((dep) => dep.version != locked.version);
       }
 
       return allowed;
     }).catchError((error, stackTrace) {
       if (error is PackageNotFoundException) {
         // Show the user why the package was being requested.
         throw new DependencyNotFoundException(
-            dep.name,
-            error,
-            _getDependencies(dep.name));
+            dep.name, error, _getDependencies(dep.name));
       }
 
       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(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, 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}');
+      _solver.logSolve('description mismatch on ${dep.name}: '
+          '${required.dep.description} != ${dep.description}');
       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));
+          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');
+      _solver
+          .logSolve('add implicit $constraint pub dependency on ' '$depName');
 
       var override = _solver._overrides[depName];
 
       // Use the same source and description as the dependency override if one
       // exists. This is mainly used by the pkgbuild tests, which use dependency
       // overrides for all repo packages.
-      var pubDep = override == null ?
-          new PackageDep(depName, "hosted", constraint, depName) :
-          override.withConstraint(constraint);
+      var pubDep = override == null
+          ? new PackageDep(depName, "hosted", constraint, depName)
+          : override.withConstraint(constraint);
       return _registerDependency(
           new Dependency("pub itself", Version.none, 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
   /// on a package must agree on source and description, except for references
   /// to the root package. This will return a reference to that "canonical"
   /// source and description, or `null` if there is no required reference yet.
   ///
   /// This is required because you may have a circular dependency back onto the
   /// root package. That second dependency won't be a root dependency and it's
   /// *that* one that other dependencies need to agree on. In other words, you
   /// can have a bunch of dependencies back onto the root package as long as
   /// they all agree with each other.
   Dependency _getRequired(String name) {
-    return _getDependencies(
-        name).firstWhere((dep) => !dep.dep.isRoot, orElse: () => null);
+    return _getDependencies(name).firstWhere((dep) => !dep.dep.isRoot,
+        orElse: () => null);
   }
 
   /// Gets the combined [VersionConstraint] currently being placed on package
   /// [name].
   VersionConstraint _getConstraint(String name) {
-    var constraint = _getDependencies(
-        name).map(
-            (dep) =>
-                dep.dep.constraint).fold(VersionConstraint.any, (a, b) => a.intersect(b));
+    var constraint = _getDependencies(name)
+        .map((dep) => dep.dep.constraint)
+        .fold(VersionConstraint.any, (a, b) => a.intersect(b));
 
     return constraint;
   }
 
   /// Gets the package [name] that's currently contained in the lockfile if it
   /// meets [constraint] and has the same source and description as other
   /// references to that package.
   ///
   /// Returns `null` otherwise.
   PackageId _getValidLocked(String name) {
     var package = _solver.getLocked(name);
     if (package == null) return null;
 
     var constraint = _getConstraint(name);
     if (!constraint.allows(package.version)) {
       _solver.logSolve('$package is locked but does not match $constraint');
       return null;
     } else {
       _solver.logSolve('$package is locked');
     }
 
     var required = _getRequired(name);
     if (required != null) {
       if (package.source != required.dep.source) return null;
 
       var source = _solver.sources[package.source];
       if (!source.descriptionsEqual(
-          package.description,
-          required.dep.description)) return null;
+          package.description, required.dep.description)) return null;
     }
 
     return package;
   }
 
   /// Run the dart2js compiler.
   Future _doCompilation(Transform transform) {
     var provider = new _BarbackCompilerProvider(_environment, transform,
         generateSourceMaps: _generateSourceMaps);
 
     // Create a "path" to the entrypoint script. The entrypoint may not actually
     // be on disk, but this gives dart2js a root to resolve relative paths
     // against.
     var id = transform.primaryInput.id;
 
     var entrypoint = _environment.graph.packages[id.package].path(id.path);
 
     // Should have more sophisticated error-handling here. Need
     // to report compile errors to the user in an easily visible way. Need to
     // make sure paths in errors are mapped to the original source path so they
     // can understand them.
-    return dart.compile(
-        entrypoint, provider,
+    return dart.compile(entrypoint, provider,
         commandLineOptions: _configCommandLineOptions,
         csp: _configBool('csp'),
         checked: _configBool('checked'),
-        minify: _configBool(
-            'minify', defaultsTo: _settings.mode == BarbackMode.RELEASE),
+        minify: _configBool('minify',
+            defaultsTo: _settings.mode == BarbackMode.RELEASE),
         verbose: _configBool('verbose'),
         environment: _configEnvironment,
         packageRoot: _environment.rootPackage.path("packages"),
         analyzeAll: _configBool('analyzeAll'),
         suppressWarnings: _configBool('suppressWarnings'),
         suppressHints: _configBool('suppressHints'),
-        suppressPackageWarnings: _configBool(
-            'suppressPackageWarnings', defaultsTo: true),
+        suppressPackageWarnings: _configBool('suppressPackageWarnings',
+            defaultsTo: true),
         terse: _configBool('terse'),
         includeSourceMapUrls: _settings.mode != BarbackMode.RELEASE);
   }
 }
 
 /// Ensures that if [pubspec] has an SDK constraint, then it is compatible
 /// with the current SDK.
 ///
 /// Throws a [SolveFailure] if not.
 void _validateSdkConstraint(Pubspec pubspec) {
   if (pubspec.environment.sdkVersion.allows(sdk.version)) return;
 
-  throw new BadSdkVersionException(
-      pubspec.name,
+  throw new BadSdkVersionException(pubspec.name,
       'Package ${pubspec.name} requires SDK version '
-          '${pubspec.environment.sdkVersion} but the current SDK is ' '${sdk.version}.');
+      '${pubspec.environment.sdkVersion} but the current SDK is ' '${sdk.version}.');
 }
-""";