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

lib/runtime/dart_runtime.js

 // Copyright (c) 2015, 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.
 
 var dart, _js_helper;
 (function (dart) {
   'use strict';
 
   let defineProperty = Object.defineProperty;
   let getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
@@ skipping 579 matching lines @@
   function copyProperties(to, from) {
     let names = getOwnPropertyNames(from);
     for (let i = 0; i < names.length; i++) {
       let name = names[i];
       defineProperty(to, name, getOwnPropertyDescriptor(from, name));
     }
     return to;
   }
   dart.copyProperties = copyProperties;
 
+  /**
+   * Initialize field `name` on `obj` to `value`.
+   *
+   * We may have getters/setters in our prototype chain, so we can't simply set
+   * `obj.name = value` in all cases.
+   */
+  function initField(type, obj, name, value) {
+    var prop = getOwnPropertyDescriptor(type.prototype, name);
+    if (prop) {
+      prop.set.call(obj, value);
+    } else {
+      obj[name] = value;
+    }
+  }
+  dart.initField = initField;
+
+  /**
+   * This is called whenever a derived class needs to introduce a new field,
+   * shadowing a field or getter/setter pair on its parent.
+   *
+   * This is important because otherwise, trying to read or write the field
+   * would end up calling the getter or setter, and one of those might not even
+   * exist, resulting in a runtime error. Even if they did exist, that's the
+   * wrong behavior if a new field was declared.
+   */
+  function virtualField(subclass, fieldName) {
+    // If the field is already overridden, do nothing.
+    let prop = getOwnPropertyDescriptor(subclass.prototype, fieldName);
+    if (prop) return;
+
+    let symbol = Symbol(subclass.name + '.' + fieldName);
+    defineProperty(subclass.prototype, fieldName, {
+      get: function() { return this[symbol]; },
+      set: function(x) { this[symbol] = x; }
+    });
+  }
+  dart.virtualField = virtualField;
 
   /** The Symbol for storing type arguments on a specialized generic type. */
   dart.mixins = Symbol('mixins');
   dart.implements = Symbol('implements');
 
   /**
    * Returns a new type that mixes members from base and all mixins.
    *
    * Each mixin applies in sequence, with further to the right ones overriding
    * previous entries.
@@ skipping 144 matching lines @@
   // TODO(vsm): How should we encode the runtime type?
   dart.runtimeType = Symbol('runtimeType');
 
   dart.JsSymbol = Symbol;
 
   // TODO(jmesserly): hack to bootstrap the SDK
   _js_helper = _js_helper || {};
   _js_helper.checkNum = notNull;
 
 })(dart || (dart = {}));