Fixed strong mode errors and warnings reachable from lib/observe.dart

lib/src/path_observer.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.
 
 library observe.src.path_observer;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math' show min;
 
@@ skipping 114 matching lines @@
           throw new ArgumentError(
               'List must contain only ints, Strings, and Symbols');
         }
       }
       return new PropertyPath._(copy);
     }
 
     var pathObj = _pathCache[path];
     if (pathObj != null) return pathObj;
 
-
     final segments = new _PathParser().parse(path);
     if (segments == null) return _InvalidPropertyPath._instance;
 
     // TODO(jmesserly): we could use an UnmodifiableListView here, but that adds
     // memory overhead.
     pathObj = new PropertyPath._(segments.toList(growable: false));
     if (_pathCache.length >= _pathCacheLimit) {
       _pathCache.remove(_pathCache.keys.first);
     }
     _pathCache[path] = pathObj;
@@ skipping 48 matching lines @@
   /// [1]: http://en.wikipedia.org/wiki/Jenkins_hash_function
   // TODO(jmesserly): should reuse this instead, see
   // https://code.google.com/p/dart/issues/detail?id=11617
   int get hashCode {
     int hash = 0;
     for (int i = 0, len = _segments.length; i < len; i++) {
       hash = 0x1fffffff & (hash + _segments[i].hashCode);
       hash = 0x1fffffff & (hash + ((0x0007ffff & hash) << 10));
       hash = hash ^ (hash >> 6);
     }
-    hash = 0x1fffffff & (hash + ((0x03ffffff & hash) <<  3));
+    hash = 0x1fffffff & (hash + ((0x03ffffff & hash) << 3));
     hash = hash ^ (hash >> 11);
     return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
   }
 
   /// Returns the current value of the path from the provided [obj]ect.
   getValueFrom(Object obj) {
     if (!isValid) return null;
     for (var segment in _segments) {
       if (obj == null) return null;
       obj = _getObjectProperty(obj, segment);
@@ skipping 23 matching lines @@
       observe(obj, _segments[i]);
 
       if (i >= last) break;
       obj = _getObjectProperty(obj, _segments[i++]);
     }
   }
 
   // Dart note: it doesn't make sense to have compiledGetValueFromFn in Dart.
 }
 
-
 /// Visible only for testing:
 getSegmentsOfPropertyPathForTesting(p) => p._segments;
 
 class _InvalidPropertyPath extends PropertyPath {
   static final _instance = new _InvalidPropertyPath();
 
   bool get isValid => false;
   _InvalidPropertyPath() : super._([]);
 }
 
