Run dartfmt on kernel package

pkg/kernel/testcases/input/DeltaBlue.dart

 // Copyright 2011 Google Inc. All Rights Reserved.
 // Copyright 1996 John Maloney and Mario Wolczko
 //
 // This file is part of GNU Smalltalk.
 //
 // GNU Smalltalk is free software; you can redistribute it and/or modify it
 // under the terms of the GNU General Public License as published by the Free
 // Software Foundation; either version 2, or (at your option) any later version.
 //
 // GNU Smalltalk is distributed in the hope that it will be useful, but WITHOUT
@@ skipping 28 matching lines @@
 }
 
 /// Benchmark class required to report results.
 class DeltaBlue {
   void run() {
     chainTest(100);
     projectionTest(100);
   }
 }
 
-
 /**
  * Strengths are used to measure the relative importance of constraints.
  * New strengths may be inserted in the strength hierarchy without
  * disrupting current constraints.  Strengths cannot be created outside
  * this class, so == can be used for value comparison.
  */
 class Strength {
-
   final int value;
   final String name;
 
   const Strength(this.value, this.name);
 
-  Strength nextWeaker() =>
-     const <Strength>[STRONG_PREFERRED, PREFERRED, STRONG_DEFAULT, NORMAL,
-                      WEAK_DEFAULT, WEAKEST][value];
+  Strength nextWeaker() => const <Strength>[
+        STRONG_PREFERRED,
+        PREFERRED,
+        STRONG_DEFAULT,
+        NORMAL,
+        WEAK_DEFAULT,
+        WEAKEST
+      ][value];
 
   static bool stronger(Strength s1, Strength s2) {
     return s1.value < s2.value;
   }
 
   static bool weaker(Strength s1, Strength s2) {
     return s1.value > s2.value;
   }
 
   static Strength weakest(Strength s1, Strength s2) {
     return weaker(s1, s2) ? s1 : s2;
   }
 
   static Strength strongest(Strength s1, Strength s2) {
     return stronger(s1, s2) ? s1 : s2;
   }
 }
 
-
 // Compile time computed constants.
-const REQUIRED         = const Strength(0, "required");
+const REQUIRED = const Strength(0, "required");
 const STRONG_PREFERRED = const Strength(1, "strongPreferred");
-const PREFERRED        = const Strength(2, "preferred");
-const STRONG_DEFAULT   = const Strength(3, "strongDefault");
-const NORMAL           = const Strength(4, "normal");
-const WEAK_DEFAULT     = const Strength(5, "weakDefault");
-const WEAKEST          = const Strength(6, "weakest");
-
+const PREFERRED = const Strength(2, "preferred");
+const STRONG_DEFAULT = const Strength(3, "strongDefault");
+const NORMAL = const Strength(4, "normal");
+const WEAK_DEFAULT = const Strength(5, "weakDefault");
+const WEAKEST = const Strength(6, "weakest");
 
 abstract class Constraint {
-
   final Strength strength;
 
   const Constraint(this.strength);
 
   bool isSatisfied();
   void markUnsatisfied();
   void addToGraph();
   void removeFromGraph();
   void chooseMethod(int mark);
   void markInputs(int mark);
@@ skipping 43 matching lines @@
    * is one that depends on external state, such as the mouse, the
    * keybord, a clock, or some arbitraty piece of imperative code.
    */
   bool isInput() => false;
 }
 
 /**
  * Abstract superclass for constraints having a single possible output variable.
  */
 abstract class UnaryConstraint extends Constraint {
-
   final Variable myOutput;
   bool satisfied = false;
 
   UnaryConstraint(this.myOutput, Strength strength) : super(strength) {
     addConstraint();
   }
 
   /// Adds this constraint to the constraint graph
   void addToGraph() {
     myOutput.addConstraint(this);
     satisfied = false;
   }
 
   /// Decides if this constraint can be satisfied and records that decision.
   void chooseMethod(int mark) {
-    satisfied = (myOutput.mark != mark)
-      && Strength.stronger(strength, myOutput.walkStrength);
+    satisfied = (myOutput.mark != mark) &&
+        Strength.stronger(strength, myOutput.walkStrength);
   }
 
   /// Returns true if this constraint is satisfied in the current solution.
   bool isSatisfied() => satisfied;
 
   void markInputs(int mark) {
     // has no inputs.
   }
 
   /// Returns the current output variable.
@@ skipping 16 matching lines @@
   }
 
   bool inputsKnown(int mark) => true;
 
   void removeFromGraph() {
     if (myOutput != null) myOutput.removeConstraint(this);
     satisfied = false;
   }
 }
 
