docs(changelog): add release notes for 2.4.2

@angular/language-service now supports using TypeScript 2.1 as the
the TypeScript host. TypeScript 2.1 is now also partially supported
in `ngc` but is not recommended as Tsickle does not yet support 2.1.

CHANGELOG.md

@@ -1,3 +1,61 @@
+<a name="2.4.2"></a>
+## [2.4.2](https://github.com/angular/angular/compare/2.4.1...2.4.2) (2017-01-06)
+
+
+### Bug Fixes
+
+* **common:** add link to trackBy docs from the error message ([#13634](https://github.com/angular/angular/issues/13634)) ([f723437](https://github.com/angular/angular/commit/f723437))
+* **common:** do not override locale provided on bootstrap ([#13654](https://github.com/angular/angular/issues/13654)) ([5f49c3e](https://github.com/angular/angular/commit/5f49c3e)), closes [#13607](https://github.com/angular/angular/issues/13607)
+* **common:** allow null/undefined values for `NgForTrackBy` ([6be55cc](https://github.com/angular/angular/commit/6be55cc)), closes [#13641](https://github.com/angular/angular/issues/13641)
+* **compiler:** don’t throw when using `ANALYZE_FOR_ENTRY_COMPONENTS` with user classes ([#13679](https://github.com/angular/angular/issues/13679)) ([230e33f](https://github.com/angular/angular/commit/230e33f)), closes [#13565](https://github.com/angular/angular/issues/13565)
+* **compiler:** query `<template>` elements before their children. ([#13677](https://github.com/angular/angular/issues/13677)) ([1cd73c7](https://github.com/angular/angular/commit/1cd73c7)), closes [#13118](https://github.com/angular/angular/issues/13118) [#13167](https://github.com/angular/angular/issues/13167)
+* **compiler:** allow "." in attribute selectors ([#13653](https://github.com/angular/angular/issues/13653)) ([29ffdfd](https://github.com/angular/angular/commit/29ffdfd)), closes [#13645](https://github.com/angular/angular/issues/13645)
+* **core:** animations no longer silently exits if the element is not apart of the DOM ([#13763](https://github.com/angular/angular/issues/13763)) ([f1cde43](https://github.com/angular/angular/commit/f1cde43))
+* **core:** animations should blend in all previously transitioned styles into next animation if interrupted ([#13148](https://github.com/angular/angular/issues/13148)) ([b245b92](https://github.com/angular/angular/commit/b245b92))
+* **core:** remove reference to "Angular 2" in dev mode warning ([#13751](https://github.com/angular/angular/issues/13751)) ([21f5f05](https://github.com/angular/angular/commit/21f5f05))
+* **core/testing:** improve misleading error message when don't call compileComponents ([#13543](https://github.com/angular/angular/issues/13543)) ([0e7f9f0](https://github.com/angular/angular/commit/0e7f9f0)), closes [#11301](https://github.com/angular/angular/issues/11301)
+* **forms:** Validators.required properly validate arrays ([#13362](https://github.com/angular/angular/issues/13362)) ([17c5fa9](https://github.com/angular/angular/commit/17c5fa9)), closes [#12274](https://github.com/angular/angular/issues/12274)
+* **language-service:** support TypeScript 2.1 ([#13655](https://github.com/angular/angular/issues/13655)) ([56b4296](https://github.com/angular/angular/commit/56b4296))
+* **router:** fix lazy loaded module with wildcard route ([#13649](https://github.com/angular/angular/issues/13649)) ([5754ecc](https://github.com/angular/angular/commit/5754ecc)), closes [#12955](https://github.com/angular/angular/issues/12955)
+* **router:** routerLink support of null ([#13380](https://github.com/angular/angular/issues/13380)) ([018865e](https://github.com/angular/angular/commit/018865e)), closes [#6971](https://github.com/angular/angular/issues/6971)
+* **router:** update route snapshot before emit new values ([#13558](https://github.com/angular/angular/issues/13558)) ([9f6a647](https://github.com/angular/angular/commit/9f6a647)), closes [#12912](https://github.com/angular/angular/issues/12912)
+* **upgrade:** fix/improve support for lifecycle hooks ([#13020](https://github.com/angular/angular/issues/13020)) ([21942a8](https://github.com/angular/angular/commit/21942a8))
+
+
+
+<a name="2.4.1"></a>
+## [2.4.1](https://github.com/angular/angular/compare/2.4.0...2.4.1) (2016-12-21)
+
+### Bug Fixes
+
+* **animations:** always quote string map key values in AOT code ([#13602](https://github.com/angular/angular/issues/13602)) ([6a5e46c](https://github.com/angular/angular/commit/6a5e46c))
+* **animations:** always recover from a failed animation step ([#13604](https://github.com/angular/angular/issues/13604)) ([d788c67](https://github.com/angular/angular/commit/d788c67))
+* **compiler:** ignore `@import` in comments ([#13368](https://github.com/angular/angular/issues/13368)) ([6316e5d](https://github.com/angular/angular/commit/6316e5d)), closes [#12196](https://github.com/angular/angular/issues/12196)
+* **core:** improve error message when component factory cannot be found ([#13541](https://github.com/angular/angular/issues/13541)) ([b9e979e](https://github.com/angular/angular/commit/b9e979e)), closes [#12678](https://github.com/angular/angular/issues/12678)
+* **router:** should reset location if a navigation by location is successful ([#13545](https://github.com/angular/angular/issues/13545)) ([a38f14b](https://github.com/angular/angular/commit/a38f14b)), closes [#13491](https://github.com/angular/angular/issues/13491)
+
+
+
+<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)
 
@@ -20,25 +78,20 @@
 * **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)
-* **dom_adapter:** remove logError from logGroup ([#12925](https://github.com/angular/angular/issues/12925)) ([5fab871](https://github.com/angular/angular/commit/5fab871))
+* **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)
-* Better error when directive not listed in NgModule.declarations ([b0cd514](https://github.com/angular/angular/commit/b0cd514))
-* Better instructions on running examples and their tests ([203cc7e](https://github.com/angular/angular/commit/203cc7e))
+* **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)
-
-
-### Features
-
 * **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)
 
 
@@ -46,6 +99,16 @@
 
 * **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 2 for JS
+# Building and Testing Angular
 
-This document describes how to set up your development environment to build and test Angular 2 JS version. 
+This document describes how to set up your development environment to build and test Angular.
 It also explains the basic mechanics of using `git`, `node`, and `npm`.
 
 * [Prerequisite Software](#prerequisite-software)
@@ -74,6 +74,15 @@ use in these instructions.
 *Option 2*: defining a bash alias like `alias nbin='PATH=$(npm bin):$PATH'` as detailed in this
 [Stackoverflow answer](http://stackoverflow.com/questions/9679932/how-to-use-package-installed-locally-in-node-modules/15157360#15157360) and used like this: e.g., `nbin gulp build`.
 
+## Installing Bower Modules
+
+Now run `bower` to install additional dependencies:
+
+```shell
+# Install other Angular project dependencies (bower.json)
+bower install
+```
+
 ## Windows only
 
 In order to create the right symlinks, run **as administrator**:
@@ -124,7 +133,8 @@ If you happen to modify the public API of Angular, API golden files must be upda
 $ gulp public-api:update
 ```
 
-Note: The command `./test.sh tools` fails when the API doesn't match the golden files.
+Note: The command `gulp public-api:enforce` fails when the API doesn't match the golden files. Make sure to rebuild
+the project before trying to verify after an API change.
 
 ## <a name="clang-format"></a> Formatting your source code
 
@@ -137,4 +147,32 @@ You can automatically format your code by running:
 $ gulp format
 ```
 
+## Linting/verifying your source code
 
+You can check that your code is properly formatted and adheres to coding style by running:
+
+``` shell
+$ gulp lint
+```
+
+## 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]
+```
+
+The script will publish the build snapshot to a branch with the same name as your current branch,
+and create it if it doesn't exist.

karma-js.conf.js

@@ -24,17 +24,25 @@ 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.0-rc.4",
+    "rxjs": "^5.0.1",
     "jpm": "1.1.4",
     "firefox-profile": "0.4.0",
     "selenium-webdriver": "^2.53.3"

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

@@ -25,6 +25,8 @@ import {isPresent, stringify} from '../facade/lang';
  *     <some-element [ngClass]="{'first': true, 'second': true, 'third': false}">...</some-element>
  *
  *     <some-element [ngClass]="stringExp|arrayExp|objExp">...</some-element>
+ *
+ *     <some-element [ngClass]="{'class1 class2 class3' : true}">...</some-element>
  * ```
  *
  * @description

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

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {ChangeDetectorRef, CollectionChangeRecord, DefaultIterableDiffer, Directive, DoCheck, EmbeddedViewRef, Input, IterableDiffer, IterableDiffers, OnChanges, SimpleChanges, TemplateRef, TrackByFn, ViewContainerRef} from '@angular/core';
+import {ChangeDetectorRef, CollectionChangeRecord, DefaultIterableDiffer, Directive, DoCheck, EmbeddedViewRef, Input, IterableDiffer, IterableDiffers, OnChanges, SimpleChanges, TemplateRef, TrackByFn, ViewContainerRef, isDevMode} from '@angular/core';
 
 import {getTypeNameForDebugging} from '../facade/lang';
 
@@ -89,9 +89,23 @@ export class NgForRow {
 @Directive({selector: '[ngFor][ngForOf]'})
 export class NgFor implements DoCheck, OnChanges {
   @Input() ngForOf: any;
-  @Input() ngForTrackBy: TrackByFn;
+  @Input()
+  set ngForTrackBy(fn: TrackByFn) {
+    if (isDevMode() && fn != null && typeof fn !== 'function') {
+      // TODO(vicb): use a log service once there is a public one available
+      if (<any>console && <any>console.warn) {
+        console.warn(
+            `trackBy must be a function, but received ${JSON.stringify(fn)}. ` +
+            `See https://angular.io/docs/ts/latest/api/common/index/NgFor-directive.html#!#change-propagation for more information.`);
+      }
+    }
+    this._trackByFn = fn;
+  }
+
+  get ngForTrackBy(): TrackByFn { return this._trackByFn; }
 
   private _differ: IterableDiffer = null;
+  private _trackByFn: TrackByFn;
 
   constructor(
       private _viewContainer: ViewContainerRef, private _template: TemplateRef<NgForRow>,
@@ -119,7 +133,7 @@ export class NgFor implements DoCheck, OnChanges {
     }
   }
 
-  ngDoCheck() {
+  ngDoCheck(): void {
     if (this._differ) {
       const changes = this._differ.diff(this.ngForOf);
       if (changes) this._applyChanges(changes);

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

@@ -294,6 +294,27 @@ export function main() {
        }));
 
     describe('track by', () => {
+      it('should console.warn if trackBy is not a function', async(() => {
+           // TODO(vicb): expect a warning message when we have a proper log service
+           const template =
+               `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="value"></template>`;
+           fixture = createTestComponent(template);
+           fixture.componentInstance.value = 0;
+           fixture.detectChanges();
+         }));
+
+      it('should track by identity when trackBy is to `null` or `undefined`', async(() => {
+           // TODO(vicb): expect no warning message when we have a proper log service
+           const template =
+               `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="value">{{ item }}</template>`;
+           fixture = createTestComponent(template);
+           fixture.componentInstance.items = ['a', 'b', 'c'];
+           fixture.componentInstance.value = null;
+           detectChangesAndExpectText('abc');
+           fixture.componentInstance.value = undefined;
+           detectChangesAndExpectText('abc');
+         }));
+
       it('should set the context to the component instance', async(() => {
            const template =
                `<template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackByContext.bind(this)"></template>`;
@@ -333,6 +354,7 @@ export function main() {
            getComponent().items = [{'id': 'a', 'color': 'red'}];
            detectChangesAndExpectText('red');
          }));
+
       it('should move items around and keep them updated ', async(() => {
            const template =
                `<div><template ngFor let-item [ngForOf]="items" [ngForTrackBy]="trackById">{{item['color']}}</template></div>`;
@@ -368,6 +390,7 @@ class Foo {
 @Component({selector: 'test-cmp', template: ''})
 class TestComponent {
   @ContentChild(TemplateRef) contentTpl: TemplateRef<Object>;
+  value: any;
   items: any[] = [1, 2];
   trackById(index: number, item: any): string { return item['id']; }
   trackByIndex(index: number, item: any): number { return index; }
@@ -384,4 +407,4 @@ const TEMPLATE = '<div><span template="ngFor let item of items">{{item.toString(
 function createTestComponent(template: string = TEMPLATE): ComponentFixture<TestComponent> {
   return TestBed.overrideComponent(TestComponent, {set: {template: template}})
       .createComponent(TestComponent);
-}
+}

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

@@ -1,5 +1,5 @@
 <div>
-  <h1>hello world</h1>
+  <h1 i18n>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,10 +44,6 @@ 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/>
@@ -58,6 +54,10 @@ 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,7 +19,6 @@ 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
@@ -30,6 +29,7 @@ function main() {
 
   Promise.resolve()
       .then(() => codeGenTest())
+      .then(() => i18nTest())
       .then(() => lazyRoutesTest())
       .then(() => {
         console.log('All done!');
@@ -42,7 +42,6 @@ function main() {
       });
 }
 
-
 function codeGenTest() {
   const basePath = path.join(__dirname, '../ngtools_src');
   const project = path.join(basePath, 'tsconfig-build.json');
@@ -52,12 +51,9 @@ 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);
-      return delegateHost.writeFile.call(delegateHost, fileName, ...rest);
-    }
-  });
+  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;
@@ -112,6 +108,67 @@ 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,9 +27,14 @@ 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);
     }
@@ -45,16 +50,29 @@ function main() {
   config.ngOptions.generateCodeForLibraries = false;
 
   console.log(`>>> running codegen for ${project}`);
-  codegen(config, (host) => new AssertingHostContext())
+  codegen(
+      config,
+      (host) => {
+        host.writeFile = (fileName: string, content: string) => {
+          fileName = path.relative(basePath, fileName);
+          writtenFiles.push({fileName, content});
+        };
+        return 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);
       })
@@ -97,4 +115,11 @@ 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/integrationtest/third_party_src/tsconfig-build.json

@@ -15,6 +15,8 @@
     "declaration": true,
     "lib": ["es6", "dom"],
     "baseUrl": ".",
-    "outDir": "../node_modules/third_party"
-  }
+    "outDir": "../node_modules/third_party",
+     // Prevent scanning up the directory tree for types
+    "typeRoots": ["node_modules/@types"]
+ }
 }

modules/@angular/compiler-cli/integrationtest/tsconfig-build.json

@@ -14,7 +14,9 @@
     "rootDir": "",
     "declaration": true,
     "lib": ["es6", "dom"],
-    "baseUrl": "."
+    "baseUrl": ".",
+    // Prevent scanning up the directory tree for types
+    "typeRoots": ["node_modules/@types"]
   },
 
   "files": [

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

@@ -11,7 +11,6 @@
  * Intended to be used in a build step.
  */
 import * as compiler from '@angular/compiler';
-import {ViewEncapsulation} from '@angular/core';
 import {AngularCompilerOptions, NgcCliOptions} from '@angular/tsc-wrapped';
 import {readFileSync} from 'fs';
 import * as path from 'path';
@@ -19,11 +18,8 @@ import * as ts from 'typescript';
 
 import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
 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.
@@ -102,14 +98,8 @@ export class CodeGenerator {
       debug: options.debug === true,
       translations: transContent,
       i18nFormat: cliOptions.i18nFormat,
-      locale: cliOptions.locale,
-      excludeFilePattern: options.generateCodeForLibraries === false ? GENERATED_OR_DTS_FILES :
-                                                                       GENERATED_FILES
+      locale: cliOptions.locale
     });
     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,6 +16,8 @@ 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>;
@@ -28,6 +30,7 @@ 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,
@@ -38,12 +41,31 @@ 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) {
+  moduleNameToFileName(m: string, containingFile: string): string|null {
     if (!containingFile || !containingFile.length) {
       if (m.indexOf('.') === 0) {
         throw new Error('Resolution of relative paths requires a containing file.');
@@ -53,7 +75,8 @@ export class CompilerHost implements AotCompilerHost {
     }
     m = m.replace(EXT, '');
     const resolved =
-        ts.resolveModuleName(m, containingFile.replace(/\\/g, '/'), this.options, this.context)
+        ts.resolveModuleName(
+              m, containingFile.replace(/\\/g, '/'), this.options, this.resolveModuleNameHost)
             .resolvedModule;
     return resolved ? this.getCanonicalFileName(resolved.resolvedFileName) : null;
   };
@@ -158,6 +181,12 @@ 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);
@@ -173,35 +202,13 @@ export class CompilerHost implements AotCompilerHost {
     }
     try {
       const metadataOrMetadatas = JSON.parse(this.context.readFile(filePath));
-      const metadatas = metadataOrMetadatas ?
+      const metadatas: ModuleMetadata[] = metadataOrMetadatas ?
           (Array.isArray(metadataOrMetadatas) ? metadataOrMetadatas : [metadataOrMetadatas]) :
           [];
-      const v1Metadata = metadatas.find((m: any) => m['version'] === 1);
-      let v3Metadata = metadatas.find((m: any) => m['version'] === 3);
+      const v1Metadata = metadatas.find(m => m.version === 1);
+      let v3Metadata = metadatas.find(m => m.version === 3);
       if (!v3Metadata && v1Metadata) {
-        // 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);
+        metadatas.push(this.upgradeVersion1Metadata(v1Metadata, dtsFilePath));
       }
       this.resolverCache.set(filePath, metadatas);
       return metadatas;
@@ -211,13 +218,49 @@ 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 { return this.context.readFile(filePath); }
+  loadSummary(filePath: string): string|null {
+    if (this.context.fileExists(filePath)) {
+      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,41 +14,15 @@
 // 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) {
-  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);
-  });
+    program: ts.Program, host: ts.CompilerHost): Promise<void> {
+  return Extractor.create(ngOptions, program, host).extract(cliOptions.i18nFormat);
 }
 
 // Entry point

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

@@ -15,29 +15,74 @@ 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 {excludeFilePattern} from './codegen';
-import {CompilerHost, ModuleResolutionHostAdapter} from './compiler_host';
+import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
+import {PathMappedCompilerHost} from './path_mapped_compiler_host';
 
 export class Extractor {
   constructor(
-      private ngExtractor: compiler.Extractor, private ngCompilerHost: CompilerHost,
+      private options: tsc.AngularCompilerOptions, private ngExtractor: compiler.Extractor,
+      public host: ts.CompilerHost, private ngCompilerHost: CompilerHost,
       private program: ts.Program) {}
 
-  extract(): Promise<compiler.MessageBundle> {
-    return this.ngExtractor.extract(this.program.getSourceFiles().map(
-        sf => this.ngCompilerHost.getCanonicalFileName(sf.fileName)));
+  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}"');
   }
 
   static create(
-      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);
+      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);
   }
 }

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

@@ -14,6 +14,7 @@ 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(
@@ -28,7 +29,7 @@ export function main(
   const cliOptions = new tsc.NgcCliOptions(args);
 
   return tsc.main(project, cliOptions, codegen).then(() => 0).catch(e => {
-    if (e instanceof tsc.UserError) {
+    if (e instanceof tsc.UserError || e instanceof SyntaxError) {
       consoleError(e.message);
       return Promise.resolve(1);
     } else {

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

@@ -13,16 +13,16 @@
  * something else.
  */
 
-import {AotCompilerHost, StaticReflector} from '@angular/compiler';
+import {AotCompilerHost, AotSummaryResolver, StaticReflector, StaticSymbolCache, StaticSymbolResolver} 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,9 +50,18 @@ 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
@@ -94,7 +103,6 @@ export class NgTools_InternalApi_NG_2 {
     return codeGenerator.codegen();
   }
 
-
   /**
    * @internal
    * @private
@@ -111,7 +119,10 @@ export class NgTools_InternalApi_NG_2 {
         new PathMappedCompilerHost(program, angularCompilerOptions, moduleResolutionHost) :
         new CompilerHost(program, angularCompilerOptions, moduleResolutionHost);
 
-    const staticReflector = new StaticReflector(ngCompilerHost);
+    const symbolCache = new StaticSymbolCache();
+    const summaryResolver = new AotSummaryResolver(ngCompilerHost, symbolCache);
+    const symbolResolver = new StaticSymbolResolver(ngCompilerHost, symbolCache, summaryResolver);
+    const staticReflector = new StaticReflector(symbolResolver);
     const routeMap = listLazyRoutesOfModule(options.entryModule, ngCompilerHost, staticReflector);
 
     return Object.keys(routeMap).reduce(
@@ -121,4 +132,19 @@ 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/src/private_import_core.ts

@@ -9,10 +9,10 @@
 import {__core_private__ as r} from '@angular/core';
 
 export type ReflectorReader = typeof r._ReflectorReader;
-export var ReflectorReader: typeof r.ReflectorReader = r.ReflectorReader;
+export const ReflectorReader: typeof r.ReflectorReader = r.ReflectorReader;
 
 export type ReflectionCapabilities = typeof r._ReflectionCapabilities;
-export var ReflectionCapabilities: typeof r.ReflectionCapabilities = r.ReflectionCapabilities;
+export const ReflectionCapabilities: typeof r.ReflectionCapabilities = r.ReflectionCapabilities;
 
 export type Console = typeof r._Console;
-export var Console: typeof r.Console = r.Console;
+export const Console: typeof r.Console = r.Console;

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

@@ -6,6 +6,7 @@
  * 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';
@@ -150,12 +151,14 @@ describe('CompilerHost', () => {
 
   it('should be able to read a metadata file', () => {
     expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/core.d.ts')).toEqual([
-      {__symbolic: 'module', version: 2, metadata: {foo: {__symbolic: 'class'}}}
+      {__symbolic: 'module', version: 3, 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')).toBeUndefined();
+    expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/unused.d.ts')).toEqual([
+      dummyMetadata
+    ]);
   });
 
   it('should be able to read empty metadata ', () => {
@@ -181,10 +184,21 @@ 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': {
@@ -204,7 +218,7 @@ const FILES: Entry = {
         '@angular': {
           'core.d.ts': dummyModule,
           'core.metadata.json':
-              `{"__symbolic":"module", "version": 2, "metadata": {"foo": {"__symbolic": "class"}}}`,
+              `{"__symbolic":"module", "version": 3, "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;',
@@ -225,6 +239,9 @@ 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,13 +29,17 @@ describe('compiler-cli', () => {
         "types": [],
         "outDir": "built",
         "declaration": true,
-        "module": "es2015"
+        "module": "es2015",
+        "moduleResolution": "node"
       },
       "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-cli/test/mocks.ts

@@ -122,11 +122,9 @@ export class MockCompilerHost implements ts.CompilerHost {
     return ts.getDefaultLibFileName(options);
   }
 
-  writeFile: ts.WriteFileCallback = (fileName, text) => { this.context.writeFile(fileName, text); }
+  writeFile: ts.WriteFileCallback = (fileName, text) => { this.context.writeFile(fileName, text); };
 
-  getCurrentDirectory(): string {
-    return this.context.currentDirectory;
-  }
+  getCurrentDirectory(): string { return this.context.currentDirectory; }
 
   getCanonicalFileName(fileName: string): string { return fileName; }
 

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

@@ -9,5 +9,5 @@
 import {__core_private__ as r} from '@angular/core';
 
 export type ReflectionCapabilities = typeof r._ReflectionCapabilities;
-export var ReflectionCapabilities: typeof r.ReflectionCapabilities = r.ReflectionCapabilities;
-export var reflector: typeof r.reflector = r.reflector;
+export const ReflectionCapabilities: typeof r.ReflectionCapabilities = r.ReflectionCapabilities;
+export const reflector: typeof r.reflector = r.reflector;

modules/@angular/compiler/index.ts

@@ -32,7 +32,9 @@ 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';
@@ -60,4 +62,5 @@ export * from './src/style_compiler';
 export * from './src/template_parser/template_parser';
 export {ViewCompiler} from './src/view_compiler/view_compiler';
 export {AnimationParser} from './src/animation/animation_parser';
+export {SyntaxError} from './src/util';
 // This file only reexports content of the `src` folder. Keep it that way.

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

@@ -66,7 +66,7 @@ class _AnimationBuilder implements AnimationAstVisitor {
     ast.styles.forEach(entry => {
       const entries =
           Object.keys(entry).map((key): [string, o.Expression] => [key, o.literal(entry[key])]);
-      stylesArr.push(o.literalMap(entries));
+      stylesArr.push(o.literalMap(entries, null, true));
     });
 
     return o.importExpr(createIdentifier(Identifiers.AnimationStyles)).instantiate([
@@ -322,12 +322,13 @@ class _AnimationBuilder implements AnimationAstVisitor {
       if (isPresent(value)) {
         const styleMap: any[] = [];
         Object.keys(value).forEach(key => { styleMap.push([key, o.literal(value[key])]); });
-        variableValue = o.literalMap(styleMap);
+        variableValue = o.literalMap(styleMap, null, true);
       }
       lookupMap.push([stateName, variableValue]);
     });
 
-    const compiledStatesMapStmt = this._statesMapVar.set(o.literalMap(lookupMap)).toDeclStmt();
+    const compiledStatesMapStmt =
+        this._statesMapVar.set(o.literalMap(lookupMap, null, true)).toDeclStmt();
     const statements: o.Statement[] = [compiledStatesMapStmt, fnStatement];
 
     return new AnimationEntryCompileResult(this.animationName, statements, fnVariable);

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

@@ -6,11 +6,10 @@
  * 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';
@@ -35,7 +34,7 @@ export class AnimationEntryParseResult {
   constructor(public ast: AnimationEntryAst, public errors: AnimationParseError[]) {}
 }
 
-@Injectable()
+@CompilerInjectable()
 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 {AotCompilerOptions} from './compiler_options';
+import {AotCompilerHost} from './compiler_host';
 import {GeneratedFile} from './generated_file';
-import {StaticReflector} from './static_reflector';
 import {StaticSymbol} from './static_symbol';
-import {AotSummaryResolver} from './summary_resolver';
-import {filterFileByPatterns} from './utils';
+import {ResolvedStaticSymbol, StaticSymbolResolver} from './static_symbol_resolver';
+import {serializeSummaries, summaryFileName} from './summary_serializer';
 
 export class AotCompiler {
   private _animationCompiler = new AnimationCompiler();
 
   constructor(
-      private _metadataResolver: CompileMetadataResolver, private _templateParser: TemplateParser,
-      private _styleCompiler: StyleCompiler, private _viewCompiler: ViewCompiler,
-      private _dirWrapperCompiler: DirectiveWrapperCompiler,
+      private _host: AotCompilerHost, private _metadataResolver: CompileMetadataResolver,
+      private _templateParser: TemplateParser, private _styleCompiler: StyleCompiler,
+      private _viewCompiler: ViewCompiler, private _dirWrapperCompiler: DirectiveWrapperCompiler,
       private _ngModuleCompiler: NgModuleCompiler, private _outputEmitter: OutputEmitter,
-      private _summaryResolver: AotSummaryResolver, private _localeId: string,
+      private _summaryResolver: SummaryResolver<StaticSymbol>, private _localeId: string,
       private _translationFormat: string, private _animationParser: AnimationParser,
-      private _staticReflector: StaticReflector, private _options: AotCompilerOptions) {}
+      private _symbolResolver: StaticSymbolResolver) {}
 
   clearCache() { this._metadataResolver.clearCache(); }
 
   compileAll(rootFiles: string[]): Promise<GeneratedFile[]> {
-    const programSymbols = extractProgramSymbols(this._staticReflector, rootFiles, this._options);
+    const programSymbols = extractProgramSymbols(this._symbolResolver, rootFiles, this._host);
     const {ngModuleByPipeOrDirective, files, ngModules} =
-        analyzeAndValidateNgModules(programSymbols, this._options, this._metadataResolver);
+        analyzeAndValidateNgModules(programSymbols, this._host, this._metadataResolver);
     return Promise
         .all(ngModules.map(
             ngModule => this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(
@@ -56,27 +56,21 @@ export class AotCompiler {
           const sourceModules = files.map(
               file => this._compileSrcFile(
                   file.srcUrl, ngModuleByPipeOrDirective, file.directives, file.pipes,
-                  file.ngModules));
+                  file.ngModules, file.injectables));
           return ListWrapper.flatten(sourceModules);
         });
   }
 
   private _compileSrcFile(
       srcFileUrl: string, ngModuleByPipeOrDirective: Map<StaticSymbol, CompileNgModuleMetadata>,
-      directives: StaticSymbol[], pipes: StaticSymbol[],
-      ngModules: StaticSymbol[]): GeneratedFile[] {
+      directives: StaticSymbol[], pipes: StaticSymbol[], ngModules: StaticSymbol[],
+      injectables: StaticSymbol[]): GeneratedFile[] {
     const fileSuffix = _splitTypescriptSuffix(srcFileUrl)[1];
     const statements: o.Statement[] = [];
     const exportedVars: string[] = [];
     const generatedFiles: GeneratedFile[] = [];
 
-    // 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));
+    generatedFiles.push(this._createSummary(srcFileUrl, directives, pipes, ngModules, injectables));
 
     // compile all ng modules
     exportedVars.push(
@@ -121,6 +115,22 @@ 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[] = [];
@@ -142,7 +152,7 @@ export class AotCompiler {
     const appCompileResult = this._ngModuleCompiler.compile(ngModule, providers);
 
     appCompileResult.dependencies.forEach((dep) => {
-      dep.placeholder.reference = this._staticReflector.getStaticSymbol(
+      dep.placeholder.reference = this._symbolResolver.getStaticSymbol(
           _ngfactoryModuleUrl(identifierModuleUrl(dep.comp)), _componentFactoryName(dep.comp));
     });
 
@@ -163,7 +173,7 @@ export class AotCompiler {
       compMeta: CompileDirectiveMetadata, ngModule: CompileNgModuleMetadata, fileSuffix: string,
       targetStatements: o.Statement[]): string {
     const hostMeta = createHostComponentMeta(
-        this._staticReflector.getStaticSymbol(
+        this._symbolResolver.getStaticSymbol(
             identifierModuleUrl(compMeta.type), `${identifierName(compMeta.type)}_Host`),
         compMeta);
     const hostViewFactoryVar = this._compileComponent(
@@ -206,16 +216,16 @@ export class AotCompiler {
         compMeta, parsedTemplate, stylesExpr, pipes, compiledAnimations);
     if (componentStyles) {
       targetStatements.push(
-          ..._resolveStyleStatements(this._staticReflector, componentStyles, fileSuffix));
+          ..._resolveStyleStatements(this._symbolResolver, componentStyles, fileSuffix));
     }
     compiledAnimations.forEach(entry => targetStatements.push(...entry.statements));
-    targetStatements.push(..._resolveViewStatements(this._staticReflector, viewResult));
+    targetStatements.push(..._resolveViewStatements(this._symbolResolver, viewResult));
     return viewResult.viewClassVar;
   }
 
   private _codgenStyles(
       fileUrl: string, stylesCompileResult: CompiledStylesheet, fileSuffix: string): GeneratedFile {
-    _resolveStyleStatements(this._staticReflector, stylesCompileResult, fileSuffix);
+    _resolveStyleStatements(this._symbolResolver, stylesCompileResult, fileSuffix);
     return this._codegenSourceModule(
         fileUrl, _stylesModuleUrl(
                      stylesCompileResult.meta.moduleUrl, stylesCompileResult.isShimmed, fileSuffix),
@@ -232,7 +242,7 @@ export class AotCompiler {
 }
 
 function _resolveViewStatements(
-    reflector: StaticReflector, compileResult: ViewCompileResult): o.Statement[] {
+    reflector: StaticSymbolResolver, compileResult: ViewCompileResult): o.Statement[] {
   compileResult.dependencies.forEach((dep) => {
     if (dep instanceof ViewClassDependency) {
       const vfd = <ViewClassDependency>dep;
@@ -253,7 +263,7 @@ function _resolveViewStatements(
 
 
 function _resolveStyleStatements(
-    reflector: StaticReflector, compileResult: CompiledStylesheet,
+    reflector: StaticSymbolResolver, compileResult: CompiledStylesheet,
     fileSuffix: string): o.Statement[] {
   compileResult.dependencies.forEach((dep) => {
     dep.valuePlaceholder.reference = reflector.getStaticSymbol(
@@ -303,26 +313,27 @@ export interface NgAnalyzedModules {
     srcUrl: string,
     directives: StaticSymbol[],
     pipes: StaticSymbol[],
-    ngModules: StaticSymbol[]
+    ngModules: StaticSymbol[],
+    injectables: 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[],
-    options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp},
+    programStaticSymbols: StaticSymbol[], host: NgAnalyzeModulesHost,
     metadataResolver: CompileMetadataResolver): NgAnalyzedModules {
   const {ngModules, symbolsMissingModule} =
-      _createNgModules(programStaticSymbols, options, metadataResolver);
-  return _analyzeNgModules(ngModules, symbolsMissingModule);
+      _createNgModules(programStaticSymbols, host, metadataResolver);
+  return _analyzeNgModules(programStaticSymbols, ngModules, symbolsMissingModule, metadataResolver);
 }
 
 export function analyzeAndValidateNgModules(
-    programStaticSymbols: StaticSymbol[],
-    options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp},
+    programStaticSymbols: StaticSymbol[], host: NgAnalyzeModulesHost,
     metadataResolver: CompileMetadataResolver): NgAnalyzedModules {
-  const result = analyzeNgModules(programStaticSymbols, options, metadataResolver);
+  const result = analyzeNgModules(programStaticSymbols, host, metadataResolver);
   if (result.symbolsMissingModule && result.symbolsMissingModule.length) {
     const messages = result.symbolsMissingModule.map(
         s => `Cannot determine the module for class ${s.name} in ${s.filePath}!`);
@@ -332,16 +343,27 @@ export function analyzeAndValidateNgModules(
 }
 
 function _analyzeNgModules(
-    ngModuleMetas: CompileNgModuleMetadata[],
-    symbolsMissingModule: StaticSymbol[]): NgAnalyzedModules {
+    programSymbols: StaticSymbol[], ngModuleMetas: CompileNgModuleMetadata[],
+    symbolsMissingModule: StaticSymbol[],
+    metadataResolver: CompileMetadataResolver): 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`,
@@ -369,17 +391,20 @@ function _analyzeNgModules(
     });
   });
 
-  const files:
-      {srcUrl: string,
-       directives: StaticSymbol[],
-       pipes: StaticSymbol[],
-       ngModules: StaticSymbol[]}[] = [];
+  const files: {
+    srcUrl: string,
+    directives: StaticSymbol[],
+    pipes: StaticSymbol[],
+    ngModules: StaticSymbol[],
+    injectables: StaticSymbol[]
+  }[] = [];
 
   filePaths.forEach((srcUrl) => {
     const directives = ngDirectivesByFile.get(srcUrl) || [];
     const pipes = ngPipesByFile.get(srcUrl) || [];
     const ngModules = ngModulesByFile.get(srcUrl) || [];
-    files.push({srcUrl, directives, pipes, ngModules});
+    const injectables = ngInjectablesByFile.get(srcUrl) || [];
+    files.push({srcUrl, directives, pipes, ngModules, injectables});
   });
 
   return {
@@ -392,29 +417,20 @@ function _analyzeNgModules(
 }
 
 export function extractProgramSymbols(
-    staticReflector: StaticReflector, files: string[],
-    options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp} = {}): StaticSymbol[] {
+    staticSymbolResolver: StaticSymbolResolver, files: string[],
+    host: NgAnalyzeModulesHost): StaticSymbol[] {
   const staticSymbols: StaticSymbol[] = [];
-  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;
+  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);
+        }
       }
-      staticSymbols.push(staticReflector.getStaticSymbol(sourceFile, symbol));
-    }
+    });
   });
 
   return staticSymbols;
@@ -424,8 +440,7 @@ export function extractProgramSymbols(
 // that all directives / pipes that are present in the program
 // are also declared by a module.
 function _createNgModules(
-    programStaticSymbols: StaticSymbol[],
-    options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp},
+    programStaticSymbols: StaticSymbol[], host: NgAnalyzeModulesHost,
     metadataResolver: CompileMetadataResolver):
     {ngModules: CompileNgModuleMetadata[], symbolsMissingModule: StaticSymbol[]} {
   const ngModules = new Map<any, CompileNgModuleMetadata>();
@@ -433,7 +448,7 @@ function _createNgModules(
   const ngModulePipesAndDirective = new Set<StaticSymbol>();
 
   const addNgModule = (staticSymbol: any) => {
-    if (ngModules.has(staticSymbol) || !filterFileByPatterns(staticSymbol.filePath, options)) {
+    if (ngModules.has(staticSymbol) || !host.isSourceFile(staticSymbol.filePath)) {
       return false;
     }
     const ngModule = metadataResolver.getNgModuleMetadata(staticSymbol, false);

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

@@ -34,8 +34,11 @@ 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.
  */
@@ -44,7 +47,10 @@ export function createAotCompiler(compilerHost: AotCompilerHost, options: AotCom
   let translations: string = options.translations || '';
 
   const urlResolver = createOfflineCompileUrlResolver();
-  const staticReflector = new StaticReflector(compilerHost);
+  const symbolCache = new StaticSymbolCache();
+  const summaryResolver = new AotSummaryResolver(compilerHost, symbolCache);
+  const symbolResolver = new StaticSymbolResolver(compilerHost, symbolCache, summaryResolver);
+  const staticReflector = new StaticReflector(symbolResolver);
   StaticAndDynamicReflectionCapabilities.install(staticReflector);
   const htmlParser = new I18NHtmlParser(new HtmlParser(), translations, options.i18nFormat);
   const config = new CompilerConfig({
@@ -60,17 +66,16 @@ 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(
-      resolver, tmplParser, new StyleCompiler(urlResolver),
+      compilerHost, 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), staticReflector, options);
+      options.i18nFormat, new AnimationParser(elementSchemaRegistry), symbolResolver);
   return {compiler, reflector: staticReflector};
 }

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

@@ -8,16 +8,17 @@
 
 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 StaticReflectorHost, ImportResolver,
-    AotSummaryResolverHost {
+export interface AotCompilerHost extends StaticSymbolResolverHost, ImportResolver,
+    AotSummaryResolverHost, AotSummarySerializerHost {
   /**
    * Loads a resource (e.g. html / css)
    */

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

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

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

@@ -8,6 +8,7 @@
 
 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) {
@@ -42,7 +43,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, runtime);
+    return this.staticDelegate.resolveIdentifier(name, moduleUrl);
   }
   resolveEnum(enumIdentifier: any, name: string): any {
     if (isStaticType(enumIdentifier)) {

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

@@ -7,10 +7,12 @@
  */
 
 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';
 
-const SUPPORTED_SCHEMA_VERSION = 3;
+import {ReflectorReader} from '../private_import_core';
+
+import {StaticSymbol, StaticSymbolCache} from './static_symbol';
+import {ResolvedStaticSymbol, StaticSymbolResolver} from './static_symbol_resolver';
+
 const ANGULAR_IMPORT_LOCATIONS = {
   coreDecorators: '@angular/core/src/metadata',
   diDecorators: '@angular/core/src/di/metadata',
@@ -22,66 +24,20 @@ 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 host: StaticReflectorHost,
-      private staticSymbolCache: StaticSymbolCache = new StaticSymbolCache(),
+      private symbolResolver: StaticSymbolResolver,
       knownMetadataClasses: {name: string, filePath: string, ctor: any}[] = [],
       knownMetadataFunctions: {name: string, filePath: string, fn: any}[] = [],
       private errorRecorder?: (error: any, fileName: string) => void) {
@@ -94,12 +50,26 @@ export class StaticReflector implements ReflectorReader {
   }
 
   importUri(typeOrFunc: StaticSymbol): string {
-    const staticSymbol = this.findDeclaration(typeOrFunc.filePath, typeOrFunc.name, '');
+    const staticSymbol = this.findSymbolDeclaration(typeOrFunc);
     return staticSymbol ? staticSymbol.filePath : null;
   }
 
-  resolveIdentifier(name: string, moduleUrl: string, runtime: any): any {
-    return this.findDeclaration(moduleUrl, name, '');
+  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;
+    }
   }
 
   resolveEnum(enumIdentifier: any, name: string): any {
@@ -128,7 +98,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']));
@@ -203,7 +173,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']));
@@ -306,7 +276,7 @@ export class StaticReflector implements ReflectorReader {
    * @param name the name of the type.
    */
   getStaticSymbol(declarationFile: string, name: string, members?: string[]): StaticSymbol {
-    return this.staticSymbolCache.get(declarationFile, name, members);
+    return this.symbolResolver.getStaticSymbol(declarationFile, name, members);
   }
 
   private reportError(error: Error, context: StaticSymbol, path?: string) {
@@ -317,96 +287,6 @@ 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;
@@ -414,93 +294,41 @@ export class StaticReflector implements ReflectorReader {
     const calling = new Map<StaticSymbol, boolean>();
 
     function simplifyInContext(context: StaticSymbol, value: any, depth: number): any {
-      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 resolveReferenceValue(staticSymbol: StaticSymbol): any {
-        const moduleMetadata = self.getModuleMetadata(staticSymbol.filePath);
-        const declarationValue =
-            moduleMetadata ? moduleMetadata['metadata'][staticSymbol.name] : null;
-        return declarationValue;
+        const resolvedSymbol = self.symbolResolver.resolveSymbol(staticSymbol);
+        return resolvedSymbol ? resolvedSymbol.metadata : null;
       }
 
-      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);
+      function simplifyCall(functionSymbol: StaticSymbol, targetFunction: any, args: any[]) {
+        if (targetFunction && targetFunction['__symbolic'] == 'function') {
+          if (calling.get(functionSymbol)) {
+            throw new Error('Recursion not supported');
           }
-        }
-        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;
+          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)));
               }
-            } finally {
-              calling.delete(functionSymbol);
+              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);
           }
         }
 
@@ -511,7 +339,7 @@ export class StaticReflector implements ReflectorReader {
           return {__symbolic: 'ignore'};
         }
         return simplify(
-            {__symbolic: 'error', message: 'Function call not supported', context: callContext});
+            {__symbolic: 'error', message: 'Function call not supported', context: functionSymbol});
       }
 
       function simplify(expression: any): any {
@@ -540,7 +368,18 @@ export class StaticReflector implements ReflectorReader {
           return result;
         }
         if (expression instanceof StaticSymbol) {
-          return expression;
+          // 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;
+            }
+          }
         }
         if (expression) {
           if (expression['__symbolic']) {
@@ -618,50 +457,33 @@ 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) {
-                  // 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);
+                  const members = selectTarget.members.concat(member);
                   selectContext =
                       self.getStaticSymbol(selectTarget.filePath, selectTarget.name, members);
-                  if (declarationValue && declarationValue.statics) {
-                    selectTarget = declarationValue.statics;
+                  const declarationValue = resolveReferenceValue(selectContext);
+                  if (declarationValue) {
+                    return simplifyInContext(selectContext, declarationValue, depth + 1);
                   } 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':
-                if (!expression['name']) {
-                  return context;
+                // 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.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;
+                break;
               case 'class':
                 return context;
               case 'function':
@@ -669,26 +491,26 @@ export class StaticReflector implements ReflectorReader {
               case 'new':
               case 'call':
                 // Determine if the function is a built-in conversion
-                let target = expression['expression'];
-                if (target['module']) {
-                  staticSymbol =
-                      self.findDeclaration(target['module'], target['name'], context.filePath);
-                } else {
-                  staticSymbol = self.getStaticSymbol(context.filePath, target['name']);
-                }
-                let converter = self.conversionMap.get(staticSymbol);
-                if (converter) {
-                  let args: any[] = expression['arguments'];
-                  if (!args) {
-                    args = [];
+                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);
                   }
-                  return converter(
-                      context, args.map(arg => simplifyInContext(context, arg, depth + 1)));
                 }
-
-                // Determine if the function is one we can simplify.
-                return simplifyCall(expression);
-
+                break;
               case 'error':
                 let message = produceErrorMessage(expression);
                 if (expression['line']) {
@@ -709,7 +531,9 @@ export class StaticReflector implements ReflectorReader {
       try {
         return simplify(value);
       } catch (e) {
-        const message = `${e.message}, resolving symbol ${context.name} in ${context.filePath}`;
+        const members = context.members.length ? `.${context.members.join('.')}` : '';
+        const message =
+            `${e.message}, resolving symbol ${context.name}${members} in ${context.filePath}`;
         if (e.fileName) {
           throw positionalError(message, e.fileName, e.line, e.column);
         }
@@ -733,40 +557,10 @@ 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 moduleMetadata = this.getModuleMetadata(type.filePath);
-    return moduleMetadata['metadata'][type.name] || {__symbolic: 'class'};
+    const resolvedSymbol = this.symbolResolver.resolveSymbol(type);
+    return resolvedSymbol && resolvedSymbol.metadata ? resolvedSymbol.metadata :
+                                                       {__symbolic: 'class'};
   }
 }
 
@@ -858,7 +652,7 @@ class PopulatedScope extends BindingScope {
 }
 
 function sameSymbol(a: StaticSymbol, b: StaticSymbol): boolean {
-  return a === b || (a.name == b.name && a.filePath == b.filePath);
+  return a === b;
 }
 
 function shouldIgnore(value: any): boolean {

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

@@ -14,3 +14,23 @@
 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

@@ -0,0 +1,289 @@
+/**
+ * @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,13 +5,12 @@
  * 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 {SummaryResolver} from '../summary_resolver';
+import {CompileSummaryKind, CompileTypeSummary} from '../compile_metadata';
+import {Summary, SummaryResolver} from '../summary_resolver';
 
-import {GeneratedFile} from './generated_file';
-import {StaticReflector} from './static_reflector';
-import {StaticSymbol} from './static_symbol';
-import {filterFileByPatterns} from './utils';
+import {StaticSymbol, StaticSymbolCache} from './static_symbol';
+import {ResolvedStaticSymbol} from './static_symbol_resolver';
+import {deserializeSummaries, summaryFileName} from './summary_serializer';
 
 const STRIP_SRC_FILE_SUFFIXES = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
 
@@ -19,106 +18,60 @@ export interface AotSummaryResolverHost {
   /**
    * Loads an NgModule/Directive/Pipe summary file
    */
-  loadSummary(filePath: string): string;
+  loadSummary(filePath: string): string /*|null*/;
 
   /**
-   * Returns the output file path of a source file.
-   * E.g.
-   * `some_file.ts` -> `some_file.d.ts`
+   * Returns whether a file is a source file or not.
    */
-  getOutputFileName(sourceFilePath: string): string;
+  isSourceFile(sourceFilePath: string): boolean;
 }
 
-export interface AotSummaryResolverOptions {
-  includeFilePattern?: RegExp;
-  excludeFilePattern?: RegExp;
-}
+export class AotSummaryResolver implements SummaryResolver<StaticSymbol> {
+  private summaryCache = new Map<StaticSymbol, Summary<StaticSymbol>>();
+  private loadedFilePaths = new Set<string>();
 
-export class AotSummaryResolver implements SummaryResolver {
-  private summaryCache: {[cacheKey: string]: CompileTypeSummary} = {};
+  constructor(private host: AotSummaryResolverHost, private staticSymbolCache: StaticSymbolCache) {}
 
-  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));
+  private _assertNoMembers(symbol: StaticSymbol) {
+    if (symbol.members.length) {
+      throw new Error(
+          `Internal state: StaticSymbols in summaries can't have members! ${JSON.stringify(symbol)}`);
+    }
   }
 
-  private _cacheKey(symbol: StaticSymbol) { return `${symbol.filePath}|${symbol.name}`; }
+  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;
+  }
 
-  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];
+  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)) {
       const summaryFilePath = summaryFileName(filePath);
-      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;
-        }
+      let json: string;
+      try {
+        json = this.host.loadSummary(summaryFilePath);
+      } catch (e) {
+        console.error(`Error loading summary file ${summaryFilePath}`);
+        throw e;
       }
-      if (!summary) {
-        throw new Error(
-            `Could not find the symbol ${name} in the summary file ${summaryFilePath}!`);
+      if (json) {
+        const readSummaries = deserializeSummaries(this.staticSymbolCache, json);
+        readSummaries.forEach((summary) => { this.summaryCache.set(summary.symbol, summary); });
       }
-      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

@@ -0,0 +1,183 @@
+/**
+ * @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

@@ -1,19 +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
- */
-
-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
+  NgModule,
+  Injectable
 }
 
 /**
@@ -126,9 +126,10 @@ export enum CompileSummaryKind {
  * in other modules / components. However, this data is not enough to compile
  * the directive / module itself.
  */
-export interface CompileSummary { summaryKind: CompileSummaryKind; }
-
-export interface CompileTypeSummary extends CompileSummary { type: CompileTypeMetadata; }
+export interface CompileTypeSummary {
+  summaryKind: CompileSummaryKind;
+  type: CompileTypeMetadata;
+}
 
 export interface CompileDiDependencyMetadata {
   isAttribute?: boolean;
@@ -210,7 +211,7 @@ export class CompileStylesheetMetadata {
 /**
  * Summary Metadata regarding compilation of a template.
  */
-export interface CompileTemplateSummary extends CompileSummary {
+export interface CompileTemplateSummary {
   animations: string[];
   ngContentSelectors: string[];
   encapsulation: ViewEncapsulation;
@@ -258,7 +259,6 @@ 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,11 +6,12 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Component, Injectable, ViewEncapsulation} from '@angular/core';
+import {Component, 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';
@@ -18,7 +19,7 @@ import {ResourceLoader} from './resource_loader';
 import {extractStyleUrls, isStyleUrlResolvable} from './style_url_resolver';
 import {PreparsedElementType, preparseElement} from './template_parser/template_preparser';
 import {UrlResolver} from './url_resolver';
-import {SyncAsyncResult} from './util';
+import {SyncAsyncResult, SyntaxError} from './util';
 
 export interface PrenormalizedTemplateMetadata {
   componentType: any;
@@ -32,7 +33,7 @@ export interface PrenormalizedTemplateMetadata {
   animations?: CompileAnimationEntryMetadata[];
 }
 
-@Injectable()
+@CompilerInjectable()
 export class DirectiveNormalizer {
   private _resourceLoaderCache = new Map<string, Promise<string>>();
 
@@ -70,7 +71,7 @@ export class DirectiveNormalizer {
     } else if (prenormData.templateUrl) {
       normalizedTemplateAsync = this.normalizeTemplateAsync(prenormData);
     } else {
-      throw new Error(
+      throw new SyntaxError(
           `No template specified for component ${stringify(prenormData.componentType)}`);
     }
 
@@ -104,7 +105,7 @@ export class DirectiveNormalizer {
         template, stringify(prenomData.componentType), false, interpolationConfig);
     if (rootNodesAndErrors.errors.length > 0) {
       const errorString = rootNodesAndErrors.errors.join('\n');
-      throw new Error(`Template parse errors:\n${errorString}`);
+      throw new SyntaxError(`Template parse errors:\n${errorString}`);
     }
     const templateMetadataStyles = this.normalizeStylesheet(new CompileStylesheetMetadata({
       styles: prenomData.styles,

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

@@ -6,14 +6,16 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Component, Directive, HostBinding, HostListener, Injectable, Input, Output, Query, Type, resolveForwardRef} from '@angular/core';
+import {Component, Directive, HostBinding, HostListener, 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}.
  *
@@ -21,7 +23,7 @@ import {splitAtColon} from './util';
  *
  * See {@link Compiler}
  */
-@Injectable()
+@CompilerInjectable()
 export class DirectiveResolver {
   constructor(private _reflector: ReflectorReader = reflector) {}
 

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

@@ -6,8 +6,6 @@
  * 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';
@@ -15,11 +13,12 @@ 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';
 import {ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan} from './parse_util';
-import {Console, LifecycleHooks, isDefaultChangeDetectionStrategy} from './private_import_core';
+import {Console, LifecycleHooks} from './private_import_core';
 import {ElementSchemaRegistry} from './schema/element_schema_registry';
 import {BindingParser} from './template_parser/binding_parser';
 import {BoundElementPropertyAst, BoundEventAst} from './template_parser/template_ast';
@@ -51,7 +50,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.
  */
-@Injectable()
+@CompilerInjectable()
 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'];
 
-@Injectable()
+@CompilerInjectable()
 export class Lexer {
   tokenize(text: string): Token[] {
     const scanner = new _Scanner(text);
@@ -120,7 +120,7 @@ function newErrorToken(index: number, message: string): Token {
   return new Token(index, TokenType.Error, 0, message);
 }
 
-export var EOF: Token = new Token(-1, TokenType.Character, 0, '');
+export const EOF: Token = new Token(-1, TokenType.Character, 0, '');
 
 class _Scanner {
   length: number;

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

@@ -6,10 +6,9 @@
  * 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';
@@ -31,7 +30,7 @@ function _createInterpolateRegExp(config: InterpolationConfig): RegExp {
   return new RegExp(pattern, 'g');
 }
 
-@Injectable()
+@CompilerInjectable()
 export class Parser {
   private errors: ParserError[] = [];
 

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

@@ -14,7 +14,9 @@ import {ViewEncapsulation} from '@angular/core';
 
 import {analyzeAndValidateNgModules, extractProgramSymbols} from '../aot/compiler';
 import {StaticAndDynamicReflectionCapabilities} from '../aot/static_reflection_capabilities';
-import {StaticReflector, StaticReflectorHost} from '../aot/static_reflector';
+import {StaticReflector} from '../aot/static_reflector';
+import {StaticSymbolCache} from '../aot/static_symbol';
+import {StaticSymbolResolver, StaticSymbolResolverHost} from '../aot/static_symbol_resolver';
 import {AotSummaryResolver, AotSummaryResolverHost} from '../aot/summary_resolver';
 import {CompileDirectiveMetadata} from '../compile_metadata';
 import {CompilerConfig} from '../config';
@@ -26,23 +28,17 @@ 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 StaticReflectorHost, AotSummaryResolverHost {
+export interface ExtractorHost extends StaticSymbolResolverHost, AotSummaryResolverHost {
   /**
    * Loads a resource (e.g. html / css)
    */
@@ -51,14 +47,13 @@ export interface ExtractorHost extends StaticReflectorHost, AotSummaryResolverHo
 
 export class Extractor {
   constructor(
-      private options: ExtractorOptions, public host: ExtractorHost,
-      private staticReflector: StaticReflector, private messageBundle: MessageBundle,
-      private metadataResolver: CompileMetadataResolver) {}
+      public host: ExtractorHost, private staticSymbolResolver: StaticSymbolResolver,
+      private messageBundle: MessageBundle, private metadataResolver: CompileMetadataResolver) {}
 
   extract(rootFiles: string[]): Promise<MessageBundle> {
-    const programSymbols = extractProgramSymbols(this.staticReflector, rootFiles, this.options);
+    const programSymbols = extractProgramSymbols(this.staticSymbolResolver, rootFiles, this.host);
     const {ngModuleByPipeOrDirective, files, ngModules} =
-        analyzeAndValidateNgModules(programSymbols, this.options, this.metadataResolver);
+        analyzeAndValidateNgModules(programSymbols, this.host, this.metadataResolver);
     return Promise
         .all(ngModules.map(
             ngModule => this.metadataResolver.loadNgModuleDirectiveAndPipeMetadata(
@@ -91,12 +86,14 @@ export class Extractor {
         });
   }
 
-  static create(host: ExtractorHost, options: ExtractorOptions):
-      {extractor: Extractor, staticReflector: StaticReflector} {
+  static create(host: ExtractorHost): {extractor: Extractor, staticReflector: StaticReflector} {
     const htmlParser = new I18NHtmlParser(new HtmlParser());
 
     const urlResolver = createOfflineCompileUrlResolver();
-    const staticReflector = new StaticReflector(host);
+    const symbolCache = new StaticSymbolCache();
+    const summaryResolver = new AotSummaryResolver(host, symbolCache);
+    const staticSymbolResolver = new StaticSymbolResolver(host, symbolCache, summaryResolver);
+    const staticReflector = new StaticReflector(staticSymbolResolver);
     StaticAndDynamicReflectionCapabilities.install(staticReflector);
 
     const config = new CompilerConfig({
@@ -111,13 +108,13 @@ export class Extractor {
     const elementSchemaRegistry = new DomElementSchemaRegistry();
     const resolver = new CompileMetadataResolver(
         new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector),
-        new PipeResolver(staticReflector), new AotSummaryResolver(host, staticReflector, options),
-        elementSchemaRegistry, normalizer, staticReflector);
+        new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer,
+        staticReflector);
 
     // TODO(vicb): implicit tags & attributes
     const messageBundle = new MessageBundle(htmlParser, [], {});
 
-    const extractor = new Extractor(options, host, staticReflector, messageBundle, resolver);
+    const extractor = new Extractor(host, staticSymbolResolver, messageBundle, resolver);
     return {extractor, staticReflector};
   }
 }

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

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-export {Extractor, ExtractorHost, ExtractorOptions} from './extractor';
+export {Extractor, ExtractorHost} 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,6 +39,7 @@ 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);
@@ -71,7 +72,7 @@ export class Xmb implements Serializer {
       new xml.CR(),
       new xml.Doctype(_MESSAGES_TAG, _DOCTYPE),
       new xml.CR(),
-      rootNode,
+      exampleVisitor.addDefaultExamples(rootNode),
       new xml.CR(),
     ]);
   }
@@ -133,4 +134,27 @@ 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

@@ -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
+ */
+
+/**
+ * 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, Injectable, Injector, ModuleWithComponentFactories, NgModuleFactory, SchemaMetadata, Type} from '@angular/core';
+import {Compiler, ComponentFactory, Injector, ModuleWithComponentFactories, NgModuleFactory, SchemaMetadata, Type} from '@angular/core';
 
 import {AnimationCompiler} from '../animation/animation_compiler';
 import {AnimationParser} from '../animation/animation_parser';
@@ -15,6 +15,7 @@ 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';
@@ -36,7 +37,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).
  */
-@Injectable()
+@CompilerInjectable()
 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, Injectable, Optional, PLATFORM_INITIALIZER, PlatformRef, Provider, ReflectiveInjector, TRANSLATIONS, TRANSLATIONS_FORMAT, Type, ViewEncapsulation, createPlatformFactory, isDevMode, platformCore} from '@angular/core';
+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 {AnimationParser} from '../animation/animation_parser';
 import {CompilerConfig} from '../config';
@@ -16,6 +16,7 @@ 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';
@@ -83,7 +84,7 @@ export const COMPILER_PROVIDERS: Array<any|Type<any>|{[k: string]: any}|any[]> =
 ];
 
 
-@Injectable()
+@CompilerInjectable()
 export class JitCompilerFactory implements CompilerFactory {
   private _defaultOptions: CompilerOptions[];
   constructor(@Inject(COMPILER_OPTIONS) defaultOptions: CompilerOptions[]) {

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

@@ -16,6 +16,7 @@ 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';
@@ -23,7 +24,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, ValueTransformer, visitValue} from './util';
+import {MODULE_SUFFIX, SyncAsyncResult, SyntaxError, ValueTransformer, visitValue} from './util';
 
 export type ErrorCollector = (error: any, type?: any) => void;
 export const ERROR_COLLECTOR_TOKEN = new OpaqueToken('ErrorCollector');
@@ -35,7 +36,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.
-@Injectable()
+@CompilerInjectable()
 export class CompileMetadataResolver {
   private _directiveCache = new Map<Type<any>, cpl.CompileDirectiveMetadata>();
   private _summaryCache = new Map<Type<any>, cpl.CompileTypeSummary>();
@@ -45,7 +46,7 @@ export class CompileMetadataResolver {
 
   constructor(
       private _ngModuleResolver: NgModuleResolver, private _directiveResolver: DirectiveResolver,
-      private _pipeResolver: PipeResolver, private _summaryResolver: SummaryResolver,
+      private _pipeResolver: PipeResolver, private _summaryResolver: SummaryResolver<any>,
       private _schemaRegistry: ElementSchemaRegistry,
       private _directiveNormalizer: DirectiveNormalizer,
       private _reflector: ReflectorReader = reflector,
@@ -128,12 +129,13 @@ export class CompileMetadataResolver {
   }
 
   private _loadSummary(type: any, kind: cpl.CompileSummaryKind): cpl.CompileTypeSummary {
-    let summary = this._summaryCache.get(type);
-    if (!summary) {
-      summary = this._summaryResolver.resolveSummary(type);
-      this._summaryCache.set(type, summary);
+    let typeSummary = this._summaryCache.get(type);
+    if (!typeSummary) {
+      const summary = this._summaryResolver.resolveSummary(type);
+      typeSummary = summary ? summary.type : null;
+      this._summaryCache.set(type, typeSummary);
     }
-    return summary && summary.summaryKind === kind ? summary : null;
+    return typeSummary && typeSummary.summaryKind === kind ? typeSummary : null;
   }
 
   private _loadDirectiveMetadata(directiveType: any, isSync: boolean): Promise<any> {
@@ -237,7 +239,7 @@ export class CompileMetadataResolver {
       if (dirMeta.viewProviders) {
         viewProviders = this._getProvidersMetadata(
             dirMeta.viewProviders, entryComponentMetadata,
-            `viewProviders for "${stringify(directiveType)}"`, [], directiveType);
+            `viewProviders for "${stringifyType(directiveType)}"`, [], directiveType);
       }
       if (dirMeta.entryComponents) {
         entryComponentMetadata = flattenAndDedupeArray(dirMeta.entryComponents)
@@ -251,7 +253,8 @@ export class CompileMetadataResolver {
       // Directive
       if (!selector) {
         this._reportError(
-            new Error(`Directive ${stringify(directiveType)} has no selector, please add it!`),
+            new SyntaxError(
+                `Directive ${stringifyType(directiveType)} has no selector, please add it!`),
             directiveType);
         selector = 'error';
       }
@@ -260,8 +263,8 @@ export class CompileMetadataResolver {
     let providers: cpl.CompileProviderMetadata[] = [];
     if (isPresent(dirMeta.providers)) {
       providers = this._getProvidersMetadata(
-          dirMeta.providers, entryComponentMetadata, `providers for "${stringify(directiveType)}"`,
-          [], directiveType);
+          dirMeta.providers, entryComponentMetadata,
+          `providers for "${stringifyType(directiveType)}"`, [], directiveType);
     }
     let queries: cpl.CompileQueryMetadata[] = [];
     let viewQueries: cpl.CompileQueryMetadata[] = [];
@@ -297,8 +300,8 @@ export class CompileMetadataResolver {
     const dirMeta = this._directiveCache.get(directiveType);
     if (!dirMeta) {
       this._reportError(
-          new Error(
-              `Illegal state: getDirectiveMetadata can only be called after loadNgModuleMetadata for a module that declares it. Directive ${stringify(directiveType)}.`),
+          new SyntaxError(
+              `Illegal state: getDirectiveMetadata can only be called after loadNgModuleMetadata for a module that declares it. Directive ${stringifyType(directiveType)}.`),
           directiveType);
     }
     return dirMeta;
@@ -309,8 +312,8 @@ export class CompileMetadataResolver {
         <cpl.CompileDirectiveSummary>this._loadSummary(dirType, cpl.CompileSummaryKind.Directive);
     if (!dirSummary) {
       this._reportError(
-          new Error(
-              `Illegal state: Could not load the summary for directive ${stringify(dirType)}.`),
+          new SyntaxError(
+              `Illegal state: Could not load the summary for directive ${stringifyType(dirType)}.`),
           dirType);
     }
     return dirSummary;
@@ -383,7 +386,8 @@ export class CompileMetadataResolver {
           if (moduleWithProviders.providers) {
             providers.push(...this._getProvidersMetadata(
                 moduleWithProviders.providers, entryComponents,
-                `provider for the NgModule '${stringify(importedModuleType)}'`, [], importedType));
+                `provider for the NgModule '${stringifyType(importedModuleType)}'`, [],
+                importedType));
           }
         }
 
@@ -391,16 +395,16 @@ export class CompileMetadataResolver {
           const importedModuleSummary = this.getNgModuleSummary(importedModuleType);
           if (!importedModuleSummary) {
             this._reportError(
-                new Error(
-                    `Unexpected ${this._getTypeDescriptor(importedType)} '${stringify(importedType)}' imported by the module '${stringify(moduleType)}'`),
+                new SyntaxError(
+                    `Unexpected ${this._getTypeDescriptor(importedType)} '${stringifyType(importedType)}' imported by the module '${stringifyType(moduleType)}'`),
                 moduleType);
             return;
           }
           importedModules.push(importedModuleSummary);
         } else {
           this._reportError(
-              new Error(
-                  `Unexpected value '${stringify(importedType)}' imported by the module '${stringify(moduleType)}'`),
+              new SyntaxError(
+                  `Unexpected value '${stringifyType(importedType)}' imported by the module '${stringifyType(moduleType)}'`),
               moduleType);
           return;
         }
@@ -411,8 +415,8 @@ export class CompileMetadataResolver {
       flattenAndDedupeArray(meta.exports).forEach((exportedType) => {
         if (!isValidType(exportedType)) {
           this._reportError(
-              new Error(
-                  `Unexpected value '${stringify(exportedType)}' exported by the module '${stringify(moduleType)}'`),
+              new SyntaxError(
+                  `Unexpected value '${stringifyType(exportedType)}' exported by the module '${stringifyType(moduleType)}'`),
               moduleType);
           return;
         }
@@ -432,8 +436,8 @@ export class CompileMetadataResolver {
       flattenAndDedupeArray(meta.declarations).forEach((declaredType) => {
         if (!isValidType(declaredType)) {
           this._reportError(
-              new Error(
-                  `Unexpected value '${stringify(declaredType)}' declared by the module '${stringify(moduleType)}'`),
+              new SyntaxError(
+                  `Unexpected value '${stringifyType(declaredType)}' declared by the module '${stringifyType(moduleType)}'`),
               moduleType);
           return;
         }
@@ -449,8 +453,8 @@ export class CompileMetadataResolver {
           this._addTypeToModule(declaredType, moduleType);
         } else {
           this._reportError(
-              new Error(
-                  `Unexpected ${this._getTypeDescriptor(declaredType)} '${stringify(declaredType)}' declared by the module '${stringify(moduleType)}'`),
+              new SyntaxError(
+                  `Unexpected ${this._getTypeDescriptor(declaredType)} '${stringifyType(declaredType)}' declared by the module '${stringifyType(moduleType)}'`),
               moduleType);
           return;
         }
@@ -468,8 +472,8 @@ export class CompileMetadataResolver {
         transitiveModule.addExportedPipe(exportedId);
       } else {
         this._reportError(
-            new Error(
-                `Can't export ${this._getTypeDescriptor(exportedId.reference)} ${stringify(exportedId.reference)} from ${stringify(moduleType)} as it was neither declared nor imported!`),
+            new SyntaxError(
+                `Can't export ${this._getTypeDescriptor(exportedId.reference)} ${stringifyType(exportedId.reference)} from ${stringifyType(moduleType)} as it was neither declared nor imported!`),
             moduleType);
       }
     });
@@ -478,25 +482,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 '${stringify(moduleType)}'`,
-          [], moduleType));
+          meta.providers, entryComponents,
+          `provider for the NgModule '${stringifyType(moduleType)}'`, [], moduleType));
     }
 
     if (meta.entryComponents) {
-      entryComponents.push(
-          ...flattenAndDedupeArray(meta.entryComponents).map(type => this._getTypeMetadata(type)));
+      entryComponents.push(...flattenAndDedupeArray(meta.entryComponents)
+                               .map(type => this._getIdentifierMetadata(type)));
     }
 
     if (meta.bootstrap) {
       flattenAndDedupeArray(meta.bootstrap).forEach(type => {
         if (!isValidType(type)) {
           this._reportError(
-              new Error(
-                  `Unexpected value '${stringify(type)}' used in the bootstrap property of module '${stringify(moduleType)}'`),
+              new SyntaxError(
+                  `Unexpected value '${stringifyType(type)}' used in the bootstrap property of module '${stringifyType(moduleType)}'`),
               moduleType);
           return;
         }
-        bootstrapComponents.push(this._getTypeMetadata(type));
+        bootstrapComponents.push(this._getIdentifierMetadata(type));
       });
     }
 
@@ -554,10 +558,10 @@ export class CompileMetadataResolver {
     const oldModule = this._ngModuleOfTypes.get(type);
     if (oldModule && oldModule !== moduleType) {
       this._reportError(
-          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)}.`),
+          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)}.`),
           moduleType);
     }
     this._ngModuleOfTypes.set(type, moduleType);
@@ -606,6 +610,26 @@ 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 {
@@ -630,8 +654,8 @@ export class CompileMetadataResolver {
     const pipeMeta = this._pipeCache.get(pipeType);
     if (!pipeMeta) {
       this._reportError(
-          new Error(
-              `Illegal state: getPipeMetadata can only be called after loadNgModuleMetadata for a module that declares it. Pipe ${stringify(pipeType)}.`),
+          new SyntaxError(
+              `Illegal state: getPipeMetadata can only be called after loadNgModuleMetadata for a module that declares it. Pipe ${stringifyType(pipeType)}.`),
           pipeType);
     }
     return pipeMeta;
@@ -642,7 +666,8 @@ export class CompileMetadataResolver {
         <cpl.CompilePipeSummary>this._loadSummary(pipeType, cpl.CompileSummaryKind.Pipe);
     if (!pipeSummary) {
       this._reportError(
-          new Error(`Illegal state: Could not load the summary for pipe ${stringify(pipeType)}.`),
+          new SyntaxError(
+              `Illegal state: Could not load the summary for pipe ${stringifyType(pipeType)}.`),
           pipeType);
     }
     return pipeSummary;
@@ -722,9 +747,10 @@ export class CompileMetadataResolver {
 
     if (hasUnknownDeps) {
       const depsTokens =
-          dependenciesMetadata.map((dep) => dep ? stringify(dep.token) : '?').join(', ');
+          dependenciesMetadata.map((dep) => dep ? stringifyType(dep.token) : '?').join(', ');
       this._reportError(
-          new Error(`Can't resolve all parameters for ${stringify(typeOrFunc)}: (${depsTokens}).`),
+          new SyntaxError(
+              `Can't resolve all parameters for ${stringifyType(typeOrFunc)}: (${depsTokens}).`),
           typeOrFunc);
     }
 
@@ -761,9 +787,9 @@ export class CompileMetadataResolver {
               (<string[]>providers.reduce(
                    (soFar: string[], seenProvider: any, seenProviderIdx: number) => {
                      if (seenProviderIdx < providerIdx) {
-                       soFar.push(`${stringify(seenProvider)}`);
+                       soFar.push(`${stringifyType(seenProvider)}`);
                      } else if (seenProviderIdx == providerIdx) {
-                       soFar.push(`?${stringify(seenProvider)}?`);
+                       soFar.push(`?${stringifyType(seenProvider)}?`);
                      } else if (seenProviderIdx == providerIdx + 1) {
                        soFar.push('...');
                      }
@@ -772,7 +798,7 @@ export class CompileMetadataResolver {
                    []))
                   .join(', ');
           this._reportError(
-              new Error(
+              new SyntaxError(
                   `Invalid ${debugInfo ? debugInfo : 'provider'} - only instances of Provider and Type are allowed, got: [${providersInfo}]`),
               type);
         }
@@ -793,19 +819,21 @@ export class CompileMetadataResolver {
 
     if (provider.useFactory || provider.useExisting || provider.useClass) {
       this._reportError(
-          new Error(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports useValue!`), type);
+          new SyntaxError(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports useValue!`), type);
       return [];
     }
 
     if (!provider.multi) {
       this._reportError(
-          new Error(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports 'multi = true'!`), type);
+          new SyntaxError(`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)) {
+      if (this._directiveResolver.isDirective(identifier.reference) ||
+          this._loadSummary(identifier.reference, cpl.CompileSummaryKind.Directive)) {
         components.push(identifier);
       }
     });
@@ -819,7 +847,7 @@ export class CompileMetadataResolver {
     let token: cpl.CompileTokenMetadata = this._getTokenMetadata(provider.token);
 
     if (provider.useClass) {
-      compileTypeMetadata = this._getTypeMetadata(provider.useClass, provider.dependencies);
+      compileTypeMetadata = this._getInjectableMetadata(provider.useClass, provider.dependencies);
       compileDeps = compileTypeMetadata.diDeps;
       if (provider.token === provider.useClass) {
         // use the compileTypeMetadata as it contains information about lifecycleHooks...
@@ -867,8 +895,8 @@ export class CompileMetadataResolver {
     } else {
       if (!q.selector) {
         this._reportError(
-            new Error(
-                `Can't construct a query for the property "${propertyName}" of "${stringify(typeOrFunc)}" since the query selector wasn't defined.`),
+            new SyntaxError(
+                `Can't construct a query for the property "${propertyName}" of "${stringifyType(typeOrFunc)}" since the query selector wasn't defined.`),
             typeOrFunc);
       }
       selectors = [this._getTokenMetadata(q.selector)];
@@ -935,8 +963,8 @@ export function componentModuleUrl(
     const scheme = getUrlScheme(moduleId);
     return scheme ? moduleId : `package:${moduleId}${MODULE_SUFFIX}`;
   } else if (moduleId !== null && moduleId !== void 0) {
-    throw new Error(
-        `moduleId should be a string in "${stringify(type)}". See https://goo.gl/wIDDiL for more information.\n` +
+    throw new SyntaxError(
+        `moduleId should be a string in "${stringifyType(type)}". See https://goo.gl/wIDDiL for more information.\n` +
         `If you're using Webpack you should inline the template and the styles, see https://goo.gl/X2J8zc.`);
   }
 
@@ -952,3 +980,11 @@ 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 {Injectable} from '@angular/core';
+import {CompilerInjectable} from '../injectable';
 
 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';
 
-@Injectable()
+@CompilerInjectable()
 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</ng-container>
- *   <template ngPluralCase="=1">one</ng-container>
- *   <template ngPluralCase="other">more than one</ng-container>
+ *   <template ngPluralCase="=0">zero</template>
+ *   <template ngPluralCase="=1">one</template>
+ *   <template ngPluralCase="other">more than one</template>
  * </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._attemptStr(this._interpolationConfig.end) &&
-          this._inInterpolation) {
+          this._interpolationConfig && this._inInterpolation &&
+          this._attemptStr(this._interpolationConfig.end)) {
         parts.push(this._interpolationConfig.end);
         this._inInterpolation = false;
       } else {

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

@@ -6,12 +6,11 @@
  * 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';
@@ -31,7 +30,7 @@ export class NgModuleCompileResult {
       public dependencies: ComponentFactoryDependency[]) {}
 }
 
-@Injectable()
+@CompilerInjectable()
 export class NgModuleCompiler {
   compile(ngModuleMeta: CompileNgModuleMetadata, extraProviders: CompileProviderMetadata[]):
       NgModuleCompileResult {

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

@@ -6,10 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Injectable, NgModule, Type} from '@angular/core';
+import {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 {
@@ -19,7 +20,7 @@ function _isNgModuleMetadata(obj: any): obj is NgModule {
 /**
  * Resolves types to {@link NgModule}.
  */
-@Injectable()
+@CompilerInjectable()
 export class NgModuleResolver {
   constructor(private _reflector: ReflectorReader = reflector) {}
 

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

@@ -68,13 +68,13 @@ export class MapType extends Type {
   visitType(visitor: TypeVisitor, context: any): any { return visitor.visitMapType(this, context); }
 }
 
-export var DYNAMIC_TYPE = new BuiltinType(BuiltinTypeName.Dynamic);
-export var BOOL_TYPE = new BuiltinType(BuiltinTypeName.Bool);
-export var INT_TYPE = new BuiltinType(BuiltinTypeName.Int);
-export var NUMBER_TYPE = new BuiltinType(BuiltinTypeName.Number);
-export var STRING_TYPE = new BuiltinType(BuiltinTypeName.String);
-export var FUNCTION_TYPE = new BuiltinType(BuiltinTypeName.Function);
-export var NULL_TYPE = new BuiltinType(BuiltinTypeName.Null);
+export const DYNAMIC_TYPE = new BuiltinType(BuiltinTypeName.Dynamic);
+export const BOOL_TYPE = new BuiltinType(BuiltinTypeName.Bool);
+export const INT_TYPE = new BuiltinType(BuiltinTypeName.Int);
+export const NUMBER_TYPE = new BuiltinType(BuiltinTypeName.Number);
+export const STRING_TYPE = new BuiltinType(BuiltinTypeName.String);
+export const FUNCTION_TYPE = new BuiltinType(BuiltinTypeName.Function);
+export const NULL_TYPE = new BuiltinType(BuiltinTypeName.Null);
 
 export interface TypeVisitor {
   visitBuiltintType(type: BuiltinType, context: any): any;
@@ -451,12 +451,12 @@ export interface ExpressionVisitor {
   visitLiteralMapExpr(ast: LiteralMapExpr, context: any): any;
 }
 
-export var THIS_EXPR = new ReadVarExpr(BuiltinVar.This);
-export var SUPER_EXPR = new ReadVarExpr(BuiltinVar.Super);
-export var CATCH_ERROR_VAR = new ReadVarExpr(BuiltinVar.CatchError);
-export var CATCH_STACK_VAR = new ReadVarExpr(BuiltinVar.CatchStack);
-export var NULL_EXPR = new LiteralExpr(null, null);
-export var TYPED_NULL_EXPR = new LiteralExpr(null, NULL_TYPE);
+export const THIS_EXPR = new ReadVarExpr(BuiltinVar.This);
+export const SUPER_EXPR = new ReadVarExpr(BuiltinVar.Super);
+export const CATCH_ERROR_VAR = new ReadVarExpr(BuiltinVar.CatchError);
+export const CATCH_STACK_VAR = new ReadVarExpr(BuiltinVar.CatchStack);
+export const NULL_EXPR = new LiteralExpr(null, null);
+export const TYPED_NULL_EXPR = new LiteralExpr(null, NULL_TYPE);
 
 //// Statements
 export enum StmtModifier {
@@ -894,8 +894,10 @@ export function literalArr(values: Expression[], type: Type = null): LiteralArra
   return new LiteralArrayExpr(values, type);
 }
 
-export function literalMap(values: [string, Expression][], type: MapType = null): LiteralMapExpr {
-  return new LiteralMapExpr(values.map(entry => new LiteralMapEntry(entry[0], entry[1])), type);
+export function literalMap(
+    values: [string, Expression][], type: MapType = null, quoted: boolean = false): LiteralMapExpr {
+  return new LiteralMapExpr(
+      values.map(entry => new LiteralMapEntry(entry[0], entry[1], quoted)), type);
 }
 
 export function not(expr: Expression): NotExpr {

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

@@ -14,5 +14,6 @@ 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;
+  abstract fileNameToModuleName(importedFilePath: string, containingFilePath: string): string
+      /*|null*/;
 }

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) {
+    if (value.reference && value.reference.members && value.reference.members.length) {
       ctx.print(value.reference.name);
       ctx.print('.');
       ctx.print(value.reference.members.join('.'));

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

@@ -6,10 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Injectable, Pipe, Type, resolveForwardRef} from '@angular/core';
+import {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 {
@@ -23,7 +24,7 @@ function _isPipeMetadata(type: any): boolean {
  *
  * See {@link Compiler}
  */
-@Injectable()
+@CompilerInjectable()
 export class PipeResolver {
   constructor(private _reflector: ReflectorReader = reflector) {}
 

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

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

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

@@ -9,12 +9,12 @@
 import {getHtmlTagDefinition} from './ml_parser/html_tags';
 
 const _SELECTOR_REGEXP = new RegExp(
-    '(\\:not\\()|' +                              //":not("
-        '([-\\w]+)|' +                            // "tag"
-        '(?:\\.([-\\w]+))|' +                     // ".class"
-        '(?:\\[([-\\w*]+)(?:=([^\\]]*))?\\])|' +  // "[name]", "[name=value]"
-        '(\\))|' +                                // ")"
-        '(\\s*,\\s*)',                            // ","
+    '(\\:not\\()|' +                               //":not("
+        '([-\\w]+)|' +                             // "tag"
+        '(?:\\.([-\\w]+))|' +                      // ".class"
+        '(?:\\[([.-\\w*]+)(?:=([^\\]]*))?\\])|' +  // "[name]", "[name=value]"
+        '(\\))|' +                                 // ")"
+        '(\\s*,\\s*)',                             // ","
     'g');
 
 /**

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

@@ -6,9 +6,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Injectable, ViewEncapsulation} from '@angular/core';
+import {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';
@@ -36,7 +37,7 @@ export class CompiledStylesheet {
       public meta: CompileStylesheetMetadata) {}
 }
 
-@Injectable()
+@CompilerInjectable()
 export class StyleCompiler {
   private _shadowCss: ShadowCss = new ShadowCss();
 

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

@@ -9,8 +9,6 @@
 // Some of the code comes from WebComponents.JS
 // https://github.com/webcomponents/webcomponentsjs/blob/master/src/HTMLImports/path.js
 
-import {isBlank, isPresent} from './facade/lang';
-
 import {UrlResolver} from './url_resolver';
 
 export class StyleWithImports {
@@ -18,8 +16,8 @@ export class StyleWithImports {
 }
 
 export function isStyleUrlResolvable(url: string): boolean {
-  if (isBlank(url) || url.length === 0 || url[0] == '/') return false;
-  const schemeMatch = url.match(_urlWithSchemaRe);
+  if (url == null || url.length === 0 || url[0] == '/') return false;
+  const schemeMatch = url.match(URL_WITH_SCHEMA_REGEXP);
   return schemeMatch === null || schemeMatch[1] == 'package' || schemeMatch[1] == 'asset';
 }
 
@@ -30,17 +28,20 @@ export function isStyleUrlResolvable(url: string): boolean {
 export function extractStyleUrls(
     resolver: UrlResolver, baseUrl: string, cssText: string): StyleWithImports {
   const foundUrls: string[] = [];
-  const modifiedCssText = cssText.replace(_cssImportRe, function(...m: string[]) {
-    const url = m[1] || m[2];
-    if (!isStyleUrlResolvable(url)) {
-      // Do not attempt to resolve non-package absolute URLs with URI scheme
-      return m[0];
-    }
-    foundUrls.push(resolver.resolve(baseUrl, url));
-    return '';
-  });
+
+  const modifiedCssText =
+      cssText.replace(CSS_COMMENT_REGEXP, '').replace(CSS_IMPORT_REGEXP, (...m: string[]) => {
+        const url = m[1] || m[2];
+        if (!isStyleUrlResolvable(url)) {
+          // Do not attempt to resolve non-package absolute URLs with URI scheme
+          return m[0];
+        }
+        foundUrls.push(resolver.resolve(baseUrl, url));
+        return '';
+      });
   return new StyleWithImports(modifiedCssText, foundUrls);
 }
 
-const _cssImportRe = /@import\s+(?:url\()?\s*(?:(?:['"]([^'"]*))|([^;\)\s]*))[^;]*;?/g;
-const _urlWithSchemaRe = /^([^:/?#]+):/;
+const CSS_IMPORT_REGEXP = /@import\s+(?:url\()?\s*(?:(?:['"]([^'"]*))|([^;\)\s]*))[^;]*;?/g;
+const CSS_COMMENT_REGEXP = /\/\*.+?\*\//g;
+const URL_WITH_SCHEMA_REGEXP = /^([^:/?#]+):/;

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

@@ -5,10 +5,17 @@
  * 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';
 
-@Injectable()
-export class SummaryResolver {
-  resolveSummary(reference: any): CompileTypeSummary { return null; }
+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 []; }
 }

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, Injectable, OpaqueToken, Optional, SchemaMetadata} from '@angular/core';
-
+import {Inject, 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[]) {}
 }
 
-@Injectable()
+@CompilerInjectable()
 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 Error(`Template parse errors:\n${errorString}`);
+      throw new SyntaxError(`Template parse errors:\n${errorString}`);
     }
 
     return result.templateAst;
@@ -149,7 +149,7 @@ export class TemplateParser {
       return new TemplateParseResult(result, errors);
     }
 
-    if (isPresent(this.transforms)) {
+    if (this.transforms) {
       this.transforms.forEach(
           (transform: TemplateAstVisitor) => { result = templateVisitAll(transform, result); });
     }
@@ -218,7 +218,7 @@ class TemplateParseVisitor implements html.Visitor {
   visitText(text: html.Text, parent: ElementContext): any {
     const ngContentIndex = parent.findNgContentIndex(TEXT_CSS_SELECTOR);
     const expr = this._bindingParser.parseInterpolation(text.value, text.sourceSpan);
-    if (isPresent(expr)) {
+    if (expr) {
       return new BoundTextAst(expr, ngContentIndex, text.sourceSpan);
     } else {
       return new TextAst(text.value, ngContentIndex, text.sourceSpan);
@@ -248,14 +248,14 @@ class TemplateParseVisitor implements html.Visitor {
       return null;
     }
 
-    const matchableAttrs: string[][] = [];
+    const matchableAttrs: [string, string][] = [];
     const elementOrDirectiveProps: BoundProperty[] = [];
     const elementOrDirectiveRefs: ElementOrDirectiveRef[] = [];
     const elementVars: VariableAst[] = [];
     const events: BoundEventAst[] = [];
 
     const templateElementOrDirectiveProps: BoundProperty[] = [];
-    const templateMatchableAttrs: string[][] = [];
+    const templateMatchableAttrs: [string, string][] = [];
     const templateElementVars: VariableAst[] = [];
 
     let hasInlineTemplates = false;
@@ -268,14 +268,17 @@ class TemplateParseVisitor implements html.Visitor {
           isTemplateElement, attr, matchableAttrs, elementOrDirectiveProps, events,
           elementOrDirectiveRefs, elementVars);
 
-      let templateBindingsSource: string|undefined = undefined;
-      let prefixToken: string|undefined = undefined;
-      if (this._normalizeAttributeName(attr.name) == TEMPLATE_ATTR) {
+      let templateBindingsSource: string|undefined;
+      let prefixToken: string|undefined;
+      let normalizedName = this._normalizeAttributeName(attr.name);
+
+      if (normalizedName == TEMPLATE_ATTR) {
         templateBindingsSource = attr.value;
-      } else if (attr.name.startsWith(TEMPLATE_ATTR_PREFIX)) {
+      } else if (normalizedName.startsWith(TEMPLATE_ATTR_PREFIX)) {
         templateBindingsSource = attr.value;
-        prefixToken = attr.name.substring(TEMPLATE_ATTR_PREFIX.length);  // remove the star
+        prefixToken = normalizedName.substring(TEMPLATE_ATTR_PREFIX.length);
       }
+
       const hasTemplateBinding = isPresent(templateBindingsSource);
       if (hasTemplateBinding) {
         if (hasInlineTemplates) {
@@ -541,10 +544,12 @@ class TemplateParseVisitor implements html.Visitor {
       elementSourceSpan: ParseSourceSpan, targetReferences: ReferenceAst[]): DirectiveAst[] {
     const matchedReferences = new Set<string>();
     let component: CompileDirectiveSummary = null;
+
     const directiveAsts = directives.map((directive) => {
       const sourceSpan = new ParseSourceSpan(
           elementSourceSpan.start, elementSourceSpan.end,
           `Directive ${identifierName(directive.type)}`);
+
       if (directive.isComponent) {
         component = directive;
       }
@@ -567,6 +572,7 @@ class TemplateParseVisitor implements html.Visitor {
       return new DirectiveAst(
           directive, directiveProperties, hostProperties, hostEvents, sourceSpan);
     });
+
     elementOrDirectiveRefs.forEach((elOrDirRef) => {
       if (elOrDirRef.value.length > 0) {
         if (!matchedReferences.has(elOrDirRef.name)) {
@@ -581,7 +587,7 @@ class TemplateParseVisitor implements html.Visitor {
         }
         targetReferences.push(new ReferenceAst(elOrDirRef.name, refToken, elOrDirRef.sourceSpan));
       }
-    });  // fix syntax highlighting issue: `
+    });
     return directiveAsts;
   }
 
@@ -742,7 +748,7 @@ class NonBindableVisitor implements html.Visitor {
       return null;
     }
 
-    const attrNameAndValues = ast.attrs.map(attrAst => [attrAst.name, attrAst.value]);
+    const attrNameAndValues = ast.attrs.map((attr): [string, string] => [attr.name, attr.value]);
     const selector = createElementCssSelector(ast.name, attrNameAndValues);
     const ngContentIndex = parent.findNgContentIndex(selector);
     const children = html.visitAll(this, ast.children, EMPTY_ELEMENT_CONTEXT);
@@ -811,16 +817,16 @@ class ElementContext {
 }
 
 export function createElementCssSelector(
-    elementName: string, matchableAttrs: string[][]): CssSelector {
+    elementName: string, attributes: [string, string][]): CssSelector {
   const cssSelector = new CssSelector();
   const elNameNoNs = splitNsName(elementName)[1];
 
   cssSelector.setElement(elNameNoNs);
 
-  for (let i = 0; i < matchableAttrs.length; i++) {
-    const attrName = matchableAttrs[i][0];
+  for (let i = 0; i < attributes.length; i++) {
+    const attrName = attributes[i][0];
     const attrNameNoNs = splitNsName(attrName)[1];
-    const attrValue = matchableAttrs[i][1];
+    const attrValue = attributes[i][1];
 
     cssSelector.addAttribute(attrNameNoNs, attrValue);
     if (attrName.toLowerCase() == CLASS_ATTR) {

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

@@ -6,9 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Inject, Injectable, PACKAGE_ROOT_URL} from '@angular/core';
+import {Inject, PACKAGE_ROOT_URL} from '@angular/core';
 
 import {isBlank, isPresent} from './facade/lang';
+import {CompilerInjectable} from './injectable';
+
 
 /**
  * Create a {@link UrlResolver} with no package prefix.
@@ -24,7 +26,7 @@ export function createOfflineCompileUrlResolver(): UrlResolver {
 /**
  * A default provider for {@link PACKAGE_ROOT_URL} that maps to '/'.
  */
-export var DEFAULT_PACKAGE_URL_PROVIDER = {
+export const DEFAULT_PACKAGE_URL_PROVIDER = {
   provide: PACKAGE_ROOT_URL,
   useValue: '/'
 };
@@ -45,7 +47,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).
  */
-@Injectable()
+@CompilerInjectable()
 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,3 +78,5 @@ export class SyncAsyncResult<T> {
     }
   }
 }
+
+export class SyntaxError extends BaseError {}

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

@@ -211,12 +211,7 @@ export class CompileElement extends CompileNode {
       const directiveInstance = this.instances.get(tokenReference(identifierToken(directive.type)));
       directive.queries.forEach((queryMeta) => { this._addQuery(queryMeta, directiveInstance); });
     }
-    const queriesWithReads: _QueryWithRead[] = [];
-    Array.from(this._resolvedProviders.values()).forEach((resolvedProvider) => {
-      const queriesForProvider = this._getQueriesFor(resolvedProvider.token);
-      queriesWithReads.push(
-          ...queriesForProvider.map(query => new _QueryWithRead(query, resolvedProvider.token)));
-    });
+
     Object.keys(this.referenceTokens).forEach(varName => {
       const token = this.referenceTokens[varName];
       let varValue: o.Expression;
@@ -226,27 +221,6 @@ export class CompileElement extends CompileNode {
         varValue = this.renderNode;
       }
       this.view.locals.set(varName, varValue);
-      const varToken = {value: varName};
-      queriesWithReads.push(
-          ...this._getQueriesFor(varToken).map(query => new _QueryWithRead(query, varToken)));
-    });
-    queriesWithReads.forEach((queryWithRead) => {
-      let value: o.Expression;
-      if (isPresent(queryWithRead.read.identifier)) {
-        // query for an identifier
-        value = this.instances.get(tokenReference(queryWithRead.read));
-      } else {
-        // query for a reference
-        const token = this.referenceTokens[queryWithRead.read.value];
-        if (isPresent(token)) {
-          value = this.instances.get(tokenReference(token));
-        } else {
-          value = this.elementRef;
-        }
-      }
-      if (isPresent(value)) {
-        queryWithRead.query.addValue(value, this.view);
-      }
     });
   }
 
@@ -265,12 +239,14 @@ export class CompileElement extends CompileNode {
       this.view.injectorGetMethod.addStmt(createInjectInternalCondition(
           this.nodeIndex, providerChildNodeCount, resolvedProvider, providerExpr));
     });
+  }
 
+  finish() {
     Array.from(this._queries.values())
         .forEach(
             queries => queries.forEach(
-                q =>
-                    q.afterChildren(this.view.createMethod, this.view.updateContentQueriesMethod)));
+                q => q.generateStatements(
+                    this.view.createMethod, this.view.updateContentQueriesMethod)));
   }
 
   addContentNode(ngContentIndex: number, nodeExpr: CompileViewRootNode) {
@@ -283,12 +259,11 @@ export class CompileElement extends CompileNode {
         null;
   }
 
-  getProviderTokens(): o.Expression[] {
-    return Array.from(this._resolvedProviders.values())
-        .map((resolvedProvider) => createDiTokenExpression(resolvedProvider.token));
+  getProviderTokens(): CompileTokenMetadata[] {
+    return Array.from(this._resolvedProviders.values()).map(provider => provider.token);
   }
 
-  private _getQueriesFor(token: CompileTokenMetadata): CompileQuery[] {
+  getQueriesFor(token: CompileTokenMetadata): CompileQuery[] {
     const result: CompileQuery[] = [];
     let currentEl: CompileElement = this;
     let distance = 0;
@@ -426,10 +401,3 @@ function createProviderProperty(
   }
   return o.THIS_EXPR.prop(propName);
 }
-
-class _QueryWithRead {
-  public read: CompileTokenMetadata;
-  constructor(public query: CompileQuery, match: CompileTokenMetadata) {
-    this.read = query.meta.read || match;
-  }
-}

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

@@ -64,7 +64,7 @@ export class CompileQuery {
     return !this._values.values.some(value => value instanceof ViewQueryValues);
   }
 
-  afterChildren(targetStaticMethod: CompileMethod, targetDynamicMethod: CompileMethod) {
+  generateStatements(targetStaticMethod: CompileMethod, targetDynamicMethod: CompileMethod) {
     const values = createQueryValues(this._values);
     const updateStmts = [this.queryList.callMethod('reset', [o.literalArr(values)]).toStmt()];
     if (isPresent(this.ownerDirectiveExpression)) {

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

@@ -154,11 +154,11 @@ export class CompileView implements NameResolver {
     }
   }
 
-  afterNodes() {
+  finish() {
     Array.from(this.viewQueries.values())
         .forEach(
             queries => queries.forEach(
-                q => q.afterChildren(this.createMethod, this.updateViewQueriesMethod)));
+                q => q.generateStatements(this.createMethod, this.updateViewQueriesMethod)));
   }
 }
 

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

@@ -133,4 +133,4 @@ type EventSummary = {
   name: string,
   target: string,
   phase: string
-}
+};

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

@@ -0,0 +1,55 @@
+/**
+ * @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 {CompileQueryMetadata, CompileTokenMetadata, tokenReference} from '../compile_metadata';
+import * as o from '../output/output_ast';
+
+import {CompileElement} from './compile_element';
+import {CompileQuery} from './compile_query';
+
+
+// Note: We can't do this when we create the CompileElements already,
+// as we create embedded views before the <template> elements themselves.
+export function bindQueryValues(ce: CompileElement) {
+  const queriesWithReads: _QueryWithRead[] = [];
+  ce.getProviderTokens().forEach((token) => {
+    const queriesForProvider = ce.getQueriesFor(token);
+    queriesWithReads.push(...queriesForProvider.map(query => new _QueryWithRead(query, token)));
+  });
+  Object.keys(ce.referenceTokens).forEach(varName => {
+    const token = ce.referenceTokens[varName];
+    const varToken = {value: varName};
+    queriesWithReads.push(
+        ...ce.getQueriesFor(varToken).map(query => new _QueryWithRead(query, varToken)));
+  });
+  queriesWithReads.forEach((queryWithRead) => {
+    let value: o.Expression;
+    if (queryWithRead.read.identifier) {
+      // query for an identifier
+      value = ce.instances.get(tokenReference(queryWithRead.read));
+    } else {
+      // query for a reference
+      const token = ce.referenceTokens[queryWithRead.read.value];
+      if (token) {
+        value = ce.instances.get(tokenReference(token));
+      } else {
+        value = ce.elementRef;
+      }
+    }
+    if (value) {
+      queryWithRead.query.addValue(value, ce.view);
+    }
+  });
+}
+
+class _QueryWithRead {
+  public read: CompileTokenMetadata;
+  constructor(public query: CompileQuery, match: CompileTokenMetadata) {
+    this.read = query.meta.read || match;
+  }
+}

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

@@ -15,6 +15,7 @@ import {CompileView} from './compile_view';
 import {bindOutputs} from './event_binder';
 import {bindDirectiveAfterContentLifecycleCallbacks, bindDirectiveAfterViewLifecycleCallbacks, bindDirectiveWrapperLifecycleCallbacks, bindInjectableDestroyLifecycleCallbacks, bindPipeDestroyLifecycleCallbacks} from './lifecycle_binder';
 import {bindDirectiveHostProps, bindDirectiveInputs, bindRenderInputs, bindRenderText} from './property_binder';
+import {bindQueryValues} from './query_binder';
 
 export function bindView(
     view: CompileView, parsedTemplate: TemplateAst[], schemaRegistry: ElementSchemaRegistry): void {
@@ -43,6 +44,7 @@ class ViewBinderVisitor implements TemplateAstVisitor {
 
   visitElement(ast: ElementAst, parent: CompileElement): any {
     const compileElement = <CompileElement>this.view.nodes[this._nodeIndex++];
+    bindQueryValues(compileElement);
     const hasEvents = bindOutputs(ast.outputs, ast.directives, compileElement, true);
     bindRenderInputs(ast.inputs, ast.outputs, hasEvents, compileElement);
     ast.directives.forEach((directiveAst, dirIndex) => {
@@ -75,6 +77,7 @@ class ViewBinderVisitor implements TemplateAstVisitor {
 
   visitEmbeddedTemplate(ast: EmbeddedTemplateAst, parent: CompileElement): any {
     const compileElement = <CompileElement>this.view.nodes[this._nodeIndex++];
+    bindQueryValues(compileElement);
     bindOutputs(ast.outputs, ast.directives, compileElement, false);
     ast.directives.forEach((directiveAst, dirIndex) => {
       const directiveInstance = compileElement.instances.get(directiveAst.directive.type.reference);

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

@@ -48,13 +48,16 @@ export function buildView(
 }
 
 export function finishView(view: CompileView, targetStatements: o.Statement[]) {
-  view.afterNodes();
-  createViewTopLevelStmts(view, targetStatements);
   view.nodes.forEach((node) => {
-    if (node instanceof CompileElement && node.hasEmbeddedView) {
-      finishView(node.embeddedView, targetStatements);
+    if (node instanceof CompileElement) {
+      node.finish();
+      if (node.hasEmbeddedView) {
+        finishView(node.embeddedView, targetStatements);
+      }
     }
   });
+  view.finish();
+  createViewTopLevelStmts(view, targetStatements);
 }
 
 class ViewBuilderVisitor implements TemplateAstVisitor {
@@ -418,7 +421,9 @@ function createStaticNodeDebugInfo(node: CompileNode): o.Expression {
   let componentToken: o.Expression = o.NULL_EXPR;
   const varTokenEntries: any[] = [];
   if (isPresent(compileElement)) {
-    providerTokens = compileElement.getProviderTokens();
+    providerTokens =
+        compileElement.getProviderTokens().map((token) => createDiTokenExpression(token));
+
     if (isPresent(compileElement.component)) {
       componentToken = createDiTokenExpression(identifierToken(compileElement.component.type));
     }
@@ -576,7 +581,8 @@ function generateDetectChangesMethod(view: CompileView): o.Statement[] {
   }
   stmts.push(...view.detectChangesRenderPropertiesMethod.finish());
   view.viewChildren.forEach((viewChild) => {
-    stmts.push(viewChild.callMethod('internalDetectChanges', [DetectChangesVars.throwOnChange]).toStmt());
+    stmts.push(
+        viewChild.callMethod('internalDetectChanges', [DetectChangesVars.throwOnChange]).toStmt());
   });
   const afterViewStmts =
       view.updateViewQueriesMethod.finish().concat(view.afterViewLifecycleCallbacksMethod.finish());

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

@@ -6,11 +6,10 @@
  * 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';
@@ -30,7 +29,7 @@ export class ViewCompileResult {
           Array<ViewClassDependency|ComponentFactoryDependency|DirectiveWrapperDependency>) {}
 }
 
-@Injectable()
+@CompilerInjectable()
 export class ViewCompiler {
   constructor(private _genConfig: CompilerConfig, private _schemaRegistry: ElementSchemaRegistry) {}
 

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

@@ -6,26 +6,25 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {StaticReflector, StaticReflectorHost, StaticSymbol} from '@angular/compiler';
+import {StaticReflector, StaticSymbol, StaticSymbolCache, StaticSymbolResolver, StaticSymbolResolverHost} from '@angular/compiler';
 import {HostListener, Inject, animate, group, keyframes, sequence, state, style, transition, trigger} from '@angular/core';
-import {MetadataCollector} from '@angular/tsc-wrapped';
-import * as ts from 'typescript';
 
-
-
-// This matches .ts files but not .d.ts files.
-const TS_EXT = /(^.|(?!\.d)..)\.ts$/;
+import {MockStaticSymbolResolverHost, MockSummaryResolver} from './static_symbol_resolver_spec';
 
 describe('StaticReflector', () => {
-  const noContext = new StaticSymbol('', '');
-  let host: StaticReflectorHost;
+  let noContext: StaticSymbol;
+  let host: StaticSymbolResolverHost;
+  let symbolResolver: StaticSymbolResolver;
   let reflector: StaticReflector;
 
   function init(
       testData: {[key: string]: any} = DEFAULT_TEST_DATA,
       decorators: {name: string, filePath: string, ctor: any}[] = []) {
-    host = new MockStaticReflectorHost(testData);
-    reflector = new StaticReflector(host, undefined, decorators);
+    const symbolCache = new StaticSymbolCache();
+    host = new MockStaticSymbolResolverHost(testData);
+    symbolResolver = new StaticSymbolResolver(host, symbolCache, new MockSummaryResolver([]));
+    reflector = new StaticReflector(symbolResolver, decorators);
+    noContext = reflector.getStaticSymbol('', '');
   }
 
   beforeEach(() => init());
@@ -77,24 +76,22 @@ 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');
@@ -129,7 +126,7 @@ describe('StaticReflector', () => {
   });
 
   it('should simplify a static symbol into itself', () => {
-    const staticSymbol = new StaticSymbol('', '');
+    const staticSymbol = reflector.getStaticSymbol('', '');
     expect(simplify(noContext, staticSymbol)).toBe(staticSymbol);
   });
 
@@ -306,49 +303,43 @@ describe('StaticReflector', () => {
     expect(simplify(noContext, expr)).toBe(2);
   });
 
-  it('should simplify a module reference', () => {
+  it('should simplify a file reference', () => {
     expect(simplify(
-               new StaticSymbol('/src/cases', ''),
-               ({__symbolic: 'reference', module: './extern', name: 's'})))
+               reflector.getStaticSymbol('/src/cases', ''),
+               reflector.getStaticSymbol('/src/extern.d.ts', '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(
-               new StaticSymbol('/src/cases', ''),
-               ({__symbolic: 'reference', module: './extern', name: 'nonExisting'})))
+               reflector.getStaticSymbol('/src/cases', ''),
+               reflector.getStaticSymbol('/src/extern.d.ts', 'nonExisting')))
         .toEqual(reflector.getStaticSymbol('/src/extern.d.ts', 'nonExisting'));
   });
 
   it('should simplify a function reference as a static symbol', () => {
     expect(simplify(
-               new StaticSymbol('/src/cases', 'myFunction'),
+               reflector.getStaticSymbol('/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(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);
+    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);
   });
 
   it('should error on direct recursive calls', () => {
     expect(
         () => simplify(
-            new StaticSymbol('/tmp/src/function-reference.ts', ''),
-            {__symbolic: 'reference', name: 'recursion'}))
+            reflector.getStaticSymbol('/tmp/src/function-reference.ts', ''),
+            reflector.getStaticSymbol('/tmp/src/function-reference.ts', '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'));
   });
@@ -362,7 +353,8 @@ describe('StaticReflector', () => {
       expect(moduleMetadata).toBeDefined();
       const classData: any = moduleMetadata['InvalidMetadata'];
       expect(classData).toBeDefined();
-      simplify(new StaticSymbol('/tmp/src/invalid-metadata.ts', ''), classData.decorators[0]);
+      simplify(
+          reflector.getStaticSymbol('/tmp/src/invalid-metadata.ts', ''), classData.decorators[0]);
     } catch (e) {
       expect(e.fileName).toBe('/tmp/src/invalid-metadata.ts');
       threw = true;
@@ -373,48 +365,17 @@ describe('StaticReflector', () => {
   it('should error on indirect recursive calls', () => {
     expect(
         () => simplify(
-            new StaticSymbol('/tmp/src/function-reference.ts', ''),
-            {__symbolic: 'reference', name: 'indirectRecursion'}))
+            reflector.getStaticSymbol('/tmp/src/function-reference.ts', ''),
+            reflector.getStaticSymbol('/tmp/src/function-reference.ts', '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(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'
-                }
-              }]
-            }]
-          }
-        }
-      }
-    });
+    expect(simplify(
+               reflector.getStaticSymbol('/tmp/src/spread.ts', ''),
+               reflector.getStaticSymbol('/tmp/src/spread.ts', 'spread')))
+        .toEqual([0, 1, 2, 3, 4, 5]);
   });
 
   it('should be able to get metadata for a class containing a custom decorator', () => {
@@ -488,62 +449,6 @@ 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) {}
@@ -706,78 +611,6 @@ 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',
@@ -1008,8 +841,6 @@ 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,
@@ -1343,47 +1174,4 @@ 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

@@ -0,0 +1,372 @@
+/**
+ * @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,128 +6,67 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {AotSummaryResolver, AotSummaryResolverHost, CompileNgModuleSummary, CompileSummaryKind, CompileTypeSummary, StaticReflector, StaticReflectorHost, StaticSymbol} from '@angular/compiler';
+import {AotSummaryResolver, AotSummaryResolverHost, CompileSummaryKind, CompileTypeSummary, ResolvedStaticSymbol, StaticSymbol, StaticSymbolCache, StaticSymbolResolver} from '@angular/compiler';
+import {AotSummarySerializerHost, deserializeSummaries, serializeSummaries} from '@angular/compiler/src/aot/summary_serializer';
 import * as path from 'path';
 
-import {MockStaticReflectorHost} from './static_reflector_spec';
+import {MockStaticSymbolResolverHost, MockSummaryResolver} from './static_symbol_resolver_spec';
 
 const EXT = /\.ts$|.d.ts$/;
 
 export function main() {
   describe('AotSummaryResolver', () => {
-    let resolver: AotSummaryResolver;
-    let staticReflector: StaticReflector;
+    let summaryResolver: AotSummaryResolver;
+    let symbolCache: StaticSymbolCache;
+    let host: MockAotSummaryResolverHost;
+
+    beforeEach(() => { symbolCache = new StaticSymbolCache(); });
 
     function init(summaries: {[filePath: string]: string} = {}) {
-      // 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$/});
+      host = new MockAotSummaryResolverHost(summaries);
+      summaryResolver = new AotSummaryResolver(host, symbolCache);
     }
 
-    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');
+    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 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'])
-          }]);
+    it('should not load summaries for source files', () => {
+      init({});
+      spyOn(host, 'loadSummary').and.callThrough();
 
-      // 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']));
+      expect(summaryResolver.resolveSummary(symbolCache.get('/a.ts', 'a'))).toBeFalsy();
+      expect(host.loadSummary).not.toHaveBeenCalled();
     });
 
-    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 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 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, '');
   }
@@ -135,4 +74,13 @@ class MockAotSummaryResolverHost implements AotSummaryResolverHost {
   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

@@ -0,0 +1,199 @@
+/**
+ * @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('No template specified for component SomeComp');
+           })).toThrowError(SyntaxError, 'No template specified for component SomeComp');
          }));
     });
 

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

@@ -43,7 +43,7 @@ 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"/></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"><ex>INTERPOLATION</ex></ph></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="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>

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

@@ -0,0 +1,51 @@
+/**
+ * @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, Directive, Input} from '@angular/core';
+import {ComponentFixture, TestBed, async} from '@angular/core/testing';
+import {By} from '@angular/platform-browser/src/dom/debug/by';
+import {expect} from '@angular/platform-browser/testing/matchers';
+
+export function main() {
+  describe('integration tests', () => {
+    let fixture: ComponentFixture<TestComponent>;
+
+
+    describe('directives', () => {
+      it('should support dotted selectors', async(() => {
+           @Directive({selector: '[dot.name]'})
+           class MyDir {
+             @Input('dot.name') value: string;
+           }
+
+           TestBed.configureTestingModule({
+             declarations: [
+               MyDir,
+               TestComponent,
+             ],
+           });
+
+           const template = `<div [dot.name]="'foo'"></div>`;
+           fixture = createTestComponent(template);
+           fixture.detectChanges();
+           const myDir = fixture.debugElement.query(By.directive(MyDir)).injector.get(MyDir);
+           expect(myDir.value).toEqual('foo');
+         }));
+    });
+
+  });
+}
+
+@Component({selector: 'test-cmp', template: ''})
+class TestComponent {
+}
+
+function createTestComponent(template: string): ComponentFixture<TestComponent> {
+  return TestBed.overrideComponent(TestComponent, {set: {template: template}})
+      .createComponent(TestComponent);
+}

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,8 +34,9 @@ export function main() {
          }
 
          expect(() => resolver.getDirectiveMetadata(ComponentWithEverythingInline))
-             .toThrowError(/Illegal state/);
-         expect(() => resolver.getPipeMetadata(SomePipe)).toThrowError(/Illegal state/);
+             .toThrowError(SyntaxError, /Illegal state/);
+         expect(() => resolver.getPipeMetadata(SomePipe))
+             .toThrowError(SyntaxError, /Illegal state/);
        }));
 
     it('should read metadata in sync for components with inline resources',
@@ -121,10 +122,10 @@ export function main() {
 
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(SomeModule, true))
              .toThrowError(
-                 `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.`);
+                 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.`);
        }));
 
 
@@ -145,7 +146,7 @@ export function main() {
          }
 
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(SomeModule, true))
-             .toThrowError(`Can't resolve all parameters for MyBrokenComp1: (?).`);
+             .toThrowError(SyntaxError, `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) => {
@@ -155,6 +156,7 @@ export function main() {
          expect(
              () => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithImportedComponent, true))
              .toThrowError(
+                 SyntaxError,
                  `Unexpected directive 'ComponentWithoutModuleId' imported by the module 'ModuleWithImportedComponent'`);
        }));
 
@@ -168,6 +170,7 @@ export function main() {
          }
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithImportedPipe, true))
              .toThrowError(
+                 SyntaxError,
                  `Unexpected pipe 'SomePipe' imported by the module 'ModuleWithImportedPipe'`);
        }));
 
@@ -181,6 +184,7 @@ export function main() {
          }
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithDeclaredModule, true))
              .toThrowError(
+                 SyntaxError,
                  `Unexpected module 'SomeModule' declared by the module 'ModuleWithDeclaredModule'`);
        }));
 
@@ -191,6 +195,7 @@ export function main() {
          }
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithNullDeclared, true))
              .toThrowError(
+                 SyntaxError,
                  `Unexpected value 'null' declared by the module 'ModuleWithNullDeclared'`);
        }));
 
@@ -201,6 +206,7 @@ export function main() {
          }
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(ModuleWithNullImported, true))
              .toThrowError(
+                 SyntaxError,
                  `Unexpected value 'null' imported by the module 'ModuleWithNullImported'`);
        }));
 
@@ -212,7 +218,8 @@ export function main() {
          }
 
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(SomeModule, true))
-             .toThrowError(`Can't resolve all parameters for NonAnnotatedService: (?).`);
+             .toThrowError(
+                 SyntaxError, `Can't resolve all parameters for NonAnnotatedService: (?).`);
        }));
 
     it('should throw with descriptive error message when one of providers is not present',
@@ -223,6 +230,7 @@ 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?, ...]`);
        }));
 
@@ -234,6 +242,7 @@ export function main() {
 
          expect(() => resolver.loadNgModuleDirectiveAndPipeMetadata(SomeModule, true))
              .toThrowError(
+                 SyntaxError,
                  `Invalid viewProviders for "MyBrokenComp4" - only instances of Provider and Type are allowed, got: [?null?, ...]`);
        }));
 
@@ -248,11 +257,13 @@ 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,7 +6,6 @@
  * 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';
@@ -304,6 +303,18 @@ 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,7 +6,6 @@
  * 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';
@@ -96,6 +95,20 @@ 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,7 +6,6 @@
  * 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';
@@ -524,7 +523,15 @@ 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', () => {
@@ -672,6 +679,26 @@ 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/output_emitter_util.ts

@@ -44,7 +44,7 @@ const baseErrorIdentifier = {
   runtime: BaseError
 };
 
-export var codegenExportsVars = [
+export const codegenExportsVars = [
   'getExpressions',
 ];
 
@@ -190,7 +190,7 @@ const _getExpressionsStmts: o.Statement[] = [
   ]))
 ];
 
-export var codegenStmts: o.Statement[] = [
+export const codegenStmts: o.Statement[] = [
   new o.CommentStmt('This is a comment'),
 
   new o.ClassStmt(

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, StaticReflectorHost, StaticSymbol} from '@angular/compiler';
+import {StaticReflector, StaticSymbol, StaticSymbolCache, StaticSymbolResolver, StaticSymbolResolverHost} 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,6 +14,8 @@ 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 = `
@@ -27,7 +29,10 @@ 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 reflector = new StaticReflector(stubHost);
+    const symbolCache = new StaticSymbolCache();
+    const symbolResolver =
+        new StaticSymbolResolver(stubHost, symbolCache, new MockSummaryResolver());
+    const reflector = new StaticReflector(symbolResolver);
 
     // Get the metadata from the above source
     const metadata = collector.getMetadata(source);
@@ -62,11 +67,11 @@ describe('TypeScriptEmitter (node only)', () => {
   });
 });
 
-class StubReflectorHost implements StaticReflectorHost {
+class StubReflectorHost implements StaticSymbolResolverHost {
   getMetadataFor(modulePath: string): {[key: string]: any}[] { return []; }
-  moduleNameToFileName(moduleName: string, containingFile: string): string { return ''; }
+  moduleNameToFileName(moduleName: string, containingFile: string): string { return 'somePath'; }
 }
 
 class StubImportResolver extends ImportResolver {
   fileNameToModuleName(importedFilePath: string, containingFilePath: string): string { return ''; }
-}
+}

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

@@ -113,6 +113,14 @@ export function main() {
       expect(emitStmt(o.literalMap([['someKey', o.literal(1)]]).toStmt())).toEqual(`{someKey: 1};`);
     });
 
+    it('should apply quotes to each entry within a map produced with literalMap when true', () => {
+      expect(
+          emitStmt(
+              o.literalMap([['a', o.literal('a')], ['*', o.literal('star')]], null, true).toStmt())
+              .replace(/\s+/gm, ''))
+          .toEqual(`{'a':'a','*':'star'};`);
+    });
+
     it('should support blank literals', () => {
       expect(emitStmt(o.literal(null).toStmt())).toEqual('(null as any);');
       expect(emitStmt(o.literal(undefined).toStmt())).toEqual('(undefined as any);');

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

@@ -30,14 +30,14 @@ export function main() {
     it('should select by element name case sensitive', () => {
       matcher.addSelectables(s1 = CssSelector.parse('someTag'), 1);
 
-      expect(matcher.match(CssSelector.parse('SOMEOTHERTAG')[0], selectableCollector))
+      expect(matcher.match(getSelectorFor({tag: 'SOMEOTHERTAG'}), selectableCollector))
           .toEqual(false);
       expect(matched).toEqual([]);
 
-      expect(matcher.match(CssSelector.parse('SOMETAG')[0], selectableCollector)).toEqual(false);
+      expect(matcher.match(getSelectorFor({tag: 'SOMETAG'}), selectableCollector)).toEqual(false);
       expect(matched).toEqual([]);
 
-      expect(matcher.match(CssSelector.parse('someTag')[0], selectableCollector)).toEqual(true);
+      expect(matcher.match(getSelectorFor({tag: 'someTag'}), selectableCollector)).toEqual(true);
       expect(matched).toEqual([s1[0], 1]);
     });
 
@@ -45,21 +45,22 @@ export function main() {
       matcher.addSelectables(s1 = CssSelector.parse('.someClass'), 1);
       matcher.addSelectables(s2 = CssSelector.parse('.someClass.class2'), 2);
 
-      expect(matcher.match(CssSelector.parse('.SOMEOTHERCLASS')[0], selectableCollector))
+      expect(matcher.match(getSelectorFor({classes: 'SOMEOTHERCLASS'}), selectableCollector))
           .toEqual(false);
       expect(matched).toEqual([]);
 
-      expect(matcher.match(CssSelector.parse('.SOMECLASS')[0], selectableCollector)).toEqual(true);
+      expect(matcher.match(getSelectorFor({classes: 'SOMECLASS'}), selectableCollector))
+          .toEqual(true);
       expect(matched).toEqual([s1[0], 1]);
 
       reset();
-      expect(matcher.match(CssSelector.parse('.someClass.class2')[0], selectableCollector))
+      expect(matcher.match(getSelectorFor({classes: 'someClass class2'}), selectableCollector))
           .toEqual(true);
       expect(matched).toEqual([s1[0], 1, s2[0], 2]);
     });
 
     it('should not throw for class name "constructor"', () => {
-      expect(matcher.match(CssSelector.parse('.constructor')[0], selectableCollector))
+      expect(matcher.match(getSelectorFor({classes: 'constructor'}), selectableCollector))
           .toEqual(false);
       expect(matched).toEqual([]);
     });
@@ -68,36 +69,43 @@ export function main() {
       matcher.addSelectables(s1 = CssSelector.parse('[someAttr]'), 1);
       matcher.addSelectables(s2 = CssSelector.parse('[someAttr][someAttr2]'), 2);
 
-      expect(matcher.match(CssSelector.parse('[SOMEOTHERATTR]')[0], selectableCollector))
+      expect(matcher.match(getSelectorFor({attrs: [['SOMEOTHERATTR', '']]}), selectableCollector))
           .toEqual(false);
       expect(matched).toEqual([]);
 
-      expect(matcher.match(CssSelector.parse('[SOMEATTR]')[0], selectableCollector)).toEqual(false);
-      expect(matched).toEqual([]);
-
-      expect(matcher.match(CssSelector.parse('[SOMEATTR=someValue]')[0], selectableCollector))
+      expect(matcher.match(getSelectorFor({attrs: [['SOMEATTR', '']]}), selectableCollector))
           .toEqual(false);
       expect(matched).toEqual([]);
 
-      expect(matcher.match(CssSelector.parse('[someAttr][someAttr2]')[0], selectableCollector))
+      expect(
+          matcher.match(getSelectorFor({attrs: [['SOMEATTR', 'someValue']]}), selectableCollector))
+          .toEqual(false);
+      expect(matched).toEqual([]);
+
+      expect(
+          matcher.match(
+              getSelectorFor({attrs: [['someAttr', ''], ['someAttr2', '']]}), selectableCollector))
           .toEqual(true);
       expect(matched).toEqual([s1[0], 1, s2[0], 2]);
 
       reset();
       expect(matcher.match(
-                 CssSelector.parse('[someAttr=someValue][someAttr2]')[0], selectableCollector))
+                 getSelectorFor({attrs: [['someAttr', 'someValue'], ['someAttr2', '']]}),
+                 selectableCollector))
           .toEqual(true);
       expect(matched).toEqual([s1[0], 1, s2[0], 2]);
 
       reset();
       expect(matcher.match(
-                 CssSelector.parse('[someAttr2][someAttr=someValue]')[0], selectableCollector))
+                 getSelectorFor({attrs: [['someAttr2', ''], ['someAttr', 'someValue']]}),
+                 selectableCollector))
           .toEqual(true);
       expect(matched).toEqual([s1[0], 1, s2[0], 2]);
 
       reset();
       expect(matcher.match(
-                 CssSelector.parse('[someAttr2=someValue][someAttr]')[0], selectableCollector))
+                 getSelectorFor({attrs: [['someAttr2', 'someValue'], ['someAttr', '']]}),
+                 selectableCollector))
           .toEqual(true);
       expect(matched).toEqual([s1[0], 1, s2[0], 2]);
     });
@@ -105,11 +113,13 @@ export function main() {
     it('should support "." in attribute names', () => {
       matcher.addSelectables(s1 = CssSelector.parse('[foo.bar]'), 1);
 
-      expect(matcher.match(CssSelector.parse('[barfoo]')[0], selectableCollector)).toEqual(false);
+      expect(matcher.match(getSelectorFor({attrs: [['barfoo', '']]}), selectableCollector))
+          .toEqual(false);
       expect(matched).toEqual([]);
 
       reset();
-      expect(matcher.match(CssSelector.parse('[foo.bar]')[0], selectableCollector)).toEqual(true);
+      expect(matcher.match(getSelectorFor({attrs: [['foo.bar', '']]}), selectableCollector))
+          .toEqual(true);
       expect(matched).toEqual([s1[0], 1]);
     });
 
@@ -127,15 +137,18 @@ export function main() {
     it('should select by attr name case sensitive and value case insensitive', () => {
       matcher.addSelectables(s1 = CssSelector.parse('[someAttr=someValue]'), 1);
 
-      expect(matcher.match(CssSelector.parse('[SOMEATTR=SOMEOTHERATTR]')[0], selectableCollector))
+      expect(matcher.match(
+                 getSelectorFor({attrs: [['SOMEATTR', 'SOMEOTHERATTR']]}), selectableCollector))
           .toEqual(false);
       expect(matched).toEqual([]);
 
-      expect(matcher.match(CssSelector.parse('[SOMEATTR=SOMEVALUE]')[0], selectableCollector))
+      expect(
+          matcher.match(getSelectorFor({attrs: [['SOMEATTR', 'SOMEVALUE']]}), selectableCollector))
           .toEqual(false);
       expect(matched).toEqual([]);
 
-      expect(matcher.match(CssSelector.parse('[someAttr=SOMEVALUE]')[0], selectableCollector))
+      expect(
+          matcher.match(getSelectorFor({attrs: [['someAttr', 'SOMEVALUE']]}), selectableCollector))
           .toEqual(true);
       expect(matched).toEqual([s1[0], 1]);
     });
@@ -143,31 +156,38 @@ export function main() {
     it('should select by element name, class name and attribute name with value', () => {
       matcher.addSelectables(s1 = CssSelector.parse('someTag.someClass[someAttr=someValue]'), 1);
 
+      expect(
+          matcher.match(
+              getSelectorFor(
+                  {tag: 'someOtherTag', classes: 'someOtherClass', attrs: [['someOtherAttr', '']]}),
+              selectableCollector))
+          .toEqual(false);
+      expect(matched).toEqual([]);
+
       expect(matcher.match(
-                 CssSelector.parse('someOtherTag.someOtherClass[someOtherAttr]')[0],
+                 getSelectorFor(
+                     {tag: 'someTag', classes: 'someOtherClass', attrs: [['someOtherAttr', '']]}),
                  selectableCollector))
           .toEqual(false);
       expect(matched).toEqual([]);
 
-      expect(
-          matcher.match(
-              CssSelector.parse('someTag.someOtherClass[someOtherAttr]')[0], selectableCollector))
+      expect(matcher.match(
+                 getSelectorFor(
+                     {tag: 'someTag', classes: 'someClass', attrs: [['someOtherAttr', '']]}),
+                 selectableCollector))
           .toEqual(false);
       expect(matched).toEqual([]);
 
       expect(matcher.match(
-                 CssSelector.parse('someTag.someClass[someOtherAttr]')[0], selectableCollector))
+                 getSelectorFor({tag: 'someTag', classes: 'someClass', attrs: [['someAttr', '']]}),
+                 selectableCollector))
           .toEqual(false);
       expect(matched).toEqual([]);
 
-      expect(
-          matcher.match(CssSelector.parse('someTag.someClass[someAttr]')[0], selectableCollector))
-          .toEqual(false);
-      expect(matched).toEqual([]);
-
-      expect(
-          matcher.match(
-              CssSelector.parse('someTag.someClass[someAttr=someValue]')[0], selectableCollector))
+      expect(matcher.match(
+                 getSelectorFor(
+                     {tag: 'someTag', classes: 'someClass', attrs: [['someAttr', 'someValue']]}),
+                 selectableCollector))
           .toEqual(true);
       expect(matched).toEqual([s1[0], 1]);
     });
@@ -217,7 +237,9 @@ export function main() {
       matcher.addSelectables(CssSelector.parse(':not(p)'), 4);
       matcher.addSelectables(CssSelector.parse(':not(p[someAttr])'), 5);
 
-      expect(matcher.match(CssSelector.parse('p.someClass[someAttr]')[0], selectableCollector))
+      expect(matcher.match(
+                 getSelectorFor({tag: 'p', classes: 'someClass', attrs: [['someAttr', '']]}),
+                 selectableCollector))
           .toEqual(false);
       expect(matched).toEqual([]);
     });
@@ -228,32 +250,38 @@ export function main() {
       matcher.addSelectables(s3 = CssSelector.parse(':not(.someClass)'), 3);
       matcher.addSelectables(s4 = CssSelector.parse(':not(.someOtherClass[someAttr])'), 4);
 
-      expect(matcher.match(
-                 CssSelector.parse('p[someOtherAttr].someOtherClass')[0], selectableCollector))
+      expect(
+          matcher.match(
+              getSelectorFor({tag: 'p', attrs: [['someOtherAttr', '']], classes: 'someOtherClass'}),
+              selectableCollector))
           .toEqual(true);
       expect(matched).toEqual([s1[0], 1, s2[0], 2, s3[0], 3, s4[0], 4]);
     });
 
     it('should match * with :not selector', () => {
       matcher.addSelectables(CssSelector.parse(':not([a])'), 1);
-      expect(matcher.match(CssSelector.parse('div')[0], () => {})).toEqual(true);
+      expect(matcher.match(getSelectorFor({tag: 'div'}), () => {})).toEqual(true);
     });
 
     it('should match with multiple :not selectors', () => {
       matcher.addSelectables(s1 = CssSelector.parse('div:not([a]):not([b])'), 1);
-      expect(matcher.match(CssSelector.parse('div[a]')[0], selectableCollector)).toBe(false);
-      expect(matcher.match(CssSelector.parse('div[b]')[0], selectableCollector)).toBe(false);
-      expect(matcher.match(CssSelector.parse('div[c]')[0], selectableCollector)).toBe(true);
+      expect(matcher.match(getSelectorFor({tag: 'div', attrs: [['a', '']]}), selectableCollector))
+          .toBe(false);
+      expect(matcher.match(getSelectorFor({tag: 'div', attrs: [['b', '']]}), selectableCollector))
+          .toBe(false);
+      expect(matcher.match(getSelectorFor({tag: 'div', attrs: [['c', '']]}), selectableCollector))
+          .toBe(true);
     });
 
     it('should select with one match in a list', () => {
       matcher.addSelectables(s1 = CssSelector.parse('input[type=text], textbox'), 1);
 
-      expect(matcher.match(CssSelector.parse('textbox')[0], selectableCollector)).toEqual(true);
+      expect(matcher.match(getSelectorFor({tag: 'textbox'}), selectableCollector)).toEqual(true);
       expect(matched).toEqual([s1[1], 1]);
 
       reset();
-      expect(matcher.match(CssSelector.parse('input[type=text]')[0], selectableCollector))
+      expect(matcher.match(
+                 getSelectorFor({tag: 'input', attrs: [['type', 'text']]}), selectableCollector))
           .toEqual(true);
       expect(matched).toEqual([s1[0], 1]);
     });
@@ -261,7 +289,8 @@ export function main() {
     it('should not select twice with two matches in a list', () => {
       matcher.addSelectables(s1 = CssSelector.parse('input, .someClass'), 1);
 
-      expect(matcher.match(CssSelector.parse('input.someclass')[0], selectableCollector))
+      expect(
+          matcher.match(getSelectorFor({tag: 'input', classes: 'someclass'}), selectableCollector))
           .toEqual(true);
       expect(matched.length).toEqual(2);
       expect(matched).toEqual([s1[0], 1]);
@@ -404,3 +433,16 @@ export function main() {
     });
   });
 }
+
+function getSelectorFor(
+    {tag = '', attrs = [], classes = ''}: {tag?: string, attrs?: any[], classes?: string} = {}):
+    CssSelector {
+  const selector = new CssSelector();
+  selector.setElement(tag);
+
+  attrs.forEach(nameValue => { selector.addAttribute(nameValue[0], nameValue[1]); });
+
+  classes.trim().split(/\s+/g).forEach(cName => { selector.addClassName(cName); });
+
+  return selector;
+}

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

@@ -36,6 +36,17 @@ export function main() {
       expect(styleWithImports.styleUrls).toEqual(['http://ng.io/1.css', 'http://ng.io/2.css']);
     });
 
+    it('should ignore "@import" in comments', () => {
+      const css = `
+      @import '1.css';
+      /*@import '2.css';*/
+      `;
+      const styleWithImports = extractStyleUrls(urlResolver, 'http://ng.io', css);
+      expect(styleWithImports.style.trim()).toEqual('');
+      expect(styleWithImports.styleUrls).toContain('http://ng.io/1.css');
+      expect(styleWithImports.styleUrls).not.toContain('http://ng.io/2.css');
+    });
+
     it('should extract "@import url()" urls', () => {
       const css = `
       @import url('3.css');

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(`Template parse errors:
+                .toThrowError(SyntaxError, `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,14 +382,16 @@ 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(`Template parse errors:
+            expect(() => parse('<unknown></unknown>', []))
+                .toThrowError(SyntaxError, `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(`Template parse errors:
+            expect(() => parse('<un-known></un-known>', []))
+                .toThrowError(SyntaxError, `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`);
@@ -397,13 +399,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(`Template parse errors:
+                .toThrowError(SyntaxError, `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(`Template parse errors:
+                .toThrowError(SyntaxError, `Template parse errors:
 Binding to attribute 'onEvent' is disallowed for security reasons ("<my-component [ERROR ->][attr.onEvent]="bar"></my-component>"): TestComp@0:14`);
           });
         });
@@ -445,6 +447,7 @@ 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/);
            });
 
@@ -479,6 +482,7 @@ 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`);
         });
 
@@ -494,6 +498,7 @@ 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`);
         });
 
@@ -618,6 +623,23 @@ Binding to attribute 'onEvent' is disallowed for security reasons ("<my-componen
              ]);
            });
 
+        it('should parse directive dotted properties', () => {
+          const dirA =
+              CompileDirectiveMetadata
+                  .create({
+                    selector: '[dot.name]',
+                    type: createTypeMeta({reference: {filePath: someModuleUrl, name: 'DirA'}}),
+                    inputs: ['localName: dot.name'],
+                  })
+                  .toSummary();
+
+          expect(humanizeTplAst(parse('<div [dot.name]="expr"></div>', [dirA]))).toEqual([
+            [ElementAst, 'div'],
+            [DirectiveAst, dirA],
+            [BoundDirectivePropertyAst, 'localName', 'expr'],
+          ]);
+        });
+
         it('should locate directives in property bindings', () => {
           const dirA =
               CompileDirectiveMetadata
@@ -940,8 +962,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(
-                  `Template parse errors:\n` +
-                  `Mixing multi and non multi provider is not possible for token service0 ("[ERROR ->]<div dirA dirB>"): TestComp@0:0`);
+                  SyntaxError, `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', () => {
@@ -1033,6 +1055,7 @@ 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');
         });
 
@@ -1047,6 +1070,7 @@ 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');
         });
 
@@ -1098,23 +1122,26 @@ 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(`Template parse errors:
+          expect(() => parse('<div #a="dirA"></div>', []))
+              .toThrowError(SyntaxError, `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(`Template parse errors:
+          expect(() => parse('<div #a-b></div>', []))
+              .toThrowError(SyntaxError, `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(`Template parse errors:
+          expect(() => parse('<div let-a></div>', []))
+              .toThrowError(SyntaxError, `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(`Template parse errors:
+              .toThrowError(SyntaxError, `Template parse errors:
 Reference "#a" is defined several times ("<div #a></div><div [ERROR ->]#a></div>"): TestComp@0:19`);
 
         });
@@ -1234,8 +1261,15 @@ Reference "#a" is defined several times ("<div #a></div><div [ERROR ->]#a></div>
         });
 
         it('should parse variables via let ...', () => {
-          expect(humanizeTplAst(parse('<div *ngIf="let a=b">', [
-          ]))).toEqual([[EmbeddedTemplateAst], [VariableAst, 'a', 'b'], [ElementAst, 'div']]);
+          const targetAst = [
+            [EmbeddedTemplateAst],
+            [VariableAst, 'a', 'b'],
+            [ElementAst, 'div'],
+          ];
+
+          expect(humanizeTplAst(parse('<div *ngIf="let a=b">', []))).toEqual(targetAst);
+
+          expect(humanizeTplAst(parse('<div data-*ngIf="let a=b">', []))).toEqual(targetAst);
         });
 
         describe('directives', () => {
@@ -1466,8 +1500,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(
-                `Template parse errors:\n` +
-                `<ng-content> element cannot have content. ("[ERROR ->]<ng-content>content</ng-content>"): TestComp@0:0`);
+                SyntaxError, `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',
@@ -1477,18 +1511,20 @@ 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(`Template parse errors:
+        expect(() => parse('<div *ngIf *ngFor>', []))
+            .toThrowError(SyntaxError, `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(`Template parse errors:
+            .toThrowError(SyntaxError, `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(`Template parse errors:
+        expect(() => parse('<div [invalidProp]></div>', []))
+            .toThrowError(SyntaxError, `Template parse errors:
 Can't bind to 'invalidProp' since it isn't a known property of 'div'. ("<div [ERROR ->][invalidProp]></div>"): TestComp@0:5`);
       });
 
@@ -1501,12 +1537,13 @@ 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(`Template parse errors:
+        expect(() => parse('<div></div>', [dirA])).toThrowError(SyntaxError, `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(`Template parse errors:
+        expect(() => parse('<div [prop]="a b"></div>', []))
+            .toThrowError(SyntaxError, `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`);
       });
 
@@ -1544,10 +1581,10 @@ Parser Error: Unexpected token 'b' at column 3 in [a b] in TestComp@0:5 ("<div [
                 .toSummary();
         expect(() => parse('<div>', [dirB, dirA]))
             .toThrowError(
-                `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`);
+                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`);
       });
 
       it('should not allow components or element bindings nor dom events on explicit embedded templates',
@@ -1562,7 +1599,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(`Template parse errors:
+               .toThrowError(SyntaxError, `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`);
@@ -1578,7 +1615,8 @@ 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(`Template parse errors:
+        expect(() => parse('<div *a="b"></div>', [dirA]))
+            .toThrowError(SyntaxError, `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`);
       });
@@ -1838,7 +1876,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(`Template parse errors:
+        expect(() => parse('{{a | test}}', [])).toThrowError(SyntaxError, `Template parse errors:
 The pipe 'test' could not be found ("{{[ERROR ->]a | test}}"): TestComp@0:2`);
       });
 

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

@@ -10,14 +10,12 @@
 import {__core_private__ as r} from '@angular/core';
 
 export type ViewMetadata = typeof r._ViewMetadata;
-export var ViewMetadata: typeof r.ViewMetadata = r.ViewMetadata;
-
-
+export const ViewMetadata: typeof r.ViewMetadata = r.ViewMetadata;
 
 import {__core_private_testing__ as r2} from '@angular/core/testing';
 
 export type TestingCompiler = typeof r2._TestingCompiler;
-export var TestingCompiler: typeof r2.TestingCompiler = r2.TestingCompiler;
+export const TestingCompiler: typeof r2.TestingCompiler = r2.TestingCompiler;
 
 export type TestingCompilerFactory = typeof r2._TestingCompilerFactory;
-export var TestingCompilerFactory: typeof r2.TestingCompilerFactory = r2.TestingCompilerFactory;
+export const TestingCompilerFactory: typeof r2.TestingCompilerFactory = r2.TestingCompilerFactory;

modules/@angular/compiler/testing/test_bindings.ts

@@ -18,7 +18,7 @@ export function createUrlResolverWithoutPackagePrefix(): UrlResolver {
 // This provider is put here just so that we can access it from multiple
 // internal test packages.
 // TODO: get rid of it or move to a separate @angular/internal_testing package
-export var TEST_COMPILER_PROVIDERS: Provider[] = [
+export const TEST_COMPILER_PROVIDERS: Provider[] = [
   {provide: ElementSchemaRegistry, useValue: new MockSchemaRegistry({}, {}, {}, [], [])},
   {provide: ResourceLoader, useClass: MockResourceLoader},
   {provide: UrlResolver, useFactory: createUrlResolverWithoutPackagePrefix}

modules/@angular/core/package.json

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

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

@@ -11,6 +11,7 @@ import {ApplicationInitStatus} from './application_init';
 import {ApplicationRef, ApplicationRef_} from './application_ref';
 import {APP_ID_RANDOM_PROVIDER} from './application_tokens';
 import {IterableDiffers, KeyValueDiffers, defaultIterableDiffers, defaultKeyValueDiffers} from './change_detection/change_detection';
+import {Inject, Optional, SkipSelf} from './di/metadata';
 import {LOCALE_ID} from './i18n/tokens';
 import {Compiler} from './linker/compiler';
 import {ViewUtils} from './linker/view_utils';
@@ -24,6 +25,10 @@ export function _keyValueDiffersFactory() {
   return defaultKeyValueDiffers;
 }
 
+export function _localeFactory(locale?: string): string {
+  return locale || 'en-US';
+}
+
 /**
  * This module includes the providers of @angular/core that are needed
  * to bootstrap components via `ApplicationRef`.
@@ -41,7 +46,11 @@ export function _keyValueDiffersFactory() {
     AnimationQueue,
     {provide: IterableDiffers, useFactory: _iterableDiffersFactory},
     {provide: KeyValueDiffers, useFactory: _keyValueDiffersFactory},
-    {provide: LOCALE_ID, useValue: 'en-US'},
+    {
+      provide: LOCALE_ID,
+      useFactory: _localeFactory,
+      deps: [[new Inject(LOCALE_ID), new Optional(), new SkipSelf()]]
+    },
   ]
 })
 export class ApplicationModule {

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(
-    parentPlaformFactory: (extraProviders?: Provider[]) => PlatformRef, name: string,
+    parentPlatformFactory: (extraProviders?: Provider[]) => PlatformRef, name: string,
     providers: Provider[] = []): (extraProviders?: Provider[]) => PlatformRef {
   const marker = new OpaqueToken(`Platform: ${name}`);
   return (extraProviders: Provider[] = []) => {
     if (!getPlatform()) {
-      if (parentPlaformFactory) {
-        parentPlaformFactory(
+      if (parentPlatformFactory) {
+        parentPlatformFactory(
             providers.concat(extraProviders).concat({provide: marker, useValue: true}));
       } else {
         createPlatform(ReflectiveInjector.resolveAndCreate(
@@ -469,7 +469,7 @@ export class ApplicationRef_ extends ApplicationRef {
     this._loadComponent(compRef);
     if (isDevMode()) {
       this._console.log(
-          `Angular 2 is running in the development mode. Call enableProdMode() to enable the production mode.`);
+          `Angular is running in the development mode. Call enableProdMode() to enable the production mode.`);
     }
     return compRef;
   }

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

@@ -43,7 +43,7 @@ import * as api from './render/api';
 import * as decorators from './util/decorators';
 import {isPromise} from './util/lang';
 
-export var __core_private__: {
+export const __core_private__: {
   isDefaultChangeDetectionStrategy: typeof constants.isDefaultChangeDetectionStrategy,
   ChangeDetectorStatus: typeof constants.ChangeDetectorStatus,
   _ChangeDetectorStatus?: constants.ChangeDetectorStatus,

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

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