fix(compiler): fix merge error in compiler_host

This change retracts support for metadata version 2.

The collector used to produce version 2 metadata was incomplete
and can cause the AOT compiler to fail to resolve symbols or
produce other spurious errors.

All libraries compiled and published with 2.3.0 ngc will need
to be recompiled and updated with this change.

CHANGELOG.md

@@ -1,77 +1,3 @@
-<a name="2.4.0"></a>
-# [2.4.0 stability-interjection](https://github.com/angular/angular/compare/2.3.1...2.4.0) (2016-12-20)
-
-
-### Bug Fixes
-
-* **animations:** allow players to be destroyed before initialized ([#13346](https://github.com/angular/angular/issues/13346)) ([b36f4bc](https://github.com/angular/angular/commit/b36f4bc)), closes [#13293](https://github.com/angular/angular/issues/13293)
-* **build:** use bash string comparison operator ([#13502](https://github.com/angular/angular/issues/13502)) ([50afbe0](https://github.com/angular/angular/commit/50afbe0))
-* **compiler:** do not lex `}}` when interpolation is disabled ([#13531](https://github.com/angular/angular/issues/13531)) ([9b87bb6](https://github.com/angular/angular/commit/9b87bb6)), closes [#13525](https://github.com/angular/angular/issues/13525)
-* **compiler-cli:** produce metadata for .d.ts files without metadata ([#13526](https://github.com/angular/angular/issues/13526)) ([debb0c9](https://github.com/angular/angular/commit/debb0c9)), closes [#13307](https://github.com/angular/angular/issues/13307) [#13473](https://github.com/angular/angular/issues/13473) [#13521](https://github.com/angular/angular/issues/13521)
-* **i18n:** add a default example to xmb placeholders ([#13507](https://github.com/angular/angular/issues/13507)) ([3f17841](https://github.com/angular/angular/commit/3f17841))
-* **upgrade:** fix `registerForNg1Tests` ([#13522](https://github.com/angular/angular/issues/13522)) ([c26c24c](https://github.com/angular/angular/commit/c26c24c))
-
-
-### Features
-
-* update to `rxjs@5.0.1` and unpin the rxjs peerDeps via `^5.0.1` ([#13572](https://github.com/angular/angular/issues/13572)) ([8d5da1e](https://github.com/angular/angular/commit/8d5da1e)), closes [#13561](https://github.com/angular/angular/issues/13561) [#13478](https://github.com/angular/angular/issues/13478)
-
-
-
-<a name="2.3.1"></a>
-## [2.3.1](https://github.com/angular/angular/compare/2.3.0...2.3.1) (2016-12-15)
-
-
-### Bug Fixes
-
-* **animations:** always cleanup players after they have finished internally ([#13334](https://github.com/angular/angular/issues/13334)) ([a26e054](https://github.com/angular/angular/commit/a26e054)), closes [#13333](https://github.com/angular/angular/issues/13333)
-* **animations:** throw errors and normalize offset beyond the range of [0,1] ([6557bc3](https://github.com/angular/angular/commit/6557bc3)), closes [#13348](https://github.com/angular/angular/issues/13348) [#13440](https://github.com/angular/angular/issues/13440)
-* **compiler:** emit quoted object literal keys if the source is quoted ([ecfad46](https://github.com/angular/angular/commit/ecfad46)), closes [#13249](https://github.com/angular/angular/issues/13249) [#13356](https://github.com/angular/angular/issues/13356)
-* **compiler:** fix merge error in compiler_host ([69b52eb](https://github.com/angular/angular/commit/69b52eb))
-* **compiler:** fix PR 13322 ([#13331](https://github.com/angular/angular/issues/13331)) ([79728b4](https://github.com/angular/angular/commit/79728b4))
-* **compiler:** fix simplify a reference without a name ([1c279b3](https://github.com/angular/angular/commit/1c279b3)), closes [#13470](https://github.com/angular/angular/issues/13470)
-* **compiler:** fix transpiled ES5 code ([#13322](https://github.com/angular/angular/issues/13322)) ([6c1d790](https://github.com/angular/angular/commit/6c1d790)), closes [#13301](https://github.com/angular/angular/issues/13301)
-* **compiler:** generated CSS files suffixed with ngstyle. ([#13353](https://github.com/angular/angular/issues/13353)) ([c8a9b70](https://github.com/angular/angular/commit/c8a9b70)), closes [#13141](https://github.com/angular/angular/issues/13141)
-* **compiler:** make sure provider values with `name` property don’t break. ([efa2d80](https://github.com/angular/angular/commit/efa2d80)), closes [#13394](https://github.com/angular/angular/issues/13394) [#13445](https://github.com/angular/angular/issues/13445)
-* **compiler:** narrow the span reported for invalid pipes ([307d305](https://github.com/angular/angular/commit/307d305)), closes [#13326](https://github.com/angular/angular/issues/13326) [#13411](https://github.com/angular/angular/issues/13411)
-* **compiler:** propagate exports when upgrading metadata to v2 ([f6ef7d6](https://github.com/angular/angular/commit/f6ef7d6))
-* **compiler:** resolver should merge host bindings and listeners ([#13474](https://github.com/angular/angular/issues/13474)) ([6aeaca3](https://github.com/angular/angular/commit/6aeaca3)), closes [#13327](https://github.com/angular/angular/issues/13327)
-* **compiler:** support dotted property binding ([8db184d](https://github.com/angular/angular/commit/8db184d)), closes [angular/flex-layout#34](https://github.com/angular/flex-layout/issues/34)
-* **compiler:** update to metadata version 3 ([#13464](https://github.com/angular/angular/issues/13464)) ([b9b557c](https://github.com/angular/angular/commit/b9b557c))
-* **core:** detectChanges() doesn't work on detached instance ([4d6ac9d](https://github.com/angular/angular/commit/4d6ac9d)), closes [#13426](https://github.com/angular/angular/issues/13426) [#13472](https://github.com/angular/angular/issues/13472)
-* **core:** properly destroy embedded Views attatched to ApplicationRef ([#13459](https://github.com/angular/angular/issues/13459)) ([d40bbf4](https://github.com/angular/angular/commit/d40bbf4)), closes [#13062](https://github.com/angular/angular/issues/13062)
-* **core:** remove logError from logGroup ([#12925](https://github.com/angular/angular/issues/12925)) ([5fab871](https://github.com/angular/angular/commit/5fab871))
-* **forms:** ensure `select[multiple]` retains selections ([b3dcff0](https://github.com/angular/angular/commit/b3dcff0)), closes [#12527](https://github.com/angular/angular/issues/12527) [#12654](https://github.com/angular/angular/issues/12654)
-* **forms:** fix Validators.min/maxLength with FormArray ([#13095](https://github.com/angular/angular/issues/13095)) ([7383e4a](https://github.com/angular/angular/commit/7383e4a)), closes [#13089](https://github.com/angular/angular/issues/13089)
-* **forms:** introduce checkbox required validator ([124267c](https://github.com/angular/angular/commit/124267c)), closes [#11459](https://github.com/angular/angular/issues/11459) [#13364](https://github.com/angular/angular/issues/13364)
-* **http:** check response body text against undefined ([#13017](https://github.com/angular/angular/issues/13017)) ([f106a18](https://github.com/angular/angular/commit/f106a18))
-* **http:** create a copy of headers when merge options ([#13365](https://github.com/angular/angular/issues/13365)) ([65c9b5b](https://github.com/angular/angular/commit/65c9b5b)), closes [#11980](https://github.com/angular/angular/issues/11980)
-* **language-service:** correctly type `undefined` ([0a7364f](https://github.com/angular/angular/commit/0a7364f)), closes [#13412](https://github.com/angular/angular/issues/13412) [#13414](https://github.com/angular/angular/issues/13414)
-* **compiler**: better error when directive not listed in NgModule.declarations ([b0cd514](https://github.com/angular/angular/commit/b0cd514))
-* **language-service:** treat string unions as strings ([#13406](https://github.com/angular/angular/issues/13406)) ([14dd2b3](https://github.com/angular/angular/commit/14dd2b3)), closes [#13403](https://github.com/angular/angular/issues/13403)
-* **router:** add support for query params with multiple values ([e4d5a5f](https://github.com/angular/angular/commit/e4d5a5f)), closes [#11373](https://github.com/angular/angular/issues/11373)
-* **router:** Use T type in Resolve interface ([#13242](https://github.com/angular/angular/issues/13242)) ([5ee8155](https://github.com/angular/angular/commit/5ee8155))
-* **selector:** SelectorMatcher match elements with :not selector ([#12977](https://github.com/angular/angular/issues/12977)) ([392c9ac](https://github.com/angular/angular/commit/392c9ac))
-* **tsc-wrapped:** generate metadata for exports without module specifier ([cd03c77](https://github.com/angular/angular/commit/cd03c77)), closes [#13327](https://github.com/angular/angular/issues/13327)
-* **upgrade:** fix downgrade content projection and injector inheritance ([86c5098](https://github.com/angular/angular/commit/86c5098)), closes [#6629](https://github.com/angular/angular/issues/6629) [#7727](https://github.com/angular/angular/issues/7727) [#8729](https://github.com/angular/angular/issues/8729) [#9643](https://github.com/angular/angular/issues/9643) [#9649](https://github.com/angular/angular/issues/9649) [#12675](https://github.com/angular/angular/issues/12675)
-* **upgrade:** enable Angular 1 unit testing of upgrade module ([2fc0560](https://github.com/angular/angular/commit/2fc0560)), closes [#5462](https://github.com/angular/angular/issues/5462) [#12675](https://github.com/angular/angular/issues/12675)
-
-
-### Performance Improvements
-
-* **animations:** always run the animation queue outside of zones ([e2622ad](https://github.com/angular/angular/commit/e2622ad)), closes [#13440](https://github.com/angular/angular/issues/13440)
-
-### Note ###
-
-Due to regression in the 2.3.0 release that was fixed by [#13464](https://github.com/angular/angular/pull/13464), 
-components that have been compiled using 2.3.0 and published to npm will need to be recompiled and republished.
-
-The >=2.3.1 compiler will issue is the following error if it encounters components compiled with 2.3.0:  
-`Unsupported metadata version 2 for module ${module}. This module should be compiled with a newer version of ngc`.
-
-We are adding more tests to our test suite to catch these kinds of problems before we cut a release.
-
-
 <a name="2.3.0"></a>
 # [2.3.0](https://github.com/angular/angular/compare/2.3.0-rc.0...2.3.0) (2016-12-07)
 

DEVELOPER.md

@@ -1,6 +1,6 @@
-# Building and Testing Angular
+# Building and Testing Angular 2 for JS
 
-This document describes how to set up your development environment to build and test Angular.
+This document describes how to set up your development environment to build and test Angular 2 JS version. 
 It also explains the basic mechanics of using `git`, `node`, and `npm`.
 
 * [Prerequisite Software](#prerequisite-software)
@@ -137,21 +137,4 @@ You can automatically format your code by running:
 $ gulp format
 ```
 
-## Publishing your own personal snapshot build
 
-You may find that your un-merged change needs some validation from external participants.
-Rather than requiring them to pull your Pull Request and build Angular locally, you can
-publish the `*-builds` snapshots just like our Travis build does.
-
-First time, you need to create the github repositories:
-
-``` shell
-$ export TOKEN=[get one from https://github.com/settings/tokens]
-$ CREATE_REPOS=1 ./scripts/publish/publish-build-artifacts.sh [github username]
-```
-
-For subsequent snapshots, just run
-
-``` shell
-$ ./scripts/publish/publish-build-artifacts.sh [github username]
-```

karma-js.conf.js

@@ -24,25 +24,17 @@ module.exports = function(config) {
       'node_modules/core-js/client/core.js',
       // include Angular v1 for upgrade module testing
       'node_modules/angular/angular.js',
-      'node_modules/angular-mocks/angular-mocks.js',
 
-      'node_modules/zone.js/dist/zone.js',
-      'node_modules/zone.js/dist/long-stack-trace-zone.js',
-      'node_modules/zone.js/dist/proxy.js',
-      'node_modules/zone.js/dist/sync-test.js',
-      'node_modules/zone.js/dist/jasmine-patch.js',
-      'node_modules/zone.js/dist/async-test.js',
+      'node_modules/zone.js/dist/zone.js', 'node_modules/zone.js/dist/long-stack-trace-zone.js',
+      'node_modules/zone.js/dist/proxy.js', 'node_modules/zone.js/dist/sync-test.js',
+      'node_modules/zone.js/dist/jasmine-patch.js', 'node_modules/zone.js/dist/async-test.js',
       'node_modules/zone.js/dist/fake-async-test.js',
 
       // Including systemjs because it defines `__eval`, which produces correct stack traces.
-      'shims_for_IE.js',
-      'node_modules/systemjs/dist/system.src.js',
+      'shims_for_IE.js', 'node_modules/systemjs/dist/system.src.js',
       {pattern: 'node_modules/rxjs/**', included: false, watched: false, served: true},
-      'node_modules/reflect-metadata/Reflect.js',
-      'tools/build/file2modulename.js',
-      'test-main.js',
-      {pattern: 'dist/all/empty.*', included: false, watched: false},
-      {
+      'node_modules/reflect-metadata/Reflect.js', 'tools/build/file2modulename.js', 'test-main.js',
+      {pattern: 'dist/all/empty.*', included: false, watched: false}, {
         pattern: 'modules/@angular/platform-browser/test/static_assets/**',
         included: false,
         watched: false

modules/@angular/benchpress/package.json

@@ -7,7 +7,7 @@
   "dependencies": {
     "@angular/core": "^2.0.0-rc.7",
     "reflect-metadata": "^0.1.2",
-    "rxjs": "^5.0.1",
+    "rxjs": "5.0.0-rc.4",
     "jpm": "1.1.4",
     "firefox-profile": "0.4.0",
     "selenium-webdriver": "^2.53.3"

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

@@ -12,9 +12,9 @@
  * Entry point for all public APIs of the common package.
  */
 export * from './location/index';
-export {NgLocalization} from './localization';
+export {NgLocaleLocalization, NgLocalization} from './localization';
 export {CommonModule} from './common_module';
 export {NgClass, NgFor, NgIf, NgPlural, NgPluralCase, NgStyle, NgSwitch, NgSwitchCase, NgSwitchDefault, NgTemplateOutlet} from './directives/index';
-export {AsyncPipe, DatePipe, I18nPluralPipe, I18nSelectPipe, JsonPipe, LowerCasePipe, CurrencyPipe, DecimalPipe, PercentPipe, SlicePipe, UpperCasePipe} from './pipes/index';
+export {AsyncPipe, DatePipe, I18nPluralPipe, I18nSelectPipe, JsonPipe, LowerCasePipe, CurrencyPipe, DecimalPipe, PercentPipe, SlicePipe, UpperCasePipe, TitleCasePipe} from './pipes/index';
 export {VERSION} from './version';
 export {Version} from '@angular/core';

modules/@angular/common/src/directives/ng_if.ts

@@ -6,46 +6,152 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Directive, Input, TemplateRef, ViewContainerRef} from '@angular/core';
+import {Directive, EmbeddedViewRef, Input, TemplateRef, ViewContainerRef} from '@angular/core';
+
 
 /**
- * Removes or recreates a portion of the DOM tree based on an {expression}.
+ * Conditionally includes a template based on the value of an `expression`.
  *
- * If the expression assigned to `ngIf` evaluates to a falsy value then the element
- * is removed from the DOM, otherwise a clone of the element is reinserted into the DOM.
+ * `ngIf` evaluates the `expression` and then renders the `then` or `else` template in its place
+ * when expression is thruthy or falsy respectively. Typically the:
+ *  - `then` template is the inline template of `ngIf` unless bound to a different value.
+ *  - `else` template is blank unless its bound.
  *
- * ### Example ([live demo](http://plnkr.co/edit/fe0kgemFBtmQOY31b4tw?p=preview)):
+ * # Most common usage
+ *
+ * The most common usage of the `ngIf` is to conditionally show the inline template as seen in this
+ * example:
+ * {@example common/ngIf/ts/module.ts region='NgIfSimple'}
+ *
+ * # Showing an alternative template using `else`
+ *
+ * If it is necessary to display a template when the `expression` is falsy use the `else` template
+ * binding as shown. Note that the `else` binding points to a `<template>` labeled `#elseBlock`.
+ * The template can be defined anywhere in the component view but is typically placed right after
+ * `ngIf` for readability.
+ *
+ * {@example common/ngIf/ts/module.ts region='NgIfElse'}
+ *
+ * # Using non-inlined `then` template
+ *
+ * Usually the `then` template is the inlined template of the `ngIf`, but it can be changed using
+ * a binding (just like `else`). Because `then` and `else` are bindings, the template references can
+ * change at runtime as shown in thise example.
+ *
+ * {@example common/ngIf/ts/module.ts region='NgIfThenElse'}
+ *
+ * # Storing conditional result in a variable
+ *
+ * A common patter is that we need to show a set of properties from the same object. if the
+ * object is undefined, then we have to use the safe-traversal-operator `?.` to guard against
+ * dereferencing a `null` value. This is especially the case when waiting on async data such as
+ * when using the `async` pipe as shown in folowing example:
  *
  * ```
- * <div *ngIf="errorCount > 0" class="error">
- *   <!-- Error message displayed when the errorCount property in the current context is greater
- * than 0. -->
- *   {{errorCount}} errors detected
- * </div>
+ * Hello {{ (userStream|async)?.last }}, {{ (userStream|async)?.first }}!
  * ```
  *
+ * There are several inefficiencies in the above example.
+ *  - We create multiple subscriptions on the `userStream`. One for each `async` pipe, or two
+ *    as shown in the example above.
+ *  - We can not display an alternative screen while waiting for the data to arrive asynchronously.
+ *  - We have to use the safe-traversal-operator `?.` to access properties, which is cumbersome.
+ *  - We have to place the `async` pipe in parenthesis.
+ *
+ * A better way to do this is to use `ngIf` and store the result of the condition in a local
+ * variable as shown in the the example below:
+ *
+ * {@example common/ngIf/ts/module.ts region='NgIfLet'}
+ *
+ * Notice that:
+ *  - We use only one `async` pipe and hence only one subscription gets created.
+ *  - `ngIf` stores the result of the `userStream|async` in the local variable `user`.
+ *  - The local `user` can than be bound repeatedly in a more efficient way.
+ *  - No need to use the safe-traversal-operator `?.` to access properties as `ngIf` will only
+ *    display the data if `userStream` returns a value.
+ *  - We can display an alternative template while waiting for the data.
+ *
  * ### Syntax
  *
+ * Simple form:
  * - `<div *ngIf="condition">...</div>`
  * - `<div template="ngIf condition">...</div>`
- * - `<template [ngIf]="condition"><div>...</div></template>`
+ * - `<ng-container [ngIf]="condition"><div>...</div></ng-container>`
+ *
+ * Form with an else block:
+ * ```
+ * <div *ngIf="condition; else elseBlock">...</div>
+ * <template #elseBlock>...</template>
+ * ```
+ *
+ * Form with a `then` and `else` block:
+ * ```
+ * <div *ngIf="condition; then thenBlock else elseBlock"></div>
+ * <template #thenBlock>...</template>
+ * <template #elseBlock>...</template>
+ * ```
+ *
+ * Form with storing the value locally:
+ * ```
+ * <div *ngIf="condition; else elseBlock; let value">{{value}}</div>
+ * <template #elseBlock>...</template>
+ * ```
  *
  * @stable
  */
 @Directive({selector: '[ngIf]'})
 export class NgIf {
-  private _hasView = false;
+  private _context: NgIfContext = new NgIfContext();
+  private _thenTemplateRef: TemplateRef<NgIfContext> = null;
+  private _elseTemplateRef: TemplateRef<NgIfContext> = null;
+  private _thenViewRef: EmbeddedViewRef<NgIfContext> = null;
+  private _elseViewRef: EmbeddedViewRef<NgIfContext> = null;
 
-  constructor(private _viewContainer: ViewContainerRef, private _template: TemplateRef<Object>) {}
+  constructor(private _viewContainer: ViewContainerRef, templateRef: TemplateRef<NgIfContext>) {
+    this._thenTemplateRef = templateRef;
+  }
 
   @Input()
   set ngIf(condition: any) {
-    if (condition && !this._hasView) {
-      this._hasView = true;
-      this._viewContainer.createEmbeddedView(this._template);
-    } else if (!condition && this._hasView) {
-      this._hasView = false;
-      this._viewContainer.clear();
+    this._context.$implicit = condition;
+    this._updateView();
+  }
+
+  @Input()
+  set ngIfThen(templateRef: TemplateRef<NgIfContext>) {
+    this._thenTemplateRef = templateRef;
+    this._thenViewRef = null;  // clear previous view if any.
+    this._updateView();
+  }
+
+  @Input()
+  set ngIfElse(templateRef: TemplateRef<NgIfContext>) {
+    this._elseTemplateRef = templateRef;
+    this._elseViewRef = null;  // clear previous view if any.
+    this._updateView();
+  }
+
+  private _updateView() {
+    if (this._context.$implicit) {
+      if (!this._thenViewRef) {
+        this._viewContainer.clear();
+        this._elseViewRef = null;
+        if (this._thenTemplateRef) {
+          this._thenViewRef =
+              this._viewContainer.createEmbeddedView(this._thenTemplateRef, this._context);
+        }
+      }
+    } else {
+      if (!this._elseViewRef) {
+        this._viewContainer.clear();
+        this._thenViewRef = null;
+        if (this._elseTemplateRef) {
+          this._elseViewRef =
+              this._viewContainer.createEmbeddedView(this._elseTemplateRef, this._context);
+        }
+      }
     }
   }
 }
+
+export class NgIfContext { public $implicit: any = null; }

modules/@angular/common/src/localization.ts

@@ -49,10 +49,10 @@ export function getPluralCategory(
  */
 @Injectable()
 export class NgLocaleLocalization extends NgLocalization {
-  constructor(@Inject(LOCALE_ID) private _locale: string) { super(); }
+  constructor(@Inject(LOCALE_ID) protected locale: string) { super(); }
 
   getPluralCategory(value: any): string {
-    const plural = getPluralCase(this._locale, value);
+    const plural = getPluralCase(this.locale, value);
 
     switch (plural) {
       case Plural.Zero:

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

@@ -0,0 +1,61 @@
+/**
+ * @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 {Pipe, PipeTransform} from '@angular/core';
+import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
+
+/**
+ * Transforms text to lowercase.
+ *
+ * {@example  core/pipes/ts/lowerupper_pipe/lowerupper_pipe_example.ts region='LowerUpperPipe' }
+ *
+ * @stable
+ */
+@Pipe({name: 'lowercase'})
+export class LowerCasePipe implements PipeTransform {
+  transform(value: string): string {
+    if (!value) return value;
+    if (typeof value !== 'string') {
+      throw new InvalidPipeArgumentError(LowerCasePipe, value);
+    }
+    return value.toLowerCase();
+  }
+}
+
+/**
+ * Transforms text to titlecase.
+ *
+ * @stable
+ */
+@Pipe({name: 'titlecase'})
+export class TitleCasePipe implements PipeTransform {
+  transform(value: string): string {
+    if (!value) return value;
+    if (typeof value !== 'string') {
+      throw new InvalidPipeArgumentError(TitleCasePipe, value);
+    }
+
+    return value[0].toUpperCase() + value.substr(1).toLowerCase();
+  }
+}
+
+/**
+ * Transforms text to uppercase.
+ *
+ * @stable
+ */
+@Pipe({name: 'uppercase'})
+export class UpperCasePipe implements PipeTransform {
+  transform(value: string): string {
+    if (!value) return value;
+    if (typeof value !== 'string') {
+      throw new InvalidPipeArgumentError(UpperCasePipe, value);
+    }
+    return value.toUpperCase();
+  }
+}

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

@@ -12,14 +12,13 @@
  * This module provides a set of common Pipes.
  */
 import {AsyncPipe} from './async_pipe';
+import {LowerCasePipe, TitleCasePipe, UpperCasePipe} from './case_conversion_pipes';
 import {DatePipe} from './date_pipe';
 import {I18nPluralPipe} from './i18n_plural_pipe';
 import {I18nSelectPipe} from './i18n_select_pipe';
 import {JsonPipe} from './json_pipe';
-import {LowerCasePipe} from './lowercase_pipe';
 import {CurrencyPipe, DecimalPipe, PercentPipe} from './number_pipe';
 import {SlicePipe} from './slice_pipe';
-import {UpperCasePipe} from './uppercase_pipe';
 
 export {
   AsyncPipe,
@@ -32,9 +31,11 @@ export {
   LowerCasePipe,
   PercentPipe,
   SlicePipe,
+  TitleCasePipe,
   UpperCasePipe
 };
 
+
 /**
  * A collection of Angular pipes that are likely to be used in each and every application.
  */
@@ -46,6 +47,7 @@ export const COMMON_PIPES = [
   SlicePipe,
   DecimalPipe,
   PercentPipe,
+  TitleCasePipe,
   CurrencyPipe,
   DatePipe,
   I18nPluralPipe,

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

@@ -1,37 +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
- */
-
-import {Pipe, PipeTransform} from '@angular/core';
-import {isBlank} from '../facade/lang';
-import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
-
-
-/**
- * @ngModule CommonModule
- * @whatItDoes Transforms string to lowercase.
- * @howToUse `expression | lowercase`
- * @description
- *
- * Converts value into a lowercase string using `String.prototype.toLowerCase()`.
- *
- * ### Example
- *
- * {@example common/pipes/ts/lowerupper_pipe.ts region='LowerUpperPipe'}
- *
- * @stable
- */
-@Pipe({name: 'lowercase'})
-export class LowerCasePipe implements PipeTransform {
-  transform(value: string): string {
-    if (isBlank(value)) return value;
-    if (typeof value !== 'string') {
-      throw new InvalidPipeArgumentError(LowerCasePipe, value);
-    }
-    return value.toLowerCase();
-  }
-}

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

@@ -1,36 +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
- */
-
-import {Pipe, PipeTransform} from '@angular/core';
-import {isBlank} from '../facade/lang';
-import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
-
-/**
- * @ngModule CommonModule
- * @whatItDoes Transforms string to uppercase.
- * @howToUse `expression | uppercase`
- * @description
- *
- * Converts value into an uppercase string using `String.prototype.toUpperCase()`.
- *
- * ### Example
- *
- * {@example common/pipes/ts/lowerupper_pipe.ts region='LowerUpperPipe'}
- *
- * @stable
- */
-@Pipe({name: 'uppercase'})
-export class UpperCasePipe implements PipeTransform {
-  transform(value: string): string {
-    if (isBlank(value)) return value;
-    if (typeof value !== 'string') {
-      throw new InvalidPipeArgumentError(UpperCasePipe, value);
-    }
-    return value.toUpperCase();
-  }
-}

modules/@angular/common/test/directives/ng_if_spec.ts

@@ -153,6 +153,78 @@ export function main() {
          expect(getDOM().hasClass(getDOM().querySelector(fixture.nativeElement, 'span'), 'foo'))
              .toBe(true);
        }));
+
+    describe('else', () => {
+      it('should support else', async(() => {
+           const template = '<div>' +
+               '<span *ngIf="booleanCondition; else elseBlock">TRUE</span>' +
+               '<template #elseBlock>FALSE</template>' +
+               '</div>';
+
+           fixture = createTestComponent(template);
+
+           fixture.detectChanges();
+           expect(fixture.nativeElement).toHaveText('TRUE');
+
+           getComponent().booleanCondition = false;
+           fixture.detectChanges();
+           expect(fixture.nativeElement).toHaveText('FALSE');
+         }));
+
+      it('should support then and else', async(() => {
+           const template = '<div>' +
+               '<span *ngIf="booleanCondition; then thenBlock; else elseBlock">IGNORE</span>' +
+               '<template #thenBlock>THEN</template>' +
+               '<template #elseBlock>ELSE</template>' +
+               '</div>';
+
+           fixture = createTestComponent(template);
+
+           fixture.detectChanges();
+           expect(fixture.nativeElement).toHaveText('THEN');
+
+           getComponent().booleanCondition = false;
+           fixture.detectChanges();
+           expect(fixture.nativeElement).toHaveText('ELSE');
+         }));
+
+      it('should support dynamic else', async(() => {
+           const template = '<div>' +
+               '<span *ngIf="booleanCondition; else nestedBooleanCondition ? b1 : b2">TRUE</span>' +
+               '<template #b1>FALSE1</template>' +
+               '<template #b2>FALSE2</template>' +
+               '</div>';
+
+           fixture = createTestComponent(template);
+
+           fixture.detectChanges();
+           expect(fixture.nativeElement).toHaveText('TRUE');
+
+           getComponent().booleanCondition = false;
+           fixture.detectChanges();
+           expect(fixture.nativeElement).toHaveText('FALSE1');
+
+           getComponent().nestedBooleanCondition = false;
+           fixture.detectChanges();
+           expect(fixture.nativeElement).toHaveText('FALSE2');
+         }));
+
+      it('should support binding to variable', async(() => {
+           const template = '<div>' +
+               '<span *ngIf="booleanCondition; else elseBlock; let v">{{v}}</span>' +
+               '<template #elseBlock let-v>{{v}}</template>' +
+               '</div>';
+
+           fixture = createTestComponent(template);
+
+           fixture.detectChanges();
+           expect(fixture.nativeElement).toHaveText('true');
+
+           getComponent().booleanCondition = false;
+           fixture.detectChanges();
+           expect(fixture.nativeElement).toHaveText('false');
+         }));
+    });
   });
 }
 

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

@@ -0,0 +1,59 @@
+/**
+ * @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 {LowerCasePipe, TitleCasePipe, UpperCasePipe} from '@angular/common';
+
+export function main() {
+  describe('LowerCasePipe', () => {
+    let pipe: LowerCasePipe;
+
+    beforeEach(() => { pipe = new LowerCasePipe(); });
+
+    it('should return lowercase', () => { expect(pipe.transform('FOO')).toEqual('foo'); });
+
+    it('should lowercase when there is a new value', () => {
+      expect(pipe.transform('FOO')).toEqual('foo');
+      expect(pipe.transform('BAr')).toEqual('bar');
+    });
+
+    it('should not support other objects',
+       () => { expect(() => pipe.transform(<any>{})).toThrowError(); });
+  });
+
+  describe('TitleCasePipe', () => {
+    let pipe: TitleCasePipe;
+
+    beforeEach(() => { pipe = new TitleCasePipe(); });
+
+    it('should return titlecase', () => { expect(pipe.transform('foo')).toEqual('Foo'); });
+
+    it('should titlecase when there is a new value', () => {
+      expect(pipe.transform('bar')).toEqual('Bar');
+      expect(pipe.transform('foo')).toEqual('Foo');
+    });
+
+    it('should not support other objects',
+       () => { expect(() => pipe.transform(<any>{})).toThrowError(); });
+  });
+
+  describe('UpperCasePipe', () => {
+    let pipe: UpperCasePipe;
+
+    beforeEach(() => { pipe = new UpperCasePipe(); });
+
+    it('should return uppercase', () => { expect(pipe.transform('foo')).toEqual('FOO'); });
+
+    it('should uppercase when there is a new value', () => {
+      expect(pipe.transform('foo')).toEqual('FOO');
+      expect(pipe.transform('bar')).toEqual('BAR');
+    });
+
+    it('should not support other objects',
+       () => { expect(() => pipe.transform(<any>{})).toThrowError(); });
+  });
+}

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

@@ -1,42 +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
- */
-
-import {LowerCasePipe} from '@angular/common';
-import {beforeEach, describe, expect, it} from '@angular/core/testing/testing_internal';
-
-export function main() {
-  describe('LowerCasePipe', () => {
-    let upper: string;
-    let lower: string;
-    let pipe: LowerCasePipe;
-
-    beforeEach(() => {
-      lower = 'something';
-      upper = 'SOMETHING';
-      pipe = new LowerCasePipe();
-    });
-
-    describe('transform', () => {
-      it('should return lowercase', () => {
-        const val = pipe.transform(upper);
-        expect(val).toEqual(lower);
-      });
-
-      it('should lowercase when there is a new value', () => {
-        const val = pipe.transform(upper);
-        expect(val).toEqual(lower);
-        const val2 = pipe.transform('WAT');
-        expect(val2).toEqual('wat');
-      });
-
-      it('should not support other objects',
-         () => { expect(() => pipe.transform(<any>{})).toThrowError(); });
-    });
-
-  });
-}

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

@@ -1,43 +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
- */
-
-import {UpperCasePipe} from '@angular/common';
-import {beforeEach, describe, expect, it} from '@angular/core/testing/testing_internal';
-
-export function main() {
-  describe('UpperCasePipe', () => {
-    let upper: string;
-    let lower: string;
-    let pipe: UpperCasePipe;
-
-    beforeEach(() => {
-      lower = 'something';
-      upper = 'SOMETHING';
-      pipe = new UpperCasePipe();
-    });
-
-    describe('transform', () => {
-
-      it('should return uppercase', () => {
-        const val = pipe.transform(lower);
-        expect(val).toEqual(upper);
-      });
-
-      it('should uppercase when there is a new value', () => {
-        const val = pipe.transform(lower);
-        expect(val).toEqual(upper);
-        const val2 = pipe.transform('wat');
-        expect(val2).toEqual('WAT');
-      });
-
-      it('should not support other objects',
-         () => { expect(() => pipe.transform(<any>{})).toThrowError(); });
-    });
-
-  });
-}

modules/@angular/compiler-cli/integrationtest/ngtools_src/app.component.html

@@ -1,5 +1,5 @@
 <div>
-  <h1 i18n>hello world</h1>
+  <h1>hello world</h1>
   <a [routerLink]="['lazy']">lazy</a>
   <router-outlet></router-outlet>
 </div>

modules/@angular/compiler-cli/integrationtest/test/i18n_spec.ts

@@ -34,9 +34,9 @@ const EXPECTED_XMB = `<?xml version="1.0" encoding="UTF-8" ?>
 <!ELEMENT ex (#PCDATA)>
 ]>
 <messagebundle>
+  <msg id="3772663375917578720">other-3rdP-component</msg>
   <msg id="8136548302122759730" desc="desc" meaning="meaning">translate me</msg>
   <msg id="3492007542396725315">Welcome</msg>
-  <msg id="3772663375917578720">other-3rdP-component</msg>
 </messagebundle>
 `;
 
@@ -44,6 +44,10 @@ const EXPECTED_XLIFF = `<?xml version="1.0" encoding="UTF-8" ?>
 <xliff version="1.2" xmlns="urn:oasis:names:tc:xliff:document:1.2">
   <file source-language="en" datatype="plaintext" original="ng2.template">
     <body>
+      <trans-unit id="63a85808f03b8181e36a952e0fa38202c2304862" datatype="html">
+        <source>other-3rdP-component</source>
+        <target/>
+      </trans-unit>
       <trans-unit id="76e1eccb1b772fa9f294ef9c146ea6d0efa8a2d4" datatype="html">
         <source>translate me</source>
         <target/>
@@ -54,10 +58,6 @@ const EXPECTED_XLIFF = `<?xml version="1.0" encoding="UTF-8" ?>
         <source>Welcome</source>
         <target/>
       </trans-unit>
-      <trans-unit id="63a85808f03b8181e36a952e0fa38202c2304862" datatype="html">
-        <source>other-3rdP-component</source>
-        <target/>
-      </trans-unit>
     </body>
   </file>
 </xliff>

modules/@angular/compiler-cli/integrationtest/test/test_ngtools_api.ts

@@ -19,6 +19,7 @@ import {AngularCompilerOptions, CodeGenerator, CompilerHostContext, NodeCompiler
 
 const glob = require('glob');
 
+
 /**
  * Main method.
  * Standalone program that executes codegen using the ngtools API and tests that files were
@@ -29,7 +30,6 @@ function main() {
 
   Promise.resolve()
       .then(() => codeGenTest())
-      .then(() => i18nTest())
       .then(() => lazyRoutesTest())
       .then(() => {
         console.log('All done!');
@@ -42,6 +42,7 @@ function main() {
       });
 }
 
+
 function codeGenTest() {
   const basePath = path.join(__dirname, '../ngtools_src');
   const project = path.join(basePath, 'tsconfig-build.json');
@@ -51,9 +52,12 @@ function codeGenTest() {
   const config = tsc.readConfiguration(project, basePath);
   const hostContext = new NodeCompilerHostContext();
   const delegateHost = ts.createCompilerHost(config.parsed.options, true);
-  const host: ts.CompilerHost = Object.assign(
-      {}, delegateHost,
-      {writeFile: (fileName: string, ...rest: any[]) => { wroteFiles.push(fileName); }});
+  const host: ts.CompilerHost = Object.assign({}, delegateHost, {
+    writeFile: (fileName: string, ...rest: any[]) => {
+      wroteFiles.push(fileName);
+      return delegateHost.writeFile.call(delegateHost, fileName, ...rest);
+    }
+  });
   const program = ts.createProgram(config.parsed.fileNames, config.parsed.options, host);
 
   config.ngOptions.basePath = basePath;
@@ -108,67 +112,6 @@ function codeGenTest() {
       });
 }
 
-function i18nTest() {
-  const basePath = path.join(__dirname, '../ngtools_src');
-  const project = path.join(basePath, 'tsconfig-build.json');
-  const readResources: string[] = [];
-  const wroteFiles: string[] = [];
-
-  const config = tsc.readConfiguration(project, basePath);
-  const hostContext = new NodeCompilerHostContext();
-  const delegateHost = ts.createCompilerHost(config.parsed.options, true);
-  const host: ts.CompilerHost = Object.assign(
-      {}, delegateHost,
-      {writeFile: (fileName: string, ...rest: any[]) => { wroteFiles.push(fileName); }});
-  const program = ts.createProgram(config.parsed.fileNames, config.parsed.options, host);
-
-  config.ngOptions.basePath = basePath;
-
-  console.log(`>>> running i18n extraction for ${project}`);
-  return __NGTOOLS_PRIVATE_API_2
-      .extractI18n({
-        basePath,
-        compilerOptions: config.parsed.options, program, host,
-        angularCompilerOptions: config.ngOptions,
-        i18nFormat: 'xlf',
-        readResource: (fileName: string) => {
-          readResources.push(fileName);
-          return hostContext.readResource(fileName);
-        },
-      })
-      .then(() => {
-        console.log(`>>> i18n extraction done, asserting read and wrote files`);
-
-        const allFiles = glob.sync(path.join(basePath, '**/*'), {nodir: true});
-
-        assert(wroteFiles.length == 1, `Expected a single message bundle file.`);
-
-        assert(
-            wroteFiles[0].endsWith('/ngtools_src/messages.xlf'),
-            `Expected the bundle file to be "message.xlf".`);
-
-        allFiles.forEach((fileName: string) => {
-          // Skip tsconfig.
-          if (fileName.match(/tsconfig-build.json$/)) {
-            return;
-          }
-
-          // Assert that file was read.
-          if (fileName.match(/\.css$/) || fileName.match(/\.html$/)) {
-            assert(
-                readResources.indexOf(fileName) != -1,
-                `Expected resource "${fileName}" to be read.`);
-          }
-        });
-
-        console.log(`done, no errors.`);
-      })
-      .catch((e: any) => {
-        console.error(e.stack);
-        console.error('Extraction failed');
-        throw e;
-      });
-}
 
 function lazyRoutesTest() {
   const basePath = path.join(__dirname, '../ngtools_src');

modules/@angular/compiler-cli/integrationtest/test/test_summaries.ts

@@ -27,14 +27,9 @@ function main() {
   const basePath = path.resolve(__dirname, '..');
   const project = path.resolve(basePath, 'tsconfig-build.json');
   const readFiles: string[] = [];
-  const writtenFiles: {fileName: string, content: string}[] = [];
 
   class AssertingHostContext extends NodeCompilerHostContext {
     readFile(fileName: string): string {
-      if (/.*\/node_modules\/.*/.test(fileName) && !/.*ngsummary\.json$/.test(fileName)) {
-        // Only allow to read summaries from node_modules
-        return null;
-      }
       readFiles.push(path.relative(basePath, fileName));
       return super.readFile(fileName);
     }
@@ -50,29 +45,16 @@ function main() {
   config.ngOptions.generateCodeForLibraries = false;
 
   console.log(`>>> running codegen for ${project}`);
-  codegen(
-      config,
-      (host) => {
-        host.writeFile = (fileName: string, content: string) => {
-          fileName = path.relative(basePath, fileName);
-          writtenFiles.push({fileName, content});
-        };
-        return new AssertingHostContext();
-      })
+  codegen(config, (host) => new AssertingHostContext())
       .then((exitCode: any) => {
         console.log(`>>> codegen done, asserting read files`);
         assertSomeFileMatch(readFiles, /^node_modules\/.*\.ngsummary\.json$/);
-        assertNoFileMatch(readFiles, /^node_modules\/.*\.metadata.json$/);
         assertNoFileMatch(readFiles, /^node_modules\/.*\.html$/);
         assertNoFileMatch(readFiles, /^node_modules\/.*\.css$/);
 
         assertNoFileMatch(readFiles, /^src\/.*\.ngsummary\.json$/);
         assertSomeFileMatch(readFiles, /^src\/.*\.html$/);
         assertSomeFileMatch(readFiles, /^src\/.*\.css$/);
-
-        console.log(`>>> asserting written files`);
-        assertWrittenFile(writtenFiles, /^src\/module\.ngfactory\.ts$/, /class MainModuleInjector/);
-
         console.log(`done, no errors.`);
         process.exit(exitCode);
       })
@@ -115,11 +97,4 @@ function assertNoFileMatch(fileNames: string[], pattern: RegExp) {
       `Expected no read files match ${pattern}, but found: \n${matches.join('\n')}`);
 }
 
-function assertWrittenFile(
-    files: {fileName: string, content: string}[], filePattern: RegExp, contentPattern: RegExp) {
-  assert(
-      files.some(file => filePattern.test(file.fileName) && contentPattern.test(file.content)),
-      `Expected some written files for ${filePattern} and content ${contentPattern}`);
-}
-
 main();

modules/@angular/compiler-cli/package.json

@@ -9,7 +9,7 @@
     "ng-xi18n": "./src/extract_i18n.js"
   },
   "dependencies": {
-    "@angular/tsc-wrapped": "0.5.0",
+    "@angular/tsc-wrapped": "0.4.2",
     "reflect-metadata": "^0.1.2",
     "minimist": "^1.2.0"
   },

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

@@ -21,7 +21,9 @@ import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './
 import {PathMappedCompilerHost} from './path_mapped_compiler_host';
 import {Console} from './private_import_core';
 
+const GENERATED_FILES = /\.ngfactory\.ts$|\.ngstyle\.ts$/;
 const GENERATED_META_FILES = /\.json$/;
+const GENERATED_OR_DTS_FILES = /\.d\.ts$|\.ngfactory\.ts$|\.ngstyle\.ts$/;
 
 const PREAMBLE = `/**
  * @fileoverview This file is generated by the Angular 2 template compiler.
@@ -100,8 +102,14 @@ export class CodeGenerator {
       debug: options.debug === true,
       translations: transContent,
       i18nFormat: cliOptions.i18nFormat,
-      locale: cliOptions.locale
+      locale: cliOptions.locale,
+      excludeFilePattern: options.generateCodeForLibraries === false ? GENERATED_OR_DTS_FILES :
+                                                                       GENERATED_FILES
     });
     return new CodeGenerator(options, program, tsCompilerHost, aotCompiler, ngCompilerHost);
   }
 }
+
+export function excludeFilePattern(options: AngularCompilerOptions): RegExp {
+  return options.generateCodeForLibraries === false ? GENERATED_OR_DTS_FILES : GENERATED_FILES;
+}

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

@@ -16,8 +16,6 @@ const EXT = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
 const DTS = /\.d\.ts$/;
 const NODE_MODULES = '/node_modules/';
 const IS_GENERATED = /\.(ngfactory|ngstyle)$/;
-const GENERATED_FILES = /\.ngfactory\.ts$|\.ngstyle\.ts$/;
-const GENERATED_OR_DTS_FILES = /\.d\.ts$|\.ngfactory\.ts$|\.ngstyle\.ts$/;
 
 export interface CompilerHostContext extends ts.ModuleResolutionHost {
   readResource(fileName: string): Promise<string>;
@@ -30,7 +28,6 @@ export class CompilerHost implements AotCompilerHost {
   protected basePath: string;
   private genDir: string;
   private resolverCache = new Map<string, ModuleMetadata[]>();
-  protected resolveModuleNameHost: CompilerHostContext;
 
   constructor(
       protected program: ts.Program, protected options: AngularCompilerOptions,
@@ -41,31 +38,12 @@ export class CompilerHost implements AotCompilerHost {
 
     const genPath: string = path.relative(this.basePath, this.genDir);
     this.isGenDirChildOfRootDir = genPath === '' || !genPath.startsWith('..');
-    this.resolveModuleNameHost = Object.create(this.context);
-
-    // When calling ts.resolveModuleName,
-    // additional allow checks for .d.ts files to be done based on
-    // checks for .ngsummary.json files,
-    // so that our codegen depends on fewer inputs and requires to be called
-    // less often.
-    // This is needed as we use ts.resolveModuleName in reflector_host
-    // and it should be able to resolve summary file names.
-    this.resolveModuleNameHost.fileExists = (fileName: string): boolean => {
-      if (this.context.fileExists(fileName)) {
-        return true;
-      }
-      if (DTS.test(fileName)) {
-        const base = fileName.substring(0, fileName.length - 5);
-        return this.context.fileExists(base + '.ngsummary.json');
-      }
-      return false;
-    };
   }
 
   // We use absolute paths on disk as canonical.
   getCanonicalFileName(fileName: string): string { return fileName; }
 
-  moduleNameToFileName(m: string, containingFile: string): string|null {
+  moduleNameToFileName(m: string, containingFile: string) {
     if (!containingFile || !containingFile.length) {
       if (m.indexOf('.') === 0) {
         throw new Error('Resolution of relative paths requires a containing file.');
@@ -75,8 +53,7 @@ export class CompilerHost implements AotCompilerHost {
     }
     m = m.replace(EXT, '');
     const resolved =
-        ts.resolveModuleName(
-              m, containingFile.replace(/\\/g, '/'), this.options, this.resolveModuleNameHost)
+        ts.resolveModuleName(m, containingFile.replace(/\\/g, '/'), this.options, this.context)
             .resolvedModule;
     return resolved ? this.getCanonicalFileName(resolved.resolvedFileName) : null;
   };
@@ -181,12 +158,6 @@ export class CompilerHost implements AotCompilerHost {
       const metadataPath = filePath.replace(DTS, '.metadata.json');
       if (this.context.fileExists(metadataPath)) {
         return this.readMetadata(metadataPath, filePath);
-      } else {
-        // If there is a .d.ts file but no metadata file we need to produce a
-        // v3 metadata from the .d.ts file as v3 includes the exports we need
-        // to resolve symbols.
-        return [this.upgradeVersion1Metadata(
-            {'__symbolic': 'module', 'version': 1, 'metadata': {}}, filePath)];
       }
     } else {
       const sf = this.getSourceFile(filePath);
@@ -202,13 +173,35 @@ export class CompilerHost implements AotCompilerHost {
     }
     try {
       const metadataOrMetadatas = JSON.parse(this.context.readFile(filePath));
-      const metadatas: ModuleMetadata[] = metadataOrMetadatas ?
+      const metadatas = metadataOrMetadatas ?
           (Array.isArray(metadataOrMetadatas) ? metadataOrMetadatas : [metadataOrMetadatas]) :
           [];
-      const v1Metadata = metadatas.find(m => m.version === 1);
-      let v3Metadata = metadatas.find(m => m.version === 3);
+      const v1Metadata = metadatas.find((m: any) => m['version'] === 1);
+      let v3Metadata = metadatas.find((m: any) => m['version'] === 3);
       if (!v3Metadata && v1Metadata) {
-        metadatas.push(this.upgradeVersion1Metadata(v1Metadata, dtsFilePath));
+        // patch up v1 to v3 by merging the metadata with metadata collected from the d.ts file
+        // as the only difference between the versions is whether all exports are contained in
+        // the metadata and the `extends` clause.
+        v3Metadata = {'__symbolic': 'module', 'version': 3, 'metadata': {}};
+        if (v1Metadata.exports) {
+          v3Metadata.exports = v1Metadata.exports;
+        }
+        for (let prop in v1Metadata.metadata) {
+          v3Metadata.metadata[prop] = v1Metadata.metadata[prop];
+        }
+
+        const exports = this.metadataCollector.getMetadata(this.getSourceFile(dtsFilePath));
+        if (exports) {
+          for (let prop in exports.metadata) {
+            if (!v3Metadata.metadata[prop]) {
+              v3Metadata.metadata[prop] = exports.metadata[prop];
+            }
+          }
+          if (exports.exports) {
+            v3Metadata.exports = exports.exports;
+          }
+        }
+        metadatas.push(v3Metadata);
       }
       this.resolverCache.set(filePath, metadatas);
       return metadatas;
@@ -218,49 +211,13 @@ export class CompilerHost implements AotCompilerHost {
     }
   }
 
-  private upgradeVersion1Metadata(v1Metadata: ModuleMetadata, dtsFilePath: string): ModuleMetadata {
-    // patch up v1 to v3 by merging the metadata with metadata collected from the d.ts file
-    // as the only difference between the versions is whether all exports are contained in
-    // the metadata and the `extends` clause.
-    let v3Metadata: ModuleMetadata = {'__symbolic': 'module', 'version': 3, 'metadata': {}};
-    if (v1Metadata.exports) {
-      v3Metadata.exports = v1Metadata.exports;
-    }
-    for (let prop in v1Metadata.metadata) {
-      v3Metadata.metadata[prop] = v1Metadata.metadata[prop];
-    }
-
-    const exports = this.metadataCollector.getMetadata(this.getSourceFile(dtsFilePath));
-    if (exports) {
-      for (let prop in exports.metadata) {
-        if (!v3Metadata.metadata[prop]) {
-          v3Metadata.metadata[prop] = exports.metadata[prop];
-        }
-      }
-      if (exports.exports) {
-        v3Metadata.exports = exports.exports;
-      }
-    }
-    return v3Metadata;
-  }
-
   loadResource(filePath: string): Promise<string> { return this.context.readResource(filePath); }
 
-  loadSummary(filePath: string): string|null {
-    if (this.context.fileExists(filePath)) {
-      return this.context.readFile(filePath);
-    }
-  }
+  loadSummary(filePath: string): string { return this.context.readFile(filePath); }
 
   getOutputFileName(sourceFilePath: string): string {
     return sourceFilePath.replace(EXT, '') + '.d.ts';
   }
-
-  isSourceFile(filePath: string): boolean {
-    const excludeRegex =
-        this.options.generateCodeForLibraries === false ? GENERATED_OR_DTS_FILES : GENERATED_FILES;
-    return !excludeRegex.test(filePath);
-  }
 }
 
 export class CompilerHostContextAdapter {

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

@@ -14,15 +14,41 @@
 // Must be imported first, because angular2 decorators throws on load.
 import 'reflect-metadata';
 
+import * as compiler from '@angular/compiler';
 import * as tsc from '@angular/tsc-wrapped';
+import * as path from 'path';
 import * as ts from 'typescript';
 
 import {Extractor} from './extractor';
 
 function extract(
     ngOptions: tsc.AngularCompilerOptions, cliOptions: tsc.I18nExtractionCliOptions,
-    program: ts.Program, host: ts.CompilerHost): Promise<void> {
-  return Extractor.create(ngOptions, program, host).extract(cliOptions.i18nFormat);
+    program: ts.Program, host: ts.CompilerHost) {
+  const extractor = Extractor.create(ngOptions, cliOptions.i18nFormat, program, host);
+
+  const bundlePromise: Promise<compiler.MessageBundle> = extractor.extract();
+
+  return (bundlePromise).then(messageBundle => {
+    let ext: string;
+    let serializer: compiler.Serializer;
+    const format = (cliOptions.i18nFormat || 'xlf').toLowerCase();
+
+    switch (format) {
+      case 'xmb':
+        ext = 'xmb';
+        serializer = new compiler.Xmb();
+        break;
+      case 'xliff':
+      case 'xlf':
+      default:
+        ext = 'xlf';
+        serializer = new compiler.Xliff();
+        break;
+    }
+
+    const dstPath = path.join(ngOptions.genDir, `messages.${ext}`);
+    host.writeFile(dstPath, messageBundle.write(serializer), false);
+  });
 }
 
 // Entry point

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

@@ -15,74 +15,29 @@ import 'reflect-metadata';
 
 import * as compiler from '@angular/compiler';
 import * as tsc from '@angular/tsc-wrapped';
-import * as path from 'path';
 import * as ts from 'typescript';
 
-import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
-import {PathMappedCompilerHost} from './path_mapped_compiler_host';
+import {excludeFilePattern} from './codegen';
+import {CompilerHost, ModuleResolutionHostAdapter} from './compiler_host';
 
 export class Extractor {
   constructor(
-      private options: tsc.AngularCompilerOptions, private ngExtractor: compiler.Extractor,
-      public host: ts.CompilerHost, private ngCompilerHost: CompilerHost,
+      private ngExtractor: compiler.Extractor, private ngCompilerHost: CompilerHost,
       private program: ts.Program) {}
 
-  extract(formatName: string): Promise<void> {
-    // Checks the format and returns the extension
-    const ext = this.getExtension(formatName);
-
-    const promiseBundle = this.extractBundle();
-
-    return promiseBundle.then(bundle => {
-      const content = this.serialize(bundle, ext);
-      const dstPath = path.join(this.options.genDir, `messages.${ext}`);
-      this.host.writeFile(dstPath, content, false);
-    });
-  }
-
-  extractBundle(): Promise<compiler.MessageBundle> {
-    const files = this.program.getSourceFiles().map(
-        sf => this.ngCompilerHost.getCanonicalFileName(sf.fileName));
-
-    return this.ngExtractor.extract(files);
-  }
-
-  serialize(bundle: compiler.MessageBundle, ext: string): string {
-    let serializer: compiler.Serializer;
-
-    switch (ext) {
-      case 'xmb':
-        serializer = new compiler.Xmb();
-        break;
-      case 'xlf':
-      default:
-        serializer = new compiler.Xliff();
-    }
-
-    return bundle.write(serializer);
-  }
-
-  getExtension(formatName: string): string {
-    const format = (formatName || 'xlf').toLowerCase();
-
-    if (format === 'xmb') return 'xmb';
-    if (format === 'xlf' || format === 'xlif') return 'xlf';
-
-    throw new Error('Unsupported format "${formatName}"');
+  extract(): Promise<compiler.MessageBundle> {
+    return this.ngExtractor.extract(this.program.getSourceFiles().map(
+        sf => this.ngCompilerHost.getCanonicalFileName(sf.fileName)));
   }
 
   static create(
-      options: tsc.AngularCompilerOptions, program: ts.Program, tsCompilerHost: ts.CompilerHost,
-      compilerHostContext?: CompilerHostContext, ngCompilerHost?: CompilerHost): Extractor {
-    if (!ngCompilerHost) {
-      const usePathMapping = !!options.rootDirs && options.rootDirs.length > 0;
-      const context = compilerHostContext || new ModuleResolutionHostAdapter(tsCompilerHost);
-      ngCompilerHost = usePathMapping ? new PathMappedCompilerHost(program, options, context) :
-                                        new CompilerHost(program, options, context);
-    }
-
-    const {extractor: ngExtractor} = compiler.Extractor.create(ngCompilerHost);
-
-    return new Extractor(options, ngExtractor, tsCompilerHost, ngCompilerHost, program);
+      options: tsc.AngularCompilerOptions, translationsFormat: string, program: ts.Program,
+      moduleResolverHost: ts.ModuleResolutionHost, ngCompilerHost?: CompilerHost): Extractor {
+    if (!ngCompilerHost)
+      ngCompilerHost =
+          new CompilerHost(program, options, new ModuleResolutionHostAdapter(moduleResolverHost));
+    const {extractor: ngExtractor} = compiler.Extractor.create(
+        ngCompilerHost, {excludeFilePattern: excludeFilePattern(options)});
+    return new Extractor(ngExtractor, ngCompilerHost, program);
   }
 }

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

@@ -14,7 +14,6 @@ import 'reflect-metadata';
 import * as ts from 'typescript';
 import * as tsc from '@angular/tsc-wrapped';
 
-import {SyntaxError} from '@angular/compiler';
 import {CodeGenerator} from './codegen';
 
 function codegen(
@@ -29,7 +28,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) {
       consoleError(e.message);
       return Promise.resolve(1);
     } else {

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

@@ -13,16 +13,16 @@
  * something else.
  */
 
-import {AotCompilerHost, AotSummaryResolver, StaticReflector, StaticSymbolCache, StaticSymbolResolver} from '@angular/compiler';
+import {AotCompilerHost, StaticReflector} from '@angular/compiler';
 import {AngularCompilerOptions, NgcCliOptions} from '@angular/tsc-wrapped';
 import * as ts from 'typescript';
 
 import {CodeGenerator} from './codegen';
 import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
-import {Extractor} from './extractor';
 import {listLazyRoutesOfModule} from './ngtools_impl';
 import {PathMappedCompilerHost} from './path_mapped_compiler_host';
 
+
 export interface NgTools_InternalApi_NG2_CodeGen_Options {
   basePath: string;
   compilerOptions: ts.CompilerOptions;
@@ -50,18 +50,9 @@ export interface NgTools_InternalApi_NG2_ListLazyRoutes_Options {
   // Every new property under this line should be optional.
 }
 
+
 export interface NgTools_InternalApi_NG_2_LazyRouteMap { [route: string]: string; }
 
-export interface NgTools_InternalApi_NG2_ExtractI18n_Options {
-  basePath: string;
-  compilerOptions: ts.CompilerOptions;
-  program: ts.Program;
-  host: ts.CompilerHost;
-  angularCompilerOptions: AngularCompilerOptions;
-  i18nFormat: string;
-  readResource: (fileName: string) => Promise<string>;
-  // Every new property under this line should be optional.
-}
 
 /**
  * A ModuleResolutionHostAdapter that overrides the readResource() method with the one
@@ -103,6 +94,7 @@ export class NgTools_InternalApi_NG_2 {
     return codeGenerator.codegen();
   }
 
+
   /**
    * @internal
    * @private
@@ -119,10 +111,7 @@ export class NgTools_InternalApi_NG_2 {
         new PathMappedCompilerHost(program, angularCompilerOptions, moduleResolutionHost) :
         new CompilerHost(program, angularCompilerOptions, moduleResolutionHost);
 
-    const symbolCache = new StaticSymbolCache();
-    const summaryResolver = new AotSummaryResolver(ngCompilerHost, symbolCache);
-    const symbolResolver = new StaticSymbolResolver(ngCompilerHost, symbolCache, summaryResolver);
-    const staticReflector = new StaticReflector(symbolResolver);
+    const staticReflector = new StaticReflector(ngCompilerHost);
     const routeMap = listLazyRoutesOfModule(options.entryModule, ngCompilerHost, staticReflector);
 
     return Object.keys(routeMap).reduce(
@@ -132,19 +121,4 @@ export class NgTools_InternalApi_NG_2 {
         },
         {});
   }
-
-  /**
-   * @internal
-   * @private
-   */
-  static extractI18n(options: NgTools_InternalApi_NG2_ExtractI18n_Options): Promise<void> {
-    const hostContext: CompilerHostContext =
-        new CustomLoaderModuleResolutionHostAdapter(options.readResource, options.host);
-
-    // Create the i18n extractor.
-    const extractor = Extractor.create(
-        options.angularCompilerOptions, options.program, options.host, hostContext);
-
-    return extractor.extract(options.i18nFormat);
-  }
 }

modules/@angular/compiler-cli/test/aot_host_spec.ts

@@ -6,7 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {ModuleMetadata} from '@angular/tsc-wrapped';
 import * as ts from 'typescript';
 
 import {CompilerHost} from '../src/compiler_host';
@@ -151,14 +150,12 @@ describe('CompilerHost', () => {
 
   it('should be able to read a metadata file', () => {
     expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/core.d.ts')).toEqual([
-      {__symbolic: 'module', version: 3, metadata: {foo: {__symbolic: 'class'}}}
+      {__symbolic: 'module', version: 2, metadata: {foo: {__symbolic: 'class'}}}
     ]);
   });
 
   it('should be able to read metadata from an otherwise unused .d.ts file ', () => {
-    expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/unused.d.ts')).toEqual([
-      dummyMetadata
-    ]);
+    expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/unused.d.ts')).toBeUndefined();
   });
 
   it('should be able to read empty metadata ', () => {
@@ -184,21 +181,10 @@ describe('CompilerHost', () => {
       }
     ]);
   });
-
-  it('should upgrade a missing metadata file into v3', () => {
-    expect(hostNestedGenDir.getMetadataFor('metadata_versions/v1_empty.d.ts')).toEqual([
-      {__symbolic: 'module', version: 3, metadata: {}, exports: [{from: './lib/utils'}]}
-    ]);
-  });
 });
 
 const dummyModule = 'export let foo: any[];';
-const dummyMetadata: ModuleMetadata = {
-  __symbolic: 'module',
-  version: 3,
-  metadata:
-      {foo: {__symbolic: 'error', message: 'Variable not initialized', line: 0, character: 11}}
-};
+
 const FILES: Entry = {
   'tmp': {
     'src': {
@@ -218,7 +204,7 @@ const FILES: Entry = {
         '@angular': {
           'core.d.ts': dummyModule,
           'core.metadata.json':
-              `{"__symbolic":"module", "version": 3, "metadata": {"foo": {"__symbolic": "class"}}}`,
+              `{"__symbolic":"module", "version": 2, "metadata": {"foo": {"__symbolic": "class"}}}`,
           'router': {'index.d.ts': dummyModule, 'src': {'providers.d.ts': dummyModule}},
           'unused.d.ts': dummyModule,
           'empty.d.ts': 'export declare var a: string;',
@@ -239,9 +225,6 @@ const FILES: Entry = {
         `,
         'v1.metadata.json':
             `{"__symbolic":"module", "version": 1, "metadata": {"foo": {"__symbolic": "class"}}}`,
-        'v1_empty.d.ts': `
-          export * from './lib/utils';
-        `
       }
     }
   }

modules/@angular/compiler-cli/test/main_spec.ts

@@ -29,17 +29,13 @@ describe('compiler-cli', () => {
         "types": [],
         "outDir": "built",
         "declaration": true,
-        "module": "es2015",
-        "moduleResolution": "node"
+        "module": "es2015"
       },
       "angularCompilerOptions": {
         "annotateForClosureCompiler": true
       },
       "files": ["test.ts"]
     }`);
-    const nodeModulesPath = path.resolve(basePath, 'node_modules');
-    fs.mkdirSync(nodeModulesPath);
-    fs.symlinkSync(path.resolve(__dirname, '..', '..'), path.resolve(nodeModulesPath, '@angular'));
   });
 
   // Restore reflector since AoT compiler will update it with a new static reflector

modules/@angular/compiler/index.ts

@@ -32,9 +32,7 @@ export * from './src/aot/compiler_host';
 export * from './src/aot/static_reflector';
 export * from './src/aot/static_reflection_capabilities';
 export * from './src/aot/static_symbol';
-export * from './src/aot/static_symbol_resolver';
 export * from './src/aot/summary_resolver';
-export * from './src/summary_resolver';
 export {JitCompiler} from './src/jit/compiler';
 export * from './src/jit/compiler_factory';
 export * from './src/url_resolver';
@@ -62,5 +60,4 @@ 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';
 // This file only reexports content of the `src` folder. Keep it that way.

modules/@angular/compiler/src/animation/animation_parser.ts

@@ -6,10 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {Injectable} from '@angular/core';
+
 import {CompileAnimationAnimateMetadata, CompileAnimationEntryMetadata, CompileAnimationGroupMetadata, CompileAnimationKeyframesSequenceMetadata, CompileAnimationMetadata, CompileAnimationSequenceMetadata, CompileAnimationStateDeclarationMetadata, CompileAnimationStateTransitionMetadata, CompileAnimationStyleMetadata, CompileAnimationWithStepsMetadata, CompileDirectiveMetadata, identifierName} from '../compile_metadata';
 import {StringMapWrapper} from '../facade/collection';
 import {isBlank, isPresent} from '../facade/lang';
-import {CompilerInjectable} from '../injectable';
 import {ParseError} from '../parse_util';
 import {ANY_STATE, FILL_STYLE_FLAG} from '../private_import_core';
 import {ElementSchemaRegistry} from '../schema/element_schema_registry';
@@ -34,7 +35,7 @@ export class AnimationEntryParseResult {
   constructor(public ast: AnimationEntryAst, public errors: AnimationParseError[]) {}
 }
 
-@CompilerInjectable()
+@Injectable()
 export class AnimationParser {
   constructor(private _schema: ElementSchemaRegistry) {}
 

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

@@ -20,34 +20,34 @@ import {NgModuleCompiler} from '../ng_module_compiler';
 import {OutputEmitter} from '../output/abstract_emitter';
 import * as o from '../output/output_ast';
 import {CompiledStylesheet, StyleCompiler} from '../style_compiler';
-import {SummaryResolver} from '../summary_resolver';
 import {TemplateParser} from '../template_parser/template_parser';
 import {ComponentFactoryDependency, DirectiveWrapperDependency, ViewClassDependency, ViewCompileResult, ViewCompiler} from '../view_compiler/view_compiler';
 
-import {AotCompilerHost} from './compiler_host';
+import {AotCompilerOptions} from './compiler_options';
 import {GeneratedFile} from './generated_file';
+import {StaticReflector} from './static_reflector';
 import {StaticSymbol} from './static_symbol';
-import {ResolvedStaticSymbol, StaticSymbolResolver} from './static_symbol_resolver';
-import {serializeSummaries, summaryFileName} from './summary_serializer';
+import {AotSummaryResolver} from './summary_resolver';
+import {filterFileByPatterns} from './utils';
 
 export class AotCompiler {
   private _animationCompiler = new AnimationCompiler();
 
   constructor(
-      private _host: AotCompilerHost, private _metadataResolver: CompileMetadataResolver,
-      private _templateParser: TemplateParser, private _styleCompiler: StyleCompiler,
-      private _viewCompiler: ViewCompiler, private _dirWrapperCompiler: DirectiveWrapperCompiler,
+      private _metadataResolver: CompileMetadataResolver, private _templateParser: TemplateParser,
+      private _styleCompiler: StyleCompiler, private _viewCompiler: ViewCompiler,
+      private _dirWrapperCompiler: DirectiveWrapperCompiler,
       private _ngModuleCompiler: NgModuleCompiler, private _outputEmitter: OutputEmitter,
-      private _summaryResolver: SummaryResolver<StaticSymbol>, private _localeId: string,
+      private _summaryResolver: AotSummaryResolver, private _localeId: string,
       private _translationFormat: string, private _animationParser: AnimationParser,
-      private _symbolResolver: StaticSymbolResolver) {}
+      private _staticReflector: StaticReflector, private _options: AotCompilerOptions) {}
 
   clearCache() { this._metadataResolver.clearCache(); }
 
   compileAll(rootFiles: string[]): Promise<GeneratedFile[]> {
-    const programSymbols = extractProgramSymbols(this._symbolResolver, rootFiles, this._host);
+    const programSymbols = extractProgramSymbols(this._staticReflector, rootFiles, this._options);
     const {ngModuleByPipeOrDirective, files, ngModules} =
-        analyzeAndValidateNgModules(programSymbols, this._host, this._metadataResolver);
+        analyzeAndValidateNgModules(programSymbols, this._options, this._metadataResolver);
     return Promise
         .all(ngModules.map(
             ngModule => this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(
@@ -56,21 +56,27 @@ export class AotCompiler {
           const sourceModules = files.map(
               file => this._compileSrcFile(
                   file.srcUrl, ngModuleByPipeOrDirective, file.directives, file.pipes,
-                  file.ngModules, file.injectables));
+                  file.ngModules));
           return ListWrapper.flatten(sourceModules);
         });
   }
 
   private _compileSrcFile(
       srcFileUrl: string, ngModuleByPipeOrDirective: Map<StaticSymbol, CompileNgModuleMetadata>,
-      directives: StaticSymbol[], pipes: StaticSymbol[], ngModules: StaticSymbol[],
-      injectables: StaticSymbol[]): GeneratedFile[] {
+      directives: StaticSymbol[], pipes: StaticSymbol[],
+      ngModules: StaticSymbol[]): GeneratedFile[] {
     const fileSuffix = _splitTypescriptSuffix(srcFileUrl)[1];
     const statements: o.Statement[] = [];
     const exportedVars: string[] = [];
     const generatedFiles: GeneratedFile[] = [];
 
-    generatedFiles.push(this._createSummary(srcFileUrl, directives, pipes, ngModules, injectables));
+    // write summary files
+    const summaries: CompileTypeSummary[] = [
+      ...ngModules.map(ref => this._metadataResolver.getNgModuleSummary(ref)),
+      ...directives.map(ref => this._metadataResolver.getDirectiveSummary(ref)),
+      ...pipes.map(ref => this._metadataResolver.getPipeSummary(ref))
+    ];
+    generatedFiles.push(this._summaryResolver.serializeSummaries(srcFileUrl, summaries));
 
     // compile all ng modules
     exportedVars.push(
@@ -115,22 +121,6 @@ export class AotCompiler {
     return generatedFiles;
   }
 
-  private _createSummary(
-      srcFileUrl: string, directives: StaticSymbol[], pipes: StaticSymbol[],
-      ngModules: StaticSymbol[], injectables: StaticSymbol[]): GeneratedFile {
-    const symbolSummaries = this._symbolResolver.getSymbolsOf(srcFileUrl)
-                                .map(symbol => this._symbolResolver.resolveSymbol(symbol));
-    const typeSummaries = [
-      ...ngModules.map(ref => this._metadataResolver.getNgModuleSummary(ref)),
-      ...directives.map(ref => this._metadataResolver.getDirectiveSummary(ref)),
-      ...pipes.map(ref => this._metadataResolver.getPipeSummary(ref)),
-      ...injectables.map(ref => this._metadataResolver.getInjectableSummary(ref))
-    ];
-    const json = serializeSummaries(
-        this._host, this._summaryResolver, this._symbolResolver, symbolSummaries, typeSummaries);
-    return new GeneratedFile(srcFileUrl, summaryFileName(srcFileUrl), json);
-  }
-
   private _compileModule(ngModuleType: StaticSymbol, targetStatements: o.Statement[]): string {
     const ngModule = this._metadataResolver.getNgModuleMetadata(ngModuleType);
     const providers: CompileProviderMetadata[] = [];
@@ -152,7 +142,7 @@ export class AotCompiler {
     const appCompileResult = this._ngModuleCompiler.compile(ngModule, providers);
 
     appCompileResult.dependencies.forEach((dep) => {
-      dep.placeholder.reference = this._symbolResolver.getStaticSymbol(
+      dep.placeholder.reference = this._staticReflector.getStaticSymbol(
           _ngfactoryModuleUrl(identifierModuleUrl(dep.comp)), _componentFactoryName(dep.comp));
     });
 
@@ -173,7 +163,7 @@ export class AotCompiler {
       compMeta: CompileDirectiveMetadata, ngModule: CompileNgModuleMetadata, fileSuffix: string,
       targetStatements: o.Statement[]): string {
     const hostMeta = createHostComponentMeta(
-        this._symbolResolver.getStaticSymbol(
+        this._staticReflector.getStaticSymbol(
             identifierModuleUrl(compMeta.type), `${identifierName(compMeta.type)}_Host`),
         compMeta);
     const hostViewFactoryVar = this._compileComponent(
@@ -216,16 +206,16 @@ export class AotCompiler {
         compMeta, parsedTemplate, stylesExpr, pipes, compiledAnimations);
     if (componentStyles) {
       targetStatements.push(
-          ..._resolveStyleStatements(this._symbolResolver, componentStyles, fileSuffix));
+          ..._resolveStyleStatements(this._staticReflector, componentStyles, fileSuffix));
     }
     compiledAnimations.forEach(entry => targetStatements.push(...entry.statements));
-    targetStatements.push(..._resolveViewStatements(this._symbolResolver, viewResult));
+    targetStatements.push(..._resolveViewStatements(this._staticReflector, viewResult));
     return viewResult.viewClassVar;
   }
 
   private _codgenStyles(
       fileUrl: string, stylesCompileResult: CompiledStylesheet, fileSuffix: string): GeneratedFile {
-    _resolveStyleStatements(this._symbolResolver, stylesCompileResult, fileSuffix);
+    _resolveStyleStatements(this._staticReflector, stylesCompileResult, fileSuffix);
     return this._codegenSourceModule(
         fileUrl, _stylesModuleUrl(
                      stylesCompileResult.meta.moduleUrl, stylesCompileResult.isShimmed, fileSuffix),
@@ -242,7 +232,7 @@ export class AotCompiler {
 }
 
 function _resolveViewStatements(
-    reflector: StaticSymbolResolver, compileResult: ViewCompileResult): o.Statement[] {
+    reflector: StaticReflector, compileResult: ViewCompileResult): o.Statement[] {
   compileResult.dependencies.forEach((dep) => {
     if (dep instanceof ViewClassDependency) {
       const vfd = <ViewClassDependency>dep;
@@ -263,7 +253,7 @@ function _resolveViewStatements(
 
 
 function _resolveStyleStatements(
-    reflector: StaticSymbolResolver, compileResult: CompiledStylesheet,
+    reflector: StaticReflector, compileResult: CompiledStylesheet,
     fileSuffix: string): o.Statement[] {
   compileResult.dependencies.forEach((dep) => {
     dep.valuePlaceholder.reference = reflector.getStaticSymbol(
@@ -313,27 +303,26 @@ export interface NgAnalyzedModules {
     srcUrl: string,
     directives: StaticSymbol[],
     pipes: StaticSymbol[],
-    ngModules: StaticSymbol[],
-    injectables: StaticSymbol[]
+    ngModules: StaticSymbol[]
   }>;
   symbolsMissingModule?: StaticSymbol[];
 }
 
-export interface NgAnalyzeModulesHost { isSourceFile(filePath: string): boolean; }
-
 // Returns all the source files and a mapping from modules to directives
 export function analyzeNgModules(
-    programStaticSymbols: StaticSymbol[], host: NgAnalyzeModulesHost,
+    programStaticSymbols: StaticSymbol[],
+    options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp},
     metadataResolver: CompileMetadataResolver): NgAnalyzedModules {
   const {ngModules, symbolsMissingModule} =
-      _createNgModules(programStaticSymbols, host, metadataResolver);
-  return _analyzeNgModules(programStaticSymbols, ngModules, symbolsMissingModule, metadataResolver);
+      _createNgModules(programStaticSymbols, options, metadataResolver);
+  return _analyzeNgModules(ngModules, symbolsMissingModule);
 }
 
 export function analyzeAndValidateNgModules(
-    programStaticSymbols: StaticSymbol[], host: NgAnalyzeModulesHost,
+    programStaticSymbols: StaticSymbol[],
+    options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp},
     metadataResolver: CompileMetadataResolver): NgAnalyzedModules {
-  const result = analyzeNgModules(programStaticSymbols, host, metadataResolver);
+  const result = analyzeNgModules(programStaticSymbols, options, metadataResolver);
   if (result.symbolsMissingModule && result.symbolsMissingModule.length) {
     const messages = result.symbolsMissingModule.map(
         s => `Cannot determine the module for class ${s.name} in ${s.filePath}!`);
@@ -343,27 +332,16 @@ export function analyzeAndValidateNgModules(
 }
 
 function _analyzeNgModules(
-    programSymbols: StaticSymbol[], ngModuleMetas: CompileNgModuleMetadata[],
-    symbolsMissingModule: StaticSymbol[],
-    metadataResolver: CompileMetadataResolver): NgAnalyzedModules {
+    ngModuleMetas: CompileNgModuleMetadata[],
+    symbolsMissingModule: StaticSymbol[]): NgAnalyzedModules {
   const moduleMetasByRef = new Map<any, CompileNgModuleMetadata>();
   ngModuleMetas.forEach((ngModule) => moduleMetasByRef.set(ngModule.type.reference, ngModule));
   const ngModuleByPipeOrDirective = new Map<StaticSymbol, CompileNgModuleMetadata>();
   const ngModulesByFile = new Map<string, StaticSymbol[]>();
   const ngDirectivesByFile = new Map<string, StaticSymbol[]>();
   const ngPipesByFile = new Map<string, StaticSymbol[]>();
-  const ngInjectablesByFile = new Map<string, StaticSymbol[]>();
   const filePaths = new Set<string>();
 
-  // Make sure we produce an analyzed file for each input file
-  programSymbols.forEach((symbol) => {
-    const filePath = symbol.filePath;
-    filePaths.add(filePath);
-    if (metadataResolver.isInjectable(symbol)) {
-      ngInjectablesByFile.set(filePath, (ngInjectablesByFile.get(filePath) || []).concat(symbol));
-    }
-  });
-
   // Looping over all modules to construct:
   // - a map from file to modules `ngModulesByFile`,
   // - a map from file to directives `ngDirectivesByFile`,
@@ -391,20 +369,17 @@ function _analyzeNgModules(
     });
   });
 
-  const files: {
-    srcUrl: string,
-    directives: StaticSymbol[],
-    pipes: StaticSymbol[],
-    ngModules: StaticSymbol[],
-    injectables: StaticSymbol[]
-  }[] = [];
+  const files:
+      {srcUrl: string,
+       directives: StaticSymbol[],
+       pipes: StaticSymbol[],
+       ngModules: StaticSymbol[]}[] = [];
 
   filePaths.forEach((srcUrl) => {
     const directives = ngDirectivesByFile.get(srcUrl) || [];
     const pipes = ngPipesByFile.get(srcUrl) || [];
     const ngModules = ngModulesByFile.get(srcUrl) || [];
-    const injectables = ngInjectablesByFile.get(srcUrl) || [];
-    files.push({srcUrl, directives, pipes, ngModules, injectables});
+    files.push({srcUrl, directives, pipes, ngModules});
   });
 
   return {
@@ -417,20 +392,29 @@ function _analyzeNgModules(
 }
 
 export function extractProgramSymbols(
-    staticSymbolResolver: StaticSymbolResolver, files: string[],
-    host: NgAnalyzeModulesHost): StaticSymbol[] {
+    staticReflector: StaticReflector, files: string[],
+    options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp} = {}): StaticSymbol[] {
   const staticSymbols: StaticSymbol[] = [];
-  files.filter(fileName => host.isSourceFile(fileName)).forEach(sourceFile => {
-    staticSymbolResolver.getSymbolsOf(sourceFile).forEach((symbol) => {
-      const resolvedSymbol = staticSymbolResolver.resolveSymbol(symbol);
-      const symbolMeta = resolvedSymbol.metadata;
-      if (symbolMeta) {
-        if (symbolMeta.__symbolic != 'error') {
-          // Ignore symbols that are only included to record error information.
-          staticSymbols.push(resolvedSymbol.symbol);
-        }
+  files.filter(fileName => filterFileByPatterns(fileName, options)).forEach(sourceFile => {
+    const moduleMetadata = staticReflector.getModuleMetadata(sourceFile);
+    if (!moduleMetadata) {
+      console.error(`WARNING: no metadata found for ${sourceFile}`);
+      return;
+    }
+
+    const metadata = moduleMetadata['metadata'];
+
+    if (!metadata) {
+      return;
+    }
+
+    for (const symbol of Object.keys(metadata)) {
+      if (metadata[symbol] && metadata[symbol].__symbolic == 'error') {
+        // Ignore symbols that are only included to record error information.
+        continue;
       }
-    });
+      staticSymbols.push(staticReflector.getStaticSymbol(sourceFile, symbol));
+    }
   });
 
   return staticSymbols;
@@ -440,7 +424,8 @@ export function extractProgramSymbols(
 // that all directives / pipes that are present in the program
 // are also declared by a module.
 function _createNgModules(
-    programStaticSymbols: StaticSymbol[], host: NgAnalyzeModulesHost,
+    programStaticSymbols: StaticSymbol[],
+    options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp},
     metadataResolver: CompileMetadataResolver):
     {ngModules: CompileNgModuleMetadata[], symbolsMissingModule: StaticSymbol[]} {
   const ngModules = new Map<any, CompileNgModuleMetadata>();
@@ -448,7 +433,7 @@ function _createNgModules(
   const ngModulePipesAndDirective = new Set<StaticSymbol>();
 
   const addNgModule = (staticSymbol: any) => {
-    if (ngModules.has(staticSymbol) || !host.isSourceFile(staticSymbol.filePath)) {
+    if (ngModules.has(staticSymbol) || !filterFileByPatterns(staticSymbol.filePath, options)) {
       return false;
     }
     const ngModule = metadataResolver.getNgModuleMetadata(staticSymbol, false);

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

@@ -34,11 +34,8 @@ import {AotCompilerHost} from './compiler_host';
 import {AotCompilerOptions} from './compiler_options';
 import {StaticAndDynamicReflectionCapabilities} from './static_reflection_capabilities';
 import {StaticReflector} from './static_reflector';
-import {StaticSymbolCache} from './static_symbol';
-import {StaticSymbolResolver} from './static_symbol_resolver';
 import {AotSummaryResolver} from './summary_resolver';
 
-
 /**
  * Creates a new AotCompiler based on options and a host.
  */
@@ -47,10 +44,7 @@ export function createAotCompiler(compilerHost: AotCompilerHost, options: AotCom
   let translations: string = options.translations || '';
 
   const urlResolver = createOfflineCompileUrlResolver();
-  const symbolCache = new StaticSymbolCache();
-  const summaryResolver = new AotSummaryResolver(compilerHost, symbolCache);
-  const symbolResolver = new StaticSymbolResolver(compilerHost, symbolCache, summaryResolver);
-  const staticReflector = new StaticReflector(symbolResolver);
+  const staticReflector = new StaticReflector(compilerHost);
   StaticAndDynamicReflectionCapabilities.install(staticReflector);
   const htmlParser = new I18NHtmlParser(new HtmlParser(), translations, options.i18nFormat);
   const config = new CompilerConfig({
@@ -66,16 +60,17 @@ export function createAotCompiler(compilerHost: AotCompilerHost, options: AotCom
   const console = new Console();
   const tmplParser =
       new TemplateParser(expressionParser, elementSchemaRegistry, htmlParser, console, []);
+  const summaryResolver = new AotSummaryResolver(compilerHost, staticReflector, options);
   const resolver = new CompileMetadataResolver(
       new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector),
       new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer,
       staticReflector);
   // TODO(vicb): do not pass options.i18nFormat here
   const compiler = new AotCompiler(
-      compilerHost, resolver, tmplParser, new StyleCompiler(urlResolver),
+      resolver, tmplParser, new StyleCompiler(urlResolver),
       new ViewCompiler(config, elementSchemaRegistry),
       new DirectiveWrapperCompiler(config, expressionParser, elementSchemaRegistry, console),
       new NgModuleCompiler(), new TypeScriptEmitter(compilerHost), summaryResolver, options.locale,
-      options.i18nFormat, new AnimationParser(elementSchemaRegistry), symbolResolver);
+      options.i18nFormat, new AnimationParser(elementSchemaRegistry), staticReflector, options);
   return {compiler, reflector: staticReflector};
 }

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

@@ -8,17 +8,16 @@
 
 import {ImportResolver} from '../output/path_util';
 
+import {StaticReflectorHost} from './static_reflector';
 import {StaticSymbol} from './static_symbol';
-import {StaticSymbolResolverHost} from './static_symbol_resolver';
 import {AotSummaryResolverHost} from './summary_resolver';
-import {AotSummarySerializerHost} from './summary_serializer';
 
 /**
  * The host of the AotCompiler disconnects the implementation from TypeScript / other language
  * services and from underlying file systems.
  */
-export interface AotCompilerHost extends StaticSymbolResolverHost, ImportResolver,
-    AotSummaryResolverHost, AotSummarySerializerHost {
+export interface AotCompilerHost extends StaticReflectorHost, ImportResolver,
+    AotSummaryResolverHost {
   /**
    * Loads a resource (e.g. html / css)
    */

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

@@ -11,4 +11,6 @@ export interface AotCompilerOptions {
   locale?: string;
   i18nFormat?: string;
   translations?: string;
+  includeFilePattern?: RegExp;
+  excludeFilePattern?: RegExp;
 }

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

@@ -8,7 +8,6 @@
 
 import {GetterFn, MethodFn, ReflectionCapabilities, SetterFn, reflector} from '../private_import_core';
 import {StaticReflector} from './static_reflector';
-import {StaticSymbol} from './static_symbol';
 
 export class StaticAndDynamicReflectionCapabilities {
   static install(staticDelegate: StaticReflector) {
@@ -43,7 +42,7 @@ export class StaticAndDynamicReflectionCapabilities {
   method(name: string): MethodFn { return this.dynamicDelegate.method(name); }
   importUri(type: any): string { return this.staticDelegate.importUri(type); }
   resolveIdentifier(name: string, moduleUrl: string, runtime: any) {
-    return this.staticDelegate.resolveIdentifier(name, moduleUrl);
+    return this.staticDelegate.resolveIdentifier(name, moduleUrl, runtime);
   }
   resolveEnum(enumIdentifier: any, name: string): any {
     if (isStaticType(enumIdentifier)) {

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

@@ -7,12 +7,10 @@
  */
 
 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 {StaticSymbol} from './static_symbol';
 
-import {StaticSymbol, StaticSymbolCache} from './static_symbol';
-import {ResolvedStaticSymbol, StaticSymbolResolver} from './static_symbol_resolver';
-
+const SUPPORTED_SCHEMA_VERSION = 3;
 const ANGULAR_IMPORT_LOCATIONS = {
   coreDecorators: '@angular/core/src/metadata',
   diDecorators: '@angular/core/src/di/metadata',
@@ -24,20 +22,66 @@ const ANGULAR_IMPORT_LOCATIONS = {
 
 const HIDDEN_KEY = /^\$.*\$$/;
 
+/**
+ * The host of the StaticReflector disconnects the implementation from TypeScript / other language
+ * services and from underlying file systems.
+ */
+export interface StaticReflectorHost {
+  /**
+   * Return a ModuleMetadata for the given module.
+   * Angular 2 CLI will produce this metadata for a module whenever a .d.ts files is
+   * produced and the module has exported variables or classes with decorators. Module metadata can
+   * also be produced directly from TypeScript sources by using MetadataCollector in tools/metadata.
+   *
+   * @param modulePath is a string identifier for a module as an absolute path.
+   * @returns the metadata for the given module.
+   */
+  getMetadataFor(modulePath: string): {[key: string]: any}[];
+
+  /**
+   * Converts a module name that is used in an `import` to a file path.
+   * I.e.
+   * `path/to/containingFile.ts` containing `import {...} from 'module-name'`.
+   */
+  moduleNameToFileName(moduleName: string, containingFile: string): string;
+}
+
+/**
+ * A cache of static symbol used by the StaticReflector to return the same symbol for the
+ * same symbol values.
+ */
+export class StaticSymbolCache {
+  private cache = new Map<string, StaticSymbol>();
+
+  get(declarationFile: string, name: string, members?: string[]): StaticSymbol {
+    const memberSuffix = members ? `.${ members.join('.')}` : '';
+    const key = `"${declarationFile}".${name}${memberSuffix}`;
+    let result = this.cache.get(key);
+    if (!result) {
+      result = new StaticSymbol(declarationFile, name, members);
+      this.cache.set(key, result);
+    }
+    return result;
+  }
+}
+
 /**
  * A static reflector implements enough of the Reflector API that is necessary to compile
  * templates statically.
  */
 export class StaticReflector implements ReflectorReader {
+  private declarationCache = new Map<string, StaticSymbol>();
   private annotationCache = new Map<StaticSymbol, any[]>();
   private propertyCache = new Map<StaticSymbol, {[key: string]: any[]}>();
   private parameterCache = new Map<StaticSymbol, any[]>();
   private methodCache = new Map<StaticSymbol, {[key: string]: boolean}>();
+  private metadataCache = new Map<string, {[key: string]: any}>();
   private conversionMap = new Map<StaticSymbol, (context: StaticSymbol, args: any[]) => any>();
   private opaqueToken: StaticSymbol;
 
   constructor(
-      private symbolResolver: StaticSymbolResolver,
+      private host: StaticReflectorHost,
+      private staticSymbolCache: StaticSymbolCache = new StaticSymbolCache(),
       knownMetadataClasses: {name: string, filePath: string, ctor: any}[] = [],
       knownMetadataFunctions: {name: string, filePath: string, fn: any}[] = [],
       private errorRecorder?: (error: any, fileName: string) => void) {
@@ -50,26 +94,12 @@ export class StaticReflector implements ReflectorReader {
   }
 
   importUri(typeOrFunc: StaticSymbol): string {
-    const staticSymbol = this.findSymbolDeclaration(typeOrFunc);
+    const staticSymbol = this.findDeclaration(typeOrFunc.filePath, typeOrFunc.name, '');
     return staticSymbol ? staticSymbol.filePath : null;
   }
 
-  resolveIdentifier(name: string, moduleUrl: string): StaticSymbol {
-    return this.findDeclaration(moduleUrl, name);
-  }
-
-  findDeclaration(moduleUrl: string, name: string, containingFile?: string): StaticSymbol {
-    return this.findSymbolDeclaration(
-        this.symbolResolver.getSymbolByModule(moduleUrl, name, containingFile));
-  }
-
-  findSymbolDeclaration(symbol: StaticSymbol): StaticSymbol {
-    const resolvedSymbol = this.symbolResolver.resolveSymbol(symbol);
-    if (resolvedSymbol && resolvedSymbol.metadata instanceof StaticSymbol) {
-      return this.findSymbolDeclaration(resolvedSymbol.metadata);
-    } else {
-      return symbol;
-    }
+  resolveIdentifier(name: string, moduleUrl: string, runtime: any): any {
+    return this.findDeclaration(moduleUrl, name, '');
   }
 
   resolveEnum(enumIdentifier: any, name: string): any {
@@ -98,7 +128,7 @@ export class StaticReflector implements ReflectorReader {
   public propMetadata(type: StaticSymbol): {[key: string]: any[]} {
     let propMetadata = this.propertyCache.get(type);
     if (!propMetadata) {
-      const classMetadata = this.getTypeMetadata(type);
+      const classMetadata = this.getTypeMetadata(type) || {};
       propMetadata = {};
       if (classMetadata['extends']) {
         const parentPropMetadata = this.propMetadata(this.simplify(type, classMetadata['extends']));
@@ -173,7 +203,7 @@ export class StaticReflector implements ReflectorReader {
   private _methodNames(type: any): {[key: string]: boolean} {
     let methodNames = this.methodCache.get(type);
     if (!methodNames) {
-      const classMetadata = this.getTypeMetadata(type);
+      const classMetadata = this.getTypeMetadata(type) || {};
       methodNames = {};
       if (classMetadata['extends']) {
         const parentMethodNames = this._methodNames(this.simplify(type, classMetadata['extends']));
@@ -276,7 +306,7 @@ export class StaticReflector implements ReflectorReader {
    * @param name the name of the type.
    */
   getStaticSymbol(declarationFile: string, name: string, members?: string[]): StaticSymbol {
-    return this.symbolResolver.getStaticSymbol(declarationFile, name, members);
+    return this.staticSymbolCache.get(declarationFile, name, members);
   }
 
   private reportError(error: Error, context: StaticSymbol, path?: string) {
@@ -287,6 +317,96 @@ export class StaticReflector implements ReflectorReader {
     }
   }
 
+  private resolveExportedSymbol(filePath: string, symbolName: string): StaticSymbol {
+    const resolveModule = (moduleName: string): string => {
+      const resolvedModulePath = this.host.moduleNameToFileName(moduleName, filePath);
+      if (!resolvedModulePath) {
+        this.reportError(
+            new Error(`Could not resolve module '${moduleName}' relative to file ${filePath}`),
+            null, filePath);
+      }
+      return resolvedModulePath;
+    };
+    const cacheKey = `${filePath}|${symbolName}`;
+    let staticSymbol = this.declarationCache.get(cacheKey);
+    if (staticSymbol) {
+      return staticSymbol;
+    }
+    const metadata = this.getModuleMetadata(filePath);
+    if (metadata) {
+      // If we have metadata for the symbol, this is the original exporting location.
+      if (metadata['metadata'][symbolName]) {
+        staticSymbol = this.getStaticSymbol(filePath, symbolName);
+      }
+
+      // If no, try to find the symbol in one of the re-export location
+      if (!staticSymbol && metadata['exports']) {
+        // Try and find the symbol in the list of explicitly re-exported symbols.
+        for (const moduleExport of metadata['exports']) {
+          if (moduleExport.export) {
+            const exportSymbol = moduleExport.export.find((symbol: any) => {
+              if (typeof symbol === 'string') {
+                return symbol == symbolName;
+              } else {
+                return symbol.as == symbolName;
+              }
+            });
+            if (exportSymbol) {
+              let symName = symbolName;
+              if (typeof exportSymbol !== 'string') {
+                symName = exportSymbol.name;
+              }
+              const resolvedModule = resolveModule(moduleExport.from);
+              if (resolvedModule) {
+                staticSymbol =
+                    this.resolveExportedSymbol(resolveModule(moduleExport.from), symName);
+                break;
+              }
+            }
+          }
+        }
+
+        if (!staticSymbol) {
+          // Try to find the symbol via export * directives.
+          for (const moduleExport of metadata['exports']) {
+            if (!moduleExport.export) {
+              const resolvedModule = resolveModule(moduleExport.from);
+              if (resolvedModule) {
+                const candidateSymbol = this.resolveExportedSymbol(resolvedModule, symbolName);
+                if (candidateSymbol) {
+                  staticSymbol = candidateSymbol;
+                  break;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    this.declarationCache.set(cacheKey, staticSymbol);
+    return staticSymbol;
+  }
+
+  findDeclaration(module: string, symbolName: string, containingFile?: string): StaticSymbol {
+    try {
+      const filePath = this.host.moduleNameToFileName(module, containingFile);
+      let symbol: StaticSymbol;
+      if (!filePath) {
+        // If the file cannot be found the module is probably referencing a declared module
+        // for which there is no disambiguating file and we also don't need to track
+        // re-exports. Just use the module name.
+        symbol = this.getStaticSymbol(module, symbolName);
+      } else {
+        symbol = this.resolveExportedSymbol(filePath, symbolName) ||
+            this.getStaticSymbol(filePath, symbolName);
+      }
+      return symbol;
+    } catch (e) {
+      console.error(`can't resolve module ${module} from ${containingFile}`);
+      throw e;
+    }
+  }
+
   /** @internal */
   public simplify(context: StaticSymbol, value: any): any {
     const self = this;
@@ -294,41 +414,93 @@ export class StaticReflector implements ReflectorReader {
     const calling = new Map<StaticSymbol, boolean>();
 
     function simplifyInContext(context: StaticSymbol, value: any, depth: number): any {
-      function resolveReferenceValue(staticSymbol: StaticSymbol): any {
-        const resolvedSymbol = self.symbolResolver.resolveSymbol(staticSymbol);
-        return resolvedSymbol ? resolvedSymbol.metadata : null;
+      function resolveReference(context: StaticSymbol, expression: any): StaticSymbol {
+        let staticSymbol: StaticSymbol;
+        if (expression['module']) {
+          staticSymbol =
+              self.findDeclaration(expression['module'], expression['name'], context.filePath);
+        } else {
+          staticSymbol = self.getStaticSymbol(context.filePath, expression['name']);
+        }
+        return staticSymbol;
       }
 
-      function simplifyCall(functionSymbol: StaticSymbol, targetFunction: any, args: any[]) {
-        if (targetFunction && targetFunction['__symbolic'] == 'function') {
-          if (calling.get(functionSymbol)) {
-            throw new Error('Recursion not supported');
+      function resolveReferenceValue(staticSymbol: StaticSymbol): any {
+        const moduleMetadata = self.getModuleMetadata(staticSymbol.filePath);
+        const declarationValue =
+            moduleMetadata ? moduleMetadata['metadata'][staticSymbol.name] : null;
+        return declarationValue;
+      }
+
+      function isOpaqueToken(context: StaticSymbol, value: any): boolean {
+        if (value && value.__symbolic === 'new' && value.expression) {
+          const target = value.expression;
+          if (target.__symbolic == 'reference') {
+            return sameSymbol(resolveReference(context, target), self.opaqueToken);
           }
-          calling.set(functionSymbol, true);
-          try {
-            const value = targetFunction['value'];
-            if (value && (depth != 0 || value.__symbolic != 'error')) {
-              const parameters: string[] = targetFunction['parameters'];
-              const defaults: any[] = targetFunction.defaults;
-              if (defaults && defaults.length > args.length) {
-                args.push(...defaults.slice(args.length).map((value: any) => simplify(value)));
-              }
-              const functionScope = BindingScope.build();
-              for (let i = 0; i < parameters.length; i++) {
-                functionScope.define(parameters[i], args[i]);
-              }
-              const oldScope = scope;
-              let result: any;
-              try {
-                scope = functionScope.done();
-                result = simplifyInContext(functionSymbol, value, depth + 1);
-              } finally {
-                scope = oldScope;
-              }
-              return result;
+        }
+        return false;
+      }
+
+      function simplifyCall(expression: any) {
+        let callContext: {[name: string]: string}|undefined = undefined;
+        if (expression['__symbolic'] == 'call') {
+          const target = expression['expression'];
+          let functionSymbol: StaticSymbol;
+          let targetFunction: any;
+          if (target) {
+            switch (target.__symbolic) {
+              case 'reference':
+                // Find the function to call.
+                callContext = {name: target.name};
+                functionSymbol = resolveReference(context, target);
+                targetFunction = resolveReferenceValue(functionSymbol);
+                break;
+              case 'select':
+                // Find the static method to call
+                if (target.expression.__symbolic == 'reference') {
+                  functionSymbol = resolveReference(context, target.expression);
+                  const classData = resolveReferenceValue(functionSymbol);
+                  if (classData && classData.statics) {
+                    targetFunction = classData.statics[target.member];
+                  }
+                }
+                break;
+            }
+          }
+          if (targetFunction && targetFunction['__symbolic'] == 'function') {
+            if (calling.get(functionSymbol)) {
+              throw new Error('Recursion not supported');
+            }
+            calling.set(functionSymbol, true);
+            try {
+              const value = targetFunction['value'];
+              if (value && (depth != 0 || value.__symbolic != 'error')) {
+                // Determine the arguments
+                const args: any[] =
+                    (expression['arguments'] || []).map((arg: any) => simplify(arg));
+                const parameters: string[] = targetFunction['parameters'];
+                const defaults: any[] = targetFunction.defaults;
+                if (defaults && defaults.length > args.length) {
+                  args.push(...defaults.slice(args.length).map((value: any) => simplify(value)));
+                }
+                const functionScope = BindingScope.build();
+                for (let i = 0; i < parameters.length; i++) {
+                  functionScope.define(parameters[i], args[i]);
+                }
+                const oldScope = scope;
+                let result: any;
+                try {
+                  scope = functionScope.done();
+                  result = simplifyInContext(functionSymbol, value, depth + 1);
+                } finally {
+                  scope = oldScope;
+                }
+                return result;
+              }
+            } finally {
+              calling.delete(functionSymbol);
             }
-          } finally {
-            calling.delete(functionSymbol);
           }
         }
 
@@ -339,7 +511,7 @@ export class StaticReflector implements ReflectorReader {
           return {__symbolic: 'ignore'};
         }
         return simplify(
-            {__symbolic: 'error', message: 'Function call not supported', context: functionSymbol});
+            {__symbolic: 'error', message: 'Function call not supported', context: callContext});
       }
 
       function simplify(expression: any): any {
@@ -368,18 +540,7 @@ export class StaticReflector implements ReflectorReader {
           return result;
         }
         if (expression instanceof StaticSymbol) {
-          // Stop simplification at builtin symbols
-          if (expression === self.opaqueToken || self.conversionMap.has(expression)) {
-            return expression;
-          } else {
-            const staticSymbol = expression;
-            const declarationValue = resolveReferenceValue(staticSymbol);
-            if (declarationValue) {
-              return simplifyInContext(staticSymbol, declarationValue, depth + 1);
-            } else {
-              return staticSymbol;
-            }
-          }
+          return expression;
         }
         if (expression) {
           if (expression['__symbolic']) {
@@ -457,33 +618,50 @@ export class StaticReflector implements ReflectorReader {
                 if (indexTarget && isPrimitive(index)) return indexTarget[index];
                 return null;
               case 'select':
-                const member = expression['member'];
                 let selectContext = context;
                 let selectTarget = simplify(expression['expression']);
                 if (selectTarget instanceof StaticSymbol) {
-                  const members = selectTarget.members.concat(member);
+                  // Access to a static instance variable
+                  const member: string = expression['member'];
+                  const members = selectTarget.members ?
+                      (selectTarget.members as string[]).concat(member) :
+                      [member];
+                  const declarationValue = resolveReferenceValue(selectTarget);
                   selectContext =
                       self.getStaticSymbol(selectTarget.filePath, selectTarget.name, members);
-                  const declarationValue = resolveReferenceValue(selectContext);
-                  if (declarationValue) {
-                    return simplifyInContext(selectContext, declarationValue, depth + 1);
+                  if (declarationValue && declarationValue.statics) {
+                    selectTarget = declarationValue.statics;
                   } else {
                     return selectContext;
                   }
                 }
+                const member = simplifyInContext(selectContext, expression['member'], depth + 1);
                 if (selectTarget && isPrimitive(member))
                   return simplifyInContext(selectContext, selectTarget[member], depth + 1);
                 return null;
               case 'reference':
-                // Note: This only has to deal with variable references,
-                // as symbol references have been converted into StaticSymbols already
-                // in the StaticSymbolResolver!
-                const name: string = expression['name'];
-                const localValue = scope.resolve(name);
-                if (localValue != BindingScope.missing) {
-                  return localValue;
+                if (!expression['name']) {
+                  return context;
                 }
-                break;
+                if (!expression.module) {
+                  const name: string = expression['name'];
+                  const localValue = scope.resolve(name);
+                  if (localValue != BindingScope.missing) {
+                    return localValue;
+                  }
+                }
+                staticSymbol = resolveReference(context, expression);
+                let result: any = staticSymbol;
+                let declarationValue = resolveReferenceValue(result);
+                if (declarationValue) {
+                  if (isOpaqueToken(staticSymbol, declarationValue)) {
+                    // If the referenced symbol is initalized by a new OpaqueToken we can keep the
+                    // reference to the symbol.
+                    return staticSymbol;
+                  }
+                  result = simplifyInContext(staticSymbol, declarationValue, depth + 1);
+                }
+                return result;
               case 'class':
                 return context;
               case 'function':
@@ -491,26 +669,26 @@ export class StaticReflector implements ReflectorReader {
               case 'new':
               case 'call':
                 // Determine if the function is a built-in conversion
-                staticSymbol = simplifyInContext(context, expression['expression'], depth + 1);
-                if (staticSymbol instanceof StaticSymbol) {
-                  if (staticSymbol === self.opaqueToken) {
-                    // if somebody calls new OpaqueToken, don't create an OpaqueToken,
-                    // but rather return the symbol to which the OpaqueToken is assigned to.
-                    return context;
-                  }
-                  const argExpressions: any[] = expression['arguments'] || [];
-                  const args =
-                      argExpressions.map(arg => simplifyInContext(context, arg, depth + 1));
-                  let converter = self.conversionMap.get(staticSymbol);
-                  if (converter) {
-                    return converter(context, args);
-                  } else {
-                    // Determine if the function is one we can simplify.
-                    const targetFunction = resolveReferenceValue(staticSymbol);
-                    return simplifyCall(staticSymbol, targetFunction, args);
-                  }
+                let target = expression['expression'];
+                if (target['module']) {
+                  staticSymbol =
+                      self.findDeclaration(target['module'], target['name'], context.filePath);
+                } else {
+                  staticSymbol = self.getStaticSymbol(context.filePath, target['name']);
                 }
-                break;
+                let converter = self.conversionMap.get(staticSymbol);
+                if (converter) {
+                  let args: any[] = expression['arguments'];
+                  if (!args) {
+                    args = [];
+                  }
+                  return converter(
+                      context, args.map(arg => simplifyInContext(context, arg, depth + 1)));
+                }
+
+                // Determine if the function is one we can simplify.
+                return simplifyCall(expression);
+
               case 'error':
                 let message = produceErrorMessage(expression);
                 if (expression['line']) {
@@ -531,9 +709,7 @@ export class StaticReflector implements ReflectorReader {
       try {
         return simplify(value);
       } catch (e) {
-        const members = context.members.length ? `.${context.members.join('.')}` : '';
-        const message =
-            `${e.message}, resolving symbol ${context.name}${members} in ${context.filePath}`;
+        const message = `${e.message}, resolving symbol ${context.name} in ${context.filePath}`;
         if (e.fileName) {
           throw positionalError(message, e.fileName, e.line, e.column);
         }
@@ -557,10 +733,40 @@ export class StaticReflector implements ReflectorReader {
     return result;
   }
 
+  /**
+   * @param module an absolute path to a module file.
+   */
+  public getModuleMetadata(module: string): {[key: string]: any} {
+    let moduleMetadata = this.metadataCache.get(module);
+    if (!moduleMetadata) {
+      const moduleMetadatas = this.host.getMetadataFor(module);
+      if (moduleMetadatas) {
+        let maxVersion = -1;
+        moduleMetadatas.forEach((md) => {
+          if (md['version'] > maxVersion) {
+            maxVersion = md['version'];
+            moduleMetadata = md;
+          }
+        });
+      }
+      if (!moduleMetadata) {
+        moduleMetadata =
+            {__symbolic: 'module', version: SUPPORTED_SCHEMA_VERSION, module: module, metadata: {}};
+      }
+      if (moduleMetadata['version'] != SUPPORTED_SCHEMA_VERSION) {
+        const errorMessage = moduleMetadata['version'] == 2 ?
+            `Unsupported metadata version ${moduleMetadata['version']} for module ${module}. This module should be compiled with a newer version of ngc` :
+            `Metadata version mismatch for module ${module}, found version ${moduleMetadata['version']}, expected ${SUPPORTED_SCHEMA_VERSION}`;
+        this.reportError(new Error(errorMessage), null);
+      }
+      this.metadataCache.set(module, moduleMetadata);
+    }
+    return moduleMetadata;
+  }
+
   private getTypeMetadata(type: StaticSymbol): {[key: string]: any} {
-    const resolvedSymbol = this.symbolResolver.resolveSymbol(type);
-    return resolvedSymbol && resolvedSymbol.metadata ? resolvedSymbol.metadata :
-                                                       {__symbolic: 'class'};
+    const moduleMetadata = this.getModuleMetadata(type.filePath);
+    return moduleMetadata['metadata'][type.name] || {__symbolic: 'class'};
   }
 }
 
@@ -652,7 +858,7 @@ class PopulatedScope extends BindingScope {
 }
 
 function sameSymbol(a: StaticSymbol, b: StaticSymbol): boolean {
-  return a === b;
+  return a === b || (a.name == b.name && a.filePath == b.filePath);
 }
 
 function shouldIgnore(value: any): boolean {

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

@@ -14,23 +14,3 @@
 export class StaticSymbol {
   constructor(public filePath: string, public name: string, public members?: string[]) {}
 }
-
-/**
- * A cache of static symbol used by the StaticReflector to return the same symbol for the
- * same symbol values.
- */
-export class StaticSymbolCache {
-  private cache = new Map<string, StaticSymbol>();
-
-  get(declarationFile: string, name: string, members?: string[]): StaticSymbol {
-    members = members || [];
-    const memberSuffix = members.length ? `.${ members.join('.')}` : '';
-    const key = `"${declarationFile}".${name}${memberSuffix}`;
-    let result = this.cache.get(key);
-    if (!result) {
-      result = new StaticSymbol(declarationFile, name, members);
-      this.cache.set(key, result);
-    }
-    return result;
-  }
-}

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

@@ -1,289 +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
- */
-
-import {SummaryResolver} from '../summary_resolver';
-import {ValueTransformer, visitValue} from '../util';
-
-import {StaticSymbol, StaticSymbolCache} from './static_symbol';
-
-export class ResolvedStaticSymbol {
-  constructor(public symbol: StaticSymbol, public metadata: any) {}
-}
-
-/**
- * The host of the SymbolResolverHost disconnects the implementation from TypeScript / other
- * language
- * services and from underlying file systems.
- */
-export interface StaticSymbolResolverHost {
-  /**
-   * Return a ModuleMetadata for the given module.
-   * Angular 2 CLI will produce this metadata for a module whenever a .d.ts files is
-   * produced and the module has exported variables or classes with decorators. Module metadata can
-   * also be produced directly from TypeScript sources by using MetadataCollector in tools/metadata.
-   *
-   * @param modulePath is a string identifier for a module as an absolute path.
-   * @returns the metadata for the given module.
-   */
-  getMetadataFor(modulePath: string): {[key: string]: any}[];
-
-  /**
-   * Converts a module name that is used in an `import` to a file path.
-   * I.e.
-   * `path/to/containingFile.ts` containing `import {...} from 'module-name'`.
-   */
-  moduleNameToFileName(moduleName: string, containingFile: string): string /*|null*/;
-}
-
-const SUPPORTED_SCHEMA_VERSION = 3;
-
-/**
- * This class is responsible for loading metadata per symbol,
- * and normalizing references between symbols.
- */
-export class StaticSymbolResolver {
-  private metadataCache = new Map<string, {[key: string]: any}>();
-  private resolvedSymbols = new Map<StaticSymbol, ResolvedStaticSymbol>();
-  private resolvedFilePaths = new Set<string>();
-
-  constructor(
-      private host: StaticSymbolResolverHost, private staticSymbolCache: StaticSymbolCache,
-      private summaryResolver: SummaryResolver<StaticSymbol>,
-      private errorRecorder?: (error: any, fileName: string) => void) {}
-
-  resolveSymbol(staticSymbol: StaticSymbol): ResolvedStaticSymbol {
-    if (staticSymbol.members.length > 0) {
-      return this._resolveSymbolMembers(staticSymbol);
-    }
-    let result = this._resolveSymbolFromSummary(staticSymbol);
-    if (!result) {
-      // Note: Some users use libraries that were not compiled with ngc, i.e. they don't
-      // have summaries, only .d.ts files. So we always need to check both, the summary
-      // and metadata.
-      this._createSymbolsOf(staticSymbol.filePath);
-      result = this.resolvedSymbols.get(staticSymbol);
-    }
-    return result;
-  }
-
-  private _resolveSymbolMembers(staticSymbol: StaticSymbol): ResolvedStaticSymbol {
-    const members = staticSymbol.members;
-    const baseResolvedSymbol =
-        this.resolveSymbol(this.getStaticSymbol(staticSymbol.filePath, staticSymbol.name));
-    if (!baseResolvedSymbol) {
-      return null;
-    }
-    const baseMetadata = baseResolvedSymbol.metadata;
-    if (baseMetadata instanceof StaticSymbol) {
-      return new ResolvedStaticSymbol(
-          staticSymbol, this.getStaticSymbol(baseMetadata.filePath, baseMetadata.name, members));
-    } else if (baseMetadata && baseMetadata.__symbolic === 'class') {
-      if (baseMetadata.statics && members.length === 1) {
-        return new ResolvedStaticSymbol(staticSymbol, baseMetadata.statics[members[0]]);
-      }
-    } else {
-      let value = baseMetadata;
-      for (let i = 0; i < members.length && value; i++) {
-        value = value[members[i]];
-      }
-      return new ResolvedStaticSymbol(staticSymbol, value);
-    }
-    return null;
-  }
-
-  private _resolveSymbolFromSummary(staticSymbol: StaticSymbol): ResolvedStaticSymbol {
-    const summary = this.summaryResolver.resolveSummary(staticSymbol);
-    return summary ? new ResolvedStaticSymbol(staticSymbol, summary.metadata) : null;
-  }
-
-  /**
-   * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded.
-   * All types passed to the StaticResolver should be pseudo-types returned by this method.
-   *
-   * @param declarationFile the absolute path of the file where the symbol is declared
-   * @param name the name of the type.
-   */
-  getStaticSymbol(declarationFile: string, name: string, members?: string[]): StaticSymbol {
-    return this.staticSymbolCache.get(declarationFile, name, members);
-  }
-
-  getSymbolsOf(filePath: string): StaticSymbol[] {
-    // Note: Some users use libraries that were not compiled with ngc, i.e. they don't
-    // have summaries, only .d.ts files. So we always need to check both, the summary
-    // and metadata.
-    let symbols = new Set<StaticSymbol>(this.summaryResolver.getSymbolsOf(filePath));
-    this._createSymbolsOf(filePath);
-    this.resolvedSymbols.forEach((resolvedSymbol) => {
-      if (resolvedSymbol.symbol.filePath === filePath) {
-        symbols.add(resolvedSymbol.symbol);
-      }
-    });
-    return Array.from(symbols);
-  }
-
-  private _createSymbolsOf(filePath: string) {
-    if (this.resolvedFilePaths.has(filePath)) {
-      return;
-    }
-    this.resolvedFilePaths.add(filePath);
-    const resolvedSymbols: ResolvedStaticSymbol[] = [];
-    const metadata = this.getModuleMetadata(filePath);
-    if (metadata['metadata']) {
-      // handle direct declarations of the symbol
-      Object.keys(metadata['metadata']).forEach((symbolName) => {
-        const symbolMeta = metadata['metadata'][symbolName];
-        resolvedSymbols.push(
-            this.createResolvedSymbol(this.getStaticSymbol(filePath, symbolName), symbolMeta));
-      });
-    }
-
-    // handle the symbols in one of the re-export location
-    if (metadata['exports']) {
-      for (const moduleExport of metadata['exports']) {
-        // handle the symbols in the list of explicitly re-exported symbols.
-        if (moduleExport.export) {
-          moduleExport.export.forEach((exportSymbol: any) => {
-            let symbolName: string;
-            if (typeof exportSymbol === 'string') {
-              symbolName = exportSymbol;
-            } else {
-              symbolName = exportSymbol.as;
-            }
-            let symName = symbolName;
-            if (typeof exportSymbol !== 'string') {
-              symName = exportSymbol.name;
-            }
-            const resolvedModule = this.resolveModule(moduleExport.from, filePath);
-            if (resolvedModule) {
-              const targetSymbol = this.getStaticSymbol(resolvedModule, symName);
-              const sourceSymbol = this.getStaticSymbol(filePath, symbolName);
-              resolvedSymbols.push(new ResolvedStaticSymbol(sourceSymbol, targetSymbol));
-            }
-          });
-        } else {
-          // handle the symbols via export * directives.
-          const resolvedModule = this.resolveModule(moduleExport.from, filePath);
-          if (resolvedModule) {
-            const nestedExports = this.getSymbolsOf(resolvedModule);
-            nestedExports.forEach((targetSymbol) => {
-              const sourceSymbol = this.getStaticSymbol(filePath, targetSymbol.name);
-              resolvedSymbols.push(new ResolvedStaticSymbol(sourceSymbol, targetSymbol));
-            });
-          }
-        }
-      }
-    }
-    resolvedSymbols.forEach(
-        (resolvedSymbol) => this.resolvedSymbols.set(resolvedSymbol.symbol, resolvedSymbol));
-  }
-
-  private createResolvedSymbol(sourceSymbol: StaticSymbol, metadata: any): ResolvedStaticSymbol {
-    const self = this;
-
-    class ReferenceTransformer extends ValueTransformer {
-      visitStringMap(map: {[key: string]: any}, functionParams: string[]): any {
-        const symbolic = map['__symbolic'];
-        if (symbolic === 'function') {
-          const oldLen = functionParams.length;
-          functionParams.push(...(map['parameters'] || []));
-          const result = super.visitStringMap(map, functionParams);
-          functionParams.length = oldLen;
-          return result;
-        } else if (symbolic === 'reference') {
-          const module = map['module'];
-          const name = map['name'];
-          if (!name) {
-            return null;
-          }
-          let filePath: string;
-          if (module) {
-            filePath = self.resolveModule(module, sourceSymbol.filePath);
-            if (!filePath) {
-              return {
-                __symbolic: 'error',
-                message: `Could not resolve ${module} relative to ${sourceSymbol.filePath}.`
-              };
-            }
-          } else {
-            const isFunctionParam = functionParams.indexOf(name) >= 0;
-            if (!isFunctionParam) {
-              filePath = sourceSymbol.filePath;
-            }
-          }
-          if (filePath) {
-            return self.getStaticSymbol(filePath, name);
-          } else {
-            // reference to a function parameter
-            return {__symbolic: 'reference', name: name};
-          }
-        } else {
-          return super.visitStringMap(map, functionParams);
-        }
-      }
-    }
-
-    const transformedMeta = visitValue(metadata, new ReferenceTransformer(), []);
-    return new ResolvedStaticSymbol(sourceSymbol, transformedMeta);
-  }
-
-  private reportError(error: Error, context: StaticSymbol, path?: string) {
-    if (this.errorRecorder) {
-      this.errorRecorder(error, (context && context.filePath) || path);
-    } else {
-      throw error;
-    }
-  }
-
-  /**
-   * @param module an absolute path to a module file.
-   */
-  private getModuleMetadata(module: string): {[key: string]: any} {
-    let moduleMetadata = this.metadataCache.get(module);
-    if (!moduleMetadata) {
-      const moduleMetadatas = this.host.getMetadataFor(module);
-      if (moduleMetadatas) {
-        let maxVersion = -1;
-        moduleMetadatas.forEach((md) => {
-          if (md['version'] > maxVersion) {
-            maxVersion = md['version'];
-            moduleMetadata = md;
-          }
-        });
-      }
-      if (!moduleMetadata) {
-        moduleMetadata =
-            {__symbolic: 'module', version: SUPPORTED_SCHEMA_VERSION, module: module, metadata: {}};
-      }
-      if (moduleMetadata['version'] != SUPPORTED_SCHEMA_VERSION) {
-        const errorMessage = moduleMetadata['version'] == 2 ?
-            `Unsupported metadata version ${moduleMetadata['version']} for module ${module}. This module should be compiled with a newer version of ngc` :
-            `Metadata version mismatch for module ${module}, found version ${moduleMetadata['version']}, expected ${SUPPORTED_SCHEMA_VERSION}`;
-        this.reportError(new Error(errorMessage), null);
-      }
-      this.metadataCache.set(module, moduleMetadata);
-    }
-    return moduleMetadata;
-  }
-
-  getSymbolByModule(module: string, symbolName: string, containingFile?: string): StaticSymbol {
-    const filePath = this.resolveModule(module, containingFile);
-    if (!filePath) {
-      throw new Error(`Could not resolve module ${module} relative to ${containingFile}`);
-    }
-    return this.getStaticSymbol(filePath, symbolName);
-  }
-
-  private resolveModule(module: string, containingFile: string): string {
-    try {
-      return this.host.moduleNameToFileName(module, containingFile);
-    } catch (e) {
-      console.error(`Could not resolve module '${module}' relative to file ${containingFile}`);
-      this.reportError(new e, null, containingFile);
-    }
-  }
-}

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

@@ -5,12 +5,13 @@
  * 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 {CompileSummaryKind, CompileTypeSummary} from '../compile_metadata';
-import {Summary, SummaryResolver} from '../summary_resolver';
+import {CompileDirectiveSummary, CompileIdentifierMetadata, CompileNgModuleSummary, CompilePipeSummary, CompileSummaryKind, CompileTypeMetadata, CompileTypeSummary, identifierModuleUrl, identifierName} from '../compile_metadata';
+import {SummaryResolver} from '../summary_resolver';
 
-import {StaticSymbol, StaticSymbolCache} from './static_symbol';
-import {ResolvedStaticSymbol} from './static_symbol_resolver';
-import {deserializeSummaries, summaryFileName} from './summary_serializer';
+import {GeneratedFile} from './generated_file';
+import {StaticReflector} from './static_reflector';
+import {StaticSymbol} from './static_symbol';
+import {filterFileByPatterns} from './utils';
 
 const STRIP_SRC_FILE_SUFFIXES = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
 
@@ -18,60 +19,106 @@ export interface AotSummaryResolverHost {
   /**
    * Loads an NgModule/Directive/Pipe summary file
    */
-  loadSummary(filePath: string): string /*|null*/;
+  loadSummary(filePath: string): string;
 
   /**
-   * Returns whether a file is a source file or not.
+   * Returns the output file path of a source file.
+   * E.g.
+   * `some_file.ts` -> `some_file.d.ts`
    */
-  isSourceFile(sourceFilePath: string): boolean;
+  getOutputFileName(sourceFilePath: string): string;
 }
 
-export class AotSummaryResolver implements SummaryResolver<StaticSymbol> {
-  private summaryCache = new Map<StaticSymbol, Summary<StaticSymbol>>();
-  private loadedFilePaths = new Set<string>();
+export interface AotSummaryResolverOptions {
+  includeFilePattern?: RegExp;
+  excludeFilePattern?: RegExp;
+}
 
-  constructor(private host: AotSummaryResolverHost, private staticSymbolCache: StaticSymbolCache) {}
+export class AotSummaryResolver implements SummaryResolver {
+  private summaryCache: {[cacheKey: string]: CompileTypeSummary} = {};
 
-  private _assertNoMembers(symbol: StaticSymbol) {
-    if (symbol.members.length) {
-      throw new Error(
-          `Internal state: StaticSymbols in summaries can't have members! ${JSON.stringify(symbol)}`);
-    }
+  constructor(
+      private host: AotSummaryResolverHost, private staticReflector: StaticReflector,
+      private options: AotSummaryResolverOptions) {}
+
+  serializeSummaries(srcFileUrl: string, summaries: CompileTypeSummary[]): GeneratedFile {
+    const jsonReplacer = (key: string, value: any) => {
+      if (value instanceof StaticSymbol) {
+        // We convert the source filenames into output filenames,
+        // as the generated summary file will be used when the current
+        // compilation unit is used as a library
+        return {
+          '__symbolic__': 'symbol',
+          'name': value.name,
+          'path': this.host.getOutputFileName(value.filePath),
+          'members': value.members
+        };
+      }
+      return value;
+    };
+    const allSummaries = summaries.slice();
+    summaries.forEach((summary) => {
+      if (summary.summaryKind === CompileSummaryKind.NgModule) {
+        const moduleMeta = <CompileNgModuleSummary>summary;
+        moduleMeta.exportedDirectives.concat(moduleMeta.exportedPipes).forEach((id) => {
+          if (!filterFileByPatterns(id.reference.filePath, this.options)) {
+            allSummaries.push(this.resolveSummary(id.reference));
+          }
+        });
+      }
+    });
+
+    return new GeneratedFile(
+        srcFileUrl, summaryFileName(srcFileUrl), JSON.stringify(allSummaries, jsonReplacer));
   }
 
-  resolveSummary(staticSymbol: StaticSymbol): Summary<StaticSymbol> {
-    this._assertNoMembers(staticSymbol);
-    let summary = this.summaryCache.get(staticSymbol);
-    if (!summary) {
-      this._loadSummaryFile(staticSymbol.filePath);
-      summary = this.summaryCache.get(staticSymbol);
-    }
-    return summary;
-  }
+  private _cacheKey(symbol: StaticSymbol) { return `${symbol.filePath}|${symbol.name}`; }
 
-  getSymbolsOf(filePath: string): StaticSymbol[] {
-    this._loadSummaryFile(filePath);
-    return Array.from(this.summaryCache.keys()).filter((symbol) => symbol.filePath === filePath);
-  }
-
-  private _loadSummaryFile(filePath: string) {
-    if (this.loadedFilePaths.has(filePath)) {
-      return;
-    }
-    this.loadedFilePaths.add(filePath);
-    if (!this.host.isSourceFile(filePath)) {
+  resolveSummary(staticSymbol: StaticSymbol): any {
+    const filePath = staticSymbol.filePath;
+    const name = staticSymbol.name;
+    const cacheKey = this._cacheKey(staticSymbol);
+    if (!filterFileByPatterns(filePath, this.options)) {
+      let summary = this.summaryCache[cacheKey];
       const summaryFilePath = summaryFileName(filePath);
-      let json: string;
-      try {
-        json = this.host.loadSummary(summaryFilePath);
-      } catch (e) {
-        console.error(`Error loading summary file ${summaryFilePath}`);
-        throw e;
+      if (!summary) {
+        try {
+          const jsonReviver = (key: string, value: any) => {
+            if (value && value['__symbolic__'] === 'symbol') {
+              // Note: We can't use staticReflector.findDeclaration here:
+              // Summary files can contain symbols of transitive compilation units
+              // (via the providers), and findDeclaration needs .metadata.json / .d.ts files,
+              // but we don't want to depend on these for transitive dependencies.
+              return this.staticReflector.getStaticSymbol(
+                  value['path'], value['name'], value['members']);
+            } else {
+              return value;
+            }
+          };
+          const readSummaries: CompileTypeSummary[] =
+              JSON.parse(this.host.loadSummary(summaryFilePath), jsonReviver);
+          readSummaries.forEach((summary) => {
+            const filePath = summary.type.reference.filePath;
+            this.summaryCache[this._cacheKey(summary.type.reference)] = summary;
+          });
+          summary = this.summaryCache[cacheKey];
+        } catch (e) {
+          console.error(`Error loading summary file ${summaryFilePath}`);
+          throw e;
+        }
       }
-      if (json) {
-        const readSummaries = deserializeSummaries(this.staticSymbolCache, json);
-        readSummaries.forEach((summary) => { this.summaryCache.set(summary.symbol, summary); });
+      if (!summary) {
+        throw new Error(
+            `Could not find the symbol ${name} in the summary file ${summaryFilePath}!`);
       }
+      return summary;
+    } else {
+      return null;
     }
   }
 }
+
+function summaryFileName(fileName: string): string {
+  const fileNameWithoutSuffix = fileName.replace(STRIP_SRC_FILE_SUFFIXES, '');
+  return `${fileNameWithoutSuffix}.ngsummary.json`;
+}

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

@@ -1,183 +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
- */
-import {CompileDirectiveSummary, CompileIdentifierMetadata, CompileNgModuleSummary, CompilePipeSummary, CompileSummaryKind, CompileTypeMetadata, CompileTypeSummary, identifierModuleUrl, identifierName} from '../compile_metadata';
-import {Summary, SummaryResolver} from '../summary_resolver';
-import {ValueTransformer, visitValue} from '../util';
-
-import {GeneratedFile} from './generated_file';
-import {StaticSymbol, StaticSymbolCache} from './static_symbol';
-import {ResolvedStaticSymbol, StaticSymbolResolver} from './static_symbol_resolver';
-
-const STRIP_SRC_FILE_SUFFIXES = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
-
-export interface AotSummarySerializerHost {
-  /**
-   * Returns the output file path of a source file.
-   * E.g.
-   * `some_file.ts` -> `some_file.d.ts`
-   */
-  getOutputFileName(sourceFilePath: string): string;
-  /**
-   * Returns whether a file is a source file or not.
-   */
-  isSourceFile(sourceFilePath: string): boolean;
-}
-
-export function serializeSummaries(
-    host: AotSummarySerializerHost, summaryResolver: SummaryResolver<StaticSymbol>,
-    symbolResolver: StaticSymbolResolver,
-
-    symbols: ResolvedStaticSymbol[], types: CompileTypeSummary[]): string {
-  const serializer = new Serializer(host);
-
-  // for symbols, we use everything except for the class metadata itself
-  // (we keep the statics though), as the class metadata is contained in the
-  // CompileTypeSummary.
-  symbols.forEach(
-      (resolvedSymbol) => serializer.addOrMergeSummary(
-          {symbol: resolvedSymbol.symbol, metadata: resolvedSymbol.metadata}));
-  // Add summaries that are referenced by the given symbols (transitively)
-  // Note: the serializer.symbols array might be growing while
-  // we execute the loop!
-  for (let processedIndex = 0; processedIndex < serializer.symbols.length; processedIndex++) {
-    const symbol = serializer.symbols[processedIndex];
-    if (!host.isSourceFile(symbol.filePath)) {
-      let summary = summaryResolver.resolveSummary(symbol);
-      if (!summary) {
-        // some symbols might originate from a plain typescript library
-        // that just exported .d.ts and .metadata.json files, i.e. where no summary
-        // files were created.
-        const resolvedSymbol = symbolResolver.resolveSymbol(symbol);
-        if (resolvedSymbol) {
-          summary = {symbol: resolvedSymbol.symbol, metadata: resolvedSymbol.metadata};
-        }
-      }
-      if (summary) {
-        serializer.addOrMergeSummary(summary);
-      }
-    }
-  }
-
-  // Add type summaries.
-  // Note: We don't add the summaries of all referenced symbols as for the ResolvedSymbols,
-  // as the type summaries already contain the transitive data that they require
-  // (in a minimal way).
-  types.forEach((typeSummary) => {
-    serializer.addOrMergeSummary(
-        {symbol: typeSummary.type.reference, metadata: {__symbolic: 'class'}, type: typeSummary});
-    if (typeSummary.summaryKind === CompileSummaryKind.NgModule) {
-      const ngModuleSummary = <CompileNgModuleSummary>typeSummary;
-      ngModuleSummary.exportedDirectives.concat(ngModuleSummary.exportedPipes).forEach((id) => {
-        const symbol: StaticSymbol = id.reference;
-        if (!host.isSourceFile(symbol.filePath)) {
-          serializer.addOrMergeSummary(summaryResolver.resolveSummary(symbol));
-        }
-      });
-    }
-  });
-  return serializer.serialize();
-}
-
-export function deserializeSummaries(
-    symbolCache: StaticSymbolCache, json: string): Summary<StaticSymbol>[] {
-  const deserializer = new Deserializer(symbolCache);
-  return deserializer.deserialize(json);
-}
-
-export function summaryFileName(fileName: string): string {
-  const fileNameWithoutSuffix = fileName.replace(STRIP_SRC_FILE_SUFFIXES, '');
-  return `${fileNameWithoutSuffix}.ngsummary.json`;
-}
-
-class Serializer extends ValueTransformer {
-  symbols: StaticSymbol[] = [];
-  private indexBySymbol = new Map<StaticSymbol, number>();
-  // This now contains a `__symbol: number` in the place of
-  // StaticSymbols, but otherwise has the same shape as the original objects.
-  private processedSummaryBySymbol = new Map<StaticSymbol, any>();
-  private processedSummaries: any[] = [];
-
-  constructor(private host: AotSummarySerializerHost) { super(); }
-
-  addOrMergeSummary(summary: Summary<StaticSymbol>) {
-    let symbolMeta = summary.metadata;
-    if (symbolMeta && symbolMeta.__symbolic === 'class') {
-      // For classes, we only keep their statics, but not the metadata
-      // of the class itself as that has been captured already via other summaries
-      // (e.g. DirectiveSummary, ...).
-      symbolMeta = {__symbolic: 'class', statics: symbolMeta.statics};
-    }
-
-    let processedSummary = this.processedSummaryBySymbol.get(summary.symbol);
-    if (!processedSummary) {
-      processedSummary = this.processValue({symbol: summary.symbol});
-      this.processedSummaries.push(processedSummary);
-      this.processedSummaryBySymbol.set(summary.symbol, processedSummary);
-    }
-    // Note: == by purpose to compare with undefined!
-    if (processedSummary.metadata == null && symbolMeta != null) {
-      processedSummary.metadata = this.processValue(symbolMeta);
-    }
-    // Note: == by purpose to compare with undefined!
-    if (processedSummary.type == null && summary.type != null) {
-      processedSummary.type = this.processValue(summary.type);
-    }
-  }
-
-  serialize(): string {
-    return JSON.stringify({
-      summaries: this.processedSummaries,
-      symbols: this.symbols.map((symbol, index) => {
-        return {
-          __symbol: index,
-          name: symbol.name,
-          // We convert the source filenames tinto output filenames,
-          // as the generated summary file will be used when teh current
-          // compilation unit is used as a library
-          filePath: this.host.getOutputFileName(symbol.filePath)
-        };
-      })
-    });
-  }
-
-  private processValue(value: any): any { return visitValue(value, this, null); }
-
-  visitOther(value: any, context: any): any {
-    if (value instanceof StaticSymbol) {
-      let index = this.indexBySymbol.get(value);
-      // Note: == by purpose to compare with undefined!
-      if (index == null) {
-        index = this.indexBySymbol.size;
-        this.indexBySymbol.set(value, index);
-        this.symbols.push(value);
-      }
-      return {__symbol: index};
-    }
-  }
-}
-
-class Deserializer extends ValueTransformer {
-  private symbols: StaticSymbol[];
-
-  constructor(private symbolCache: StaticSymbolCache) { super(); }
-
-  deserialize(json: string): Summary<StaticSymbol>[] {
-    const data: {summaries: any[], symbols: any[]} = JSON.parse(json);
-    this.symbols = data.symbols.map(
-        serializedSymbol => this.symbolCache.get(serializedSymbol.filePath, serializedSymbol.name));
-    return visitValue(data.summaries, this, null);
-  }
-
-  visitStringMap(map: {[key: string]: any}, context: any): any {
-    if ('__symbol' in map) {
-      return this.symbols[map['__symbol']];
-    } else {
-      return super.visitStringMap(map, context);
-    }
-  }
-}

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

@@ -0,0 +1,19 @@
+/**
+ * @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
+ */
+
+export function filterFileByPatterns(
+    fileName: string, options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp} = {}) {
+  let match = true;
+  if (options.includeFilePattern) {
+    match = match && !!options.includeFilePattern.exec(fileName);
+  }
+  if (options.excludeFilePattern) {
+    match = match && !options.excludeFilePattern.exec(fileName);
+  }
+  return match;
+}

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

@@ -115,10 +115,10 @@ export function identifierModuleUrl(compileIdentifier: CompileIdentifierMetadata
 export interface CompileIdentifierMetadata { reference: any; }
 
 export enum CompileSummaryKind {
+  Template,
   Pipe,
   Directive,
-  NgModule,
-  Injectable
+  NgModule
 }
 
 /**
@@ -126,10 +126,9 @@ export enum CompileSummaryKind {
  * in other modules / components. However, this data is not enough to compile
  * the directive / module itself.
  */
-export interface CompileTypeSummary {
-  summaryKind: CompileSummaryKind;
-  type: CompileTypeMetadata;
-}
+export interface CompileSummary { summaryKind: CompileSummaryKind; }
+
+export interface CompileTypeSummary extends CompileSummary { type: CompileTypeMetadata; }
 
 export interface CompileDiDependencyMetadata {
   isAttribute?: boolean;
@@ -211,7 +210,7 @@ export class CompileStylesheetMetadata {
 /**
  * Summary Metadata regarding compilation of a template.
  */
-export interface CompileTemplateSummary {
+export interface CompileTemplateSummary extends CompileSummary {
   animations: string[];
   ngContentSelectors: string[];
   encapsulation: ViewEncapsulation;
@@ -259,6 +258,7 @@ export class CompileTemplateMetadata {
 
   toSummary(): CompileTemplateSummary {
     return {
+      summaryKind: CompileSummaryKind.Template,
       animations: this.animations.map(anim => anim.name),
       ngContentSelectors: this.ngContentSelectors,
       encapsulation: this.encapsulation

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

@@ -6,12 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Component, ViewEncapsulation} from '@angular/core';
+import {Component, Injectable, ViewEncapsulation} from '@angular/core';
 
 import {CompileAnimationEntryMetadata, CompileDirectiveMetadata, CompileStylesheetMetadata, CompileTemplateMetadata, CompileTypeMetadata} from './compile_metadata';
 import {CompilerConfig} from './config';
 import {isBlank, isPresent, stringify} from './facade/lang';
-import {CompilerInjectable} from './injectable';
 import * as html from './ml_parser/ast';
 import {HtmlParser} from './ml_parser/html_parser';
 import {InterpolationConfig} from './ml_parser/interpolation_config';
@@ -19,7 +18,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} from './util';
 
 export interface PrenormalizedTemplateMetadata {
   componentType: any;
@@ -33,7 +32,7 @@ export interface PrenormalizedTemplateMetadata {
   animations?: CompileAnimationEntryMetadata[];
 }
 
-@CompilerInjectable()
+@Injectable()
 export class DirectiveNormalizer {
   private _resourceLoaderCache = new Map<string, Promise<string>>();
 
@@ -71,7 +70,7 @@ export class DirectiveNormalizer {
     } else if (prenormData.templateUrl) {
       normalizedTemplateAsync = this.normalizeTemplateAsync(prenormData);
     } else {
-      throw new SyntaxError(
+      throw new Error(
           `No template specified for component ${stringify(prenormData.componentType)}`);
     }
 
@@ -105,7 +104,7 @@ export class DirectiveNormalizer {
         template, stringify(prenomData.componentType), false, interpolationConfig);
     if (rootNodesAndErrors.errors.length > 0) {
       const errorString = rootNodesAndErrors.errors.join('\n');
-      throw new SyntaxError(`Template parse errors:\n${errorString}`);
+      throw new Error(`Template parse errors:\n${errorString}`);
     }
     const templateMetadataStyles = this.normalizeStylesheet(new CompileStylesheetMetadata({
       styles: prenomData.styles,

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

@@ -6,16 +6,14 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Component, Directive, HostBinding, HostListener, Input, Output, Query, Type, resolveForwardRef} from '@angular/core';
+import {Component, Directive, HostBinding, HostListener, Injectable, Input, Output, Query, Type, resolveForwardRef} from '@angular/core';
 
 import {ListWrapper, StringMapWrapper} from './facade/collection';
 import {stringify} from './facade/lang';
-import {CompilerInjectable} from './injectable';
 import {ReflectorReader, reflector} from './private_import_core';
 import {splitAtColon} from './util';
 
 
-
 /*
  * Resolve a `Type` for {@link Directive}.
  *
@@ -23,7 +21,7 @@ import {splitAtColon} from './util';
  *
  * See {@link Compiler}
  */
-@CompilerInjectable()
+@Injectable()
 export class DirectiveResolver {
   constructor(private _reflector: ReflectorReader = reflector) {}
 

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

@@ -6,6 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {Injectable} from '@angular/core';
+
 import {CompileDirectiveMetadata, CompileDirectiveSummary, CompileIdentifierMetadata, identifierModuleUrl, identifierName} from './compile_metadata';
 import {createCheckBindingField, createCheckBindingStmt} from './compiler_util/binding_util';
 import {EventHandlerVars, convertActionBinding, convertPropertyBinding} from './compiler_util/expression_converter';
@@ -13,7 +15,6 @@ import {triggerAnimation, writeToRenderer} from './compiler_util/render_util';
 import {CompilerConfig} from './config';
 import {Parser} from './expression_parser/parser';
 import {Identifiers, createIdentifier} from './identifiers';
-import {CompilerInjectable} from './injectable';
 import {DEFAULT_INTERPOLATION_CONFIG} from './ml_parser/interpolation_config';
 import {ClassBuilder, createClassStmt} from './output/class_builder';
 import * as o from './output/output_ast';
@@ -50,7 +51,7 @@ const RESET_CHANGES_STMT = o.THIS_EXPR.prop(CHANGES_FIELD_NAME).set(o.literalMap
  *
  * So far, only `@Input` and the lifecycle hooks have been implemented.
  */
-@CompilerInjectable()
+@Injectable()
 export class DirectiveWrapperCompiler {
   static dirWrapperClassName(id: CompileIdentifierMetadata) {
     return `Wrapper_${identifierName(id)}`;

modules/@angular/compiler/src/expression_parser/lexer.ts

@@ -6,9 +6,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {Injectable} from '@angular/core';
 import * as chars from '../chars';
 import {NumberWrapper, isPresent} from '../facade/lang';
-import {CompilerInjectable} from '../injectable';
 
 export enum TokenType {
   Character,
@@ -22,7 +22,7 @@ export enum TokenType {
 
 const KEYWORDS = ['var', 'let', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this'];
 
-@CompilerInjectable()
+@Injectable()
 export class Lexer {
   tokenize(text: string): Token[] {
     const scanner = new _Scanner(text);

modules/@angular/compiler/src/expression_parser/parser.ts

@@ -6,9 +6,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {Injectable} from '@angular/core';
+
 import * as chars from '../chars';
 import {escapeRegExp, isBlank, isPresent} from '../facade/lang';
-import {CompilerInjectable} from '../injectable';
 import {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from '../ml_parser/interpolation_config';
 
 import {AST, ASTWithSource, AstVisitor, Binary, BindingPipe, Chain, Conditional, EmptyExpr, FunctionCall, ImplicitReceiver, Interpolation, KeyedRead, KeyedWrite, LiteralArray, LiteralMap, LiteralPrimitive, MethodCall, ParseSpan, ParserError, PrefixNot, PropertyRead, PropertyWrite, Quote, SafeMethodCall, SafePropertyRead, TemplateBinding} from './ast';
@@ -30,7 +31,7 @@ function _createInterpolateRegExp(config: InterpolationConfig): RegExp {
   return new RegExp(pattern, 'g');
 }
 
-@CompilerInjectable()
+@Injectable()
 export class Parser {
   private errors: ParserError[] = [];
 

modules/@angular/compiler/src/i18n/digest.ts

@@ -9,13 +9,13 @@
 import * as i18n from './i18n_ast';
 
 export function digest(message: i18n.Message): string {
-  return sha1(serializeNodes(message.nodes).join('') + `[${message.meaning}]`);
+  return message.id || sha1(serializeNodes(message.nodes).join('') + `[${message.meaning}]`);
 }
 
 export function decimalDigest(message: i18n.Message): string {
   const visitor = new _SerializerIgnoreIcuExpVisitor();
   const parts = message.nodes.map(a => a.visit(visitor, null));
-  return computeMsgId(parts.join(''), message.meaning);
+  return message.id || computeMsgId(parts.join(''), message.meaning);
 }
 
 /**

modules/@angular/compiler/src/i18n/extractor.ts

@@ -14,9 +14,7 @@ import {ViewEncapsulation} from '@angular/core';
 
 import {analyzeAndValidateNgModules, extractProgramSymbols} from '../aot/compiler';
 import {StaticAndDynamicReflectionCapabilities} from '../aot/static_reflection_capabilities';
-import {StaticReflector} from '../aot/static_reflector';
-import {StaticSymbolCache} from '../aot/static_symbol';
-import {StaticSymbolResolver, StaticSymbolResolverHost} from '../aot/static_symbol_resolver';
+import {StaticReflector, StaticReflectorHost} from '../aot/static_reflector';
 import {AotSummaryResolver, AotSummaryResolverHost} from '../aot/summary_resolver';
 import {CompileDirectiveMetadata} from '../compile_metadata';
 import {CompilerConfig} from '../config';
@@ -28,17 +26,23 @@ import {InterpolationConfig} from '../ml_parser/interpolation_config';
 import {NgModuleResolver} from '../ng_module_resolver';
 import {ParseError} from '../parse_util';
 import {PipeResolver} from '../pipe_resolver';
+import {Console} from '../private_import_core';
 import {DomElementSchemaRegistry} from '../schema/dom_element_schema_registry';
 import {createOfflineCompileUrlResolver} from '../url_resolver';
 
 import {I18NHtmlParser} from './i18n_html_parser';
 import {MessageBundle} from './message_bundle';
 
+export interface ExtractorOptions {
+  includeFilePattern?: RegExp;
+  excludeFilePattern?: RegExp;
+}
+
 /**
  * The host of the Extractor disconnects the implementation from TypeScript / other language
  * services and from underlying file systems.
  */
-export interface ExtractorHost extends StaticSymbolResolverHost, AotSummaryResolverHost {
+export interface ExtractorHost extends StaticReflectorHost, AotSummaryResolverHost {
   /**
    * Loads a resource (e.g. html / css)
    */
@@ -47,13 +51,14 @@ export interface ExtractorHost extends StaticSymbolResolverHost, AotSummaryResol
 
 export class Extractor {
   constructor(
-      public host: ExtractorHost, private staticSymbolResolver: StaticSymbolResolver,
-      private messageBundle: MessageBundle, private metadataResolver: CompileMetadataResolver) {}
+      private options: ExtractorOptions, public host: ExtractorHost,
+      private staticReflector: StaticReflector, private messageBundle: MessageBundle,
+      private metadataResolver: CompileMetadataResolver) {}
 
   extract(rootFiles: string[]): Promise<MessageBundle> {
-    const programSymbols = extractProgramSymbols(this.staticSymbolResolver, rootFiles, this.host);
+    const programSymbols = extractProgramSymbols(this.staticReflector, rootFiles, this.options);
     const {ngModuleByPipeOrDirective, files, ngModules} =
-        analyzeAndValidateNgModules(programSymbols, this.host, this.metadataResolver);
+        analyzeAndValidateNgModules(programSymbols, this.options, this.metadataResolver);
     return Promise
         .all(ngModules.map(
             ngModule => this.metadataResolver.loadNgModuleDirectiveAndPipeMetadata(
@@ -86,14 +91,12 @@ export class Extractor {
         });
   }
 
-  static create(host: ExtractorHost): {extractor: Extractor, staticReflector: StaticReflector} {
+  static create(host: ExtractorHost, options: ExtractorOptions):
+      {extractor: Extractor, staticReflector: StaticReflector} {
     const htmlParser = new I18NHtmlParser(new HtmlParser());
 
     const urlResolver = createOfflineCompileUrlResolver();
-    const symbolCache = new StaticSymbolCache();
-    const summaryResolver = new AotSummaryResolver(host, symbolCache);
-    const staticSymbolResolver = new StaticSymbolResolver(host, symbolCache, summaryResolver);
-    const staticReflector = new StaticReflector(staticSymbolResolver);
+    const staticReflector = new StaticReflector(host);
     StaticAndDynamicReflectionCapabilities.install(staticReflector);
 
     const config = new CompilerConfig({
@@ -108,13 +111,13 @@ export class Extractor {
     const elementSchemaRegistry = new DomElementSchemaRegistry();
     const resolver = new CompileMetadataResolver(
         new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector),
-        new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer,
-        staticReflector);
+        new PipeResolver(staticReflector), new AotSummaryResolver(host, staticReflector, options),
+        elementSchemaRegistry, normalizer, staticReflector);
 
     // TODO(vicb): implicit tags & attributes
     const messageBundle = new MessageBundle(htmlParser, [], {});
 
-    const extractor = new Extractor(host, staticSymbolResolver, messageBundle, resolver);
+    const extractor = new Extractor(options, host, staticReflector, messageBundle, resolver);
     return {extractor, staticReflector};
   }
 }

modules/@angular/compiler/src/i18n/extractor_merger.ts

@@ -18,6 +18,8 @@ import {TranslationBundle} from './translation_bundle';
 const _I18N_ATTR = 'i18n';
 const _I18N_ATTR_PREFIX = 'i18n-';
 const _I18N_COMMENT_PREFIX_REGEXP = /^i18n:?/;
+const MEANING_SEPARATOR = '|';
+const ID_SEPARATOR = '@@';
 
 /**
  * Extract translatable messages from an html AST
@@ -77,7 +79,7 @@ class _Visitor implements html.Visitor {
   // _VisitorMode.Merge only
   private _translations: TranslationBundle;
   private _createI18nMessage:
-      (msg: html.Node[], meaning: string, description: string) => i18n.Message;
+      (msg: html.Node[], meaning: string, description: string, id: string) => i18n.Message;
 
 
   constructor(private _implicitTags: string[], private _implicitAttrs: {[k: string]: string[]}) {}
@@ -330,15 +332,15 @@ class _Visitor implements html.Visitor {
   }
 
   // add a translatable message
-  private _addMessage(ast: html.Node[], meaningAndDesc?: string): i18n.Message {
+  private _addMessage(ast: html.Node[], msgMeta?: string): i18n.Message {
     if (ast.length == 0 ||
         ast.length == 1 && ast[0] instanceof html.Attribute && !(<html.Attribute>ast[0]).value) {
       // Do not create empty messages
       return;
     }
 
-    const [meaning, description] = _splitMeaningAndDesc(meaningAndDesc);
-    const message = this._createI18nMessage(ast, meaning, description);
+    const {meaning, description, id} = _parseMessageMeta(msgMeta);
+    const message = this._createI18nMessage(ast, meaning, description, id);
     this._messages.push(message);
     return message;
   }
@@ -368,7 +370,7 @@ class _Visitor implements html.Visitor {
     attributes.forEach(attr => {
       if (attr.name.startsWith(_I18N_ATTR_PREFIX)) {
         i18nAttributeMeanings[attr.name.slice(_I18N_ATTR_PREFIX.length)] =
-            _splitMeaningAndDesc(attr.value)[0];
+            _parseMessageMeta(attr.value).meaning;
       }
     });
 
@@ -382,7 +384,7 @@ class _Visitor implements html.Visitor {
 
       if (attr.value && attr.value != '' && i18nAttributeMeanings.hasOwnProperty(attr.name)) {
         const meaning = i18nAttributeMeanings[attr.name];
-        const message: i18n.Message = this._createI18nMessage([attr], meaning, '');
+        const message: i18n.Message = this._createI18nMessage([attr], meaning, '', '');
         const nodes = this._translations.get(message);
         if (nodes) {
           if (nodes[0] instanceof html.Text) {
@@ -496,8 +498,16 @@ function _getI18nAttr(p: html.Element): html.Attribute {
   return p.attrs.find(attr => attr.name === _I18N_ATTR) || null;
 }
 
-function _splitMeaningAndDesc(i18n: string): [string, string] {
-  if (!i18n) return ['', ''];
-  const pipeIndex = i18n.indexOf('|');
-  return pipeIndex == -1 ? ['', i18n] : [i18n.slice(0, pipeIndex), i18n.slice(pipeIndex + 1)];
+function _parseMessageMeta(i18n: string): {meaning: string, description: string, id: string} {
+  if (!i18n) return {meaning: '', description: '', id: ''};
+
+  const idIndex = i18n.indexOf(ID_SEPARATOR);
+  const descIndex = i18n.indexOf(MEANING_SEPARATOR);
+  const [meaningAndDesc, id] =
+      (idIndex > -1) ? [i18n.slice(0, idIndex), i18n.slice(idIndex + 2)] : [i18n, ''];
+  const [meaning, description] = (descIndex > -1) ?
+      [meaningAndDesc.slice(0, descIndex), meaningAndDesc.slice(descIndex + 1)] :
+      ['', meaningAndDesc];
+
+  return {meaning, description, id};
 }

modules/@angular/compiler/src/i18n/i18n_ast.ts

@@ -15,11 +15,12 @@ export class Message {
    * @param placeholderToMessage maps placeholder names to messages (used for nested ICU messages)
    * @param meaning
    * @param description
+   * @param id
    */
   constructor(
       public nodes: Node[], public placeholders: {[phName: string]: string},
       public placeholderToMessage: {[phName: string]: Message}, public meaning: string,
-      public description: string) {}
+      public description: string, public id: string) {}
 }
 
 export interface Node {

modules/@angular/compiler/src/i18n/i18n_parser.ts

@@ -22,11 +22,11 @@ const _expParser = new ExpressionParser(new ExpressionLexer());
  * Returns a function converting html nodes to an i18n Message given an interpolationConfig
  */
 export function createI18nMessageFactory(interpolationConfig: InterpolationConfig): (
-    nodes: html.Node[], meaning: string, description: string) => i18n.Message {
+    nodes: html.Node[], meaning: string, description: string, id: string) => i18n.Message {
   const visitor = new _I18nVisitor(_expParser, interpolationConfig);
 
-  return (nodes: html.Node[], meaning: string, description: string) =>
-             visitor.toI18nMessage(nodes, meaning, description);
+  return (nodes: html.Node[], meaning: string, description: string, id: string) =>
+             visitor.toI18nMessage(nodes, meaning, description, id);
 }
 
 class _I18nVisitor implements html.Visitor {
@@ -40,7 +40,8 @@ class _I18nVisitor implements html.Visitor {
       private _expressionParser: ExpressionParser,
       private _interpolationConfig: InterpolationConfig) {}
 
-  public toI18nMessage(nodes: html.Node[], meaning: string, description: string): i18n.Message {
+  public toI18nMessage(nodes: html.Node[], meaning: string, description: string, id: string):
+      i18n.Message {
     this._isIcu = nodes.length == 1 && nodes[0] instanceof html.Expansion;
     this._icuDepth = 0;
     this._placeholderRegistry = new PlaceholderRegistry();
@@ -50,7 +51,7 @@ class _I18nVisitor implements html.Visitor {
     const i18nodes: i18n.Node[] = html.visitAll(this, nodes, {});
 
     return new i18n.Message(
-        i18nodes, this._placeholderToContent, this._placeholderToMessage, meaning, description);
+        i18nodes, this._placeholderToContent, this._placeholderToMessage, meaning, description, id);
   }
 
   visitElement(el: html.Element, context: any): i18n.Node {
@@ -115,7 +116,7 @@ class _I18nVisitor implements html.Visitor {
     // TODO(vicb): add a html.Node -> i18n.Message cache to avoid having to re-create the msg
     const phName = this._placeholderRegistry.getPlaceholderName('ICU', icu.sourceSpan.toString());
     const visitor = new _I18nVisitor(this._expressionParser, this._interpolationConfig);
-    this._placeholderToMessage[phName] = visitor.toI18nMessage([icu], '', '');
+    this._placeholderToMessage[phName] = visitor.toI18nMessage([icu], '', '', '');
     return new i18n.IcuPlaceholder(i18nIcu, phName, icu.sourceSpan);
   }
 

modules/@angular/compiler/src/i18n/index.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-export {Extractor, ExtractorHost} from './extractor';
+export {Extractor, ExtractorHost, ExtractorOptions} from './extractor';
 export {I18NHtmlParser} from './i18n_html_parser';
 export {MessageBundle} from './message_bundle';
 export {Serializer} from './serializers/serializer';

modules/@angular/compiler/src/i18n/serializers/xmb.ts

@@ -39,7 +39,6 @@ const _DOCTYPE = `<!ELEMENT messagebundle (msg)*>
 
 export class Xmb implements Serializer {
   write(messages: i18n.Message[]): string {
-    const exampleVisitor = new ExampleVisitor();
     const visitor = new _Visitor();
     const visited: {[id: string]: boolean} = {};
     let rootNode = new xml.Tag(_MESSAGES_TAG);
@@ -72,7 +71,7 @@ export class Xmb implements Serializer {
       new xml.CR(),
       new xml.Doctype(_MESSAGES_TAG, _DOCTYPE),
       new xml.CR(),
-      exampleVisitor.addDefaultExamples(rootNode),
+      rootNode,
       new xml.CR(),
     ]);
   }
@@ -135,26 +134,3 @@ class _Visitor implements i18n.Visitor {
 export function digest(message: i18n.Message): string {
   return decimalDigest(message);
 }
-
-// TC requires at least one non-empty example on placeholders
-class ExampleVisitor implements xml.IVisitor {
-  addDefaultExamples(node: xml.Node): xml.Node {
-    node.visit(this);
-    return node;
-  }
-
-  visitTag(tag: xml.Tag): void {
-    if (tag.name === _PLACEHOLDER_TAG) {
-      if (!tag.children || tag.children.length == 0) {
-        const exText = new xml.Text(tag.attrs['name'] || '...');
-        tag.children = [new xml.Tag(_EXEMPLE_TAG, {}, [exText])];
-      }
-    } else if (tag.children) {
-      tag.children.forEach(node => node.visit(this));
-    }
-  }
-
-  visitText(text: xml.Text): void {}
-  visitDeclaration(decl: xml.Declaration): void {}
-  visitDoctype(doctype: xml.Doctype): void {}
-}

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

@@ -1,16 +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
- */
-
-/**
- * A replacement for @Injectable to be used in the compiler, so that
- * we don't try to evaluate the metadata in the compiler during AoT.
- * This decorator is enough to make the compiler work with the ReflectiveInjector though.
- */
-export function CompilerInjectable(): (data: any) => any {
-  return (x) => x;
-}

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

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Compiler, ComponentFactory, Injector, ModuleWithComponentFactories, NgModuleFactory, SchemaMetadata, Type} from '@angular/core';
+import {Compiler, ComponentFactory, Injectable, Injector, ModuleWithComponentFactories, NgModuleFactory, SchemaMetadata, Type} from '@angular/core';
 
 import {AnimationCompiler} from '../animation/animation_compiler';
 import {AnimationParser} from '../animation/animation_parser';
@@ -15,7 +15,6 @@ import {CompilerConfig} from '../config';
 import {DirectiveNormalizer} from '../directive_normalizer';
 import {DirectiveWrapperCompiler} from '../directive_wrapper_compiler';
 import {stringify} from '../facade/lang';
-import {CompilerInjectable} from '../injectable';
 import {CompileMetadataResolver} from '../metadata_resolver';
 import {NgModuleCompiler} from '../ng_module_compiler';
 import * as ir from '../output/output_ast';
@@ -37,7 +36,7 @@ import {ComponentFactoryDependency, DirectiveWrapperDependency, ViewClassDepende
  * from a trusted source. Attacker-controlled data introduced by a template could expose your
  * application to XSS risks.  For more detail, see the [Security Guide](http://g.co/ng/security).
  */
-@CompilerInjectable()
+@Injectable()
 export class JitCompiler implements Compiler {
   private _compiledTemplateCache = new Map<Type<any>, CompiledTemplate>();
   private _compiledHostTemplateCache = new Map<Type<any>, CompiledTemplate>();

modules/@angular/compiler/src/jit/compiler_factory.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {COMPILER_OPTIONS, Compiler, CompilerFactory, CompilerOptions, Inject, Optional, PLATFORM_INITIALIZER, PlatformRef, Provider, ReflectiveInjector, TRANSLATIONS, TRANSLATIONS_FORMAT, Type, ViewEncapsulation, createPlatformFactory, isDevMode, platformCore} from '@angular/core';
+import {COMPILER_OPTIONS, Compiler, CompilerFactory, CompilerOptions, Inject, Injectable, Optional, PLATFORM_INITIALIZER, PlatformRef, Provider, ReflectiveInjector, TRANSLATIONS, TRANSLATIONS_FORMAT, Type, ViewEncapsulation, createPlatformFactory, isDevMode, platformCore} from '@angular/core';
 
 import {AnimationParser} from '../animation/animation_parser';
 import {CompilerConfig} from '../config';
@@ -16,7 +16,6 @@ import {DirectiveWrapperCompiler} from '../directive_wrapper_compiler';
 import {Lexer} from '../expression_parser/lexer';
 import {Parser} from '../expression_parser/parser';
 import * as i18n from '../i18n/index';
-import {CompilerInjectable} from '../injectable';
 import {CompileMetadataResolver} from '../metadata_resolver';
 import {HtmlParser} from '../ml_parser/html_parser';
 import {NgModuleCompiler} from '../ng_module_compiler';
@@ -84,7 +83,7 @@ export const COMPILER_PROVIDERS: Array<any|Type<any>|{[k: string]: any}|any[]> =
 ];
 
 
-@CompilerInjectable()
+@Injectable()
 export class JitCompilerFactory implements CompilerFactory {
   private _defaultOptions: CompilerOptions[];
   constructor(@Inject(COMPILER_OPTIONS) defaultOptions: CompilerOptions[]) {

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

@@ -16,7 +16,6 @@ import {DirectiveResolver} from './directive_resolver';
 import {ListWrapper, StringMapWrapper} from './facade/collection';
 import {isBlank, isPresent, stringify} from './facade/lang';
 import {Identifiers, createIdentifierToken, resolveIdentifier} from './identifiers';
-import {CompilerInjectable} from './injectable';
 import {hasLifecycleHook} from './lifecycle_reflector';
 import {NgModuleResolver} from './ng_module_resolver';
 import {PipeResolver} from './pipe_resolver';
@@ -24,7 +23,7 @@ import {ComponentStillLoadingError, LIFECYCLE_HOOKS_VALUES, ReflectorReader, ref
 import {ElementSchemaRegistry} from './schema/element_schema_registry';
 import {SummaryResolver} from './summary_resolver';
 import {getUrlScheme} from './url_resolver';
-import {MODULE_SUFFIX, SyncAsyncResult, SyntaxError, ValueTransformer, visitValue} from './util';
+import {MODULE_SUFFIX, SyncAsyncResult, ValueTransformer, visitValue} from './util';
 
 export type ErrorCollector = (error: any, type?: any) => void;
 export const ERROR_COLLECTOR_TOKEN = new OpaqueToken('ErrorCollector');
@@ -36,7 +35,7 @@ export const ERROR_COLLECTOR_TOKEN = new OpaqueToken('ErrorCollector');
 //   But we want to report errors even when the async work is
 //   not required to check that the user would have been able
 //   to wait correctly.
-@CompilerInjectable()
+@Injectable()
 export class CompileMetadataResolver {
   private _directiveCache = new Map<Type<any>, cpl.CompileDirectiveMetadata>();
   private _summaryCache = new Map<Type<any>, cpl.CompileTypeSummary>();
@@ -46,7 +45,7 @@ export class CompileMetadataResolver {
 
   constructor(
       private _ngModuleResolver: NgModuleResolver, private _directiveResolver: DirectiveResolver,
-      private _pipeResolver: PipeResolver, private _summaryResolver: SummaryResolver<any>,
+      private _pipeResolver: PipeResolver, private _summaryResolver: SummaryResolver,
       private _schemaRegistry: ElementSchemaRegistry,
       private _directiveNormalizer: DirectiveNormalizer,
       private _reflector: ReflectorReader = reflector,
@@ -129,13 +128,12 @@ export class CompileMetadataResolver {
   }
 
   private _loadSummary(type: any, kind: cpl.CompileSummaryKind): cpl.CompileTypeSummary {
-    let typeSummary = this._summaryCache.get(type);
-    if (!typeSummary) {
-      const summary = this._summaryResolver.resolveSummary(type);
-      typeSummary = summary ? summary.type : null;
-      this._summaryCache.set(type, typeSummary);
+    let summary = this._summaryCache.get(type);
+    if (!summary) {
+      summary = this._summaryResolver.resolveSummary(type);
+      this._summaryCache.set(type, summary);
     }
-    return typeSummary && typeSummary.summaryKind === kind ? typeSummary : null;
+    return summary && summary.summaryKind === kind ? summary : null;
   }
 
   private _loadDirectiveMetadata(directiveType: any, isSync: boolean): Promise<any> {
@@ -239,7 +237,7 @@ export class CompileMetadataResolver {
       if (dirMeta.viewProviders) {
         viewProviders = this._getProvidersMetadata(
             dirMeta.viewProviders, entryComponentMetadata,
-            `viewProviders for "${stringifyType(directiveType)}"`, [], directiveType);
+            `viewProviders for "${stringify(directiveType)}"`, [], directiveType);
       }
       if (dirMeta.entryComponents) {
         entryComponentMetadata = flattenAndDedupeArray(dirMeta.entryComponents)
@@ -253,8 +251,7 @@ export class CompileMetadataResolver {
       // Directive
       if (!selector) {
         this._reportError(
-            new SyntaxError(
-                `Directive ${stringifyType(directiveType)} has no selector, please add it!`),
+            new Error(`Directive ${stringify(directiveType)} has no selector, please add it!`),
             directiveType);
         selector = 'error';
       }
@@ -263,8 +260,8 @@ export class CompileMetadataResolver {
     let providers: cpl.CompileProviderMetadata[] = [];
     if (isPresent(dirMeta.providers)) {
       providers = this._getProvidersMetadata(
-          dirMeta.providers, entryComponentMetadata,
-          `providers for "${stringifyType(directiveType)}"`, [], directiveType);
+          dirMeta.providers, entryComponentMetadata, `providers for "${stringify(directiveType)}"`,
+          [], directiveType);
     }
     let queries: cpl.CompileQueryMetadata[] = [];
     let viewQueries: cpl.CompileQueryMetadata[] = [];
@@ -300,8 +297,8 @@ export class CompileMetadataResolver {
     const dirMeta = this._directiveCache.get(directiveType);
     if (!dirMeta) {
       this._reportError(
-          new SyntaxError(
-              `Illegal state: getDirectiveMetadata can only be called after loadNgModuleMetadata for a module that declares it. Directive ${stringifyType(directiveType)}.`),
+          new Error(
+              `Illegal state: getDirectiveMetadata can only be called after loadNgModuleMetadata for a module that declares it. Directive ${stringify(directiveType)}.`),
           directiveType);
     }
     return dirMeta;
@@ -312,8 +309,8 @@ export class CompileMetadataResolver {
         <cpl.CompileDirectiveSummary>this._loadSummary(dirType, cpl.CompileSummaryKind.Directive);
     if (!dirSummary) {
       this._reportError(
-          new SyntaxError(
-              `Illegal state: Could not load the summary for directive ${stringifyType(dirType)}.`),
+          new Error(
+              `Illegal state: Could not load the summary for directive ${stringify(dirType)}.`),
           dirType);
     }
     return dirSummary;
@@ -386,8 +383,7 @@ export class CompileMetadataResolver {
           if (moduleWithProviders.providers) {
             providers.push(...this._getProvidersMetadata(
                 moduleWithProviders.providers, entryComponents,
-                `provider for the NgModule '${stringifyType(importedModuleType)}'`, [],
-                importedType));
+                `provider for the NgModule '${stringify(importedModuleType)}'`, [], importedType));
           }
         }
 
@@ -395,16 +391,16 @@ export class CompileMetadataResolver {
           const importedModuleSummary = this.getNgModuleSummary(importedModuleType);
           if (!importedModuleSummary) {
             this._reportError(
-                new SyntaxError(
-                    `Unexpected ${this._getTypeDescriptor(importedType)} '${stringifyType(importedType)}' imported by the module '${stringifyType(moduleType)}'`),
+                new Error(
+                    `Unexpected ${this._getTypeDescriptor(importedType)} '${stringify(importedType)}' imported by the module '${stringify(moduleType)}'`),
                 moduleType);
             return;
           }
           importedModules.push(importedModuleSummary);
         } else {
           this._reportError(
-              new SyntaxError(
-                  `Unexpected value '${stringifyType(importedType)}' imported by the module '${stringifyType(moduleType)}'`),
+              new Error(
+                  `Unexpected value '${stringify(importedType)}' imported by the module '${stringify(moduleType)}'`),
               moduleType);
           return;
         }
@@ -415,8 +411,8 @@ export class CompileMetadataResolver {
       flattenAndDedupeArray(meta.exports).forEach((exportedType) => {
         if (!isValidType(exportedType)) {
           this._reportError(
-              new SyntaxError(
-                  `Unexpected value '${stringifyType(exportedType)}' exported by the module '${stringifyType(moduleType)}'`),
+              new Error(
+                  `Unexpected value '${stringify(exportedType)}' exported by the module '${stringify(moduleType)}'`),
               moduleType);
           return;
         }
@@ -436,8 +432,8 @@ export class CompileMetadataResolver {
       flattenAndDedupeArray(meta.declarations).forEach((declaredType) => {
         if (!isValidType(declaredType)) {
           this._reportError(
-              new SyntaxError(
-                  `Unexpected value '${stringifyType(declaredType)}' declared by the module '${stringifyType(moduleType)}'`),
+              new Error(
+                  `Unexpected value '${stringify(declaredType)}' declared by the module '${stringify(moduleType)}'`),
               moduleType);
           return;
         }
@@ -453,8 +449,8 @@ export class CompileMetadataResolver {
           this._addTypeToModule(declaredType, moduleType);
         } else {
           this._reportError(
-              new SyntaxError(
-                  `Unexpected ${this._getTypeDescriptor(declaredType)} '${stringifyType(declaredType)}' declared by the module '${stringifyType(moduleType)}'`),
+              new Error(
+                  `Unexpected ${this._getTypeDescriptor(declaredType)} '${stringify(declaredType)}' declared by the module '${stringify(moduleType)}'`),
               moduleType);
           return;
         }
@@ -472,8 +468,8 @@ export class CompileMetadataResolver {
         transitiveModule.addExportedPipe(exportedId);
       } else {
         this._reportError(
-            new SyntaxError(
-                `Can't export ${this._getTypeDescriptor(exportedId.reference)} ${stringifyType(exportedId.reference)} from ${stringifyType(moduleType)} as it was neither declared nor imported!`),
+            new Error(
+                `Can't export ${this._getTypeDescriptor(exportedId.reference)} ${stringify(exportedId.reference)} from ${stringify(moduleType)} as it was neither declared nor imported!`),
             moduleType);
       }
     });
@@ -482,25 +478,25 @@ export class CompileMetadataResolver {
     // so that they overwrite any other provider we already added.
     if (meta.providers) {
       providers.push(...this._getProvidersMetadata(
-          meta.providers, entryComponents,
-          `provider for the NgModule '${stringifyType(moduleType)}'`, [], moduleType));
+          meta.providers, entryComponents, `provider for the NgModule '${stringify(moduleType)}'`,
+          [], moduleType));
     }
 
     if (meta.entryComponents) {
-      entryComponents.push(...flattenAndDedupeArray(meta.entryComponents)
-                               .map(type => this._getIdentifierMetadata(type)));
+      entryComponents.push(
+          ...flattenAndDedupeArray(meta.entryComponents).map(type => this._getTypeMetadata(type)));
     }
 
     if (meta.bootstrap) {
       flattenAndDedupeArray(meta.bootstrap).forEach(type => {
         if (!isValidType(type)) {
           this._reportError(
-              new SyntaxError(
-                  `Unexpected value '${stringifyType(type)}' used in the bootstrap property of module '${stringifyType(moduleType)}'`),
+              new Error(
+                  `Unexpected value '${stringify(type)}' used in the bootstrap property of module '${stringify(moduleType)}'`),
               moduleType);
           return;
         }
-        bootstrapComponents.push(this._getIdentifierMetadata(type));
+        bootstrapComponents.push(this._getTypeMetadata(type));
       });
     }
 
@@ -558,10 +554,10 @@ export class CompileMetadataResolver {
     const oldModule = this._ngModuleOfTypes.get(type);
     if (oldModule && oldModule !== moduleType) {
       this._reportError(
-          new 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)}.`),
+          new Error(
+              `Type ${stringify(type)} is part of the declarations of 2 modules: ${stringify(oldModule)} and ${stringify(moduleType)}! ` +
+              `Please consider moving ${stringify(type)} to a higher module that imports ${stringify(oldModule)} and ${stringify(moduleType)}. ` +
+              `You can also create a new NgModule that exports and includes ${stringify(type)} then import that NgModule in ${stringify(oldModule)} and ${stringify(moduleType)}.`),
           moduleType);
     }
     this._ngModuleOfTypes.set(type, moduleType);
@@ -610,26 +606,6 @@ export class CompileMetadataResolver {
     return {reference: type};
   }
 
-  isInjectable(type: any): boolean {
-    const annotations = this._reflector.annotations(type);
-    // Note: We need an exact check here as @Component / @Directive / ... inherit
-    // from @CompilerInjectable!
-    return annotations.some(ann => ann.constructor === Injectable);
-  }
-
-  getInjectableSummary(type: any): cpl.CompileTypeSummary {
-    return {summaryKind: cpl.CompileSummaryKind.Injectable, type: this._getTypeMetadata(type)};
-  }
-
-  private _getInjectableMetadata(type: Type<any>, dependencies: any[] = null):
-      cpl.CompileTypeMetadata {
-    const typeSummary = this._loadSummary(type, cpl.CompileSummaryKind.Injectable);
-    if (typeSummary) {
-      return typeSummary.type;
-    }
-    return this._getTypeMetadata(type, dependencies);
-  }
-
   private _getTypeMetadata(type: Type<any>, dependencies: any[] = null): cpl.CompileTypeMetadata {
     const identifier = this._getIdentifierMetadata(type);
     return {
@@ -654,8 +630,8 @@ export class CompileMetadataResolver {
     const pipeMeta = this._pipeCache.get(pipeType);
     if (!pipeMeta) {
       this._reportError(
-          new SyntaxError(
-              `Illegal state: getPipeMetadata can only be called after loadNgModuleMetadata for a module that declares it. Pipe ${stringifyType(pipeType)}.`),
+          new Error(
+              `Illegal state: getPipeMetadata can only be called after loadNgModuleMetadata for a module that declares it. Pipe ${stringify(pipeType)}.`),
           pipeType);
     }
     return pipeMeta;
@@ -666,8 +642,7 @@ export class CompileMetadataResolver {
         <cpl.CompilePipeSummary>this._loadSummary(pipeType, cpl.CompileSummaryKind.Pipe);
     if (!pipeSummary) {
       this._reportError(
-          new SyntaxError(
-              `Illegal state: Could not load the summary for pipe ${stringifyType(pipeType)}.`),
+          new Error(`Illegal state: Could not load the summary for pipe ${stringify(pipeType)}.`),
           pipeType);
     }
     return pipeSummary;
@@ -747,10 +722,9 @@ export class CompileMetadataResolver {
 
     if (hasUnknownDeps) {
       const depsTokens =
-          dependenciesMetadata.map((dep) => dep ? stringifyType(dep.token) : '?').join(', ');
+          dependenciesMetadata.map((dep) => dep ? stringify(dep.token) : '?').join(', ');
       this._reportError(
-          new SyntaxError(
-              `Can't resolve all parameters for ${stringifyType(typeOrFunc)}: (${depsTokens}).`),
+          new Error(`Can't resolve all parameters for ${stringify(typeOrFunc)}: (${depsTokens}).`),
           typeOrFunc);
     }
 
@@ -787,9 +761,9 @@ export class CompileMetadataResolver {
               (<string[]>providers.reduce(
                    (soFar: string[], seenProvider: any, seenProviderIdx: number) => {
                      if (seenProviderIdx < providerIdx) {
-                       soFar.push(`${stringifyType(seenProvider)}`);
+                       soFar.push(`${stringify(seenProvider)}`);
                      } else if (seenProviderIdx == providerIdx) {
-                       soFar.push(`?${stringifyType(seenProvider)}?`);
+                       soFar.push(`?${stringify(seenProvider)}?`);
                      } else if (seenProviderIdx == providerIdx + 1) {
                        soFar.push('...');
                      }
@@ -798,7 +772,7 @@ export class CompileMetadataResolver {
                    []))
                   .join(', ');
           this._reportError(
-              new SyntaxError(
+              new Error(
                   `Invalid ${debugInfo ? debugInfo : 'provider'} - only instances of Provider and Type are allowed, got: [${providersInfo}]`),
               type);
         }
@@ -819,21 +793,19 @@ export class CompileMetadataResolver {
 
     if (provider.useFactory || provider.useExisting || provider.useClass) {
       this._reportError(
-          new SyntaxError(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports useValue!`), type);
+          new Error(`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'!`),
-          type);
+          new Error(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports 'multi = true'!`), type);
       return [];
     }
 
     extractIdentifiers(provider.useValue, collectedIdentifiers);
     collectedIdentifiers.forEach((identifier) => {
-      if (this._directiveResolver.isDirective(identifier.reference) ||
-          this._loadSummary(identifier.reference, cpl.CompileSummaryKind.Directive)) {
+      if (this._directiveResolver.isDirective(identifier.reference)) {
         components.push(identifier);
       }
     });
@@ -847,7 +819,7 @@ export class CompileMetadataResolver {
     let token: cpl.CompileTokenMetadata = this._getTokenMetadata(provider.token);
 
     if (provider.useClass) {
-      compileTypeMetadata = this._getInjectableMetadata(provider.useClass, provider.dependencies);
+      compileTypeMetadata = this._getTypeMetadata(provider.useClass, provider.dependencies);
       compileDeps = compileTypeMetadata.diDeps;
       if (provider.token === provider.useClass) {
         // use the compileTypeMetadata as it contains information about lifecycleHooks...
@@ -895,8 +867,8 @@ export class CompileMetadataResolver {
     } else {
       if (!q.selector) {
         this._reportError(
-            new SyntaxError(
-                `Can't construct a query for the property "${propertyName}" of "${stringifyType(typeOrFunc)}" since the query selector wasn't defined.`),
+            new Error(
+                `Can't construct a query for the property "${propertyName}" of "${stringify(typeOrFunc)}" since the query selector wasn't defined.`),
             typeOrFunc);
       }
       selectors = [this._getTokenMetadata(q.selector)];
@@ -963,8 +935,8 @@ export function componentModuleUrl(
     const scheme = getUrlScheme(moduleId);
     return scheme ? moduleId : `package:${moduleId}${MODULE_SUFFIX}`;
   } else if (moduleId !== null && moduleId !== void 0) {
-    throw new SyntaxError(
-        `moduleId should be a string in "${stringifyType(type)}". See https://goo.gl/wIDDiL for more information.\n` +
+    throw new Error(
+        `moduleId should be a string in "${stringify(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.`);
   }
 
@@ -980,11 +952,3 @@ class _CompileValueConverter extends ValueTransformer {
     targetIdentifiers.push({reference: value});
   }
 }
-
-function stringifyType(type: any): string {
-  if (type instanceof StaticSymbol) {
-    return `${type.name} in ${type.filePath}`;
-  } else {
-    return stringify(type);
-  }
-}

modules/@angular/compiler/src/ml_parser/html_parser.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {CompilerInjectable} from '../injectable';
+import {Injectable} from '@angular/core';
 
 import {getHtmlTagDefinition} from './html_tags';
 import {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from './interpolation_config';
@@ -14,7 +14,7 @@ import {ParseTreeResult, Parser} from './parser';
 
 export {ParseTreeResult, TreeError} from './parser';
 
-@CompilerInjectable()
+@Injectable()
 export class HtmlParser extends Parser {
   constructor() { super(getHtmlTagDefinition); }
 

modules/@angular/compiler/src/ml_parser/icu_ast_expander.ts

@@ -30,9 +30,9 @@ const PLURAL_CASES: string[] = ['zero', 'one', 'two', 'few', 'many', 'other'];
  *
  * ```
  * <ng-container [ngPlural]="messages.length">
- *   <template ngPluralCase="=0">zero</template>
- *   <template ngPluralCase="=1">one</template>
- *   <template ngPluralCase="other">more than one</template>
+ *   <template ngPluralCase="=0">zero</ng-container>
+ *   <template ngPluralCase="=1">one</ng-container>
+ *   <template ngPluralCase="other">more than one</ng-container>
  * </ng-container>
  * ```
  */

modules/@angular/compiler/src/ml_parser/lexer.ts

@@ -133,7 +133,7 @@ class _Tokenizer {
           } else {
             this._consumeTagOpen(start);
           }
-        } else if (!(this._tokenizeIcu && this._tokenizeExpansionForm())) {
+        } else if (!this._tokenizeIcu || !this._tokenizeExpansionForm()) {
           this._consumeText();
         }
       } catch (e) {
@@ -586,8 +586,8 @@ class _Tokenizer {
         parts.push(this._interpolationConfig.start);
         this._inInterpolation = true;
       } else if (
-          this._interpolationConfig && this._inInterpolation &&
-          this._attemptStr(this._interpolationConfig.end)) {
+          this._interpolationConfig && this._attemptStr(this._interpolationConfig.end) &&
+          this._inInterpolation) {
         parts.push(this._interpolationConfig.end);
         this._inInterpolation = false;
       } else {

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

@@ -6,11 +6,12 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {Injectable} from '@angular/core';
+
 import {CompileDiDependencyMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompileProviderMetadata, CompileTokenMetadata, identifierModuleUrl, identifierName, tokenName, tokenReference} from './compile_metadata';
 import {createDiTokenExpression} from './compiler_util/identifier_util';
 import {isPresent} from './facade/lang';
 import {Identifiers, createIdentifier, createIdentifierToken, resolveIdentifier} from './identifiers';
-import {CompilerInjectable} from './injectable';
 import {ClassBuilder, createClassStmt} from './output/class_builder';
 import * as o from './output/output_ast';
 import {convertValueToOutputAst} from './output/value_util';
@@ -30,7 +31,7 @@ export class NgModuleCompileResult {
       public dependencies: ComponentFactoryDependency[]) {}
 }
 
-@CompilerInjectable()
+@Injectable()
 export class NgModuleCompiler {
   compile(ngModuleMeta: CompileNgModuleMetadata, extraProviders: CompileProviderMetadata[]):
       NgModuleCompileResult {

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

@@ -6,11 +6,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {NgModule, Type} from '@angular/core';
+import {Injectable, NgModule, Type} from '@angular/core';
 
 import {ListWrapper} from './facade/collection';
 import {isPresent, stringify} from './facade/lang';
-import {CompilerInjectable} from './injectable';
 import {ReflectorReader, reflector} from './private_import_core';
 
 function _isNgModuleMetadata(obj: any): obj is NgModule {
@@ -20,7 +19,7 @@ function _isNgModuleMetadata(obj: any): obj is NgModule {
 /**
  * Resolves types to {@link NgModule}.
  */
-@CompilerInjectable()
+@Injectable()
 export class NgModuleResolver {
   constructor(private _reflector: ReflectorReader = reflector) {}
 

modules/@angular/compiler/src/output/path_util.ts

@@ -14,6 +14,5 @@ export abstract class ImportResolver {
    * Converts a file path to a module name that can be used as an `import.
    * I.e. `path/to/importedFile.ts` should be imported by `path/to/containingFile.ts`.
    */
-  abstract fileNameToModuleName(importedFilePath: string, containingFilePath: string): string
-      /*|null*/;
+  abstract fileNameToModuleName(importedFilePath: string, containingFilePath: string): string;
 }

modules/@angular/compiler/src/output/ts_emitter.ts

@@ -335,7 +335,7 @@ class _TsEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisitor
       }
       ctx.print(`${prefix}.`);
     }
-    if (value.reference && value.reference.members && value.reference.members.length) {
+    if (value.reference && value.reference.members) {
       ctx.print(value.reference.name);
       ctx.print('.');
       ctx.print(value.reference.members.join('.'));

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

@@ -6,11 +6,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Pipe, Type, resolveForwardRef} from '@angular/core';
+import {Injectable, Pipe, Type, resolveForwardRef} from '@angular/core';
 
 import {ListWrapper} from './facade/collection';
 import {isPresent, stringify} from './facade/lang';
-import {CompilerInjectable} from './injectable';
 import {ReflectorReader, reflector} from './private_import_core';
 
 function _isPipeMetadata(type: any): boolean {
@@ -24,7 +23,7 @@ function _isPipeMetadata(type: any): boolean {
  *
  * See {@link Compiler}
  */
-@CompilerInjectable()
+@Injectable()
 export class PipeResolver {
   constructor(private _reflector: ReflectorReader = reflector) {}
 

modules/@angular/compiler/src/schema/dom_element_schema_registry.ts

@@ -6,8 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {AUTO_STYLE, CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA, SchemaMetadata, SecurityContext} from '@angular/core';
-import {CompilerInjectable} from '../injectable';
+import {AUTO_STYLE, CUSTOM_ELEMENTS_SCHEMA, Injectable, NO_ERRORS_SCHEMA, SchemaMetadata, SecurityContext} from '@angular/core';
 
 import {dashCaseToCamelCase} from '../util';
 
@@ -239,7 +238,7 @@ const _ATTR_TO_PROP: {[name: string]: string} = {
   'tabindex': 'tabIndex',
 };
 
-@CompilerInjectable()
+@Injectable()
 export class DomElementSchemaRegistry extends ElementSchemaRegistry {
   private _schema: {[element: string]: {[property: string]: string}} = {};
 

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

@@ -6,10 +6,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {ViewEncapsulation} from '@angular/core';
+import {Injectable, ViewEncapsulation} from '@angular/core';
 
 import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileStylesheetMetadata, identifierModuleUrl, identifierName} from './compile_metadata';
-import {CompilerInjectable} from './injectable';
 import * as o from './output/output_ast';
 import {ShadowCss} from './shadow_css';
 import {UrlResolver} from './url_resolver';
@@ -37,7 +36,7 @@ export class CompiledStylesheet {
       public meta: CompileStylesheetMetadata) {}
 }
 
-@CompilerInjectable()
+@Injectable()
 export class StyleCompiler {
   private _shadowCss: ShadowCss = new ShadowCss();
 

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

@@ -5,17 +5,10 @@
  * 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 {Injectable} from '@angular/core';
 import {CompileTypeSummary} from './compile_metadata';
-import {CompilerInjectable} from './injectable';
 
-export interface Summary<T> {
-  symbol: T;
-  metadata: any;
-  type?: CompileTypeSummary;
-}
-
-@CompilerInjectable()
-export class SummaryResolver<T> {
-  resolveSummary(reference: T): Summary<T> { return null; };
-  getSymbolsOf(filePath: string): T[] { return []; }
+@Injectable()
+export class SummaryResolver {
+  resolveSummary(reference: any): CompileTypeSummary { return null; }
 }

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

@@ -6,13 +6,13 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Inject, OpaqueToken, Optional, SchemaMetadata} from '@angular/core';
+import {Inject, Injectable, OpaqueToken, Optional, SchemaMetadata} from '@angular/core';
+
 import {CompileDirectiveMetadata, CompileDirectiveSummary, CompilePipeSummary, CompileTemplateSummary, CompileTokenMetadata, CompileTypeMetadata, identifierName} from '../compile_metadata';
 import {Parser} from '../expression_parser/parser';
 import {isPresent} from '../facade/lang';
 import {I18NHtmlParser} from '../i18n/i18n_html_parser';
 import {Identifiers, createIdentifierToken, identifierToken} from '../identifiers';
-import {CompilerInjectable} from '../injectable';
 import * as html from '../ml_parser/ast';
 import {ParseTreeResult} from '../ml_parser/html_parser';
 import {expandNodes} from '../ml_parser/icu_ast_expander';
@@ -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 {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';
@@ -79,7 +79,7 @@ export class TemplateParseResult {
   constructor(public templateAst?: TemplateAst[], public errors?: ParseError[]) {}
 }
 
-@CompilerInjectable()
+@Injectable()
 export class TemplateParser {
   constructor(
       private _exprParser: Parser, private _schemaRegistry: ElementSchemaRegistry,
@@ -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 new Error(`Template parse errors:\n${errorString}`);
     }
 
     return result.templateAst;

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

@@ -6,11 +6,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Inject, PACKAGE_ROOT_URL} from '@angular/core';
+import {Inject, Injectable, PACKAGE_ROOT_URL} from '@angular/core';
 
 import {isBlank, isPresent} from './facade/lang';
-import {CompilerInjectable} from './injectable';
-
 
 /**
  * Create a {@link UrlResolver} with no package prefix.
@@ -47,7 +45,7 @@ export var DEFAULT_PACKAGE_URL_PROVIDER = {
  * Attacker-controlled data introduced by a template could expose your
  * application to XSS risks. For more detail, see the [Security Guide](http://g.co/ng/security).
  */
-@CompilerInjectable()
+@Injectable()
 export class UrlResolver {
   constructor(@Inject(PACKAGE_ROOT_URL) private _packagePrefix: string = null) {}
 

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

@@ -6,8 +6,8 @@
  * 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 = '';
 
 const CAMEL_CASE_REGEXP = /([A-Z])/g;
@@ -78,5 +78,3 @@ export class SyncAsyncResult<T> {
     }
   }
 }
-
-export class SyntaxError extends BaseError {}

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

@@ -6,10 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {Injectable} from '@angular/core';
+
 import {AnimationEntryCompileResult} from '../animation/animation_compiler';
 import {CompileDirectiveMetadata, CompilePipeSummary} from '../compile_metadata';
 import {CompilerConfig} from '../config';
-import {CompilerInjectable} from '../injectable';
 import * as o from '../output/output_ast';
 import {ElementSchemaRegistry} from '../schema/element_schema_registry';
 import {TemplateAst} from '../template_parser/template_ast';
@@ -29,7 +30,7 @@ export class ViewCompileResult {
           Array<ViewClassDependency|ComponentFactoryDependency|DirectiveWrapperDependency>) {}
 }
 
-@CompilerInjectable()
+@Injectable()
 export class ViewCompiler {
   constructor(private _genConfig: CompilerConfig, private _schemaRegistry: ElementSchemaRegistry) {}
 

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

@@ -6,25 +6,26 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {StaticReflector, StaticSymbol, StaticSymbolCache, StaticSymbolResolver, StaticSymbolResolverHost} from '@angular/compiler';
+import {StaticReflector, StaticReflectorHost, StaticSymbol} from '@angular/compiler';
 import {HostListener, Inject, animate, group, keyframes, sequence, state, style, transition, trigger} from '@angular/core';
+import {MetadataCollector} from '@angular/tsc-wrapped';
+import * as ts from 'typescript';
 
-import {MockStaticSymbolResolverHost, MockSummaryResolver} from './static_symbol_resolver_spec';
+
+
+// This matches .ts files but not .d.ts files.
+const TS_EXT = /(^.|(?!\.d)..)\.ts$/;
 
 describe('StaticReflector', () => {
-  let noContext: StaticSymbol;
-  let host: StaticSymbolResolverHost;
-  let symbolResolver: StaticSymbolResolver;
+  const noContext = new StaticSymbol('', '');
+  let host: StaticReflectorHost;
   let reflector: StaticReflector;
 
   function init(
       testData: {[key: string]: any} = DEFAULT_TEST_DATA,
       decorators: {name: string, filePath: string, ctor: any}[] = []) {
-    const symbolCache = new StaticSymbolCache();
-    host = new MockStaticSymbolResolverHost(testData);
-    symbolResolver = new StaticSymbolResolver(host, symbolCache, new MockSummaryResolver([]));
-    reflector = new StaticReflector(symbolResolver, decorators);
-    noContext = reflector.getStaticSymbol('', '');
+    host = new MockStaticReflectorHost(testData);
+    reflector = new StaticReflector(host, undefined, decorators);
   }
 
   beforeEach(() => init());
@@ -76,22 +77,24 @@ describe('StaticReflector', () => {
     ])]);
   });
 
+  it('should throw an exception for unsupported metadata versions', () => {
+    expect(() => reflector.findDeclaration('src/version-error', 'e'))
+        .toThrow(new Error(
+            'Metadata version mismatch for module /tmp/src/version-error.d.ts, found version 100, expected 3'));
+  });
+
+  it('should throw an exception for version 2 metadata', () => {
+    expect(() => reflector.findDeclaration('src/version-2-error', 'e'))
+        .toThrowError(
+            'Unsupported metadata version 2 for module /tmp/src/version-2-error.d.ts. This module should be compiled with a newer version of ngc');
+  });
+
   it('should get and empty annotation list for an unknown class', () => {
     const UnknownClass = reflector.findDeclaration('src/app/app.component', 'UnknownClass');
     const annotations = reflector.annotations(UnknownClass);
     expect(annotations).toEqual([]);
   });
 
-  it('should get and empty annotation list for a symbol with null value', () => {
-    init({
-      '/tmp/test.ts': `
-        export var x = null;
-      `
-    });
-    const annotations = reflector.annotations(reflector.getStaticSymbol('/tmp/test.ts', 'x'));
-    expect(annotations).toEqual([]);
-  });
-
   it('should get propMetadata for HeroDetailComponent', () => {
     const HeroDetailComponent =
         reflector.findDeclaration('src/app/hero-detail.component', 'HeroDetailComponent');
@@ -126,7 +129,7 @@ describe('StaticReflector', () => {
   });
 
   it('should simplify a static symbol into itself', () => {
-    const staticSymbol = reflector.getStaticSymbol('', '');
+    const staticSymbol = new StaticSymbol('', '');
     expect(simplify(noContext, staticSymbol)).toBe(staticSymbol);
   });
 
@@ -303,43 +306,49 @@ describe('StaticReflector', () => {
     expect(simplify(noContext, expr)).toBe(2);
   });
 
-  it('should simplify a file reference', () => {
+  it('should simplify a module reference', () => {
     expect(simplify(
-               reflector.getStaticSymbol('/src/cases', ''),
-               reflector.getStaticSymbol('/src/extern.d.ts', 's')))
+               new StaticSymbol('/src/cases', ''),
+               ({__symbolic: 'reference', module: './extern', name: 's'})))
         .toEqual('s');
   });
 
+  it('should not simplify a module reference without a name', () => {
+    const staticSymbol = new StaticSymbol('/src/cases', '');
+    expect(simplify(staticSymbol, ({__symbolic: 'reference', module: './extern', name: ''})))
+        .toEqual(staticSymbol);
+  });
+
   it('should simplify a non existing reference as a static symbol', () => {
     expect(simplify(
-               reflector.getStaticSymbol('/src/cases', ''),
-               reflector.getStaticSymbol('/src/extern.d.ts', 'nonExisting')))
+               new StaticSymbol('/src/cases', ''),
+               ({__symbolic: 'reference', module: './extern', name: 'nonExisting'})))
         .toEqual(reflector.getStaticSymbol('/src/extern.d.ts', 'nonExisting'));
   });
 
   it('should simplify a function reference as a static symbol', () => {
     expect(simplify(
-               reflector.getStaticSymbol('/src/cases', 'myFunction'),
+               new StaticSymbol('/src/cases', 'myFunction'),
                ({__symbolic: 'function', parameters: ['a'], value: []})))
         .toEqual(reflector.getStaticSymbol('/src/cases', 'myFunction'));
   });
 
   it('should simplify values initialized with a function call', () => {
-    expect(simplify(
-               reflector.getStaticSymbol('/tmp/src/function-reference.ts', ''),
-               reflector.getStaticSymbol('/tmp/src/function-reference.ts', 'one')))
-        .toEqual(['some-value']);
-    expect(simplify(
-               reflector.getStaticSymbol('/tmp/src/function-reference.ts', ''),
-               reflector.getStaticSymbol('/tmp/src/function-reference.ts', 'three')))
-        .toEqual(3);
+    expect(simplify(new StaticSymbol('/tmp/src/function-reference.ts', ''), {
+      __symbolic: 'reference',
+      name: 'one'
+    })).toEqual(['some-value']);
+    expect(simplify(new StaticSymbol('/tmp/src/function-reference.ts', ''), {
+      __symbolic: 'reference',
+      name: 'three'
+    })).toEqual(3);
   });
 
   it('should error on direct recursive calls', () => {
     expect(
         () => simplify(
-            reflector.getStaticSymbol('/tmp/src/function-reference.ts', ''),
-            reflector.getStaticSymbol('/tmp/src/function-reference.ts', 'recursion')))
+            new StaticSymbol('/tmp/src/function-reference.ts', ''),
+            {__symbolic: 'reference', name: 'recursion'}))
         .toThrow(new Error(
             'Recursion not supported, resolving symbol recursive in /tmp/src/function-recursive.d.ts, resolving symbol recursion in /tmp/src/function-reference.ts, resolving symbol  in /tmp/src/function-reference.ts'));
   });
@@ -353,8 +362,7 @@ describe('StaticReflector', () => {
       expect(moduleMetadata).toBeDefined();
       const classData: any = moduleMetadata['InvalidMetadata'];
       expect(classData).toBeDefined();
-      simplify(
-          reflector.getStaticSymbol('/tmp/src/invalid-metadata.ts', ''), classData.decorators[0]);
+      simplify(new StaticSymbol('/tmp/src/invalid-metadata.ts', ''), classData.decorators[0]);
     } catch (e) {
       expect(e.fileName).toBe('/tmp/src/invalid-metadata.ts');
       threw = true;
@@ -365,17 +373,48 @@ describe('StaticReflector', () => {
   it('should error on indirect recursive calls', () => {
     expect(
         () => simplify(
-            reflector.getStaticSymbol('/tmp/src/function-reference.ts', ''),
-            reflector.getStaticSymbol('/tmp/src/function-reference.ts', 'indirectRecursion')))
+            new StaticSymbol('/tmp/src/function-reference.ts', ''),
+            {__symbolic: 'reference', name: 'indirectRecursion'}))
         .toThrow(new Error(
             'Recursion not supported, resolving symbol indirectRecursion2 in /tmp/src/function-recursive.d.ts, resolving symbol indirectRecursion1 in /tmp/src/function-recursive.d.ts, resolving symbol indirectRecursion in /tmp/src/function-reference.ts, resolving symbol  in /tmp/src/function-reference.ts'));
   });
 
   it('should simplify a spread expression', () => {
-    expect(simplify(
-               reflector.getStaticSymbol('/tmp/src/spread.ts', ''),
-               reflector.getStaticSymbol('/tmp/src/spread.ts', 'spread')))
-        .toEqual([0, 1, 2, 3, 4, 5]);
+    expect(simplify(new StaticSymbol('/tmp/src/spread.ts', ''), {
+      __symbolic: 'reference',
+      name: 'spread'
+    })).toEqual([0, 1, 2, 3, 4, 5]);
+  });
+
+  it('should be able to get metadata from a ts file', () => {
+    const metadata = reflector.getModuleMetadata('/tmp/src/custom-decorator-reference.ts');
+    expect(metadata).toEqual({
+      __symbolic: 'module',
+      version: 3,
+      metadata: {
+        Foo: {
+          __symbolic: 'class',
+          decorators: [{
+            __symbolic: 'call',
+            expression:
+                {__symbolic: 'reference', module: './custom-decorator', name: 'CustomDecorator'}
+          }],
+          members: {
+            foo: [{
+              __symbolic: 'property',
+              decorators: [{
+                __symbolic: 'call',
+                expression: {
+                  __symbolic: 'reference',
+                  module: './custom-decorator',
+                  name: 'CustomDecorator'
+                }
+              }]
+            }]
+          }
+        }
+      }
+    });
   });
 
   it('should be able to get metadata for a class containing a custom decorator', () => {
@@ -449,6 +488,62 @@ describe('StaticReflector', () => {
     expect(annotations[0].providers[0].useValue.members[0]).toEqual('staticMethod');
   });
 
+  it('should be able to produce a symbol for an exported symbol', () => {
+    expect(reflector.findDeclaration('@angular/router', 'foo', 'main.ts')).toBeDefined();
+  });
+
+  it('should be able to produce a symbol for values space only reference', () => {
+    expect(reflector.findDeclaration('@angular/router/src/providers', 'foo', 'main.ts'))
+        .toBeDefined();
+  });
+
+  it('should be produce the same symbol if asked twice', () => {
+    const foo1 = reflector.getStaticSymbol('main.ts', 'foo');
+    const foo2 = reflector.getStaticSymbol('main.ts', 'foo');
+    expect(foo1).toBe(foo2);
+  });
+
+  it('should be able to produce a symbol for a module with no file',
+     () => { expect(reflector.getStaticSymbol('angularjs', 'SomeAngularSymbol')).toBeDefined(); });
+
+  it('should be able to trace a named export', () => {
+    const symbol = reflector.findDeclaration('./reexport/reexport', 'One', '/tmp/src/main.ts');
+    expect(symbol.name).toEqual('One');
+    expect(symbol.filePath).toEqual('/tmp/src/reexport/src/origin1.d.ts');
+  });
+
+  it('should be able to trace a renamed export', () => {
+    const symbol = reflector.findDeclaration('./reexport/reexport', 'Four', '/tmp/src/main.ts');
+    expect(symbol.name).toEqual('Three');
+    expect(symbol.filePath).toEqual('/tmp/src/reexport/src/origin1.d.ts');
+  });
+
+  it('should be able to trace an export * export', () => {
+    const symbol = reflector.findDeclaration('./reexport/reexport', 'Five', '/tmp/src/main.ts');
+    expect(symbol.name).toEqual('Five');
+    expect(symbol.filePath).toEqual('/tmp/src/reexport/src/origin5.d.ts');
+  });
+
+  it('should be able to trace a multi-level re-export', () => {
+    const symbol = reflector.findDeclaration('./reexport/reexport', 'Thirty', '/tmp/src/main.ts');
+    expect(symbol.name).toEqual('Thirty');
+    expect(symbol.filePath).toEqual('/tmp/src/reexport/src/origin30.d.ts');
+  });
+
+  it('should cache tracing a named export', () => {
+    const moduleNameToFileNameSpy = spyOn(host, 'moduleNameToFileName').and.callThrough();
+    const getMetadataForSpy = spyOn(host, 'getMetadataFor').and.callThrough();
+    reflector.findDeclaration('./reexport/reexport', 'One', '/tmp/src/main.ts');
+    moduleNameToFileNameSpy.calls.reset();
+    getMetadataForSpy.calls.reset();
+
+    const symbol = reflector.findDeclaration('./reexport/reexport', 'One', '/tmp/src/main.ts');
+    expect(moduleNameToFileNameSpy.calls.count()).toBe(1);
+    expect(getMetadataForSpy.calls.count()).toBe(0);
+    expect(symbol.name).toEqual('One');
+    expect(symbol.filePath).toEqual('/tmp/src/reexport/src/origin1.d.ts');
+  });
+
   describe('inheritance', () => {
     class ClassDecorator {
       constructor(public value: any) {}
@@ -611,6 +706,78 @@ describe('StaticReflector', () => {
 
 });
 
+export class MockStaticReflectorHost implements StaticReflectorHost {
+  private collector = new MetadataCollector();
+
+  constructor(private data: {[key: string]: any}) {}
+
+  // In tests, assume that symbols are not re-exported
+  moduleNameToFileName(modulePath: string, containingFile?: string): string {
+    function splitPath(path: string): string[] { return path.split(/\/|\\/g); }
+
+    function resolvePath(pathParts: string[]): string {
+      const result: string[] = [];
+      pathParts.forEach((part, index) => {
+        switch (part) {
+          case '':
+          case '.':
+            if (index > 0) return;
+            break;
+          case '..':
+            if (index > 0 && result.length != 0) result.pop();
+            return;
+        }
+        result.push(part);
+      });
+      return result.join('/');
+    }
+
+    function pathTo(from: string, to: string): string {
+      let result = to;
+      if (to.startsWith('.')) {
+        const fromParts = splitPath(from);
+        fromParts.pop();  // remove the file name.
+        const toParts = splitPath(to);
+        result = resolvePath(fromParts.concat(toParts));
+      }
+      return result;
+    }
+
+    if (modulePath.indexOf('.') === 0) {
+      const baseName = pathTo(containingFile, modulePath);
+      const tsName = baseName + '.ts';
+      if (this._getMetadataFor(tsName)) {
+        return tsName;
+      }
+      return baseName + '.d.ts';
+    }
+    return '/tmp/' + modulePath + '.d.ts';
+  }
+
+  getMetadataFor(moduleId: string): any { return this._getMetadataFor(moduleId); }
+
+  private _getMetadataFor(moduleId: string): any {
+    if (this.data[moduleId] && moduleId.match(TS_EXT)) {
+      const text = this.data[moduleId];
+      if (typeof text === 'string') {
+        const sf = ts.createSourceFile(
+            moduleId, this.data[moduleId], ts.ScriptTarget.ES5, /* setParentNodes */ true);
+        const diagnostics: ts.Diagnostic[] = (<any>sf).parseDiagnostics;
+        if (diagnostics && diagnostics.length) {
+          throw Error(`Error encountered during parse of file ${moduleId}`);
+        }
+        return [this.collector.getMetadata(sf)];
+      }
+    }
+    const result = this.data[moduleId];
+    if (result) {
+      return Array.isArray(result) ? result : [result];
+    } else {
+      return null;
+    }
+  }
+}
+
 const DEFAULT_TEST_DATA: {[key: string]: any} = {
       '/tmp/@angular/common/src/forms-deprecated/directives.d.ts': [{
         '__symbolic': 'module',
@@ -841,6 +1008,8 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
         }
       },
       '/src/extern.d.ts': {'__symbolic': 'module', 'version': 3, metadata: {s: 's'}},
+      '/tmp/src/version-error.d.ts': {'__symbolic': 'module', 'version': 100, metadata: {e: 's'}},
+      '/tmp/src/version-2-error.d.ts': {'__symbolic': 'module', 'version': 2, metadata: {e: 's'}},
       '/tmp/src/error-reporting.d.ts': {
         __symbolic: 'module',
         version: 3,
@@ -1174,4 +1343,47 @@ const DEFAULT_TEST_DATA: {[key: string]: any} = {
           @Input f: Forward;
         }
       `,
+      '/tmp/src/reexport/reexport.d.ts': {
+        __symbolic: 'module',
+        version: 3,
+        metadata: {},
+        exports: [
+          {from: './src/origin1', export: ['One', 'Two', {name: 'Three', as: 'Four'}]},
+          {from: './src/origin5'}, {from: './src/reexport2'}
+        ]
+      },
+      '/tmp/src/reexport/src/origin1.d.ts': {
+        __symbolic: 'module',
+        version: 3,
+        metadata: {
+          One: {__symbolic: 'class'},
+          Two: {__symbolic: 'class'},
+          Three: {__symbolic: 'class'},
+        },
+      },
+      '/tmp/src/reexport/src/origin5.d.ts': {
+        __symbolic: 'module',
+        version: 3,
+        metadata: {
+          Five: {__symbolic: 'class'},
+        },
+      },
+      '/tmp/src/reexport/src/origin30.d.ts': {
+        __symbolic: 'module',
+        version: 3,
+        metadata: {
+          Thirty: {__symbolic: 'class'},
+        },
+      },
+      '/tmp/src/reexport/src/originNone.d.ts': {
+        __symbolic: 'module',
+        version: 3,
+        metadata: {},
+      },
+      '/tmp/src/reexport/src/reexport2.d.ts': {
+        __symbolic: 'module',
+        version: 3,
+        metadata: {},
+        exports: [{from: './originNone'}, {from: './origin30'}]
+      }
     };

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

@@ -1,372 +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
- */
-
-import {StaticSymbol, StaticSymbolCache, StaticSymbolResolver, StaticSymbolResolverHost, Summary, SummaryResolver} from '@angular/compiler';
-import {MetadataCollector} from '@angular/tsc-wrapped';
-import * as ts from 'typescript';
-
-
-
-// This matches .ts files but not .d.ts files.
-const TS_EXT = /(^.|(?!\.d)..)\.ts$/;
-
-describe('StaticSymbolResolver', () => {
-  const noContext = new StaticSymbol('', '');
-  let host: StaticSymbolResolverHost;
-  let symbolResolver: StaticSymbolResolver;
-  let symbolCache: StaticSymbolCache;
-
-  beforeEach(() => { symbolCache = new StaticSymbolCache(); });
-
-  function init(
-      testData: {[key: string]: any} = DEFAULT_TEST_DATA, summaries: Summary<StaticSymbol>[] = []) {
-    host = new MockStaticSymbolResolverHost(testData);
-    symbolResolver =
-        new StaticSymbolResolver(host, symbolCache, new MockSummaryResolver(summaries));
-  }
-
-  beforeEach(() => init());
-
-  it('should throw an exception for unsupported metadata versions', () => {
-    expect(
-        () => symbolResolver.resolveSymbol(
-            symbolResolver.getSymbolByModule('src/version-error', 'e')))
-        .toThrow(new Error(
-            'Metadata version mismatch for module /tmp/src/version-error.d.ts, found version 100, expected 3'));
-  });
-
-  it('should throw an exception for version 2 metadata', () => {
-    expect(
-        () => symbolResolver.resolveSymbol(
-            symbolResolver.getSymbolByModule('src/version-2-error', 'e')))
-        .toThrowError(
-            'Unsupported metadata version 2 for module /tmp/src/version-2-error.d.ts. This module should be compiled with a newer version of ngc');
-  });
-
-  it('should be produce the same symbol if asked twice', () => {
-    const foo1 = symbolResolver.getStaticSymbol('main.ts', 'foo');
-    const foo2 = symbolResolver.getStaticSymbol('main.ts', 'foo');
-    expect(foo1).toBe(foo2);
-  });
-
-  it('should be able to produce a symbol for a module with no file', () => {
-    expect(symbolResolver.getStaticSymbol('angularjs', 'SomeAngularSymbol')).toBeDefined();
-  });
-
-  it('should be able to split the metadata per symbol', () => {
-    init({
-      '/tmp/src/test.ts': `
-        export var a = 1;
-        export var b = 2;
-      `
-    });
-    expect(symbolResolver.resolveSymbol(symbolResolver.getStaticSymbol('/tmp/src/test.ts', 'a'))
-               .metadata)
-        .toBe(1);
-    expect(symbolResolver.resolveSymbol(symbolResolver.getStaticSymbol('/tmp/src/test.ts', 'b'))
-               .metadata)
-        .toBe(2);
-  });
-
-  it('should be able to resolve static symbols with members', () => {
-    init({
-      '/tmp/src/test.ts': `
-        export {exportedObj} from './export';
-
-        export var obj = {a: 1};
-        export class SomeClass {
-          static someField = 2;
-        }
-      `,
-      '/tmp/src/export.ts': `
-        export var exportedObj = {};
-      `,
-    });
-    expect(symbolResolver
-               .resolveSymbol(symbolResolver.getStaticSymbol('/tmp/src/test.ts', 'obj', ['a']))
-               .metadata)
-        .toBe(1);
-    expect(symbolResolver
-               .resolveSymbol(
-                   symbolResolver.getStaticSymbol('/tmp/src/test.ts', 'SomeClass', ['someField']))
-               .metadata)
-        .toBe(2);
-    expect(symbolResolver
-               .resolveSymbol(symbolResolver.getStaticSymbol(
-                   '/tmp/src/test.ts', 'exportedObj', ['someMember']))
-               .metadata)
-        .toBe(symbolResolver.getStaticSymbol('/tmp/src/export.ts', 'exportedObj', ['someMember']));
-  });
-
-  it('should use summaries in resolveSymbol and prefer them over regular metadata', () => {
-    const someSymbol = symbolCache.get('/test.ts', 'a');
-    init({'/test.ts': 'export var a = 2'}, [{symbol: someSymbol, metadata: 1}]);
-    expect(symbolResolver.resolveSymbol(someSymbol).metadata).toBe(1);
-  });
-
-  it('should be able to get all exported symbols of a file', () => {
-    expect(symbolResolver.getSymbolsOf('/tmp/src/reexport/src/origin1.d.ts')).toEqual([
-      symbolResolver.getStaticSymbol('/tmp/src/reexport/src/origin1.d.ts', 'One'),
-      symbolResolver.getStaticSymbol('/tmp/src/reexport/src/origin1.d.ts', 'Two'),
-      symbolResolver.getStaticSymbol('/tmp/src/reexport/src/origin1.d.ts', 'Three'),
-    ]);
-  });
-
-  it('should be able to get all reexported symbols of a file', () => {
-    expect(symbolResolver.getSymbolsOf('/tmp/src/reexport/reexport.d.ts')).toEqual([
-      symbolResolver.getStaticSymbol('/tmp/src/reexport/reexport.d.ts', 'One'),
-      symbolResolver.getStaticSymbol('/tmp/src/reexport/reexport.d.ts', 'Two'),
-      symbolResolver.getStaticSymbol('/tmp/src/reexport/reexport.d.ts', 'Four'),
-      symbolResolver.getStaticSymbol('/tmp/src/reexport/reexport.d.ts', 'Five'),
-      symbolResolver.getStaticSymbol('/tmp/src/reexport/reexport.d.ts', 'Thirty')
-    ]);
-  });
-
-  it('should merge the exported symbols of a file with the exported symbols of its summary', () => {
-    const someSymbol = symbolCache.get('/test.ts', 'a');
-    init(
-        {'/test.ts': 'export var b = 2'},
-        [{symbol: symbolCache.get('/test.ts', 'a'), metadata: 1}]);
-    expect(symbolResolver.getSymbolsOf('/test.ts')).toEqual([
-      symbolCache.get('/test.ts', 'a'), symbolCache.get('/test.ts', 'b')
-    ]);
-  });
-
-  it('should replace references by StaticSymbols', () => {
-    init({
-      '/test.ts': `
-        import {b, y} from './test2';
-        export var a = b;
-        export var x = [y];
-
-        export function simpleFn(fnArg) {
-          return [a, y, fnArg];
-        }
-      `,
-      '/test2.ts': `
-        export var b;
-        export var y;
-      `
-    });
-    expect(symbolResolver.resolveSymbol(symbolCache.get('/test.ts', 'a')).metadata)
-        .toEqual(symbolCache.get('/test2.ts', 'b'));
-    expect(symbolResolver.resolveSymbol(symbolCache.get('/test.ts', 'x')).metadata).toEqual([
-      symbolCache.get('/test2.ts', 'y')
-    ]);
-    expect(symbolResolver.resolveSymbol(symbolCache.get('/test.ts', 'simpleFn')).metadata).toEqual({
-      __symbolic: 'function',
-      parameters: ['fnArg'],
-      value: [
-        symbolCache.get('/test.ts', 'a'), symbolCache.get('/test2.ts', 'y'),
-        Object({__symbolic: 'reference', name: 'fnArg'})
-      ]
-    });
-  });
-
-  it('should ignore module references without a name', () => {
-    init({
-      '/test.ts': `
-        import Default from './test2';
-        export {Default};
-      `
-    });
-
-    expect(symbolResolver.resolveSymbol(symbolCache.get('/test.ts', 'Default')).metadata)
-        .toBeFalsy();
-  });
-
-  it('should be able to trace a named export', () => {
-    const symbol = symbolResolver
-                       .resolveSymbol(symbolResolver.getSymbolByModule(
-                           './reexport/reexport', 'One', '/tmp/src/main.ts'))
-                       .metadata;
-    expect(symbol.name).toEqual('One');
-    expect(symbol.filePath).toEqual('/tmp/src/reexport/src/origin1.d.ts');
-  });
-
-  it('should be able to trace a renamed export', () => {
-    const symbol = symbolResolver
-                       .resolveSymbol(symbolResolver.getSymbolByModule(
-                           './reexport/reexport', 'Four', '/tmp/src/main.ts'))
-                       .metadata;
-    expect(symbol.name).toEqual('Three');
-    expect(symbol.filePath).toEqual('/tmp/src/reexport/src/origin1.d.ts');
-  });
-
-  it('should be able to trace an export * export', () => {
-    const symbol = symbolResolver
-                       .resolveSymbol(symbolResolver.getSymbolByModule(
-                           './reexport/reexport', 'Five', '/tmp/src/main.ts'))
-                       .metadata;
-    expect(symbol.name).toEqual('Five');
-    expect(symbol.filePath).toEqual('/tmp/src/reexport/src/origin5.d.ts');
-  });
-
-  it('should be able to trace a multi-level re-export', () => {
-    const symbol1 = symbolResolver
-                        .resolveSymbol(symbolResolver.getSymbolByModule(
-                            './reexport/reexport', 'Thirty', '/tmp/src/main.ts'))
-                        .metadata;
-    expect(symbol1.name).toEqual('Thirty');
-    expect(symbol1.filePath).toEqual('/tmp/src/reexport/src/reexport2.d.ts');
-    const symbol2 = symbolResolver.resolveSymbol(symbol1).metadata;
-    expect(symbol2.name).toEqual('Thirty');
-    expect(symbol2.filePath).toEqual('/tmp/src/reexport/src/origin30.d.ts');
-  });
-
-  it('should cache tracing a named export', () => {
-    const moduleNameToFileNameSpy = spyOn(host, 'moduleNameToFileName').and.callThrough();
-    const getMetadataForSpy = spyOn(host, 'getMetadataFor').and.callThrough();
-    symbolResolver.resolveSymbol(
-        symbolResolver.getSymbolByModule('./reexport/reexport', 'One', '/tmp/src/main.ts'));
-    moduleNameToFileNameSpy.calls.reset();
-    getMetadataForSpy.calls.reset();
-
-    const symbol = symbolResolver
-                       .resolveSymbol(symbolResolver.getSymbolByModule(
-                           './reexport/reexport', 'One', '/tmp/src/main.ts'))
-                       .metadata;
-    expect(moduleNameToFileNameSpy.calls.count()).toBe(1);
-    expect(getMetadataForSpy.calls.count()).toBe(0);
-    expect(symbol.name).toEqual('One');
-    expect(symbol.filePath).toEqual('/tmp/src/reexport/src/origin1.d.ts');
-  });
-
-});
-
-export class MockSummaryResolver implements SummaryResolver<StaticSymbol> {
-  constructor(private summaries: Summary<StaticSymbol>[] = []) {}
-
-  resolveSummary(reference: StaticSymbol): Summary<StaticSymbol> {
-    return this.summaries.find(summary => summary.symbol === reference);
-  };
-  getSymbolsOf(filePath: string): StaticSymbol[] {
-    return this.summaries.filter(summary => summary.symbol.filePath === filePath)
-        .map(summary => summary.symbol);
-  }
-}
-
-export class MockStaticSymbolResolverHost implements StaticSymbolResolverHost {
-  private collector = new MetadataCollector();
-
-  constructor(private data: {[key: string]: any}) {}
-
-  // In tests, assume that symbols are not re-exported
-  moduleNameToFileName(modulePath: string, containingFile?: string): string {
-    function splitPath(path: string): string[] { return path.split(/\/|\\/g); }
-
-    function resolvePath(pathParts: string[]): string {
-      const result: string[] = [];
-      pathParts.forEach((part, index) => {
-        switch (part) {
-          case '':
-          case '.':
-            if (index > 0) return;
-            break;
-          case '..':
-            if (index > 0 && result.length != 0) result.pop();
-            return;
-        }
-        result.push(part);
-      });
-      return result.join('/');
-    }
-
-    function pathTo(from: string, to: string): string {
-      let result = to;
-      if (to.startsWith('.')) {
-        const fromParts = splitPath(from);
-        fromParts.pop();  // remove the file name.
-        const toParts = splitPath(to);
-        result = resolvePath(fromParts.concat(toParts));
-      }
-      return result;
-    }
-
-    if (modulePath.indexOf('.') === 0) {
-      const baseName = pathTo(containingFile, modulePath);
-      const tsName = baseName + '.ts';
-      if (this._getMetadataFor(tsName)) {
-        return tsName;
-      }
-      return baseName + '.d.ts';
-    }
-    return '/tmp/' + modulePath + '.d.ts';
-  }
-
-  getMetadataFor(moduleId: string): any { return this._getMetadataFor(moduleId); }
-
-  private _getMetadataFor(filePath: string): any {
-    if (this.data[filePath] && filePath.match(TS_EXT)) {
-      const text = this.data[filePath];
-      if (typeof text === 'string') {
-        const sf = ts.createSourceFile(
-            filePath, this.data[filePath], ts.ScriptTarget.ES5, /* setParentNodes */ true);
-        const diagnostics: ts.Diagnostic[] = (<any>sf).parseDiagnostics;
-        if (diagnostics && diagnostics.length) {
-          throw Error(`Error encountered during parse of file ${filePath}`);
-        }
-        return [this.collector.getMetadata(sf)];
-      }
-    }
-    const result = this.data[filePath];
-    if (result) {
-      return Array.isArray(result) ? result : [result];
-    } else {
-      return null;
-    }
-  }
-}
-
-const DEFAULT_TEST_DATA: {[key: string]: any} = {
-  '/tmp/src/version-error.d.ts': {'__symbolic': 'module', 'version': 100, metadata: {e: 's'}},
-  '/tmp/src/version-2-error.d.ts': {'__symbolic': 'module', 'version': 2, metadata: {e: 's'}},
-  '/tmp/src/reexport/reexport.d.ts': {
-    __symbolic: 'module',
-    version: 3,
-    metadata: {},
-    exports: [
-      {from: './src/origin1', export: ['One', 'Two', {name: 'Three', as: 'Four'}]},
-      {from: './src/origin5'}, {from: './src/reexport2'}
-    ]
-  },
-  '/tmp/src/reexport/src/origin1.d.ts': {
-    __symbolic: 'module',
-    version: 3,
-    metadata: {
-      One: {__symbolic: 'class'},
-      Two: {__symbolic: 'class'},
-      Three: {__symbolic: 'class'},
-    },
-  },
-  '/tmp/src/reexport/src/origin5.d.ts': {
-    __symbolic: 'module',
-    version: 3,
-    metadata: {
-      Five: {__symbolic: 'class'},
-    },
-  },
-  '/tmp/src/reexport/src/origin30.d.ts': {
-    __symbolic: 'module',
-    version: 3,
-    metadata: {
-      Thirty: {__symbolic: 'class'},
-    },
-  },
-  '/tmp/src/reexport/src/originNone.d.ts': {
-    __symbolic: 'module',
-    version: 3,
-    metadata: {},
-  },
-  '/tmp/src/reexport/src/reexport2.d.ts': {
-    __symbolic: 'module',
-    version: 3,
-    metadata: {},
-    exports: [{from: './originNone'}, {from: './origin30'}]
-  }
-};

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

@@ -6,67 +6,128 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {AotSummaryResolver, AotSummaryResolverHost, CompileSummaryKind, CompileTypeSummary, ResolvedStaticSymbol, StaticSymbol, StaticSymbolCache, StaticSymbolResolver} from '@angular/compiler';
-import {AotSummarySerializerHost, deserializeSummaries, serializeSummaries} from '@angular/compiler/src/aot/summary_serializer';
+import {AotSummaryResolver, AotSummaryResolverHost, CompileNgModuleSummary, CompileSummaryKind, CompileTypeSummary, StaticReflector, StaticReflectorHost, StaticSymbol} from '@angular/compiler';
 import * as path from 'path';
 
-import {MockStaticSymbolResolverHost, MockSummaryResolver} from './static_symbol_resolver_spec';
+import {MockStaticReflectorHost} from './static_reflector_spec';
 
 const EXT = /\.ts$|.d.ts$/;
 
 export function main() {
   describe('AotSummaryResolver', () => {
-    let summaryResolver: AotSummaryResolver;
-    let symbolCache: StaticSymbolCache;
-    let host: MockAotSummaryResolverHost;
-
-    beforeEach(() => { symbolCache = new StaticSymbolCache(); });
+    let resolver: AotSummaryResolver;
+    let staticReflector: StaticReflector;
 
     function init(summaries: {[filePath: string]: string} = {}) {
-      host = new MockAotSummaryResolverHost(summaries);
-      summaryResolver = new AotSummaryResolver(host, symbolCache);
+      // Note: We don't give the static reflector metadata files,
+      // so that we can test that we can deserialize summary files
+      // without reading metadata files. This is important
+      // as summary files can contain references to files of transitive compilation
+      // dependencies, and we don't want to read their metadata files.
+      staticReflector = new StaticReflector(new MockStaticReflectorHost({}));
+      const host = new MockAotSummaryResolverHost(summaries);
+      resolver = new AotSummaryResolver(host, staticReflector, {excludeFilePattern: /\.d\.ts$/});
     }
 
-    function serialize(symbols: ResolvedStaticSymbol[], types: CompileTypeSummary[]): string {
-      // Note: Don't use the top level host / summaryResolver as they might not be created yet
-      const mockSummaryResolver = new MockSummaryResolver([]);
-      const symbolResolver = new StaticSymbolResolver(
-          new MockStaticSymbolResolverHost({}), symbolCache, mockSummaryResolver);
-      return serializeSummaries(
-          new MockAotSummarySerializerHost(), mockSummaryResolver, symbolResolver, symbols, types);
-    }
-
-    it('should load serialized summary files', () => {
-      const asymbol = symbolCache.get('/a.d.ts', 'a');
-      init({'/a.ngsummary.json': serialize([{symbol: asymbol, metadata: 1}], [])});
-      expect(summaryResolver.resolveSummary(asymbol)).toEqual({symbol: asymbol, metadata: 1});
+    it('should add .ngsummary.json to the filename', () => {
+      init();
+      expect(resolver.serializeSummaries('a.ts', []).genFileUrl).toBe('a.ngsummary.json');
+      expect(resolver.serializeSummaries('a.d.ts', []).genFileUrl).toBe('a.ngsummary.json');
+      expect(resolver.serializeSummaries('a.js', []).genFileUrl).toBe('a.ngsummary.json');
     });
 
-    it('should not load summaries for source files', () => {
-      init({});
-      spyOn(host, 'loadSummary').and.callThrough();
+    it('should serialize various data correctly', () => {
+      init();
+      const serializedData = resolver.serializeSummaries(
+          '/tmp/some_pipe.ts', [<any>{
+            summaryKind: CompileSummaryKind.Pipe,
+            type: {
+              reference: staticReflector.getStaticSymbol('/tmp/some_pipe.ts', 'SomePipe'),
+            },
+            aNumber: 1,
+            aString: 'hello',
+            anArray: [1, 2],
+            aStaticSymbol:
+                staticReflector.getStaticSymbol('/tmp/some_symbol.ts', 'someName', ['someMember'])
+          }]);
 
-      expect(summaryResolver.resolveSummary(symbolCache.get('/a.ts', 'a'))).toBeFalsy();
-      expect(host.loadSummary).not.toHaveBeenCalled();
+      // Note: this creates a new staticReflector!
+      init({[serializedData.genFileUrl]: serializedData.source});
+
+      const deserialized = resolver.resolveSummary(
+          staticReflector.getStaticSymbol('/tmp/some_pipe.d.ts', 'SomePipe'));
+      expect(deserialized.aNumber).toBe(1);
+      expect(deserialized.aString).toBe('hello');
+      expect(deserialized.anArray).toEqual([1, 2]);
+      expect(deserialized.aStaticSymbol instanceof StaticSymbol).toBe(true);
+      // Note: change from .ts to .d.ts is expected
+      expect(deserialized.aStaticSymbol)
+          .toEqual(
+              staticReflector.getStaticSymbol('/tmp/some_symbol.d.ts', 'someName', ['someMember']));
     });
 
-    it('should cache summaries', () => {
-      const asymbol = symbolCache.get('/a.d.ts', 'a');
-      init({'/a.ngsummary.json': serialize([{symbol: asymbol, metadata: 1}], [])});
-      expect(summaryResolver.resolveSummary(asymbol)).toBe(summaryResolver.resolveSummary(asymbol));
+    it('should store reexports in the same file', () => {
+      init();
+      const reexportedData = resolver.serializeSummaries(
+          '/tmp/some_pipe.ts', [{
+            summaryKind: CompileSummaryKind.Pipe,
+            type: {
+              reference: staticReflector.getStaticSymbol('/tmp/some_pipe.ts', 'SomeReexportedPipe'),
+              diDeps: [],
+              lifecycleHooks: []
+            },
+          }]);
+
+      init({[reexportedData.genFileUrl]: reexportedData.source});
+      const serializedData = resolver.serializeSummaries('/tmp/some_module.ts', [
+        <CompileNgModuleSummary>{
+          summaryKind: CompileSummaryKind.NgModule,
+          type: {
+            reference: staticReflector.getStaticSymbol('/tmp/some_module.ts', 'SomeModule'),
+            diDeps: [],
+            lifecycleHooks: []
+          },
+          exportedPipes: [{
+            reference: staticReflector.getStaticSymbol('/tmp/some_pipe.d.ts', 'SomeReexportedPipe')
+          }],
+          exportedDirectives: [],
+          providers: [],
+          entryComponents: [],
+          modules: []
+        }
+      ]);
+
+      init({[serializedData.genFileUrl]: serializedData.source});
+
+      resolver.resolveSummary(
+          staticReflector.getStaticSymbol('/tmp/some_module.d.ts', 'SomeModule'));
+      expect(resolver.resolveSummary(
+                 staticReflector.getStaticSymbol('/tmp/some_pipe.d.ts', 'SomeReexportedPipe')))
+          .toEqual({
+            summaryKind: CompileSummaryKind.Pipe,
+            type: {
+              reference:
+                  staticReflector.getStaticSymbol('/tmp/some_pipe.d.ts', 'SomeReexportedPipe'),
+              diDeps: [],
+              lifecycleHooks: []
+            },
+          });
     });
 
-    it('should return all sumbols in a summary', () => {
-      const asymbol = symbolCache.get('/a.d.ts', 'a');
-      init({'/a.ngsummary.json': serialize([{symbol: asymbol, metadata: 1}], [])});
-      expect(summaryResolver.getSymbolsOf('/a.d.ts')).toEqual([asymbol]);
-
-    });
   });
 }
 
+class MockAotSummaryResolverHost implements AotSummaryResolverHost {
+  constructor(private summaries: {[fileName: string]: string}) {}
+
+  loadSummary(filePath: string): string {
+    const result = this.summaries[filePath];
+    if (!result) {
+      throw new Error(`Could not find summary for ${filePath}`);
+    }
+    return result;
+  }
 
-export class MockAotSummarySerializerHost implements AotSummarySerializerHost {
   fileNameToModuleName(fileName: string): string {
     return './' + path.basename(fileName).replace(EXT, '');
   }
@@ -74,13 +135,4 @@ export class MockAotSummarySerializerHost implements AotSummarySerializerHost {
   getOutputFileName(sourceFileName: string): string {
     return sourceFileName.replace(EXT, '') + '.d.ts';
   }
-
-  isSourceFile(filePath: string) { return !filePath.endsWith('.d.ts'); }
-}
-
-export class MockAotSummaryResolverHost extends MockAotSummarySerializerHost implements
-    AotSummaryResolverHost {
-  constructor(private summaries: {[fileName: string]: string}) { super(); }
-
-  loadSummary(filePath: string): string { return this.summaries[filePath]; }
 }

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

@@ -1,199 +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
- */
-
-import {AotSummaryResolver, AotSummaryResolverHost, CompileSummaryKind, StaticSymbol, StaticSymbolCache, StaticSymbolResolver, StaticSymbolResolverHost} from '@angular/compiler';
-import {AotSummarySerializerHost, deserializeSummaries, serializeSummaries, summaryFileName} from '@angular/compiler/src/aot/summary_serializer';
-
-import {MockStaticSymbolResolverHost} from './static_symbol_resolver_spec';
-import {MockAotSummaryResolverHost} from './summary_resolver_spec';
-
-
-export function main() {
-  describe('summary serializer', () => {
-    let summaryResolver: AotSummaryResolver;
-    let symbolResolver: StaticSymbolResolver;
-    let symbolCache: StaticSymbolCache;
-    let host: MockAotSummaryResolverHost;
-
-    beforeEach(() => { symbolCache = new StaticSymbolCache(); });
-
-    function init(
-        summaries: {[filePath: string]: string} = {}, metadata: {[key: string]: any} = {}) {
-      host = new MockAotSummaryResolverHost(summaries);
-      summaryResolver = new AotSummaryResolver(host, symbolCache);
-      symbolResolver = new StaticSymbolResolver(
-          new MockStaticSymbolResolverHost(metadata), symbolCache, summaryResolver);
-    }
-
-    describe('summaryFileName', () => {
-      it('should add .ngsummary.json to the filename', () => {
-        init();
-        expect(summaryFileName('a.ts')).toBe('a.ngsummary.json');
-        expect(summaryFileName('a.d.ts')).toBe('a.ngsummary.json');
-        expect(summaryFileName('a.js')).toBe('a.ngsummary.json');
-      });
-    });
-
-    it('should serialize various data correctly', () => {
-      init();
-      const serializedData = serializeSummaries(
-          host, summaryResolver, symbolResolver,
-          [
-            {
-              symbol: symbolCache.get('/tmp/some_values.ts', 'Values'),
-              metadata: {
-                aNumber: 1,
-                aString: 'hello',
-                anArray: [1, 2],
-                aStaticSymbol: symbolCache.get('/tmp/some_symbol.ts', 'someName')
-              }
-            },
-            {
-              symbol: symbolCache.get('/tmp/some_service.ts', 'SomeService'),
-              metadata: {
-                __symbolic: 'class',
-                members: {'aMethod': {__symbolic: 'function'}},
-                statics: {aStatic: true}
-              }
-            }
-          ],
-          [<any>{
-            summaryKind: CompileSummaryKind.Injectable,
-            type: {
-              reference: symbolCache.get('/tmp/some_service.ts', 'SomeService'),
-            },
-          }]);
-
-
-      const summaries = deserializeSummaries(symbolCache, serializedData);
-      expect(summaries.length).toBe(2);
-
-      // Note: change from .ts to .d.ts is expected
-      expect(summaries[0].symbol).toBe(symbolCache.get('/tmp/some_values.d.ts', 'Values'));
-      expect(summaries[0].metadata).toEqual({
-        aNumber: 1,
-        aString: 'hello',
-        anArray: [1, 2],
-        aStaticSymbol: symbolCache.get('/tmp/some_symbol.d.ts', 'someName')
-      });
-
-      expect(summaries[1].symbol).toBe(symbolCache.get('/tmp/some_service.d.ts', 'SomeService'));
-      // serialization should only keep the statics...
-      expect(summaries[1].metadata).toEqual({__symbolic: 'class', statics: {aStatic: true}});
-      expect(summaries[1].type.type.reference)
-          .toBe(symbolCache.get('/tmp/some_service.d.ts', 'SomeService'));
-    });
-
-    it('should automatically add exported directives / pipes of NgModules that are not source files',
-       () => {
-         init({});
-         const externalSerialized = serializeSummaries(host, summaryResolver, symbolResolver, [], [
-           <any>{
-             summaryKind: CompileSummaryKind.Pipe,
-             type: {
-               reference: symbolCache.get('/tmp/external.ts', 'SomeExternalPipe'),
-             }
-           },
-           <any>{
-             summaryKind: CompileSummaryKind.Directive,
-             type: {
-               reference: symbolCache.get('/tmp/external.ts', 'SomeExternalDir'),
-             }
-           }
-         ]);
-         init({
-           '/tmp/external.ngsummary.json': externalSerialized,
-         });
-
-         const serialized = serializeSummaries(
-             host, summaryResolver, symbolResolver, [], [<any>{
-               summaryKind: CompileSummaryKind.NgModule,
-               type: {reference: symbolCache.get('/tmp/some_module.ts', 'SomeModule')},
-               exportedPipes: [
-                 {reference: symbolCache.get('/tmp/some_pipe.ts', 'SomePipe')},
-                 {reference: symbolCache.get('/tmp/external.d.ts', 'SomeExternalPipe')}
-               ],
-               exportedDirectives: [
-                 {reference: symbolCache.get('/tmp/some_dir.ts', 'SomeDir')},
-                 {reference: symbolCache.get('/tmp/external.d.ts', 'SomeExternalDir')}
-               ]
-             }]);
-
-         const summaries = deserializeSummaries(symbolCache, serialized);
-         expect(summaries.length).toBe(3);
-         expect(summaries[0].symbol).toBe(symbolCache.get('/tmp/some_module.d.ts', 'SomeModule'));
-         expect(summaries[1].symbol).toBe(symbolCache.get('/tmp/external.d.ts', 'SomeExternalDir'));
-         expect(summaries[2].symbol)
-             .toBe(symbolCache.get('/tmp/external.d.ts', 'SomeExternalPipe'));
-       });
-
-    it('should automatically add the metadata of referenced symbols that are not in the soure files',
-       () => {
-         const externalSerialized = serializeSummaries(
-             host, summaryResolver, symbolResolver,
-             [
-               {
-                 symbol: symbolCache.get('/tmp/external.ts', 'PROVIDERS'),
-                 metadata: [symbolCache.get('/tmp/external_svc.ts', 'SomeService')]
-               },
-               {
-                 symbol: symbolCache.get('/tmp/external_svc.ts', 'SomeService'),
-                 metadata: {__symbolic: 'class'}
-               }
-             ],
-             [<any>{
-               summaryKind: CompileSummaryKind.Injectable,
-               type: {
-                 reference: symbolCache.get('/tmp/external_svc.ts', 'SomeService'),
-               }
-             }]);
-         init(
-             {
-               '/tmp/external.ngsummary.json': externalSerialized,
-             },
-             {
-               '/tmp/local.ts': `
-          export var local = 'a';
-        `,
-               '/tmp/non_summary.d.ts':
-                   {__symbolic: 'module', version: 3, metadata: {'external': 'b'}}
-             });
-         const serialized = serializeSummaries(
-             host, summaryResolver, symbolResolver, [{
-               symbol: symbolCache.get('/tmp/test.ts', 'main'),
-               metadata: {
-                 local: symbolCache.get('/tmp/local.ts', 'local'),
-                 external: symbolCache.get('/tmp/external.d.ts', 'PROVIDERS'),
-                 externalNonSummary: symbolCache.get('/tmp/non_summary.d.ts', 'external')
-               }
-             }],
-             []);
-
-         const summaries = deserializeSummaries(symbolCache, serialized);
-         // Note: local should not show up!
-         expect(summaries.length).toBe(4);
-         expect(summaries[0].symbol).toBe(symbolCache.get('/tmp/test.d.ts', 'main'));
-         expect(summaries[0].metadata).toEqual({
-           local: symbolCache.get('/tmp/local.d.ts', 'local'),
-           external: symbolCache.get('/tmp/external.d.ts', 'PROVIDERS'),
-           externalNonSummary: symbolCache.get('/tmp/non_summary.d.ts', 'external')
-         });
-         expect(summaries[1].symbol).toBe(symbolCache.get('/tmp/external.d.ts', 'PROVIDERS'));
-         expect(summaries[1].metadata).toEqual([symbolCache.get(
-             '/tmp/external_svc.d.ts', 'SomeService')]);
-         // there was no summary for non_summary, but it should have
-         // been serialized as well.
-         expect(summaries[2].symbol).toBe(symbolCache.get('/tmp/non_summary.d.ts', 'external'));
-         expect(summaries[2].metadata).toEqual('b');
-         // SomService is a transitive dep, but sould have been serialized as well.
-         expect(summaries[3].symbol).toBe(symbolCache.get('/tmp/external_svc.d.ts', 'SomeService'));
-         expect(summaries[3].type.type.reference)
-             .toBe(symbolCache.get('/tmp/external_svc.d.ts', 'SomeService'));
-       });
-  });
-}

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

@@ -5,7 +5,7 @@
  * 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,7 +31,7 @@ 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');
          }));
     });
 

modules/@angular/compiler/test/i18n/digest_spec.ts

@@ -6,10 +6,23 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {computeMsgId, sha1} from '../../src/i18n/digest';
+import {computeMsgId, digest, sha1} from '../../src/i18n/digest';
 
 export function main(): void {
   describe('digest', () => {
+    describe('digest', () => {
+      it('must return the ID if it\'s explicit', () => {
+        expect(digest({
+          id: 'i',
+          nodes: [],
+          placeholders: {},
+          placeholderToMessage: {},
+          meaning: '',
+          description: '',
+        })).toEqual('i');
+      });
+    });
+
     describe('sha1', () => {
       it('should work on empty strings',
          () => { expect(sha1('')).toEqual('da39a3ee5e6b4b0d3255bfef95601890afd80709'); });

modules/@angular/compiler/test/i18n/extractor_merger_spec.ts

@@ -20,7 +20,10 @@ export function main() {
     describe('elements', () => {
       it('should extract from elements', () => {
         expect(extract('<div i18n="m|d|e">text<span>nested</span></div>')).toEqual([
-          [['text', '<ph tag name="START_TAG_SPAN">nested</ph name="CLOSE_TAG_SPAN">'], 'm', 'd|e'],
+          [
+            ['text', '<ph tag name="START_TAG_SPAN">nested</ph name="CLOSE_TAG_SPAN">'], 'm', 'd|e',
+            ''
+          ],
         ]);
       });
 
@@ -29,11 +32,45 @@ export function main() {
             extract(
                 '<div i18n="m1|d1"><span i18n-title="m2|d2" title="single child">nested</span></div>'))
             .toEqual([
-              [['<ph tag name="START_TAG_SPAN">nested</ph name="CLOSE_TAG_SPAN">'], 'm1', 'd1'],
-              [['single child'], 'm2', 'd2'],
+              [['<ph tag name="START_TAG_SPAN">nested</ph name="CLOSE_TAG_SPAN">'], 'm1', 'd1', ''],
+              [['single child'], 'm2', 'd2', ''],
             ]);
       });
 
+      it('should extract from attributes with id', () => {
+        expect(
+            extract(
+                '<div i18n="m1|d1@@i1"><span i18n-title="m2|d2@@i2" title="single child">nested</span></div>'))
+            .toEqual([
+              [
+                ['<ph tag name="START_TAG_SPAN">nested</ph name="CLOSE_TAG_SPAN">'], 'm1', 'd1',
+                'i1'
+              ],
+              [['single child'], 'm2', 'd2', 'i2'],
+            ]);
+      });
+
+      it('should extract from attributes without meaning and with id', () => {
+        expect(
+            extract(
+                '<div i18n="d1@@i1"><span i18n-title="d2@@i2" title="single child">nested</span></div>'))
+            .toEqual([
+              [['<ph tag name="START_TAG_SPAN">nested</ph name="CLOSE_TAG_SPAN">'], '', 'd1', 'i1'],
+              [['single child'], '', 'd2', 'i2'],
+            ]);
+      });
+
+      it('should extract from attributes with id only', () => {
+        expect(
+            extract(
+                '<div i18n="@@i1"><span i18n-title="@@i2" title="single child">nested</span></div>'))
+            .toEqual([
+              [['<ph tag name="START_TAG_SPAN">nested</ph name="CLOSE_TAG_SPAN">'], '', '', 'i1'],
+              [['single child'], '', '', 'i2'],
+            ]);
+      });
+
+
       it('should extract from ICU messages', () => {
         expect(
             extract(
@@ -43,10 +80,10 @@ export function main() {
                 [
                   '{count, plural, =0 {[<ph tag name="START_PARAGRAPH"></ph name="CLOSE_PARAGRAPH">]}}'
                 ],
-                'm', 'd'
+                'm', 'd', ''
               ],
-              [['title'], '', ''],
-              [['desc'], '', ''],
+              [['title'], '', '', ''],
+              [['desc'], '', '', ''],
             ]);
       });
 
@@ -55,7 +92,7 @@ export function main() {
 
       it('should ignore implicit elements in translatable elements', () => {
         expect(extract('<div i18n="m|d"><p></p></div>', ['p'])).toEqual([
-          [['<ph tag name="START_PARAGRAPH"></ph name="CLOSE_PARAGRAPH">'], 'm', 'd']
+          [['<ph tag name="START_PARAGRAPH"></ph name="CLOSE_PARAGRAPH">'], 'm', 'd', '']
         ]);
       });
     });
@@ -64,17 +101,19 @@ export function main() {
       it('should extract from blocks', () => {
         expect(extract(`<!-- i18n: meaning1|desc1 -->message1<!-- /i18n -->
          <!-- i18n: desc2 -->message2<!-- /i18n -->
-         <!-- i18n -->message3<!-- /i18n -->`))
+         <!-- i18n -->message3<!-- /i18n -->
+         <!-- i18n: meaning4|desc4@@id4 -->message4<!-- /i18n -->
+         <!-- i18n: @@id5 -->message5<!-- /i18n -->`))
             .toEqual([
-              [['message1'], 'meaning1', 'desc1'],
-              [['message2'], '', 'desc2'],
-              [['message3'], '', ''],
+              [['message1'], 'meaning1', 'desc1', ''], [['message2'], '', 'desc2', ''],
+              [['message3'], '', '', ''], [['message4'], 'meaning4', 'desc4', 'id4'],
+              [['message5'], '', '', 'id5']
             ]);
       });
 
       it('should ignore implicit elements in blocks', () => {
         expect(extract('<!-- i18n:m|d --><p></p><!-- /i18n -->', ['p'])).toEqual([
-          [['<ph tag name="START_PARAGRAPH"></ph name="CLOSE_PARAGRAPH">'], 'm', 'd']
+          [['<ph tag name="START_PARAGRAPH"></ph name="CLOSE_PARAGRAPH">'], 'm', 'd', '']
         ]);
       });
 
@@ -88,7 +127,7 @@ export function main() {
                 [
                   '{count, plural, =0 {[<ph tag name="START_TAG_SPAN">html</ph name="CLOSE_TAG_SPAN">]}}'
                 ],
-                '', ''
+                '', '', ''
               ],
               [
                 [
@@ -98,15 +137,15 @@ export function main() {
                       ' name="START_TAG_SPAN">html</ph name="CLOSE_TAG_SPAN">]}}</ph>',
                   '[<ph name="INTERPOLATION">interp</ph>]'
                 ],
-                '', ''
+                '', '', ''
               ],
             ]);
       });
 
       it('should ignore other comments', () => {
-        expect(extract(`<!-- i18n: meaning1|desc1 --><!-- other -->message1<!-- /i18n -->`))
+        expect(extract(`<!-- i18n: meaning1|desc1@@id1 --><!-- other -->message1<!-- /i18n -->`))
             .toEqual([
-              [['message1'], 'meaning1', 'desc1'],
+              [['message1'], 'meaning1', 'desc1', 'id1'],
             ]);
       });
 
@@ -118,34 +157,37 @@ export function main() {
       it('should extract ICU messages from translatable elements', () => {
         // single message when ICU is the only children
         expect(extract('<div i18n="m|d">{count, plural, =0 {text}}</div>')).toEqual([
-          [['{count, plural, =0 {[text]}}'], 'm', 'd'],
+          [['{count, plural, =0 {[text]}}'], 'm', 'd', ''],
         ]);
 
         // single message when ICU is the only (implicit) children
         expect(extract('<div>{count, plural, =0 {text}}</div>', ['div'])).toEqual([
-          [['{count, plural, =0 {[text]}}'], '', ''],
+          [['{count, plural, =0 {[text]}}'], '', '', ''],
         ]);
 
         // one message for the element content and one message for the ICU
-        expect(extract('<div i18n="m|d">before{count, plural, =0 {text}}after</div>')).toEqual([
-          [['before', '<ph icu name="ICU">{count, plural, =0 {[text]}}</ph>', 'after'], 'm', 'd'],
-          [['{count, plural, =0 {[text]}}'], '', ''],
+        expect(extract('<div i18n="m|d@@i">before{count, plural, =0 {text}}after</div>')).toEqual([
+          [
+            ['before', '<ph icu name="ICU">{count, plural, =0 {[text]}}</ph>', 'after'], 'm', 'd',
+            'i'
+          ],
+          [['{count, plural, =0 {[text]}}'], '', '', ''],
         ]);
       });
 
       it('should extract ICU messages from translatable block', () => {
         // single message when ICU is the only children
         expect(extract('<!-- i18n:m|d -->{count, plural, =0 {text}}<!-- /i18n -->')).toEqual([
-          [['{count, plural, =0 {[text]}}'], 'm', 'd'],
+          [['{count, plural, =0 {[text]}}'], 'm', 'd', ''],
         ]);
 
         // one message for the block content and one message for the ICU
         expect(extract('<!-- i18n:m|d -->before{count, plural, =0 {text}}after<!-- /i18n -->'))
             .toEqual([
-              [['{count, plural, =0 {[text]}}'], '', ''],
+              [['{count, plural, =0 {[text]}}'], '', '', ''],
               [
                 ['before', '<ph icu name="ICU">{count, plural, =0 {[text]}}</ph>', 'after'], 'm',
-                'd'
+                'd', ''
               ],
             ]);
       });
@@ -156,20 +198,20 @@ export function main() {
       it('should ignore nested ICU messages', () => {
         expect(extract('<div i18n="m|d">{count, plural, =0 { {sex, select, male {m}} }}</div>'))
             .toEqual([
-              [['{count, plural, =0 {[{sex, select, male {[m]}},  ]}}'], 'm', 'd'],
+              [['{count, plural, =0 {[{sex, select, male {[m]}},  ]}}'], 'm', 'd', ''],
             ]);
       });
 
       it('should ignore implicit elements in non translatable ICU messages', () => {
-        expect(
-            extract(
-                '<div i18n="m|d">{count, plural, =0 { {sex, select, male {<p>ignore</p>}} }}</div>',
-                ['p']))
+        expect(extract(
+                   '<div i18n="m|d@@i">{count, plural, =0 { {sex, select, male {<p>ignore</p>}}' +
+                       ' }}</div>',
+                   ['p']))
             .toEqual([[
               [
                 '{count, plural, =0 {[{sex, select, male {[<ph tag name="START_PARAGRAPH">ignore</ph name="CLOSE_PARAGRAPH">]}},  ]}}'
               ],
-              'm', 'd'
+              'm', 'd', 'i'
             ]]);
       });
 
@@ -181,46 +223,45 @@ export function main() {
 
     describe('attributes', () => {
       it('should extract from attributes outside of translatable sections', () => {
-        expect(extract('<div i18n-title="m|d" title="msg"></div>')).toEqual([
-          [['msg'], 'm', 'd'],
+        expect(extract('<div i18n-title="m|d@@i" title="msg"></div>')).toEqual([
+          [['msg'], 'm', 'd', 'i'],
         ]);
       });
 
       it('should extract from attributes in translatable elements', () => {
-        expect(extract('<div i18n><p><b i18n-title="m|d" title="msg"></b></p></div>')).toEqual([
+        expect(extract('<div i18n><p><b i18n-title="m|d@@i" title="msg"></b></p></div>')).toEqual([
           [
             ['<ph tag name="START_PARAGRAPH"><ph tag name="START_BOLD_TEXT"></ph' +
              ' name="CLOSE_BOLD_TEXT"></ph name="CLOSE_PARAGRAPH">'],
-            '', ''
+            '', '', ''
           ],
-          [['msg'], 'm', 'd'],
+          [['msg'], 'm', 'd', 'i'],
         ]);
       });
 
       it('should extract from attributes in translatable blocks', () => {
         expect(extract('<!-- i18n --><p><b i18n-title="m|d" title="msg"></b></p><!-- /i18n -->'))
             .toEqual([
-              [['msg'], 'm', 'd'],
+              [['msg'], 'm', 'd', ''],
               [
                 ['<ph tag name="START_PARAGRAPH"><ph tag name="START_BOLD_TEXT"></ph' +
                  ' name="CLOSE_BOLD_TEXT"></ph name="CLOSE_PARAGRAPH">'],
-                '', ''
+                '', '', ''
               ],
             ]);
       });
 
       it('should extract from attributes in translatable ICUs', () => {
-        expect(
-            extract(
-                '<!-- i18n -->{count, plural, =0 {<p><b i18n-title="m|d" title="msg"></b></p>}}<!-- /i18n -->'))
+        expect(extract(`<!-- i18n -->{count, plural, =0 {<p><b i18n-title="m|d@@i" 
+                 title="msg"></b></p>}}<!-- /i18n -->`))
             .toEqual([
-              [['msg'], 'm', 'd'],
+              [['msg'], 'm', 'd', 'i'],
               [
                 [
                   '{count, plural, =0 {[<ph tag name="START_PARAGRAPH"><ph tag' +
                   ' name="START_BOLD_TEXT"></ph name="CLOSE_BOLD_TEXT"></ph name="CLOSE_PARAGRAPH">]}}'
                 ],
-                '', ''
+                '', '', ''
               ],
             ]);
       });
@@ -228,7 +269,7 @@ export function main() {
       it('should extract from attributes in non translatable ICUs', () => {
         expect(extract('{count, plural, =0 {<p><b i18n-title="m|d" title="msg"></b></p>}}'))
             .toEqual([
-              [['msg'], 'm', 'd'],
+              [['msg'], 'm', 'd', ''],
             ]);
       });
 
@@ -239,7 +280,7 @@ export function main() {
     describe('implicit elements', () => {
       it('should extract from implicit elements', () => {
         expect(extract('<b>bold</b><i>italic</i>', ['b'])).toEqual([
-          [['bold'], '', ''],
+          [['bold'], '', '', ''],
         ]);
       });
 
@@ -251,7 +292,7 @@ export function main() {
         }).not.toThrow();
 
         expect(result).toEqual([
-          [['outer', '<ph tag name="START_TAG_DIV">inner</ph name="CLOSE_TAG_DIV">'], '', ''],
+          [['outer', '<ph tag name="START_TAG_DIV">inner</ph name="CLOSE_TAG_DIV">'], '', '', ''],
         ]);
       });
 
@@ -261,7 +302,7 @@ export function main() {
       it('should extract implicit attributes', () => {
         expect(extract('<b title="bb">bold</b><i title="ii">italic</i>', [], {'b': ['title']}))
             .toEqual([
-              [['bb'], '', ''],
+              [['bb'], '', '', ''],
             ]);
       });
     });
@@ -433,7 +474,7 @@ function extract(
   // clang-format off
   // https://github.com/angular/clang-format/issues/35
   return result.messages.map(
-    message => [serializeI18nNodes(message.nodes), message.meaning, message.description, ]) as [string[], string, string][];
+    message => [serializeI18nNodes(message.nodes), message.meaning, message.description, message.id]) as [string[], string, string][];
   // clang-format on
 }
 

modules/@angular/compiler/test/i18n/integration_spec.ts

@@ -59,14 +59,17 @@ export function main() {
       tb.detectChanges();
       expect(el.query(By.css('#i18n-7')).nativeElement).toHaveText('un');
       expect(el.query(By.css('#i18n-14')).nativeElement).toHaveText('un');
+      expect(el.query(By.css('#i18n-17')).nativeElement).toHaveText('un');
       cmp.count = 2;
       tb.detectChanges();
       expect(el.query(By.css('#i18n-7')).nativeElement).toHaveText('deux');
       expect(el.query(By.css('#i18n-14')).nativeElement).toHaveText('deux');
+      expect(el.query(By.css('#i18n-17')).nativeElement).toHaveText('deux');
       cmp.count = 3;
       tb.detectChanges();
       expect(el.query(By.css('#i18n-7')).nativeElement).toHaveText('beaucoup');
       expect(el.query(By.css('#i18n-14')).nativeElement).toHaveText('beaucoup');
+      expect(el.query(By.css('#i18n-17')).nativeElement).toHaveText('beaucoup');
 
       cmp.sex = 'm';
       cmp.sexB = 'f';
@@ -90,8 +93,8 @@ export function main() {
           .toEqual('<h1 id="i18n-12">Balises dans les commentaires html</h1>');
       expectHtml(el, '#i18n-13')
           .toBe('<div id="i18n-13" title="dans une section traductible"></div>');
-
       expectHtml(el, '#i18n-15').toMatch(/ca <b>devrait<\/b> marcher/);
+      expectHtml(el, '#i18n-16').toMatch(/avec un ID explicite/);
     });
   });
 }
@@ -141,6 +144,8 @@ function expectHtml(el: DebugElement, cssSelector: string): any {
 <!-- /i18n -->
 
 <div id="i18n-15"><ng-container i18n>it <b>should</b> work</ng-container></div>
+<div id="i18n-16" i18n="@@i18n16">with an explicit ID</div>
+<div id="i18n-17" i18n="@@i18n17">{count, plural, =0 {zero} =1 {one} =2 {two} other {<b>many</b>}}</div>
 `
 })
 class I18nComponent {
@@ -182,6 +187,9 @@ const XTB = `
     <ph name="START_TAG_DIV_1"/><ph name="ICU"/><ph name="CLOSE_TAG_DIV"></ph>
 </translation>
   <translation id="1491627405349178954">ca <ph name="START_BOLD_TEXT"/>devrait<ph name="CLOSE_BOLD_TEXT"/> marcher</translation>
+  <translation id="i18n16">avec un ID explicite</translation>
+  <translation id="i18n17">{VAR_PLURAL, plural, =0 {zero} =1 {un} =2 {deux} other {<ph 
+  name="START_BOLD_TEXT"><ex>&lt;b&gt;</ex></ph>beaucoup<ph name="CLOSE_BOLD_TEXT"><ex>&lt;/b&gt;</ex></ph>} }</translation>
 </translationbundle>`;
 
 // unused, for reference only
@@ -210,5 +218,7 @@ const XMB = `
     <ph name="START_TAG_DIV_1"><ex>&lt;div&gt;</ex></ph><ph name="ICU"/><ph name="CLOSE_TAG_DIV"><ex>&lt;/div&gt;</ex></ph>
 </msg>
   <msg id="1491627405349178954">it <ph name="START_BOLD_TEXT"><ex>&lt;b&gt;</ex></ph>should<ph name="CLOSE_BOLD_TEXT"><ex>&lt;/b&gt;</ex></ph> work</msg>
+  <msg id="i18n16">with an explicit ID</msg>
+  <msg id="i18n17">{VAR_PLURAL, plural, =0 {zero} =1 {one} =2 {two} other {<ph name="START_BOLD_TEXT"><ex>&lt;b&gt;</ex></ph>many<ph name="CLOSE_BOLD_TEXT"><ex>&lt;/b&gt;</ex></ph>} }</msg>
 </messagebundle>
 `;

modules/@angular/compiler/test/i18n/serializers/xliff_spec.ts

@@ -18,6 +18,8 @@ const HTML = `
 <p i18n-title title="translatable attribute">not translatable</p>
 <p i18n>translatable element <b>with placeholders</b> {{ interpolation}}</p>
 <p i18n="m|d">foo</p>
+<p i18n="m|d@@i">foo</p>
+<p i18n="@@bar">foo</p>
 <p i18n="ph names"><br><img><div></div></p>
 `;
 
@@ -39,6 +41,16 @@ const WRITE_XLIFF = `<?xml version="1.0" encoding="UTF-8" ?>
         <note priority="1" from="description">d</note>
         <note priority="1" from="meaning">m</note>
       </trans-unit>
+      <trans-unit id="i" datatype="html">
+        <source>foo</source>
+        <target/>
+        <note priority="1" from="description">d</note>
+        <note priority="1" from="meaning">m</note>
+      </trans-unit>
+      <trans-unit id="bar" datatype="html">
+        <source>foo</source>
+        <target/>
+      </trans-unit>
       <trans-unit id="d7fa2d59aaedcaa5309f13028c59af8c85b8c49d" datatype="html">
         <source><x id="LINE_BREAK" ctype="lb"/><x id="TAG_IMG" ctype="image"/><x id="START_TAG_DIV" ctype="x-div"/><x id="CLOSE_TAG_DIV" ctype="x-div"/></source>
         <target/>
@@ -67,6 +79,16 @@ const LOAD_XLIFF = `<?xml version="1.0" encoding="UTF-8" ?>
         <note priority="1" from="description">d</note>
         <note priority="1" from="meaning">m</note>
       </trans-unit>
+      <trans-unit id="i" datatype="html">
+        <source>foo</source>
+        <target>toto</target>
+        <note priority="1" from="description">d</note>
+        <note priority="1" from="meaning">m</note>
+      </trans-unit>
+      <trans-unit id="bar" datatype="html">
+        <source>foo</source>
+        <target>tata</target>
+      </trans-unit>
       <trans-unit id="d7fa2d59aaedcaa5309f13028c59af8c85b8c49d" datatype="html">
         <source><x id="LINE_BREAK" ctype="lb"/><x id="TAG_IMG" ctype="image"/><x id="START_TAG_DIV" ctype="x-div"/><x id="CLOSE_TAG_DIV" ctype="x-div"/></source>
         <target><x id="START_TAG_DIV" ctype="x-div"/><x id="CLOSE_TAG_DIV" ctype="x-div"/><x id="TAG_IMG" ctype="image"/><x id="LINE_BREAK" ctype="lb"/></target>
@@ -107,6 +129,8 @@ export function main(): void {
           'ec1d033f2436133c14ab038286c4f5df4697484a':
               '<ph name="INTERPOLATION"/> footnemele elbatalsnart <ph name="START_BOLD_TEXT"/>sredlohecalp htiw<ph name="CLOSE_BOLD_TEXT"/>',
           'db3e0a6a5a96481f60aec61d98c3eecddef5ac23': 'oof',
+          'i': 'toto',
+          'bar': 'tata',
           'd7fa2d59aaedcaa5309f13028c59af8c85b8c49d':
               '<ph name="START_TAG_DIV"/><ph name="CLOSE_TAG_DIV"/><ph name="TAG_IMG"/><ph name="LINE_BREAK"/>',
         });

modules/@angular/compiler/test/i18n/serializers/xmb_spec.ts

@@ -18,6 +18,9 @@ export function main(): void {
 <p i18n>translatable element <b>with placeholders</b> {{ interpolation}}</p>
 <!-- i18n -->{ count, plural, =0 {<p>test</p>}}<!-- /i18n -->
 <p i18n="m|d">foo</p>
+<p i18n="m|d@@i">foo</p>
+<p i18n="@@bar">foo</p>
+<p i18n="@@baz">{ count, plural, =0 { { sex, select, other {<p>deeply nested</p>}} }}</p>
 <p i18n>{ count, plural, =0 { { sex, select, other {<p>deeply nested</p>}} }}</p>`;
 
     const XMB = `<?xml version="1.0" encoding="UTF-8" ?>
@@ -43,9 +46,12 @@ export function main(): void {
 <!ELEMENT ex (#PCDATA)>
 ]>
 <messagebundle>
-  <msg id="7056919470098446707">translatable element <ph name="START_BOLD_TEXT"><ex>&lt;b&gt;</ex></ph>with placeholders<ph name="CLOSE_BOLD_TEXT"><ex>&lt;/b&gt;</ex></ph> <ph name="INTERPOLATION"><ex>INTERPOLATION</ex></ph></msg>
+  <msg id="7056919470098446707">translatable element <ph name="START_BOLD_TEXT"><ex>&lt;b&gt;</ex></ph>with placeholders<ph name="CLOSE_BOLD_TEXT"><ex>&lt;/b&gt;</ex></ph> <ph name="INTERPOLATION"/></msg>
   <msg id="2981514368455622387">{VAR_PLURAL, plural, =0 {<ph name="START_PARAGRAPH"><ex>&lt;p&gt;</ex></ph>test<ph name="CLOSE_PARAGRAPH"><ex>&lt;/p&gt;</ex></ph>} }</msg>
   <msg id="7999024498831672133" desc="d" meaning="m">foo</msg>
+  <msg id="i" desc="d" meaning="m">foo</msg>
+  <msg id="bar">foo</msg>
+  <msg id="baz">{VAR_PLURAL, plural, =0 {{VAR_SELECT, select, other {<ph name="START_PARAGRAPH"><ex>&lt;p&gt;</ex></ph>deeply nested<ph name="CLOSE_PARAGRAPH"><ex>&lt;/p&gt;</ex></ph>} } } }</msg>
   <msg id="2015957479576096115">{VAR_PLURAL, plural, =0 {{VAR_SELECT, select, other {<ph name="START_PARAGRAPH"><ex>&lt;p&gt;</ex></ph>deeply nested<ph name="CLOSE_PARAGRAPH"><ex>&lt;/p&gt;</ex></ph>} } } }</msg>
 </messagebundle>
 `;

modules/@angular/compiler/test/i18n/translation_bundle_spec.ts

@@ -21,7 +21,7 @@ export function main(): void {
     it('should translate a plain message', () => {
       const msgMap = {foo: [new i18n.Text('bar', null)]};
       const tb = new TranslationBundle(msgMap, (_) => 'foo');
-      const msg = new i18n.Message([srcNode], {}, {}, 'm', 'd');
+      const msg = new i18n.Message([srcNode], {}, {}, 'm', 'd', 'i');
       expect(serializeNodes(tb.get(msg))).toEqual(['bar']);
     });
 
@@ -36,7 +36,7 @@ export function main(): void {
         ph1: '*phContent*',
       };
       const tb = new TranslationBundle(msgMap, (_) => 'foo');
-      const msg = new i18n.Message([srcNode], phMap, {}, 'm', 'd');
+      const msg = new i18n.Message([srcNode], phMap, {}, 'm', 'd', 'i');
       expect(serializeNodes(tb.get(msg))).toEqual(['bar*phContent*']);
     });
 
@@ -51,8 +51,8 @@ export function main(): void {
           new i18n.Text('*refMsg*', null),
         ],
       };
-      const refMsg = new i18n.Message([srcNode], {}, {}, 'm', 'd');
-      const msg = new i18n.Message([srcNode], {}, {ph1: refMsg}, 'm', 'd');
+      const refMsg = new i18n.Message([srcNode], {}, {}, 'm', 'd', 'i');
+      const msg = new i18n.Message([srcNode], {}, {ph1: refMsg}, 'm', 'd', 'i');
       let count = 0;
       const digest = (_: any) => count++ ? 'ref' : 'foo';
       const tb = new TranslationBundle(msgMap, digest);
@@ -69,13 +69,13 @@ export function main(): void {
           ]
         };
         const tb = new TranslationBundle(msgMap, (_) => 'foo');
-        const msg = new i18n.Message([srcNode], {}, {}, 'm', 'd');
+        const msg = new i18n.Message([srcNode], {}, {}, 'm', 'd', 'i');
         expect(() => tb.get(msg)).toThrowError(/Unknown placeholder/);
       });
 
       it('should report missing translation', () => {
         const tb = new TranslationBundle({}, (_) => 'foo');
-        const msg = new i18n.Message([srcNode], {}, {}, 'm', 'd');
+        const msg = new i18n.Message([srcNode], {}, {}, 'm', 'd', 'i');
         expect(() => tb.get(msg)).toThrowError(/Missing translation for message foo/);
       });
 
@@ -83,8 +83,8 @@ export function main(): void {
         const msgMap = {
           foo: [new i18n.Placeholder('', 'ph1', span)],
         };
-        const refMsg = new i18n.Message([srcNode], {}, {}, 'm', 'd');
-        const msg = new i18n.Message([srcNode], {}, {ph1: refMsg}, 'm', 'd');
+        const refMsg = new i18n.Message([srcNode], {}, {}, 'm', 'd', 'i');
+        const msg = new i18n.Message([srcNode], {}, {ph1: refMsg}, 'm', 'd', 'i');
         let count = 0;
         const digest = (_: any) => count++ ? 'ref' : 'foo';
         const tb = new TranslationBundle(msgMap, digest);
@@ -102,7 +102,7 @@ export function main(): void {
           ph1: '</b>',
         };
         const tb = new TranslationBundle(msgMap, (_) => 'foo');
-        const msg = new i18n.Message([srcNode], phMap, {}, 'm', 'd');
+        const msg = new i18n.Message([srcNode], phMap, {}, 'm', 'd', 'i');
         expect(() => tb.get(msg)).toThrowError(/Unexpected closing tag "b"/);
       });
     });

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

@@ -15,8 +15,8 @@ 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';
 
 export function main() {
@@ -34,9 +34,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 +121,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 +145,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 +155,6 @@ export function main() {
          expect(
              () => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithImportedComponent, true))
              .toThrowError(
-                 SyntaxError,
                  `Unexpected directive 'ComponentWithoutModuleId' imported by the module 'ModuleWithImportedComponent'`);
        }));
 
@@ -170,7 +168,6 @@ export function main() {
          }
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithImportedPipe, true))
              .toThrowError(
-                 SyntaxError,
                  `Unexpected pipe 'SomePipe' imported by the module 'ModuleWithImportedPipe'`);
        }));
 
@@ -184,7 +181,6 @@ export function main() {
          }
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithDeclaredModule, true))
              .toThrowError(
-                 SyntaxError,
                  `Unexpected module 'SomeModule' declared by the module 'ModuleWithDeclaredModule'`);
        }));
 
@@ -195,7 +191,6 @@ export function main() {
          }
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithNullDeclared, true))
              .toThrowError(
-                 SyntaxError,
                  `Unexpected value 'null' declared by the module 'ModuleWithNullDeclared'`);
        }));
 
@@ -206,7 +201,6 @@ export function main() {
          }
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithNullImported, true))
              .toThrowError(
-                 SyntaxError,
                  `Unexpected value 'null' imported by the module 'ModuleWithNullImported'`);
        }));
 
@@ -218,8 +212,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 one of providers is not present',
@@ -230,7 +223,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?, ...]`);
        }));
 
@@ -242,7 +234,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?, ...]`);
        }));
 
@@ -257,13 +248,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/ml_parser/html_parser_spec.ts

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {beforeEach, describe, expect, it} from '../../../core/testing/testing_internal';
 import * as html from '../../src/ml_parser/ast';
 import {HtmlParser, ParseTreeResult, TreeError} from '../../src/ml_parser/html_parser';
 import {TokenType} from '../../src/ml_parser/lexer';
@@ -303,18 +304,6 @@ export function main() {
           ]))).toEqual([[html.Text, 'One {{message}}', 0]]);
         });
 
-        it('should parse out expansion forms', () => {
-          const parsed =
-              parser.parse(`<div><span>{a, plural, =0 {b}}</span></div>`, 'TestComp', true);
-
-          expect(humanizeDom(parsed)).toEqual([
-            [html.Element, 'div', 0],
-            [html.Element, 'span', 1],
-            [html.Expansion, 'a', 'plural', 2],
-            [html.ExpansionCase, '=0', 3],
-          ]);
-        });
-
         it('should parse out nested expansion forms', () => {
           const parsed = parser.parse(
               `{messages.length, plural, =0 { {p.gender, select, male {m}} }}`, 'TestComp', true);

modules/@angular/compiler/test/ml_parser/icu_ast_expander_spec.ts

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {describe, expect, it} from '../../../core/testing/testing_internal';
 import * as html from '../../src/ml_parser/ast';
 import {HtmlParser} from '../../src/ml_parser/html_parser';
 import {ExpansionResult, expandNodes} from '../../src/ml_parser/icu_ast_expander';
@@ -95,20 +96,6 @@ export function main() {
       ]);
     });
 
-    it('should parse an expansion form as a tag single child', () => {
-      const res = expand(`<div><span>{a, b, =4 {c}}</span></div>`);
-
-      expect(humanizeNodes(res.nodes)).toEqual([
-        [html.Element, 'div', 0],
-        [html.Element, 'span', 1],
-        [html.Element, 'ng-container', 2],
-        [html.Attribute, '[ngSwitch]', 'a'],
-        [html.Element, 'template', 3],
-        [html.Attribute, 'ngSwitchCase', '=4'],
-        [html.Text, 'c', 4],
-      ]);
-    });
-
     describe('errors', () => {
       it('should error on unknown plural cases', () => {
         expect(humanizeErrors(expand('{n, plural, unknown {-}}').errors)).toEqual([

modules/@angular/compiler/test/ml_parser/lexer_spec.ts

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {describe, expect, it} from '../../../core/testing/testing_internal';
 import {getHtmlTagDefinition} from '../../src/ml_parser/html_tags';
 import {InterpolationConfig} from '../../src/ml_parser/interpolation_config';
 import * as lex from '../../src/ml_parser/lexer';
@@ -523,15 +524,7 @@ export function main() {
         ]);
       });
 
-      it('should treat expansion form as text when they are not parsed', () => {
-        expect(tokenizeAndHumanizeParts('<span>{a, b, =4 {c}}</span>', false)).toEqual([
-          [lex.TokenType.TAG_OPEN_START, null, 'span'],
-          [lex.TokenType.TAG_OPEN_END],
-          [lex.TokenType.TEXT, '{a, b, =4 {c}}'],
-          [lex.TokenType.TAG_CLOSE, null, 'span'],
-          [lex.TokenType.EOF],
-        ]);
-      });
+
     });
 
     describe('raw text', () => {
@@ -679,26 +672,6 @@ export function main() {
         ]);
       });
 
-      it('should parse an expansion form as a tag single child', () => {
-        expect(tokenizeAndHumanizeParts('<div><span>{a, b, =4 {c}}</span></div>', true)).toEqual([
-          [lex.TokenType.TAG_OPEN_START, null, 'div'],
-          [lex.TokenType.TAG_OPEN_END],
-          [lex.TokenType.TAG_OPEN_START, null, 'span'],
-          [lex.TokenType.TAG_OPEN_END],
-          [lex.TokenType.EXPANSION_FORM_START],
-          [lex.TokenType.RAW_TEXT, 'a'],
-          [lex.TokenType.RAW_TEXT, 'b'],
-          [lex.TokenType.EXPANSION_CASE_VALUE, '=4'],
-          [lex.TokenType.EXPANSION_CASE_EXP_START],
-          [lex.TokenType.TEXT, 'c'],
-          [lex.TokenType.EXPANSION_CASE_EXP_END],
-          [lex.TokenType.EXPANSION_FORM_END],
-          [lex.TokenType.TAG_CLOSE, null, 'span'],
-          [lex.TokenType.TAG_CLOSE, null, 'div'],
-          [lex.TokenType.EOF],
-        ]);
-      });
-
       it('should parse an expansion forms with elements in it', () => {
         expect(tokenizeAndHumanizeParts('{one.two, three, =4 {four <b>a</b>}}', true)).toEqual([
           [lex.TokenType.EXPANSION_FORM_START],

modules/@angular/compiler/test/output/ts_emitter_node_only_spec.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {StaticReflector, StaticSymbol, StaticSymbolCache, StaticSymbolResolver, StaticSymbolResolverHost} from '@angular/compiler';
+import {StaticReflector, StaticReflectorHost, StaticSymbol} from '@angular/compiler';
 import * as o from '@angular/compiler/src/output/output_ast';
 import {ImportResolver} from '@angular/compiler/src/output/path_util';
 import {TypeScriptEmitter} from '@angular/compiler/src/output/ts_emitter';
@@ -14,8 +14,6 @@ import {convertValueToOutputAst} from '@angular/compiler/src/output/value_util';
 import {MetadataCollector, isClassMetadata, isMetadataSymbolicCallExpression} from '@angular/tsc-wrapped';
 import * as ts from 'typescript';
 
-import {MockSummaryResolver} from '../aot/static_symbol_resolver_spec';
-
 describe('TypeScriptEmitter (node only)', () => {
   it('should quote identifiers quoted in the source', () => {
     const sourceText = `
@@ -29,10 +27,7 @@ describe('TypeScriptEmitter (node only)', () => {
     const source = ts.createSourceFile('test.ts', sourceText, ts.ScriptTarget.Latest);
     const collector = new MetadataCollector({quotedNames: true});
     const stubHost = new StubReflectorHost();
-    const symbolCache = new StaticSymbolCache();
-    const symbolResolver =
-        new StaticSymbolResolver(stubHost, symbolCache, new MockSummaryResolver());
-    const reflector = new StaticReflector(symbolResolver);
+    const reflector = new StaticReflector(stubHost);
 
     // Get the metadata from the above source
     const metadata = collector.getMetadata(source);
@@ -67,9 +62,9 @@ describe('TypeScriptEmitter (node only)', () => {
   });
 });
 
-class StubReflectorHost implements StaticSymbolResolverHost {
+class StubReflectorHost implements StaticReflectorHost {
   getMetadataFor(modulePath: string): {[key: string]: any}[] { return []; }
-  moduleNameToFileName(moduleName: string, containingFile: string): string { return 'somePath'; }
+  moduleNameToFileName(moduleName: string, containingFile: string): string { return ''; }
 }
 
 class StubImportResolver extends ImportResolver {

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

@@ -5,7 +5,7 @@
  * 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 +374,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 +382,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 +397,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 +445,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 +479,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 +494,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`);
         });
 
@@ -945,8 +940,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', () => {
@@ -1038,7 +1033,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');
         });
 
@@ -1053,7 +1047,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');
         });
 
@@ -1105,26 +1098,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`);
 
         });
@@ -1476,8 +1466,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',
@@ -1487,20 +1477,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`);
       });
 
@@ -1513,13 +1501,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`);
       });
 
@@ -1557,10 +1544,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',
@@ -1575,7 +1562,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`);
@@ -1591,8 +1578,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`);
       });
@@ -1852,7 +1838,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/package.json

@@ -8,7 +8,7 @@
   "author": "angular",
   "license": "MIT",
   "peerDependencies": {
-    "rxjs": "^5.0.1",
+    "rxjs": "5.0.0-rc.4",
     "zone.js": "^0.7.2"
   },
   "repository": {

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

@@ -94,13 +94,13 @@ export function createPlatform(injector: Injector): PlatformRef {
  * @experimental APIs related to application bootstrap are currently under review.
  */
 export function createPlatformFactory(
-    parentPlatformFactory: (extraProviders?: Provider[]) => PlatformRef, name: string,
+    parentPlaformFactory: (extraProviders?: Provider[]) => PlatformRef, name: string,
     providers: Provider[] = []): (extraProviders?: Provider[]) => PlatformRef {
   const marker = new OpaqueToken(`Platform: ${name}`);
   return (extraProviders: Provider[] = []) => {
     if (!getPlatform()) {
-      if (parentPlatformFactory) {
-        parentPlatformFactory(
+      if (parentPlaformFactory) {
+        parentPlaformFactory(
             providers.concat(extraProviders).concat({provide: marker, useValue: true}));
       } else {
         createPlatform(ReflectiveInjector.resolveAndCreate(

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

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Injectable, OpaqueToken} from '../di';
+import {OpaqueToken} from '../di';
 import {BaseError} from '../facade/errors';
 import {stringify} from '../facade/lang';
 import {ViewEncapsulation} from '../metadata';
@@ -54,7 +54,6 @@ function _throwError() {
  * of components.
  * @stable
  */
-@Injectable()
 export class Compiler {
   /**
    * Compiles the given NgModule and all of its components. All templates of the components listed

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

@@ -135,6 +135,11 @@ export class TestBed implements Injector {
     return TestBed;
   }
 
+  static overrideTemplate(component: Type<any>, template: string): typeof TestBed {
+    getTestBed().overrideComponent(component, {set: {template, templateUrl: null}});
+    return TestBed;
+  }
+
   static get(token: any, notFoundValue: any = Injector.THROW_IF_NOT_FOUND) {
     return getTestBed().get(token, notFoundValue);
   }

modules/@angular/examples/common/ngIf/ts/e2e_test/ngIf_spec.ts

@@ -0,0 +1,72 @@
+/**
+ * @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 {$, ExpectedConditions, browser, by, element} from 'protractor';
+import {verifyNoBrowserErrors} from '../../../../_common/e2e_util';
+
+function waitForElement(selector: string) {
+  const EC = ExpectedConditions;
+  // Waits for the element with id 'abc' to be present on the dom.
+  browser.wait(EC.presenceOf($(selector)), 20000);
+}
+
+describe('ngIf', () => {
+  const URL = 'common/ngIf/ts/';
+  afterEach(verifyNoBrowserErrors);
+
+  describe('ng-if-simple', () => {
+    let comp = 'ng-if-simple';
+    it('should hide/show content', () => {
+      browser.get(URL);
+      waitForElement(comp);
+      expect(element.all(by.css(comp)).get(0).getText()).toEqual('hide show = true\nText to show');
+      element(by.css(comp + ' button')).click();
+      expect(element.all(by.css(comp)).get(0).getText()).toEqual('show show = false');
+    });
+  });
+
+  describe('ng-if-else', () => {
+    let comp = 'ng-if-else';
+    it('should hide/show content', () => {
+      browser.get(URL);
+      waitForElement(comp);
+      expect(element.all(by.css(comp)).get(0).getText()).toEqual('hide show = true\nText to show');
+      element(by.css(comp + ' button')).click();
+      expect(element.all(by.css(comp)).get(0).getText())
+          .toEqual('show show = false\nAlternate text while primary text is hidden');
+    });
+  });
+
+  describe('ng-if-then-else', () => {
+    let comp = 'ng-if-then-else';
+    it('should hide/show content', () => {
+      browser.get(URL);
+      waitForElement(comp);
+      expect(element.all(by.css(comp)).get(0).getText())
+          .toEqual('hide Switch Primary show = true\nPrimary text to show');
+      element.all(by.css(comp + ' button')).get(1).click();
+      expect(element.all(by.css(comp)).get(0).getText())
+          .toEqual('hide Switch Primary show = true\nSecondary text to show');
+      element.all(by.css(comp + ' button')).get(0).click();
+      expect(element.all(by.css(comp)).get(0).getText())
+          .toEqual('show Switch Primary show = false\nAlternate text while primary text is hidden');
+    });
+  });
+
+  describe('ng-if-let', () => {
+    let comp = 'ng-if-let';
+    it('should hide/show content', () => {
+      browser.get(URL);
+      waitForElement(comp);
+      expect(element.all(by.css(comp)).get(0).getText())
+          .toEqual('Next User\nWaiting... (user is null)');
+      element(by.css(comp + ' button')).click();
+      expect(element.all(by.css(comp)).get(0).getText()).toEqual('Next User\nHello Smith, John!');
+    });
+  });
+});

modules/@angular/examples/common/ngIf/ts/module.ts

@@ -0,0 +1,128 @@
+/**
+ * @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 {Component, NgModule, OnInit, TemplateRef, ViewChild} from '@angular/core';
+import {BrowserModule} from '@angular/platform-browser';
+import {Subject} from 'rxjs/Subject';
+
+
+// #docregion NgIfSimple
+@Component({
+  selector: 'ng-if-simple',
+  template: `
+    <button (click)="show = !show">{{show ? 'hide' : 'show'}}</button>
+    show = {{show}}
+    <br>
+    <div *ngIf="show">Text to show</div>
+`
+})
+class NgIfSimple {
+  show: boolean = true;
+}
+// #enddocregion
+
+// #docregion NgIfElse
+@Component({
+  selector: 'ng-if-else',
+  template: `
+    <button (click)="show = !show">{{show ? 'hide' : 'show'}}</button>
+    show = {{show}}
+    <br>
+    <div *ngIf="show; else elseBlock">Text to show</div>
+    <template #elseBlock>Alternate text while primary text is hidden</template>
+`
+})
+class NgIfElse {
+  show: boolean = true;
+}
+// #enddocregion
+
+// #docregion NgIfThenElse
+@Component({
+  selector: 'ng-if-then-else',
+  template: `
+    <button (click)="show = !show">{{show ? 'hide' : 'show'}}</button>
+    <button (click)="switchPrimary()">Switch Primary</button>
+    show = {{show}}
+    <br>
+    <div *ngIf="show; then thenBlock; else elseBlock">this is ignored</div>
+    <template #primaryBlock>Primary text to show</template>
+    <template #secondaryBlock>Secondary text to show</template>
+    <template #elseBlock>Alternate text while primary text is hidden</template>
+`
+})
+class NgIfThenElse implements OnInit {
+  thenBlock: TemplateRef<any> = null;
+  show: boolean = true;
+
+  @ViewChild('primaryBlock')
+  primaryBlock: TemplateRef<any> = null;
+  @ViewChild('secondaryBlock')
+  secondaryBlock: TemplateRef<any> = null;
+
+  switchPrimary() {
+    this.thenBlock = this.thenBlock === this.primaryBlock ? this.secondaryBlock : this.primaryBlock;
+  }
+
+  ngOnInit() { this.thenBlock = this.primaryBlock; }
+}
+// #enddocregion
+
+// #docregion NgIfLet
+@Component({
+  selector: 'ng-if-let',
+  template: `
+    <button (click)="nextUser()">Next User</button>
+    <br>
+    <div *ngIf="userObservable | async; else loading; let user">
+      Hello {{user.last}}, {{user.first}}!
+    </div>
+    <template #loading let-user>Waiting... (user is {{user|json}})</template>
+`
+})
+class NgIfLet {
+  userObservable = new Subject<{first: string, last: string}>();
+  first = ['John', 'Mike', 'Mary', 'Bob'];
+  firstIndex = 0;
+  last = ['Smith', 'Novotny', 'Angular'];
+  lastIndex = 0;
+
+  nextUser() {
+    let first = this.first[this.firstIndex++];
+    if (this.firstIndex >= this.first.length) this.firstIndex = 0;
+    let last = this.last[this.lastIndex++];
+    if (this.lastIndex >= this.last.length) this.lastIndex = 0;
+    this.userObservable.next({first, last});
+  }
+}
+// #enddocregion
+
+
+@Component({
+  selector: 'example-app',
+  template: `
+    <ng-if-simple></ng-if-simple>
+    <hr>
+    <ng-if-else></ng-if-else>
+    <hr>
+    <ng-if-then-else></ng-if-then-else>
+    <hr>
+    <ng-if-let></ng-if-let>
+    <hr>
+`
+})
+class ExampleApp {
+}
+
+@NgModule({
+  imports: [BrowserModule],
+  declarations: [ExampleApp, NgIfSimple, NgIfElse, NgIfThenElse, NgIfLet],
+  bootstrap: [ExampleApp]
+})
+export class AppModule {
+}

modules/@angular/forms/src/directives.ts

@@ -14,6 +14,7 @@ import {NgControlStatus, NgControlStatusGroup} from './directives/ng_control_sta
 import {NgForm} from './directives/ng_form';
 import {NgModel} from './directives/ng_model';
 import {NgModelGroup} from './directives/ng_model_group';
+import {NgNovalidate} from './directives/ng_novalidate_directive';
 import {NumberValueAccessor} from './directives/number_value_accessor';
 import {RadioControlValueAccessor} from './directives/radio_control_value_accessor';
 import {RangeValueAccessor} from './directives/range_value_accessor';
@@ -44,6 +45,7 @@ export {NgSelectOption, SelectControlValueAccessor} from './directives/select_co
 export {NgSelectMultipleOption, SelectMultipleControlValueAccessor} from './directives/select_multiple_control_value_accessor';
 
 export const SHARED_FORM_DIRECTIVES: Type<any>[] = [
+  NgNovalidate,
   NgSelectOption,
   NgSelectMultipleOption,
   DefaultValueAccessor,

modules/@angular/forms/src/directives/ng_novalidate_directive.ts

@@ -0,0 +1,16 @@
+/**
+ * @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 {Directive} from '@angular/core';
+
+@Directive({
+  selector: 'form:not([ngNoForm])',
+  host: {'novalidate': ''},
+})
+export class NgNovalidate {
+}

modules/@angular/forms/test/reactive_integration_spec.ts

@@ -72,6 +72,15 @@ export function main() {
         expect(input.nativeElement.value).toEqual('loginValue');
       });
 
+      it('should add novalidate by default to form', () => {
+        const fixture = TestBed.createComponent(FormGroupComp);
+        fixture.componentInstance.form = new FormGroup({'login': new FormControl('loginValue')});
+        fixture.detectChanges();
+
+        const form = fixture.debugElement.query(By.css('form'));
+        expect(form.nativeElement.getAttribute('novalidate')).toEqual('');
+      });
+
       it('work with formGroups (view -> model)', () => {
         const fixture = TestBed.createComponent(FormGroupComp);
         const form = new FormGroup({'login': new FormControl('oldValue')});

modules/@angular/forms/test/template_integration_spec.ts

@@ -76,6 +76,16 @@ export function main() {
            expect(form.valid).toBe(false);
          }));
 
+      it('should add novalidate by default to form element', fakeAsync(() => {
+           const fixture = TestBed.createComponent(NgModelForm);
+
+           fixture.detectChanges();
+           tick();
+
+           const form = fixture.debugElement.query(By.css('form'));
+           expect(form.nativeElement.getAttribute('novalidate')).toEqual('');
+         }));
+
       it('should support ngModelGroup', fakeAsync(() => {
            const fixture = TestBed.createComponent(NgModelGroupForm);
            fixture.componentInstance.first = 'Nancy';
@@ -232,6 +242,13 @@ export function main() {
         fixture.detectChanges();
         expect(fixture.debugElement.children[0].providerTokens.length).toEqual(0);
       });
+
+      it('should not add novalidate when ngNoForm is used', () => {
+        const fixture = TestBed.createComponent(NgNoFormComp);
+        fixture.detectChanges();
+        const form = fixture.debugElement.query(By.css('form'));
+        expect(form.nativeElement.hasAttribute('novalidate')).toBeFalsy();
+      });
     });
 
     describe('name and ngModelOptions', () => {