fix: add support for subclassing of Errors

Calling `new Error` returns a new instance of `Error`. This means
that subclassing of `Error` needs to take that into account as calling
`super` will not expect return value. 

To fix this `ZoneAwareError` detects to see if it was called with `new`
and if so will copy the fields from the `Error` to the current instance.

Author: mhevery

Diff for: lib/zone.ts

@@ -1703,6 +1703,20 @@ const Zone: ZoneType = (function(global: any) {
     // 1. attach zone information to stack frame
     // 2. remove zone internal stack frames
     attachZoneAndRemoveInternalZoneFrames(error);
+    if (this instanceof NativeError && this.constructor != NativeError) {
+      // We got called with a `new` operator AND we are subclass of ZoneAwareError
+      // in that case we have to copy all of our properties to `this`.
+      Object.keys(error).concat('stack', 'message').forEach((key) => {
+        if ((error as any)[key] !== undefined) {
+          try {
+            this[key] = (error as any)[key];
+          } catch (e) {
+            // ignore the assignment in case it is a setter and it throws.
+          }
+        }
+      });
+      return this;
+    }
     return error;
   }
 

Diff for: test/common/Error.spec.ts

@@ -9,6 +9,75 @@
 const _global: any =
     typeof window === 'object' && window || typeof self === 'object' && self || global;
 
+// simulate @angular/facade/src/error.ts
+class BaseError extends Error {
+  /** @internal **/
+  _nativeError: Error;
+
+  constructor(message: string) {
+    super(message);
+    const nativeError = new Error(message) as any as Error;
+    this._nativeError = nativeError;
+  }
+
+  get message() {
+    return this._nativeError.message;
+  }
+  set message(message) {
+    this._nativeError.message = message;
+  }
+  get name() {
+    return this._nativeError.name;
+  }
+  get stack() {
+    return (this._nativeError as any).stack;
+  }
+  set stack(value) {
+    (this._nativeError as any).stack = value;
+  }
+  toString() {
+    return this._nativeError.toString();
+  }
+}
+
+class WrappedError extends BaseError {
+  originalError: any;
+
+  constructor(message: string, error: any) {
+    super(`${message} caused by: ${error instanceof Error ? error.message : error}`);
+    this.originalError = error;
+  }
+
+  get stack() {
+    return ((this.originalError instanceof Error ? this.originalError : this._nativeError) as any)
+        .stack;
+  }
+}
+
+class TestError extends WrappedError {
+  constructor(message: string, error: any) {
+    super(`${message} caused by: ${error instanceof Error ? error.message : error}`, error);
+  }
+
+  get message() {
+    return 'test ' + this.originalError.message;
+  }
+}
+
+class TestMessageError extends WrappedError {
+  constructor(message: string, error: any) {
+    super(`${message} caused by: ${error instanceof Error ? error.message : error}`, error);
+  }
+
+  get message() {
+    return 'test ' + this.originalError.message;
+  }
+
+  set message(value) {
+    this.originalError.message = value;
+  }
+}
+
 describe('ZoneAwareError', () => {
   // If the environment does not supports stack rewrites, then these tests will fail
   // and there is no point in running them.
@@ -18,7 +87,7 @@ describe('ZoneAwareError', () => {
     class MyError extends Error {}
     const myError = new MyError();
     expect(myError instanceof Error).toBe(true);
-    expect(myError instanceof _global[(Zone as any).__symbol__('Error')]).toBe(true);
+    expect(myError instanceof MyError).toBe(true);
     expect(myError.stack).not.toBe(undefined);
   });
 
@@ -70,6 +139,27 @@ describe('ZoneAwareError', () => {
     }
   });
 
+  it('should not use child Error class get/set in ZoneAwareError constructor', () => {
+    const func = () => {
+      const error = new BaseError('test');
+      expect(error.message).toEqual('test');
+    };
+
+    expect(func).not.toThrow();
+  });
+
+  it('should behave correctly with wrapped error', () => {
+    const error = new TestError('originalMessage', new Error('error message'));
+    expect(error.message).toEqual('test error message');
+    error.originalError.message = 'new error message';
+    expect(error.message).toEqual('test new error message');
+
+    const error1 = new TestMessageError('originalMessage', new Error('error message'));
+    expect(error1.message).toEqual('test error message');
+    error1.message = 'new error message';
+    expect(error1.message).toEqual('test new error message');
+  });
+
   it('should copy customized NativeError properties to ZoneAwareError', () => {
     const spy = jasmine.createSpy('errorCustomFunction');
     const NativeError = (global as any)[(Zone as any).__symbol__('Error')];