Reapply change that makes path-observer more agressive with property lookups.

pkg/template_binding/test/template_binding_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_binding.test.template_binding_test;
 
 import 'dart:async';
 import 'dart:html';
 import 'dart:math' as math;
 import 'package:observe/observe.dart';
@@ skipping 139 matching lines @@
     var div = createTestHtml(
         '<template bind="{{ bound }}" if="{{ predicate }}">'
           'value:{{ value }}'
         '</template>');
     // Dart note: predicate changed from 0->null because 0 isn't falsey in Dart.
     // See https://code.google.com/p/dart/issues/detail?id=11956
     // Changed bound from null->1 since null is equivalent to JS undefined,
     // and would cause the template to not be expanded.
     var m = toObservable({ 'predicate': null, 'bound': 1 });
     var template = div.firstChild;
-    templateBind(template).model = m;
+    bool errorSeen = false;
+    runZoned(() {
+      templateBind(template).model = m;
+    }, onError: (e, s) {
+      expect(e, isNoSuchMethodError);
+      errorSeen = true;
+    });
     return new Future(() {
       expect(div.nodes.length, 1);
 
       m['predicate'] = 1;
 
-    }).then(endOfMicrotask).then((_) {
-      expect(div.nodes.length, 2);
-      expect(div.lastChild.text, 'value:');
+      expect(errorSeen, isFalse);
+    }).then(nextMicrotask).then((_) {
+      expect(errorSeen, isTrue);
+      expect(div.nodes.length, 1);
 
       m['bound'] = toObservable({ 'value': 2 });
 
     }).then(endOfMicrotask).then((_) {
       expect(div.nodes.length, 2);
       expect(div.lastChild.text, 'value:2');
 
       m['bound']['value'] = 3;
 
     }).then(endOfMicrotask).then((_) {
@@ skipping 48 matching lines @@
   test('Bind oneTime-If - predicate true', () {
     var div = createTestHtml(
         '<template bind="{{ bound }}" if="[[ predicate ]]">'
           'value:{{ value }}'
         '</template>');
 
     // Dart note: changed bound from null->1 since null is equivalent to JS
     // undefined, and would cause the template to not be expanded.
     var m = toObservable({ 'predicate': 1, 'bound': 1 });
     var template = div.firstChild;
-    templateBind(template).model = m;
+    bool errorSeen = false;
+    runZoned(() {
+      templateBind(template).model = m;
+    }, onError: (e, s) {
+      expect(e, isNoSuchMethodError);
+      errorSeen = true;
+    });
 
     return new Future(() {
-      expect(div.nodes.length, 2);
-      expect(div.lastChild.text, 'value:');
-
+      expect(div.nodes.length, 1);
       m['bound'] = toObservable({ 'value': 2 });
-
+      expect(errorSeen, isTrue);
     }).then(endOfMicrotask).then((_) {
       expect(div.nodes.length, 2);
       expect(div.lastChild.text, 'value:2');
 
       m['bound']['value'] = 3;
 
     }).then(endOfMicrotask).then((_) {
       expect(div.nodes.length, 2);
       expect(div.lastChild.text, 'value:3');
 
@@ skipping 1937 matching lines @@
     var instance = outer.createInstance(model, new TestBindingSyntax());
     expect(outer.content.nodes.first,
         templateBind(instance.nodes.first).ref);
 
     host.append(instance);
     return new Future(() {
       expect(host.firstChild.nextNode.text, 'bar:replaced');
     });
   });
 
+  test('CreateInstance - sync error', () {
+    var div = createTestHtml('<template bind="{{}}">{{foo}}</template>');
+    var outer = templateBind(div.nodes.first);
+    var model = 1; // model is missing 'foo' should throw.
+    expect(() => outer.createInstance(model, new TestBindingSyntax()),
+        throwsA(isNoSuchMethodError));
+  });
+
+  test('CreateInstance - async error', () {
+    var div = createTestHtml(
+      '<template bind="{{a}}">'
+        '<template bind="{{b}}">'
+          '{{ foo }}:{{ replaceme }}'
+        '</template>'
+      '</template>');
+    var outer = templateBind(div.nodes.first);
+    var model = toObservable({'b': 1}); // missing 'foo' should throw.
+
+    bool seen = false;
+    runZoned(() => outer.createInstance(model, new TestBindingSyntax()),

[Siggi Cherem (dart-lang), 2014/03/26 22:36:17]

I'm not 100% convinced about having some errors being sync and some async.
Alternatively we could rework template-binding to throw and undo the changes it
was mid-way through, or finish processing the rest, but rethrow at the end of
that process. Thoughts?

+      onError: (e) {
+        expect(e, isNoSuchMethodError);
+        seen = true;
+      });
+    return new Future(() { expect(seen, isTrue); });
+  });
+
   test('Repeat - svg', () {
     var div = createTestHtml(
         '<svg width="400" height="110">'
           '<template repeat>'
             '<rect width="{{ width }}" height="{{ height }}" />'
           '</template>'
         '</svg>');
 
     var model = toObservable([{ 'width': 10, 'height': 11 },
                               { 'width': 20, 'height': 21 }]);
@@ skipping 183 matching lines @@
   }
 }
 
 class Issue18Syntax extends BindingDelegate {
   prepareBinding(path, name, node) {
     if (name != 'class') return null;
 
     return (model, _, oneTime) => new PathObserver(model, path);
   }
 }