diff --git a/src/ng/parse.js b/src/ng/parse.js
index 58ddca7e1e46..f2bb16617091 100644
--- a/src/ng/parse.js
+++ b/src/ng/parse.js
@@ -946,6 +946,12 @@ function getterFn(path, options, fullExp) {
   return fn;
 }
 
+var objectValueOf = Object.prototype.valueOf;
+
+function getValueOf(value) {
+  return isFunction(value.valueOf) ? value.valueOf() : objectValueOf.call(value);
+}
+
 ///////////////////////////////////
 
 /**
@@ -1092,7 +1098,7 @@ function $ParseProvider() {
         // attempt to convert the value to a primitive type
         // TODO(docs): add a note to docs that by implementing valueOf even objects and arrays can
         //             be cheaply dirty-checked
-        newValue = newValue.valueOf();
+        newValue = getValueOf(newValue);
 
         if (typeof newValue === 'object') {
           // objects/arrays are not supported - deep-watching them would be too expensive
@@ -1119,7 +1125,7 @@ function $ParseProvider() {
           var newInputValue = inputExpressions(scope);
           if (!expressionInputDirtyCheck(newInputValue, oldInputValue)) {
             lastResult = parsedExpression(scope);
-            oldInputValue = newInputValue && newInputValue.valueOf();
+            oldInputValue = newInputValue && getValueOf(newInputValue);
           }
           return lastResult;
         }, listener, objectEquality);
@@ -1136,7 +1142,7 @@ function $ParseProvider() {
         for (var i = 0, ii = inputExpressions.length; i < ii; i++) {
           var newInputValue = inputExpressions[i](scope);
           if (changed || (changed = !expressionInputDirtyCheck(newInputValue, oldInputValueOfValues[i]))) {
-            oldInputValueOfValues[i] = newInputValue && newInputValue.valueOf();
+            oldInputValueOfValues[i] = newInputValue && getValueOf(newInputValue);
           }
         }
 
diff --git a/test/ng/parseSpec.js b/test/ng/parseSpec.js
index cc36b35a483b..e274c835884f 100644
--- a/test/ng/parseSpec.js
+++ b/test/ng/parseSpec.js
@@ -1460,6 +1460,32 @@ describe('parser', function() {
           expect(watcherCalls).toBe(1);
         }));
 
+        it("should always reevaluate filters with non-primitive input created with null prototype",
+            inject(function($parse) {
+          var filterCalls = 0;
+          $filterProvider.register('foo', valueFn(function(input) {
+            filterCalls++;
+            return input;
+          }));
+
+          var parsed = $parse('obj | foo');
+          var obj = scope.obj = Object.create(null);
+
+          var watcherCalls = 0;
+          scope.$watch(parsed, function(input) {
+            expect(input).toBe(obj);
+            watcherCalls++;
+          });
+
+          scope.$digest();
+          expect(filterCalls).toBe(2);
+          expect(watcherCalls).toBe(1);
+
+          scope.$digest();
+          expect(filterCalls).toBe(3);
+          expect(watcherCalls).toBe(1);
+        }));
+
         it("should not reevaluate filters with non-primitive input that does support valueOf()",
             inject(function($parse) {
           var filterCalls = 0;