perf: Don’t subclass Error; resulting in smaller binary (#14160)

Subclassing errors is problematic since Error returns a
new instance. All of the patching which we do than prevent
proper application of source maps.

PR Close #14160

modules/@angular/common/src/pipes/async_pipe.ts

@@ -9,7 +9,7 @@
 import {ChangeDetectorRef, OnDestroy, Pipe, PipeTransform, WrappedValue} from '@angular/core';
 import {EventEmitter, Observable} from '../facade/async';
 import {isObservable, isPromise} from '../private_import_core';
-import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
+import {invalidPipeArgumentError} from './invalid_pipe_argument_error';
 
 interface SubscriptionStrategy {
   createSubscription(async: any, updateLatestValue: any): any;
@@ -120,7 +120,7 @@ export class AsyncPipe implements OnDestroy, PipeTransform {
       return _observableStrategy;
     }
 
-    throw new InvalidPipeArgumentError(AsyncPipe, obj);
+    throw invalidPipeArgumentError(AsyncPipe, obj);
   }
 
   private _dispose(): void {

modules/@angular/common/src/pipes/case_conversion_pipes.ts

@@ -7,7 +7,7 @@
  */
 
 import {Pipe, PipeTransform} from '@angular/core';
-import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
+import {invalidPipeArgumentError} from './invalid_pipe_argument_error';
 
 /**
  * Transforms text to lowercase.
@@ -21,7 +21,7 @@ export class LowerCasePipe implements PipeTransform {
   transform(value: string): string {
     if (!value) return value;
     if (typeof value !== 'string') {
-      throw new InvalidPipeArgumentError(LowerCasePipe, value);
+      throw invalidPipeArgumentError(LowerCasePipe, value);
     }
     return value.toLowerCase();
   }
@@ -48,7 +48,7 @@ export class TitleCasePipe implements PipeTransform {
   transform(value: string): string {
     if (!value) return value;
     if (typeof value !== 'string') {
-      throw new InvalidPipeArgumentError(TitleCasePipe, value);
+      throw invalidPipeArgumentError(TitleCasePipe, value);
     }
 
     return value.split(/\b/g).map(word => titleCaseWord(word)).join('');
@@ -65,7 +65,7 @@ export class UpperCasePipe implements PipeTransform {
   transform(value: string): string {
     if (!value) return value;
     if (typeof value !== 'string') {
-      throw new InvalidPipeArgumentError(UpperCasePipe, value);
+      throw invalidPipeArgumentError(UpperCasePipe, value);
     }
     return value.toUpperCase();
   }

modules/@angular/common/src/pipes/date_pipe.ts

@@ -9,7 +9,7 @@
 import {Inject, LOCALE_ID, Pipe, PipeTransform} from '@angular/core';
 import {NumberWrapper} from '../facade/lang';
 import {DateFormatter} from './intl';
-import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
+import {invalidPipeArgumentError} from './invalid_pipe_argument_error';
 
 const ISO8601_DATE_REGEX =
     /^(\d{4})-?(\d\d)-?(\d\d)(?:T(\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d+))?)?)?(Z|([+-])(\d\d):?(\d\d))?)?$/;
@@ -134,7 +134,7 @@ export class DatePipe implements PipeTransform {
       if ((typeof value === 'string') && (match = value.match(ISO8601_DATE_REGEX))) {
         date = isoStringToDate(match);
       } else {
-        throw new InvalidPipeArgumentError(DatePipe, value);
+        throw invalidPipeArgumentError(DatePipe, value);
       }
     }
 

modules/@angular/common/src/pipes/i18n_plural_pipe.ts

@@ -8,7 +8,7 @@
 
 import {Pipe, PipeTransform} from '@angular/core';
 import {NgLocalization, getPluralCategory} from '../localization';
-import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
+import {invalidPipeArgumentError} from './invalid_pipe_argument_error';
 
 const _INTERPOLATION_REGEXP: RegExp = /#/g;
 
@@ -37,7 +37,7 @@ export class I18nPluralPipe implements PipeTransform {
     if (value == null) return '';
 
     if (typeof pluralMap !== 'object' || pluralMap === null) {
-      throw new InvalidPipeArgumentError(I18nPluralPipe, pluralMap);
+      throw invalidPipeArgumentError(I18nPluralPipe, pluralMap);
     }
 
     const key = getPluralCategory(value, Object.keys(pluralMap), this._localization);

modules/@angular/common/src/pipes/i18n_select_pipe.ts

@@ -7,7 +7,7 @@
  */
 
 import {Pipe, PipeTransform} from '@angular/core';
-import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
+import {invalidPipeArgumentError} from './invalid_pipe_argument_error';
 
 /**
  * @ngModule CommonModule
@@ -32,7 +32,7 @@ export class I18nSelectPipe implements PipeTransform {
     if (value == null) return '';
 
     if (typeof mapping !== 'object' || typeof value !== 'string') {
-      throw new InvalidPipeArgumentError(I18nSelectPipe, mapping);
+      throw invalidPipeArgumentError(I18nSelectPipe, mapping);
     }
 
     if (mapping.hasOwnProperty(value)) {

modules/@angular/common/src/pipes/invalid_pipe_argument_error.ts

@@ -8,11 +8,8 @@
 
 import {Type} from '@angular/core';
 
-import {BaseError} from '../facade/errors';
 import {stringify} from '../facade/lang';
 
-export class InvalidPipeArgumentError extends BaseError {
-  constructor(type: Type<any>, value: Object) {
-    super(`Invalid argument '${value}' for pipe '${stringify(type)}'`);
-  }
+export function invalidPipeArgumentError(type: Type<any>, value: Object) {
+  return Error(`InvalidPipeArgument: '${value}' for pipe '${stringify(type)}'`);
 }

modules/@angular/common/src/pipes/number_pipe.ts

@@ -11,7 +11,7 @@ import {Inject, LOCALE_ID, Pipe, PipeTransform, Type} from '@angular/core';
 import {NumberWrapper} from '../facade/lang';
 
 import {NumberFormatStyle, NumberFormatter} from './intl';
-import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
+import {invalidPipeArgumentError} from './invalid_pipe_argument_error';
 
 const _NUMBER_FORMAT_REGEXP = /^(\d+)?\.((\d+)(-(\d+))?)?$/;
 
@@ -23,7 +23,7 @@ function formatNumber(
   // Convert strings to numbers
   value = typeof value === 'string' && NumberWrapper.isNumeric(value) ? +value : value;
   if (typeof value !== 'number') {
-    throw new InvalidPipeArgumentError(pipe, value);
+    throw invalidPipeArgumentError(pipe, value);
   }
 
   let minInt: number;

modules/@angular/common/src/pipes/slice_pipe.ts

@@ -7,7 +7,7 @@
  */
 
 import {Pipe, PipeTransform} from '@angular/core';
-import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
+import {invalidPipeArgumentError} from './invalid_pipe_argument_error';
 
 /**
  * @ngModule CommonModule
@@ -60,7 +60,7 @@ export class SlicePipe implements PipeTransform {
     if (value == null) return value;
 
     if (!this.supports(value)) {
-      throw new InvalidPipeArgumentError(SlicePipe, value);
+      throw invalidPipeArgumentError(SlicePipe, value);
     }
 
     return value.slice(start, end);

modules/@angular/common/test/pipes/date_pipe_spec.ts

@@ -59,7 +59,7 @@ export function main() {
          () => { expect(() => pipe.transform(isoStringWithoutTime)).not.toThrow(); });
 
       it('should not support other objects',
-         () => expect(() => pipe.transform({})).toThrowError(/Invalid argument/));
+         () => expect(() => pipe.transform({})).toThrowError(/InvalidPipeArgument/));
     });
 
     describe('transform', () => {

modules/@angular/compiler-cli/src/main.ts

@@ -13,8 +13,8 @@ import 'reflect-metadata';
 
 import * as ts from 'typescript';
 import * as tsc from '@angular/tsc-wrapped';
+import {isSyntaxError} from '@angular/compiler';
 
-import {SyntaxError} from '@angular/compiler';
 import {CodeGenerator} from './codegen';
 
 function codegen(
@@ -29,7 +29,7 @@ export function main(
   const cliOptions = new tsc.NgcCliOptions(args);
 
   return tsc.main(project, cliOptions, codegen).then(() => 0).catch(e => {
-    if (e instanceof tsc.UserError || e instanceof SyntaxError) {
+    if (e instanceof tsc.UserError || isSyntaxError(e)) {
       consoleError(e.message);
       return Promise.resolve(1);
     } else {

modules/@angular/compiler/index.ts

@@ -62,5 +62,5 @@ export * from './src/style_compiler';
 export * from './src/template_parser/template_parser';
 export {ViewCompiler} from './src/view_compiler/view_compiler';
 export {AnimationParser} from './src/animation/animation_parser';
-export {SyntaxError} from './src/util';
+export {isSyntaxError, syntaxError} from './src/util';
 // This file only reexports content of the `src` folder. Keep it that way.

modules/@angular/compiler/src/aot/static_reflector.ts

@@ -9,7 +9,7 @@
 import {Attribute, Component, ContentChild, ContentChildren, Directive, Host, HostBinding, HostListener, Inject, Injectable, Input, NgModule, Optional, Output, Pipe, Self, SkipSelf, ViewChild, ViewChildren, animate, group, keyframes, sequence, state, style, transition, trigger} from '@angular/core';
 
 import {ReflectorReader} from '../private_import_core';
-import {SyntaxError} from '../util';
+import {syntaxError} from '../util';
 
 import {StaticSymbol} from './static_symbol';
 import {StaticSymbolResolver} from './static_symbol_resolver';
@@ -566,7 +566,7 @@ export class StaticReflector implements ReflectorReader {
         if (e.fileName) {
           throw positionalError(message, e.fileName, e.line, e.column);
         }
-        throw new SyntaxError(message);
+        throw syntaxError(message);
       }
     }
 

modules/@angular/compiler/src/css_parser/css_lexer.ts

@@ -8,7 +8,6 @@
 
 
 import * as chars from '../chars';
-import {BaseError} from '../facade/errors';
 import {isPresent} from '../facade/lang';
 
 export enum CssTokenType {
@@ -42,7 +41,7 @@ export enum CssLexerMode {
 }
 
 export class LexedCssResult {
-  constructor(public error: CssScannerError, public token: CssToken) {}
+  constructor(public error: Error, public token: CssToken) {}
 }
 
 export function generateErrorMessage(
@@ -86,16 +85,22 @@ export class CssLexer {
   }
 }
 
-export class CssScannerError extends BaseError {
-  public rawMessage: string;
-  public message: string;
+export function cssScannerError(token: CssToken, message: string): Error {
+  const error = Error('CssParseError: ' + message);
+  (error as any)[ERROR_RAW_MESSAGE] = message;
+  (error as any)[ERROR_TOKEN] = token;
+  return error;
+}
 
-  constructor(public token: CssToken, message: string) {
-    super('Css Parse Error: ' + message);
-    this.rawMessage = message;
-  }
+const ERROR_TOKEN = 'ngToken';
+const ERROR_RAW_MESSAGE = 'ngRawMessage';
 
-  toString(): string { return this.message; }
+export function getRawMessage(error: Error): string {
+  return (error as any)[ERROR_RAW_MESSAGE];
+}
+
+export function getToken(error: Error): CssToken {
+  return (error as any)[ERROR_TOKEN];
 }
 
 function _trackWhitespace(mode: CssLexerMode) {
@@ -122,7 +127,7 @@ export class CssScanner {
   /** @internal */
   _currentMode: CssLexerMode = CssLexerMode.BLOCK;
   /** @internal */
-  _currentError: CssScannerError = null;
+  _currentError: Error = null;
 
   constructor(public input: string, private _trackComments: boolean = false) {
     this.length = this.input.length;
@@ -221,7 +226,7 @@ export class CssScanner {
     // mode so that the parser can recover...
     this.setMode(mode);
 
-    let error: CssScannerError = null;
+    let error: Error = null;
     if (!isMatchingType || (isPresent(value) && value != next.strValue)) {
       let errorMessage =
           CssTokenType[next.type] + ' does not match expected ' + CssTokenType[type] + ' value';
@@ -230,7 +235,7 @@ export class CssScanner {
         errorMessage += ' ("' + next.strValue + '" should match "' + value + '")';
       }
 
-      error = new CssScannerError(
+      error = cssScannerError(
           next, generateErrorMessage(
                     this.input, errorMessage, next.strValue, previousIndex, previousLine,
                     previousColumn));
@@ -483,7 +488,7 @@ export class CssScanner {
     if (!doNotAdvance) {
       this.advance();
     }
-    this._currentError = new CssScannerError(invalidToken, errorMessage);
+    this._currentError = cssScannerError(invalidToken, errorMessage);
     return invalidToken;
   }
 }

modules/@angular/compiler/src/css_parser/css_parser.ts

@@ -11,7 +11,7 @@ import {isPresent} from '../facade/lang';
 import {ParseError, ParseLocation, ParseSourceFile, ParseSourceSpan} from '../parse_util';
 
 import {BlockType, CssAst, CssAtRulePredicateAst, CssBlockAst, CssBlockDefinitionRuleAst, CssBlockRuleAst, CssDefinitionAst, CssInlineRuleAst, CssKeyframeDefinitionAst, CssKeyframeRuleAst, CssMediaQueryRuleAst, CssPseudoSelectorAst, CssRuleAst, CssSelectorAst, CssSelectorRuleAst, CssSimpleSelectorAst, CssStyleSheetAst, CssStyleValueAst, CssStylesBlockAst, CssUnknownRuleAst, CssUnknownTokenListAst, mergeTokens} from './css_ast';
-import {CssLexer, CssLexerMode, CssScanner, CssToken, CssTokenType, generateErrorMessage, isNewline} from './css_lexer';
+import {CssLexer, CssLexerMode, CssScanner, CssToken, CssTokenType, generateErrorMessage, getRawMessage, isNewline} from './css_lexer';
 
 const SPACE_OPERATOR = ' ';
 
@@ -378,7 +378,7 @@ export class CssParser {
     const token = output.token;
     const error = output.error;
     if (isPresent(error)) {
-      this._error(error.rawMessage, token);
+      this._error(getRawMessage(error), token);
     }
     this._lastToken = token;
     return token;
@@ -393,7 +393,7 @@ export class CssParser {
     const token = output.token;
     const error = output.error;
     if (isPresent(error)) {
-      this._error(error.rawMessage, token);
+      this._error(getRawMessage(error), token);
     }
     this._lastToken = token;
     return token;

modules/@angular/compiler/src/directive_normalizer.ts

@@ -19,7 +19,7 @@ import {ResourceLoader} from './resource_loader';
 import {extractStyleUrls, isStyleUrlResolvable} from './style_url_resolver';
 import {PreparsedElementType, preparseElement} from './template_parser/template_preparser';
 import {UrlResolver} from './url_resolver';
-import {SyncAsyncResult, SyntaxError} from './util';
+import {SyncAsyncResult, syntaxError} from './util';
 
 export interface PrenormalizedTemplateMetadata {
   componentType: any;
@@ -67,19 +67,19 @@ export class DirectiveNormalizer {
     let normalizedTemplateAsync: Promise<CompileTemplateMetadata>;
     if (prenormData.template != null) {
       if (typeof prenormData.template !== 'string') {
-        throw new SyntaxError(
+        throw syntaxError(
             `The template specified for component ${stringify(prenormData.componentType)} is not a string`);
       }
       normalizedTemplateSync = this.normalizeTemplateSync(prenormData);
       normalizedTemplateAsync = Promise.resolve(normalizedTemplateSync);
     } else if (prenormData.templateUrl) {
       if (typeof prenormData.templateUrl !== 'string') {
-        throw new SyntaxError(
+        throw syntaxError(
             `The templateUrl specified for component ${stringify(prenormData.componentType)} is not a string`);
       }
       normalizedTemplateAsync = this.normalizeTemplateAsync(prenormData);
     } else {
-      throw new SyntaxError(
+      throw syntaxError(
           `No template specified for component ${stringify(prenormData.componentType)}`);
     }
 
@@ -113,7 +113,7 @@ export class DirectiveNormalizer {
         template, stringify(prenomData.componentType), true, interpolationConfig);
     if (rootNodesAndErrors.errors.length > 0) {
       const errorString = rootNodesAndErrors.errors.join('\n');
-      throw new SyntaxError(`Template parse errors:\n${errorString}`);
+      throw syntaxError(`Template parse errors:\n${errorString}`);
     }
 
     const templateMetadataStyles = this.normalizeStylesheet(new CompileStylesheetMetadata({

modules/@angular/compiler/src/metadata_resolver.ts

@@ -20,11 +20,11 @@ import {CompilerInjectable} from './injectable';
 import {hasLifecycleHook} from './lifecycle_reflector';
 import {NgModuleResolver} from './ng_module_resolver';
 import {PipeResolver} from './pipe_resolver';
-import {ComponentStillLoadingError, LIFECYCLE_HOOKS_VALUES, ReflectorReader, reflector} from './private_import_core';
+import {ERROR_COMPONENT_TYPE, LIFECYCLE_HOOKS_VALUES, ReflectorReader, reflector} from './private_import_core';
 import {ElementSchemaRegistry} from './schema/element_schema_registry';
 import {SummaryResolver} from './summary_resolver';
 import {getUrlScheme} from './url_resolver';
-import {MODULE_SUFFIX, SyntaxError, ValueTransformer, visitValue} from './util';
+import {MODULE_SUFFIX, ValueTransformer, syntaxError, visitValue} from './util';
 
 export type ErrorCollector = (error: any, type?: any) => void;
 export const ERROR_COLLECTOR_TOKEN = new InjectionToken('ErrorCollector');
@@ -254,7 +254,7 @@ export class CompileMetadataResolver {
         return null;
       } else {
         if (isSync) {
-          this._reportError(new ComponentStillLoadingError(directiveType), directiveType);
+          this._reportError(componentStillLoadingError(directiveType), directiveType);
           return null;
         }
         return templateMeta.asyncResult.then(createDirectiveMetadata);
@@ -328,7 +328,7 @@ export class CompileMetadataResolver {
       // Directive
       if (!selector) {
         this._reportError(
-            new SyntaxError(
+            syntaxError(
                 `Directive ${stringifyType(directiveType)} has no selector, please add it!`),
             directiveType);
         selector = 'error';
@@ -383,7 +383,7 @@ export class CompileMetadataResolver {
     const dirMeta = this._directiveCache.get(directiveType);
     if (!dirMeta) {
       this._reportError(
-          new SyntaxError(
+          syntaxError(
               `Illegal state: getDirectiveMetadata can only be called after loadNgModuleDirectiveAndPipeMetadata for a module that declares it. Directive ${stringifyType(directiveType)}.`),
           directiveType);
     }
@@ -395,7 +395,7 @@ export class CompileMetadataResolver {
         <cpl.CompileDirectiveSummary>this._loadSummary(dirType, cpl.CompileSummaryKind.Directive);
     if (!dirSummary) {
       this._reportError(
-          new SyntaxError(
+          syntaxError(
               `Illegal state: Could not load the summary for directive ${stringifyType(dirType)}.`),
           dirType);
     }
@@ -478,7 +478,7 @@ export class CompileMetadataResolver {
           const importedModuleSummary = this.getNgModuleSummary(importedModuleType);
           if (!importedModuleSummary) {
             this._reportError(
-                new SyntaxError(
+                syntaxError(
                     `Unexpected ${this._getTypeDescriptor(importedType)} '${stringifyType(importedType)}' imported by the module '${stringifyType(moduleType)}'`),
                 moduleType);
             return;
@@ -486,7 +486,7 @@ export class CompileMetadataResolver {
           importedModules.push(importedModuleSummary);
         } else {
           this._reportError(
-              new SyntaxError(
+              syntaxError(
                   `Unexpected value '${stringifyType(importedType)}' imported by the module '${stringifyType(moduleType)}'`),
               moduleType);
           return;
@@ -498,7 +498,7 @@ export class CompileMetadataResolver {
       flattenAndDedupeArray(meta.exports).forEach((exportedType) => {
         if (!isValidType(exportedType)) {
           this._reportError(
-              new SyntaxError(
+              syntaxError(
                   `Unexpected value '${stringifyType(exportedType)}' exported by the module '${stringifyType(moduleType)}'`),
               moduleType);
           return;
@@ -519,7 +519,7 @@ export class CompileMetadataResolver {
       flattenAndDedupeArray(meta.declarations).forEach((declaredType) => {
         if (!isValidType(declaredType)) {
           this._reportError(
-              new SyntaxError(
+              syntaxError(
                   `Unexpected value '${stringifyType(declaredType)}' declared by the module '${stringifyType(moduleType)}'`),
               moduleType);
           return;
@@ -536,7 +536,7 @@ export class CompileMetadataResolver {
           this._addTypeToModule(declaredType, moduleType);
         } else {
           this._reportError(
-              new SyntaxError(
+              syntaxError(
                   `Unexpected ${this._getTypeDescriptor(declaredType)} '${stringifyType(declaredType)}' declared by the module '${stringifyType(moduleType)}'`),
               moduleType);
           return;
@@ -555,7 +555,7 @@ export class CompileMetadataResolver {
         transitiveModule.addExportedPipe(exportedId);
       } else {
         this._reportError(
-            new SyntaxError(
+            syntaxError(
                 `Can't export ${this._getTypeDescriptor(exportedId.reference)} ${stringifyType(exportedId.reference)} from ${stringifyType(moduleType)} as it was neither declared nor imported!`),
             moduleType);
       }
@@ -578,7 +578,7 @@ export class CompileMetadataResolver {
       flattenAndDedupeArray(meta.bootstrap).forEach(type => {
         if (!isValidType(type)) {
           this._reportError(
-              new SyntaxError(
+              syntaxError(
                   `Unexpected value '${stringifyType(type)}' used in the bootstrap property of module '${stringifyType(moduleType)}'`),
               moduleType);
           return;
@@ -642,7 +642,7 @@ export class CompileMetadataResolver {
     const oldModule = this._ngModuleOfTypes.get(type);
     if (oldModule && oldModule !== moduleType) {
       this._reportError(
-          new SyntaxError(
+          syntaxError(
               `Type ${stringifyType(type)} is part of the declarations of 2 modules: ${stringifyType(oldModule)} and ${stringifyType(moduleType)}! ` +
               `Please consider moving ${stringifyType(type)} to a higher module that imports ${stringifyType(oldModule)} and ${stringifyType(moduleType)}. ` +
               `You can also create a new NgModule that exports and includes ${stringifyType(type)} then import that NgModule in ${stringifyType(oldModule)} and ${stringifyType(moduleType)}.`),
@@ -738,7 +738,7 @@ export class CompileMetadataResolver {
     const pipeMeta = this._pipeCache.get(pipeType);
     if (!pipeMeta) {
       this._reportError(
-          new SyntaxError(
+          syntaxError(
               `Illegal state: getPipeMetadata can only be called after loadNgModuleDirectiveAndPipeMetadata for a module that declares it. Pipe ${stringifyType(pipeType)}.`),
           pipeType);
     }
@@ -750,7 +750,7 @@ export class CompileMetadataResolver {
         <cpl.CompilePipeSummary>this._loadSummary(pipeType, cpl.CompileSummaryKind.Pipe);
     if (!pipeSummary) {
       this._reportError(
-          new SyntaxError(
+          syntaxError(
               `Illegal state: Could not load the summary for pipe ${stringifyType(pipeType)}.`),
           pipeType);
     }
@@ -833,7 +833,7 @@ export class CompileMetadataResolver {
       const depsTokens =
           dependenciesMetadata.map((dep) => dep ? stringifyType(dep.token) : '?').join(', ');
       this._reportError(
-          new SyntaxError(
+          syntaxError(
               `Can't resolve all parameters for ${stringifyType(typeOrFunc)}: (${depsTokens}).`),
           typeOrFunc);
     }
@@ -868,7 +868,7 @@ export class CompileMetadataResolver {
         } else if (isValidType(provider)) {
           providerMeta = new cpl.ProviderMeta(provider, {useClass: provider});
         } else if (provider === void 0) {
-          this._reportError(new SyntaxError(
+          this._reportError(syntaxError(
               `Encountered undefined provider! Usually this means you have a circular dependencies (might be caused by using 'barrel' index.ts files.`));
         } else {
           const providersInfo =
@@ -886,7 +886,7 @@ export class CompileMetadataResolver {
                    []))
                   .join(', ');
           this._reportError(
-              new SyntaxError(
+              syntaxError(
                   `Invalid ${debugInfo ? debugInfo : 'provider'} - only instances of Provider and Type are allowed, got: [${providersInfo}]`),
               type);
         }
@@ -902,7 +902,7 @@ export class CompileMetadataResolver {
 
   private _validateProvider(provider: any): void {
     if (provider.hasOwnProperty('useClass') && provider.useClass == null) {
-      this._reportError(new SyntaxError(
+      this._reportError(syntaxError(
           `Invalid provider for ${stringifyType(provider.provide)}. useClass cannot be ${provider.useClass}.
            Usually it happens when:
            1. There's a circular dependency (might be caused by using index.ts (barrel) files).
@@ -917,13 +917,13 @@ export class CompileMetadataResolver {
 
     if (provider.useFactory || provider.useExisting || provider.useClass) {
       this._reportError(
-          new SyntaxError(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports useValue!`), type);
+          syntaxError(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports useValue!`), type);
       return [];
     }
 
     if (!provider.multi) {
       this._reportError(
-          new SyntaxError(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports 'multi = true'!`),
+          syntaxError(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports 'multi = true'!`),
           type);
       return [];
     }
@@ -1006,7 +1006,7 @@ export class CompileMetadataResolver {
     } else {
       if (!q.selector) {
         this._reportError(
-            new SyntaxError(
+            syntaxError(
                 `Can't construct a query for the property "${propertyName}" of "${stringifyType(typeOrFunc)}" since the query selector wasn't defined.`),
             typeOrFunc);
       }
@@ -1074,7 +1074,7 @@ export function componentModuleUrl(
     const scheme = getUrlScheme(moduleId);
     return scheme ? moduleId : `package:${moduleId}${MODULE_SUFFIX}`;
   } else if (moduleId !== null && moduleId !== void 0) {
-    throw new SyntaxError(
+    throw syntaxError(
         `moduleId should be a string in "${stringifyType(type)}". See https://goo.gl/wIDDiL for more information.\n` +
         `If you're using Webpack you should inline the template and the styles, see https://goo.gl/X2J8zc.`);
   }
@@ -1099,3 +1099,14 @@ function stringifyType(type: any): string {
     return stringify(type);
   }
 }
+
+/**
+ * Indicates that a component is still being loaded in a synchronous compile.
+ */
+function componentStillLoadingError(compType: Type<any>) {
+  debugger;
+  const error =
+      Error(`Can't compile synchronously as ${stringify(compType)} is still being loaded!`);
+  (error as any)[ERROR_COMPONENT_TYPE] = compType;
+  return error;
+}

modules/@angular/compiler/src/private_import_core.ts

@@ -58,6 +58,7 @@ export const AnimationStyles: typeof r.AnimationStyles = r.AnimationStyles;
 export const ANY_STATE = r.ANY_STATE;
 export const DEFAULT_STATE = r.DEFAULT_STATE;
 export const EMPTY_STATE = r.EMPTY_STATE;
+export const ERROR_COMPONENT_TYPE = r.ERROR_COMPONENT_TYPE;
 export const FILL_STYLE_FLAG = r.FILL_STYLE_FLAG;
 export const prepareFinalAnimationStyles: typeof r.prepareFinalAnimationStyles =
     r.prepareFinalAnimationStyles;
@@ -68,9 +69,6 @@ export const collectAndResolveStyles: typeof r.collectAndResolveStyles = r.colle
 export const renderStyles: typeof r.renderStyles = r.renderStyles;
 export type ViewMetadata = typeof r._ViewMetadata;
 export const ViewMetadata: typeof r.ViewMetadata = r.ViewMetadata;
-export type ComponentStillLoadingError = typeof r._ComponentStillLoadingError;
-export const ComponentStillLoadingError: typeof r.ComponentStillLoadingError =
-    r.ComponentStillLoadingError;
 export const AnimationTransition: typeof r.AnimationTransition = r.AnimationTransition;
 export type SetterFn = typeof r._SetterFn;
 export type GetterFn = typeof r._GetterFn;

modules/@angular/compiler/src/template_parser/template_parser.ts

@@ -24,7 +24,7 @@ import {ProviderElementContext, ProviderViewContext} from '../provider_analyzer'
 import {ElementSchemaRegistry} from '../schema/element_schema_registry';
 import {CssSelector, SelectorMatcher} from '../selector';
 import {isStyleUrlResolvable} from '../style_url_resolver';
-import {SyntaxError} from '../util';
+import {syntaxError} from '../util';
 import {BindingParser, BoundProperty} from './binding_parser';
 import {AttrAst, BoundDirectivePropertyAst, BoundElementPropertyAst, BoundEventAst, BoundTextAst, DirectiveAst, ElementAst, EmbeddedTemplateAst, NgContentAst, PropertyBindingType, ReferenceAst, TemplateAst, TemplateAstVisitor, TextAst, VariableAst, templateVisitAll} from './template_ast';
 import {PreparsedElementType, preparseElement} from './template_preparser';
@@ -99,7 +99,7 @@ export class TemplateParser {
 
     if (errors.length > 0) {
       const errorString = errors.join('\n');
-      throw new SyntaxError(`Template parse errors:\n${errorString}`);
+      throw syntaxError(`Template parse errors:\n${errorString}`);
     }
 
     return result.templateAst;

modules/@angular/compiler/src/util.ts

@@ -6,7 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {BaseError} from './facade/errors';
 import {isPrimitive, isStrictStringMap} from './facade/lang';
 export const MODULE_SUFFIX = '';
 
@@ -79,4 +78,14 @@ export class SyncAsyncResult<T> {
   }
 }
 
-export class SyntaxError extends BaseError {}
+export function syntaxError(msg: string): Error {
+  const error = Error(msg);
+  (error as any)[ERROR_SYNTAX_ERROR] = true;
+  return error;
+}
+
+const ERROR_SYNTAX_ERROR = 'ngSyntaxError';
+
+export function isSyntaxError(error: Error): boolean {
+  return (error as any)[ERROR_SYNTAX_ERROR];
+}

modules/@angular/compiler/test/aot/static_reflector_spec.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {StaticReflector, StaticSymbol, StaticSymbolCache, StaticSymbolResolver, StaticSymbolResolverHost, SyntaxError} from '@angular/compiler';
+import {StaticReflector, StaticSymbol, StaticSymbolCache, StaticSymbolResolver, StaticSymbolResolverHost} from '@angular/compiler';
 import {HostListener, Inject, animate, group, keyframes, sequence, state, style, transition, trigger} from '@angular/core';
 
 import {MockStaticSymbolResolverHost, MockSummaryResolver} from './static_symbol_resolver_spec';
@@ -354,7 +354,6 @@ describe('StaticReflector', () => {
                      'Could not resolve ./does-not-exist.component relative to /tmp/src/function-reference.ts'
                })))
            .toThrowError(
-               SyntaxError,
                'Error encountered resolving symbol values statically. Could not resolve ./does-not-exist.component relative to /tmp/src/function-reference.ts, resolving symbol AppModule in /tmp/src/function-reference.ts');
      });
 

modules/@angular/compiler/test/css_parser/css_lexer_spec.ts

@@ -7,7 +7,7 @@
  */
 
 import {describe, expect, it} from '../../../core/testing/testing_internal';
-import {CssLexer, CssLexerMode, CssScannerError, CssToken, CssTokenType} from '../../src/css_parser/css_lexer';
+import {CssLexer, CssLexerMode, CssToken, CssTokenType, cssScannerError, getRawMessage, getToken} from '../../src/css_parser/css_lexer';
 import {isPresent} from '../../src/facade/lang';
 
 export function main() {
@@ -22,7 +22,7 @@ export function main() {
     while (output != null) {
       const error = output.error;
       if (isPresent(error)) {
-        throw new CssScannerError(error.token, error.rawMessage);
+        throw cssScannerError(getToken(error), getRawMessage(error));
       }
       tokens.push(output.token);
       output = scanner.scan();
@@ -279,7 +279,7 @@ export function main() {
         try {
           tokenize(cssCode, false, CssLexerMode.STYLE_BLOCK);
         } catch (e) {
-          capturedMessage = e.rawMessage;
+          capturedMessage = getRawMessage(e);
         }
 
         expect(capturedMessage).toMatch(/Unexpected character \[\>\] at column 0:7 in expression/g);
@@ -288,7 +288,7 @@ export function main() {
         try {
           tokenize(cssCode, false, CssLexerMode.SELECTOR);
         } catch (e) {
-          capturedMessage = e.rawMessage;
+          capturedMessage = getRawMessage(e);
         }
 
         expect(capturedMessage).toEqual(null);

modules/@angular/compiler/test/directive_normalizer_spec.ts

@@ -5,7 +5,6 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import {SyntaxError} from '@angular/compiler';
 import {CompileDirectiveMetadata, CompileStylesheetMetadata, CompileTemplateMetadata, CompileTypeMetadata} from '@angular/compiler/src/compile_metadata';
 import {CompilerConfig} from '@angular/compiler/src/config';
 import {DirectiveNormalizer} from '@angular/compiler/src/directive_normalizer';
@@ -31,23 +30,23 @@ export function main() {
            expect(() => normalizer.normalizeTemplate({
              componentType: SomeComp,
              moduleUrl: SOME_MODULE_URL,
-           })).toThrowError(SyntaxError, 'No template specified for component SomeComp');
+           })).toThrowError('No template specified for component SomeComp');
          }));
       it('should throw if template is not a string',
          inject([DirectiveNormalizer], (normalizer: DirectiveNormalizer) => {
-           expect(
-               () => normalizer.normalizeTemplate(
-                   {componentType: SomeComp, moduleUrl: SOME_MODULE_URL, template: <any>{}}))
-               .toThrowError(
-                   SyntaxError, 'The template specified for component SomeComp is not a string');
+           expect(() => normalizer.normalizeTemplate({
+             componentType: SomeComp,
+             moduleUrl: SOME_MODULE_URL,
+             template: <any>{}
+           })).toThrowError('The template specified for component SomeComp is not a string');
          }));
       it('should throw if templateUrl is not a string',
          inject([DirectiveNormalizer], (normalizer: DirectiveNormalizer) => {
-           expect(
-               () => normalizer.normalizeTemplate(
-                   {componentType: SomeComp, moduleUrl: SOME_MODULE_URL, templateUrl: <any>{}}))
-               .toThrowError(
-                   SyntaxError, 'The templateUrl specified for component SomeComp is not a string');
+           expect(() => normalizer.normalizeTemplate({
+             componentType: SomeComp,
+             moduleUrl: SOME_MODULE_URL,
+             templateUrl: <any>{}
+           })).toThrowError('The templateUrl specified for component SomeComp is not a string');
          }));
     });
 

modules/@angular/compiler/test/metadata_resolver_spec.ts

@@ -15,7 +15,6 @@ import {identifierName} from '../src/compile_metadata';
 import {stringify} from '../src/facade/lang';
 import {CompileMetadataResolver} from '../src/metadata_resolver';
 import {ResourceLoader} from '../src/resource_loader';
-import {SyntaxError} from '../src/util';
 import {MockResourceLoader} from '../testing/resource_loader_mock';
 import {MalformedStylesComponent} from './metadata_resolver_fixture';
 
@@ -34,9 +33,8 @@ export function main() {
          }
 
          expect(() => resolver.getDirectiveMetadata(ComponentWithEverythingInline))
-             .toThrowError(SyntaxError, /Illegal state/);
-         expect(() => resolver.getPipeMetadata(SomePipe))
-             .toThrowError(SyntaxError, /Illegal state/);
+             .toThrowError(/Illegal state/);
+         expect(() => resolver.getPipeMetadata(SomePipe)).toThrowError(/Illegal state/);
        }));
 
     it('should read metadata in sync for components with inline resources',
@@ -122,10 +120,10 @@ export function main() {
 
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(SomeModule, true))
              .toThrowError(
-                 SyntaxError, `moduleId should be a string in "ComponentWithInvalidModuleId". See` +
-                     ` https://goo.gl/wIDDiL for more information.\n` +
-                     `If you're using Webpack you should inline the template and the styles, see` +
-                     ` https://goo.gl/X2J8zc.`);
+                 `moduleId should be a string in "ComponentWithInvalidModuleId". See` +
+                 ` https://goo.gl/wIDDiL for more information.\n` +
+                 `If you're using Webpack you should inline the template and the styles, see` +
+                 ` https://goo.gl/X2J8zc.`);
        }));
 
 
@@ -146,7 +144,7 @@ export function main() {
          }
 
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(SomeModule, true))
-             .toThrowError(SyntaxError, `Can't resolve all parameters for MyBrokenComp1: (?).`);
+             .toThrowError(`Can't resolve all parameters for MyBrokenComp1: (?).`);
        }));
     it('should throw with descriptive error message when a directive is passed to imports',
        inject([CompileMetadataResolver], (resolver: CompileMetadataResolver) => {
@@ -156,7 +154,6 @@ export function main() {
          expect(
              () => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithImportedComponent, true))
              .toThrowError(
-                 SyntaxError,
                  `Unexpected directive 'ComponentWithoutModuleId' imported by the module 'ModuleWithImportedComponent'`);
        }));
 
@@ -170,7 +167,6 @@ export function main() {
          }
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithImportedPipe, true))
              .toThrowError(
-                 SyntaxError,
                  `Unexpected pipe 'SomePipe' imported by the module 'ModuleWithImportedPipe'`);
        }));
 
@@ -184,7 +180,6 @@ export function main() {
          }
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithDeclaredModule, true))
              .toThrowError(
-                 SyntaxError,
                  `Unexpected module 'SomeModule' declared by the module 'ModuleWithDeclaredModule'`);
        }));
 
@@ -195,7 +190,6 @@ export function main() {
          }
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithNullDeclared, true))
              .toThrowError(
-                 SyntaxError,
                  `Unexpected value 'null' declared by the module 'ModuleWithNullDeclared'`);
        }));
 
@@ -206,7 +200,6 @@ export function main() {
          }
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithNullImported, true))
              .toThrowError(
-                 SyntaxError,
                  `Unexpected value 'null' imported by the module 'ModuleWithNullImported'`);
        }));
 
@@ -218,8 +211,7 @@ export function main() {
          }
 
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(SomeModule, true))
-             .toThrowError(
-                 SyntaxError, `Can't resolve all parameters for NonAnnotatedService: (?).`);
+             .toThrowError(`Can't resolve all parameters for NonAnnotatedService: (?).`);
        }));
 
     it('should throw with descriptive error message when encounter invalid provider',
@@ -229,8 +221,7 @@ export function main() {
          }
 
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(SomeModule, true))
-             .toThrowError(
-                 SyntaxError, /Invalid provider for SimpleService. useClass cannot be undefined./);
+             .toThrowError(/Invalid provider for SimpleService. useClass cannot be undefined./);
        }));
 
     it('should throw with descriptive error message when provider is undefined',
@@ -240,7 +231,7 @@ export function main() {
          }
 
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(SomeModule, true))
-             .toThrowError(SyntaxError, /Encountered undefined provider!/);
+             .toThrowError(/Encountered undefined provider!/);
        }));
 
     it('should throw with descriptive error message when one of providers is not present',
@@ -251,7 +242,6 @@ export function main() {
 
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(SomeModule, true))
              .toThrowError(
-                 SyntaxError,
                  `Invalid providers for "MyBrokenComp3" - only instances of Provider and Type are allowed, got: [SimpleService, ?null?, ...]`);
        }));
 
@@ -263,7 +253,6 @@ export function main() {
 
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(SomeModule, true))
              .toThrowError(
-                 SyntaxError,
                  `Invalid viewProviders for "MyBrokenComp4" - only instances of Provider and Type are allowed, got: [?null?, ...]`);
        }));
 
@@ -278,13 +267,11 @@ export function main() {
 
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithNullBootstrap, true))
              .toThrowError(
-                 SyntaxError,
                  `Unexpected value 'null' used in the bootstrap property of module 'ModuleWithNullBootstrap'`);
          expect(
              () =>
                  resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithUndefinedBootstrap, true))
              .toThrowError(
-                 SyntaxError,
                  `Unexpected value 'undefined' used in the bootstrap property of module 'ModuleWithUndefinedBootstrap'`);
        }));
 

modules/@angular/compiler/test/template_parser/template_parser_spec.ts

@@ -5,7 +5,6 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import {SyntaxError} from '@angular/compiler';
 import {CompileAnimationEntryMetadata, CompileDiDependencyMetadata, CompileDirectiveMetadata, CompileDirectiveSummary, CompilePipeMetadata, CompilePipeSummary, CompileProviderMetadata, CompileTemplateMetadata, CompileTokenMetadata, CompileTypeMetadata, tokenReference} from '@angular/compiler/src/compile_metadata';
 import {DomElementSchemaRegistry} from '@angular/compiler/src/schema/dom_element_schema_registry';
 import {ElementSchemaRegistry} from '@angular/compiler/src/schema/element_schema_registry';
@@ -374,7 +373,7 @@ export function main() {
         describe('errors', () => {
           it('should throw error when binding to an unknown property', () => {
             expect(() => parse('<my-component [invalidProp]="bar"></my-component>', []))
-                .toThrowError(SyntaxError, `Template parse errors:
+                .toThrowError(`Template parse errors:
 Can't bind to 'invalidProp' since it isn't a known property of 'my-component'.
 1. If 'my-component' is an Angular component and it has 'invalidProp' input, then verify that it is part of this module.
 2. If 'my-component' is a Web Component then add "CUSTOM_ELEMENTS_SCHEMA" to the '@NgModule.schemas' of this component to suppress this message.
@@ -382,16 +381,14 @@ Can't bind to 'invalidProp' since it isn't a known property of 'my-component'.
           });
 
           it('should throw error when binding to an unknown element w/o bindings', () => {
-            expect(() => parse('<unknown></unknown>', []))
-                .toThrowError(SyntaxError, `Template parse errors:
+            expect(() => parse('<unknown></unknown>', [])).toThrowError(`Template parse errors:
 'unknown' is not a known element:
 1. If 'unknown' is an Angular component, then verify that it is part of this module.
 2. If 'unknown' is a Web Component then add "CUSTOM_ELEMENTS_SCHEMA" to the '@NgModule.schemas' of this component to suppress this message. ("[ERROR ->]<unknown></unknown>"): TestComp@0:0`);
           });
 
           it('should throw error when binding to an unknown custom element w/o bindings', () => {
-            expect(() => parse('<un-known></un-known>', []))
-                .toThrowError(SyntaxError, `Template parse errors:
+            expect(() => parse('<un-known></un-known>', [])).toThrowError(`Template parse errors:
 'un-known' is not a known element:
 1. If 'un-known' is an Angular component, then verify that it is part of this module.
 2. If 'un-known' is a Web Component then add "CUSTOM_ELEMENTS_SCHEMA" to the '@NgModule.schemas' of this component to suppress this message. ("[ERROR ->]<un-known></un-known>"): TestComp@0:0`);
@@ -399,13 +396,13 @@ Can't bind to 'invalidProp' since it isn't a known property of 'my-component'.
 
           it('should throw error when binding to an invalid property', () => {
             expect(() => parse('<my-component [onEvent]="bar"></my-component>', []))
-                .toThrowError(SyntaxError, `Template parse errors:
+                .toThrowError(`Template parse errors:
 Binding to property 'onEvent' is disallowed for security reasons ("<my-component [ERROR ->][onEvent]="bar"></my-component>"): TestComp@0:14`);
           });
 
           it('should throw error when binding to an invalid attribute', () => {
             expect(() => parse('<my-component [attr.onEvent]="bar"></my-component>', []))
-                .toThrowError(SyntaxError, `Template parse errors:
+                .toThrowError(`Template parse errors:
 Binding to attribute 'onEvent' is disallowed for security reasons ("<my-component [ERROR ->][attr.onEvent]="bar"></my-component>"): TestComp@0:14`);
           });
         });
@@ -447,7 +444,6 @@ Binding to attribute 'onEvent' is disallowed for security reasons ("<my-componen
            () => {
              expect(() => { parse('<div @someAnimation="value2">', [], [], []); })
                  .toThrowError(
-                     SyntaxError,
                      /Assigning animation triggers via @prop="exp" attributes with an expression is invalid. Use property bindings \(e.g. \[@prop\]="exp"\) or use an attribute without a value \(e.g. @prop\) instead. \("<div \[ERROR ->\]@someAnimation="value2">"\): TestComp@0:5/);
            });
 
@@ -482,7 +478,6 @@ Binding to attribute 'onEvent' is disallowed for security reasons ("<my-componen
 
           expect(() => { parse('<broken></broken>', [dirA]); })
               .toThrowError(
-                  SyntaxError,
                   `Template parse errors:\nValue of the host property binding "class.foo" needs to be a string representing an expression but got "null" (object) ("[ERROR ->]<broken></broken>"): TestComp@0:0, Directive DirA`);
         });
 
@@ -498,7 +493,6 @@ Binding to attribute 'onEvent' is disallowed for security reasons ("<my-componen
 
           expect(() => { parse('<broken></broken>', [dirA]); })
               .toThrowError(
-                  SyntaxError,
                   `Template parse errors:\nValue of the host listener "click" needs to be a string representing an expression but got "null" (object) ("[ERROR ->]<broken></broken>"): TestComp@0:0, Directive DirA`);
         });
 
@@ -962,8 +956,8 @@ Binding to attribute 'onEvent' is disallowed for security reasons ("<my-componen
           const dirB = createDir('[dirB]', {providers: [provider1]});
           expect(() => parse('<div dirA dirB>', [dirA, dirB]))
               .toThrowError(
-                  SyntaxError, `Template parse errors:\n` +
-                      `Mixing multi and non multi provider is not possible for token service0 ("[ERROR ->]<div dirA dirB>"): TestComp@0:0`);
+                  `Template parse errors:\n` +
+                  `Mixing multi and non multi provider is not possible for token service0 ("[ERROR ->]<div dirA dirB>"): TestComp@0:0`);
         });
 
         it('should sort providers by their DI order', () => {
@@ -1055,7 +1049,6 @@ Binding to attribute 'onEvent' is disallowed for security reasons ("<my-componen
           const dirA = createDir('[dirA]', {deps: ['self:provider0']});
           expect(() => parse('<div dirA></div>', [dirA]))
               .toThrowError(
-                  SyntaxError,
                   'Template parse errors:\nNo provider for provider0 ("[ERROR ->]<div dirA></div>"): TestComp@0:0');
         });
 
@@ -1070,7 +1063,6 @@ Binding to attribute 'onEvent' is disallowed for security reasons ("<my-componen
           const dirA = createDir('[dirA]', {deps: ['host:provider0']});
           expect(() => parse('<div dirA></div>', [dirA]))
               .toThrowError(
-                  SyntaxError,
                   'Template parse errors:\nNo provider for provider0 ("[ERROR ->]<div dirA></div>"): TestComp@0:0');
         });
 
@@ -1122,26 +1114,23 @@ Binding to attribute 'onEvent' is disallowed for security reasons ("<my-componen
         });
 
         it('should report references with values that dont match a directive as errors', () => {
-          expect(() => parse('<div #a="dirA"></div>', []))
-              .toThrowError(SyntaxError, `Template parse errors:
+          expect(() => parse('<div #a="dirA"></div>', [])).toThrowError(`Template parse errors:
 There is no directive with "exportAs" set to "dirA" ("<div [ERROR ->]#a="dirA"></div>"): TestComp@0:5`);
         });
 
         it('should report invalid reference names', () => {
-          expect(() => parse('<div #a-b></div>', []))
-              .toThrowError(SyntaxError, `Template parse errors:
+          expect(() => parse('<div #a-b></div>', [])).toThrowError(`Template parse errors:
 "-" is not allowed in reference names ("<div [ERROR ->]#a-b></div>"): TestComp@0:5`);
         });
 
         it('should report variables as errors', () => {
-          expect(() => parse('<div let-a></div>', []))
-              .toThrowError(SyntaxError, `Template parse errors:
+          expect(() => parse('<div let-a></div>', [])).toThrowError(`Template parse errors:
 "let-" is only supported on template elements. ("<div [ERROR ->]let-a></div>"): TestComp@0:5`);
         });
 
         it('should report duplicate reference names', () => {
           expect(() => parse('<div #a></div><div #a></div>', []))
-              .toThrowError(SyntaxError, `Template parse errors:
+              .toThrowError(`Template parse errors:
 Reference "#a" is defined several times ("<div #a></div><div [ERROR ->]#a></div>"): TestComp@0:19`);
 
         });
@@ -1513,8 +1502,8 @@ Reference "#a" is defined several times ("<div #a></div><div [ERROR ->]#a></div>
       it('should report when ng-content has non WS content', () => {
         expect(() => parse('<ng-content>content</ng-content>', []))
             .toThrowError(
-                SyntaxError, `Template parse errors:\n` +
-                    `<ng-content> element cannot have content. ("[ERROR ->]<ng-content>content</ng-content>"): TestComp@0:0`);
+                `Template parse errors:\n` +
+                `<ng-content> element cannot have content. ("[ERROR ->]<ng-content>content</ng-content>"): TestComp@0:0`);
       });
 
       it('should treat *attr on a template element as valid',
@@ -1524,20 +1513,18 @@ Reference "#a" is defined several times ("<div #a></div><div [ERROR ->]#a></div>
          () => { expect(() => parse('<template template="ngIf">', [])).not.toThrowError(); });
 
       it('should report when mutliple *attrs are used on the same element', () => {
-        expect(() => parse('<div *ngIf *ngFor>', []))
-            .toThrowError(SyntaxError, `Template parse errors:
+        expect(() => parse('<div *ngIf *ngFor>', [])).toThrowError(`Template parse errors:
 Can't have multiple template bindings on one element. Use only one attribute named 'template' or prefixed with * ("<div *ngIf [ERROR ->]*ngFor>"): TestComp@0:11`);
       });
 
       it('should report when mix of template and *attrs are used on the same element', () => {
         expect(() => parse('<span template="ngIf" *ngFor>', []))
-            .toThrowError(SyntaxError, `Template parse errors:
+            .toThrowError(`Template parse errors:
 Can't have multiple template bindings on one element. Use only one attribute named 'template' or prefixed with * ("<span template="ngIf" [ERROR ->]*ngFor>"): TestComp@0:22`);
       });
 
       it('should report invalid property names', () => {
-        expect(() => parse('<div [invalidProp]></div>', []))
-            .toThrowError(SyntaxError, `Template parse errors:
+        expect(() => parse('<div [invalidProp]></div>', [])).toThrowError(`Template parse errors:
 Can't bind to 'invalidProp' since it isn't a known property of 'div'. ("<div [ERROR ->][invalidProp]></div>"): TestComp@0:5`);
       });
 
@@ -1550,13 +1537,12 @@ Can't bind to 'invalidProp' since it isn't a known property of 'div'. ("<div [ER
                   host: {'[invalidProp]': 'someProp'}
                 })
                 .toSummary();
-        expect(() => parse('<div></div>', [dirA])).toThrowError(SyntaxError, `Template parse errors:
+        expect(() => parse('<div></div>', [dirA])).toThrowError(`Template parse errors:
 Can't bind to 'invalidProp' since it isn't a known property of 'div'. ("[ERROR ->]<div></div>"): TestComp@0:0, Directive DirA`);
       });
 
       it('should report errors in expressions', () => {
-        expect(() => parse('<div [prop]="a b"></div>', []))
-            .toThrowError(SyntaxError, `Template parse errors:
+        expect(() => parse('<div [prop]="a b"></div>', [])).toThrowError(`Template parse errors:
 Parser Error: Unexpected token 'b' at column 3 in [a b] in TestComp@0:5 ("<div [ERROR ->][prop]="a b"></div>"): TestComp@0:5`);
       });
 
@@ -1594,10 +1580,10 @@ Parser Error: Unexpected token 'b' at column 3 in [a b] in TestComp@0:5 ("<div [
                 .toSummary();
         expect(() => parse('<div>', [dirB, dirA]))
             .toThrowError(
-                SyntaxError, `Template parse errors:\n` +
-                    `More than one component matched on this element.\n` +
-                    `Make sure that only one component's selector can match a given element.\n` +
-                    `Conflicting components: DirB,DirA ("[ERROR ->]<div>"): TestComp@0:0`);
+                `Template parse errors:\n` +
+                `More than one component matched on this element.\n` +
+                `Make sure that only one component's selector can match a given element.\n` +
+                `Conflicting components: DirB,DirA ("[ERROR ->]<div>"): TestComp@0:0`);
       });
 
       it('should not allow components or element bindings nor dom events on explicit embedded templates',
@@ -1612,7 +1598,7 @@ Parser Error: Unexpected token 'b' at column 3 in [a b] in TestComp@0:5 ("<div [
                    })
                    .toSummary();
            expect(() => parse('<template [a]="b" (e)="f"></template>', [dirA]))
-               .toThrowError(SyntaxError, `Template parse errors:
+               .toThrowError(`Template parse errors:
 Event binding e not emitted by any directive on an embedded template. Make sure that the event name is spelled correctly and all directives are listed in the "@NgModule.declarations". ("<template [a]="b" [ERROR ->](e)="f"></template>"): TestComp@0:18
 Components on an embedded template: DirA ("[ERROR ->]<template [a]="b" (e)="f"></template>"): TestComp@0:0
 Property binding a not used by any directive on an embedded template. Make sure that the property name is spelled correctly and all directives are listed in the "@NgModule.declarations". ("[ERROR ->]<template [a]="b" (e)="f"></template>"): TestComp@0:0`);
@@ -1628,8 +1614,7 @@ Property binding a not used by any directive on an embedded template. Make sure
                   template: new CompileTemplateMetadata({ngContentSelectors: []})
                 })
                 .toSummary();
-        expect(() => parse('<div *a="b"></div>', [dirA]))
-            .toThrowError(SyntaxError, `Template parse errors:
+        expect(() => parse('<div *a="b"></div>', [dirA])).toThrowError(`Template parse errors:
 Components on an embedded template: DirA ("[ERROR ->]<div *a="b"></div>"): TestComp@0:0
 Property binding a not used by any directive on an embedded template. Make sure that the property name is spelled correctly and all directives are listed in the "@NgModule.declarations". ("[ERROR ->]<div *a="b"></div>"): TestComp@0:0`);
       });
@@ -1889,7 +1874,7 @@ Property binding a not used by any directive on an embedded template. Make sure
       });
 
       it('should report pipes as error that have not been defined as dependencies', () => {
-        expect(() => parse('{{a | test}}', [])).toThrowError(SyntaxError, `Template parse errors:
+        expect(() => parse('{{a | test}}', [])).toThrowError(`Template parse errors:
 The pipe 'test' could not be found ("{{[ERROR ->]a | test}}"): TestComp@0:2`);
       });
 

modules/@angular/core/src/core_private_export.ts

@@ -20,7 +20,7 @@ import * as constants from './change_detection/constants';
 import * as console from './console';
 import * as debug from './debug/debug_renderer';
 import * as reflective_provider from './di/reflective_provider';
-import {ComponentStillLoadingError} from './linker/compiler';
+import {ERROR_COMPONENT_TYPE} from './errors';
 import * as component_factory from './linker/component_factory';
 import * as component_factory_resolver from './linker/component_factory_resolver';
 import * as debug_context from './linker/debug_context';
@@ -104,12 +104,11 @@ export const __core_private__: {
   DEFAULT_STATE: typeof DEFAULT_STATE_,
   EMPTY_STATE: typeof EMPTY_STATE_,
   FILL_STYLE_FLAG: typeof FILL_STYLE_FLAG_,
-  _ComponentStillLoadingError?: ComponentStillLoadingError,
-  ComponentStillLoadingError: typeof ComponentStillLoadingError,
   isPromise: typeof isPromise,
   isObservable: typeof isObservable,
   AnimationTransition: typeof AnimationTransition
   view_utils: typeof view_utils,
+  ERROR_COMPONENT_TYPE: typeof ERROR_COMPONENT_TYPE,
 } = {
   isDefaultChangeDetectionStrategy: constants.isDefaultChangeDetectionStrategy,
   ChangeDetectorStatus: constants.ChangeDetectorStatus,
@@ -156,8 +155,8 @@ export const __core_private__: {
   DEFAULT_STATE: DEFAULT_STATE_,
   EMPTY_STATE: EMPTY_STATE_,
   FILL_STYLE_FLAG: FILL_STYLE_FLAG_,
-  ComponentStillLoadingError: ComponentStillLoadingError,
   isPromise: isPromise,
   isObservable: isObservable,
-  AnimationTransition: AnimationTransition
+  AnimationTransition: AnimationTransition,
+  ERROR_COMPONENT_TYPE: ERROR_COMPONENT_TYPE
 };

modules/@angular/core/src/di/reflective_errors.ts

@@ -6,7 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {BaseError, WrappedError} from '../facade/errors';
+import {wrappedError} from '../error_handler';
+import {ERROR_ORIGINAL_ERROR, getOriginalError} from '../errors';
 import {stringify} from '../facade/lang';
 import {Type} from '../type';
 
@@ -35,38 +36,31 @@ function constructResolvingPath(keys: any[]): string {
   return '';
 }
 
-
-/**
- * Base class for all errors arising from misconfigured providers.
- * @stable
- */
-export class AbstractProviderError extends BaseError {
-  /** @internal */
-  message: string;
-
-  /** @internal */
+export interface InjectionError extends Error {
   keys: ReflectiveKey[];
-
-  /** @internal */
   injectors: ReflectiveInjector[];
+  constructResolvingMessage: (this: InjectionError) => string;
+  addKey(injector: ReflectiveInjector, key: ReflectiveKey): void;
+}
 
-  /** @internal */
-  constructResolvingMessage: Function;
+function injectionError(
+    injector: ReflectiveInjector, key: ReflectiveKey,
+    constructResolvingMessage: (this: InjectionError) => string,
+    originalError?: Error): InjectionError {
+  const error = (originalError ? wrappedError('', originalError) : Error()) as InjectionError;
+  error.addKey = addKey;
+  error.keys = [key];
+  error.injectors = [injector];
+  error.constructResolvingMessage = constructResolvingMessage;
+  error.message = error.constructResolvingMessage();
+  (error as any)[ERROR_ORIGINAL_ERROR] = originalError;
+  return error;
+}
 
-  constructor(
-      injector: ReflectiveInjector, key: ReflectiveKey, constructResolvingMessage: Function) {
-    super('DI Error');
-    this.keys = [key];
-    this.injectors = [injector];
-    this.constructResolvingMessage = constructResolvingMessage;
-    this.message = this.constructResolvingMessage(this.keys);
-  }
-
-  addKey(injector: ReflectiveInjector, key: ReflectiveKey): void {
-    this.injectors.push(injector);
-    this.keys.push(key);
-    this.message = this.constructResolvingMessage(this.keys);
-  }
+function addKey(this: InjectionError, injector: ReflectiveInjector, key: ReflectiveKey): void {
+  this.injectors.push(injector);
+  this.keys.push(key);
+  this.message = this.constructResolvingMessage();
 }
 
 /**
@@ -82,15 +76,12 @@ export class AbstractProviderError extends BaseError {
  *
  * expect(() => Injector.resolveAndCreate([A])).toThrowError();
  * ```
- * @stable
  */
-export class NoProviderError extends AbstractProviderError {
-  constructor(injector: ReflectiveInjector, key: ReflectiveKey) {
-    super(injector, key, function(keys: any[]) {
-      const first = stringify(keys[0].token);
-      return `No provider for ${first}!${constructResolvingPath(keys)}`;
-    });
-  }
+export function noProviderError(injector: ReflectiveInjector, key: ReflectiveKey): InjectionError {
+  return injectionError(injector, key, function(this: InjectionError) {
+    const first = stringify(this.keys[0].token);
+    return `No provider for ${first}!${constructResolvingPath(this.keys)}`;
+  });
 }
 
 /**
@@ -108,14 +99,12 @@ export class NoProviderError extends AbstractProviderError {
  * ```
  *
  * Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.
- * @stable
  */
-export class CyclicDependencyError extends AbstractProviderError {
-  constructor(injector: ReflectiveInjector, key: ReflectiveKey) {
-    super(injector, key, function(keys: any[]) {
-      return `Cannot instantiate cyclic dependency!${constructResolvingPath(keys)}`;
-    });
-  }
+export function cyclicDependencyError(
+    injector: ReflectiveInjector, key: ReflectiveKey): InjectionError {
+  return injectionError(injector, key, function(this: InjectionError) {
+    return `Cannot instantiate cyclic dependency!${constructResolvingPath(this.keys)}`;
+  });
 }
 
 /**
@@ -143,34 +132,14 @@ export class CyclicDependencyError extends AbstractProviderError {
  *   expect(e.originalStack).toBeDefined();
  * }
  * ```
- * @stable
  */
-export class InstantiationError extends WrappedError {
-  /** @internal */
-  keys: ReflectiveKey[];
-
-  /** @internal */
-  injectors: ReflectiveInjector[];
-
-  constructor(
-      injector: ReflectiveInjector, originalException: any, originalStack: any,
-      key: ReflectiveKey) {
-    super('DI Error', originalException);
-    this.keys = [key];
-    this.injectors = [injector];
-  }
-
-  addKey(injector: ReflectiveInjector, key: ReflectiveKey): void {
-    this.injectors.push(injector);
-    this.keys.push(key);
-  }
-
-  get message(): string {
+export function instantiationError(
+    injector: ReflectiveInjector, originalException: any, originalStack: any,
+    key: ReflectiveKey): InjectionError {
+  return injectionError(injector, key, function(this: InjectionError) {
     const first = stringify(this.keys[0].token);
-    return `${this.originalError.message}: Error during instantiation of ${first}!${constructResolvingPath(this.keys)}.`;
-  }
-
-  get causeKey(): ReflectiveKey { return this.keys[0]; }
+    return `${getOriginalError(this).message}: Error during instantiation of ${first}!${constructResolvingPath(this.keys)}.`;
+  }, originalException);
 }
 
 /**
@@ -182,12 +151,10 @@ export class InstantiationError extends WrappedError {
  * ```typescript
  * expect(() => Injector.resolveAndCreate(["not a type"])).toThrowError();
  * ```
- * @stable
  */
-export class InvalidProviderError extends BaseError {
-  constructor(provider: any) {
-    super(`Invalid provider - only instances of Provider and Type are allowed, got: ${provider}`);
-  }
+export function invalidProviderError(provider: any) {
+  return Error(
+      `Invalid provider - only instances of Provider and Type are allowed, got: ${provider}`);
 }
 
 /**
@@ -219,26 +186,21 @@ export class InvalidProviderError extends BaseError {
  * ```
  * @stable
  */
-export class NoAnnotationError extends BaseError {
-  constructor(typeOrFunc: Type<any>|Function, params: any[][]) {
-    super(NoAnnotationError._genMessage(typeOrFunc, params));
-  }
-
-  private static _genMessage(typeOrFunc: Type<any>|Function, params: any[][]) {
-    const signature: string[] = [];
-    for (let i = 0, ii = params.length; i < ii; i++) {
-      const parameter = params[i];
-      if (!parameter || parameter.length == 0) {
-        signature.push('?');
-      } else {
-        signature.push(parameter.map(stringify).join(' '));
-      }
+export function noAnnotationError(typeOrFunc: Type<any>| Function, params: any[][]): Error {
+  const signature: string[] = [];
+  for (let i = 0, ii = params.length; i < ii; i++) {
+    const parameter = params[i];
+    if (!parameter || parameter.length == 0) {
+      signature.push('?');
+    } else {
+      signature.push(parameter.map(stringify).join(' '));
     }
-    return 'Cannot resolve all parameters for \'' + stringify(typeOrFunc) + '\'(' +
-        signature.join(', ') + '). ' +
-        'Make sure that all the parameters are decorated with Inject or have valid type annotations and that \'' +
-        stringify(typeOrFunc) + '\' is decorated with Injectable.';
   }
+  return Error(
+      'Cannot resolve all parameters for \'' + stringify(typeOrFunc) + '\'(' +
+      signature.join(', ') + '). ' +
+      'Make sure that all the parameters are decorated with Inject or have valid type annotations and that \'' +
+      stringify(typeOrFunc) + '\' is decorated with Injectable.');
 }
 
 /**
@@ -255,8 +217,8 @@ export class NoAnnotationError extends BaseError {
  * ```
  * @stable
  */
-export class OutOfBoundsError extends BaseError {
-  constructor(index: number) { super(`Index ${index} is out-of-bounds.`); }
+export function outOfBoundsError(index: number) {
+  return Error(`Index ${index} is out-of-bounds.`);
 }
 
 // TODO: add a working example after alpha38 is released
@@ -272,10 +234,7 @@ export class OutOfBoundsError extends BaseError {
  * ])).toThrowError();
  * ```
  */
-export class MixingMultiProvidersWithRegularProvidersError extends BaseError {
-  constructor(provider1: any, provider2: any) {
-    super(
-        'Cannot mix multi providers and regular providers, got: ' + provider1.toString() + ' ' +
-        provider2.toString());
-  }
+export function mixingMultiProvidersWithRegularProvidersError(
+    provider1: any, provider2: any): Error {
+  return Error(`Cannot mix multi providers and regular providers, got: ${provider1} ${provider2}`);
 }

modules/@angular/core/src/di/reflective_injector.ts

@@ -9,7 +9,7 @@
 import {Injector, THROW_IF_NOT_FOUND} from './injector';
 import {Self, SkipSelf} from './metadata';
 import {Provider} from './provider';
-import {AbstractProviderError, CyclicDependencyError, InstantiationError, NoProviderError, OutOfBoundsError} from './reflective_errors';
+import {cyclicDependencyError, instantiationError, noProviderError, outOfBoundsError} from './reflective_errors';
 import {ReflectiveKey} from './reflective_key';
 import {ReflectiveDependency, ResolvedReflectiveFactory, ResolvedReflectiveProvider, resolveReflectiveProviders} from './reflective_provider';
 
@@ -331,7 +331,7 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
 
   getProviderAtIndex(index: number): ResolvedReflectiveProvider {
     if (index < 0 || index >= this._providers.length) {
-      throw new OutOfBoundsError(index);
+      throw outOfBoundsError(index);
     }
     return this._providers[index];
   }
@@ -339,7 +339,7 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
   /** @internal */
   _new(provider: ResolvedReflectiveProvider): any {
     if (this._constructionCounter++ > this._getMaxNumberOfObjects()) {
-      throw new CyclicDependencyError(this, provider.key);
+      throw cyclicDependencyError(this, provider.key);
     }
     return this._instantiateProvider(provider);
   }
@@ -368,7 +368,7 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
       deps =
           ResolvedReflectiveFactory.dependencies.map(dep => this._getByReflectiveDependency(dep));
     } catch (e) {
-      if (e instanceof AbstractProviderError || e instanceof InstantiationError) {
+      if (e.addKey) {
         e.addKey(this, provider.key);
       }
       throw e;
@@ -378,7 +378,7 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
     try {
       obj = factory(...deps);
     } catch (e) {
-      throw new InstantiationError(this, e, e.stack, provider.key);
+      throw instantiationError(this, e, e.stack, provider.key);
     }
 
     return obj;
@@ -420,7 +420,7 @@ export class ReflectiveInjector_ implements ReflectiveInjector {
     if (notFoundValue !== THROW_IF_NOT_FOUND) {
       return notFoundValue;
     } else {
-      throw new NoProviderError(this, key);
+      throw noProviderError(this, key);
     }
   }
 

modules/@angular/core/src/di/reflective_provider.ts

@@ -12,7 +12,7 @@ import {Type} from '../type';
 import {resolveForwardRef} from './forward_ref';
 import {Host, Inject, Optional, Self, SkipSelf} from './metadata';
 import {ClassProvider, ExistingProvider, FactoryProvider, Provider, TypeProvider, ValueProvider} from './provider';
-import {InvalidProviderError, MixingMultiProvidersWithRegularProvidersError, NoAnnotationError} from './reflective_errors';
+import {invalidProviderError, mixingMultiProvidersWithRegularProvidersError, noAnnotationError} from './reflective_errors';
 import {ReflectiveKey} from './reflective_key';
 
 
@@ -154,7 +154,7 @@ export function mergeResolvedReflectiveProviders(
     const existing = normalizedProvidersMap.get(provider.key.id);
     if (existing) {
       if (provider.multiProvider !== existing.multiProvider) {
-        throw new MixingMultiProvidersWithRegularProvidersError(existing, provider);
+        throw mixingMultiProvidersWithRegularProvidersError(existing, provider);
       }
       if (provider.multiProvider) {
         for (let j = 0; j < provider.resolvedFactories.length; j++) {
@@ -189,7 +189,7 @@ function _normalizeProviders(providers: Provider[], res: Provider[]): Provider[]
       _normalizeProviders(b, res);
 
     } else {
-      throw new InvalidProviderError(b);
+      throw invalidProviderError(b);
     }
   });
 
@@ -211,7 +211,7 @@ function _dependenciesFor(typeOrFunc: any): ReflectiveDependency[] {
 
   if (!params) return [];
   if (params.some(p => p == null)) {
-    throw new NoAnnotationError(typeOrFunc, params);
+    throw noAnnotationError(typeOrFunc, params);
   }
   return params.map(p => _extractToken(typeOrFunc, p, params));
 }
@@ -253,7 +253,7 @@ function _extractToken(
   if (token != null) {
     return _createDependency(token, optional, visibility);
   } else {
-    throw new NoAnnotationError(typeOrFunc, params);
+    throw noAnnotationError(typeOrFunc, params);
   }
 }
 

modules/@angular/core/src/error_handler.ts

@@ -6,7 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {WrappedError} from './facade/errors';
+import {ERROR_ORIGINAL_ERROR, getDebugContext, getOriginalError} from './errors';
+
 
 /**
  * @whatItDoes Provides a hook for centralized exception handling.
@@ -48,24 +49,26 @@ export class ErrorHandler {
   constructor(rethrowError: boolean = true) { this.rethrowError = rethrowError; }
 
   handleError(error: any): void {
-    const originalError = this._findOriginalError(error);
-    const originalStack = this._findOriginalStack(error);
-    const context = this._findContext(error);
-
     this._console.error(`EXCEPTION: ${this._extractMessage(error)}`);
 
-    if (originalError) {
-      this._console.error(`ORIGINAL EXCEPTION: ${this._extractMessage(originalError)}`);
-    }
+    if (error instanceof Error) {
+      const originalError = this._findOriginalError(error);
+      const originalStack = this._findOriginalStack(error);
+      const context = this._findContext(error);
 
-    if (originalStack) {
-      this._console.error('ORIGINAL STACKTRACE:');
-      this._console.error(originalStack);
-    }
+      if (originalError) {
+        this._console.error(`ORIGINAL EXCEPTION: ${this._extractMessage(originalError)}`);
+      }
 
-    if (context) {
-      this._console.error('ERROR CONTEXT:');
-      this._console.error(context);
+      if (originalStack) {
+        this._console.error('ORIGINAL STACKTRACE:');
+        this._console.error(originalStack);
+      }
+
+      if (context) {
+        this._console.error('ERROR CONTEXT:');
+        this._console.error(context);
+      }
     }
 
     // We rethrow exceptions, so operations like 'bootstrap' will result in an error
@@ -81,31 +84,29 @@ export class ErrorHandler {
   /** @internal */
   _findContext(error: any): any {
     if (error) {
-      return error.context ? error.context :
-                             this._findContext((error as WrappedError).originalError);
+      return getDebugContext(error) ? getDebugContext(error) :
+                                      this._findContext(getOriginalError(error));
     }
 
     return null;
   }
 
   /** @internal */
-  _findOriginalError(error: any): any {
-    let e = (error as WrappedError).originalError;
-    while (e && (e as WrappedError).originalError) {
-      e = (e as WrappedError).originalError;
+  _findOriginalError(error: Error): any {
+    let e = getOriginalError(error);
+    while (e && getOriginalError(e)) {
+      e = getOriginalError(e);
     }
 
     return e;
   }
 
   /** @internal */
-  _findOriginalStack(error: any): string {
-    if (!(error instanceof Error)) return null;
-
+  _findOriginalStack(error: Error): string {
     let e: any = error;
     let stack: string = e.stack;
-    while (e instanceof Error && (e as WrappedError).originalError) {
-      e = (e as WrappedError).originalError;
+    while (e instanceof Error && getOriginalError(e)) {
+      e = getOriginalError(e);
       if (e instanceof Error && e.stack) {
         stack = e.stack;
       }
@@ -114,3 +115,11 @@ export class ErrorHandler {
     return stack;
   }
 }
+
+export function wrappedError(message: string, originalError: any): Error {
+  const msg =
+      `${message} caused by: ${originalError instanceof Error ? originalError.message: originalError }`;
+  const error = Error(msg);
+  (error as any)[ERROR_ORIGINAL_ERROR] = originalError;
+  return error;
+}

modules/@angular/core/src/errors.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Type} from './type';
+import {DebugContext} from './view';
+
+export const ERROR_TYPE = 'ngType';
+export const ERROR_COMPONENT_TYPE = 'ngComponentType';
+export const ERROR_DEBUG_CONTEXT = 'ngDebugContext';
+export const ERROR_ORIGINAL_ERROR = 'ngOriginalError';
+
+
+export function getType(error: Error): Function {
+  return (error as any)[ERROR_TYPE];
+}
+
+export function getDebugContext(error: Error): DebugContext {
+  return (error as any)[ERROR_DEBUG_CONTEXT];
+}
+
+export function getOriginalError(error: Error): Error {
+  return (error as any)[ERROR_ORIGINAL_ERROR];
+}

modules/@angular/core/src/linker/compiler.ts

@@ -7,7 +7,6 @@
  */
 
 import {Injectable, InjectionToken} from '../di';
-import {BaseError} from '../facade/errors';
 import {stringify} from '../facade/lang';
 import {MissingTranslationStrategy} from '../i18n/tokens';
 import {ViewEncapsulation} from '../metadata';
@@ -16,19 +15,6 @@ import {Type} from '../type';
 import {ComponentFactory} from './component_factory';
 import {NgModuleFactory} from './ng_module_factory';
 
-
-
-/**
- * Indicates that a component is still being loaded in a synchronous compile.
- *
- * @stable
- */
-export class ComponentStillLoadingError extends BaseError {
-  constructor(public compType: Type<any>) {
-    super(`Can't compile synchronously as ${stringify(compType)} is still being loaded!`);
-  }
-}
-
 /**
  * Combination of NgModuleFactory and ComponentFactorys.
  *
@@ -59,8 +45,7 @@ function _throwError() {
 export class Compiler {
   /**
    * Compiles the given NgModule and all of its components. All templates of the components listed
-   * in `entryComponents`
-   * have to be inlined. Otherwise throws a {@link ComponentStillLoadingError}.
+   * in `entryComponents` have to be inlined.
    */
   compileModuleSync<T>(moduleType: Type<T>): NgModuleFactory<T> { throw _throwError(); }
 

modules/@angular/core/src/linker/component_factory_resolver.ts

@@ -6,7 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {BaseError} from '../facade/errors';
 import {stringify} from '../facade/lang';
 import {Type} from '../type';
 
@@ -14,19 +13,23 @@ import {ComponentFactory} from './component_factory';
 
 
 
-/**
- * @stable
- */
-export class NoComponentFactoryError extends BaseError {
-  constructor(public component: Function) {
-    super(
-        `No component factory found for ${stringify(component)}. Did you add it to @NgModule.entryComponents?`);
-  }
+export function noComponentFactoryError(component: Function) {
+  const error = Error(
+      `No component factory found for ${stringify(component)}. Did you add it to @NgModule.entryComponents?`);
+  (error as any)[ERROR_COMPONENT] = component;
+  return error;
 }
 
+const ERROR_COMPONENT = 'ngComponent';
+
+export function getComponent(error: Error): Type<any> {
+  return (error as any)[ERROR_COMPONENT];
+}
+
+
 class _NullComponentFactoryResolver implements ComponentFactoryResolver {
   resolveComponentFactory<T>(component: {new (...args: any[]): T}): ComponentFactory<T> {
-    throw new NoComponentFactoryError(component);
+    throw noComponentFactoryError(component);
   }
 }
 

modules/@angular/core/src/linker/errors.ts

@@ -6,8 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {BaseError, WrappedError} from '../facade/errors';
-
+import {wrappedError} from '../error_handler';
+import {ERROR_DEBUG_CONTEXT, ERROR_TYPE} from '../errors';
 import {DebugContext} from './debug_context';
 
 
@@ -41,19 +41,19 @@ import {DebugContext} from './debug_context';
  *   }
  * }
  * ```
- * @stable
  */
-export class ExpressionChangedAfterItHasBeenCheckedError extends BaseError {
-  constructor(oldValue: any, currValue: any, isFirstCheck: boolean) {
-    let msg =
-        `Expression has changed after it was checked. Previous value: '${oldValue}'. Current value: '${currValue}'.`;
-    if (isFirstCheck) {
-      msg +=
-          ` It seems like the view has been created after its parent and its children have been dirty checked.` +
-          ` Has it been created in a change detection hook ?`;
-    }
-    super(msg);
+export function expressionChangedAfterItHasBeenCheckedError(
+    oldValue: any, currValue: any, isFirstCheck: boolean) {
+  let msg =
+      `Expression has changed after it was checked. Previous value: '${oldValue}'. Current value: '${currValue}'.`;
+  if (isFirstCheck) {
+    msg +=
+        ` It seems like the view has been created after its parent and its children have been dirty checked.` +
+        ` Has it been created in a change detection hook ?`;
   }
+  const error = Error(msg);
+  (error as any)[ERROR_TYPE] = expressionChangedAfterItHasBeenCheckedError;
+  return error;
 }
 
 /**
@@ -61,28 +61,21 @@ export class ExpressionChangedAfterItHasBeenCheckedError extends BaseError {
  *
  * This error wraps the original exception to attach additional contextual information that can
  * be useful for debugging.
- * @stable
  */
-export class ViewWrappedError extends WrappedError {
-  /**
-   * DebugContext
-   */
-  context: DebugContext;
-
-  constructor(originalError: any, context: DebugContext) {
-    super(`Error in ${context.source}`, originalError);
-    this.context = context;
-  }
+export function viewWrappedError(originalError: any, context: DebugContext): Error {
+  const error = wrappedError(`Error in ${context.source}`, originalError);
+  (error as any)[ERROR_DEBUG_CONTEXT] = context;
+  (error as any)[ERROR_TYPE] = viewWrappedError;
+  return error;
 }
 
 /**
- * Thrown when a destroyed view is used.
- *
- * This error indicates a bug in the framework.
- *
- * This is an internal Angular error.
- * @stable
- */
-export class ViewDestroyedError extends BaseError {
-  constructor(details: string) { super(`Attempt to use a destroyed view: ${details}`); }
+* Thrown when a destroyed view is used.
+*
+* This error indicates a bug in the framework.
+*
+* This is an internal Angular error.
+*/
+export function viewDestroyedError(details: string) {
+  return Error(`Attempt to use a destroyed view: ${details}`);
 }

modules/@angular/core/src/linker/view.ts

@@ -6,9 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+
 import {ApplicationRef} from '../application_ref';
 import {ChangeDetectorRef, ChangeDetectorStatus} from '../change_detection/change_detection';
 import {Injector, THROW_IF_NOT_FOUND} from '../di/injector';
+import {getType} from '../errors';
 import {isPresent} from '../facade/lang';
 import {WtfScopeFn, wtfCreateScope, wtfLeave} from '../profile/profile';
 import {DirectRenderer, RenderComponentType, Renderer} from '../render/api';
@@ -17,7 +19,7 @@ import {AnimationViewContext} from './animation_view_context';
 import {ComponentRef} from './component_factory';
 import {DebugContext, StaticNodeDebugInfo} from './debug_context';
 import {ElementInjector} from './element_injector';
-import {ExpressionChangedAfterItHasBeenCheckedError, ViewDestroyedError, ViewWrappedError} from './errors';
+import {expressionChangedAfterItHasBeenCheckedError, viewDestroyedError, viewWrappedError} from './errors';
 import {ViewContainer} from './view_container';
 import {ViewRef_} from './view_ref';
 import {ViewType} from './view_type';
@@ -360,7 +362,7 @@ export abstract class AppView<T> {
     return cb;
   }
 
-  throwDestroyedError(details: string): void { throw new ViewDestroyedError(details); }
+  throwDestroyedError(details: string): void { throw viewDestroyedError(details); }
 }
 
 export class DebugAppView<T> extends AppView<T> {
@@ -445,12 +447,12 @@ export class DebugAppView<T> extends AppView<T> {
   }
 
   private _rethrowWithContext(e: any) {
-    if (!(e instanceof ViewWrappedError)) {
-      if (!(e instanceof ExpressionChangedAfterItHasBeenCheckedError)) {
+    if (!(getType(e) == viewWrappedError)) {
+      if (!(getType(e) == expressionChangedAfterItHasBeenCheckedError)) {
         this.cdMode = ChangeDetectorStatus.Errored;
       }
       if (isPresent(this._currentDebugContext)) {
-        throw new ViewWrappedError(e, this._currentDebugContext);
+        throw viewWrappedError(e, this._currentDebugContext);
       }
     }
   }

modules/@angular/core/src/linker/view_utils.ts

@@ -17,7 +17,7 @@ import {Type} from '../type';
 import {VERSION} from '../version';
 
 import {ComponentFactory} from './component_factory';
-import {ExpressionChangedAfterItHasBeenCheckedError} from './errors';
+import {expressionChangedAfterItHasBeenCheckedError} from './errors';
 import {AppView} from './view';
 
 @Injectable()
@@ -104,7 +104,7 @@ export function checkBinding(
   const isFirstCheck = view.numberOfChecks === 0;
   if (view.throwOnChange) {
     if (isFirstCheck || !devModeEqual(oldValue, newValue)) {
-      throw new ExpressionChangedAfterItHasBeenCheckedError(oldValue, newValue, isFirstCheck);
+      throw expressionChangedAfterItHasBeenCheckedError(oldValue, newValue, isFirstCheck);
     }
     return false;
   } else {

modules/@angular/core/src/view/errors.ts

@@ -6,12 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {BaseError, WrappedError} from '../facade/errors';
-
+import {ERROR_DEBUG_CONTEXT, ERROR_ORIGINAL_ERROR, getDebugContext} from '../errors';
 import {DebugContext, EntryAction, ViewState} from './types';
 
 export function expressionChangedAfterItHasBeenCheckedError(
-    context: DebugContext, oldValue: any, currValue: any, isFirstCheck: boolean): ViewDebugError {
+    context: DebugContext, oldValue: any, currValue: any, isFirstCheck: boolean): Error {
   let msg =
       `Expression has changed after it was checked. Previous value: '${oldValue}'. Current value: '${currValue}'.`;
   if (isFirstCheck) {
@@ -22,25 +21,22 @@ export function expressionChangedAfterItHasBeenCheckedError(
   return viewDebugError(msg, context);
 }
 
-export function viewWrappedDebugError(originalError: any, context: DebugContext): WrappedError&
-    ViewDebugError {
-  const err = viewDebugError(originalError.message, context) as WrappedError & ViewDebugError;
-  err.originalError = originalError;
+export function viewWrappedDebugError(originalError: any, context: DebugContext): Error {
+  const err = viewDebugError(originalError.message, context);
+  (err as any)[ERROR_ORIGINAL_ERROR] = originalError;
   return err;
 }
 
-export interface ViewDebugError { context: DebugContext; }
-
-export function viewDebugError(msg: string, context: DebugContext): ViewDebugError {
-  const err = new Error(msg) as any;
-  err.context = context;
+export function viewDebugError(msg: string, context: DebugContext): Error {
+  const err = new Error(msg);
+  (err as any)[ERROR_DEBUG_CONTEXT] = context;
   err.stack = context.source;
   context.view.state |= ViewState.Errored;
   return err;
 }
 
-export function isViewDebugError(err: any): boolean {
-  return err.context;
+export function isViewDebugError(err: Error): boolean {
+  return !!getDebugContext(err);
 }
 
 export function viewDestroyedError(action: EntryAction): Error {

modules/@angular/core/src/view/view.ts

@@ -6,9 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {isDevMode} from '../application_ref';
 import {RenderComponentType, Renderer} from '../render/api';
-
 import {checkAndUpdateElementDynamic, checkAndUpdateElementInline, createElement} from './element';
 import {expressionChangedAfterItHasBeenCheckedError} from './errors';
 import {appendNgContent} from './ng_content';

modules/@angular/core/test/di/reflective_injector_spec.ts

@@ -9,6 +9,7 @@
 import {Inject, Injectable, Injector, Optional, Provider, ReflectiveInjector, ReflectiveKey, Self, forwardRef} from '@angular/core';
 import {ReflectiveInjector_} from '@angular/core/src/di/reflective_injector';
 import {ResolvedReflectiveProvider_} from '@angular/core/src/di/reflective_provider';
+import {getOriginalError} from '@angular/core/src/errors';
 import {expect} from '@angular/platform-browser/testing/matchers';
 
 import {isPresent, stringify} from '../../src/facade/lang';
@@ -293,8 +294,8 @@ export function main() {
       } catch (e) {
         expect(e.message).toContain(
             `Error during instantiation of Engine! (${stringify(Car)} -> Engine)`);
-        expect(e.originalError instanceof Error).toBeTruthy();
-        expect(e.causeKey.token).toEqual(Engine);
+        expect(getOriginalError(e) instanceof Error).toBeTruthy();
+        expect(e.keys[0].token).toEqual(Engine);
       }
     });
 

modules/@angular/core/test/error_handler_spec.ts

@@ -6,22 +6,17 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {WrappedError} from '@angular/core/src/facade/errors';
+import {ERROR_DEBUG_CONTEXT} from '@angular/core/src/errors';
 import {DebugContext} from '@angular/core/src/linker/debug_context';
-import {ViewWrappedError} from '@angular/core/src/linker/errors';
+import {viewWrappedError} from '@angular/core/src/linker/errors';
 
-import {ErrorHandler} from '../src/error_handler';
+import {ErrorHandler, wrappedError} from '../src/error_handler';
 
 class MockConsole {
   res: any[] = [];
   error(s: any): void { this.res.push(s); }
 }
 
-class _CustomException {
-  context = 'some context';
-  toString(): string { return 'custom'; }
-}
-
 export function main() {
   function errorToString(error: any) {
     const logger = new MockConsole();
@@ -58,12 +53,9 @@ export function main() {
       it('should print nested context', () => {
         const cause = new Error('message!');
         const stack = getStack(cause);
-        const context = {
-          source: 'context!',
-          toString() { return 'Context'; }
-        } as any as DebugContext;
-        const original = new ViewWrappedError(cause, context);
-        const e = errorToString(new WrappedError('message', original));
+        const context = { source: 'context!', toString() { return 'Context'; } } as any;
+        const original = viewWrappedError(cause, context);
+        const e = errorToString(wrappedError('message', original));
         expect(e).toEqual(
             stack ? `EXCEPTION: message caused by: Error in context! caused by: message!
 ORIGINAL EXCEPTION: message!
@@ -81,15 +73,15 @@ Context`);
     describe('original exception', () => {
       it('should print original exception message if available (original is Error)', () => {
         const realOriginal = new Error('inner');
-        const original = new WrappedError('wrapped', realOriginal);
-        const e = errorToString(new WrappedError('wrappedwrapped', original));
+        const original = wrappedError('wrapped', realOriginal);
+        const e = errorToString(wrappedError('wrappedwrapped', original));
         expect(e).toContain('inner');
       });
 
       it('should print original exception message if available (original is not Error)', () => {
-        const realOriginal = new _CustomException();
-        const original = new WrappedError('wrapped', realOriginal);
-        const e = errorToString(new WrappedError('wrappedwrapped', original));
+        const realOriginal = new Error('custom');
+        const original = wrappedError('wrapped', realOriginal);
+        const e = errorToString(wrappedError('wrappedwrapped', original));
         expect(e).toContain('custom');
       });
     });
@@ -99,8 +91,8 @@ Context`);
         const realOriginal = new Error('inner');
         const stack = getStack(realOriginal);
         if (stack) {
-          const original = new WrappedError('wrapped', realOriginal);
-          const e = errorToString(new WrappedError('wrappedwrapped', original));
+          const original = wrappedError('wrapped', realOriginal);
+          const e = errorToString(wrappedError('wrappedwrapped', original));
           expect(e).toContain(stack);
         }
       });

modules/@angular/core/test/linker/entry_components_integration_spec.ts

@@ -7,7 +7,7 @@
  */
 
 import {ANALYZE_FOR_ENTRY_COMPONENTS, Component, ComponentFactoryResolver} from '@angular/core';
-import {NoComponentFactoryError} from '@angular/core/src/linker/component_factory_resolver';
+import {noComponentFactoryError} from '@angular/core/src/linker/component_factory_resolver';
 import {TestBed} from '@angular/core/testing';
 
 import {Console} from '../../src/console';
@@ -77,7 +77,7 @@ function declareTests({useJit}: {useJit: boolean}) {
       const nestedChildComp: NestedChildComp = nestedChildCompEl.componentInstance;
       expect(nestedChildComp.cfr.resolveComponentFactory(ChildComp).componentType).toBe(ChildComp);
       expect(() => nestedChildComp.cfr.resolveComponentFactory(NestedChildComp))
-          .toThrow(new NoComponentFactoryError(NestedChildComp));
+          .toThrow(noComponentFactoryError(NestedChildComp));
     });
 
   });

modules/@angular/core/test/linker/integration_spec.ts

@@ -9,6 +9,7 @@
 import {CommonModule} from '@angular/common';
 import {ComponentFactory, Host, Inject, Injectable, InjectionToken, Injector, NO_ERRORS_SCHEMA, NgModule, OnDestroy, ReflectiveInjector, SkipSelf} from '@angular/core';
 import {ChangeDetectionStrategy, ChangeDetectorRef, PipeTransform} from '@angular/core/src/change_detection/change_detection';
+import {getDebugContext} from '@angular/core/src/errors';
 import {ComponentFactoryResolver} from '@angular/core/src/linker/component_factory_resolver';
 import {ElementRef} from '@angular/core/src/linker/element_ref';
 import {QueryList} from '@angular/core/src/linker/query_list';
@@ -1295,7 +1296,7 @@ function declareTests({useJit}: {useJit: boolean}) {
           TestBed.createComponent(MyComp);
           throw 'Should throw';
         } catch (e) {
-          const c = e.context;
+          const c = getDebugContext(e);
           expect(getDOM().nodeName(c.componentRenderElement).toUpperCase()).toEqual('DIV');
           expect((<Injector>c.injector).get).toBeTruthy();
         }
@@ -1310,7 +1311,7 @@ function declareTests({useJit}: {useJit: boolean}) {
           fixture.detectChanges();
           throw 'Should throw';
         } catch (e) {
-          const c = e.context;
+          const c = getDebugContext(e);
           expect(getDOM().nodeName(c.renderNode).toUpperCase()).toEqual('INPUT');
           expect(getDOM().nodeName(c.componentRenderElement).toUpperCase()).toEqual('DIV');
           expect((<Injector>c.injector).get).toBeTruthy();
@@ -1330,7 +1331,7 @@ function declareTests({useJit}: {useJit: boolean}) {
              fixture.detectChanges();
              throw 'Should throw';
            } catch (e) {
-             const c = e.context;
+             const c = getDebugContext(e);
              expect(c.renderNode).toBeTruthy();
              expect(c.source).toContain(':0:5');
            }
@@ -1353,7 +1354,7 @@ function declareTests({useJit}: {useJit: boolean}) {
              try {
                tc.injector.get(DirectiveEmittingEvent).fireEvent('boom');
              } catch (e) {
-               const c = e.context;
+               const c = getDebugContext(e);
                expect(getDOM().nodeName(c.renderNode).toUpperCase()).toEqual('SPAN');
                expect(getDOM().nodeName(c.componentRenderElement).toUpperCase()).toEqual('DIV');
                expect((<Injector>c.injector).get).toBeTruthy();

modules/@angular/core/test/view/element_spec.ts

@@ -7,6 +7,7 @@
  */
 
 import {Injector, RenderComponentType, RootRenderer, Sanitizer, SecurityContext, ViewEncapsulation, WrappedValue, getDebugNode} from '@angular/core';
+import {getDebugContext} from '@angular/core/src/errors';
 import {BindingType, DebugContext, NodeDef, NodeFlags, RootData, ViewData, ViewDefinition, ViewFlags, ViewHandleEventFn, ViewUpdateFn, anchorDef, asElementData, checkAndUpdateView, checkNoChangesView, checkNodeDynamic, checkNodeInline, createRootView, destroyView, elementDef, rootRenderNodes, setCurrentNode, textDef, viewDef} from '@angular/core/src/view/index';
 import {inject} from '@angular/core/testing';
 import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
@@ -363,7 +364,7 @@ function defineTests(config: {directDom: boolean, viewFlags: number}) {
           }
           expect(err).toBeTruthy();
           expect(err.message).toBe('Test');
-          const debugCtx = <DebugContext>err.context;
+          const debugCtx = getDebugContext(err);
           expect(debugCtx.view).toBe(view);
           expect(debugCtx.nodeIndex).toBe(0);
         });

modules/@angular/core/test/view/provider_spec.ts

@@ -7,6 +7,7 @@
  */
 
 import {AfterContentChecked, AfterContentInit, AfterViewChecked, AfterViewInit, ChangeDetectorRef, DoCheck, ElementRef, EventEmitter, Injector, OnChanges, OnDestroy, OnInit, RenderComponentType, Renderer, RootRenderer, Sanitizer, SecurityContext, SimpleChange, TemplateRef, ViewContainerRef, ViewEncapsulation, WrappedValue, getDebugNode} from '@angular/core';
+import {getDebugContext} from '@angular/core/src/errors';
 import {BindingType, DebugContext, DepFlags, NodeDef, NodeFlags, ProviderType, RootData, ViewData, ViewDefinition, ViewFlags, ViewHandleEventFn, ViewUpdateFn, anchorDef, asElementData, asProviderData, checkAndUpdateView, checkNoChangesView, checkNodeDynamic, checkNodeInline, createRootView, destroyView, directiveDef, elementDef, providerDef, rootRenderNodes, setCurrentNode, textDef, viewDef} from '@angular/core/src/view/index';
 import {inject} from '@angular/core/testing';
 import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
@@ -135,7 +136,7 @@ function defineTests(config: {directDom: boolean, viewFlags: number}) {
         }
         expect(err).toBeTruthy();
         expect(err.message).toBe('Test');
-        const debugCtx = <DebugContext>err.context;
+        const debugCtx = getDebugContext(err);
         expect(debugCtx.view).toBeTruthy();
         // errors should point to the already existing element
         expect(debugCtx.nodeIndex).toBe(0);
@@ -447,7 +448,7 @@ function defineTests(config: {directDom: boolean, viewFlags: number}) {
           err = e;
         }
         expect(err).toBeTruthy();
-        const debugCtx = <DebugContext>err.context;
+        const debugCtx = getDebugContext(err);
         expect(debugCtx.view).toBe(view);
         // events are emitted with the index of the element, not the index of the provider.
         expect(debugCtx.nodeIndex).toBe(0);
@@ -576,7 +577,7 @@ function defineTests(config: {directDom: boolean, viewFlags: number}) {
         }
         expect(err).toBeTruthy();
         expect(err.message).toBe('Test');
-        const debugCtx = <DebugContext>err.context;
+        const debugCtx = getDebugContext(err);
         expect(debugCtx.view).toBe(view);
         expect(debugCtx.nodeIndex).toBe(1);
       });
@@ -599,7 +600,7 @@ function defineTests(config: {directDom: boolean, viewFlags: number}) {
         }
         expect(err).toBeTruthy();
         expect(err.message).toBe('Test');
-        const debugCtx = <DebugContext>err.context;
+        const debugCtx = getDebugContext(err);
         expect(debugCtx.view).toBe(view);
         expect(debugCtx.nodeIndex).toBe(1);
       });

modules/@angular/core/test/view/query_spec.ts

@@ -7,6 +7,7 @@
  */
 
 import {ElementRef, Injector, QueryList, RenderComponentType, RootRenderer, Sanitizer, SecurityContext, TemplateRef, ViewContainerRef, ViewEncapsulation, getDebugNode} from '@angular/core';
+import {getDebugContext} from '@angular/core/src/errors';
 import {BindingType, DebugContext, NodeDef, NodeFlags, QueryBindingType, QueryValueType, RootData, ViewData, ViewDefinition, ViewFlags, ViewHandleEventFn, ViewUpdateFn, anchorDef, asElementData, asProviderData, attachEmbeddedView, checkAndUpdateView, checkNoChangesView, checkNodeDynamic, checkNodeInline, createEmbeddedView, createRootView, destroyView, detachEmbeddedView, directiveDef, elementDef, queryDef, rootRenderNodes, setCurrentNode, textDef, viewDef} from '@angular/core/src/view/index';
 import {inject} from '@angular/core/testing';
 import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';
@@ -395,7 +396,7 @@ export function main() {
         expect(err.message)
             .toBe(
                 `Expression has changed after it was checked. Previous value: 'Query query1 not dirty'. Current value: 'Query query1 dirty'.`);
-        const debugCtx = <DebugContext>err.context;
+        const debugCtx = getDebugContext(err);
         expect(debugCtx.view).toBe(view);
         expect(debugCtx.nodeIndex).toBe(2);
       });
@@ -421,10 +422,10 @@ export function main() {
         }
         expect(err).toBeTruthy();
         expect(err.message).toBe('Test');
-        const debugCtx = <DebugContext>err.context;
+        const debugCtx = getDebugContext(err);
         expect(debugCtx.view).toBe(view);
         expect(debugCtx.nodeIndex).toBe(2);
       });
     });
   });