-
 /**
  * Variables that should, with some level of preference, stay the same.
  * Planners may exploit the fact that instances, if satisfied, will not
  * change their output during plan execution.  This is called "stay
  * optimization".
  */
 class StayConstraint extends UnaryConstraint {
-
   StayConstraint(Variable v, Strength str) : super(v, str);
 
   void execute() {
     // Stay constraints do nothing.
   }
 }
 
-
 /**
  * A unary input constraint used to mark a variable that the client
  * wishes to change.
  */
 class EditConstraint extends UnaryConstraint {
-
   EditConstraint(Variable v, Strength str) : super(v, str);
 
   /// Edits indicate that a variable is to be changed by imperative code.
   bool isInput() => true;
 
   void execute() {
     // Edit constraints do nothing.
   }
 }
 
-
 // Directions.
 const int NONE = 1;
 const int FORWARD = 2;
 const int BACKWARD = 0;
 
-
 /**
  * Abstract superclass for constraints having two possible output
  * variables.
  */
 abstract class BinaryConstraint extends Constraint {
-
   Variable v1;
   Variable v2;
   int direction = NONE;
 
   BinaryConstraint(this.v1, this.v2, Strength strength) : super(strength) {
     addConstraint();
   }
 
   /**
    * Decides if this constraint can be satisfied and which way it
    * should flow based on the relative strength of the variables related,
    * and record that decision.
    */
   void chooseMethod(int mark) {
     if (v1.mark == mark) {
-      direction = (v2.mark != mark &&
-                   Strength.stronger(strength, v2.walkStrength))
-        ? FORWARD : NONE;
+      direction =
+          (v2.mark != mark && Strength.stronger(strength, v2.walkStrength))
+              ? FORWARD
+              : NONE;
     }
     if (v2.mark == mark) {
-      direction = (v1.mark != mark &&
-                   Strength.stronger(strength, v1.walkStrength))
-        ? BACKWARD : NONE;
+      direction =
+          (v1.mark != mark && Strength.stronger(strength, v1.walkStrength))
+              ? BACKWARD
+              : NONE;
     }
     if (Strength.weaker(v1.walkStrength, v2.walkStrength)) {
-      direction = Strength.stronger(strength, v1.walkStrength)
-        ? BACKWARD : NONE;
+      direction =
+          Strength.stronger(strength, v1.walkStrength) ? BACKWARD : NONE;
     } else {
-      direction = Strength.stronger(strength, v2.walkStrength)
-        ? FORWARD : BACKWARD;
+      direction =
+          Strength.stronger(strength, v2.walkStrength) ? FORWARD : BACKWARD;
     }
   }
 
   /// Add this constraint to the constraint graph.
   void addToGraph() {
     v1.addConstraint(this);
     v2.addConstraint(this);
     direction = NONE;
   }
 
@@ skipping 33 matching lines @@
     return i.mark == mark || i.stay || i.determinedBy == null;
   }
 
   void removeFromGraph() {
     if (v1 != null) v1.removeConstraint(this);
     if (v2 != null) v2.removeConstraint(this);
     direction = NONE;
   }
 }
 
