Add warning to then()

When debugging, warn when then is passed something
but nothing is a function

src/call_get.js

@@ -66,12 +66,11 @@ getGetter = function(name) {
 };
 }
 
-var classString= {}.toString;
 function ensureMethod(obj, methodName) {
     var fn;
     if (obj != null) fn = obj[methodName];
     if (typeof fn !== "function") {
-        var message = "Object " + classString.call(obj) + " has no method '" +
+        var message = "Object " + util.classString(obj) + " has no method '" +
             util.toString(methodName) + "'";
         throw new Promise.TypeError(message);
     }

src/debuggability.js

@@ -1,6 +1,7 @@
 "use strict";
 module.exports = function(Promise, CapturedTrace) {
 var async = require("./async.js");
+var Warning = require("./errors.js").Warning;
 var util = require("./util.js");
 var ASSERT = require("./assert.js");
 var canAttachTrace = util.canAttachTrace;
@@ -110,6 +111,18 @@ Promise.prototype._attachExtraTrace = function (error, ignoreSelf) {
     }
 };
 
+Promise.prototype._warn = function(message) {
+    var warning = new Warning(message);
+    var ctx = this._peekContext();
+    if (ctx) {
+        ctx.attachExtraTrace(warning);
+    } else {
+        var parsed = CapturedTrace.parseStackAndMessage(warning);
+        warning.stack = parsed.message + "\n" + parsed.stack.join("\n");
+    }
+    CapturedTrace.formatAndLogError(warning, "");
+};
+
 Promise.onPossiblyUnhandledRejection = function (fn) {
     possiblyUnhandledRejection = typeof fn === "function" ? fn : undefined;
 };

src/errors.js

@@ -12,13 +12,16 @@ function subError(nameProperty, defaultMessage) {
         notEnumerableProp(this, "name", nameProperty);
         if (Error.captureStackTrace) {
             Error.captureStackTrace(this, this.constructor);
+        } else {
+            Error.call(this);
         }
     }
     inherits(SubError, Error);
     return SubError;
 }
 
 var _TypeError, _RangeError;
+var Warning = subError("Warning", "warning");
 var CancellationError = subError("CancellationError", "cancellation error");
 var TimeoutError = subError("TimeoutError", "timeout error");
 var AggregateError = subError("AggregateError", "aggregate error");
@@ -98,5 +101,6 @@ module.exports = {
     CancellationError: errorTypes.CancellationError,
     OperationalError: errorTypes.OperationalError,
     TimeoutError: errorTypes.TimeoutError,
-    AggregateError: errorTypes.AggregateError
+    AggregateError: errorTypes.AggregateError,
+    Warning: Warning
 };

src/promise.js

@@ -96,11 +96,20 @@ Promise.prototype.reflect = function () {
 };
 
 Promise.prototype.then = function (didFulfill, didReject, didProgress) {
+    if (isDebugging() && arguments.length > 0 &&
+        typeof didFulfill !== "function" &&
+        typeof didReject !== "function") {
+        var msg = ".then() only accepts functions but was passed: " +
+                util.classString(didFulfill);
+        if (arguments.length > 1) {
+            msg += ", " + util.classString(didReject);
+        }
+        this._warn(msg);
+    }
     return this._then(didFulfill, didReject, didProgress,
         undefined, undefined);
 };
 
-
 Promise.prototype.done = function (didFulfill, didReject, didProgress) {
     var promise = this._then(didFulfill, didReject, didProgress,
         undefined, undefined);

src/util.js

@@ -239,6 +239,10 @@ var ensureErrorObject = (function() {
     }
 })();
 
+function classString(obj) {
+    return {}.toString.call(obj);
+}
+
 var ret = {
     isClass: isClass,
     isIdentifier: isIdentifier,
@@ -264,7 +268,8 @@ var ret = {
     canAttachTrace: canAttachTrace,
     ensureErrorObject: ensureErrorObject,
     originatesFromRejection: originatesFromRejection,
-    markAsOriginatingFromRejection: markAsOriginatingFromRejection
+    markAsOriginatingFromRejection: markAsOriginatingFromRejection,
+    classString: classString
 };
 try {throw new Error(); } catch (e) {ret.lastLineError = e;}
 module.exports = ret;