-}
+}

modules/@angular/core/test/zone/ng_zone_spec.ts

@@ -10,7 +10,6 @@ import {NgZone} from '@angular/core/src/zone/ng_zone';
 import {async, fakeAsync, flushMicrotasks} from '@angular/core/testing';
 import {AsyncTestCompleter, Log, beforeEach, describe, expect, inject, it, xit} from '@angular/core/testing/testing_internal';
 import {browserDetection} from '@angular/platform-browser/testing/browser_util';
-import {BaseError} from '../../src/facade/errors';
 import {isPresent, scheduleMicroTask} from '../../src/facade/lang';
 
 const needsLongerTimers = browserDetection.isSlow || browserDetection.isEdge;
@@ -94,7 +93,7 @@ export function main() {
                setTimeout(() => {
                  setTimeout(() => {
                    resolve(null);
-                   throw new BaseError('ccc');
+                   throw new Error('ccc');
                  }, 0);
                }, 0);
              });
@@ -117,7 +116,7 @@ export function main() {
                scheduleMicroTask(() => {
                  scheduleMicroTask(() => {
                    resolve(null);
-                   throw new BaseError('ddd');
+                   throw new Error('ddd');
                  });
                });
              });
@@ -152,7 +151,7 @@ export function main() {
                setTimeout(() => {
                  setTimeout(() => {
                    resolve(null);
-                   throw new BaseError('ccc');
+                   throw new Error('ccc');
                  }, 0);
                }, 0);
              });
