fixes #52, fields shadowing getters/setters or other fields

test/codegen/expect/DeltaBlue.js

 var DeltaBlue;
 (function(exports) {
   'use strict';
   // Function main: () → dynamic
   function main() {
     new DeltaBlue().report();
   }
   class DeltaBlue extends BenchmarkBase.BenchmarkBase {
     DeltaBlue() {
       super.BenchmarkBase("DeltaBlue");
     }
     run() {
       chainTest(100);
       projectionTest(100);
     }
   }
+  let value$ = Symbol('value');
+  let name$ = Symbol('name');
   class Strength extends core.Object {
+    get value() {
+      return this[value$];
+    }
+    get name() {
+      return this[name$];
+    }
     Strength(value, name) {
-      this.value = value;
-      this.name = name;
+      this[value$] = value;
+      this[name$] = name;
     }
     nextWeaker() {
       return /* Unimplemented const */new core.List$(Strength).from([STRONG_PREFERRED, PREFERRED, STRONG_DEFAULT, NORMAL, WEAK_DEFAULT, WEAKEST])[core.$get](this.value);
     }
     static stronger(s1, s2) {
       return dart.notNull(s1.value) < dart.notNull(s2.value);
     }
     static weaker(s1, s2) {
       return dart.notNull(s1.value) > dart.notNull(s2.value);
     }
     static weakest(s1, s2) {
       return Strength.weaker(s1, s2) ? s1 : s2;
     }
     static strongest(s1, s2) {
       return Strength.stronger(s1, s2) ? s1 : s2;
     }
   }
   let REQUIRED = new Strength(0, "required");
   let STRONG_PREFERRED = new Strength(1, "strongPreferred");
   let PREFERRED = new Strength(2, "preferred");
   let STRONG_DEFAULT = new Strength(3, "strongDefault");
   let NORMAL = new Strength(4, "normal");
   let WEAK_DEFAULT = new Strength(5, "weakDefault");
   let WEAKEST = new Strength(6, "weakest");
+  let strength$ = Symbol('strength');
   class Constraint extends core.Object {
+    get strength() {
+      return this[strength$];
+    }
     Constraint(strength) {
-      this.strength = strength;
+      this[strength$] = strength;
     }
     addConstraint() {
       this.addToGraph();
       exports.planner.incrementalAdd(this);
     }
     satisfy(mark) {
       this.chooseMethod(dart.as(mark, core.int));
       if (!dart.notNull(this.isSatisfied())) {
         if (dart.equals(this.strength, REQUIRED)) {
           core.print("Could not satisfy a required constraint!");
@@ skipping 13 matching lines @@
     }
     destroyConstraint() {
       if (this.isSatisfied())
         exports.planner.incrementalRemove(this);
       this.removeFromGraph();
     }
     isInput() {
       return false;
     }
   }
+  let myOutput$ = Symbol('myOutput');
+  let satisfied = Symbol('satisfied');
   class UnaryConstraint extends Constraint {
+    get myOutput() {
+      return this[myOutput$];
+    }
+    get satisfied() {
+      return this[satisfied];
+    }
+    set satisfied(value) {
+      this[satisfied] = value;
+    }
     UnaryConstraint(myOutput, strength) {

[Jennifer Messerly, 2015/04/17 18:38:55]

This parameter name is why the renamer didn't name the storage slot "myOutput"

Incidentally is a pretty common pattern. We special case it already for
`this._privateName` fields. Maybe should add a special case for public ones now
too.

-      this.myOutput = myOutput;
-      this.satisfied = false;
+      this[myOutput$] = myOutput;
+      this[satisfied] = false;
       super.Constraint(strength);
       this.addConstraint();
     }
     addToGraph() {
       this.myOutput.addConstraint(this);
       this.satisfied = false;
     }
     chooseMethod(mark) {
       this.satisfied = this.myOutput.mark != mark && dart.notNull(Strength.stronger(this.strength, this.myOutput.walkStrength));
     }
@@ skipping 33 matching lines @@
       super.UnaryConstraint(v, str);
     }
     isInput() {
       return true;
     }
     execute() {}
   }
   let NONE = 1;
   let FORWARD = 2;
   let BACKWARD = 0;
+  let v1$ = Symbol('v1');
+  let v2$ = Symbol('v2');
+  let direction = Symbol('direction');
   class BinaryConstraint extends Constraint {
+    get v1() {
+      return this[v1$];
+    }
+    set v1(value) {
+      this[v1$] = value;
+    }
+    get v2() {
+      return this[v2$];
+    }
+    set v2(value) {
+      this[v2$] = value;
+    }
+    get direction() {
+      return this[direction];
+    }
+    set direction(value) {
+      this[direction] = value;
+    }
     BinaryConstraint(v1, v2, strength) {
-      this.v1 = v1;
-      this.v2 = v2;
-      this.direction = NONE;
+      this[v1$] = v1;
+      this[v2$] = v2;
+      this[direction] = NONE;
       super.Constraint(strength);
       this.addConstraint();
     }
     chooseMethod(mark) {
       if (this.v1.mark == mark) {
         this.direction = this.v2.mark != mark && dart.notNull(Strength.stronger(this.strength, this.v2.walkStrength)) ? FORWARD : NONE;
       }
       if (this.v2.mark == mark) {
         this.direction = this.v1.mark != mark && dart.notNull(Strength.stronger(this.strength, this.v1.walkStrength)) ? BACKWARD : NONE;
       }
@@ skipping 35 matching lines @@
       return i.mark == mark || dart.notNull(i.stay) || dart.notNull(i.determinedBy == null);
     }
     removeFromGraph() {
       if (this.v1 != null)
         this.v1.removeConstraint(this);
       if (this.v2 != null)
         this.v2.removeConstraint(this);
       this.direction = NONE;
     }
   }
+  let scale$ = Symbol('scale');
+  let offset$ = Symbol('offset');
   class ScaleConstraint extends BinaryConstraint {
+    get scale() {
+      return this[scale$];
+    }
+    get offset() {
+      return this[offset$];
+    }
     ScaleConstraint(src, scale, offset, dest, strength) {
-      this.scale = scale;
-      this.offset = offset;
+      this[scale$] = scale;
+      this[offset$] = offset;
       super.BinaryConstraint(src, dest, strength);
     }
     addToGraph() {
       super.addToGraph();
       this.scale.addConstraint(this);
       this.offset.addConstraint(this);
     }
     removeFromGraph() {
       super.removeFromGraph();
       if (this.scale != null)
@@ skipping 21 matching lines @@
     }
   }
   class EqualityConstraint extends BinaryConstraint {
     EqualityConstraint(v1, v2, strength) {
       super.BinaryConstraint(v1, v2, strength);
     }
     execute() {
       this.output().value = this.input().value;
     }
   }
+  let constraints = Symbol('constraints');
+  let determinedBy = Symbol('determinedBy');
+  let mark = Symbol('mark');
+  let walkStrength = Symbol('walkStrength');
+  let stay = Symbol('stay');
+  let value$0 = Symbol('value');
+  let name$0 = Symbol('name');
   class Variable extends core.Object {
+    get constraints() {
+      return this[constraints];
+    }
+    set constraints(value) {
+      this[constraints] = value;
+    }
+    get determinedBy() {
+      return this[determinedBy];
+    }
+    set determinedBy(value) {
+      this[determinedBy] = value;
+    }
+    get mark() {
+      return this[mark];
+    }
+    set mark(value) {
+      this[mark] = value;
+    }
+    get walkStrength() {
+      return this[walkStrength];
+    }
+    set walkStrength(value) {
+      this[walkStrength] = value;
+    }
+    get stay() {
+      return this[stay];
+    }
+    set stay(value) {
+      this[stay] = value;
+    }
+    get value() {
+      return this[value$0];
+    }
+    set value(value) {
+      this[value$0] = value;
+    }
+    get name() {
+      return this[name$0];
+    }
     Variable(name, value) {
-      this.constraints = new core.List$(Constraint).from([]);
-      this.name = name;
-      this.value = value;
-      this.determinedBy = null;
-      this.mark = 0;
-      this.walkStrength = WEAKEST;
-      this.stay = true;
+      this[constraints] = new core.List$(Constraint).from([]);
+      this[name$0] = name;
+      this[value$0] = value;
+      this[determinedBy] = null;
+      this[mark] = 0;
+      this[walkStrength] = WEAKEST;
+      this[stay] = true;
     }
     addConstraint(c) {
       this.constraints[core.$add](c);
     }
     removeConstraint(c) {
       this.constraints[core.$remove](c);
       if (dart.equals(this.determinedBy, c))
         this.determinedBy = null;
     }
   }
+  let currentMark = Symbol('currentMark');
   class Planner extends core.Object {
     Planner() {
-      this.currentMark = 0;
+      this[currentMark] = 0;
+    }
+    get currentMark() {
+      return this[currentMark];
+    }
+    set currentMark(value) {
+      this[currentMark] = value;
     }
     incrementalAdd(c) {
       let mark = this.newMark();
       for (let overridden = c.satisfy(mark); overridden != null; overridden = overridden.satisfy(mark))
         ;
     }
     incrementalRemove(c) {
       let out = c.output();
       c.markUnsatisfied();
       c.removeFromGraph();
@@ skipping 73 matching lines @@
     }
     addConstraintsConsumingTo(v, coll) {
       let determining = v.determinedBy;
       for (let i = 0; dart.notNull(i) < dart.notNull(v.constraints[core.$length]); i = dart.notNull(i) + 1) {
         let c = v.constraints[core.$get](i);
         if (dart.notNull(!dart.equals(c, determining)) && dart.notNull(c.isSatisfied()))
           coll[core.$add](c);
       }
     }
   }
+  let list = Symbol('list');
   class Plan extends core.Object {
     Plan() {
-      this.list = new core.List$(Constraint).from([]);
+      this[list] = new core.List$(Constraint).from([]);
+    }
+    get list() {
+      return this[list];
+    }
+    set list(value) {
+      this[list] = value;
     }
     addConstraint(c) {
       this.list[core.$add](c);
     }
     size() {
       return this.list[core.$length];
     }
     execute() {
       for (let i = 0; dart.notNull(i) < dart.notNull(this.list[core.$length]); i = dart.notNull(i) + 1) {
         this.list[core.$get](i).execute();
@@ skipping 89 matching lines @@
   exports.BinaryConstraint = BinaryConstraint;
   exports.ScaleConstraint = ScaleConstraint;
   exports.EqualityConstraint = EqualityConstraint;
   exports.Variable = Variable;
   exports.Planner = Planner;
   exports.Plan = Plan;
   exports.chainTest = chainTest;
   exports.projectionTest = projectionTest;
   exports.change = change;
 })(DeltaBlue || (DeltaBlue = {}));