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

pkg/template_binding/test/template_binding_test.dart

Index: pkg/template_binding/test/template_binding_test.dart
diff --git a/pkg/template_binding/test/template_binding_test.dart b/pkg/template_binding/test/template_binding_test.dart
index c2ac5a959303de8c13a974f6ac00612cb0837628..a87bcd67d8b4890b18cda2e053c344023780d6ce 100644
--- a/pkg/template_binding/test/template_binding_test.dart
+++ b/pkg/template_binding/test/template_binding_test.dart
@@ -157,15 +157,22 @@ templateInstantiationTests() {
     // 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 });
 
@@ -234,14 +241,18 @@ templateInstantiationTests() {
     // 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');
@@ -2199,6 +2210,33 @@ templateInstantiationTests() {
     });
   });
 
+  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">'