@@ -719,7 +718,7 @@ function commonTests() {
     it('should call the on error callback when it is invoked via zone.runGuarded',
        inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
          macroTask(() => {
-           const exception = new BaseError('sync');
+           const exception = new Error('sync');
 
            _zone.runGuarded(() => { throw exception; });
 
@@ -732,7 +731,7 @@ function commonTests() {
     it('should not call the on error callback but rethrow when it is invoked via zone.run',
        inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
          macroTask(() => {
-           const exception = new BaseError('sync');
+           const exception = new Error('sync');
            expect(() => _zone.run(() => { throw exception; })).toThrowError('sync');
 
            expect(_errors.length).toBe(0);
@@ -742,7 +741,7 @@ function commonTests() {
 
     it('should call onError for errors from microtasks',
        inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
-         const exception = new BaseError('async');
+         const exception = new Error('async');
 
          macroTask(() => { _zone.run(() => { scheduleMicroTask(() => { throw exception; }); }); });
 

modules/@angular/core/testing/test_bed.ts

@@ -6,8 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {CompilerOptions, Component, Directive, InjectionToken, Injector, ModuleWithComponentFactories, NgModule, NgModuleRef, NgZone, Pipe, PlatformRef, Provider, ReflectiveInjector, SchemaMetadata, Type} from '@angular/core';
-
+import {CompilerOptions, Component, Directive, InjectionToken, Injector, ModuleWithComponentFactories, NgModule, NgModuleRef, NgZone, Pipe, PlatformRef, Provider, ReflectiveInjector, SchemaMetadata, Type, __core_private__} from '@angular/core';
 import {AsyncTestCompleter} from './async_test_completer';
 import {ComponentFixture} from './component_fixture';
 import {stringify} from './facade/lang';
@@ -266,9 +265,9 @@ export class TestBed implements Injector {
         this._moduleWithComponentFactories =
             this._compiler.compileModuleAndAllComponentsSync(moduleType);
       } catch (e) {
-        if (e.compType) {
+        if (getComponentType(e)) {
           throw new Error(
-              `This test module uses the component ${stringify(e.compType)} which is using a "templateUrl" or "styleUrls", but they were never compiled. ` +
+              `This test module uses the component ${stringify(getComponentType(e))} which is using a "templateUrl" or "styleUrls", but they were never compiled. ` +
               `Please call "TestBed.compileComponents" before your test.`);
         } else {
           throw e;
@@ -471,3 +470,7 @@ export function withModule(moduleDef: TestModuleMetadata, fn: Function = null):
   }
   return new InjectSetupWrapper(() => moduleDef);
 }
+
+function getComponentType(error: Error): Function {
+  return (error as any)[__core_private__.ERROR_COMPONENT_TYPE];
+}

modules/@angular/core/testing/test_compiler.ts

@@ -8,9 +8,11 @@
 
 import {Compiler, CompilerOptions, Component, Directive, Injector, NgModule, Pipe, Type} from '@angular/core';
 
-import {unimplemented} from './facade/errors';
 import {MetadataOverride} from './metadata_override';
 
+function unimplemented(): any {
+  throw Error('unimplemented');
+}
 
 /**
  * Special interface to the compiler only used by testing

modules/@angular/facade/src/errors.ts

@@ -1,56 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-/**
- * Convenience to throw an Error with 'unimplemented' as the message.
- */
-export function unimplemented(): any {
-  throw new Error('unimplemented');
-}
-
-/**
- * @stable
- */
-export class BaseError extends Error {
-  /** @internal **/
-  _nativeError: Error;
-
-  constructor(message: string) {
-    super(message);
-    // Errors don't use current this, instead they create a new instance.
-    // We have to do forward all of our api to the nativeInstance.
-    // TODO(bradfordcsmith): Remove this hack when
-    //     google/closure-compiler/issues/2102 is fixed.
-    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(); }
-}
-
-/**
- * @stable
- */
-export 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;
-  }
-}

modules/@angular/upgrade/test/static/integration/upgrade_component_spec.ts

@@ -1436,21 +1436,21 @@ export function main() {
 
              bootstrap(platformBrowserDynamic(), Ng2Module, elementA, ng1Module).then(() => {
                expect(mockExceptionHandler).toHaveBeenCalledWith(jasmine.objectContaining({
-                 originalError: new Error(
+                 ngOriginalError: new Error(
                      'Unable to find required \'iDoNotExist\' in upgraded directive \'ng1A\'.')
                }));
              });
 
              bootstrap(platformBrowserDynamic(), Ng2Module, elementB, ng1Module).then(() => {
                expect(mockExceptionHandler).toHaveBeenCalledWith(jasmine.objectContaining({
-                 originalError: new Error(
+                 ngOriginalError: new Error(
                      'Unable to find required \'^iDoNotExist\' in upgraded directive \'ng1B\'.')
                }));
              });
 
              bootstrap(platformBrowserDynamic(), Ng2Module, elementC, ng1Module).then(() => {
                expect(mockExceptionHandler).toHaveBeenCalledWith(jasmine.objectContaining({
-                 originalError: new Error(
+                 ngOriginalError: new Error(
                      'Unable to find required \'^^iDoNotExist\' in upgraded directive \'ng1C\'.')
                }));
              });

modules/benchmarks/src/tree/ng2_ftl/ftl_util.ts

@@ -8,7 +8,7 @@
 
 import {ComponentFactory, ComponentRef, ElementRef, Injector, TemplateRef, ViewContainerRef, ViewRef} from '@angular/core';
 import {devModeEqual, looseIdentical} from '@angular/core/src/change_detection/change_detection_util';
-import {ExpressionChangedAfterItHasBeenCheckedError} from '@angular/core/src/linker/errors';
+import {expressionChangedAfterItHasBeenCheckedError} from '@angular/core/src/linker/errors';
 
 
 export function unimplemented(): any {
@@ -212,10 +212,10 @@ export function createAnchorAndAppend(parent: any) {
 export function checkBinding(throwOnChange: boolean, oldValue: any, newValue: any): boolean {
   if (throwOnChange) {
     if (!devModeEqual(oldValue, newValue)) {
-      throw new ExpressionChangedAfterItHasBeenCheckedError(oldValue, newValue, false);
+      throw expressionChangedAfterItHasBeenCheckedError(oldValue, newValue, false);
     }
     return false;
   } else {
     return !looseIdentical(oldValue, newValue);
   }
-}
+}

modules/benchmarks/src/tree/ng2_static_ftl/ftl_util.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import {devModeEqual, looseIdentical} from '@angular/core/src/change_detection/change_detection_util';
-import {ExpressionChangedAfterItHasBeenCheckedError} from '@angular/core/src/linker/errors';
+import {expressionChangedAfterItHasBeenCheckedError} from '@angular/core/src/linker/errors';
 
 export function createElementAndAppend(parent: any, name: string) {
   const el = document.createElement(name);
@@ -29,10 +29,10 @@ export function createAnchorAndAppend(parent: any) {
 export function checkBinding(throwOnChange: boolean, oldValue: any, newValue: any): boolean {
   if (throwOnChange) {
     if (!devModeEqual(oldValue, newValue)) {
-      throw new ExpressionChangedAfterItHasBeenCheckedError(oldValue, newValue, false);
+      throw expressionChangedAfterItHasBeenCheckedError(oldValue, newValue, false);
     }
     return false;
   } else {
     return !looseIdentical(oldValue, newValue);
   }
-}
+}