fix(errors): Custom RxJS errors now all have a call stack

NOTE: Because we have to workaround compilation-to-ES5 inadequacies until call stack locations will show as being inside of the constructor impelementation at the top level. This will go away as we are able to move the community to ES2015+

BREAKING CHANGE: Tests that are written with naive expectations against errors may fail now that errors have a proper `stack` property. In some testing frameworks, a deep equality check on two error instances will check the values in `stack`, which could be different.

fixes ReactiveX#4250

spec/helpers/test-helper.ts

@@ -60,14 +60,4 @@ export const createObservableInputs = <T>(value: T) => of(
 /**
  * Used to signify no subscriptions took place to `expectSubscriptions` assertions.
  */
-export const NO_SUBS: string[] = [];
-
-/**
- * Does a deep equality assertion. Used to set up {@link TestScheduler}, so that
- * trees of marbles can be compared.
- * @param actual The value to run the expectation against.
- * @param expected The value expected.
- */
-export function assertDeepEquals (actual: any, expected: any) {
-  expect(actual).to.deep.equal(expected);
-}
+export const NO_SUBS: string[] = [];

spec/operators/concatWith-spec.ts

@@ -2,14 +2,15 @@ import { expect } from 'chai';
 import { of, Observable } from 'rxjs';
 import { concatWith, mergeMap, take } from 'rxjs/operators';
 import { TestScheduler } from 'rxjs/testing';
-import { assertDeepEquals, NO_SUBS } from '../helpers/test-helper';
+import { NO_SUBS } from '../helpers/test-helper';
+import { observableMatcher } from '../helpers/observableMatcher';
 
 /** @test {concat} */
 describe('concat operator', () => {
   let rxTest: TestScheduler;
 
   beforeEach(() => {
-    rxTest = new TestScheduler(assertDeepEquals);
+    rxTest = new TestScheduler(observableMatcher);
   });
 
   it('should concatenate two cold observables', () => {

spec/operators/single-spec.ts

@@ -2,14 +2,14 @@ import { expect } from 'chai';
 import { single, mergeMap, tap } from 'rxjs/operators';
 import { of, EmptyError, SequenceError, NotFoundError, Observable } from 'rxjs';
 import { TestScheduler } from 'rxjs/testing';
-import { assertDeepEquals } from '../helpers/test-helper';
+import { observableMatcher } from '../helpers/observableMatcher';
 
 /** @test {single} */
 describe('single operator', () => {
   let rxTest: TestScheduler;
 
   beforeEach(() => {
-    rxTest = new TestScheduler(assertDeepEquals);
+    rxTest = new TestScheduler(observableMatcher);
   });
 
   it('should raise error from empty predicate if observable emits multiple time', () => {

spec/operators/takeLast-spec.ts

@@ -2,14 +2,14 @@ import { expect } from 'chai';
 import { takeLast, mergeMap } from 'rxjs/operators';
 import { range, ArgumentOutOfRangeError, of } from 'rxjs';
 import { TestScheduler } from 'rxjs/testing';
-import { assertDeepEquals } from '../helpers/test-helper';
+import { observableMatcher } from '../helpers/observableMatcher';
 
 /** @test {takeLast} */
 describe('takeLast operator', () => {
   let rxTest: TestScheduler;
 
   beforeEach(() => {
-    rxTest = new TestScheduler(assertDeepEquals);
+    rxTest = new TestScheduler(observableMatcher);
   });
 
   it('should error for invalid arguments', () => {

spec/util/ArgumentOutOfRangeError-spec.ts

@@ -10,4 +10,7 @@ describe('ArgumentOutOfRangeError', () => {
   it('Should have a message', () => {
     expect(error.message).to.be.equal('argument out of range');
   });
+  it('Should have a stack', () => {
+    expect(error.stack).to.be.a('string');
+  });
 });

spec/util/EmptyError-spec.ts

@@ -10,4 +10,7 @@ describe('EmptyError', () => {
   it('Should have a message', () => {
     expect(error.message).to.be.equal('no elements in sequence');
   });
+  it('Should have a stack', () => {
+    expect(error.stack).to.be.a('string');
+  });
 });

spec/util/ObjectUnsubscribedError-spec.ts

@@ -10,4 +10,7 @@ describe('ObjectUnsubscribedError', () => {
   it('Should have a message', () => {
     expect(error.message).to.be.equal('object unsubscribed');
   });
+  it('Should have a stack', () => {
+    expect(error.stack).to.be.a('string');
+  });
 });

spec/util/TimeoutError-spec.ts

@@ -10,4 +10,7 @@ describe('TimeoutError', () => {
   it('Should have a message', () => {
     expect(error.message).to.be.equal('Timeout has occurred');
   });
+  it('Should have a stack', () => {
+    expect(error.stack).to.be.a('string');
+  });
 });

spec/util/UnsubscriptionError-spec.ts

@@ -19,6 +19,7 @@ describe('UnsubscriptionError', () => {
       expect(err instanceof UnsubscriptionError).to.equal(true);
       expect(err.errors).to.deep.equal([err1, err2]);
       expect(err.name).to.equal('UnsubscriptionError');
+      expect(err.stack).to.be.a('string');
     }
   });
 });

src/internal/observable/dom/AjaxObservable.ts

@@ -2,6 +2,7 @@
 import { Observable } from '../../Observable';
 import { Subscriber } from '../../Subscriber';
 import { TeardownLogic, PartialObserver } from '../../types';
+import { createErrorClass } from '../../util/createErrorClass';
 
 export interface AjaxRequest {
   url?: string;
@@ -322,28 +323,6 @@ export interface AjaxErrorCtor {
   new (message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError;
 }
 
-const AjaxErrorImpl = (() => {
-  function AjaxErrorImpl(this: any, message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError {
-    Error.call(this);
-    this.message = message;
-    this.name = 'AjaxError';
-    this.xhr = xhr;
-    this.request = request;
-    this.status = xhr.status;
-    this.responseType = xhr.responseType;
-    let response: any;
-    try {
-      response = getXHRResponse(xhr);
-    } catch (err) {
-      response = xhr.responseText;
-    }
-    this.response = response;
-    return this;
-  }
-  AjaxErrorImpl.prototype = Object.create(Error.prototype);
-  return AjaxErrorImpl;
-})();
-
 /**
  * Thrown when an error occurs during an AJAX request.
  * This is only exported because it is useful for checking to see if an error
@@ -353,7 +332,25 @@ const AjaxErrorImpl = (() => {
  * @class AjaxError
  * @see ajax
  */
-export const AjaxError: AjaxErrorCtor = AjaxErrorImpl as any;
+export const AjaxError: AjaxErrorCtor = createErrorClass('AjaxError', function (
+  this: any,
+  message: string,
+  xhr: XMLHttpRequest,
+  request: AjaxRequest
+) {
+  this.message = message;
+  this.xhr = xhr;
+  this.request = request;
+  this.status = xhr.status;
+  this.responseType = xhr.responseType;
+  let response: any;
+  try {
+    response = getXHRResponse(xhr);
+  } catch (err) {
+    response = xhr.responseText;
+  }
+  this.response = response;
+});
 
 function getXHRResponse(xhr: XMLHttpRequest) {
   switch (xhr.responseType) {
@@ -391,6 +388,8 @@ export interface AjaxTimeoutErrorCtor {
   new (xhr: XMLHttpRequest, request: AjaxRequest): AjaxTimeoutError;
 }
 
+// NOTE: We are not using createErrorClass here, because we're deriving this from
+// the AjaxError we defined above.
 const AjaxTimeoutErrorImpl = (() => {
   function AjaxTimeoutErrorImpl(this: any, xhr: XMLHttpRequest, request: AjaxRequest) {
     AjaxError.call(this, 'ajax timeout', xhr, request);

src/internal/operators/timeout.ts

@@ -7,6 +7,7 @@ import { Subscription } from '../Subscription';
 import { lift } from '../util/lift';
 import { Observable } from '../Observable';
 import { from } from '../observable/from';
+import { createErrorClass } from '../util/createErrorClass';
 
 export interface TimeoutConfig<T, R = T, M = unknown> {
   /**
@@ -72,20 +73,6 @@ export interface TimeoutErrorCtor {
   new <T = unknown, M = unknown>(info?: TimeoutInfo<T, M>): TimeoutError<T, M>;
 }
 
-const TimeoutErrorImpl = (() => {
-  function TimeoutErrorImpl(this: any, info: TimeoutInfo<any> | null = null) {
-    Error.call(this);
-    this.message = 'Timeout has occurred';
-    this.name = 'TimeoutError';
-    this.info = info;
-    return this;
-  }
-
-  TimeoutErrorImpl.prototype = Object.create(Error.prototype);
-
-  return TimeoutErrorImpl;
-})();
-
 /**
  * An error thrown by the {@link operators/timeout} operator.
  *
@@ -98,7 +85,11 @@ const TimeoutErrorImpl = (() => {
  *
  * @class TimeoutError
  */
-export const TimeoutError: TimeoutErrorCtor = TimeoutErrorImpl as any;
+export const TimeoutError: TimeoutErrorCtor = createErrorClass('TimeoutError', function (info: TimeoutInfo<any> | null = null) {
+  this.message = 'Timeout has occurred';
+  this.name = 'TimeoutError';
+  (this as any).info = info;
+});
 
 /**
  * If `with` is provided, this will return an observable that will switch to a different observable if the source

src/internal/util/ArgumentOutOfRangeError.ts

@@ -1,23 +1,12 @@
-export interface ArgumentOutOfRangeError extends Error {
-}
+/** @prettier */
+import { createErrorClass } from './createErrorClass';
+
+export interface ArgumentOutOfRangeError extends Error {}
 
 export interface ArgumentOutOfRangeErrorCtor {
-  new(): ArgumentOutOfRangeError;
+  new (): ArgumentOutOfRangeError;
 }
 
-const ArgumentOutOfRangeErrorImpl = (() => {
-  function ArgumentOutOfRangeErrorImpl(this: Error) {
-    Error.call(this);
-    this.message = 'argument out of range';
-    this.name = 'ArgumentOutOfRangeError';
-    return this;
-  }
-
-  ArgumentOutOfRangeErrorImpl.prototype = Object.create(Error.prototype);
-
-  return ArgumentOutOfRangeErrorImpl;
-})();
-
 /**
  * An error thrown when an element was queried at a certain index of an
  * Observable, but no such index or position exists in that sequence.
@@ -28,4 +17,6 @@ const ArgumentOutOfRangeErrorImpl = (() => {
  *
  * @class ArgumentOutOfRangeError
  */
-export const ArgumentOutOfRangeError: ArgumentOutOfRangeErrorCtor = ArgumentOutOfRangeErrorImpl as any;
+export const ArgumentOutOfRangeError: ArgumentOutOfRangeErrorCtor = createErrorClass('ArgumentOutOfRangeError', function () {
+  this.message = 'argument out of range';
+});

src/internal/util/EmptyError.ts

@@ -1,23 +1,12 @@
+import { createErrorClass } from './createErrorClass';
+
 export interface EmptyError extends Error {
 }
 
 export interface EmptyErrorCtor {
   new(): EmptyError;
 }
 
-const EmptyErrorImpl = (() => {
-  function EmptyErrorImpl(this: Error) {
-    Error.call(this);
-    this.message = 'no elements in sequence';
-    this.name = 'EmptyError';
-    return this;
-  }
-
-  EmptyErrorImpl.prototype = Object.create(Error.prototype);
-
-  return EmptyErrorImpl;
-})();
-
 /**
  * An error thrown when an Observable or a sequence was queried but has no
  * elements.
@@ -28,4 +17,6 @@ const EmptyErrorImpl = (() => {
  *
  * @class EmptyError
  */
-export const EmptyError: EmptyErrorCtor = EmptyErrorImpl as any;
+export const EmptyError: EmptyErrorCtor = createErrorClass('EmptyError', function () {
+  this.message = 'no elements in sequence';
+});

src/internal/util/NotFoundError.ts

@@ -1,23 +1,12 @@
-export interface NotFoundError extends Error {
-}
+/** @prettier */
+import { createErrorClass } from './createErrorClass';
+
+export interface NotFoundError extends Error {}
 
 export interface NotFoundErrorCtor {
-  new(message: string): NotFoundError;
+  new (message: string): NotFoundError;
 }
 
-const NotFoundErrorImpl = (() => {
-  function NotFoundErrorImpl(this: Error, message: string) {
-    Error.call(this);
-    this.message = message;
-    this.name = 'NotFoundError';
-    return this;
-  }
-
-  NotFoundErrorImpl.prototype = Object.create(Error.prototype);
-
-  return NotFoundErrorImpl;
-})();
-
 /**
  * An error thrown when a value or values are missing from an
  * observable sequence.
@@ -26,4 +15,6 @@ const NotFoundErrorImpl = (() => {
  *
  * @class NotFoundError
  */
-export const NotFoundError: NotFoundErrorCtor = NotFoundErrorImpl as any;
+export const NotFoundError: NotFoundErrorCtor = createErrorClass('NotFoundError', function (message: string) {
+  this.message = message;
+});

src/internal/util/ObjectUnsubscribedError.ts

@@ -1,23 +1,12 @@
-export interface ObjectUnsubscribedError extends Error {
-}
+/** @prettier */
+import { createErrorClass } from './createErrorClass';
+
+export interface ObjectUnsubscribedError extends Error {}
 
 export interface ObjectUnsubscribedErrorCtor {
-  new(): ObjectUnsubscribedError;
+  new (): ObjectUnsubscribedError;
 }
 
-const ObjectUnsubscribedErrorImpl = (() => {
-  function ObjectUnsubscribedErrorImpl(this: Error) {
-    Error.call(this);
-    this.message = 'object unsubscribed';
-    this.name = 'ObjectUnsubscribedError';
-    return this;
-  }
-
-  ObjectUnsubscribedErrorImpl.prototype = Object.create(Error.prototype);
-
-  return ObjectUnsubscribedErrorImpl;
-})();
-
 /**
  * An error thrown when an action is invalid because the object has been
  * unsubscribed.
@@ -27,4 +16,6 @@ const ObjectUnsubscribedErrorImpl = (() => {
  *
  * @class ObjectUnsubscribedError
  */
-export const ObjectUnsubscribedError: ObjectUnsubscribedErrorCtor = ObjectUnsubscribedErrorImpl as any;
+export const ObjectUnsubscribedError: ObjectUnsubscribedErrorCtor = createErrorClass('ObjectUnsubscribedError', function () {
+  this.message = 'object unsubscribed';
+});