use symbol literals instead of const ctor in packages

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 107 matching lines @@
 
   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 });
     recursivelySetTemplateModel(div, m);
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 1);
 
-    m[sym('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' } });
     recursivelySetTemplateModel(div, m);
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 1);
 
-    m[sym('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' });
     recursivelySetTemplateModel(div, m);
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 1);
 
-    m[sym('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] });
     recursivelySetTemplateModel(div, m);
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 1);
 
-    m[sym('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'});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'aBc');
 
-    model[sym('b')] = 'b';
+    model[#b] = 'b';
     deliverChanges(model);
     expect(div.nodes.last.text, 'abc');
 
-    model[sym('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'} });
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'aBc');
 
-    model[sym('data')][sym('b')] = 'b';
+    model[#data][#b] = 'b';
     deliverChanges(model);
     expect(div.nodes.last.text, 'abc');
 
-    model[sym('data')] = toSymbols({'b': 'X'});
+    model[#data] = toSymbols({'b': 'X'});
     deliverChanges(model);
     expect(div.nodes.last.text, 'aXc');
 
-    model[sym('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});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'aBc');
 
-    model[sym('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[sym('d')] = null;
+    model[#d] = null;
     deliverChanges(model);
     expect(div.nodes.length, 1);
 
-    model[sym('d')] = 'here';
-    model[sym('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'}});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'aBc');
 
-    model[sym('b')] = toSymbols({'value': 'b'});
+    model[#b] = toSymbols({'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'});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 2);
     expect(div.nodes.last.attributes['foo'], 'aBc');
 
-    model[sym('b')] = 'b';
+    model[#b] = 'b';
     deliverChanges(model);
     expect(div.nodes.last.attributes['foo'], 'abc');
 
-    model[sym('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'});
     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[sym('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]);
     recursivelySetTemplateModel(div, model);
@@ skipping 26 matching lines @@
     ]);
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 6);
     var template = div.firstChild;
 
     addExpandos(template.nextNode);
     checkExpandos(template.nextNode);
 
-    final VAL = const Symbol('val');
-    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 53 matching lines @@
     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][sym('v')] = 33;
-    vs[4][sym('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]);
@@ skipping 53 matching lines @@
       {'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][sym('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'}]));
     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'});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes.length, 2);
     expect(div.nodes.last.value, 'hi');
 
-    model[sym('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[sym('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>'
@@ skipping 133 matching lines @@
         {'name': 'Arv'},
         {'name': 'Neal'}
       ]
     });
 
     recursivelySetTemplateModel(div, m);
     deliverChanges(m);
 
     assertNodesAre(div, ['Hi Raf', 'Hi Arv', 'Hi Neal']);
 
-    m[sym('contacts')].add(toSymbols({'name': 'Alex'}));
+    m[#contacts].add(toSymbols({'name': 'Alex'}));
     deliverChanges(m);
     assertNodesAre(div, ['Hi Raf', 'Hi Arv', 'Hi Neal', 'Hi Alex']);
 
-    m[sym('contacts')].replaceRange(0, 2,
+    m[#contacts].replaceRange(0, 2,
         toSymbols([{'name': 'Rafael'}, {'name': 'Erik'}]));
     deliverChanges(m);
     assertNodesAre(div, ['Hi Rafael', 'Hi Erik', 'Hi Neal', 'Hi Alex']);
 
-    m[sym('contacts')].removeRange(1, 3);
+    m[#contacts].removeRange(1, 3);
     deliverChanges(m);
     assertNodesAre(div, ['Hi Rafael', 'Hi Alex']);
 
-    m[sym('contacts')].insertAll(1,
+    m[#contacts].insertAll(1,
         toSymbols([{'name': 'Erik'}, {'name': 'Dimitri'}]));
     deliverChanges(m);
     assertNodesAre(div, ['Hi Rafael', 'Hi Erik', 'Hi Dimitri', 'Hi Alex']);
 
-    m[sym('contacts')].replaceRange(0, 1,
+    m[#contacts].replaceRange(0, 1,
         toSymbols([{'name': 'Tab'}, {'name': 'Neal'}]));
     deliverChanges(m);
     assertNodesAre(div, ['Hi Tab', 'Hi Neal', 'Hi Erik', 'Hi Dimitri', 'Hi Alex']);
 
-    m[sym('contacts')] = toSymbols([{'name': 'Alex'}]);
+    m[#contacts] = toSymbols([{'name': 'Alex'}]);
     deliverChanges(m);
     assertNodesAre(div, ['Hi Alex']);
 
-    m[sym('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({
@@ skipping 146 matching lines @@
     });
 
     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[sym('a')][sym('b')] = 11;
+    m[#a][#b] = 11;
     deliverChanges(m);
     expect(div.nodes[start].text, '11');
 
-    m[sym('a')][sym('c')] = toSymbols({'d': 22});
+    m[#a][#c] = toSymbols({'d': 22});
     deliverChanges(m);
     expect(div.nodes[start + 2].text, '22');
   }
 
   observeTest('Nested', () {
     nestedHelper(
         '<template bind="{{a}}">'
           '{{b}}'
           '<template bind="{{c}}">'
             '{{d}}'
@@ skipping 30 matching lines @@
     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[sym('a')][1] = toSymbols({
+    m[#a][1] = toSymbols({
       'b': 3,
       'c': {'d': 33}
     });
 
     deliverChanges(m);
     expect(div.nodes[start + 3].text, '3');
     expect(div.nodes[start + 5].text, '33');
   }
 
   observeTest('NestedRepeatBind', () {
@@ skipping 39 matching lines @@
     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[sym('a')][1] = toSymbols({
+    m[#a][1] = toSymbols({
       '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 327 matching lines @@
         '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[sym('child')] = toSymbols({'name': 'Dwight'});
+    m[#child] = toSymbols({'name': 'Dwight'});
     deliverChanges(m);
     expect(div.nodes.length, 6);
     expect(div.nodes[5].text, 'Child: Dwight');
 
-    m.remove(sym('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({
       '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[sym('friend')][sym('friend')] = toSymbols({'name': 'Leela'});
+    m[#friend][#friend] = toSymbols({'name': 'Leela'});
     deliverChanges(m);
     expect(div.nodes.length, 7);
     expect(div.nodes[5].text, 'Name: Leela');
 
-    m[sym('friend')] = toSymbols({'name': 'Leela'});
+    m[#friend] = toSymbols({'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>');
@@ skipping 164 matching lines @@
   observeTest('BindShadowDOM createInstance', () {
     if (ShadowRoot.supported) {
       var model = toSymbolMap({'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[sym('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({}));
@@ skipping 18 matching lines @@
           'age': 42
         }
       }
     });
 
     recursivelySetTemplateModel(div, model, syntax);
 
     deliverChanges(model);
     expect(syntax.count, 1);
 
-    var inner = model[sym('outer')][sym('inner')];
-    model[sym('outer')] = null;
+    var inner = model[#outer][#inner];
+    model[#outer] = null;
 
     deliverChanges(model);
     expect(syntax.count, 1);
 
-    model[sym('outer')] = toSymbols({'inner': {'age': 2}});
+    model[#outer] = toSymbols({'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="{{}} {{}}">'
@@ skipping 85 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[sym('age')], expectedAge);
+    expect(model[#age], expectedAge);
     count++;
   }
 }
 
 /**
  * Verifies that the model is Observable, then calls
  * [performMicrotaskCheckpoint].
  */
 void deliverChanges(model) {
   expectObservable(model);
@@ skipping 15 matching lines @@
   } else if (model is ObservableMap) {
     model.forEach((k, v) {
       expectObservable(k);
       expectObservable(v);
     });
   }
 }
 
 toSymbols(obj) => toObservable(_deepToSymbol(obj));
 
-sym(x) => new Symbol(x);
-
 _deepToSymbol(value) {
   if (value is Map) {
     var result = new LinkedHashMap();
     value.forEach((k, v) {
-      k = k is String ? sym(k) : _deepToSymbol(k);
+      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) {}
 }