refactor($parse): don't use bind-once interceptor for non-bind-once expressions

Side-effects:
  - Logic for allOrNothing watches now lives in $intercept rather than $parse

Closes angular#9958

Author: caitp

src/ng/compile.js

@@ -1936,7 +1936,6 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
                   }
                   return lastValue = parentValue;
                 };
-                parentValueWatch.$stateful = true;
                 var unwatch;
                 if (definition.collection) {
                   unwatch = scope.$watchCollection(attrs[attrName], parentValueWatch);

src/ng/interpolate.js

@@ -192,7 +192,9 @@ function $InterpolateProvider() {
           textLength = text.length,
           exp,
           concat = [],
-          expressionPositions = [];
+          expressionPositions = [],
+          interceptor = allOrNothing ? allOrNothingParseStringifyInterceptor :
+              parseStringifyInterceptor;
 
       while (index < textLength) {
         if (((startIndex = text.indexOf(startSymbol, index)) != -1) &&
@@ -202,7 +204,7 @@ function $InterpolateProvider() {
           }
           exp = text.substring(startIndex + startSymbolLength, endIndex);
           expressions.push(exp);
-          parseFns.push($parse(exp, parseStringifyInterceptor));
+          parseFns.push($parse(exp, interceptor));
           index = endIndex + endSymbolLength;
           expressionPositions.push(concat.length);
           concat.push('');
@@ -231,7 +233,9 @@ function $InterpolateProvider() {
       if (!mustHaveExpression || expressions.length) {
         var compute = function(values) {
           for (var i = 0, ii = expressions.length; i < ii; i++) {
-            if (allOrNothing && isUndefined(values[i])) return;
+            if (allOrNothing && isUndefined(values[i])) {
+              return;
+            }
             concat[expressionPositions[i]] = values[i];
           }
           return concat.join('');
@@ -308,6 +312,20 @@ function $InterpolateProvider() {
           $exceptionHandler(newErr);
         }
       }
+
+      function allOrNothingParseStringifyInterceptor(value) {
+        try {
+          value = getValue(value);
+          if (isDefined(value)) {
+            value = stringify(value);
+          }
+          return value;
+        } catch (err) {
+          var newErr = $interpolateMinErr('interr', "Can't interpolate: {0}\n{1}", text,
+            err.toString());
+          $exceptionHandler(newErr);
+        }
+      }
     }
 
 

src/ng/parse.js

@@ -1253,13 +1253,22 @@ function $ParseProvider() {
 
     function addInterceptor(parsedExpression, interceptorFn) {
       if (!interceptorFn) return parsedExpression;
+      var watchDelegate = parsedExpression.$$watchDelegate;
 
-      var fn = function interceptedExpression(scope, locals) {
+      var regularWatch =
+          watchDelegate !== oneTimeLiteralWatchDelegate &&
+          watchDelegate !== oneTimeWatchDelegate;
+
+      var fn = regularWatch ? function regularInterceptedExpression(scope, locals) {
+        var value = parsedExpression(scope, locals);
+        var result = interceptorFn(value, scope, locals);
+        return result;
+      } : function oneTimeInterceptedExpression(scope, locals) {
         var value = parsedExpression(scope, locals);
         var result = interceptorFn(value, scope, locals);
         // we only return the interceptor's result if the
         // initial value is defined (for bind-once)
-        return isDefined(value) || interceptorFn.$stateful ? result : value;
+        return isDefined(value) ? result : value;
       };
 
       // Propagate $$watchDelegates other then inputsWatchDelegate