@@ skipping 12 matching lines @@
     }
   } else if (property is String) {
     return object[property];
   } else if (property is Symbol) {
     // Support indexer if available, e.g. Maps or polymer_expressions Scope.
     // This is the default syntax used by polymer/nodebind and
     // polymer/observe-js PathObserver.
     // TODO(sigmund): should we also support using checking dynamically for
     // whether the type practically implements the indexer API
     // (smoke.hasInstanceMethod(type, const Symbol('[]')))?
-    if (object is Indexable || object is Map && !_MAP_PROPERTIES.contains(property)) {
+    if (object is Indexable ||
+        object is Map && !_MAP_PROPERTIES.contains(property)) {
       return object[smoke.symbolToName(property)];
     }
     try {
       return smoke.read(object, property);
     } on NoSuchMethodError catch (_) {
       // Rethrow, unless the type implements noSuchMethod, in which case we
       // interpret the exception as a signal that the method was not found.
       // Dart note: getting invalid properties is an error, unlike in JS where
       // it returns undefined.
       if (!smoke.hasNoSuchMethod(object.runtimeType)) rethrow;
     }
   }
 
   if (_logger.isLoggable(Level.FINER)) {
     _logger.finer("can't get $property in $object");
   }
   return null;
 }
 
 bool _setObjectProperty(object, property, value) {
   if (object == null) return false;
 
   if (property is int) {
     if (object is List && property >= 0 && property < object.length) {
       object[property] = value;
       return true;
     }
   } else if (property is Symbol) {
     // Support indexer if available, e.g. Maps or polymer_expressions Scope.
-    if (object is Indexable || object is Map && !_MAP_PROPERTIES.contains(property)) {
+    if (object is Indexable ||
+        object is Map && !_MAP_PROPERTIES.contains(property)) {
       object[smoke.symbolToName(property)] = value;
       return true;
     }
     try {
       smoke.write(object, property, value);
       return true;
     } on NoSuchMethodError catch (_) {
       if (!smoke.hasNoSuchMethod(object.runtimeType)) rethrow;
     }
   }
@@ skipping 14 matching lines @@
 
 _isIdent(s) => _identRegExp.hasMatch(s);
 
 // Dart note: refactored to convert to codepoints once and operate on codepoints
 // rather than characters.
 class _PathParser {
   List keys = [];
   int index = -1;
   String key;
 
-  final Map<String, List<String>> _pathStateMachine = {
+  final Map<String, Map<String, List<String>>> _pathStateMachine = {
     'beforePath': {
       'ws': ['beforePath'],
       'ident': ['inIdent', 'append'],
       '[': ['beforeElement'],
       'eof': ['afterPath']
     },
-
     'inPath': {
       'ws': ['inPath'],
       '.': ['beforeIdent'],
       '[': ['beforeElement'],
       'eof': ['afterPath']
     },
-
     'beforeIdent': {
       'ws': ['beforeIdent'],
       'ident': ['inIdent', 'append']
     },
-
     'inIdent': {
       'ident': ['inIdent', 'append'],
       '0': ['inIdent', 'append'],
       'number': ['inIdent', 'append'],
       'ws': ['inPath', 'push'],
       '.': ['beforeIdent', 'push'],
       '[': ['beforeElement', 'push'],
       'eof': ['afterPath', 'push']
     },
-
     'beforeElement': {
       'ws': ['beforeElement'],
       '0': ['afterZero', 'append'],
       'number': ['inIndex', 'append'],
       "'": ['inSingleQuote', 'append', ''],
       '"': ['inDoubleQuote', 'append', '']
     },
-
     'afterZero': {
       'ws': ['afterElement', 'push'],
       ']': ['inPath', 'push']
     },
-
     'inIndex': {
       '0': ['inIndex', 'append'],
       'number': ['inIndex', 'append'],
       'ws': ['afterElement'],
       ']': ['inPath', 'push']
     },
-
     'inSingleQuote': {
       "'": ['afterElement'],
       'eof': ['error'],
       'else': ['inSingleQuote', 'append']
     },
-
     'inDoubleQuote': {
       '"': ['afterElement'],
       'eof': ['error'],
       'else': ['inDoubleQuote', 'append']
     },
-
     'afterElement': {
       'ws': ['afterElement'],
       ']': ['inPath', 'push']
     }
   };
 
   /// From getPathCharType: determines the type of a given [code]point.
   String _getPathCharType(code) {
     if (code == null) return 'eof';
-    switch(code) {
+    switch (code) {
       case 0x5B: // [
       case 0x5D: // ]
       case 0x2E: // .
       case 0x22: // "
       case 0x27: // '
       case 0x30: // 0
         return _char(code);
 
       case 0x5F: // _
       case 0x24: // $
         return 'ident';
 
       case 0x20: // Space
       case 0x09: // Tab
       case 0x0A: // Newline
       case 0x0D: // Return
-      case 0xA0:  // No-break space
-      case 0xFEFF:  // Byte Order Mark
-      case 0x2028:  // Line Separator
-      case 0x2029:  // Paragraph Separator
+      case 0xA0: // No-break space
+      case 0xFEFF: // Byte Order Mark
+      case 0x2028: // Line Separator
+      case 0x2029: // Paragraph Separator
         return 'ws';
     }
 
     // a-z, A-Z
     if ((0x61 <= code && code <= 0x7A) || (0x41 <= code && code <= 0x5A))
       return 'ident';
 
     // 1-9
-    if (0x31 <= code && code <= 0x39)
-      return 'number';
+    if (0x31 <= code && code <= 0x39) return 'number';
 
     return 'else';
   }
 
   static String _char(int codepoint) => new String.fromCharCodes([codepoint]);
 
   void push() {
     if (key == null) return;
 
     // Dart note: we store the keys with different types, rather than
@@ skipping 17 matching lines @@
     if ((mode == 'inSingleQuote' && nextChar == "'") ||
         (mode == 'inDoubleQuote' && nextChar == '"')) {
       index++;
       append(nextChar);
       return true;
     }
     return false;
   }
 
   /// Returns the parsed keys, or null if there was a parse error.
-  List<String> parse(String path) {
+  List parse(String path) {

[Bob Nystrom, 2016/01/22 18:50:25]

So the old return type was straight up wrong, right?

How about List<Object> here and on the keys field?

[vsm, 2016/01/22 19:05:05]

Yes, the list has Symbols and Strings (at least statically).

Done.

     var codePoints = stringToCodepoints(path);
     var mode = 'beforePath';
 
     while (mode != null) {
       index++;
       var c = index >= codePoints.length ? null : codePoints[index];
 
       if (c != null &&
-          _char(c) == '\\' && _maybeUnescapeQuote(mode, codePoints)) continue;
+          _char(c) == '\\' &&
+          _maybeUnescapeQuote(mode, codePoints)) continue;
 
       var type = _getPathCharType(c);
       if (mode == 'error') return null;
 
       var typeMap = _pathStateMachine[mode];
       var transition = typeMap[type];
       if (transition == null) transition = typeMap['else'];
       if (transition == null) return null; // parse error;
 
       mode = transition[0];
       var actionName = transition.length > 1 ? transition[1] : null;
       if (actionName == 'push' && key != null) push();
       if (actionName == 'append') {
         var newChar = transition.length > 2 && transition[2] != null
-            ? transition[2] : _char(c);
+            ? transition[2]
+            : _char(c);
         append(newChar);
       }
 
       if (mode == 'afterPath') return keys;
     }
     return null; // parse error
   }
 }
 
 final Logger _logger = new Logger('observe.PathObserver');
 
-
 /// This is a simple cache. It's like LRU but we don't update an item on a
 /// cache hit, because that would require allocation. Better to let it expire
 /// and reallocate the PropertyPath.
 // TODO(jmesserly): this optimization is from observe-js, how valuable is it in
 // practice?
 final _pathCache = new LinkedHashMap<String, PropertyPath>();
 
 /// The size of a path like "foo.bar" is approximately 160 bytes, so this
 /// reserves ~16Kb of memory for recently used paths. Since paths are frequently
 /// reused, the theory is that this ends up being a good tradeoff in practice.
@@ skipping 107 matching lines @@
   bool _check({bool skipChanges: false}) {
     bool changed = false;
     _value.length = _observed.length ~/ 2;
     var oldValues = null;
     for (var i = 0; i < _observed.length; i += 2) {
       var object = _observed[i];
       var path = _observed[i + 1];
       var value;
       if (identical(object, _observerSentinel)) {
         var observable = path as Bindable;
-        value = _state == _Observer._UNOPENED ?
-            observable.open((_) => this.deliver()) :
-            observable.value;
+        value = _state == _Observer._UNOPENED
+            ? observable.open((_) => this.deliver())
+            : observable.value;
       } else {
         value = (path as PropertyPath).getValueFrom(object);
       }
 
       if (skipChanges) {
         _value[i ~/ 2] = value;
         continue;
       }
 
       if (value == _value[i ~/ 2]) continue;
@@ skipping 18 matching lines @@
 }
 
 /// An object accepted by [PropertyPath] where properties are read and written
 /// as indexing operations, just like a [Map].
 abstract class Indexable<K, V> {
   V operator [](K key);
   operator []=(K key, V value);
 }
 
 const _observerSentinel = const _ObserverSentinel();
-class _ObserverSentinel { const _ObserverSentinel(); }
+
+class _ObserverSentinel {
+  const _ObserverSentinel();
+}
 
 // Visible for testing
 get observerSentinelForTesting => _observerSentinel;
 
 // A base class for the shared API implemented by PathObserver and
 // CompoundObserver and used in _ObservedSet.
 abstract class _Observer extends Bindable {
   Function _notifyCallback;
   int _notifyArgumentCount;
   var _value;
@@ skipping 56 matching lines @@
     var cycles = 0;
     while (cycles < _MAX_DIRTY_CHECK_CYCLES && _check()) {
       cycles++;
     }
     return cycles > 0;
   }
 
   void _report(newValue, oldValue, [extraArg]) {
     try {
       switch (_notifyArgumentCount) {
-        case 0: _notifyCallback(); break;
-        case 1: _notifyCallback(newValue); break;
-        case 2: _notifyCallback(newValue, oldValue); break;
-        case 3: _notifyCallback(newValue, oldValue, extraArg); break;
+        case 0:
+          _notifyCallback();
+          break;
+        case 1:
+          _notifyCallback(newValue);
+          break;
+        case 2:
+          _notifyCallback(newValue, oldValue);
+          break;
+        case 3:
+          _notifyCallback(newValue, oldValue, extraArg);
+          break;
       }
     } catch (e, s) {
       // Deliver errors async, so if a single callback fails it doesn't prevent
       // other things from working.
       new Completer().completeError(e, s);
     }
   }
 }
 
 /// The observedSet abstraction is a perf optimization which reduces the total
@@ skipping 115 matching lines @@
         }
       } else {
         // TODO(sigmund): consider adding object to MapChangeRecord, and make
         // this more precise.
         return false;
       }
     }
     return true;
   }
 
-  void _callback(records) {
+  void _callback(List<ChangeRecord> records) {
     if (_canIgnoreRecords(records)) return;
     for (var observer in _observers.toList(growable: false)) {
       if (observer._isOpen) observer._iterateObjects(observe);
     }
 
     for (var observer in _observers.toList(growable: false)) {
       if (observer._isOpen) observer._check();
     }
   }
 }
 
 const int _MAX_DIRTY_CHECK_CYCLES = 1000;