package:observe fix various api issues

pkg/mdv/test/template_element_test.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 template_element_test;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html';
 import 'dart:math' as math;
@@ skipping 74 matching lines @@
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'text');
   });
 
   observeTest('Template bind, no parent', () {
     var div = createTestHtml('<template bind>text</template>');
     var template = div.nodes[0];
     template.remove();
 
-    recursivelySetTemplateModel(template, toSymbolMap({}));
+    recursivelySetTemplateModel(template, toObservable({}));
     performMicrotaskCheckpoint();
     expect(template.nodes.length, 0);
     expect(template.nextNode, null);
   });
 
   observeTest('Template bind, no defaultView', () {
     var div = createTestHtml('<template bind>text</template>');
     var template = div.nodes[0];
     var doc = document.implementation.createHtmlDocument('');
     doc.adoptNode(div);
-    recursivelySetTemplateModel(template, toSymbolMap({}));
+    recursivelySetTemplateModel(template, toObservable({}));
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 1);
   });
 
   observeTest('Template-Empty Bind', () {
     var div = createTestHtml('<template bind>text</template>');
     recursivelySetTemplateModel(div, null);
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'text');
   });
 
   observeTest('Template Bind If', () {
     var div = createTestHtml('<template bind if="{{ foo }}">text</template>');
     // Note: changed this value from 0->null because zero is not falsey in Dart.
     // See https://code.google.com/p/dart/issues/detail?id=11956
-    var m = toSymbolMap({ 'foo': null });
+    var m = toObservable({ 'foo': null });
     recursivelySetTemplateModel(div, m);
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 1);
 
-    m[#foo] = 1;
+    m['foo'] = 1;
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     expect(div.lastChild.text, 'text');
   });
 
   observeTest('Template Bind If, 2', () {
     var div = createTestHtml(
         '<template bind="{{ foo }}" if="{{ bar }}">{{ bat }}</template>');
-    var m = toSymbolMap({ 'bar': null, 'foo': { 'bat': 'baz' } });
+    var m = toObservable({ 'bar': null, 'foo': { 'bat': 'baz' } });
     recursivelySetTemplateModel(div, m);
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 1);
 
-    m[#bar] = 1;
+    m['bar'] = 1;
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     expect(div.lastChild.text, 'baz');
   });
 
   observeTest('Template If', () {
     var div = createTestHtml('<template if="{{ foo }}">{{ value }}</template>');
     // Note: changed this value from 0->null because zero is not falsey in Dart.
     // See https://code.google.com/p/dart/issues/detail?id=11956
-    var m = toSymbolMap({ 'foo': null, 'value': 'foo' });
+    var m = toObservable({ 'foo': null, 'value': 'foo' });
     recursivelySetTemplateModel(div, m);
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 1);
 
-    m[#foo] = 1;
+    m['foo'] = 1;
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     expect(div.lastChild.text, 'foo');
   });
 
   observeTest('Template Repeat If', () {
     var div = createTestHtml(
         '<template repeat="{{ foo }}" if="{{ bar }}">{{ }}</template>');
     // Note: changed this value from 0->null because zero is not falsey in Dart.
     // See https://code.google.com/p/dart/issues/detail?id=11956
-    var m = toSymbolMap({ 'bar': null, 'foo': [1, 2, 3] });
+    var m = toObservable({ 'bar': null, 'foo': [1, 2, 3] });
     recursivelySetTemplateModel(div, m);
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 1);
 
-    m[#bar] = 1;
+    m['bar'] = 1;
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 4);
     expect(div.nodes[1].text, '1');
     expect(div.nodes[2].text, '2');
     expect(div.nodes[3].text, '3');
   });
 
   observeTest('TextTemplateWithNullStringBinding', () {
     var div = createTestHtml('<template bind={{}}>a{{b}}c</template>');
-    var model = toSymbolMap({'b': 'B'});
+    var model = toObservable({'b': 'B'});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'aBc');
 
-    model[#b] = 'b';
+    model['b'] = 'b';
     deliverChanges(model);
     expect(div.nodes.last.text, 'abc');
 
-    model[#b] = null;
+    model['b'] = null;
     deliverChanges(model);
     expect(div.nodes.last.text, 'ac');
 
     model = null;
     deliverChanges(model);
     // setting model isn't observable.
     expect(div.nodes.last.text, 'ac');
   });
 
   observeTest('TextTemplateWithBindingPath', () {
     var div = createTestHtml(
         '<template bind="{{ data }}">a{{b}}c</template>');
-    var model = toSymbolMap({ 'data': {'b': 'B'} });
+    var model = toObservable({ 'data': {'b': 'B'} });
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'aBc');
 
-    model[#data][#b] = 'b';
+    model['data']['b'] = 'b';
     deliverChanges(model);
     expect(div.nodes.last.text, 'abc');
 
-    model[#data] = toSymbols({'b': 'X'});
+    model['data'] = toObservable({'b': 'X'});
     deliverChanges(model);
     expect(div.nodes.last.text, 'aXc');
 
-    model[#data] = null;
+    model['data'] = null;
     deliverChanges(model);
     expect(div.nodes.last.text, 'ac');
   });
 
   observeTest('TextTemplateWithBindingAndConditional', () {
     var div = createTestHtml(
         '<template bind="{{}}" if="{{ d }}">a{{b}}c</template>');
-    var model = toSymbolMap({'b': 'B', 'd': 1});
+    var model = toObservable({'b': 'B', 'd': 1});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'aBc');
 
-    model[#b] = 'b';
+    model['b'] = 'b';
     deliverChanges(model);
     expect(div.nodes.last.text, 'abc');
 
     // TODO(jmesserly): MDV set this to empty string and relies on JS conversion
     // rules. Is that intended?
     // See https://github.com/toolkitchen/mdv/issues/59
-    model[#d] = null;
+    model['d'] = null;
     deliverChanges(model);
     expect(div.nodes.length, 1);
 
-    model[#d] = 'here';
-    model[#b] = 'd';
+    model['d'] = 'here';
+    model['b'] = 'd';
 
     deliverChanges(model);
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'adc');
   });
 
   observeTest('TemplateWithTextBinding2', () {
     var div = createTestHtml(
         '<template bind="{{ b }}">a{{value}}c</template>');
     expect(div.nodes.length, 1);
-    var model = toSymbolMap({'b': {'value': 'B'}});
+    var model = toObservable({'b': {'value': 'B'}});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'aBc');
 
-    model[#b] = toSymbols({'value': 'b'});
+    model['b'] = toObservable({'value': 'b'});
     deliverChanges(model);
     expect(div.nodes.last.text, 'abc');
   });
 
   observeTest('TemplateWithAttributeBinding', () {
     var div = createTestHtml(
         '<template bind="{{}}">'
         '<div foo="a{{b}}c"></div>'
         '</template>');
-    var model = toSymbolMap({'b': 'B'});
+    var model = toObservable({'b': 'B'});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 2);
     expect(div.nodes.last.attributes['foo'], 'aBc');
 
-    model[#b] = 'b';
+    model['b'] = 'b';
     deliverChanges(model);
     expect(div.nodes.last.attributes['foo'], 'abc');
 
-    model[#b] = 'X';
+    model['b'] = 'X';
     deliverChanges(model);
     expect(div.nodes.last.attributes['foo'], 'aXc');
   });
 
   observeTest('TemplateWithConditionalBinding', () {
     var div = createTestHtml(
         '<template bind="{{}}">'
         '<div foo?="{{b}}"></div>'
         '</template>');
-    var model = toSymbolMap({'b': 'b'});
+    var model = toObservable({'b': 'b'});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 2);
     expect(div.nodes.last.attributes['foo'], '');
     expect(div.nodes.last.attributes, isNot(contains('foo?')));
 
-    model[#b] = null;
+    model['b'] = null;
     deliverChanges(model);
     expect(div.nodes.last.attributes, isNot(contains('foo')));
   });
 
   observeTest('Repeat', () {
     var div = createTestHtml(
         '<template repeat="{{}}"">text</template>');
 
-    var model = toSymbols([0, 1, 2]);
+    var model = toObservable([0, 1, 2]);
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 4);
 
     model.length = 1;
     deliverChanges(model);
     expect(div.nodes.length, 2);
 
-    model.addAll(toSymbols([3, 4]));
+    model.addAll(toObservable([3, 4]));
     deliverChanges(model);
     expect(div.nodes.length, 4);
 
     model.removeRange(1, 2);
     deliverChanges(model);
     expect(div.nodes.length, 3);
   });
 
   observeTest('Repeat - Reuse Instances', () {
     var div = createTestHtml('<template repeat>{{ val }}</template>');
 
-    var model = toSymbols([
+    var model = toObservable([
       {'val': 10},
       {'val': 5},
       {'val': 2},
       {'val': 8},
       {'val': 1}
     ]);
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 6);
     var template = div.firstChild;
 
     addExpandos(template.nextNode);
     checkExpandos(template.nextNode);
 
-    model.sort((a, b) => a[#val] - b[#val]);
+    model.sort((a, b) => a['val'] - b['val']);
     deliverChanges(model);
     checkExpandos(template.nextNode);
 
     model = toObservable(model.reversed);
     recursivelySetTemplateModel(div, model);
     deliverChanges(model);
     checkExpandos(template.nextNode);
 
     for (var item in model) {
-      item[#val] += 1;
+      item['val'] += 1;
     }
 
     deliverChanges(model);
     expect(div.nodes[1].text, "11");
     expect(div.nodes[2].text, "9");
     expect(div.nodes[3].text, "6");
     expect(div.nodes[4].text, "3");
     expect(div.nodes[5].text, "2");
   });
 
@@ skipping 14 matching lines @@
     model = toObservable({'foo': model['foo']});
     recursivelySetTemplateModel(div, model);
     deliverChanges(model);
     checkExpandos(template.nextNode);
   });
 
   observeTest('Repeat-Empty', () {
     var div = createTestHtml(
         '<template repeat>text</template>');
 
-    var model = toSymbols([0, 1, 2]);
+    var model = toObservable([0, 1, 2]);
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 4);
 
     model.length = 1;
     deliverChanges(model);
     expect(div.nodes.length, 2);
 
-    model.addAll(toSymbols([3, 4]));
+    model.addAll(toObservable([3, 4]));
     deliverChanges(model);
     expect(div.nodes.length, 4);
 
     model.removeRange(1, 2);
     deliverChanges(model);
     expect(div.nodes.length, 3);
   });
 
   observeTest('Removal from iteration needs to unbind', () {
     var div = createTestHtml(
         '<template repeat="{{}}"><a>{{v}}</a></template>');
-    var model = toSymbols([{'v': 0}, {'v': 1}, {'v': 2}, {'v': 3}, {'v': 4}]);
+    var model = toObservable([{'v': 0}, {'v': 1}, {'v': 2}, {'v': 3}, {'v': 4}]);
     recursivelySetTemplateModel(div, model);
     deliverChanges(model);
 
     var nodes = div.nodes.skip(1).toList();
     var vs = model.toList();
 
     for (var i = 0; i < 5; i++) {
       expect(nodes[i].text, '$i');
     }
 
     model.length = 3;
     deliverChanges(model);
     for (var i = 0; i < 5; i++) {
       expect(nodes[i].text, '$i');
     }
 
-    vs[3][#v] = 33;
-    vs[4][#v] = 44;
+    vs[3]['v'] = 33;
+    vs[4]['v'] = 44;
     deliverChanges(model);
     for (var i = 0; i < 5; i++) {
       expect(nodes[i].text, '$i');
     }
   });
 
   observeTest('DOM Stability on Iteration', () {
     var div = createTestHtml(
         '<template repeat="{{}}">{{}}</template>');
-    var model = toSymbols([1, 2, 3, 4, 5]);
+    var model = toObservable([1, 2, 3, 4, 5]);
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
 
     // Note: the node at index 0 is the <template>.
     var nodes = div.nodes.toList();
     expect(nodes.length, 6, reason: 'list has 5 items');
 
     model.removeAt(0);
     model.removeLast();
@@ skipping 30 matching lines @@
     expect(identical(div.nodes[4], nodes[3]), true);
     expect(identical(div.nodes[5], nodes[4]), true);
     expect(identical(div.nodes[6], nodes[5]), true);
   });
 
   observeTest('Repeat2', () {
     var div = createTestHtml(
         '<template repeat="{{}}">{{value}}</template>');
     expect(div.nodes.length, 1);
 
-    var model = toSymbols([
+    var model = toObservable([
       {'value': 0},
       {'value': 1},
       {'value': 2}
     ]);
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 4);
     expect(div.nodes[1].text, '0');
     expect(div.nodes[2].text, '1');
     expect(div.nodes[3].text, '2');
 
-    model[1][#value] = 'One';
+    model[1]['value'] = 'One';
     deliverChanges(model);
     expect(div.nodes.length, 4);
     expect(div.nodes[1].text, '0');
     expect(div.nodes[2].text, 'One');
     expect(div.nodes[3].text, '2');
 
-    model.replaceRange(0, 1, toSymbols([{'value': 'Zero'}]));
+    model.replaceRange(0, 1, toObservable([{'value': 'Zero'}]));
     deliverChanges(model);
     expect(div.nodes.length, 4);
     expect(div.nodes[1].text, 'Zero');
     expect(div.nodes[2].text, 'One');
     expect(div.nodes[3].text, '2');
   });
 
   observeTest('TemplateWithInputValue', () {
     var div = createTestHtml(
         '<template bind="{{}}">'
         '<input value="{{x}}">'
         '</template>');
-    var model = toSymbolMap({'x': 'hi'});
+    var model = toObservable({'x': 'hi'});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 2);
     expect(div.nodes.last.value, 'hi');
 
-    model[#x] = 'bye';
+    model['x'] = 'bye';
     expect(div.nodes.last.value, 'hi');
     deliverChanges(model);
     expect(div.nodes.last.value, 'bye');
 
     div.nodes.last.value = 'hello';
     dispatchEvent('input', div.nodes.last);
-    expect(model[#x], 'hello');
+    expect(model['x'], 'hello');
     deliverChanges(model);
     expect(div.nodes.last.value, 'hello');
   });
 
 //////////////////////////////////////////////////////////////////////////////
 
   observeTest('Decorated', () {
     var div = createTestHtml(
         '<template bind="{{ XX }}" id="t1">'
           '<p>Crew member: {{name}}, Job title: {{title}}</p>'
         '</template>'
         '<template bind="{{ XY }}" id="t2" ref="t1"></template>');
 
-    var model = toSymbolMap({
+    var model = toObservable({
       'XX': {'name': 'Leela', 'title': 'Captain'},
       'XY': {'name': 'Fry', 'title': 'Delivery boy'},
       'XZ': {'name': 'Zoidberg', 'title': 'Doctor'}
     });
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
 
     var t1 = document.getElementById('t1');
     var instance = t1.nextElementSibling;
@@ skipping 16 matching lines @@
 
     document.body.append(t);
     expect(t.getComputedStyle().display, 'none');
 
     t.remove();
   });
 
 
   observeTest('Bind', () {
     var div = createTestHtml('<template bind="{{}}">Hi {{ name }}</template>');
-    var model = toSymbolMap({'name': 'Leela'});
+    var model = toObservable({'name': 'Leela'});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes[1].text, 'Hi Leela');
   });
 
   observeTest('BindImperative', () {
     var div = createTestHtml(
         '<template>'
           'Hi {{ name }}'
         '</template>');
     var t = div.nodes.first;
 
-    var model = toSymbolMap({'name': 'Leela'});
+    var model = toObservable({'name': 'Leela'});
     t.bind('bind', model, '');
 
     deliverChanges(model);
     expect(div.nodes[1].text, 'Hi Leela');
   });
 
   observeTest('BindPlaceHolderHasNewLine', () {
     var div = createTestHtml('<template bind="{{}}">Hi {{\nname\n}}</template>');
-    var model = toSymbolMap({'name': 'Leela'});
+    var model = toObservable({'name': 'Leela'});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes[1].text, 'Hi Leela');
   });
 
   observeTest('BindWithRef', () {
     var id = 't${new math.Random().nextDouble()}';
     var div = createTestHtml(
         '<template id="$id">'
           'Hi {{ name }}'
         '</template>'
         '<template ref="$id" bind="{{}}"></template>');
 
     var t1 = div.nodes.first;
     var t2 = div.nodes[1];
 
     expect(t2.ref, t1);
 
-    var model = toSymbolMap({'name': 'Fry'});
+    var model = toObservable({'name': 'Fry'});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(t2.nextNode.text, 'Hi Fry');
   });
 
   observeTest('BindChanged', () {
-    var model = toSymbolMap({
+    var model = toObservable({
       'XX': {'name': 'Leela', 'title': 'Captain'},
       'XY': {'name': 'Fry', 'title': 'Delivery boy'},
       'XZ': {'name': 'Zoidberg', 'title': 'Doctor'}
     });
 
     var div = createTestHtml(
         '<template bind="{{ XX }}">Hi {{ name }}</template>');
 
     recursivelySetTemplateModel(div, model);
 
@@ skipping 18 matching lines @@
       var targetNode = div.nodes[i + 1];
       expect(targetNode.text, arguments[i]);
     }
   }
 
   observeTest('Repeat3', () {
     var div = createTestHtml(
         '<template repeat="{{ contacts }}">Hi {{ name }}</template>');
     var t = div.nodes.first;
 
-    var m = toSymbols({
+    var m = toObservable({
       'contacts': [
         {'name': 'Raf'},
         {'name': 'Arv'},
         {'name': 'Neal'}
       ]
     });
 
     recursivelySetTemplateModel(div, m);
     deliverChanges(m);
 
     assertNodesAre(div, ['Hi Raf', 'Hi Arv', 'Hi Neal']);
 
-    m[#contacts].add(toSymbols({'name': 'Alex'}));
+    m['contacts'].add(toObservable({'name': 'Alex'}));
     deliverChanges(m);
     assertNodesAre(div, ['Hi Raf', 'Hi Arv', 'Hi Neal', 'Hi Alex']);
 
-    m[#contacts].replaceRange(0, 2,
-        toSymbols([{'name': 'Rafael'}, {'name': 'Erik'}]));
+    m['contacts'].replaceRange(0, 2,
+        toObservable([{'name': 'Rafael'}, {'name': 'Erik'}]));
     deliverChanges(m);
     assertNodesAre(div, ['Hi Rafael', 'Hi Erik', 'Hi Neal', 'Hi Alex']);
 
-    m[#contacts].removeRange(1, 3);
+    m['contacts'].removeRange(1, 3);
     deliverChanges(m);
     assertNodesAre(div, ['Hi Rafael', 'Hi Alex']);
 
-    m[#contacts].insertAll(1,
-        toSymbols([{'name': 'Erik'}, {'name': 'Dimitri'}]));
+    m['contacts'].insertAll(1,
+        toObservable([{'name': 'Erik'}, {'name': 'Dimitri'}]));
     deliverChanges(m);
     assertNodesAre(div, ['Hi Rafael', 'Hi Erik', 'Hi Dimitri', 'Hi Alex']);
 
-    m[#contacts].replaceRange(0, 1,
-        toSymbols([{'name': 'Tab'}, {'name': 'Neal'}]));
+    m['contacts'].replaceRange(0, 1,
+        toObservable([{'name': 'Tab'}, {'name': 'Neal'}]));
     deliverChanges(m);
     assertNodesAre(div, ['Hi Tab', 'Hi Neal', 'Hi Erik', 'Hi Dimitri', 'Hi Alex']);
 
-    m[#contacts] = toSymbols([{'name': 'Alex'}]);
+    m['contacts'] = toObservable([{'name': 'Alex'}]);
     deliverChanges(m);
     assertNodesAre(div, ['Hi Alex']);
 
-    m[#contacts].length = 0;
+    m['contacts'].length = 0;
     deliverChanges(m);
     assertNodesAre(div, []);
   });
 
   observeTest('RepeatModelSet', () {
     var div = createTestHtml(
         '<template repeat="{{ contacts }}">'
           'Hi {{ name }}'
         '</template>');
-    var m = toSymbols({
+    var m = toObservable({
       'contacts': [
         {'name': 'Raf'},
         {'name': 'Arv'},
         {'name': 'Neal'}
       ]
     });
     recursivelySetTemplateModel(div, m);
 
     deliverChanges(m);
     var t = div.nodes.first;
 
     assertNodesAre(div, ['Hi Raf', 'Hi Arv', 'Hi Neal']);
   });
 
   observeTest('RepeatEmptyPath', () {
     var div = createTestHtml('<template repeat="{{}}">Hi {{ name }}</template>');
     var t = div.nodes.first;
 
-    var m = toSymbols([
+    var m = toObservable([
       {'name': 'Raf'},
       {'name': 'Arv'},
       {'name': 'Neal'}
     ]);
     recursivelySetTemplateModel(div, m);
 
     deliverChanges(m);
 
     assertNodesAre(div, ['Hi Raf', 'Hi Arv', 'Hi Neal']);
 
-    m.add(toSymbols({'name': 'Alex'}));
+    m.add(toObservable({'name': 'Alex'}));
     deliverChanges(m);
     assertNodesAre(div, ['Hi Raf', 'Hi Arv', 'Hi Neal', 'Hi Alex']);
 
-    m.replaceRange(0, 2, toSymbols([{'name': 'Rafael'}, {'name': 'Erik'}]));
+    m.replaceRange(0, 2, toObservable([{'name': 'Rafael'}, {'name': 'Erik'}]));
     deliverChanges(m);
     assertNodesAre(div, ['Hi Rafael', 'Hi Erik', 'Hi Neal', 'Hi Alex']);
 
     m.removeRange(1, 3);
     deliverChanges(m);
     assertNodesAre(div, ['Hi Rafael', 'Hi Alex']);
 
-    m.insertAll(1, toSymbols([{'name': 'Erik'}, {'name': 'Dimitri'}]));
+    m.insertAll(1, toObservable([{'name': 'Erik'}, {'name': 'Dimitri'}]));
     deliverChanges(m);
     assertNodesAre(div, ['Hi Rafael', 'Hi Erik', 'Hi Dimitri', 'Hi Alex']);
 
-    m.replaceRange(0, 1, toSymbols([{'name': 'Tab'}, {'name': 'Neal'}]));
+    m.replaceRange(0, 1, toObservable([{'name': 'Tab'}, {'name': 'Neal'}]));
     deliverChanges(m);
     assertNodesAre(div, ['Hi Tab', 'Hi Neal', 'Hi Erik', 'Hi Dimitri', 'Hi Alex']);
 
     m.length = 0;
-    m.add(toSymbols({'name': 'Alex'}));
+    m.add(toObservable({'name': 'Alex'}));
     deliverChanges(m);
     assertNodesAre(div, ['Hi Alex']);
   });
 
   observeTest('RepeatNullModel', () {
     var div = createTestHtml('<template repeat="{{}}">Hi {{ name }}</template>');
     var t = div.nodes.first;
 
     var m = null;
     recursivelySetTemplateModel(div, m);
 
     expect(div.nodes.length, 1);
 
     t.attributes['iterate'] = '';
-    m = toSymbols({});
+    m = toObservable({});
     recursivelySetTemplateModel(div, m);
 
     deliverChanges(m);
     expect(div.nodes.length, 1);
   });
 
   observeTest('RepeatReuse', () {
     var div = createTestHtml('<template repeat="{{}}">Hi {{ name }}</template>');
     var t = div.nodes.first;
 
-    var m = toSymbols([
+    var m = toObservable([
       {'name': 'Raf'},
       {'name': 'Arv'},
       {'name': 'Neal'}
     ]);
     recursivelySetTemplateModel(div, m);
     deliverChanges(m);
 
     assertNodesAre(div, ['Hi Raf', 'Hi Arv', 'Hi Neal']);
     var node1 = div.nodes[1];
     var node2 = div.nodes[2];
     var node3 = div.nodes[3];
 
-    m.replaceRange(1, 2, toSymbols([{'name': 'Erik'}]));
+    m.replaceRange(1, 2, toObservable([{'name': 'Erik'}]));
     deliverChanges(m);
     assertNodesAre(div, ['Hi Raf', 'Hi Erik', 'Hi Neal']);
     expect(div.nodes[1], node1,
         reason: 'model[0] did not change so the node should not have changed');
     expect(div.nodes[2], isNot(equals(node2)),
         reason: 'Should not reuse when replacing');
     expect(div.nodes[3], node3,
         reason: 'model[2] did not change so the node should not have changed');
 
     node2 = div.nodes[2];
-    m.insert(0, toSymbols({'name': 'Alex'}));
+    m.insert(0, toObservable({'name': 'Alex'}));
     deliverChanges(m);
     assertNodesAre(div, ['Hi Alex', 'Hi Raf', 'Hi Erik', 'Hi Neal']);
   });
 
   observeTest('TwoLevelsDeepBug', () {
     var div = createTestHtml(
       '<template bind="{{}}"><span><span>{{ foo }}</span></span></template>');
 
-    var model = toSymbolMap({'foo': 'bar'});
+    var model = toObservable({'foo': 'bar'});
     recursivelySetTemplateModel(div, model);
     deliverChanges(model);
 
     expect(div.nodes[1].nodes[0].nodes[0].text, 'bar');
   });
 
   observeTest('Checked', () {
     var div = createTestHtml(
         '<template>'
           '<input type="checkbox" checked="{{a}}">'
         '</template>');
     var t = div.nodes.first;
-    var m = toSymbols({
+    var m = toObservable({
       'a': true
     });
     t.bind('bind', m, '');
     deliverChanges(m);
 
     var instanceInput = t.nextNode;
     expect(instanceInput.checked, true);
 
     instanceInput.click();
     expect(instanceInput.checked, false);
 
     instanceInput.click();
     expect(instanceInput.checked, true);
   });
 
   nestedHelper(s, start) {
     var div = createTestHtml(s);
 
-    var m = toSymbols({
+    var m = toObservable({
       'a': {
         'b': 1,
         'c': {'d': 2}
       },
     });
 
     recursivelySetTemplateModel(div, m);
     deliverChanges(m);
 
     var i = start;
     expect(div.nodes[i++].text, '1');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, '2');
 
-    m[#a][#b] = 11;
+    m['a']['b'] = 11;
     deliverChanges(m);
     expect(div.nodes[start].text, '11');
 
-    m[#a][#c] = toSymbols({'d': 22});
+    m['a']['c'] = toObservable({'d': 22});
     deliverChanges(m);
     expect(div.nodes[start + 2].text, '22');
   }
 
   observeTest('Nested', () {
     nestedHelper(
         '<template bind="{{a}}">'
           '{{b}}'
           '<template bind="{{c}}">'
             '{{d}}'
           '</template>'
         '</template>', 1);
   });
 
   observeTest('NestedWithRef', () {
     nestedHelper(
         '<template id="inner">{{d}}</template>'
         '<template id="outer" bind="{{a}}">'
           '{{b}}'
           '<template ref="inner" bind="{{c}}"></template>'
         '</template>', 2);
   });
 
   nestedIterateInstantiateHelper(s, start) {
     var div = createTestHtml(s);
 
-    var m = toSymbols({
+    var m = toObservable({
       'a': [
         {
           'b': 1,
           'c': {'d': 11}
         },
         {
           'b': 2,
           'c': {'d': 22}
         }
       ]
     });
 
     recursivelySetTemplateModel(div, m);
     deliverChanges(m);
 
     var i = start;
     expect(div.nodes[i++].text, '1');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, '11');
     expect(div.nodes[i++].text, '2');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, '22');
 
-    m[#a][1] = toSymbols({
+    m['a'][1] = toObservable({
       'b': 3,
       'c': {'d': 33}
     });
 
     deliverChanges(m);
     expect(div.nodes[start + 3].text, '3');
     expect(div.nodes[start + 5].text, '33');
   }
 
   observeTest('NestedRepeatBind', () {
@@ skipping 13 matching lines @@
         '</template>'
         '<template repeat="{{a}}">'
           '{{b}}'
           '<template ref="inner" bind="{{c}}"></template>'
         '</template>', 2);
   });
 
   nestedIterateIterateHelper(s, start) {
     var div = createTestHtml(s);
 
-    var m = toSymbols({
+    var m = toObservable({
       'a': [
         {
           'b': 1,
           'c': [{'d': 11}, {'d': 12}]
         },
         {
           'b': 2,
           'c': [{'d': 21}, {'d': 22}]
         }
       ]
     });
 
     recursivelySetTemplateModel(div, m);
     deliverChanges(m);
 
     var i = start;
     expect(div.nodes[i++].text, '1');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, '11');
     expect(div.nodes[i++].text, '12');
     expect(div.nodes[i++].text, '2');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, '21');
     expect(div.nodes[i++].text, '22');
 
-    m[#a][1] = toSymbols({
+    m['a'][1] = toObservable({
       'b': 3,
       'c': [{'d': 31}, {'d': 32}, {'d': 33}]
     });
 
     i = start + 4;
     deliverChanges(m);
     expect(div.nodes[start + 4].text, '3');
     expect(div.nodes[start + 6].text, '31');
     expect(div.nodes[start + 7].text, '32');
     expect(div.nodes[start + 8].text, '33');
@@ skipping 20 matching lines @@
         '</template>', 2);
   });
 
   observeTest('NestedRepeatSelfRef', () {
     var div = createTestHtml(
         '<template id="t" repeat="{{}}">'
           '{{name}}'
           '<template ref="t" repeat="{{items}}"></template>'
         '</template>');
 
-    var m = toSymbols([
+    var m = toObservable([
       {
         'name': 'Item 1',
         'items': [
           {
             'name': 'Item 1.1',
             'items': [
               {
                  'name': 'Item 1.1.1',
                  'items': []
               }
@@ skipping 17 matching lines @@
     expect(div.nodes[i++].text, 'Item 1');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, 'Item 1.1');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, 'Item 1.1.1');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, 'Item 1.2');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, 'Item 2');
 
-    m[0] = toSymbols({'name': 'Item 1 changed'});
+    m[0] = toObservable({'name': 'Item 1 changed'});
 
     i = 1;
     deliverChanges(m);
     expect(div.nodes[i++].text, 'Item 1 changed');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, 'Item 2');
   });
 
   observeTest('Attribute Template Option/Optgroup', () {
     var div = createTestHtml(
         '<template bind>'
           '<select selectedIndex="{{ selected }}">'
             '<optgroup template repeat="{{ groups }}" label="{{ name }}">'
               '<option template repeat="{{ items }}">{{ val }}</option>'
             '</optgroup>'
           '</select>'
         '</template>');
 
-    var m = toSymbols({
+    var m = toObservable({
       'selected': 1,
       'groups': [{
         'name': 'one', 'items': [{ 'val': 0 }, { 'val': 1 }]
       }],
     });
 
     recursivelySetTemplateModel(div, m);
     deliverChanges(m);
 
     var select = div.nodes[0].nextNode;
@@ skipping 21 matching lines @@
 
     var div = createTestHtml(
         '<table><tbody>'
           '<template repeat="{{}}">'
             '<tr>'
               '<td template repeat="{{}}" class="{{ val }}">{{ val }}</td>'
             '</tr>'
           '</template>'
         '</tbody></table>');
 
-    var m = toSymbols([
+    var m = toObservable([
       [{ 'val': 0 }, { 'val': 1 }],
       [{ 'val': 2 }, { 'val': 3 }]
     ]);
 
     recursivelySetTemplateModel(div, m);
     deliverChanges(m);
 
     var tbody = div.nodes[0].nodes[0];
 
     // 1 for the <tr template>, 2 * (1 tr)
@@ skipping 16 matching lines @@
   });
 
   observeTest('NestedIterateTable', () {
     var div = createTestHtml(
         '<table><tbody>'
           '<tr template repeat="{{}}">'
             '<td template repeat="{{}}" class="{{ val }}">{{ val }}</td>'
           '</tr>'
         '</tbody></table>');
 
-    var m = toSymbols([
+    var m = toObservable([
       [{ 'val': 0 }, { 'val': 1 }],
       [{ 'val': 2 }, { 'val': 3 }]
     ]);
 
     recursivelySetTemplateModel(div, m);
     deliverChanges(m);
 
     var i = 1;
     var tbody = div.nodes[0].nodes[0];
 
@@ skipping 20 matching lines @@
         '<ul>'
           '<template repeat="{{}}" id=t1>'
             '<li>{{name}}'
               '<ul>'
                 '<template ref=t1 repaet="{{items}}"></template>'
               '</ul>'
             '</li>'
           '</template>'
         '</ul>');
 
-    var m = toSymbols([
+    var m = toObservable([
       {
         'name': 'Item 1',
         'items': [
           {
             'name': 'Item 1.1'
           }
         ]
       }
     ]);
 
     recursivelySetTemplateModel(div, m);
 
     deliverChanges(m);
     m.removeAt(0);
     deliverChanges(m);
   });
 
   observeTest('DeepNested', () {
     var div = createTestHtml(
       '<template bind="{{a}}">'
         '<p>'
           '<template bind="{{b}}">'
             '{{ c }}'
           '</template>'
         '</p>'
       '</template>');
 
-    var m = toSymbols({
+    var m = toObservable({
       'a': {
         'b': {
           'c': 42
         }
       }
     });
     recursivelySetTemplateModel(div, m);
     deliverChanges(m);
 
     expect(div.nodes[1].tagName, 'P');
     expect(div.nodes[1].nodes.first.tagName, 'TEMPLATE');
     expect(div.nodes[1].nodes[1].text, '42');
   });
 
   observeTest('TemplateContentRemoved', () {
     var div = createTestHtml('<template bind="{{}}">{{ }}</template>');
     var model = 42;
 
     recursivelySetTemplateModel(div, model);
     deliverChanges(model);
     expect(div.nodes[1].text, '42');
     expect(div.nodes[0].text, '');
   });
 
   observeTest('TemplateContentRemovedEmptyArray', () {
     var div = createTestHtml('<template iterate>Remove me</template>');
-    var model = toSymbols([]);
+    var model = toObservable([]);
 
     recursivelySetTemplateModel(div, model);
     deliverChanges(model);
     expect(div.nodes.length, 1);
     expect(div.nodes[0].text, '');
   });
 
   observeTest('TemplateContentRemovedNested', () {
     var div = createTestHtml(
         '<template bind="{{}}">'
           '{{ a }}'
           '<template bind="{{}}">'
             '{{ b }}'
           '</template>'
         '</template>');
 
-    var model = toSymbolMap({
+    var model = toObservable({
       'a': 1,
       'b': 2
     });
     recursivelySetTemplateModel(div, model);
     deliverChanges(model);
 
     expect(div.nodes[0].text, '');
     expect(div.nodes[1].text, '1');
     expect(div.nodes[2].text, '');
     expect(div.nodes[3].text, '2');
   });
 
   observeTest('BindWithUndefinedModel', () {
     var div = createTestHtml(
         '<template bind="{{}}" if="{{}}">{{ a }}</template>');
 
-    var model = toSymbolMap({'a': 42});
+    var model = toObservable({'a': 42});
     recursivelySetTemplateModel(div, model);
     deliverChanges(model);
     expect(div.nodes[1].text, '42');
 
     model = null;
     recursivelySetTemplateModel(div, model);
     deliverChanges(model);
     expect(div.nodes.length, 1);
 
-    model = toSymbols({'a': 42});
+    model = toObservable({'a': 42});
     recursivelySetTemplateModel(div, model);
     deliverChanges(model);
     expect(div.nodes[1].text, '42');
   });
 
   observeTest('BindNested', () {
     var div = createTestHtml(
         '<template bind="{{}}">'
           'Name: {{ name }}'
           '<template bind="{{wife}}" if="{{wife}}">'
             'Wife: {{ name }}'
           '</template>'
           '<template bind="{{child}}" if="{{child}}">'
             'Child: {{ name }}'
           '</template>'
         '</template>');
 
-    var m = toSymbols({
+    var m = toObservable({
       'name': 'Hermes',
       'wife': {
         'name': 'LaBarbara'
       }
     });
     recursivelySetTemplateModel(div, m);
     deliverChanges(m);
 
     expect(div.nodes.length, 5);
     expect(div.nodes[1].text, 'Name: Hermes');
     expect(div.nodes[3].text, 'Wife: LaBarbara');
 
-    m[#child] = toSymbols({'name': 'Dwight'});
+    m['child'] = toObservable({'name': 'Dwight'});
     deliverChanges(m);
     expect(div.nodes.length, 6);
     expect(div.nodes[5].text, 'Child: Dwight');
 
-    m.remove(#wife);
+    m.remove('wife');
     deliverChanges(m);
     expect(div.nodes.length, 5);
     expect(div.nodes[4].text, 'Child: Dwight');
   });
 
   observeTest('BindRecursive', () {
     var div = createTestHtml(
         '<template bind="{{}}" if="{{}}" id="t">'
           'Name: {{ name }}'
           '<template bind="{{friend}}" if="{{friend}}" ref="t"></template>'
         '</template>');
 
-    var m = toSymbols({
+    var m = toObservable({
       'name': 'Fry',
       'friend': {
         'name': 'Bender'
       }
     });
     recursivelySetTemplateModel(div, m);
     deliverChanges(m);
 
     expect(div.nodes.length, 5);
     expect(div.nodes[1].text, 'Name: Fry');
     expect(div.nodes[3].text, 'Name: Bender');
 
-    m[#friend][#friend] = toSymbols({'name': 'Leela'});
+    m['friend']['friend'] = toObservable({'name': 'Leela'});
     deliverChanges(m);
     expect(div.nodes.length, 7);
     expect(div.nodes[5].text, 'Name: Leela');
 
-    m[#friend] = toSymbols({'name': 'Leela'});
+    m['friend'] = toObservable({'name': 'Leela'});
     deliverChanges(m);
     expect(div.nodes.length, 5);
     expect(div.nodes[3].text, 'Name: Leela');
   });
 
   observeTest('Template - Self is terminator', () {
     var div = createTestHtml(
         '<template repeat>{{ foo }}'
           '<template bind></template>'
         '</template>');
 
-    var m = toSymbols([{ 'foo': 'bar' }]);
+    var m = toObservable([{ 'foo': 'bar' }]);
     recursivelySetTemplateModel(div, m);
     performMicrotaskCheckpoint();
 
-    m.add(toSymbols({ 'foo': 'baz' }));
+    m.add(toObservable({ 'foo': 'baz' }));
     recursivelySetTemplateModel(div, m);
     performMicrotaskCheckpoint();
 
     expect(div.nodes.length, 5);
     expect(div.nodes[1].text, 'bar');
     expect(div.nodes[3].text, 'baz');
   });
 
   observeTest('Template - Same Contents, Different Array has no effect', () {
     if (!MutationObserver.supported) return;
 
     var div = createTestHtml('<template repeat>{{ foo }}</template>');
 
-    var m = toSymbols([{ 'foo': 'bar' }, { 'foo': 'bat'}]);
+    var m = toObservable([{ 'foo': 'bar' }, { 'foo': 'bat'}]);
     recursivelySetTemplateModel(div, m);
     performMicrotaskCheckpoint();
 
     var observer = new MutationObserver((records, _) {});
     observer.observe(div, childList: true);
 
     var template = div.firstChild;
     template.bind('repeat', toObservable(m.toList()), '');
     performMicrotaskCheckpoint();
     var records = observer.takeRecords();
     expect(records.length, 0);
   });
 
   observeTest('RecursiveRef', () {
     var div = createTestHtml(
         '<template bind>'
           '<template id=src>{{ foo }}</template>'
           '<template bind ref=src></template>'
         '</template>');
 
-    var m = toSymbols({'foo': 'bar'});
+    var m = toObservable({'foo': 'bar'});
     recursivelySetTemplateModel(div, m);
     performMicrotaskCheckpoint();
 
     expect(div.nodes.length, 4);
     expect(div.nodes[3].text, 'bar');
   });
 
   observeTest('ChangeFromBindToRepeat', () {
     var div = createTestHtml(
         '<template bind="{{a}}">'
           '{{ length }}'
         '</template>');
     var template = div.nodes.first;
 
     // Note: this test data is a little different from the JS version, because
     // we allow binding to the "length" field of the Map in preference to
     // binding keys.
-    var m = toSymbols({
+    var m = toObservable({
       'a': [
         [],
         { 'b': [1,2,3,4] },
         // Note: this will use the Map "length" property, not the "length" key.
         {'length': 42, 'c': 123}
       ]
     });
     recursivelySetTemplateModel(div, m);
     deliverChanges(m);
 
@@ skipping 16 matching lines @@
     expect(div.nodes[1].text, '4');
   });
 
   observeTest('ChangeRefId', () {
     var div = createTestHtml(
         '<template id="a">a:{{ }}</template>'
         '<template id="b">b:{{ }}</template>'
         '<template repeat="{{}}">'
           '<template ref="a" bind="{{}}"></template>'
         '</template>');
-    var model = toSymbols([]);
+    var model = toObservable([]);
     recursivelySetTemplateModel(div, model);
     deliverChanges(model);
 
     expect(div.nodes.length, 3);
 
     document.getElementById('a').id = 'old-a';
     document.getElementById('b').id = 'a';
 
     model..add(1)..add(2);
     deliverChanges(model);
@@ skipping 41 matching lines @@
     var templateB = templateA.content.nodes.first;
 
     expect(templateB.document, templateA.content.document);
     expect(templateB.content.document, templateA.content.document);
   });
 
   observeTest('BindShadowDOM', () {
     if (ShadowRoot.supported) {
       var root = createShadowTestHtml(
           '<template bind="{{}}">Hi {{ name }}</template>');
-      var model = toSymbolMap({'name': 'Leela'});
+      var model = toObservable({'name': 'Leela'});
       recursivelySetTemplateModel(root, model);
       deliverChanges(model);
       expect(root.nodes[1].text, 'Hi Leela');
     }
   });
 
   observeTest('BindShadowDOM createInstance', () {
     if (ShadowRoot.supported) {
-      var model = toSymbolMap({'name': 'Leela'});
+      var model = toObservable({'name': 'Leela'});
       var template = new Element.html('<template>Hi {{ name }}</template>');
       var root = createShadowTestHtml('');
       root.nodes.add(template.createInstance(model));
 
       performMicrotaskCheckpoint();
       expect(root.text, 'Hi Leela');
 
-      model[#name] = 'Fry';
+      model['name'] = 'Fry';
       performMicrotaskCheckpoint();
       expect(root.text, 'Hi Fry');
     }
   });
 
   observeTest('BindShadowDOM Template Ref', () {
     if (ShadowRoot.supported) {
       var root = createShadowTestHtml(
           '<template id=foo>Hi</template><template bind ref=foo></template>');
-      recursivelySetTemplateModel(root, toSymbolMap({}));
+      recursivelySetTemplateModel(root, toObservable({}));
       performMicrotaskCheckpoint();
       expect(root.nodes.length, 3);
     }
   });
 
   // https://github.com/toolkitchen/mdv/issues/8
   observeTest('UnbindingInNestedBind', () {
     var div = createTestHtml(
       '<template bind="{{outer}}" if="{{outer}}" syntax="testHelper">'
         '<template bind="{{inner}}" if="{{inner}}">'
           '{{ age }}'
         '</template>'
       '</template>');
 
     var syntax = new UnbindingInNestedBindSyntax();
-    var model = toSymbolMap({
+    var model = toObservable({
       'outer': {
         'inner': {
           'age': 42
         }
       }
     });
 
     recursivelySetTemplateModel(div, model, syntax);
 
     deliverChanges(model);
     expect(syntax.count, 1);
 
-    var inner = model[#outer][#inner];
-    model[#outer] = null;
+    var inner = model['outer']['inner'];
+    model['outer'] = null;
 
     deliverChanges(model);
     expect(syntax.count, 1);
 
-    model[#outer] = toSymbols({'inner': {'age': 2}});
+    model['outer'] = toObservable({'inner': {'age': 2}});
     syntax.expectedAge = 2;
 
     deliverChanges(model);
     expect(syntax.count, 2);
   });
 
   // https://github.com/toolkitchen/mdv/issues/8
   observeTest('DontCreateInstancesForAbandonedIterators', () {
     var div = createTestHtml(
       '<template bind="{{}} {{}}">'
         '<template bind="{{}}">Foo'
         '</template>'
       '</template>');
     recursivelySetTemplateModel(div, null);
     performMicrotaskCheckpoint();
   });
 
   observeTest('CreateInstance', () {
     var div = createTestHtml(
       '<template bind="{{a}}">'
         '<template bind="{{b}}">'
           '{{ foo }}:{{ replaceme }}'
         '</template>'
       '</template>');
     var outer = div.nodes.first;
-    var model = toSymbolMap({'b': {'foo': 'bar'}});
+    var model = toObservable({'b': {'foo': 'bar'}});
 
     var host = new DivElement();
     var instance = outer.createInstance(model, new TestBindingSyntax());
     expect(outer.content.nodes.first, instance.nodes.first.ref);
 
     host.append(instance);
     performMicrotaskCheckpoint();
     expect(host.firstChild.nextNode.text, 'bar:replaced');
   });
 
@@ skipping 59 matching lines @@
 }
 
 class UnbindingInNestedBindSyntax extends BindingDelegate {
   int expectedAge = 42;
   int count = 0;
 
   getBinding(model, path, name, node) {
     if (name != 'text' || path != 'age')
       return;
 
-    expect(model[#age], expectedAge);
+    expect(model['age'], expectedAge);
     count++;
   }
 }
 
 /**
  * Verifies that the model is Observable, then calls
  * [performMicrotaskCheckpoint].
  */
 void deliverChanges(model) {
   expectObservable(model);
   performMicrotaskCheckpoint();
 }
 
 void expectObservable(model) {
   if (model is! Observable) {
     // This is here to eagerly catch a bug in the test; it means the test
-    // forgot a toSymbols somewhere.
-    expect(identical(toSymbols(model), model), true,
+    // forgot a toObservable somewhere.
+    expect(identical(toObservable(model), model), true,
         reason: 'model type "${model.runtimeType}" should be observable');
     return;
   }
   if (model is ObservableList) {
     for (var item in model) {
       expectObservable(item);
     }
   } else if (model is ObservableMap) {
     model.forEach((k, v) {
       expectObservable(k);
       expectObservable(v);
     });
   }
 }
 
-toSymbols(obj) => toObservable(_deepToSymbol(obj));
-
 _deepToSymbol(value) {
   if (value is Map) {
     var result = new LinkedHashMap();
     value.forEach((k, v) {
       k = k is String ? new Symbol(k) : _deepToSymbol(k);
       result[k] = _deepToSymbol(v);
     });
     return result;
   }
   if (value is Iterable) {
     return value.map(_deepToSymbol).toList();
   }
   return value;
 }
 
 /**
  * Sanitizer which does nothing.
  */
 class NullTreeSanitizer implements NodeTreeSanitizer {
   void sanitizeTree(Node node) {}
 }