-
 /**
  * Relates two variables by the linear scaling relationship: "v2 =
  * (v1 * scale) + offset". Either v1 or v2 may be changed to maintain
  * this relationship but the scale factor and offset are considered
  * read-only.
  */
 
 class ScaleConstraint extends BinaryConstraint {
-
   final Variable scale;
   final Variable offset;
 
-  ScaleConstraint(Variable src, this.scale, this.offset,
-                  Variable dest, Strength strength)
-    : super(src, dest, strength);
+  ScaleConstraint(
+      Variable src, this.scale, this.offset, Variable dest, Strength strength)
+      : super(src, dest, strength);
 
   /// Adds this constraint to the constraint graph.
   void addToGraph() {
     super.addToGraph();
     scale.addConstraint(this);
     offset.addConstraint(this);
   }
 
   void removeFromGraph() {
     super.removeFromGraph();
@@ skipping 19 matching lines @@
    * Calculate the walkabout strength, the stay flag, and, if it is
    * 'stay', the value for the current output of this constraint. Assume
    * this constraint is satisfied.
    */
   void recalculate() {
     Variable ihn = input(), out = output();
     out.walkStrength = Strength.weakest(strength, ihn.walkStrength);
     out.stay = ihn.stay && scale.stay && offset.stay;
     if (out.stay) execute();
   }
-
 }
 
-
 /**
  * Constrains two variables to have the same value.
  */
 class EqualityConstraint extends BinaryConstraint {
-
   EqualityConstraint(Variable v1, Variable v2, Strength strength)
-    : super(v1, v2, strength);
+      : super(v1, v2, strength);
 
   /// Enforce this constraint. Assume that it is satisfied.
   void execute() {
     output().value = input().value;
   }
 }
 
-
 /**
  * A constrained variable. In addition to its value, it maintain the
  * structure of the constraint graph, the current dataflow graph, and
  * various parameters of interest to the DeltaBlue incremental
  * constraint solver.
  **/
 class Variable {
-
   List<Constraint> constraints = <Constraint>[];
   Constraint determinedBy;
   int mark = 0;
   Strength walkStrength = WEAKEST;
   bool stay = true;
   int value;
   final String name;
 
   Variable(this.name, this.value);
 
   /**
    * Add the given constraint to the set of all constraints that refer
    * this variable.
    */
   void addConstraint(Constraint c) {
     constraints.add(c);
   }
 
   /// Removes all traces of c from this variable.
   void removeConstraint(Constraint c) {
     constraints.remove(c);
     if (determinedBy == c) determinedBy = null;
   }
 }
 
-
 class Planner {
-
   int currentMark = 0;
 
   /**
    * Attempt to satisfy the given constraint and, if successful,
    * incrementally update the dataflow graph.  Details: If satifying
    * the constraint is successful, it may override a weaker constraint
    * on its output. The algorithm attempts to resatisfy that
    * constraint using some other method. This process is repeated
    * until either a) it reaches a variable that was not previously
    * determined by any constraint or b) it reaches a constraint that
    * is too weak to be satisfied using any of its methods. The
    * variables of constraints that have been processed are marked with
    * a unique mark value so that we know where we've been. This allows
    * the algorithm to avoid getting into an infinite loop even if the
    * constraint graph has an inadvertent cycle.
    */
   void incrementalAdd(Constraint c) {
     int mark = newMark();
-    for(Constraint overridden = c.satisfy(mark);
+    for (Constraint overridden = c.satisfy(mark);
         overridden != null;
         overridden = overridden.satisfy(mark));
   }
 
   /**
    * Entry point for retracting a constraint. Remove the given
    * constraint and incrementally update the dataflow graph.
    * Details: Retracting the given constraint may allow some currently
    * unsatisfiable downstream constraint to be satisfied. We therefore collect
    * a list of unsatisfied downstream constraints and attempt to
@@ skipping 126 matching lines @@
 
   void addConstraintsConsumingTo(Variable v, List<Constraint> coll) {
     Constraint determining = v.determinedBy;
     for (int i = 0; i < v.constraints.length; i++) {
       Constraint c = v.constraints[i];
       if (c != determining && c.isSatisfied()) coll.add(c);
     }
   }
 }
 
-
 /**
  * A Plan is an ordered list of constraints to be executed in sequence
  * to resatisfy all currently satisfiable constraints in the face of
  * one or more changing inputs.
  */
 class Plan {
   List<Constraint> list = <Constraint>[];
 
   void addConstraint(Constraint c) {
     list.add(c);
   }
 
   int size() => list.length;
 
   void execute() {
     for (int i = 0; i < list.length; i++) {
       list[i].execute();
     }
   }
 }
 
-
 /**
  * This is the standard DeltaBlue benchmark. A long chain of equality
  * constraints is constructed with a stay constraint on one end. An
  * edit constraint is then added to the opposite end and the time is
  * measured for adding and removing this constraint, and extracting
  * and executing a constraint satisfaction plan. There are two cases.
  * In case 1, the added constraint is stronger than the stay
  * constraint and values must propagate down the entire length of the
  * chain. In case 2, the added constraint is weaker than the stay
  * constraint so it cannot be accomodated. The cost in this case is,
@@ skipping 62 matching lines @@
   EditConstraint edit = new EditConstraint(v, PREFERRED);
   Plan plan = planner.extractPlanFromConstraints(<EditConstraint>[edit]);
   for (int i = 0; i < 10; i++) {
     v.value = newValue;
     plan.execute();
   }
   edit.destroyConstraint();
 }
 
 Planner planner;