Update expectations.

pkg/front_end/testcases/DeltaBlue.dart.direct.expect

 library;
 import self as self;
 import "dart:core" as core;
 
 class DeltaBlue extends core::Object {
-  constructor •() → void
+  default constructor •() → void
     : super core::Object::•()
     ;
   method run() → void {
     self::chainTest(100);
     self::projectionTest(100);
   }
 }
 class Strength extends core::Object {
   final field core::int value;
   final field core::String name;
@@ skipping 170 matching lines @@
     this.direction = self::NONE;
   }
 }
 class ScaleConstraint extends self::BinaryConstraint {
   final field self::Variable scale;
   final field self::Variable offset;
   constructor •(self::Variable src, self::Variable scale, self::Variable offset, self::Variable dest, self::Strength strength) → void
     : self::ScaleConstraint::scale = scale, self::ScaleConstraint::offset = offset, super self::BinaryConstraint::•(src, dest, strength)
     ;
   method addToGraph() → void {
-    this.{=self::BinaryConstraint::addToGraph}();
+    super.{self::BinaryConstraint::addToGraph}();
     this.scale.addConstraint(this);
     this.offset.addConstraint(this);
   }
   method removeFromGraph() → void {
-    this.{=self::BinaryConstraint::removeFromGraph}();
+    super.{self::BinaryConstraint::removeFromGraph}();
     if(!this.scale.==(null))
       this.scale.removeConstraint(this);
     if(!this.offset.==(null))
       this.offset.removeConstraint(this);
   }
   method markInputs(core::int mark) → void {
-    this.{=self::BinaryConstraint::markInputs}(mark);
+    super.{self::BinaryConstraint::markInputs}(mark);
     this.scale.mark = this.offset.mark = mark;
   }
   method execute() → void {
     if(this.direction.==(self::FORWARD)) {
       this.v2.value = this.v1.value.*(this.scale.value).+(this.offset.value);
     }
     else {
       this.v1.value = this.v2.value.-(this.offset.value).~/(this.scale.value);
     }
   }
@@ skipping 29 matching lines @@
     this.constraints.add(c);
   }
   method removeConstraint(self::Constraint c) → void {
     this.constraints.remove(c);
     if(this.determinedBy.==(c))
       this.determinedBy = null;
   }
 }
 class Planner extends core::Object {
   field core::int currentMark = 0;
-  constructor •() → void
+  default constructor •() → void
     : super core::Object::•()
     ;
   method incrementalAdd(self::Constraint c) → void {
     core::int mark = this.newMark();
     for (self::Constraint overridden = c.satisfy(mark); !overridden.==(null); overridden = overridden.satisfy(mark))
       ;
   }
   method incrementalRemove(self::Constraint c) → void {
     self::Variable out = c.output();
     c.markUnsatisfied();
@@ skipping 76 matching lines @@
     self::Constraint determining = v.determinedBy;
     for (core::int i = 0; i.<(v.constraints.length); i = i.+(1)) {
       self::Constraint c = v.constraints.[](i);
       if(!c.==(determining) && c.isSatisfied())
         coll.add(c);
     }
   }
 }
 class Plan extends core::Object {
   field core::List<self::Constraint> list = <self::Constraint>[];
-  constructor •() → void
+  default constructor •() → void
     : super core::Object::•()
     ;
   method addConstraint(self::Constraint c) → void {
     this.list.add(c);
   }
   method size() → core::int
     return this.list.length;
   method execute() → void {
     for (core::int i = 0; i.<(this.list.length); i = i.+(1)) {
       this.list.[](i).execute();
@@ skipping 74 matching lines @@
 }
 static method change(self::Variable v, core::int newValue) → void {
   self::EditConstraint edit = new self::EditConstraint::•(v, self::PREFERRED);
   self::Plan plan = self::planner.extractPlanFromConstraints(<self::EditConstraint>[edit]);
   for (core::int i = 0; i.<(10); i = i.+(1)) {
     v.value = newValue;
     plan.execute();
   }
   edit.destroyConstraint();
 }