workaround various mixin bugs

lib/observe/observable.dart

 // Copyright (c) 2013, 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.
 
 /**
  * This library is used to implement [Observable] types.
  *
  * It exposes lower level functionality such as [hasObservers], [observeReads]
  * [notifyChange] and [notifyRead].
  *
@@ skipping 207 matching lines @@
  * Returns a function that can be used to stop observation.
  * Calling this makes it possible for the garbage collector to reclaim memory
  * associated with the observation and prevents further calls to [callback].
  *
  * You can force a synchronous change delivery at any time by calling
  * [deliverChangesSync]. Calling this method if there are no changes has no
  * effect. If changes are delivered by deliverChangesSync, they will not be
  * delivered again asynchronously, unless the value is changed again.
  */
 ChangeUnobserver observeChanges(Observable obj, ChangeRecordObserver observer) {
-  if (obj._observers == null) obj._observers = new LinkedList();
-  var node = obj._observers.add(observer);
+  if (obj.$_observers == null) obj.$_observers = new LinkedList();
+  var node = obj.$_observers.add(observer);
   return node.remove;
 }
 
 
 /**
  * Converts the [Iterable], [Set] or [Map] to an [ObservableList],
  * [ObservableSet] or [ObservableMap] respectively.
  *
  * The resulting object will contain a shallow copy of the data.
  * If [value] is not one of those collection types, it will be returned
@@ skipping 19 matching lines @@
 
 /**
  * An observable object. This is used by data in model-view architectures
  * to notify interested parties of changes.
  *
  * Most of the methods for observation are static methods to keep them
  * stratified from the objects being observed. This is a similar to the design
  * of Mirrors.
  */
 class Observable {
-  // TODO(jmesserly): make these fields private once we have mixins in Dart VM.
-
   /** Observers for this object. Uses a linked-list for fast removal. */
-  LinkedList<ChangeRecordObserver> _observers;
+  // TODO(jmesserly): make these fields private again once dart2js bugs around
+  // mixins and private fields are fixed.
+  // TODO(jmesserly): removed type annotation here to workaround a VM checked
+  // mode bug. It should be: LinkedList<ChangeRecordObserver>
+  var $_observers;
 
   /** Changes to this object since last batch was delivered. */
-  List<ChangeRecord> _changes;
+  List<ChangeRecord> $_changes;
 
-  final int hashCode = ++Observable._nextHashCode;
+  final int hashCode = ++Observable.$_nextHashCode;
 
   // TODO(jmessery): workaround for VM bug http://dartbug.com/5746
   // We need hashCode to be fast for _ExpressionObserver to work.
-  static int _nextHashCode = 0;
+  static int $_nextHashCode = 0;
 }
 
 // Note: these are not instance methods of Observable, to make it clear that
 // they aren't themselves being observed. It is the same reason that mirrors and
 // EcmaScript's Object.observe are stratified.
 // TODO(jmesserly): this makes it impossible to proxy an Observable. Is that an
 // acceptable restriction?
 
 /**
  * True if [self] has any observers, and should call [notifyChange] for
  * changes.
  *
  * Note: this is used by objects implementing [Observable].
  * You should not need it if your type is marked `@observable`.
  */
 bool hasObservers(Observable self) =>
-    self._observers != null && self._observers.head != null;
+    self.$_observers != null && self.$_observers.head != null;
 
 /**
  * True if we are observing reads. This should be checked before calling
  * [notifyRead].
  *
  * Note: this is used by objects implementing [Observable].
  * You should not need it if your type is marked `@observable`.
  */
 bool get observeReads => _activeObserver != null;
 
@@ skipping 28 matching lines @@
   // the value actually changed. If not don't signal a change event.
   // This helps programmers avoid some common cases of cycles in their code.
   if ((type & (ChangeRecord.INSERT | ChangeRecord.REMOVE)) == 0) {
     if (oldValue == newValue) return;
   }
 
   if (_changedObjects == null) {
     _changedObjects = [];
     setImmediate(deliverChangesSync);
   }
-  if (self._changes == null) {
-    self._changes = [];
+  if (self.$_changes == null) {
+    self.$_changes = [];
     _changedObjects.add(self);
   }
-  self._changes.add(new ChangeRecord(type, key, oldValue, newValue));
+  self.$_changes.add(new ChangeRecord(type, key, oldValue, newValue));
 }
 
 // Optimizations to avoid extra work if observing const/final data.
 void _doNothing() {}
 
 /**
  * The current observer that is tracking reads, or null if we aren't tracking
  * reads. Reads are tracked when executing [_ExpressionObserver._observe].
  */
 _ExpressionObserver _activeObserver;
@@ skipping 43 matching lines @@
       return;
     }
 
     if (changedObjects != null) {
       for (var observable in changedObjects) {
         // TODO(jmesserly): freeze the "changes" list?
         // If one observer incorrectly mutates it, it will affect what future
         // observers see, possibly leading to subtle bugs.
         // OTOH, I don't want to add a defensive copy here. Maybe a wrapper that
         // prevents mutation, or a ListBuilder of some sort than can be frozen.
-        var changes = observable._changes;
-        observable._changes = null;
+        var changes = observable.$_changes;
+        observable.$_changes = null;
 
-        for (var n = observable._observers.head; n != null; n = n.next) {
+        for (var n = observable.$_observers.head; n != null; n = n.next) {
           var observer = n.value;
           try {
             observer(changes);
           } catch (error, trace) {
             onObserveUnhandledError(error, trace, observer, 'from $observable');
           }
         }
       }
     }
 
@@ skipping 16 matching lines @@
  */
 void _diagnoseCircularLimit(List<Observable> changedObjects,
     Map<int, _ExpressionObserver> changedExpressions) {
   // TODO(jmesserly,sigmund): we could do purity checks when running "observe"
   // itself, to detect if it causes writes to happen. I think that case is less
   // common than cycles caused by the notifications though.
 
   var trace = [];
   if (changedObjects != null) {
     for (var observable in changedObjects) {
-      var changes = observable._changes;
+      var changes = observable.$_changes;
       trace.add('$observable $changes');
     }
   }
 
   if (changedExpressions != null) {
     for (var exprObserver in changedExpressions.values) {
       var change = exprObserver._deliver();
       if (change != null) trace.add('$exprObserver $change');
     }
   }
@@ skipping 218 matching lines @@
 /**
  * The type of the `@observable` annotation.
  *
  * Library private because you should be able to use the [observable] field
  * to get the one and only instance. We could make it public though, if anyone
  * needs it for some reason.
  */
 class _ObservableAnnotation {
   const _ObservableAnnotation();
 }