fix(scopes): don't break one time ngbind expressions

Author: erwinmombay

dist/hint.js

@@ -1410,14 +1410,36 @@ function decorateRootScope($delegate, $parse) {
 
   var _watch = scopePrototype.$watch;
   var _digestEvents = [];
+  var skipNextPerfWatchers = false;
   scopePrototype.$watch = function (watchExpression, reactionFunction) {
+    // if `skipNextPerfWatchers` is true, this means the previous run of the
+    // `$watch` decorator was a one time binding expression and this invocation
+    // of the $watch function has the `oneTimeInterceptedExpression` (internal angular function)
+    // as the `watchExpression` parameter. If we decorate it with the performance
+    // timers function this will cause us to invoke `oneTimeInterceptedExpression`
+    // on subsequent digest loops and will update the one time bindings
+    // if anything mutated the property.
+    if (skipNextPerfWatchers) {
+      skipNextPerfWatchers = false;
+      return _watch.apply(this, arguments);
+    }
+
     if (typeof watchExpression === 'string' &&
         isOneTimeBindExp(watchExpression)) {
+      skipNextPerfWatchers = true;
       return _watch.apply(this, arguments);
     }
     var watchStr = humanReadableWatchExpression(watchExpression);
     var scopeId = this.$id;
+    var expressions = null;
     if (typeof watchExpression === 'function') {
+      expressions = watchExpression.expressions;
+      if (Object.prototype.toString.call(expressions) === '[object Array]' &&
+          expressions.some(isOneTimeBindExp)) {
+        skipNextPerfWatchers = true;
+        return _watch.apply(this, arguments);
+      }
+
       arguments[0] = function () {
         var start = perf.now();
         var ret = watchExpression.apply(this, arguments);

src/modules/scopes.js

@@ -77,14 +77,36 @@ function decorateRootScope($delegate, $parse) {
 
   var _watch = scopePrototype.$watch;
   var _digestEvents = [];
+  var skipNextPerfWatchers = false;
   scopePrototype.$watch = function (watchExpression, reactionFunction) {
+    // if `skipNextPerfWatchers` is true, this means the previous run of the
+    // `$watch` decorator was a one time binding expression and this invocation
+    // of the $watch function has the `oneTimeInterceptedExpression` (internal angular function)
+    // as the `watchExpression` parameter. If we decorate it with the performance
+    // timers function this will cause us to invoke `oneTimeInterceptedExpression`
+    // on subsequent digest loops and will update the one time bindings
+    // if anything mutated the property.
+    if (skipNextPerfWatchers) {
+      skipNextPerfWatchers = false;
+      return _watch.apply(this, arguments);
+    }
+
     if (typeof watchExpression === 'string' &&
         isOneTimeBindExp(watchExpression)) {
+      skipNextPerfWatchers = true;
       return _watch.apply(this, arguments);
     }
     var watchStr = humanReadableWatchExpression(watchExpression);
     var scopeId = this.$id;
+    var expressions = null;
     if (typeof watchExpression === 'function') {
+      expressions = watchExpression.expressions;
+      if (Object.prototype.toString.call(expressions) === '[object Array]' &&
+          expressions.some(isOneTimeBindExp)) {
+        skipNextPerfWatchers = true;
+        return _watch.apply(this, arguments);
+      }
+
       arguments[0] = function () {
         var start = perf.now();
         var ret = watchExpression.apply(this, arguments);

test/scopes.spec.js

@@ -3,11 +3,12 @@
 var hint = angular.hint;
 describe('ngHintScopes', function() {
 
-  var $rootScope;
+  var $rootScope, $compile;
 
   beforeEach(module('ngHintScopes'));
-  beforeEach(inject(function(_$rootScope_) {
+  beforeEach(inject(function(_$rootScope_, _$compile_) {
     $rootScope = _$rootScope_;
+    $compile = _$compile_;
   }));
 
   describe('scope.$watch', function() {
@@ -52,24 +53,34 @@ describe('ngHintScopes', function() {
     });
 
     if (angular.version.minor >= 3) {
-      it('should not run perf timers for one time bind expressions', function() {
+      it('should not run perf timers for one time bind expressions passed to watch', function() {
         var calls = hint.emit.calls;
         scope.$watch('::a.b', function() {});
         expect(calls.count()).toBe(0);
 
         scope.$apply();
         var evt = calls.mostRecent().args[1].events[0];
-        // this is the watch angular registers and deregisters on $$postDigest
-        // for one time watch expressions
         expect(calls.count()).toBe(1);
-        expect(evt.eventType).toBe('scope:watch');
-        expect(evt.watch).toBe('oneTimeWatch');
-
-        scope.$apply()
-        var evt = calls.mostRecent().args[1].events[0];
-        expect(calls.count()).toBe(2);
         expect(evt).toBeUndefined();
       });
+
+      it('should not run perf timers for one time template bindings', function() {
+        var elt = angular.element(
+          '<div>' +
+          '<span>{{::a}}</span>' +
+          '<button ng-click="a = \'bar\'">Set</button>' +
+          '</div>'
+        );
+        scope.a = 'foo';
+        var view = $compile(elt)(scope);
+        scope.$apply();
+        var $binding = view.find('span');
+        var $button = view.find('button');
+
+        $button.triggerHandler('click');
+        scope.$apply();
+        expect($binding.text()).toBe('foo');
+      });
     }
 
     // the event's time property is set to null before comparison with expectedEvent, so callers