fix(form): fix merge errors

docs(changelog): add changelog for 2.3.1
build: bump angular to 2.3.1 & tsc-wrapped to 0.5.0
2016-12-14 18:22:03 -08:00 · 2016-12-14 18:14:34 -08:00 · 2016-12-14 18:11:35 -08:00 · 2016-12-14 18:08:54 -08:00 · 2016-12-14 18:08:48 -08:00 · 2016-12-14 18:08:43 -08:00
265 changed files with 8503 additions and 9900 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,107 +1,3 @@
-<a name="4.0.0-beta.2"></a>
-# [4.0.0-beta.2](https://github.com/angular/angular/compare/4.0.0-beta.1...4.0.0-beta.2) (2017-01-06)
-
-
-### Features
-
-* **compiler:** generate less code for bindings to DOM elements ([db49d42](https://github.com/angular/angular/commit/db49d42))
-* **compiler:** generate proper reexports in `.ngfactory.ts` files to not need transitive deps for compiling `.ngfactory.ts` files. ([#13524](https://github.com/angular/angular/issues/13524)) ([9c69703](https://github.com/angular/angular/commit/9c69703)), closes [#12787](https://github.com/angular/angular/issues/12787)
-* **router:** add an extra argument to CanDeactivate interface ([#13560](https://github.com/angular/angular/issues/13560)) ([69fa3bb](https://github.com/angular/angular/commit/69fa3bb)), closes [#9853](https://github.com/angular/angular/issues/9853)
-
-
-### Bug Fixes
-
-* **common:** improve error message by adding a link to trackBy docs ([#13634](https://github.com/angular/angular/issues/13634)) ([6976903](https://github.com/angular/angular/commit/6976903))
-* **common:** do not override locale provided on bootstrap ([#13654](https://github.com/angular/angular/issues/13654)) ([2dd6280](https://github.com/angular/angular/commit/2dd6280)), closes [#13607](https://github.com/angular/angular/issues/13607)
-* **common:** allow null/undefined values for `NgForTrackBy` ([f88cd2f](https://github.com/angular/angular/commit/f88cd2f)), 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)) ([7690d02](https://github.com/angular/angular/commit/7690d02)), closes [#13565](https://github.com/angular/angular/issues/13565)
-* **compiler:** improve error message for undefined providers ([#13546](https://github.com/angular/angular/issues/13546)) ([6b02b80](https://github.com/angular/angular/commit/6b02b80)), closes [#10835](https://github.com/angular/angular/issues/10835)
-* **compiler:** improve the error when template is not a string ([2c0c86e](https://github.com/angular/angular/commit/2c0c86e)), closes [#8708](https://github.com/angular/angular/issues/8708) [#13377](https://github.com/angular/angular/issues/13377)
-* **compiler:** query `<template>` elements before their children. ([#13677](https://github.com/angular/angular/issues/13677)) ([7c21064](https://github.com/angular/angular/commit/7c21064)), closes [#13118](https://github.com/angular/angular/issues/13118) [#13167](https://github.com/angular/angular/issues/13167)
-* **compiler:** throw an error for invalid provider ([#13544](https://github.com/angular/angular/issues/13544)) ([445ed43](https://github.com/angular/angular/commit/445ed43)), closes [#8870](https://github.com/angular/angular/issues/8870)
-* **compiler:** allow "." in attribute selectors ([#13653](https://github.com/angular/angular/issues/13653)) ([881eb89](https://github.com/angular/angular/commit/881eb89)), 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)) ([21030e9](https://github.com/angular/angular/commit/21030e9))
-* **core:** animations should blend in all previously transitioned styles into next animation if interrupted ([#13148](https://github.com/angular/angular/issues/13148)) ([889b48d](https://github.com/angular/angular/commit/889b48d))
-* **core:** remove reference to "Angular 2" in dev mode warning ([#13751](https://github.com/angular/angular/issues/13751)) ([c5c53f3](https://github.com/angular/angular/commit/c5c53f3))
-* **forms:** Validators.required properly validate arrays ([#13362](https://github.com/angular/angular/issues/13362)) ([9898d8f](https://github.com/angular/angular/commit/9898d8f)), closes [#12274](https://github.com/angular/angular/issues/12274)
-* **i18n:** parse ICU messages while normalizing templates ([e74d8aa](https://github.com/angular/angular/commit/e74d8aa))
-* **language-service:** support TypeScript 2.1 ([#13655](https://github.com/angular/angular/issues/13655)) ([8063b0d](https://github.com/angular/angular/commit/8063b0d))
-* **router:** fix lazy loaded module with wildcard route ([#13649](https://github.com/angular/angular/issues/13649)) ([0eca960](https://github.com/angular/angular/commit/0eca960)), closes [#12955](https://github.com/angular/angular/issues/12955)
-* **router:** routerLink support of null ([#13380](https://github.com/angular/angular/issues/13380)) ([174334d](https://github.com/angular/angular/commit/174334d)), 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)) ([07e0fce](https://github.com/angular/angular/commit/07e0fce)), closes [#12912](https://github.com/angular/angular/issues/12912)
-* **testing:** improve misleading error message when don't call compileComponents ([#13543](https://github.com/angular/angular/issues/13543)) ([67380d4](https://github.com/angular/angular/commit/67380d4)), closes [#11301](https://github.com/angular/angular/issues/11301)
-* **upgrade:** fix/improve support for lifecycle hooks ([#13020](https://github.com/angular/angular/issues/13020)) ([e5c4e58](https://github.com/angular/angular/commit/e5c4e58))
-
-
-### BREAKING CHANGES
-
-* **core**: `SimpleChange` now takes an additional argument that defines whether this is the first
-change or not. This is a low profile API and we don't expect anyone to be affected by this change.
-If you are impacted by this change please file an issue. ([465516b](https://github.com/angular/angular/commit/465516b))
-
-
-
-<a name="4.0.0-beta.1"></a>
-# [4.0.0-beta.1](https://github.com/angular/angular/compare/2.4.0-marker...4.0.0-beta.1) (2016-12-22)
-
-### Features
-
-* **upgrade:** support the `$doCheck()` lifecycle hook in `UpgradeComponent` ([#13015](https://github.com/angular/angular/issues/13015)) ([9da4c25](https://github.com/angular/angular/commit/9da4c25))
-
-Note: 4.0.0-beta.1 release also contains all the changes present in the 2.4.0 and the 2.4.1 releases.
-
-<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="4.0.0-beta.0"></a>
-# [4.0.0-beta.0](https://github.com/angular/angular/compare/2.3.0...4.0.0-beta.0) (2016-12-15)
-
-
-### Features
-
-* **common:** add a `titlecase` pipe ([#13324](https://github.com/angular/angular/issues/13324)) ([61d7c1e](https://github.com/angular/angular/commit/61d7c1e)), closes [#11436](https://github.com/angular/angular/issues/11436)
-* **common:** export NgLocaleLocalization ([#13367](https://github.com/angular/angular/issues/13367)) ([56dce0e](https://github.com/angular/angular/commit/56dce0e)), closes [#11921](https://github.com/angular/angular/issues/11921)
-* **compiler:** add id property to i18nMessage ([6dd5201](https://github.com/angular/angular/commit/6dd5201))
-* **compiler:** digest methods return i18nMessage id if sets ([562f7a2](https://github.com/angular/angular/commit/562f7a2))
-* **forms:** add novalidate by default ([#13092](https://github.com/angular/angular/issues/13092)) ([4c35be3](https://github.com/angular/angular/commit/4c35be3))
-* **http:** simplify URLSearchParams creation ([#13338](https://github.com/angular/angular/issues/13338)) ([90c2235](https://github.com/angular/angular/commit/90c2235)), closes [#8858](https://github.com/angular/angular/issues/8858)
-* **language-service:** warn when a method isn't called in an event ([#13437](https://github.com/angular/angular/issues/13437)) ([9ec0a4e](https://github.com/angular/angular/commit/9ec0a4e))
-* **platform browser:** introduce Meta service ([#12322](https://github.com/angular/angular/issues/12322)) ([72361fb](https://github.com/angular/angular/commit/72361fb))
-* **router:** routerLink add tabindex attribute ([#13094](https://github.com/angular/angular/issues/13094)) ([a006c14](https://github.com/angular/angular/commit/a006c14)), closes [#10895](https://github.com/angular/angular/issues/10895)
-* **testing:** add overrideTemplate method ([#13372](https://github.com/angular/angular/issues/13372)) ([169ed82](https://github.com/angular/angular/commit/169ed82)), closes [#10685](https://github.com/angular/angular/issues/10685)
-* **common** ngIf now supports else; saves condition to local var ([b4db73d](https://github.com/angular/angular/commit/b4db73d)), closes [#13061](https://github.com/angular/angular/issues/13061) [#13297](https://github.com/angular/angular/issues/13297)
-
-Note: 4.0.0-beta.0 release also contains all the changes present in the 2.3.1 release.
-
 <a name="2.3.1"></a>
 ## [2.3.1](https://github.com/angular/angular/compare/2.3.0...2.3.1) (2016-12-15)

@ -124,20 +20,25 @@ Note: 4.0.0-beta.0 release also contains all the changes present in the 2.3.1 re
 * **compiler:** update to metadata version 3 ([#13464](https://github.com/angular/angular/issues/13464)) ([b9b557c](https://github.com/angular/angular/commit/b9b557c))
 * **core:** detectChanges() doesn't work on detached instance ([4d6ac9d](https://github.com/angular/angular/commit/4d6ac9d)), closes [#13426](https://github.com/angular/angular/issues/13426) [#13472](https://github.com/angular/angular/issues/13472)
 * **core:** properly destroy embedded Views attatched to ApplicationRef ([#13459](https://github.com/angular/angular/issues/13459)) ([d40bbf4](https://github.com/angular/angular/commit/d40bbf4)), closes [#13062](https://github.com/angular/angular/issues/13062)
-* **core:** remove logError from logGroup ([#12925](https://github.com/angular/angular/issues/12925)) ([5fab871](https://github.com/angular/angular/commit/5fab871))
+* **dom_adapter:** remove logError from logGroup ([#12925](https://github.com/angular/angular/issues/12925)) ([5fab871](https://github.com/angular/angular/commit/5fab871))
 * **forms:** ensure `select[multiple]` retains selections ([b3dcff0](https://github.com/angular/angular/commit/b3dcff0)), closes [#12527](https://github.com/angular/angular/issues/12527) [#12654](https://github.com/angular/angular/issues/12654)
 * **forms:** fix Validators.min/maxLength with FormArray ([#13095](https://github.com/angular/angular/issues/13095)) ([7383e4a](https://github.com/angular/angular/commit/7383e4a)), closes [#13089](https://github.com/angular/angular/issues/13089)
 * **forms:** introduce checkbox required validator ([124267c](https://github.com/angular/angular/commit/124267c)), closes [#11459](https://github.com/angular/angular/issues/11459) [#13364](https://github.com/angular/angular/issues/13364)
 * **http:** check response body text against undefined ([#13017](https://github.com/angular/angular/issues/13017)) ([f106a18](https://github.com/angular/angular/commit/f106a18))
 * **http:** create a copy of headers when merge options ([#13365](https://github.com/angular/angular/issues/13365)) ([65c9b5b](https://github.com/angular/angular/commit/65c9b5b)), closes [#11980](https://github.com/angular/angular/issues/11980)
 * **language-service:** correctly type `undefined` ([0a7364f](https://github.com/angular/angular/commit/0a7364f)), closes [#13412](https://github.com/angular/angular/issues/13412) [#13414](https://github.com/angular/angular/issues/13414)
-* **compiler**: better error when directive not listed in NgModule.declarations ([b0cd514](https://github.com/angular/angular/commit/b0cd514))
+* 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))
 * **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)


@ -145,15 +46,6 @@ Note: 4.0.0-beta.0 release also contains all the changes present in the 2.3.1 re

 * **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)
--- a/DEVELOPER.md
+++ b/DEVELOPER.md
@ -1,6 +1,6 @@
-# Building and Testing Angular
+# Building and Testing Angular 2 for JS

-This document describes how to set up your development environment to build and test Angular.
+This document describes how to set up your development environment to build and test Angular 2 JS version. 
 It also explains the basic mechanics of using `git`, `node`, and `npm`.

 * [Prerequisite Software](#prerequisite-software)
@ -74,15 +74,6 @@ 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**:
@ -133,8 +124,7 @@ If you happen to modify the public API of Angular, API golden files must be upda
 $ gulp public-api:update
 ```

-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.
+Note: The command `./test.sh tools` fails when the API doesn't match the golden files.

 ## <a name="clang-format"></a> Formatting your source code

@ -147,32 +137,4 @@ 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.
--- a/karma-js.conf.js
+++ b/karma-js.conf.js
@ -24,25 +24,17 @@ module.exports = function(config) {
      'node_modules/core-js/client/core.js',
      // include Angular v1 for upgrade module testing
      'node_modules/angular/angular.js',
-      'node_modules/angular-mocks/angular-mocks.js',

-      'node_modules/zone.js/dist/zone.js',
-      'node_modules/zone.js/dist/long-stack-trace-zone.js',
-      'node_modules/zone.js/dist/proxy.js',
-      'node_modules/zone.js/dist/sync-test.js',
-      'node_modules/zone.js/dist/jasmine-patch.js',
-      'node_modules/zone.js/dist/async-test.js',
+      'node_modules/zone.js/dist/zone.js', 'node_modules/zone.js/dist/long-stack-trace-zone.js',
+      'node_modules/zone.js/dist/proxy.js', 'node_modules/zone.js/dist/sync-test.js',
+      'node_modules/zone.js/dist/jasmine-patch.js', 'node_modules/zone.js/dist/async-test.js',
      'node_modules/zone.js/dist/fake-async-test.js',

      // Including systemjs because it defines `__eval`, which produces correct stack traces.
-      'shims_for_IE.js',
-      'node_modules/systemjs/dist/system.src.js',
+      'shims_for_IE.js', 'node_modules/systemjs/dist/system.src.js',
      {pattern: 'node_modules/rxjs/**', included: false, watched: false, served: true},
-      'node_modules/reflect-metadata/Reflect.js',
-      'tools/build/file2modulename.js',
-      'test-main.js',
-      {pattern: 'dist/all/empty.*', included: false, watched: false},
-      {
+      'node_modules/reflect-metadata/Reflect.js', 'tools/build/file2modulename.js', 'test-main.js',
+      {pattern: 'dist/all/empty.*', included: false, watched: false}, {
        pattern: 'modules/@angular/platform-browser/test/static_assets/**',
        included: false,
        watched: false
--- a/modules/@angular/benchpress/package.json
+++ b/modules/@angular/benchpress/package.json
@ -7,7 +7,7 @@
  "dependencies": {
    "@angular/core": "^2.0.0-rc.7",
    "reflect-metadata": "^0.1.2",
-    "rxjs": "^5.0.1",
+    "rxjs": "5.0.0-rc.4",
    "jpm": "1.1.4",
    "firefox-profile": "0.4.0",
    "selenium-webdriver": "^2.53.3"
--- a/modules/@angular/common/src/common.ts
+++ b/modules/@angular/common/src/common.ts
@ -12,9 +12,9 @@
 * Entry point for all public APIs of the common package.
 */
 export * from './location/index';
-export {NgLocaleLocalization, NgLocalization} from './localization';
+export {NgLocalization} from './localization';
 export {CommonModule} from './common_module';
 export {NgClass, NgFor, NgIf, NgPlural, NgPluralCase, NgStyle, NgSwitch, NgSwitchCase, NgSwitchDefault, NgTemplateOutlet} from './directives/index';
-export {AsyncPipe, DatePipe, I18nPluralPipe, I18nSelectPipe, JsonPipe, LowerCasePipe, CurrencyPipe, DecimalPipe, PercentPipe, SlicePipe, UpperCasePipe, TitleCasePipe} from './pipes/index';
+export {AsyncPipe, DatePipe, I18nPluralPipe, I18nSelectPipe, JsonPipe, LowerCasePipe, CurrencyPipe, DecimalPipe, PercentPipe, SlicePipe, UpperCasePipe} from './pipes/index';
 export {VERSION} from './version';
 export {Version} from '@angular/core';
--- a/modules/@angular/common/src/directives/ng_class.ts
+++ b/modules/@angular/common/src/directives/ng_class.ts
@ -25,8 +25,6 @@ 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
--- a/modules/@angular/common/src/directives/ng_for.ts
+++ b/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, isDevMode} from '@angular/core';
+import {ChangeDetectorRef, CollectionChangeRecord, DefaultIterableDiffer, Directive, DoCheck, EmbeddedViewRef, Input, IterableDiffer, IterableDiffers, OnChanges, SimpleChanges, TemplateRef, TrackByFn, ViewContainerRef} from '@angular/core';

 import {getTypeNameForDebugging} from '../facade/lang';

@ -89,23 +89,9 @@ export class NgForRow {
@Directive({selector: '[ngFor][ngForOf]'})
 export class NgFor implements DoCheck, OnChanges {
  @Input() ngForOf: any;
-  @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; }
+  @Input() ngForTrackBy: TrackByFn;

  private _differ: IterableDiffer = null;
-  private _trackByFn: TrackByFn;

  constructor(
      private _viewContainer: ViewContainerRef, private _template: TemplateRef<NgForRow>,
@ -133,7 +119,7 @@ export class NgFor implements DoCheck, OnChanges {
    }
  }

-  ngDoCheck(): void {
+  ngDoCheck() {
    if (this._differ) {
      const changes = this._differ.diff(this.ngForOf);
      if (changes) this._applyChanges(changes);
--- a/modules/@angular/common/src/directives/ng_if.ts
+++ b/modules/@angular/common/src/directives/ng_if.ts
@ -6,152 +6,46 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {Directive, EmbeddedViewRef, Input, TemplateRef, ViewContainerRef} from '@angular/core';
-
+import {Directive, Input, TemplateRef, ViewContainerRef} from '@angular/core';

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

-  constructor(private _viewContainer: ViewContainerRef, templateRef: TemplateRef<NgIfContext>) {
-    this._thenTemplateRef = templateRef;
-  }
+  constructor(private _viewContainer: ViewContainerRef, private _template: TemplateRef<Object>) {}

  @Input()
  set ngIf(condition: any) {
-    this._context.$implicit = condition;
-    this._updateView();
-  }
-
-  @Input()
-  set ngIfThen(templateRef: TemplateRef<NgIfContext>) {
-    this._thenTemplateRef = templateRef;
-    this._thenViewRef = null;  // clear previous view if any.
-    this._updateView();
-  }
-
-  @Input()
-  set ngIfElse(templateRef: TemplateRef<NgIfContext>) {
-    this._elseTemplateRef = templateRef;
-    this._elseViewRef = null;  // clear previous view if any.
-    this._updateView();
-  }
-
-  private _updateView() {
-    if (this._context.$implicit) {
-      if (!this._thenViewRef) {
-        this._viewContainer.clear();
-        this._elseViewRef = null;
-        if (this._thenTemplateRef) {
-          this._thenViewRef =
-              this._viewContainer.createEmbeddedView(this._thenTemplateRef, this._context);
-        }
-      }
-    } else {
-      if (!this._elseViewRef) {
-        this._viewContainer.clear();
-        this._thenViewRef = null;
-        if (this._elseTemplateRef) {
-          this._elseViewRef =
-              this._viewContainer.createEmbeddedView(this._elseTemplateRef, this._context);
-        }
-      }
+    if (condition && !this._hasView) {
+      this._hasView = true;
+      this._viewContainer.createEmbeddedView(this._template);
+    } else if (!condition && this._hasView) {
+      this._hasView = false;
+      this._viewContainer.clear();
    }
  }
 }
-
-export class NgIfContext { public $implicit: any = null; }
--- a/modules/@angular/common/src/localization.ts
+++ b/modules/@angular/common/src/localization.ts
@ -49,10 +49,10 @@ export function getPluralCategory(
 */
@Injectable()
 export class NgLocaleLocalization extends NgLocalization {
-  constructor(@Inject(LOCALE_ID) protected locale: string) { super(); }
+  constructor(@Inject(LOCALE_ID) private _locale: string) { super(); }

  getPluralCategory(value: any): string {
-    const plural = getPluralCase(this.locale, value);
+    const plural = getPluralCase(this._locale, value);

    switch (plural) {
      case Plural.Zero:
@ -431,4 +431,4 @@ export function getPluralCase(locale: string, nLike: number | string): Plural {
    default:
      return Plural.Other;
  }
-}
+}
--- a/modules/@angular/common/src/pipes/case_conversion_pipes.ts
+++ b/modules/@angular/common/src/pipes/case_conversion_pipes.ts
@ -1,72 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {Pipe, PipeTransform} from '@angular/core';
-import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
-
-/**
- * Transforms text to lowercase.
- *
- * {@example  common/pipes/ts/lowerupper_pipe.ts region='LowerUpperPipe' }
- *
- * @stable
- */
-@Pipe({name: 'lowercase'})
-export class LowerCasePipe implements PipeTransform {
-  transform(value: string): string {
-    if (!value) return value;
-    if (typeof value !== 'string') {
-      throw new InvalidPipeArgumentError(LowerCasePipe, value);
-    }
-    return value.toLowerCase();
-  }
-}
-
-
-/**
- * Helper method to transform a single word to titlecase.
- *
- * @stable
- */
-function titleCaseWord(word: string) {
-  if (!word) return word;
-  return word[0].toUpperCase() + word.substr(1).toLowerCase();
-}
-
-/**
- * Transforms text to titlecase.
- *
- * @stable
- */
-@Pipe({name: 'titlecase'})
-export class TitleCasePipe implements PipeTransform {
-  transform(value: string): string {
-    if (!value) return value;
-    if (typeof value !== 'string') {
-      throw new InvalidPipeArgumentError(TitleCasePipe, value);
-    }
-
-    return value.split(/\b/g).map(word => titleCaseWord(word)).join('');
-  }
-}
-
-/**
- * Transforms text to uppercase.
- *
- * @stable
- */
-@Pipe({name: 'uppercase'})
-export class UpperCasePipe implements PipeTransform {
-  transform(value: string): string {
-    if (!value) return value;
-    if (typeof value !== 'string') {
-      throw new InvalidPipeArgumentError(UpperCasePipe, value);
-    }
-    return value.toUpperCase();
-  }
-}
--- a/modules/@angular/common/src/pipes/index.ts
+++ b/modules/@angular/common/src/pipes/index.ts
@ -12,13 +12,14 @@
 * This module provides a set of common Pipes.
 */
 import {AsyncPipe} from './async_pipe';
-import {LowerCasePipe, TitleCasePipe, UpperCasePipe} from './case_conversion_pipes';
 import {DatePipe} from './date_pipe';
 import {I18nPluralPipe} from './i18n_plural_pipe';
 import {I18nSelectPipe} from './i18n_select_pipe';
 import {JsonPipe} from './json_pipe';
+import {LowerCasePipe} from './lowercase_pipe';
 import {CurrencyPipe, DecimalPipe, PercentPipe} from './number_pipe';
 import {SlicePipe} from './slice_pipe';
+import {UpperCasePipe} from './uppercase_pipe';

 export {
  AsyncPipe,
@ -31,11 +32,9 @@ export {
  LowerCasePipe,
  PercentPipe,
  SlicePipe,
-  TitleCasePipe,
  UpperCasePipe
 };

-
 /**
 * A collection of Angular pipes that are likely to be used in each and every application.
 */
@ -47,7 +46,6 @@ export const COMMON_PIPES = [
  SlicePipe,
  DecimalPipe,
  PercentPipe,
-  TitleCasePipe,
  CurrencyPipe,
  DatePipe,
  I18nPluralPipe,
--- a/modules/@angular/common/src/pipes/lowercase_pipe.ts
+++ b/modules/@angular/common/src/pipes/lowercase_pipe.ts
@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Pipe, PipeTransform} from '@angular/core';
+import {isBlank} from '../facade/lang';
+import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
+
+
+/**
+ * @ngModule CommonModule
+ * @whatItDoes Transforms string to lowercase.
+ * @howToUse `expression | lowercase`
+ * @description
+ *
+ * Converts value into a lowercase string using `String.prototype.toLowerCase()`.
+ *
+ * ### Example
+ *
+ * {@example common/pipes/ts/lowerupper_pipe.ts region='LowerUpperPipe'}
+ *
+ * @stable
+ */
+@Pipe({name: 'lowercase'})
+export class LowerCasePipe implements PipeTransform {
+  transform(value: string): string {
+    if (isBlank(value)) return value;
+    if (typeof value !== 'string') {
+      throw new InvalidPipeArgumentError(LowerCasePipe, value);
+    }
+    return value.toLowerCase();
+  }
+}
--- a/modules/@angular/common/src/pipes/uppercase_pipe.ts
+++ b/modules/@angular/common/src/pipes/uppercase_pipe.ts
@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {Pipe, PipeTransform} from '@angular/core';
+import {isBlank} from '../facade/lang';
+import {InvalidPipeArgumentError} from './invalid_pipe_argument_error';
+
+/**
+ * @ngModule CommonModule
+ * @whatItDoes Transforms string to uppercase.
+ * @howToUse `expression | uppercase`
+ * @description
+ *
+ * Converts value into an uppercase string using `String.prototype.toUpperCase()`.
+ *
+ * ### Example
+ *
+ * {@example common/pipes/ts/lowerupper_pipe.ts region='LowerUpperPipe'}
+ *
+ * @stable
+ */
+@Pipe({name: 'uppercase'})
+export class UpperCasePipe implements PipeTransform {
+  transform(value: string): string {
+    if (isBlank(value)) return value;
+    if (typeof value !== 'string') {
+      throw new InvalidPipeArgumentError(UpperCasePipe, value);
+    }
+    return value.toUpperCase();
+  }
+}
--- a/modules/@angular/common/test/directives/ng_for_spec.ts
+++ b/modules/@angular/common/test/directives/ng_for_spec.ts
@ -294,27 +294,6 @@ 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>`;
@ -354,7 +333,6 @@ 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>`;
@ -390,7 +368,6 @@ 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; }
@ -407,4 +384,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);
-}
+}
--- a/modules/@angular/common/test/directives/ng_if_spec.ts
+++ b/modules/@angular/common/test/directives/ng_if_spec.ts
@ -153,78 +153,6 @@ export function main() {
         expect(getDOM().hasClass(getDOM().querySelector(fixture.nativeElement, 'span'), 'foo'))
             .toBe(true);
       }));
-
-    describe('else', () => {
-      it('should support else', async(() => {
-           const template = '<div>' +
-               '<span *ngIf="booleanCondition; else elseBlock">TRUE</span>' +
-               '<template #elseBlock>FALSE</template>' +
-               '</div>';
-
-           fixture = createTestComponent(template);
-
-           fixture.detectChanges();
-           expect(fixture.nativeElement).toHaveText('TRUE');
-
-           getComponent().booleanCondition = false;
-           fixture.detectChanges();
-           expect(fixture.nativeElement).toHaveText('FALSE');
-         }));
-
-      it('should support then and else', async(() => {
-           const template = '<div>' +
-               '<span *ngIf="booleanCondition; then thenBlock; else elseBlock">IGNORE</span>' +
-               '<template #thenBlock>THEN</template>' +
-               '<template #elseBlock>ELSE</template>' +
-               '</div>';
-
-           fixture = createTestComponent(template);
-
-           fixture.detectChanges();
-           expect(fixture.nativeElement).toHaveText('THEN');
-
-           getComponent().booleanCondition = false;
-           fixture.detectChanges();
-           expect(fixture.nativeElement).toHaveText('ELSE');
-         }));
-
-      it('should support dynamic else', async(() => {
-           const template = '<div>' +
-               '<span *ngIf="booleanCondition; else nestedBooleanCondition ? b1 : b2">TRUE</span>' +
-               '<template #b1>FALSE1</template>' +
-               '<template #b2>FALSE2</template>' +
-               '</div>';
-
-           fixture = createTestComponent(template);
-
-           fixture.detectChanges();
-           expect(fixture.nativeElement).toHaveText('TRUE');
-
-           getComponent().booleanCondition = false;
-           fixture.detectChanges();
-           expect(fixture.nativeElement).toHaveText('FALSE1');
-
-           getComponent().nestedBooleanCondition = false;
-           fixture.detectChanges();
-           expect(fixture.nativeElement).toHaveText('FALSE2');
-         }));
-
-      it('should support binding to variable', async(() => {
-           const template = '<div>' +
-               '<span *ngIf="booleanCondition; else elseBlock; let v">{{v}}</span>' +
-               '<template #elseBlock let-v>{{v}}</template>' +
-               '</div>';
-
-           fixture = createTestComponent(template);
-
-           fixture.detectChanges();
-           expect(fixture.nativeElement).toHaveText('true');
-
-           getComponent().booleanCondition = false;
-           fixture.detectChanges();
-           expect(fixture.nativeElement).toHaveText('false');
-         }));
-    });
  });
 }

--- a/modules/@angular/common/test/pipes/case_conversion_pipes_spec.ts
+++ b/modules/@angular/common/test/pipes/case_conversion_pipes_spec.ts
@ -1,67 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {LowerCasePipe, TitleCasePipe, UpperCasePipe} from '@angular/common';
-
-export function main() {
-  describe('LowerCasePipe', () => {
-    let pipe: LowerCasePipe;
-
-    beforeEach(() => { pipe = new LowerCasePipe(); });
-
-    it('should return lowercase', () => { expect(pipe.transform('FOO')).toEqual('foo'); });
-
-    it('should lowercase when there is a new value', () => {
-      expect(pipe.transform('FOO')).toEqual('foo');
-      expect(pipe.transform('BAr')).toEqual('bar');
-    });
-
-    it('should not support other objects',
-       () => { expect(() => pipe.transform(<any>{})).toThrowError(); });
-  });
-
-  describe('TitleCasePipe', () => {
-    let pipe: TitleCasePipe;
-
-    beforeEach(() => { pipe = new TitleCasePipe(); });
-
-    it('should return titlecase', () => { expect(pipe.transform('foo')).toEqual('Foo'); });
-
-    it('should return titlecase for subsequent words',
-       () => { expect(pipe.transform('one TWO Three fouR')).toEqual('One Two Three Four'); });
-
-    it('should support empty strings', () => { expect(pipe.transform('')).toEqual(''); });
-
-    it('should persist whitespace',
-       () => { expect(pipe.transform('one   two')).toEqual('One   Two'); });
-
-    it('should titlecase when there is a new value', () => {
-      expect(pipe.transform('bar')).toEqual('Bar');
-      expect(pipe.transform('foo')).toEqual('Foo');
-    });
-
-    it('should not support other objects',
-       () => { expect(() => pipe.transform(<any>{})).toThrowError(); });
-  });
-
-  describe('UpperCasePipe', () => {
-    let pipe: UpperCasePipe;
-
-    beforeEach(() => { pipe = new UpperCasePipe(); });
-
-    it('should return uppercase', () => { expect(pipe.transform('foo')).toEqual('FOO'); });
-
-    it('should uppercase when there is a new value', () => {
-      expect(pipe.transform('foo')).toEqual('FOO');
-      expect(pipe.transform('bar')).toEqual('BAR');
-    });
-
-    it('should not support other objects',
-       () => { expect(() => pipe.transform(<any>{})).toThrowError(); });
-  });
-}
--- a/modules/@angular/common/test/pipes/lowercase_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/lowercase_pipe_spec.ts
@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {LowerCasePipe} from '@angular/common';
+import {beforeEach, describe, expect, it} from '@angular/core/testing/testing_internal';
+
+export function main() {
+  describe('LowerCasePipe', () => {
+    let upper: string;
+    let lower: string;
+    let pipe: LowerCasePipe;
+
+    beforeEach(() => {
+      lower = 'something';
+      upper = 'SOMETHING';
+      pipe = new LowerCasePipe();
+    });
+
+    describe('transform', () => {
+      it('should return lowercase', () => {
+        const val = pipe.transform(upper);
+        expect(val).toEqual(lower);
+      });
+
+      it('should lowercase when there is a new value', () => {
+        const val = pipe.transform(upper);
+        expect(val).toEqual(lower);
+        const val2 = pipe.transform('WAT');
+        expect(val2).toEqual('wat');
+      });
+
+      it('should not support other objects',
+         () => { expect(() => pipe.transform(<any>{})).toThrowError(); });
+    });
+
+  });
+}
--- a/modules/@angular/common/test/pipes/uppercase_pipe_spec.ts
+++ b/modules/@angular/common/test/pipes/uppercase_pipe_spec.ts
@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {UpperCasePipe} from '@angular/common';
+import {beforeEach, describe, expect, it} from '@angular/core/testing/testing_internal';
+
+export function main() {
+  describe('UpperCasePipe', () => {
+    let upper: string;
+    let lower: string;
+    let pipe: UpperCasePipe;
+
+    beforeEach(() => {
+      lower = 'something';
+      upper = 'SOMETHING';
+      pipe = new UpperCasePipe();
+    });
+
+    describe('transform', () => {
+
+      it('should return uppercase', () => {
+        const val = pipe.transform(lower);
+        expect(val).toEqual(upper);
+      });
+
+      it('should uppercase when there is a new value', () => {
+        const val = pipe.transform(lower);
+        expect(val).toEqual(upper);
+        const val2 = pipe.transform('wat');
+        expect(val2).toEqual('WAT');
+      });
+
+      it('should not support other objects',
+         () => { expect(() => pipe.transform(<any>{})).toThrowError(); });
+    });
+
+  });
+}
--- a/modules/@angular/compiler-cli/integrationtest/ngtools_src/app.component.html
+++ b/modules/@angular/compiler-cli/integrationtest/ngtools_src/app.component.html
@ -1,5 +1,5 @@
 <div>
-  <h1 i18n>hello world</h1>
+  <h1>hello world</h1>
  <a [routerLink]="['lazy']">lazy</a>
  <router-outlet></router-outlet>
 </div>
--- a/modules/@angular/compiler-cli/integrationtest/test/i18n_spec.ts
+++ b/modules/@angular/compiler-cli/integrationtest/test/i18n_spec.ts
@ -34,9 +34,9 @@ const EXPECTED_XMB = `<?xml version="1.0" encoding="UTF-8" ?>
 <!ELEMENT ex (#PCDATA)>
 ]>
 <messagebundle>
+  <msg id="3772663375917578720">other-3rdP-component</msg>
  <msg id="8136548302122759730" desc="desc" meaning="meaning">translate me</msg>
  <msg id="3492007542396725315">Welcome</msg>
-  <msg id="3772663375917578720">other-3rdP-component</msg>
 </messagebundle>
 `;

@ -44,6 +44,10 @@ const EXPECTED_XLIFF = `<?xml version="1.0" encoding="UTF-8" ?>
 <xliff version="1.2" xmlns="urn:oasis:names:tc:xliff:document:1.2">
  <file source-language="en" datatype="plaintext" original="ng2.template">
    <body>
+      <trans-unit id="63a85808f03b8181e36a952e0fa38202c2304862" datatype="html">
+        <source>other-3rdP-component</source>
+        <target/>
+      </trans-unit>
      <trans-unit id="76e1eccb1b772fa9f294ef9c146ea6d0efa8a2d4" datatype="html">
        <source>translate me</source>
        <target/>
@ -54,10 +58,6 @@ const EXPECTED_XLIFF = `<?xml version="1.0" encoding="UTF-8" ?>
        <source>Welcome</source>
        <target/>
      </trans-unit>
-      <trans-unit id="63a85808f03b8181e36a952e0fa38202c2304862" datatype="html">
-        <source>other-3rdP-component</source>
-        <target/>
-      </trans-unit>
    </body>
  </file>
 </xliff>
--- a/modules/@angular/compiler-cli/integrationtest/test/test_ngtools_api.ts
+++ b/modules/@angular/compiler-cli/integrationtest/test/test_ngtools_api.ts
@ -19,6 +19,7 @@ import {AngularCompilerOptions, CodeGenerator, CompilerHostContext, NodeCompiler

 const glob = require('glob');

+
 /**
 * Main method.
 * Standalone program that executes codegen using the ngtools API and tests that files were
@ -29,7 +30,6 @@ function main() {

  Promise.resolve()
      .then(() => codeGenTest())
-      .then(() => i18nTest())
      .then(() => lazyRoutesTest())
      .then(() => {
        console.log('All done!');
@ -42,6 +42,7 @@ function main() {
      });
 }

+
 function codeGenTest() {
  const basePath = path.join(__dirname, '../ngtools_src');
  const project = path.join(basePath, 'tsconfig-build.json');
@ -51,9 +52,12 @@ function codeGenTest() {
  const config = tsc.readConfiguration(project, basePath);
  const hostContext = new NodeCompilerHostContext();
  const delegateHost = ts.createCompilerHost(config.parsed.options, true);
-  const host: ts.CompilerHost = Object.assign(
-      {}, delegateHost,
-      {writeFile: (fileName: string, ...rest: any[]) => { wroteFiles.push(fileName); }});
+  const host: ts.CompilerHost = Object.assign({}, delegateHost, {
+    writeFile: (fileName: string, ...rest: any[]) => {
+      wroteFiles.push(fileName);
+      return delegateHost.writeFile.call(delegateHost, fileName, ...rest);
+    }
+  });
  const program = ts.createProgram(config.parsed.fileNames, config.parsed.options, host);

  config.ngOptions.basePath = basePath;
@ -108,67 +112,6 @@ function codeGenTest() {
      });
 }

-function i18nTest() {
-  const basePath = path.join(__dirname, '../ngtools_src');
-  const project = path.join(basePath, 'tsconfig-build.json');
-  const readResources: string[] = [];
-  const wroteFiles: string[] = [];
-
-  const config = tsc.readConfiguration(project, basePath);
-  const hostContext = new NodeCompilerHostContext();
-  const delegateHost = ts.createCompilerHost(config.parsed.options, true);
-  const host: ts.CompilerHost = Object.assign(
-      {}, delegateHost,
-      {writeFile: (fileName: string, ...rest: any[]) => { wroteFiles.push(fileName); }});
-  const program = ts.createProgram(config.parsed.fileNames, config.parsed.options, host);
-
-  config.ngOptions.basePath = basePath;
-
-  console.log(`>>> running i18n extraction for ${project}`);
-  return __NGTOOLS_PRIVATE_API_2
-      .extractI18n({
-        basePath,
-        compilerOptions: config.parsed.options, program, host,
-        angularCompilerOptions: config.ngOptions,
-        i18nFormat: 'xlf',
-        readResource: (fileName: string) => {
-          readResources.push(fileName);
-          return hostContext.readResource(fileName);
-        },
-      })
-      .then(() => {
-        console.log(`>>> i18n extraction done, asserting read and wrote files`);
-
-        const allFiles = glob.sync(path.join(basePath, '**/*'), {nodir: true});
-
-        assert(wroteFiles.length == 1, `Expected a single message bundle file.`);
-
-        assert(
-            wroteFiles[0].endsWith('/ngtools_src/messages.xlf'),
-            `Expected the bundle file to be "message.xlf".`);
-
-        allFiles.forEach((fileName: string) => {
-          // Skip tsconfig.
-          if (fileName.match(/tsconfig-build.json$/)) {
-            return;
-          }
-
-          // Assert that file was read.
-          if (fileName.match(/\.css$/) || fileName.match(/\.html$/)) {
-            assert(
-                readResources.indexOf(fileName) != -1,
-                `Expected resource "${fileName}" to be read.`);
-          }
-        });
-
-        console.log(`done, no errors.`);
-      })
-      .catch((e: any) => {
-        console.error(e.stack);
-        console.error('Extraction failed');
-        throw e;
-      });
-}

 function lazyRoutesTest() {
  const basePath = path.join(__dirname, '../ngtools_src');
--- a/modules/@angular/compiler-cli/integrationtest/test/test_summaries.ts
+++ b/modules/@angular/compiler-cli/integrationtest/test/test_summaries.ts
@ -27,14 +27,9 @@ function main() {
  const basePath = path.resolve(__dirname, '..');
  const project = path.resolve(basePath, 'tsconfig-build.json');
  const readFiles: string[] = [];
-  const writtenFiles: {fileName: string, content: string}[] = [];

  class AssertingHostContext extends NodeCompilerHostContext {
    readFile(fileName: string): string {
-      if (/.*\/node_modules\/.*/.test(fileName) && !/.*ngsummary\.json$/.test(fileName)) {
-        // Only allow to read summaries from node_modules
-        return null;
-      }
      readFiles.push(path.relative(basePath, fileName));
      return super.readFile(fileName);
    }
@ -50,29 +45,16 @@ function main() {
  config.ngOptions.generateCodeForLibraries = false;

  console.log(`>>> running codegen for ${project}`);
-  codegen(
-      config,
-      (host) => {
-        host.writeFile = (fileName: string, content: string) => {
-          fileName = path.relative(basePath, fileName);
-          writtenFiles.push({fileName, content});
-        };
-        return new AssertingHostContext();
-      })
+  codegen(config, (host) => new AssertingHostContext())
      .then((exitCode: any) => {
        console.log(`>>> codegen done, asserting read files`);
        assertSomeFileMatch(readFiles, /^node_modules\/.*\.ngsummary\.json$/);
-        assertNoFileMatch(readFiles, /^node_modules\/.*\.metadata.json$/);
        assertNoFileMatch(readFiles, /^node_modules\/.*\.html$/);
        assertNoFileMatch(readFiles, /^node_modules\/.*\.css$/);

        assertNoFileMatch(readFiles, /^src\/.*\.ngsummary\.json$/);
        assertSomeFileMatch(readFiles, /^src\/.*\.html$/);
        assertSomeFileMatch(readFiles, /^src\/.*\.css$/);
-
-        console.log(`>>> asserting written files`);
-        assertWrittenFile(writtenFiles, /^src\/module\.ngfactory\.ts$/, /class MainModuleInjector/);
-
        console.log(`done, no errors.`);
        process.exit(exitCode);
      })
@ -115,11 +97,4 @@ function assertNoFileMatch(fileNames: string[], pattern: RegExp) {
      `Expected no read files match ${pattern}, but found: \n${matches.join('\n')}`);
 }

-function assertWrittenFile(
-    files: {fileName: string, content: string}[], filePattern: RegExp, contentPattern: RegExp) {
-  assert(
-      files.some(file => filePattern.test(file.fileName) && contentPattern.test(file.content)),
-      `Expected some written files for ${filePattern} and content ${contentPattern}`);
-}
-
 main();
--- a/modules/@angular/compiler-cli/integrationtest/third_party_src/tsconfig-build.json
+++ b/modules/@angular/compiler-cli/integrationtest/third_party_src/tsconfig-build.json
@ -15,8 +15,6 @@
    "declaration": true,
    "lib": ["es6", "dom"],
    "baseUrl": ".",
-    "outDir": "../node_modules/third_party",
-     // Prevent scanning up the directory tree for types
-    "typeRoots": ["node_modules/@types"]
- }
+    "outDir": "../node_modules/third_party"
+  }
 }
--- a/modules/@angular/compiler-cli/integrationtest/tsconfig-build.json
+++ b/modules/@angular/compiler-cli/integrationtest/tsconfig-build.json
@ -14,9 +14,7 @@
    "rootDir": "",
    "declaration": true,
    "lib": ["es6", "dom"],
-    "baseUrl": ".",
-    // Prevent scanning up the directory tree for types
-    "typeRoots": ["node_modules/@types"]
+    "baseUrl": "."
  },

  "files": [
--- a/modules/@angular/compiler-cli/src/codegen.ts
+++ b/modules/@angular/compiler-cli/src/codegen.ts
@ -11,6 +11,7 @@
 * 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';
@ -18,8 +19,11 @@ 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.
@ -98,8 +102,14 @@ export class CodeGenerator {
      debug: options.debug === true,
      translations: transContent,
      i18nFormat: cliOptions.i18nFormat,
-      locale: cliOptions.locale
+      locale: cliOptions.locale,
+      excludeFilePattern: options.generateCodeForLibraries === false ? GENERATED_OR_DTS_FILES :
+                                                                       GENERATED_FILES
    });
    return new CodeGenerator(options, program, tsCompilerHost, aotCompiler, ngCompilerHost);
  }
 }
+
+export function excludeFilePattern(options: AngularCompilerOptions): RegExp {
+  return options.generateCodeForLibraries === false ? GENERATED_OR_DTS_FILES : GENERATED_FILES;
+}
--- a/modules/@angular/compiler-cli/src/compiler_host.ts
+++ b/modules/@angular/compiler-cli/src/compiler_host.ts
@ -16,8 +16,6 @@ const EXT = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
 const DTS = /\.d\.ts$/;
 const NODE_MODULES = '/node_modules/';
 const IS_GENERATED = /\.(ngfactory|ngstyle)$/;
-const GENERATED_FILES = /\.ngfactory\.ts$|\.ngstyle\.ts$/;
-const GENERATED_OR_DTS_FILES = /\.d\.ts$|\.ngfactory\.ts$|\.ngstyle\.ts$/;

 export interface CompilerHostContext extends ts.ModuleResolutionHost {
  readResource(fileName: string): Promise<string>;
@ -30,7 +28,6 @@ export class CompilerHost implements AotCompilerHost {
  protected basePath: string;
  private genDir: string;
  private resolverCache = new Map<string, ModuleMetadata[]>();
-  protected resolveModuleNameHost: CompilerHostContext;

  constructor(
      protected program: ts.Program, protected options: AngularCompilerOptions,
@ -41,31 +38,12 @@ export class CompilerHost implements AotCompilerHost {

    const genPath: string = path.relative(this.basePath, this.genDir);
    this.isGenDirChildOfRootDir = genPath === '' || !genPath.startsWith('..');
-    this.resolveModuleNameHost = Object.create(this.context);
-
-    // When calling ts.resolveModuleName,
-    // additional allow checks for .d.ts files to be done based on
-    // checks for .ngsummary.json files,
-    // so that our codegen depends on fewer inputs and requires to be called
-    // less often.
-    // This is needed as we use ts.resolveModuleName in reflector_host
-    // and it should be able to resolve summary file names.
-    this.resolveModuleNameHost.fileExists = (fileName: string): boolean => {
-      if (this.context.fileExists(fileName)) {
-        return true;
-      }
-      if (DTS.test(fileName)) {
-        const base = fileName.substring(0, fileName.length - 5);
-        return this.context.fileExists(base + '.ngsummary.json');
-      }
-      return false;
-    };
  }

  // We use absolute paths on disk as canonical.
  getCanonicalFileName(fileName: string): string { return fileName; }

-  moduleNameToFileName(m: string, containingFile: string): string|null {
+  moduleNameToFileName(m: string, containingFile: string) {
    if (!containingFile || !containingFile.length) {
      if (m.indexOf('.') === 0) {
        throw new Error('Resolution of relative paths requires a containing file.');
@ -75,8 +53,7 @@ export class CompilerHost implements AotCompilerHost {
    }
    m = m.replace(EXT, '');
    const resolved =
-        ts.resolveModuleName(
-              m, containingFile.replace(/\\/g, '/'), this.options, this.resolveModuleNameHost)
+        ts.resolveModuleName(m, containingFile.replace(/\\/g, '/'), this.options, this.context)
            .resolvedModule;
    return resolved ? this.getCanonicalFileName(resolved.resolvedFileName) : null;
  };
@ -181,12 +158,6 @@ export class CompilerHost implements AotCompilerHost {
      const metadataPath = filePath.replace(DTS, '.metadata.json');
      if (this.context.fileExists(metadataPath)) {
        return this.readMetadata(metadataPath, filePath);
-      } else {
-        // If there is a .d.ts file but no metadata file we need to produce a
-        // v3 metadata from the .d.ts file as v3 includes the exports we need
-        // to resolve symbols.
-        return [this.upgradeVersion1Metadata(
-            {'__symbolic': 'module', 'version': 1, 'metadata': {}}, filePath)];
      }
    } else {
      const sf = this.getSourceFile(filePath);
@ -202,13 +173,35 @@ export class CompilerHost implements AotCompilerHost {
    }
    try {
      const metadataOrMetadatas = JSON.parse(this.context.readFile(filePath));
-      const metadatas: ModuleMetadata[] = metadataOrMetadatas ?
+      const metadatas = metadataOrMetadatas ?
          (Array.isArray(metadataOrMetadatas) ? metadataOrMetadatas : [metadataOrMetadatas]) :
          [];
-      const v1Metadata = metadatas.find(m => m.version === 1);
-      let v3Metadata = metadatas.find(m => m.version === 3);
+      const v1Metadata = metadatas.find((m: any) => m['version'] === 1);
+      let v3Metadata = metadatas.find((m: any) => m['version'] === 3);
      if (!v3Metadata && v1Metadata) {
-        metadatas.push(this.upgradeVersion1Metadata(v1Metadata, dtsFilePath));
+        // patch up v1 to v3 by merging the metadata with metadata collected from the d.ts file
+        // as the only difference between the versions is whether all exports are contained in
+        // the metadata and the `extends` clause.
+        v3Metadata = {'__symbolic': 'module', 'version': 3, 'metadata': {}};
+        if (v1Metadata.exports) {
+          v3Metadata.exports = v1Metadata.exports;
+        }
+        for (let prop in v1Metadata.metadata) {
+          v3Metadata.metadata[prop] = v1Metadata.metadata[prop];
+        }
+
+        const exports = this.metadataCollector.getMetadata(this.getSourceFile(dtsFilePath));
+        if (exports) {
+          for (let prop in exports.metadata) {
+            if (!v3Metadata.metadata[prop]) {
+              v3Metadata.metadata[prop] = exports.metadata[prop];
+            }
+          }
+          if (exports.exports) {
+            v3Metadata.exports = exports.exports;
+          }
+        }
+        metadatas.push(v3Metadata);
      }
      this.resolverCache.set(filePath, metadatas);
      return metadatas;
@ -218,49 +211,13 @@ export class CompilerHost implements AotCompilerHost {
    }
  }

-  private upgradeVersion1Metadata(v1Metadata: ModuleMetadata, dtsFilePath: string): ModuleMetadata {
-    // patch up v1 to v3 by merging the metadata with metadata collected from the d.ts file
-    // as the only difference between the versions is whether all exports are contained in
-    // the metadata and the `extends` clause.
-    let v3Metadata: ModuleMetadata = {'__symbolic': 'module', 'version': 3, 'metadata': {}};
-    if (v1Metadata.exports) {
-      v3Metadata.exports = v1Metadata.exports;
-    }
-    for (let prop in v1Metadata.metadata) {
-      v3Metadata.metadata[prop] = v1Metadata.metadata[prop];
-    }
-
-    const exports = this.metadataCollector.getMetadata(this.getSourceFile(dtsFilePath));
-    if (exports) {
-      for (let prop in exports.metadata) {
-        if (!v3Metadata.metadata[prop]) {
-          v3Metadata.metadata[prop] = exports.metadata[prop];
-        }
-      }
-      if (exports.exports) {
-        v3Metadata.exports = exports.exports;
-      }
-    }
-    return v3Metadata;
-  }
-
  loadResource(filePath: string): Promise<string> { return this.context.readResource(filePath); }

-  loadSummary(filePath: string): string|null {
-    if (this.context.fileExists(filePath)) {
-      return this.context.readFile(filePath);
-    }
-  }
+  loadSummary(filePath: string): string { return this.context.readFile(filePath); }

  getOutputFileName(sourceFilePath: string): string {
    return sourceFilePath.replace(EXT, '') + '.d.ts';
  }
-
-  isSourceFile(filePath: string): boolean {
-    const excludeRegex =
-        this.options.generateCodeForLibraries === false ? GENERATED_OR_DTS_FILES : GENERATED_FILES;
-    return !excludeRegex.test(filePath);
-  }
 }

 export class CompilerHostContextAdapter {
--- a/modules/@angular/compiler-cli/src/extract_i18n.ts
+++ b/modules/@angular/compiler-cli/src/extract_i18n.ts
@ -14,15 +14,41 @@
 // Must be imported first, because angular2 decorators throws on load.
 import 'reflect-metadata';

+import * as compiler from '@angular/compiler';
 import * as tsc from '@angular/tsc-wrapped';
+import * as path from 'path';
 import * as ts from 'typescript';

 import {Extractor} from './extractor';

 function extract(
    ngOptions: tsc.AngularCompilerOptions, cliOptions: tsc.I18nExtractionCliOptions,
-    program: ts.Program, host: ts.CompilerHost): Promise<void> {
-  return Extractor.create(ngOptions, program, host).extract(cliOptions.i18nFormat);
+    program: ts.Program, host: ts.CompilerHost) {
+  const extractor = Extractor.create(ngOptions, cliOptions.i18nFormat, program, host);
+
+  const bundlePromise: Promise<compiler.MessageBundle> = extractor.extract();
+
+  return (bundlePromise).then(messageBundle => {
+    let ext: string;
+    let serializer: compiler.Serializer;
+    const format = (cliOptions.i18nFormat || 'xlf').toLowerCase();
+
+    switch (format) {
+      case 'xmb':
+        ext = 'xmb';
+        serializer = new compiler.Xmb();
+        break;
+      case 'xliff':
+      case 'xlf':
+      default:
+        ext = 'xlf';
+        serializer = new compiler.Xliff();
+        break;
+    }
+
+    const dstPath = path.join(ngOptions.genDir, `messages.${ext}`);
+    host.writeFile(dstPath, messageBundle.write(serializer), false);
+  });
 }

 // Entry point
--- a/modules/@angular/compiler-cli/src/extractor.ts
+++ b/modules/@angular/compiler-cli/src/extractor.ts
@ -15,74 +15,29 @@ import 'reflect-metadata';

 import * as compiler from '@angular/compiler';
 import * as tsc from '@angular/tsc-wrapped';
-import * as path from 'path';
 import * as ts from 'typescript';

-import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
-import {PathMappedCompilerHost} from './path_mapped_compiler_host';
+import {excludeFilePattern} from './codegen';
+import {CompilerHost, ModuleResolutionHostAdapter} from './compiler_host';

 export class Extractor {
  constructor(
-      private options: tsc.AngularCompilerOptions, private ngExtractor: compiler.Extractor,
-      public host: ts.CompilerHost, private ngCompilerHost: CompilerHost,
+      private ngExtractor: compiler.Extractor, private ngCompilerHost: CompilerHost,
      private program: ts.Program) {}

-  extract(formatName: string): Promise<void> {
-    // Checks the format and returns the extension
-    const ext = this.getExtension(formatName);
-
-    const promiseBundle = this.extractBundle();
-
-    return promiseBundle.then(bundle => {
-      const content = this.serialize(bundle, ext);
-      const dstPath = path.join(this.options.genDir, `messages.${ext}`);
-      this.host.writeFile(dstPath, content, false);
-    });
-  }
-
-  extractBundle(): Promise<compiler.MessageBundle> {
-    const files = this.program.getSourceFiles().map(
-        sf => this.ngCompilerHost.getCanonicalFileName(sf.fileName));
-
-    return this.ngExtractor.extract(files);
-  }
-
-  serialize(bundle: compiler.MessageBundle, ext: string): string {
-    let serializer: compiler.Serializer;
-
-    switch (ext) {
-      case 'xmb':
-        serializer = new compiler.Xmb();
-        break;
-      case 'xlf':
-      default:
-        serializer = new compiler.Xliff();
-    }
-
-    return bundle.write(serializer);
-  }
-
-  getExtension(formatName: string): string {
-    const format = (formatName || 'xlf').toLowerCase();
-
-    if (format === 'xmb') return 'xmb';
-    if (format === 'xlf' || format === 'xlif') return 'xlf';
-
-    throw new Error('Unsupported format "${formatName}"');
+  extract(): Promise<compiler.MessageBundle> {
+    return this.ngExtractor.extract(this.program.getSourceFiles().map(
+        sf => this.ngCompilerHost.getCanonicalFileName(sf.fileName)));
  }

  static create(
-      options: tsc.AngularCompilerOptions, program: ts.Program, tsCompilerHost: ts.CompilerHost,
-      compilerHostContext?: CompilerHostContext, ngCompilerHost?: CompilerHost): Extractor {
-    if (!ngCompilerHost) {
-      const usePathMapping = !!options.rootDirs && options.rootDirs.length > 0;
-      const context = compilerHostContext || new ModuleResolutionHostAdapter(tsCompilerHost);
-      ngCompilerHost = usePathMapping ? new PathMappedCompilerHost(program, options, context) :
-                                        new CompilerHost(program, options, context);
-    }
-
-    const {extractor: ngExtractor} = compiler.Extractor.create(ngCompilerHost);
-
-    return new Extractor(options, ngExtractor, tsCompilerHost, ngCompilerHost, program);
+      options: tsc.AngularCompilerOptions, translationsFormat: string, program: ts.Program,
+      moduleResolverHost: ts.ModuleResolutionHost, ngCompilerHost?: CompilerHost): Extractor {
+    if (!ngCompilerHost)
+      ngCompilerHost =
+          new CompilerHost(program, options, new ModuleResolutionHostAdapter(moduleResolverHost));
+    const {extractor: ngExtractor} = compiler.Extractor.create(
+        ngCompilerHost, {excludeFilePattern: excludeFilePattern(options)});
+    return new Extractor(ngExtractor, ngCompilerHost, program);
  }
 }
--- a/modules/@angular/compiler-cli/src/main.ts
+++ b/modules/@angular/compiler-cli/src/main.ts
@ -14,7 +14,6 @@ import 'reflect-metadata';
 import * as ts from 'typescript';
 import * as tsc from '@angular/tsc-wrapped';

-import {SyntaxError} from '@angular/compiler';
 import {CodeGenerator} from './codegen';

 function codegen(
@ -29,7 +28,7 @@ export function main(
  const cliOptions = new tsc.NgcCliOptions(args);

  return tsc.main(project, cliOptions, codegen).then(() => 0).catch(e => {
-    if (e instanceof tsc.UserError || e instanceof SyntaxError) {
+    if (e instanceof tsc.UserError) {
      consoleError(e.message);
      return Promise.resolve(1);
    } else {
--- a/modules/@angular/compiler-cli/src/ngtools_api.ts
+++ b/modules/@angular/compiler-cli/src/ngtools_api.ts
@ -13,16 +13,16 @@
 * something else.
 */

-import {AotCompilerHost, AotSummaryResolver, StaticReflector, StaticSymbolCache, StaticSymbolResolver} from '@angular/compiler';
+import {AotCompilerHost, StaticReflector} from '@angular/compiler';
 import {AngularCompilerOptions, NgcCliOptions} from '@angular/tsc-wrapped';
 import * as ts from 'typescript';

 import {CodeGenerator} from './codegen';
 import {CompilerHost, CompilerHostContext, ModuleResolutionHostAdapter} from './compiler_host';
-import {Extractor} from './extractor';
 import {listLazyRoutesOfModule} from './ngtools_impl';
 import {PathMappedCompilerHost} from './path_mapped_compiler_host';

+
 export interface NgTools_InternalApi_NG2_CodeGen_Options {
  basePath: string;
  compilerOptions: ts.CompilerOptions;
@ -50,18 +50,9 @@ export interface NgTools_InternalApi_NG2_ListLazyRoutes_Options {
  // Every new property under this line should be optional.
 }

+
 export interface NgTools_InternalApi_NG_2_LazyRouteMap { [route: string]: string; }

-export interface NgTools_InternalApi_NG2_ExtractI18n_Options {
-  basePath: string;
-  compilerOptions: ts.CompilerOptions;
-  program: ts.Program;
-  host: ts.CompilerHost;
-  angularCompilerOptions: AngularCompilerOptions;
-  i18nFormat: string;
-  readResource: (fileName: string) => Promise<string>;
-  // Every new property under this line should be optional.
-}

 /**
 * A ModuleResolutionHostAdapter that overrides the readResource() method with the one
@ -103,6 +94,7 @@ export class NgTools_InternalApi_NG_2 {
    return codeGenerator.codegen();
  }

+
  /**
   * @internal
   * @private
@ -119,10 +111,7 @@ export class NgTools_InternalApi_NG_2 {
        new PathMappedCompilerHost(program, angularCompilerOptions, moduleResolutionHost) :
        new CompilerHost(program, angularCompilerOptions, moduleResolutionHost);

-    const symbolCache = new StaticSymbolCache();
-    const summaryResolver = new AotSummaryResolver(ngCompilerHost, symbolCache);
-    const symbolResolver = new StaticSymbolResolver(ngCompilerHost, symbolCache, summaryResolver);
-    const staticReflector = new StaticReflector(symbolResolver);
+    const staticReflector = new StaticReflector(ngCompilerHost);
    const routeMap = listLazyRoutesOfModule(options.entryModule, ngCompilerHost, staticReflector);

    return Object.keys(routeMap).reduce(
@ -132,19 +121,4 @@ export class NgTools_InternalApi_NG_2 {
        },
        {});
  }
-
-  /**
-   * @internal
-   * @private
-   */
-  static extractI18n(options: NgTools_InternalApi_NG2_ExtractI18n_Options): Promise<void> {
-    const hostContext: CompilerHostContext =
-        new CustomLoaderModuleResolutionHostAdapter(options.readResource, options.host);
-
-    // Create the i18n extractor.
-    const extractor = Extractor.create(
-        options.angularCompilerOptions, options.program, options.host, hostContext);
-
-    return extractor.extract(options.i18nFormat);
-  }
 }
--- a/modules/@angular/compiler-cli/src/private_import_core.ts
+++ b/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 const ReflectorReader: typeof r.ReflectorReader = r.ReflectorReader;
+export var ReflectorReader: typeof r.ReflectorReader = r.ReflectorReader;

 export type ReflectionCapabilities = typeof r._ReflectionCapabilities;
-export const ReflectionCapabilities: typeof r.ReflectionCapabilities = r.ReflectionCapabilities;
+export var ReflectionCapabilities: typeof r.ReflectionCapabilities = r.ReflectionCapabilities;

 export type Console = typeof r._Console;
-export const Console: typeof r.Console = r.Console;
+export var Console: typeof r.Console = r.Console;
--- a/modules/@angular/compiler-cli/test/aot_host_spec.ts
+++ b/modules/@angular/compiler-cli/test/aot_host_spec.ts
@ -6,7 +6,6 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {ModuleMetadata} from '@angular/tsc-wrapped';
 import * as ts from 'typescript';

 import {CompilerHost} from '../src/compiler_host';
@ -151,14 +150,12 @@ describe('CompilerHost', () => {

  it('should be able to read a metadata file', () => {
    expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/core.d.ts')).toEqual([
-      {__symbolic: 'module', version: 3, metadata: {foo: {__symbolic: 'class'}}}
+      {__symbolic: 'module', version: 2, metadata: {foo: {__symbolic: 'class'}}}
    ]);
  });

  it('should be able to read metadata from an otherwise unused .d.ts file ', () => {
-    expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/unused.d.ts')).toEqual([
-      dummyMetadata
-    ]);
+    expect(hostNestedGenDir.getMetadataFor('node_modules/@angular/unused.d.ts')).toBeUndefined();
  });

  it('should be able to read empty metadata ', () => {
@ -184,21 +181,10 @@ describe('CompilerHost', () => {
      }
    ]);
  });
-
-  it('should upgrade a missing metadata file into v3', () => {
-    expect(hostNestedGenDir.getMetadataFor('metadata_versions/v1_empty.d.ts')).toEqual([
-      {__symbolic: 'module', version: 3, metadata: {}, exports: [{from: './lib/utils'}]}
-    ]);
-  });
 });

 const dummyModule = 'export let foo: any[];';
-const dummyMetadata: ModuleMetadata = {
-  __symbolic: 'module',
-  version: 3,
-  metadata:
-      {foo: {__symbolic: 'error', message: 'Variable not initialized', line: 0, character: 11}}
-};
+
 const FILES: Entry = {
  'tmp': {
    'src': {
@ -218,7 +204,7 @@ const FILES: Entry = {
        '@angular': {
          'core.d.ts': dummyModule,
          'core.metadata.json':
-              `{"__symbolic":"module", "version": 3, "metadata": {"foo": {"__symbolic": "class"}}}`,
+              `{"__symbolic":"module", "version": 2, "metadata": {"foo": {"__symbolic": "class"}}}`,
          'router': {'index.d.ts': dummyModule, 'src': {'providers.d.ts': dummyModule}},
          'unused.d.ts': dummyModule,
          'empty.d.ts': 'export declare var a: string;',
@ -239,9 +225,6 @@ const FILES: Entry = {
        `,
        'v1.metadata.json':
            `{"__symbolic":"module", "version": 1, "metadata": {"foo": {"__symbolic": "class"}}}`,
-        'v1_empty.d.ts': `
-          export * from './lib/utils';
-        `
      }
    }
  }
--- a/modules/@angular/compiler-cli/test/main_spec.ts
+++ b/modules/@angular/compiler-cli/test/main_spec.ts
@ -29,17 +29,13 @@ describe('compiler-cli', () => {
        "types": [],
        "outDir": "built",
        "declaration": true,
-        "module": "es2015",
-        "moduleResolution": "node"
+        "module": "es2015"
      },
      "angularCompilerOptions": {
        "annotateForClosureCompiler": true
      },
      "files": ["test.ts"]
    }`);
-    const nodeModulesPath = path.resolve(basePath, 'node_modules');
-    fs.mkdirSync(nodeModulesPath);
-    fs.symlinkSync(path.resolve(__dirname, '..', '..'), path.resolve(nodeModulesPath, '@angular'));
  });

  // Restore reflector since AoT compiler will update it with a new static reflector
--- a/modules/@angular/compiler-cli/test/mocks.ts
+++ b/modules/@angular/compiler-cli/test/mocks.ts
@ -122,9 +122,11 @@ 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; }

--- a/modules/@angular/compiler-cli/test/private_import_core.ts
+++ b/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 const ReflectionCapabilities: typeof r.ReflectionCapabilities = r.ReflectionCapabilities;
-export const reflector: typeof r.reflector = r.reflector;
+export var ReflectionCapabilities: typeof r.ReflectionCapabilities = r.ReflectionCapabilities;
+export var reflector: typeof r.reflector = r.reflector;
--- a/modules/@angular/compiler/index.ts
+++ b/modules/@angular/compiler/index.ts
@ -32,9 +32,7 @@ export * from './src/aot/compiler_host';
 export * from './src/aot/static_reflector';
 export * from './src/aot/static_reflection_capabilities';
 export * from './src/aot/static_symbol';
-export * from './src/aot/static_symbol_resolver';
 export * from './src/aot/summary_resolver';
-export * from './src/summary_resolver';
 export {JitCompiler} from './src/jit/compiler';
 export * from './src/jit/compiler_factory';
 export * from './src/url_resolver';
@ -62,5 +60,4 @@ export * from './src/style_compiler';
 export * from './src/template_parser/template_parser';
 export {ViewCompiler} from './src/view_compiler/view_compiler';
 export {AnimationParser} from './src/animation/animation_parser';
-export {SyntaxError} from './src/util';
 // This file only reexports content of the `src` folder. Keep it that way.
--- a/modules/@angular/compiler/src/animation/animation_compiler.ts
+++ b/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, null, true));
+      stylesArr.push(o.literalMap(entries));
    });

    return o.importExpr(createIdentifier(Identifiers.AnimationStyles)).instantiate([
@ -322,13 +322,12 @@ 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, null, true);
+        variableValue = o.literalMap(styleMap);
      }
      lookupMap.push([stateName, variableValue]);
    });

-    const compiledStatesMapStmt =
-        this._statesMapVar.set(o.literalMap(lookupMap, null, true)).toDeclStmt();
+    const compiledStatesMapStmt = this._statesMapVar.set(o.literalMap(lookupMap)).toDeclStmt();
    const statements: o.Statement[] = [compiledStatesMapStmt, fnStatement];

    return new AnimationEntryCompileResult(this.animationName, statements, fnVariable);
--- a/modules/@angular/compiler/src/animation/animation_parser.ts
+++ b/modules/@angular/compiler/src/animation/animation_parser.ts
@ -6,10 +6,11 @@
 * found in the LICENSE file at https://angular.io/license
 */

+import {Injectable} from '@angular/core';
+
 import {CompileAnimationAnimateMetadata, CompileAnimationEntryMetadata, CompileAnimationGroupMetadata, CompileAnimationKeyframesSequenceMetadata, CompileAnimationMetadata, CompileAnimationSequenceMetadata, CompileAnimationStateDeclarationMetadata, CompileAnimationStateTransitionMetadata, CompileAnimationStyleMetadata, CompileAnimationWithStepsMetadata, CompileDirectiveMetadata, identifierName} from '../compile_metadata';
 import {StringMapWrapper} from '../facade/collection';
 import {isBlank, isPresent} from '../facade/lang';
-import {CompilerInjectable} from '../injectable';
 import {ParseError} from '../parse_util';
 import {ANY_STATE, FILL_STYLE_FLAG} from '../private_import_core';
 import {ElementSchemaRegistry} from '../schema/element_schema_registry';
@ -34,7 +35,7 @@ export class AnimationEntryParseResult {
  constructor(public ast: AnimationEntryAst, public errors: AnimationParseError[]) {}
 }

-@CompilerInjectable()
+@Injectable()
 export class AnimationParser {
  constructor(private _schema: ElementSchemaRegistry) {}

--- a/modules/@angular/compiler/src/aot/compiler.ts
+++ b/modules/@angular/compiler/src/aot/compiler.ts
@ -10,7 +10,7 @@ import {SchemaMetadata} from '@angular/core';

 import {AnimationCompiler} from '../animation/animation_compiler';
 import {AnimationParser} from '../animation/animation_parser';
-import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompilePipeMetadata, CompileProviderMetadata, CompileTypeSummary, componentFactoryName, createHostComponentMeta, identifierModuleUrl, identifierName} from '../compile_metadata';
+import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompilePipeMetadata, CompileProviderMetadata, CompileTypeSummary, createHostComponentMeta, identifierModuleUrl, identifierName} from '../compile_metadata';
 import {DirectiveNormalizer} from '../directive_normalizer';
 import {DirectiveWrapperCompileResult, DirectiveWrapperCompiler} from '../directive_wrapper_compiler';
 import {ListWrapper} from '../facade/collection';
@ -20,35 +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, ComponentViewDependency, DirectiveWrapperDependency, ViewCompileResult, ViewCompiler} from '../view_compiler/view_compiler';
+import {ComponentFactoryDependency, DirectiveWrapperDependency, ViewClassDependency, ViewCompileResult, ViewCompiler} from '../view_compiler/view_compiler';

-import {AotCompilerHost} from './compiler_host';
+import {AotCompilerOptions} from './compiler_options';
 import {GeneratedFile} from './generated_file';
+import {StaticReflector} from './static_reflector';
 import {StaticSymbol} from './static_symbol';
-import {ResolvedStaticSymbol, StaticSymbolResolver} from './static_symbol_resolver';
-import {serializeSummaries} from './summary_serializer';
-import {ngfactoryFilePath, splitTypescriptSuffix, summaryFileName} from './util';
+import {AotSummaryResolver} from './summary_resolver';
+import {filterFileByPatterns} from './utils';

 export class AotCompiler {
  private _animationCompiler = new AnimationCompiler();

  constructor(
-      private _host: AotCompilerHost, private _metadataResolver: CompileMetadataResolver,
-      private _templateParser: TemplateParser, private _styleCompiler: StyleCompiler,
-      private _viewCompiler: ViewCompiler, private _dirWrapperCompiler: DirectiveWrapperCompiler,
+      private _metadataResolver: CompileMetadataResolver, private _templateParser: TemplateParser,
+      private _styleCompiler: StyleCompiler, private _viewCompiler: ViewCompiler,
+      private _dirWrapperCompiler: DirectiveWrapperCompiler,
      private _ngModuleCompiler: NgModuleCompiler, private _outputEmitter: OutputEmitter,
-      private _summaryResolver: SummaryResolver<StaticSymbol>, private _localeId: string,
+      private _summaryResolver: AotSummaryResolver, private _localeId: string,
      private _translationFormat: string, private _animationParser: AnimationParser,
-      private _symbolResolver: StaticSymbolResolver) {}
+      private _staticReflector: StaticReflector, private _options: AotCompilerOptions) {}

  clearCache() { this._metadataResolver.clearCache(); }

  compileAll(rootFiles: string[]): Promise<GeneratedFile[]> {
-    const programSymbols = extractProgramSymbols(this._symbolResolver, rootFiles, this._host);
+    const programSymbols = extractProgramSymbols(this._staticReflector, rootFiles, this._options);
    const {ngModuleByPipeOrDirective, files, ngModules} =
-        analyzeAndValidateNgModules(programSymbols, this._host, this._metadataResolver);
+        analyzeAndValidateNgModules(programSymbols, this._options, this._metadataResolver);
    return Promise
        .all(ngModules.map(
            ngModule => this._metadataResolver.loadNgModuleDirectiveAndPipeMetadata(
@ -57,22 +56,27 @@ export class AotCompiler {
          const sourceModules = files.map(
              file => this._compileSrcFile(
                  file.srcUrl, ngModuleByPipeOrDirective, file.directives, file.pipes,
-                  file.ngModules, file.injectables));
+                  file.ngModules));
          return ListWrapper.flatten(sourceModules);
        });
  }

  private _compileSrcFile(
      srcFileUrl: string, ngModuleByPipeOrDirective: Map<StaticSymbol, CompileNgModuleMetadata>,
-      directives: StaticSymbol[], pipes: StaticSymbol[], ngModules: StaticSymbol[],
-      injectables: StaticSymbol[]): GeneratedFile[] {
-    const fileSuffix = splitTypescriptSuffix(srcFileUrl)[1];
+      directives: StaticSymbol[], pipes: StaticSymbol[],
+      ngModules: StaticSymbol[]): GeneratedFile[] {
+    const fileSuffix = _splitTypescriptSuffix(srcFileUrl)[1];
    const statements: o.Statement[] = [];
    const exportedVars: string[] = [];
    const generatedFiles: GeneratedFile[] = [];

-    generatedFiles.push(this._createSummary(
-        srcFileUrl, directives, pipes, ngModules, injectables, statements, exportedVars));
+    // write summary files
+    const summaries: CompileTypeSummary[] = [
+      ...ngModules.map(ref => this._metadataResolver.getNgModuleSummary(ref)),
+      ...directives.map(ref => this._metadataResolver.getDirectiveSummary(ref)),
+      ...pipes.map(ref => this._metadataResolver.getPipeSummary(ref))
+    ];
+    generatedFiles.push(this._summaryResolver.serializeSummaries(srcFileUrl, summaries));

    // compile all ng modules
    exportedVars.push(
@ -111,34 +115,12 @@ export class AotCompiler {
    });
    if (statements.length > 0) {
      const srcModule = this._codegenSourceModule(
-          srcFileUrl, ngfactoryFilePath(srcFileUrl), statements, exportedVars);
+          srcFileUrl, _ngfactoryModuleUrl(srcFileUrl), statements, exportedVars);
      generatedFiles.unshift(srcModule);
    }
    return generatedFiles;
  }

-  private _createSummary(
-      srcFileUrl: string, directives: StaticSymbol[], pipes: StaticSymbol[],
-      ngModules: StaticSymbol[], injectables: StaticSymbol[], targetStatements: o.Statement[],
-      targetExportedVars: string[]): 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, exportAs} = serializeSummaries(
-        this._summaryResolver, this._symbolResolver, symbolSummaries, typeSummaries);
-    exportAs.forEach((entry) => {
-      targetStatements.push(
-          o.variable(entry.exportAs).set(o.importExpr({reference: entry.symbol})).toDeclStmt());
-      targetExportedVars.push(entry.exportAs);
-    });
-    return new GeneratedFile(srcFileUrl, summaryFileName(srcFileUrl), json);
-  }
-
  private _compileModule(ngModuleType: StaticSymbol, targetStatements: o.Statement[]): string {
    const ngModule = this._metadataResolver.getNgModuleMetadata(ngModuleType);
    const providers: CompileProviderMetadata[] = [];
@ -158,6 +140,12 @@ export class AotCompiler {
    }

    const appCompileResult = this._ngModuleCompiler.compile(ngModule, providers);
+
+    appCompileResult.dependencies.forEach((dep) => {
+      dep.placeholder.reference = this._staticReflector.getStaticSymbol(
+          _ngfactoryModuleUrl(identifierModuleUrl(dep.comp)), _componentFactoryName(dep.comp));
+    });
+
    targetStatements.push(...appCompileResult.statements);
    return appCompileResult.ngModuleFactoryVar;
  }
@ -174,12 +162,13 @@ export class AotCompiler {
  private _compileComponentFactory(
      compMeta: CompileDirectiveMetadata, ngModule: CompileNgModuleMetadata, fileSuffix: string,
      targetStatements: o.Statement[]): string {
-    const hostType = this._metadataResolver.getHostComponentType(compMeta.type.reference);
    const hostMeta = createHostComponentMeta(
-        hostType, compMeta, this._metadataResolver.getHostComponentViewClass(hostType));
+        this._staticReflector.getStaticSymbol(
+            identifierModuleUrl(compMeta.type), `${identifierName(compMeta.type)}_Host`),
+        compMeta);
    const hostViewFactoryVar = this._compileComponent(
        hostMeta, ngModule, [compMeta.type], null, fileSuffix, targetStatements);
-    const compFactoryVar = componentFactoryName(compMeta.type.reference);
+    const compFactoryVar = _componentFactoryName(compMeta.type);
    targetStatements.push(
        o.variable(compFactoryVar)
            .set(o.importExpr(
@ -217,16 +206,16 @@ export class AotCompiler {
        compMeta, parsedTemplate, stylesExpr, pipes, compiledAnimations);
    if (componentStyles) {
      targetStatements.push(
-          ..._resolveStyleStatements(this._symbolResolver, componentStyles, fileSuffix));
+          ..._resolveStyleStatements(this._staticReflector, componentStyles, fileSuffix));
    }
    compiledAnimations.forEach(entry => targetStatements.push(...entry.statements));
-    targetStatements.push(...viewResult.statements);
+    targetStatements.push(..._resolveViewStatements(this._staticReflector, viewResult));
    return viewResult.viewClassVar;
  }

  private _codgenStyles(
      fileUrl: string, stylesCompileResult: CompiledStylesheet, fileSuffix: string): GeneratedFile {
-    _resolveStyleStatements(this._symbolResolver, stylesCompileResult, fileSuffix);
+    _resolveStyleStatements(this._staticReflector, stylesCompileResult, fileSuffix);
    return this._codegenSourceModule(
        fileUrl, _stylesModuleUrl(
                     stylesCompileResult.meta.moduleUrl, stylesCompileResult.isShimmed, fileSuffix),
@ -242,8 +231,29 @@ export class AotCompiler {
  }
 }

+function _resolveViewStatements(
+    reflector: StaticReflector, compileResult: ViewCompileResult): o.Statement[] {
+  compileResult.dependencies.forEach((dep) => {
+    if (dep instanceof ViewClassDependency) {
+      const vfd = <ViewClassDependency>dep;
+      vfd.placeholder.reference =
+          reflector.getStaticSymbol(_ngfactoryModuleUrl(identifierModuleUrl(vfd.comp)), dep.name);
+    } else if (dep instanceof ComponentFactoryDependency) {
+      const cfd = <ComponentFactoryDependency>dep;
+      cfd.placeholder.reference = reflector.getStaticSymbol(
+          _ngfactoryModuleUrl(identifierModuleUrl(cfd.comp)), _componentFactoryName(cfd.comp));
+    } else if (dep instanceof DirectiveWrapperDependency) {
+      const dwd = <DirectiveWrapperDependency>dep;
+      dwd.placeholder.reference =
+          reflector.getStaticSymbol(_ngfactoryModuleUrl(identifierModuleUrl(dwd.dir)), dwd.name);
+    }
+  });
+  return compileResult.statements;
+}
+
+
 function _resolveStyleStatements(
-    reflector: StaticSymbolResolver, compileResult: CompiledStylesheet,
+    reflector: StaticReflector, compileResult: CompiledStylesheet,
    fileSuffix: string): o.Statement[] {
  compileResult.dependencies.forEach((dep) => {
    dep.valuePlaceholder.reference = reflector.getStaticSymbol(
@ -252,6 +262,15 @@ function _resolveStyleStatements(
  return compileResult.statements;
 }

+function _ngfactoryModuleUrl(dirUrl: string): string {
+  const urlWithSuffix = _splitTypescriptSuffix(dirUrl);
+  return `${urlWithSuffix[0]}.ngfactory${urlWithSuffix[1]}`;
+}
+
+function _componentFactoryName(comp: CompileIdentifierMetadata): string {
+  return `${identifierName(comp)}NgFactory`;
+}
+
 function _stylesModuleUrl(stylesheetUrl: string, shim: boolean, suffix: string): string {
  return `${stylesheetUrl}${shim ? '.shim' : ''}.ngstyle${suffix}`;
 }
@ -263,6 +282,20 @@ function _assertComponent(meta: CompileDirectiveMetadata) {
  }
 }

+function _splitTypescriptSuffix(path: string): string[] {
+  if (path.endsWith('.d.ts')) {
+    return [path.slice(0, -5), '.ts'];
+  }
+
+  const lastDot = path.lastIndexOf('.');
+
+  if (lastDot !== -1) {
+    return [path.substring(0, lastDot), path.substring(lastDot)];
+  }
+
+  return [path, ''];
+}
+
 export interface NgAnalyzedModules {
  ngModules: CompileNgModuleMetadata[];
  ngModuleByPipeOrDirective: Map<StaticSymbol, CompileNgModuleMetadata>;
@ -270,27 +303,26 @@ export interface NgAnalyzedModules {
    srcUrl: string,
    directives: StaticSymbol[],
    pipes: StaticSymbol[],
-    ngModules: StaticSymbol[],
-    injectables: StaticSymbol[]
+    ngModules: StaticSymbol[]
  }>;
  symbolsMissingModule?: StaticSymbol[];
 }

-export interface NgAnalyzeModulesHost { isSourceFile(filePath: string): boolean; }
-
 // Returns all the source files and a mapping from modules to directives
 export function analyzeNgModules(
-    programStaticSymbols: StaticSymbol[], host: NgAnalyzeModulesHost,
+    programStaticSymbols: StaticSymbol[],
+    options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp},
    metadataResolver: CompileMetadataResolver): NgAnalyzedModules {
  const {ngModules, symbolsMissingModule} =
-      _createNgModules(programStaticSymbols, host, metadataResolver);
-  return _analyzeNgModules(programStaticSymbols, ngModules, symbolsMissingModule, metadataResolver);
+      _createNgModules(programStaticSymbols, options, metadataResolver);
+  return _analyzeNgModules(ngModules, symbolsMissingModule);
 }

 export function analyzeAndValidateNgModules(
-    programStaticSymbols: StaticSymbol[], host: NgAnalyzeModulesHost,
+    programStaticSymbols: StaticSymbol[],
+    options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp},
    metadataResolver: CompileMetadataResolver): NgAnalyzedModules {
-  const result = analyzeNgModules(programStaticSymbols, host, metadataResolver);
+  const result = analyzeNgModules(programStaticSymbols, options, metadataResolver);
  if (result.symbolsMissingModule && result.symbolsMissingModule.length) {
    const messages = result.symbolsMissingModule.map(
        s => `Cannot determine the module for class ${s.name} in ${s.filePath}!`);
@ -300,27 +332,16 @@ export function analyzeAndValidateNgModules(
 }

 function _analyzeNgModules(
-    programSymbols: StaticSymbol[], ngModuleMetas: CompileNgModuleMetadata[],
-    symbolsMissingModule: StaticSymbol[],
-    metadataResolver: CompileMetadataResolver): NgAnalyzedModules {
+    ngModuleMetas: CompileNgModuleMetadata[],
+    symbolsMissingModule: StaticSymbol[]): NgAnalyzedModules {
  const moduleMetasByRef = new Map<any, CompileNgModuleMetadata>();
  ngModuleMetas.forEach((ngModule) => moduleMetasByRef.set(ngModule.type.reference, ngModule));
  const ngModuleByPipeOrDirective = new Map<StaticSymbol, CompileNgModuleMetadata>();
  const ngModulesByFile = new Map<string, StaticSymbol[]>();
  const ngDirectivesByFile = new Map<string, StaticSymbol[]>();
  const ngPipesByFile = new Map<string, StaticSymbol[]>();
-  const ngInjectablesByFile = new Map<string, StaticSymbol[]>();
  const filePaths = new Set<string>();

-  // Make sure we produce an analyzed file for each input file
-  programSymbols.forEach((symbol) => {
-    const filePath = symbol.filePath;
-    filePaths.add(filePath);
-    if (metadataResolver.isInjectable(symbol)) {
-      ngInjectablesByFile.set(filePath, (ngInjectablesByFile.get(filePath) || []).concat(symbol));
-    }
-  });
-
  // Looping over all modules to construct:
  // - a map from file to modules `ngModulesByFile`,
  // - a map from file to directives `ngDirectivesByFile`,
@ -348,20 +369,17 @@ function _analyzeNgModules(
    });
  });

-  const files: {
-    srcUrl: string,
-    directives: StaticSymbol[],
-    pipes: StaticSymbol[],
-    ngModules: StaticSymbol[],
-    injectables: StaticSymbol[]
-  }[] = [];
+  const files:
+      {srcUrl: string,
+       directives: StaticSymbol[],
+       pipes: StaticSymbol[],
+       ngModules: StaticSymbol[]}[] = [];

  filePaths.forEach((srcUrl) => {
    const directives = ngDirectivesByFile.get(srcUrl) || [];
    const pipes = ngPipesByFile.get(srcUrl) || [];
    const ngModules = ngModulesByFile.get(srcUrl) || [];
-    const injectables = ngInjectablesByFile.get(srcUrl) || [];
-    files.push({srcUrl, directives, pipes, ngModules, injectables});
+    files.push({srcUrl, directives, pipes, ngModules});
  });

  return {
@ -374,20 +392,29 @@ function _analyzeNgModules(
 }

 export function extractProgramSymbols(
-    staticSymbolResolver: StaticSymbolResolver, files: string[],
-    host: NgAnalyzeModulesHost): StaticSymbol[] {
+    staticReflector: StaticReflector, files: string[],
+    options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp} = {}): StaticSymbol[] {
  const staticSymbols: StaticSymbol[] = [];
-  files.filter(fileName => host.isSourceFile(fileName)).forEach(sourceFile => {
-    staticSymbolResolver.getSymbolsOf(sourceFile).forEach((symbol) => {
-      const resolvedSymbol = staticSymbolResolver.resolveSymbol(symbol);
-      const symbolMeta = resolvedSymbol.metadata;
-      if (symbolMeta) {
-        if (symbolMeta.__symbolic != 'error') {
-          // Ignore symbols that are only included to record error information.
-          staticSymbols.push(resolvedSymbol.symbol);
-        }
+  files.filter(fileName => filterFileByPatterns(fileName, options)).forEach(sourceFile => {
+    const moduleMetadata = staticReflector.getModuleMetadata(sourceFile);
+    if (!moduleMetadata) {
+      console.error(`WARNING: no metadata found for ${sourceFile}`);
+      return;
+    }
+
+    const metadata = moduleMetadata['metadata'];
+
+    if (!metadata) {
+      return;
+    }
+
+    for (const symbol of Object.keys(metadata)) {
+      if (metadata[symbol] && metadata[symbol].__symbolic == 'error') {
+        // Ignore symbols that are only included to record error information.
+        continue;
      }
-    });
+      staticSymbols.push(staticReflector.getStaticSymbol(sourceFile, symbol));
+    }
  });

  return staticSymbols;
@ -397,7 +424,8 @@ export function extractProgramSymbols(
 // that all directives / pipes that are present in the program
 // are also declared by a module.
 function _createNgModules(
-    programStaticSymbols: StaticSymbol[], host: NgAnalyzeModulesHost,
+    programStaticSymbols: StaticSymbol[],
+    options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp},
    metadataResolver: CompileMetadataResolver):
    {ngModules: CompileNgModuleMetadata[], symbolsMissingModule: StaticSymbol[]} {
  const ngModules = new Map<any, CompileNgModuleMetadata>();
@ -405,7 +433,7 @@ function _createNgModules(
  const ngModulePipesAndDirective = new Set<StaticSymbol>();

  const addNgModule = (staticSymbol: any) => {
-    if (ngModules.has(staticSymbol) || !host.isSourceFile(staticSymbol.filePath)) {
+    if (ngModules.has(staticSymbol) || !filterFileByPatterns(staticSymbol.filePath, options)) {
      return false;
    }
    const ngModule = metadataResolver.getNgModuleMetadata(staticSymbol, false);
--- a/modules/@angular/compiler/src/aot/compiler_factory.ts
+++ b/modules/@angular/compiler/src/aot/compiler_factory.ts
@ -34,12 +34,8 @@ import {AotCompilerHost} from './compiler_host';
 import {AotCompilerOptions} from './compiler_options';
 import {StaticAndDynamicReflectionCapabilities} from './static_reflection_capabilities';
 import {StaticReflector} from './static_reflector';
-import {StaticSymbol, 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.
 */
@ -48,10 +44,7 @@ export function createAotCompiler(compilerHost: AotCompilerHost, options: AotCom
  let translations: string = options.translations || '';

  const urlResolver = createOfflineCompileUrlResolver();
-  const symbolCache = new StaticSymbolCache();
-  const summaryResolver = new AotSummaryResolver(compilerHost, symbolCache);
-  const symbolResolver = new StaticSymbolResolver(compilerHost, symbolCache, summaryResolver);
-  const staticReflector = new StaticReflector(symbolResolver);
+  const staticReflector = new StaticReflector(compilerHost);
  StaticAndDynamicReflectionCapabilities.install(staticReflector);
  const htmlParser = new I18NHtmlParser(new HtmlParser(), translations, options.i18nFormat);
  const config = new CompilerConfig({
@ -67,22 +60,17 @@ export function createAotCompiler(compilerHost: AotCompilerHost, options: AotCom
  const console = new Console();
  const tmplParser =
      new TemplateParser(expressionParser, elementSchemaRegistry, htmlParser, console, []);
+  const summaryResolver = new AotSummaryResolver(compilerHost, staticReflector, options);
  const resolver = new CompileMetadataResolver(
      new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector),
      new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer,
-      symbolCache, staticReflector);
+      staticReflector);
  // TODO(vicb): do not pass options.i18nFormat here
-  const importResolver = {
-    getImportAs: (symbol: StaticSymbol) => symbolResolver.getImportAs(symbol),
-    fileNameToModuleName: (fileName: string, containingFilePath: string) =>
-                              compilerHost.fileNameToModuleName(fileName, containingFilePath)
-  };
  const compiler = new AotCompiler(
-      compilerHost, resolver, tmplParser, new StyleCompiler(urlResolver),
+      resolver, tmplParser, new StyleCompiler(urlResolver),
      new ViewCompiler(config, elementSchemaRegistry),
      new DirectiveWrapperCompiler(config, expressionParser, elementSchemaRegistry, console),
-      new NgModuleCompiler(), new TypeScriptEmitter(importResolver), summaryResolver,
-      options.locale, options.i18nFormat, new AnimationParser(elementSchemaRegistry),
-      symbolResolver);
+      new NgModuleCompiler(), new TypeScriptEmitter(compilerHost), summaryResolver, options.locale,
+      options.i18nFormat, new AnimationParser(elementSchemaRegistry), staticReflector, options);
  return {compiler, reflector: staticReflector};
 }
--- a/modules/@angular/compiler/src/aot/compiler_host.ts
+++ b/modules/@angular/compiler/src/aot/compiler_host.ts
@ -6,24 +6,18 @@
 * found in the LICENSE file at https://angular.io/license
 */

+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';

 /**
 * The host of the AotCompiler disconnects the implementation from TypeScript / other language
 * services and from underlying file systems.
 */
-export interface AotCompilerHost extends StaticSymbolResolverHost, AotSummaryResolverHost {
-  /**
-   * 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`.
-   *
-   * See ImportResolver.
-   */
-  fileNameToModuleName(importedFilePath: string, containingFilePath: string): string
-      /*|null*/;
-
+export interface AotCompilerHost extends StaticReflectorHost, ImportResolver,
+    AotSummaryResolverHost {
  /**
   * Loads a resource (e.g. html / css)
   */
--- a/modules/@angular/compiler/src/aot/compiler_options.ts
+++ b/modules/@angular/compiler/src/aot/compiler_options.ts
@ -11,4 +11,6 @@ export interface AotCompilerOptions {
  locale?: string;
  i18nFormat?: string;
  translations?: string;
+  includeFilePattern?: RegExp;
+  excludeFilePattern?: RegExp;
 }
--- a/modules/@angular/compiler/src/aot/static_reflection_capabilities.ts
+++ b/modules/@angular/compiler/src/aot/static_reflection_capabilities.ts
@ -8,7 +8,6 @@

 import {GetterFn, MethodFn, ReflectionCapabilities, SetterFn, reflector} from '../private_import_core';
 import {StaticReflector} from './static_reflector';
-import {StaticSymbol} from './static_symbol';

 export class StaticAndDynamicReflectionCapabilities {
  static install(staticDelegate: StaticReflector) {
@ -43,7 +42,7 @@ export class StaticAndDynamicReflectionCapabilities {
  method(name: string): MethodFn { return this.dynamicDelegate.method(name); }
  importUri(type: any): string { return this.staticDelegate.importUri(type); }
  resolveIdentifier(name: string, moduleUrl: string, runtime: any) {
-    return this.staticDelegate.resolveIdentifier(name, moduleUrl);
+    return this.staticDelegate.resolveIdentifier(name, moduleUrl, runtime);
  }
  resolveEnum(enumIdentifier: any, name: string): any {
    if (isStaticType(enumIdentifier)) {
--- a/modules/@angular/compiler/src/aot/static_reflector.ts
+++ b/modules/@angular/compiler/src/aot/static_reflector.ts
@ -7,12 +7,10 @@
 */

 import {Attribute, Component, ContentChild, ContentChildren, Directive, Host, HostBinding, HostListener, Inject, Injectable, Input, NgModule, Optional, Output, Pipe, Self, SkipSelf, ViewChild, ViewChildren, animate, group, keyframes, sequence, state, style, transition, trigger} from '@angular/core';
-
 import {ReflectorReader} from '../private_import_core';
+import {StaticSymbol} from './static_symbol';

-import {StaticSymbol, StaticSymbolCache} from './static_symbol';
-import {ResolvedStaticSymbol, StaticSymbolResolver} from './static_symbol_resolver';
-
+const SUPPORTED_SCHEMA_VERSION = 3;
 const ANGULAR_IMPORT_LOCATIONS = {
  coreDecorators: '@angular/core/src/metadata',
  diDecorators: '@angular/core/src/di/metadata',
@ -24,20 +22,66 @@ const ANGULAR_IMPORT_LOCATIONS = {

 const HIDDEN_KEY = /^\$.*\$$/;

+/**
+ * The host of the StaticReflector disconnects the implementation from TypeScript / other language
+ * services and from underlying file systems.
+ */
+export interface StaticReflectorHost {
+  /**
+   * Return a ModuleMetadata for the given module.
+   * Angular 2 CLI will produce this metadata for a module whenever a .d.ts files is
+   * produced and the module has exported variables or classes with decorators. Module metadata can
+   * also be produced directly from TypeScript sources by using MetadataCollector in tools/metadata.
+   *
+   * @param modulePath is a string identifier for a module as an absolute path.
+   * @returns the metadata for the given module.
+   */
+  getMetadataFor(modulePath: string): {[key: string]: any}[];
+
+  /**
+   * Converts a module name that is used in an `import` to a file path.
+   * I.e.
+   * `path/to/containingFile.ts` containing `import {...} from 'module-name'`.
+   */
+  moduleNameToFileName(moduleName: string, containingFile: string): string;
+}
+
+/**
+ * A cache of static symbol used by the StaticReflector to return the same symbol for the
+ * same symbol values.
+ */
+export class StaticSymbolCache {
+  private cache = new Map<string, StaticSymbol>();
+
+  get(declarationFile: string, name: string, members?: string[]): StaticSymbol {
+    const memberSuffix = members ? `.${ members.join('.')}` : '';
+    const key = `"${declarationFile}".${name}${memberSuffix}`;
+    let result = this.cache.get(key);
+    if (!result) {
+      result = new StaticSymbol(declarationFile, name, members);
+      this.cache.set(key, result);
+    }
+    return result;
+  }
+}
+
 /**
 * A static reflector implements enough of the Reflector API that is necessary to compile
 * templates statically.
 */
 export class StaticReflector implements ReflectorReader {
+  private declarationCache = new Map<string, StaticSymbol>();
  private annotationCache = new Map<StaticSymbol, any[]>();
  private propertyCache = new Map<StaticSymbol, {[key: string]: any[]}>();
  private parameterCache = new Map<StaticSymbol, any[]>();
  private methodCache = new Map<StaticSymbol, {[key: string]: boolean}>();
+  private metadataCache = new Map<string, {[key: string]: any}>();
  private conversionMap = new Map<StaticSymbol, (context: StaticSymbol, args: any[]) => any>();
  private opaqueToken: StaticSymbol;

  constructor(
-      private symbolResolver: StaticSymbolResolver,
+      private host: StaticReflectorHost,
+      private staticSymbolCache: StaticSymbolCache = new StaticSymbolCache(),
      knownMetadataClasses: {name: string, filePath: string, ctor: any}[] = [],
      knownMetadataFunctions: {name: string, filePath: string, fn: any}[] = [],
      private errorRecorder?: (error: any, fileName: string) => void) {
@ -50,26 +94,12 @@ export class StaticReflector implements ReflectorReader {
  }

  importUri(typeOrFunc: StaticSymbol): string {
-    const staticSymbol = this.findSymbolDeclaration(typeOrFunc);
+    const staticSymbol = this.findDeclaration(typeOrFunc.filePath, typeOrFunc.name, '');
    return staticSymbol ? staticSymbol.filePath : null;
  }

-  resolveIdentifier(name: string, moduleUrl: string): StaticSymbol {
-    return this.findDeclaration(moduleUrl, name);
-  }
-
-  findDeclaration(moduleUrl: string, name: string, containingFile?: string): StaticSymbol {
-    return this.findSymbolDeclaration(
-        this.symbolResolver.getSymbolByModule(moduleUrl, name, containingFile));
-  }
-
-  findSymbolDeclaration(symbol: StaticSymbol): StaticSymbol {
-    const resolvedSymbol = this.symbolResolver.resolveSymbol(symbol);
-    if (resolvedSymbol && resolvedSymbol.metadata instanceof StaticSymbol) {
-      return this.findSymbolDeclaration(resolvedSymbol.metadata);
-    } else {
-      return symbol;
-    }
+  resolveIdentifier(name: string, moduleUrl: string, runtime: any): any {
+    return this.findDeclaration(moduleUrl, name, '');
  }

  resolveEnum(enumIdentifier: any, name: string): any {
@ -83,11 +113,8 @@ export class StaticReflector implements ReflectorReader {
      annotations = [];
      const classMetadata = this.getTypeMetadata(type);
      if (classMetadata['extends']) {
-        const parentType = this.simplify(type, classMetadata['extends']);
-        if (parentType instanceof StaticSymbol) {
-          const parentAnnotations = this.annotations(parentType);
-          annotations.push(...parentAnnotations);
-        }
+        const parentAnnotations = this.annotations(this.simplify(type, classMetadata['extends']));
+        annotations.push(...parentAnnotations);
      }
      if (classMetadata['decorators']) {
        const ownAnnotations: any[] = this.simplify(type, classMetadata['decorators']);
@ -101,16 +128,13 @@ 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 parentType = this.simplify(type, classMetadata['extends']);
-        if (parentType instanceof StaticSymbol) {
-          const parentPropMetadata = this.propMetadata(parentType);
-          Object.keys(parentPropMetadata).forEach((parentProp) => {
-            propMetadata[parentProp] = parentPropMetadata[parentProp];
-          });
-        }
+        const parentPropMetadata = this.propMetadata(this.simplify(type, classMetadata['extends']));
+        Object.keys(parentPropMetadata).forEach((parentProp) => {
+          propMetadata[parentProp] = parentPropMetadata[parentProp];
+        });
      }

      const members = classMetadata['members'] || {};
@ -162,10 +186,7 @@ export class StaticReflector implements ReflectorReader {
            parameters.push(nestedResult);
          });
        } else if (classMetadata['extends']) {
-          const parentType = this.simplify(type, classMetadata['extends']);
-          if (parentType instanceof StaticSymbol) {
-            parameters = this.parameters(parentType);
-          }
+          parameters = this.parameters(this.simplify(type, classMetadata['extends']));
        }
        if (!parameters) {
          parameters = [];
@ -182,16 +203,13 @@ 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 parentType = this.simplify(type, classMetadata['extends']);
-        if (parentType instanceof StaticSymbol) {
-          const parentMethodNames = this._methodNames(parentType);
-          Object.keys(parentMethodNames).forEach((parentProp) => {
-            methodNames[parentProp] = parentMethodNames[parentProp];
-          });
-        }
+        const parentMethodNames = this._methodNames(this.simplify(type, classMetadata['extends']));
+        Object.keys(parentMethodNames).forEach((parentProp) => {
+          methodNames[parentProp] = parentMethodNames[parentProp];
+        });
      }

      const members = classMetadata['members'] || {};
@ -288,7 +306,7 @@ export class StaticReflector implements ReflectorReader {
   * @param name the name of the type.
   */
  getStaticSymbol(declarationFile: string, name: string, members?: string[]): StaticSymbol {
-    return this.symbolResolver.getStaticSymbol(declarationFile, name, members);
+    return this.staticSymbolCache.get(declarationFile, name, members);
  }

  private reportError(error: Error, context: StaticSymbol, path?: string) {
@ -299,6 +317,96 @@ export class StaticReflector implements ReflectorReader {
    }
  }

+  private resolveExportedSymbol(filePath: string, symbolName: string): StaticSymbol {
+    const resolveModule = (moduleName: string): string => {
+      const resolvedModulePath = this.host.moduleNameToFileName(moduleName, filePath);
+      if (!resolvedModulePath) {
+        this.reportError(
+            new Error(`Could not resolve module '${moduleName}' relative to file ${filePath}`),
+            null, filePath);
+      }
+      return resolvedModulePath;
+    };
+    const cacheKey = `${filePath}|${symbolName}`;
+    let staticSymbol = this.declarationCache.get(cacheKey);
+    if (staticSymbol) {
+      return staticSymbol;
+    }
+    const metadata = this.getModuleMetadata(filePath);
+    if (metadata) {
+      // If we have metadata for the symbol, this is the original exporting location.
+      if (metadata['metadata'][symbolName]) {
+        staticSymbol = this.getStaticSymbol(filePath, symbolName);
+      }
+
+      // If no, try to find the symbol in one of the re-export location
+      if (!staticSymbol && metadata['exports']) {
+        // Try and find the symbol in the list of explicitly re-exported symbols.
+        for (const moduleExport of metadata['exports']) {
+          if (moduleExport.export) {
+            const exportSymbol = moduleExport.export.find((symbol: any) => {
+              if (typeof symbol === 'string') {
+                return symbol == symbolName;
+              } else {
+                return symbol.as == symbolName;
+              }
+            });
+            if (exportSymbol) {
+              let symName = symbolName;
+              if (typeof exportSymbol !== 'string') {
+                symName = exportSymbol.name;
+              }
+              const resolvedModule = resolveModule(moduleExport.from);
+              if (resolvedModule) {
+                staticSymbol =
+                    this.resolveExportedSymbol(resolveModule(moduleExport.from), symName);
+                break;
+              }
+            }
+          }
+        }
+
+        if (!staticSymbol) {
+          // Try to find the symbol via export * directives.
+          for (const moduleExport of metadata['exports']) {
+            if (!moduleExport.export) {
+              const resolvedModule = resolveModule(moduleExport.from);
+              if (resolvedModule) {
+                const candidateSymbol = this.resolveExportedSymbol(resolvedModule, symbolName);
+                if (candidateSymbol) {
+                  staticSymbol = candidateSymbol;
+                  break;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    this.declarationCache.set(cacheKey, staticSymbol);
+    return staticSymbol;
+  }
+
+  findDeclaration(module: string, symbolName: string, containingFile?: string): StaticSymbol {
+    try {
+      const filePath = this.host.moduleNameToFileName(module, containingFile);
+      let symbol: StaticSymbol;
+      if (!filePath) {
+        // If the file cannot be found the module is probably referencing a declared module
+        // for which there is no disambiguating file and we also don't need to track
+        // re-exports. Just use the module name.
+        symbol = this.getStaticSymbol(module, symbolName);
+      } else {
+        symbol = this.resolveExportedSymbol(filePath, symbolName) ||
+            this.getStaticSymbol(filePath, symbolName);
+      }
+      return symbol;
+    } catch (e) {
+      console.error(`can't resolve module ${module} from ${containingFile}`);
+      throw e;
+    }
+  }
+
  /** @internal */
  public simplify(context: StaticSymbol, value: any): any {
    const self = this;
@ -306,41 +414,93 @@ export class StaticReflector implements ReflectorReader {
    const calling = new Map<StaticSymbol, boolean>();

    function simplifyInContext(context: StaticSymbol, value: any, depth: number): any {
-      function resolveReferenceValue(staticSymbol: StaticSymbol): any {
-        const resolvedSymbol = self.symbolResolver.resolveSymbol(staticSymbol);
-        return resolvedSymbol ? resolvedSymbol.metadata : null;
+      function resolveReference(context: StaticSymbol, expression: any): StaticSymbol {
+        let staticSymbol: StaticSymbol;
+        if (expression['module']) {
+          staticSymbol =
+              self.findDeclaration(expression['module'], expression['name'], context.filePath);
+        } else {
+          staticSymbol = self.getStaticSymbol(context.filePath, expression['name']);
+        }
+        return staticSymbol;
      }

-      function simplifyCall(functionSymbol: StaticSymbol, targetFunction: any, args: any[]) {
-        if (targetFunction && targetFunction['__symbolic'] == 'function') {
-          if (calling.get(functionSymbol)) {
-            throw new Error('Recursion not supported');
+      function resolveReferenceValue(staticSymbol: StaticSymbol): any {
+        const moduleMetadata = self.getModuleMetadata(staticSymbol.filePath);
+        const declarationValue =
+            moduleMetadata ? moduleMetadata['metadata'][staticSymbol.name] : null;
+        return declarationValue;
+      }
+
+      function isOpaqueToken(context: StaticSymbol, value: any): boolean {
+        if (value && value.__symbolic === 'new' && value.expression) {
+          const target = value.expression;
+          if (target.__symbolic == 'reference') {
+            return sameSymbol(resolveReference(context, target), self.opaqueToken);
          }
-          calling.set(functionSymbol, true);
-          try {
-            const value = targetFunction['value'];
-            if (value && (depth != 0 || value.__symbolic != 'error')) {
-              const parameters: string[] = targetFunction['parameters'];
-              const defaults: any[] = targetFunction.defaults;
-              if (defaults && defaults.length > args.length) {
-                args.push(...defaults.slice(args.length).map((value: any) => simplify(value)));
-              }
-              const functionScope = BindingScope.build();
-              for (let i = 0; i < parameters.length; i++) {
-                functionScope.define(parameters[i], args[i]);
-              }
-              const oldScope = scope;
-              let result: any;
-              try {
-                scope = functionScope.done();
-                result = simplifyInContext(functionSymbol, value, depth + 1);
-              } finally {
-                scope = oldScope;
-              }
-              return result;
+        }
+        return false;
+      }
+
+      function simplifyCall(expression: any) {
+        let callContext: {[name: string]: string}|undefined = undefined;
+        if (expression['__symbolic'] == 'call') {
+          const target = expression['expression'];
+          let functionSymbol: StaticSymbol;
+          let targetFunction: any;
+          if (target) {
+            switch (target.__symbolic) {
+              case 'reference':
+                // Find the function to call.
+                callContext = {name: target.name};
+                functionSymbol = resolveReference(context, target);
+                targetFunction = resolveReferenceValue(functionSymbol);
+                break;
+              case 'select':
+                // Find the static method to call
+                if (target.expression.__symbolic == 'reference') {
+                  functionSymbol = resolveReference(context, target.expression);
+                  const classData = resolveReferenceValue(functionSymbol);
+                  if (classData && classData.statics) {
+                    targetFunction = classData.statics[target.member];
+                  }
+                }
+                break;
+            }
+          }
+          if (targetFunction && targetFunction['__symbolic'] == 'function') {
+            if (calling.get(functionSymbol)) {
+              throw new Error('Recursion not supported');
+            }
+            calling.set(functionSymbol, true);
+            try {
+              const value = targetFunction['value'];
+              if (value && (depth != 0 || value.__symbolic != 'error')) {
+                // Determine the arguments
+                const args: any[] =
+                    (expression['arguments'] || []).map((arg: any) => simplify(arg));
+                const parameters: string[] = targetFunction['parameters'];
+                const defaults: any[] = targetFunction.defaults;
+                if (defaults && defaults.length > args.length) {
+                  args.push(...defaults.slice(args.length).map((value: any) => simplify(value)));
+                }
+                const functionScope = BindingScope.build();
+                for (let i = 0; i < parameters.length; i++) {
+                  functionScope.define(parameters[i], args[i]);
+                }
+                const oldScope = scope;
+                let result: any;
+                try {
+                  scope = functionScope.done();
+                  result = simplifyInContext(functionSymbol, value, depth + 1);
+                } finally {
+                  scope = oldScope;
+                }
+                return result;
+              }
+            } finally {
+              calling.delete(functionSymbol);
            }
-          } finally {
-            calling.delete(functionSymbol);
          }
        }

@ -351,7 +511,7 @@ export class StaticReflector implements ReflectorReader {
          return {__symbolic: 'ignore'};
        }
        return simplify(
-            {__symbolic: 'error', message: 'Function call not supported', context: functionSymbol});
+            {__symbolic: 'error', message: 'Function call not supported', context: callContext});
      }

      function simplify(expression: any): any {
@ -380,18 +540,7 @@ export class StaticReflector implements ReflectorReader {
          return result;
        }
        if (expression instanceof StaticSymbol) {
-          // Stop simplification at builtin symbols
-          if (expression === self.opaqueToken || self.conversionMap.has(expression)) {
-            return expression;
-          } else {
-            const staticSymbol = expression;
-            const declarationValue = resolveReferenceValue(staticSymbol);
-            if (declarationValue) {
-              return simplifyInContext(staticSymbol, declarationValue, depth + 1);
-            } else {
-              return staticSymbol;
-            }
-          }
+          return expression;
        }
        if (expression) {
          if (expression['__symbolic']) {
@ -469,33 +618,50 @@ export class StaticReflector implements ReflectorReader {
                if (indexTarget && isPrimitive(index)) return indexTarget[index];
                return null;
              case 'select':
-                const member = expression['member'];
                let selectContext = context;
                let selectTarget = simplify(expression['expression']);
                if (selectTarget instanceof StaticSymbol) {
-                  const members = selectTarget.members.concat(member);
+                  // Access to a static instance variable
+                  const member: string = expression['member'];
+                  const members = selectTarget.members ?
+                      (selectTarget.members as string[]).concat(member) :
+                      [member];
+                  const declarationValue = resolveReferenceValue(selectTarget);
                  selectContext =
                      self.getStaticSymbol(selectTarget.filePath, selectTarget.name, members);
-                  const declarationValue = resolveReferenceValue(selectContext);
-                  if (declarationValue) {
-                    return simplifyInContext(selectContext, declarationValue, depth + 1);
+                  if (declarationValue && declarationValue.statics) {
+                    selectTarget = declarationValue.statics;
                  } else {
                    return selectContext;
                  }
                }
+                const member = simplifyInContext(selectContext, expression['member'], depth + 1);
                if (selectTarget && isPrimitive(member))
                  return simplifyInContext(selectContext, selectTarget[member], depth + 1);
                return null;
              case 'reference':
-                // Note: This only has to deal with variable references,
-                // as symbol references have been converted into StaticSymbols already
-                // in the StaticSymbolResolver!
-                const name: string = expression['name'];
-                const localValue = scope.resolve(name);
-                if (localValue != BindingScope.missing) {
-                  return localValue;
+                if (!expression['name']) {
+                  return context;
                }
-                break;
+                if (!expression.module) {
+                  const name: string = expression['name'];
+                  const localValue = scope.resolve(name);
+                  if (localValue != BindingScope.missing) {
+                    return localValue;
+                  }
+                }
+                staticSymbol = resolveReference(context, expression);
+                let result: any = staticSymbol;
+                let declarationValue = resolveReferenceValue(result);
+                if (declarationValue) {
+                  if (isOpaqueToken(staticSymbol, declarationValue)) {
+                    // If the referenced symbol is initalized by a new OpaqueToken we can keep the
+                    // reference to the symbol.
+                    return staticSymbol;
+                  }
+                  result = simplifyInContext(staticSymbol, declarationValue, depth + 1);
+                }
+                return result;
              case 'class':
                return context;
              case 'function':
@ -503,26 +669,26 @@ export class StaticReflector implements ReflectorReader {
              case 'new':
              case 'call':
                // Determine if the function is a built-in conversion
-                staticSymbol = simplifyInContext(context, expression['expression'], depth + 1);
-                if (staticSymbol instanceof StaticSymbol) {
-                  if (staticSymbol === self.opaqueToken) {
-                    // if somebody calls new OpaqueToken, don't create an OpaqueToken,
-                    // but rather return the symbol to which the OpaqueToken is assigned to.
-                    return context;
-                  }
-                  const argExpressions: any[] = expression['arguments'] || [];
-                  const args =
-                      argExpressions.map(arg => simplifyInContext(context, arg, depth + 1));
-                  let converter = self.conversionMap.get(staticSymbol);
-                  if (converter) {
-                    return converter(context, args);
-                  } else {
-                    // Determine if the function is one we can simplify.
-                    const targetFunction = resolveReferenceValue(staticSymbol);
-                    return simplifyCall(staticSymbol, targetFunction, args);
-                  }
+                let target = expression['expression'];
+                if (target['module']) {
+                  staticSymbol =
+                      self.findDeclaration(target['module'], target['name'], context.filePath);
+                } else {
+                  staticSymbol = self.getStaticSymbol(context.filePath, target['name']);
                }
-                break;
+                let converter = self.conversionMap.get(staticSymbol);
+                if (converter) {
+                  let args: any[] = expression['arguments'];
+                  if (!args) {
+                    args = [];
+                  }
+                  return converter(
+                      context, args.map(arg => simplifyInContext(context, arg, depth + 1)));
+                }
+
+                // Determine if the function is one we can simplify.
+                return simplifyCall(expression);
+
              case 'error':
                let message = produceErrorMessage(expression);
                if (expression['line']) {
@ -543,9 +709,7 @@ export class StaticReflector implements ReflectorReader {
      try {
        return simplify(value);
      } catch (e) {
-        const members = context.members.length ? `.${context.members.join('.')}` : '';
-        const message =
-            `${e.message}, resolving symbol ${context.name}${members} in ${context.filePath}`;
+        const message = `${e.message}, resolving symbol ${context.name} in ${context.filePath}`;
        if (e.fileName) {
          throw positionalError(message, e.fileName, e.line, e.column);
        }
@ -569,10 +733,40 @@ export class StaticReflector implements ReflectorReader {
    return result;
  }

+  /**
+   * @param module an absolute path to a module file.
+   */
+  public getModuleMetadata(module: string): {[key: string]: any} {
+    let moduleMetadata = this.metadataCache.get(module);
+    if (!moduleMetadata) {
+      const moduleMetadatas = this.host.getMetadataFor(module);
+      if (moduleMetadatas) {
+        let maxVersion = -1;
+        moduleMetadatas.forEach((md) => {
+          if (md['version'] > maxVersion) {
+            maxVersion = md['version'];
+            moduleMetadata = md;
+          }
+        });
+      }
+      if (!moduleMetadata) {
+        moduleMetadata =
+            {__symbolic: 'module', version: SUPPORTED_SCHEMA_VERSION, module: module, metadata: {}};
+      }
+      if (moduleMetadata['version'] != SUPPORTED_SCHEMA_VERSION) {
+        const errorMessage = moduleMetadata['version'] == 2 ?
+            `Unsupported metadata version ${moduleMetadata['version']} for module ${module}. This module should be compiled with a newer version of ngc` :
+            `Metadata version mismatch for module ${module}, found version ${moduleMetadata['version']}, expected ${SUPPORTED_SCHEMA_VERSION}`;
+        this.reportError(new Error(errorMessage), null);
+      }
+      this.metadataCache.set(module, moduleMetadata);
+    }
+    return moduleMetadata;
+  }
+
  private getTypeMetadata(type: StaticSymbol): {[key: string]: any} {
-    const resolvedSymbol = this.symbolResolver.resolveSymbol(type);
-    return resolvedSymbol && resolvedSymbol.metadata ? resolvedSymbol.metadata :
-                                                       {__symbolic: 'class'};
+    const moduleMetadata = this.getModuleMetadata(type.filePath);
+    return moduleMetadata['metadata'][type.name] || {__symbolic: 'class'};
  }
 }

@ -664,7 +858,7 @@ class PopulatedScope extends BindingScope {
 }

 function sameSymbol(a: StaticSymbol, b: StaticSymbol): boolean {
-  return a === b;
+  return a === b || (a.name == b.name && a.filePath == b.filePath);
 }

 function shouldIgnore(value: any): boolean {
--- a/modules/@angular/compiler/src/aot/static_symbol.ts
+++ b/modules/@angular/compiler/src/aot/static_symbol.ts
@ -12,32 +12,5 @@
 * This token is unique for a filePath and name and can be used as a hash table key.
 */
 export class StaticSymbol {
-  constructor(public filePath: string, public name: string, public members: string[]) {}
-
-  assertNoMembers() {
-    if (this.members.length) {
-      throw new Error(
-          `Illegal state: symbol without members expected, but got ${JSON.stringify(this)}.`);
-    }
-  }
+  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;
-  }
-}
--- a/modules/@angular/compiler/src/aot/static_symbol_resolver.ts
+++ b/modules/@angular/compiler/src/aot/static_symbol_resolver.ts
@ -1,345 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {SummaryResolver} from '../summary_resolver';
-import {ValueTransformer, visitValue} from '../util';
-
-import {StaticSymbol, StaticSymbolCache} from './static_symbol';
-
-export class ResolvedStaticSymbol {
-  constructor(public symbol: StaticSymbol, public metadata: any) {}
-}
-
-/**
- * The host of the SymbolResolverHost disconnects the implementation from TypeScript / other
- * language
- * services and from underlying file systems.
- */
-export interface StaticSymbolResolverHost {
-  /**
-   * Return a ModuleMetadata for the given module.
-   * Angular 2 CLI will produce this metadata for a module whenever a .d.ts files is
-   * produced and the module has exported variables or classes with decorators. Module metadata can
-   * also be produced directly from TypeScript sources by using MetadataCollector in tools/metadata.
-   *
-   * @param modulePath is a string identifier for a module as an absolute path.
-   * @returns the metadata for the given module.
-   */
-  getMetadataFor(modulePath: string): {[key: string]: any}[];
-
-  /**
-   * Converts a module name that is used in an `import` to a file path.
-   * I.e.
-   * `path/to/containingFile.ts` containing `import {...} from 'module-name'`.
-   */
-  moduleNameToFileName(moduleName: string, containingFile: string): string /*|null*/;
-}
-
-const SUPPORTED_SCHEMA_VERSION = 3;
-
-/**
- * This class is responsible for loading metadata per symbol,
- * and normalizing references between symbols.
- *
- * Internally, it only uses symbols without members,
- * and deduces the values for symbols with members based
- * on these symbols.
- */
-export class StaticSymbolResolver {
-  private metadataCache = new Map<string, {[key: string]: any}>();
-  // Note: this will only contain StaticSymbols without members!
-  private resolvedSymbols = new Map<StaticSymbol, ResolvedStaticSymbol>();
-  private resolvedFilePaths = new Set<string>();
-  // Note: this will only contain StaticSymbols without members!
-  private importAs = new Map<StaticSymbol, StaticSymbol>();
-
-  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.resolvedSymbols.get(staticSymbol);
-    if (result) {
-      return result;
-    }
-    result = this._resolveSymbolFromSummary(staticSymbol);
-    if (result) {
-      return 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;
-  }
-
-  getImportAs(staticSymbol: StaticSymbol): StaticSymbol {
-    if (staticSymbol.members.length) {
-      const baseSymbol = this.getStaticSymbol(staticSymbol.filePath, staticSymbol.name);
-      const baseImportAs = this.getImportAs(baseSymbol);
-      return baseImportAs ?
-          this.getStaticSymbol(baseImportAs.filePath, baseImportAs.name, staticSymbol.members) :
-          null;
-    }
-    let result = this.summaryResolver.getImportAs(staticSymbol);
-    if (!result) {
-      result = this.importAs.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
-      const topLevelSymbolNames =
-          new Set<string>(Object.keys(metadata['metadata']).map(unescapeIdentifier));
-      Object.keys(metadata['metadata']).forEach((metadataKey) => {
-        const symbolMeta = metadata['metadata'][metadataKey];
-        resolvedSymbols.push(this.createResolvedSymbol(
-            this.getStaticSymbol(filePath, unescapeIdentifier(metadataKey)), topLevelSymbolNames,
-            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;
-            }
-            symbolName = unescapeIdentifier(symbolName);
-            let symName = symbolName;
-            if (typeof exportSymbol !== 'string') {
-              symName = unescapeIdentifier(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(this.createExport(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(this.createExport(sourceSymbol, targetSymbol));
-            });
-          }
-        }
-      }
-    }
-    resolvedSymbols.forEach(
-        (resolvedSymbol) => this.resolvedSymbols.set(resolvedSymbol.symbol, resolvedSymbol));
-  }
-
-  private createResolvedSymbol(
-      sourceSymbol: StaticSymbol, topLevelSymbolNames: Set<string>,
-      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'] ? unescapeIdentifier(map['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}.`
-              };
-            }
-            return self.getStaticSymbol(filePath, name);
-          } else if (functionParams.indexOf(name) >= 0) {
-            // reference to a function parameter
-            return {__symbolic: 'reference', name: name};
-          } else {
-            if (topLevelSymbolNames.has(name)) {
-              return self.getStaticSymbol(sourceSymbol.filePath, name);
-            }
-            // ambient value
-            null;
-          }
-        } else {
-          return super.visitStringMap(map, functionParams);
-        }
-      }
-    }
-    const transformedMeta = visitValue(metadata, new ReferenceTransformer(), []);
-    if (transformedMeta instanceof StaticSymbol) {
-      return this.createExport(sourceSymbol, transformedMeta);
-    }
-    return new ResolvedStaticSymbol(sourceSymbol, transformedMeta);
-  }
-
-  private createExport(sourceSymbol: StaticSymbol, targetSymbol: StaticSymbol):
-      ResolvedStaticSymbol {
-    sourceSymbol.assertNoMembers();
-    targetSymbol.assertNoMembers();
-    if (this.summaryResolver.isLibraryFile(sourceSymbol.filePath)) {
-      // This case is for an ng library importing symbols from a plain ts library
-      // transitively.
-      // Note: We rely on the fact that we discover symbols in the direction
-      // from source files to library files
-      this.importAs.set(targetSymbol, this.getImportAs(sourceSymbol) || sourceSymbol);
-    }
-    return new ResolvedStaticSymbol(sourceSymbol, targetSymbol);
-  }
-
-  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);
-    }
-  }
-}
-
-const UNDERSCORE_CHAR_CODE = 95;
-
-// Remove extra underscore from escaped identifier.
-// See https://github.com/Microsoft/TypeScript/blob/master/src/compiler/utilities.ts
-export function unescapeIdentifier(identifier: string): string {
-  return identifier.startsWith('___') ? identifier.substr(1) : identifier;
-}
--- a/modules/@angular/compiler/src/aot/summary_resolver.ts
+++ b/modules/@angular/compiler/src/aot/summary_resolver.ts
@ -5,24 +5,22 @@
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
-import {CompileSummaryKind, CompileTypeSummary} from '../compile_metadata';
-import {Summary, SummaryResolver} from '../summary_resolver';
+import {CompileDirectiveSummary, CompileIdentifierMetadata, CompileNgModuleSummary, CompilePipeSummary, CompileSummaryKind, CompileTypeMetadata, CompileTypeSummary, identifierModuleUrl, identifierName} from '../compile_metadata';
+import {SummaryResolver} from '../summary_resolver';

-import {StaticSymbol, StaticSymbolCache} from './static_symbol';
-import {ResolvedStaticSymbol} from './static_symbol_resolver';
-import {deserializeSummaries} from './summary_serializer';
-import {ngfactoryFilePath, stripNgFactory, summaryFileName} from './util';
+import {GeneratedFile} from './generated_file';
+import {StaticReflector} from './static_reflector';
+import {StaticSymbol} from './static_symbol';
+import {filterFileByPatterns} from './utils';
+
+const STRIP_SRC_FILE_SUFFIXES = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;

 export interface AotSummaryResolverHost {
  /**
   * Loads an NgModule/Directive/Pipe summary file
   */
-  loadSummary(filePath: string): string /*|null*/;
+  loadSummary(filePath: string): string;

-  /**
-   * Returns whether a file is a source file or not.
-   */
-  isSourceFile(sourceFilePath: string): boolean;
  /**
   * Returns the output file path of a source file.
   * E.g.
@ -31,67 +29,96 @@ export interface AotSummaryResolverHost {
  getOutputFileName(sourceFilePath: string): string;
 }

-export class AotSummaryResolver implements SummaryResolver<StaticSymbol> {
-  // Note: this will only contain StaticSymbols without members!
-  private summaryCache = new Map<StaticSymbol, Summary<StaticSymbol>>();
-  private loadedFilePaths = new Set<string>();
-  // Note: this will only contain StaticSymbols without members!
-  private importAs = new Map<StaticSymbol, StaticSymbol>();
+export interface AotSummaryResolverOptions {
+  includeFilePattern?: RegExp;
+  excludeFilePattern?: RegExp;
+}

-  constructor(private host: AotSummaryResolverHost, private staticSymbolCache: StaticSymbolCache) {}
+export class AotSummaryResolver implements SummaryResolver {
+  private summaryCache: {[cacheKey: string]: CompileTypeSummary} = {};

-  isLibraryFile(filePath: string): boolean {
-    // Note: We need to strip the .ngfactory. file path,
-    // so this method also works for generated files
-    // (for which host.isSourceFile will always return false).
-    return !this.host.isSourceFile(stripNgFactory(filePath));
-  }
+  constructor(
+      private host: AotSummaryResolverHost, private staticReflector: StaticReflector,
+      private options: AotSummaryResolverOptions) {}

-  getLibraryFileName(filePath: string) { return this.host.getOutputFileName(filePath); }
-
-  resolveSummary(staticSymbol: StaticSymbol): Summary<StaticSymbol> {
-    staticSymbol.assertNoMembers();
-    let summary = this.summaryCache.get(staticSymbol);
-    if (!summary) {
-      this._loadSummaryFile(staticSymbol.filePath);
-      summary = this.summaryCache.get(staticSymbol);
-    }
-    return summary;
-  }
-
-  getSymbolsOf(filePath: string): StaticSymbol[] {
-    this._loadSummaryFile(filePath);
-    return Array.from(this.summaryCache.keys()).filter((symbol) => symbol.filePath === filePath);
-  }
-
-  getImportAs(staticSymbol: StaticSymbol): StaticSymbol {
-    staticSymbol.assertNoMembers();
-    return this.importAs.get(staticSymbol);
-  }
-
-  private _loadSummaryFile(filePath: string) {
-    if (this.loadedFilePaths.has(filePath)) {
-      return;
-    }
-    this.loadedFilePaths.add(filePath);
-    if (this.isLibraryFile(filePath)) {
-      const summaryFilePath = summaryFileName(filePath);
-      let json: string;
-      try {
-        json = this.host.loadSummary(summaryFilePath);
-      } catch (e) {
-        console.error(`Error loading summary file ${summaryFilePath}`);
-        throw e;
+  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
+        };
      }
-      if (json) {
-        const {summaries, importAs} = deserializeSummaries(this.staticSymbolCache, json);
-        summaries.forEach((summary) => this.summaryCache.set(summary.symbol, summary));
-        importAs.forEach((importAs) => {
-          this.importAs.set(
-              importAs.symbol,
-              this.staticSymbolCache.get(ngfactoryFilePath(filePath), importAs.importAs));
+      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 _cacheKey(symbol: StaticSymbol) { return `${symbol.filePath}|${symbol.name}`; }
+
+  resolveSummary(staticSymbol: StaticSymbol): any {
+    const filePath = staticSymbol.filePath;
+    const name = staticSymbol.name;
+    const cacheKey = this._cacheKey(staticSymbol);
+    if (!filterFileByPatterns(filePath, this.options)) {
+      let summary = this.summaryCache[cacheKey];
+      const summaryFilePath = summaryFileName(filePath);
+      if (!summary) {
+        try {
+          const jsonReviver = (key: string, value: any) => {
+            if (value && value['__symbolic__'] === 'symbol') {
+              // Note: We can't use staticReflector.findDeclaration here:
+              // Summary files can contain symbols of transitive compilation units
+              // (via the providers), and findDeclaration needs .metadata.json / .d.ts files,
+              // but we don't want to depend on these for transitive dependencies.
+              return this.staticReflector.getStaticSymbol(
+                  value['path'], value['name'], value['members']);
+            } else {
+              return value;
+            }
+          };
+          const readSummaries: CompileTypeSummary[] =
+              JSON.parse(this.host.loadSummary(summaryFilePath), jsonReviver);
+          readSummaries.forEach((summary) => {
+            const filePath = summary.type.reference.filePath;
+            this.summaryCache[this._cacheKey(summary.type.reference)] = summary;
+          });
+          summary = this.summaryCache[cacheKey];
+        } catch (e) {
+          console.error(`Error loading summary file ${summaryFilePath}`);
+          throw e;
+        }
+      }
+      if (!summary) {
+        throw new Error(
+            `Could not find the symbol ${name} in the summary file ${summaryFilePath}!`);
+      }
+      return summary;
+    } else {
+      return null;
    }
  }
 }
+
+function summaryFileName(fileName: string): string {
+  const fileNameWithoutSuffix = fileName.replace(STRIP_SRC_FILE_SUFFIXES, '');
+  return `${fileNameWithoutSuffix}.ngsummary.json`;
+}
--- a/modules/@angular/compiler/src/aot/summary_serializer.ts
+++ b/modules/@angular/compiler/src/aot/summary_serializer.ts
@ -1,194 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import {CompileDirectiveSummary, CompileIdentifierMetadata, CompileNgModuleSummary, CompilePipeSummary, CompileSummaryKind, CompileTypeMetadata, CompileTypeSummary, identifierModuleUrl, identifierName} from '../compile_metadata';
-import {Summary, SummaryResolver} from '../summary_resolver';
-import {ValueTransformer, visitValue} from '../util';
-
-import {GeneratedFile} from './generated_file';
-import {StaticSymbol, StaticSymbolCache} from './static_symbol';
-import {ResolvedStaticSymbol, StaticSymbolResolver} from './static_symbol_resolver';
-
-const STRIP_SRC_FILE_SUFFIXES = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
-
-export function serializeSummaries(
-    summaryResolver: SummaryResolver<StaticSymbol>, symbolResolver: StaticSymbolResolver,
-    symbols: ResolvedStaticSymbol[], types: CompileTypeSummary[]):
-    {json: string, exportAs: {symbol: StaticSymbol, exportAs: string}[]} {
-  const serializer = new Serializer(symbolResolver, summaryResolver);
-
-  // 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 (summaryResolver.isLibraryFile(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 (summaryResolver.isLibraryFile(symbol.filePath)) {
-          const summary = summaryResolver.resolveSummary(symbol);
-          if (summary) {
-            serializer.addOrMergeSummary(summary);
-          }
-        }
-      });
-    }
-  });
-  return serializer.serialize();
-}
-
-export function deserializeSummaries(symbolCache: StaticSymbolCache, json: string):
-    {summaries: Summary<StaticSymbol>[], importAs: {symbol: StaticSymbol, importAs: string}[]} {
-  const deserializer = new Deserializer(symbolCache);
-  return deserializer.deserialize(json);
-}
-
-class Serializer extends ValueTransformer {
-  // Note: This only contains symbols without members.
-  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 symbolResolver: StaticSymbolResolver,
-      private summaryResolver: SummaryResolver<StaticSymbol>) {
-    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(): {json: string, exportAs: {symbol: StaticSymbol, exportAs: string}[]} {
-    const exportAs: {symbol: StaticSymbol, exportAs: string}[] = [];
-    const json = JSON.stringify({
-      summaries: this.processedSummaries,
-      symbols: this.symbols.map((symbol, index) => {
-        symbol.assertNoMembers();
-        let importAs: string;
-        if (this.summaryResolver.isLibraryFile(symbol.filePath)) {
-          importAs = `${symbol.name}_${index}`;
-          exportAs.push({symbol, exportAs: importAs});
-        }
-        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.summaryResolver.getLibraryFileName(symbol.filePath),
-          importAs: importAs
-        };
-      })
-    });
-    return {json, exportAs};
-  }
-
-  private processValue(value: any): any { return visitValue(value, this, null); }
-
-  visitOther(value: any, context: any): any {
-    if (value instanceof StaticSymbol) {
-      const baseSymbol = this.symbolResolver.getStaticSymbol(value.filePath, value.name);
-      let index = this.indexBySymbol.get(baseSymbol);
-      // Note: == by purpose to compare with undefined!
-      if (index == null) {
-        index = this.indexBySymbol.size;
-        this.indexBySymbol.set(baseSymbol, index);
-        this.symbols.push(baseSymbol);
-      }
-      return {__symbol: index, members: value.members};
-    }
-  }
-}
-
-class Deserializer extends ValueTransformer {
-  private symbols: StaticSymbol[];
-
-  constructor(private symbolCache: StaticSymbolCache) { super(); }
-
-  deserialize(json: string):
-      {summaries: Summary<StaticSymbol>[], importAs: {symbol: StaticSymbol, importAs: string}[]} {
-    const data: {summaries: any[], symbols: any[]} = JSON.parse(json);
-    const importAs: {symbol: StaticSymbol, importAs: string}[] = [];
-    this.symbols = [];
-    data.symbols.forEach((serializedSymbol) => {
-      const symbol = this.symbolCache.get(serializedSymbol.filePath, serializedSymbol.name);
-      this.symbols.push(symbol);
-      if (serializedSymbol.importAs) {
-        importAs.push({symbol: symbol, importAs: serializedSymbol.importAs});
-      }
-    });
-    const summaries = visitValue(data.summaries, this, null);
-    return {summaries, importAs};
-  }
-
-  visitStringMap(map: {[key: string]: any}, context: any): any {
-    if ('__symbol' in map) {
-      const baseSymbol = this.symbols[map['__symbol']];
-      const members = map['members'];
-      return members.length ? this.symbolCache.get(baseSymbol.filePath, baseSymbol.name, members) :
-                              baseSymbol;
-    } else {
-      return super.visitStringMap(map, context);
-    }
-  }
-}
--- a/modules/@angular/compiler/src/aot/util.ts
+++ b/modules/@angular/compiler/src/aot/util.ts
@ -1,37 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-const STRIP_SRC_FILE_SUFFIXES = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
-
-export function ngfactoryFilePath(filePath: string): string {
-  const urlWithSuffix = splitTypescriptSuffix(filePath);
-  return `${urlWithSuffix[0]}.ngfactory${urlWithSuffix[1]}`;
-}
-
-export function stripNgFactory(filePath: string): string {
-  return filePath.replace(/\.ngfactory\./, '.');
-}
-
-export function splitTypescriptSuffix(path: string): string[] {
-  if (path.endsWith('.d.ts')) {
-    return [path.slice(0, -5), '.ts'];
-  }
-
-  const lastDot = path.lastIndexOf('.');
-
-  if (lastDot !== -1) {
-    return [path.substring(0, lastDot), path.substring(lastDot)];
-  }
-
-  return [path, ''];
-}
-
-export function summaryFileName(fileName: string): string {
-  const fileNameWithoutSuffix = fileName.replace(STRIP_SRC_FILE_SUFFIXES, '');
-  return `${fileNameWithoutSuffix}.ngsummary.json`;
-}
--- a/modules/@angular/compiler/src/aot/utils.ts
+++ b/modules/@angular/compiler/src/aot/utils.ts
@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+export function filterFileByPatterns(
+    fileName: string, options: {includeFilePattern?: RegExp, excludeFilePattern?: RegExp} = {}) {
+  let match = true;
+  if (options.includeFilePattern) {
+    match = match && !!options.includeFilePattern.exec(fileName);
+  }
+  if (options.excludeFilePattern) {
+    match = match && !options.excludeFilePattern.exec(fileName);
+  }
+  return match;
+}
--- a/modules/@angular/compiler/src/compile_metadata.ts
+++ b/modules/@angular/compiler/src/compile_metadata.ts
@ -6,7 +6,7 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {ChangeDetectionStrategy, ComponentFactory, SchemaMetadata, Type, ViewEncapsulation} from '@angular/core';
+import {ChangeDetectionStrategy, SchemaMetadata, Type, ViewEncapsulation} from '@angular/core';

 import {StaticSymbol} from './aot/static_symbol';
 import {ListWrapper} from './facade/collection';
@ -112,31 +112,13 @@ export function identifierModuleUrl(compileIdentifier: CompileIdentifierMetadata
  return reflector.importUri(ref);
 }

-export function viewClassName(compType: any, embeddedTemplateIndex: number): string {
-  return `View_${identifierName({reference: compType})}_${embeddedTemplateIndex}`;
-}
-
-export function hostViewClassName(compType: any): string {
-  return `HostView_${identifierName({reference: compType})}`;
-}
-
-export function dirWrapperClassName(dirType: any) {
-  return `Wrapper_${identifierName({reference: dirType})}`;
-}
-
-export function componentFactoryName(compType: any): string {
-  return `${identifierName({reference: compType})}NgFactory`;
-}
-
-export interface ProxyClass { setDelegate(delegate: any): void; }
-
 export interface CompileIdentifierMetadata { reference: any; }

 export enum CompileSummaryKind {
+  Template,
  Pipe,
  Directive,
-  NgModule,
-  Injectable
+  NgModule
 }

 /**
@ -144,10 +126,9 @@ export enum CompileSummaryKind {
 * in other modules / components. However, this data is not enough to compile
 * the directive / module itself.
 */
-export interface CompileTypeSummary {
-  summaryKind: CompileSummaryKind;
-  type: CompileTypeMetadata;
-}
+export interface CompileSummary { summaryKind: CompileSummaryKind; }
+
+export interface CompileTypeSummary extends CompileSummary { type: CompileTypeMetadata; }

 export interface CompileDiDependencyMetadata {
  isAttribute?: boolean;
@ -229,7 +210,7 @@ export class CompileStylesheetMetadata {
 /**
 * Summary Metadata regarding compilation of a template.
 */
-export interface CompileTemplateSummary {
+export interface CompileTemplateSummary extends CompileSummary {
  animations: string[];
  ngContentSelectors: string[];
  encapsulation: ViewEncapsulation;
@ -259,7 +240,7 @@ export class CompileTemplateMetadata {
        externalStylesheets?: CompileStylesheetMetadata[],
        ngContentSelectors?: string[],
        animations?: CompileAnimationEntryMetadata[],
-        interpolation?: [string, string],
+        interpolation?: [string, string]
      } = {}) {
    this.encapsulation = encapsulation;
    this.template = template;
@ -277,18 +258,14 @@ export class CompileTemplateMetadata {

  toSummary(): CompileTemplateSummary {
    return {
+      summaryKind: CompileSummaryKind.Template,
      animations: this.animations.map(anim => anim.name),
      ngContentSelectors: this.ngContentSelectors,
-      encapsulation: this.encapsulation,
+      encapsulation: this.encapsulation
    };
  }
 }

-export interface CompileEntryComponentMetadata {
-  componentType: any;
-  componentFactory: StaticSymbol|ComponentFactory<any>;
-}
-
 // Note: This should only use interfaces as nested data types
 // as we need to be able to serialize this from/to JSON!
 export interface CompileDirectiveSummary extends CompileTypeSummary {
@ -304,12 +281,9 @@ export interface CompileDirectiveSummary extends CompileTypeSummary {
  providers: CompileProviderMetadata[];
  viewProviders: CompileProviderMetadata[];
  queries: CompileQueryMetadata[];
-  entryComponents: CompileEntryComponentMetadata[];
+  entryComponents: CompileIdentifierMetadata[];
  changeDetection: ChangeDetectionStrategy;
  template: CompileTemplateSummary;
-  wrapperType: StaticSymbol|ProxyClass;
-  componentViewType: StaticSymbol|ProxyClass;
-  componentFactory: StaticSymbol|ComponentFactory<any>;
 }

 /**
@ -318,8 +292,7 @@ export interface CompileDirectiveSummary extends CompileTypeSummary {
 export class CompileDirectiveMetadata {
  static create(
      {isHost, type, isComponent, selector, exportAs, changeDetection, inputs, outputs, host,
-       providers, viewProviders, queries, viewQueries, entryComponents, template, wrapperType,
-       componentViewType, componentFactory}: {
+       providers, viewProviders, queries, viewQueries, entryComponents, template}: {
        isHost?: boolean,
        type?: CompileTypeMetadata,
        isComponent?: boolean,
@ -333,11 +306,8 @@ export class CompileDirectiveMetadata {
        viewProviders?: CompileProviderMetadata[],
        queries?: CompileQueryMetadata[],
        viewQueries?: CompileQueryMetadata[],
-        entryComponents?: CompileEntryComponentMetadata[],
-        template?: CompileTemplateMetadata,
-        wrapperType?: StaticSymbol|ProxyClass,
-        componentViewType?: StaticSymbol|ProxyClass,
-        componentFactory?: StaticSymbol|ComponentFactory<any>,
+        entryComponents?: CompileIdentifierMetadata[],
+        template?: CompileTemplateMetadata
      } = {}): CompileDirectiveMetadata {
    const hostListeners: {[key: string]: string} = {};
    const hostProperties: {[key: string]: string} = {};
@ -389,9 +359,6 @@ export class CompileDirectiveMetadata {
      viewQueries,
      entryComponents,
      template,
-      wrapperType,
-      componentViewType,
-      componentFactory,
    });
  }
  isHost: boolean;
@ -409,39 +376,32 @@ export class CompileDirectiveMetadata {
  viewProviders: CompileProviderMetadata[];
  queries: CompileQueryMetadata[];
  viewQueries: CompileQueryMetadata[];
-  entryComponents: CompileEntryComponentMetadata[];
+  entryComponents: CompileIdentifierMetadata[];

  template: CompileTemplateMetadata;

-  wrapperType: StaticSymbol|ProxyClass;
-  componentViewType: StaticSymbol|ProxyClass;
-  componentFactory: StaticSymbol|ComponentFactory<any>;
-
-  constructor({isHost,          type,      isComponent,   selector,          exportAs,
-               changeDetection, inputs,    outputs,       hostListeners,     hostProperties,
-               hostAttributes,  providers, viewProviders, queries,           viewQueries,
-               entryComponents, template,  wrapperType,   componentViewType, componentFactory}: {
-    isHost?: boolean,
-    type?: CompileTypeMetadata,
-    isComponent?: boolean,
-    selector?: string,
-    exportAs?: string,
-    changeDetection?: ChangeDetectionStrategy,
-    inputs?: {[key: string]: string},
-    outputs?: {[key: string]: string},
-    hostListeners?: {[key: string]: string},
-    hostProperties?: {[key: string]: string},
-    hostAttributes?: {[key: string]: string},
-    providers?: CompileProviderMetadata[],
-    viewProviders?: CompileProviderMetadata[],
-    queries?: CompileQueryMetadata[],
-    viewQueries?: CompileQueryMetadata[],
-    entryComponents?: CompileEntryComponentMetadata[],
-    template?: CompileTemplateMetadata,
-    wrapperType?: StaticSymbol|ProxyClass,
-    componentViewType?: StaticSymbol|ProxyClass,
-    componentFactory?: StaticSymbol|ComponentFactory<any>,
-  } = {}) {
+  constructor(
+      {isHost, type, isComponent, selector, exportAs, changeDetection, inputs, outputs,
+       hostListeners, hostProperties, hostAttributes, providers, viewProviders, queries,
+       viewQueries, entryComponents, template}: {
+        isHost?: boolean,
+        type?: CompileTypeMetadata,
+        isComponent?: boolean,
+        selector?: string,
+        exportAs?: string,
+        changeDetection?: ChangeDetectionStrategy,
+        inputs?: {[key: string]: string},
+        outputs?: {[key: string]: string},
+        hostListeners?: {[key: string]: string},
+        hostProperties?: {[key: string]: string},
+        hostAttributes?: {[key: string]: string},
+        providers?: CompileProviderMetadata[],
+        viewProviders?: CompileProviderMetadata[],
+        queries?: CompileQueryMetadata[],
+        viewQueries?: CompileQueryMetadata[],
+        entryComponents?: CompileIdentifierMetadata[],
+        template?: CompileTemplateMetadata,
+      } = {}) {
    this.isHost = !!isHost;
    this.type = type;
    this.isComponent = isComponent;
@ -458,11 +418,8 @@ export class CompileDirectiveMetadata {
    this.queries = _normalizeArray(queries);
    this.viewQueries = _normalizeArray(viewQueries);
    this.entryComponents = _normalizeArray(entryComponents);
-    this.template = template;

-    this.wrapperType = wrapperType;
-    this.componentViewType = componentViewType;
-    this.componentFactory = componentFactory;
+    this.template = template;
  }

  toSummary(): CompileDirectiveSummary {
@ -482,10 +439,7 @@ export class CompileDirectiveMetadata {
      queries: this.queries,
      entryComponents: this.entryComponents,
      changeDetection: this.changeDetection,
-      template: this.template && this.template.toSummary(),
-      wrapperType: this.wrapperType,
-      componentViewType: this.componentViewType,
-      componentFactory: this.componentFactory
+      template: this.template && this.template.toSummary()
    };
  }
 }
@ -494,12 +448,11 @@ export class CompileDirectiveMetadata {
 * Construct {@link CompileDirectiveMetadata} from {@link ComponentTypeMetadata} and a selector.
 */
 export function createHostComponentMeta(
-    hostTypeReference: any, compMeta: CompileDirectiveMetadata,
-    hostViewType: StaticSymbol | ProxyClass): CompileDirectiveMetadata {
+    typeReference: any, compMeta: CompileDirectiveMetadata): CompileDirectiveMetadata {
  const template = CssSelector.parse(compMeta.selector)[0].getMatchingElementTemplate();
  return CompileDirectiveMetadata.create({
    isHost: true,
-    type: {reference: hostTypeReference, diDeps: [], lifecycleHooks: []},
+    type: {reference: typeReference, diDeps: [], lifecycleHooks: []},
    template: new CompileTemplateMetadata({
      encapsulation: ViewEncapsulation.None,
      template: template,
@ -518,8 +471,7 @@ export function createHostComponentMeta(
    providers: [],
    viewProviders: [],
    queries: [],
-    viewQueries: [],
-    componentViewType: hostViewType
+    viewQueries: []
  });
 }

@ -565,7 +517,7 @@ export interface CompileNgModuleSummary extends CompileTypeSummary {
  exportedPipes: CompileIdentifierMetadata[];

  // Note: This is transitive.
-  entryComponents: CompileEntryComponentMetadata[];
+  entryComponents: CompileIdentifierMetadata[];
  // Note: This is transitive.
  providers: {provider: CompileProviderMetadata, module: CompileIdentifierMetadata}[];
  // Note: This is transitive.
@ -582,7 +534,7 @@ export class CompileNgModuleMetadata {
  declaredPipes: CompileIdentifierMetadata[];

  exportedPipes: CompileIdentifierMetadata[];
-  entryComponents: CompileEntryComponentMetadata[];
+  entryComponents: CompileIdentifierMetadata[];
  bootstrapComponents: CompileIdentifierMetadata[];
  providers: CompileProviderMetadata[];

@ -603,7 +555,7 @@ export class CompileNgModuleMetadata {
        exportedDirectives?: CompileIdentifierMetadata[],
        declaredPipes?: CompileIdentifierMetadata[],
        exportedPipes?: CompileIdentifierMetadata[],
-        entryComponents?: CompileEntryComponentMetadata[],
+        entryComponents?: CompileIdentifierMetadata[],
        bootstrapComponents?: CompileIdentifierMetadata[],
        importedModules?: CompileNgModuleSummary[],
        exportedModules?: CompileNgModuleSummary[],
@ -651,7 +603,7 @@ export class TransitiveCompileNgModuleMetadata {
  modulesSet = new Set<any>();
  modules: CompileTypeMetadata[] = [];
  entryComponentsSet = new Set<any>();
-  entryComponents: CompileEntryComponentMetadata[] = [];
+  entryComponents: CompileIdentifierMetadata[] = [];

  providers: {provider: CompileProviderMetadata, module: CompileIdentifierMetadata}[] = [];

@ -689,10 +641,10 @@ export class TransitiveCompileNgModuleMetadata {
      this.modules.push(id);
    }
  }
-  addEntryComponent(ec: CompileEntryComponentMetadata) {
-    if (!this.entryComponentsSet.has(ec.componentType)) {
-      this.entryComponentsSet.add(ec.componentType);
-      this.entryComponents.push(ec);
+  addEntryComponent(id: CompileIdentifierMetadata) {
+    if (!this.entryComponentsSet.has(id.reference)) {
+      this.entryComponentsSet.add(id.reference);
+      this.entryComponents.push(id);
    }
  }
 }
--- a/modules/@angular/compiler/src/compiler_util/binding_util.ts
+++ b/modules/@angular/compiler/src/compiler_util/binding_util.ts
@ -21,14 +21,28 @@ export function createCheckBindingField(builder: ClassBuilder): CheckBindingFiel
  const fieldExpr = createBindFieldExpr(bindingId);
  // private is fine here as no child view will reference the cached value...
  builder.fields.push(new o.ClassField(fieldExpr.name, null, [o.StmtModifier.Private]));
-  builder.ctorStmts.push(o.THIS_EXPR.prop(fieldExpr.name).set(o.literal(undefined)).toStmt());
+  builder.ctorStmts.push(o.THIS_EXPR.prop(fieldExpr.name)
+                             .set(o.importExpr(createIdentifier(Identifiers.UNINITIALIZED)))
+                             .toStmt());
  return new CheckBindingField(fieldExpr, bindingId);
 }

+export function createCheckBindingStmt(
+    evalResult: ConvertPropertyBindingResult, fieldExpr: o.ReadPropExpr,
+    throwOnChangeVar: o.Expression, actions: o.Statement[]): o.Statement[] {
+  let condition: o.Expression = o.importExpr(createIdentifier(Identifiers.checkBinding)).callFn([
+    throwOnChangeVar, fieldExpr, evalResult.currValExpr
+  ]);
+  if (evalResult.forceUpdate) {
+    condition = evalResult.forceUpdate.or(condition);
+  }
+  return [
+    ...evalResult.stmts, new o.IfStmt(condition, actions.concat([
+      <o.Statement>o.THIS_EXPR.prop(fieldExpr.name).set(evalResult.currValExpr).toStmt()
+    ]))
+  ];
+}
+
 function createBindFieldExpr(bindingId: string): o.ReadPropExpr {
  return o.THIS_EXPR.prop(`_expr_${bindingId}`);
 }
-
-export function isFirstViewCheck(view: o.Expression): o.Expression {
-  return o.not(view.prop('numberOfChecks'));
-}
--- a/modules/@angular/compiler/src/compiler_util/render_util.ts
+++ b/modules/@angular/compiler/src/compiler_util/render_util.ts
@ -13,64 +13,69 @@ import * as o from '../output/output_ast';
 import {EMPTY_STATE as EMPTY_ANIMATION_STATE} from '../private_import_core';
 import {BoundElementPropertyAst, BoundEventAst, PropertyBindingType} from '../template_parser/template_ast';

-import {isFirstViewCheck} from './binding_util';
-import {ConvertPropertyBindingResult} from './expression_converter';
 import {createEnumExpression} from './identifier_util';

-export function createCheckRenderBindingStmt(
-    view: o.Expression, renderElement: o.Expression, boundProp: BoundElementPropertyAst,
-    oldValue: o.ReadPropExpr, evalResult: ConvertPropertyBindingResult,
+export function writeToRenderer(
+    view: o.Expression, boundProp: BoundElementPropertyAst, renderElement: o.Expression,
+    renderValue: o.Expression, logBindingUpdate: boolean,
    securityContextExpression?: o.Expression): o.Statement[] {
-  const checkStmts: o.Statement[] = [...evalResult.stmts];
-  const securityContext = calcSecurityContext(boundProp, securityContextExpression);
+  const updateStmts: o.Statement[] = [];
+  const renderer = view.prop('renderer');
+  renderValue = sanitizedValue(view, boundProp, renderValue, securityContextExpression);
  switch (boundProp.type) {
    case PropertyBindingType.Property:
-      checkStmts.push(o.importExpr(createIdentifier(Identifiers.checkRenderProperty))
-                          .callFn([
-                            view, renderElement, o.literal(boundProp.name), oldValue,
-                            oldValue.set(evalResult.currValExpr),
-                            evalResult.forceUpdate || o.literal(false), securityContext
-                          ])
-                          .toStmt());
+      if (logBindingUpdate) {
+        updateStmts.push(
+            o.importExpr(createIdentifier(Identifiers.setBindingDebugInfo))
+                .callFn([renderer, renderElement, o.literal(boundProp.name), renderValue])
+                .toStmt());
+      }
+      updateStmts.push(
+          renderer
+              .callMethod(
+                  'setElementProperty', [renderElement, o.literal(boundProp.name), renderValue])
+              .toStmt());
      break;
    case PropertyBindingType.Attribute:
-      checkStmts.push(o.importExpr(createIdentifier(Identifiers.checkRenderAttribute))
-                          .callFn([
-                            view, renderElement, o.literal(boundProp.name), oldValue,
-                            oldValue.set(evalResult.currValExpr),
-                            evalResult.forceUpdate || o.literal(false), securityContext
-                          ])
-                          .toStmt());
+      renderValue =
+          renderValue.isBlank().conditional(o.NULL_EXPR, renderValue.callMethod('toString', []));
+      updateStmts.push(
+          renderer
+              .callMethod(
+                  'setElementAttribute', [renderElement, o.literal(boundProp.name), renderValue])
+              .toStmt());
      break;
    case PropertyBindingType.Class:
-      checkStmts.push(
-          o.importExpr(createIdentifier(Identifiers.checkRenderClass))
-              .callFn([
-                view, renderElement, o.literal(boundProp.name), oldValue,
-                oldValue.set(evalResult.currValExpr), evalResult.forceUpdate || o.literal(false)
-              ])
+      updateStmts.push(
+          renderer
+              .callMethod(
+                  'setElementClass', [renderElement, o.literal(boundProp.name), renderValue])
              .toStmt());
      break;
    case PropertyBindingType.Style:
-      checkStmts.push(
-          o.importExpr(createIdentifier(Identifiers.checkRenderStyle))
-              .callFn([
-                view, renderElement, o.literal(boundProp.name), o.literal(boundProp.unit), oldValue,
-                oldValue.set(evalResult.currValExpr), evalResult.forceUpdate || o.literal(false),
-                securityContext
-              ])
+      let strValue: o.Expression = renderValue.callMethod('toString', []);
+      if (isPresent(boundProp.unit)) {
+        strValue = strValue.plus(o.literal(boundProp.unit));
+      }
+
+      renderValue = renderValue.isBlank().conditional(o.NULL_EXPR, strValue);
+      updateStmts.push(
+          renderer
+              .callMethod(
+                  'setElementStyle', [renderElement, o.literal(boundProp.name), renderValue])
              .toStmt());
      break;
    case PropertyBindingType.Animation:
      throw new Error('Illegal state: Should not come here!');
  }
-  return checkStmts;
+  return updateStmts;
 }

-function calcSecurityContext(
-    boundProp: BoundElementPropertyAst, securityContextExpression?: o.Expression): o.Expression {
+function sanitizedValue(
+    view: o.Expression, boundProp: BoundElementPropertyAst, renderValue: o.Expression,
+    securityContextExpression?: o.Expression): o.Expression {
  if (boundProp.securityContext === SecurityContext.NONE) {
-    return o.NULL_EXPR;  // No sanitization needed.
+    return renderValue;  // No sanitization needed.
  }
  if (!boundProp.needsRuntimeSecurityContext) {
    securityContextExpression =
@ -79,13 +84,15 @@ function calcSecurityContext(
  if (!securityContextExpression) {
    throw new Error(`internal error, no SecurityContext given ${boundProp.name}`);
  }
-  return securityContextExpression;
+  const ctx = view.prop('viewUtils').prop('sanitizer');
+  const args = [securityContextExpression, renderValue];
+  return ctx.callMethod('sanitize', args);
 }

-export function createCheckAnimationBindingStmts(
+export function triggerAnimation(
    view: o.Expression, componentView: o.Expression, boundProp: BoundElementPropertyAst,
    boundOutputs: BoundEventAst[], eventListener: o.Expression, renderElement: o.Expression,
-    oldValue: o.ReadPropExpr, evalResult: ConvertPropertyBindingResult) {
+    renderValue: o.Expression, lastRenderValue: o.Expression) {
  const detachStmts: o.Statement[] = [];
  const updateStmts: o.Statement[] = [];

@ -97,21 +104,22 @@ export function createCheckAnimationBindingStmts(
  // it's important to normalize the void value as `void` explicitly
  // so that the styles data can be obtained from the stringmap
  const emptyStateValue = o.literal(EMPTY_ANIMATION_STATE);
+  const unitializedValue = o.importExpr(createIdentifier(Identifiers.UNINITIALIZED));
  const animationTransitionVar = o.variable('animationTransition_' + animationName);

  updateStmts.push(
      animationTransitionVar
          .set(animationFnExpr.callFn([
-            view, renderElement, isFirstViewCheck(view).conditional(emptyStateValue, oldValue),
-            evalResult.currValExpr
+            view, renderElement,
+            lastRenderValue.equals(unitializedValue).conditional(emptyStateValue, lastRenderValue),
+            renderValue.equals(unitializedValue).conditional(emptyStateValue, renderValue)
          ]))
          .toDeclStmt());
-  updateStmts.push(oldValue.set(evalResult.currValExpr).toStmt());

-  detachStmts.push(animationTransitionVar
-                       .set(animationFnExpr.callFn(
-                           [view, renderElement, evalResult.currValExpr, emptyStateValue]))
-                       .toDeclStmt());
+  detachStmts.push(
+      animationTransitionVar
+          .set(animationFnExpr.callFn([view, renderElement, lastRenderValue, emptyStateValue]))
+          .toDeclStmt());

  const registerStmts: o.Statement[] = [];
  const animationStartMethodExists = boundOutputs.find(
@ -143,14 +151,5 @@ export function createCheckAnimationBindingStmts(
  updateStmts.push(...registerStmts);
  detachStmts.push(...registerStmts);

-  const checkUpdateStmts: o.Statement[] = [
-    ...evalResult.stmts,
-    new o.IfStmt(
-        o.importExpr(createIdentifier(Identifiers.checkBinding)).callFn([
-          view, oldValue, evalResult.currValExpr, evalResult.forceUpdate || o.literal(false)
-        ]),
-        updateStmts)
-  ];
-  const checkDetachStmts: o.Statement[] = [...evalResult.stmts, ...detachStmts];
-  return {checkUpdateStmts, checkDetachStmts};
+  return {updateStmts, detachStmts};
 }
--- a/modules/@angular/compiler/src/directive_normalizer.ts
+++ b/modules/@angular/compiler/src/directive_normalizer.ts
@ -6,12 +6,11 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {ViewEncapsulation} from '@angular/core';
+import {Component, Injectable, ViewEncapsulation} from '@angular/core';

 import {CompileAnimationEntryMetadata, CompileDirectiveMetadata, CompileStylesheetMetadata, CompileTemplateMetadata, CompileTypeMetadata} from './compile_metadata';
 import {CompilerConfig} from './config';
-import {stringify} from './facade/lang';
-import {CompilerInjectable} from './injectable';
+import {isBlank, isPresent, stringify} from './facade/lang';
 import * as html from './ml_parser/ast';
 import {HtmlParser} from './ml_parser/html_parser';
 import {InterpolationConfig} from './ml_parser/interpolation_config';
@ -19,7 +18,7 @@ import {ResourceLoader} from './resource_loader';
 import {extractStyleUrls, isStyleUrlResolvable} from './style_url_resolver';
 import {PreparsedElementType, preparseElement} from './template_parser/template_preparser';
 import {UrlResolver} from './url_resolver';
-import {SyncAsyncResult, SyntaxError} from './util';
+import {SyncAsyncResult} from './util';

 export interface PrenormalizedTemplateMetadata {
  componentType: any;
@ -33,7 +32,7 @@ export interface PrenormalizedTemplateMetadata {
  animations?: CompileAnimationEntryMetadata[];
 }

-@CompilerInjectable()
+@Injectable()
 export class DirectiveNormalizer {
  private _resourceLoaderCache = new Map<string, Promise<string>>();

@ -41,9 +40,9 @@ export class DirectiveNormalizer {
      private _resourceLoader: ResourceLoader, private _urlResolver: UrlResolver,
      private _htmlParser: HtmlParser, private _config: CompilerConfig) {}

-  clearCache(): void { this._resourceLoaderCache.clear(); }
+  clearCache() { this._resourceLoaderCache.clear(); }

-  clearCacheFor(normalizedDirective: CompileDirectiveMetadata): void {
+  clearCacheFor(normalizedDirective: CompileDirectiveMetadata) {
    if (!normalizedDirective.isComponent) {
      return;
    }
@ -65,21 +64,13 @@ export class DirectiveNormalizer {
      SyncAsyncResult<CompileTemplateMetadata> {
    let normalizedTemplateSync: CompileTemplateMetadata = null;
    let normalizedTemplateAsync: Promise<CompileTemplateMetadata>;
-    if (prenormData.template != null) {
-      if (typeof prenormData.template !== 'string') {
-        throw new SyntaxError(
-            `The template specified for component ${stringify(prenormData.componentType)} is not a string`);
-      }
+    if (isPresent(prenormData.template)) {
      normalizedTemplateSync = this.normalizeTemplateSync(prenormData);
      normalizedTemplateAsync = Promise.resolve(normalizedTemplateSync);
    } else if (prenormData.templateUrl) {
-      if (typeof prenormData.templateUrl !== 'string') {
-        throw new SyntaxError(
-            `The templateUrl specified for component ${stringify(prenormData.componentType)} is not a string`);
-      }
      normalizedTemplateAsync = this.normalizeTemplateAsync(prenormData);
    } else {
-      throw new SyntaxError(
+      throw new Error(
          `No template specified for component ${stringify(prenormData.componentType)}`);
    }

@ -110,12 +101,11 @@ export class DirectiveNormalizer {
      templateAbsUrl: string): CompileTemplateMetadata {
    const interpolationConfig = InterpolationConfig.fromArray(prenomData.interpolation);
    const rootNodesAndErrors = this._htmlParser.parse(
-        template, stringify(prenomData.componentType), true, interpolationConfig);
+        template, stringify(prenomData.componentType), false, interpolationConfig);
    if (rootNodesAndErrors.errors.length > 0) {
      const errorString = rootNodesAndErrors.errors.join('\n');
-      throw new SyntaxError(`Template parse errors:\n${errorString}`);
+      throw new Error(`Template parse errors:\n${errorString}`);
    }
-
    const templateMetadataStyles = this.normalizeStylesheet(new CompileStylesheetMetadata({
      styles: prenomData.styles,
      styleUrls: prenomData.styleUrls,
@ -128,7 +118,7 @@ export class DirectiveNormalizer {
        {styles: visitor.styles, styleUrls: visitor.styleUrls, moduleUrl: templateAbsUrl}));

    let encapsulation = prenomData.encapsulation;
-    if (encapsulation == null) {
+    if (isBlank(encapsulation)) {
      encapsulation = this._config.defaultEncapsulation;
    }

@ -237,13 +227,9 @@ class TemplatePreparseVisitor implements html.Visitor {
    return null;
  }

-  visitExpansion(ast: html.Expansion, context: any): any { html.visitAll(this, ast.cases); }
-
-  visitExpansionCase(ast: html.ExpansionCase, context: any): any {
-    html.visitAll(this, ast.expression);
-  }
-
  visitComment(ast: html.Comment, context: any): any { return null; }
  visitAttribute(ast: html.Attribute, context: any): any { return null; }
  visitText(ast: html.Text, context: any): any { return null; }
+  visitExpansion(ast: html.Expansion, context: any): any { return null; }
+  visitExpansionCase(ast: html.ExpansionCase, context: any): any { return null; }
 }
--- a/modules/@angular/compiler/src/directive_resolver.ts
+++ b/modules/@angular/compiler/src/directive_resolver.ts
@ -6,16 +6,14 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {Component, Directive, HostBinding, HostListener, Input, Output, Query, Type, resolveForwardRef} from '@angular/core';
+import {Component, Directive, HostBinding, HostListener, Injectable, Input, Output, Query, Type, resolveForwardRef} from '@angular/core';

 import {ListWrapper, StringMapWrapper} from './facade/collection';
 import {stringify} from './facade/lang';
-import {CompilerInjectable} from './injectable';
 import {ReflectorReader, reflector} from './private_import_core';
 import {splitAtColon} from './util';


-
 /*
 * Resolve a `Type` for {@link Directive}.
 *
@ -23,7 +21,7 @@ import {splitAtColon} from './util';
 *
 * See {@link Compiler}
 */
-@CompilerInjectable()
+@Injectable()
 export class DirectiveResolver {
  constructor(private _reflector: ReflectorReader = reflector) {}

--- a/modules/@angular/compiler/src/directive_wrapper_compiler.ts
+++ b/modules/@angular/compiler/src/directive_wrapper_compiler.ts
@ -6,19 +6,20 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {CompileDirectiveMetadata, CompileDirectiveSummary, CompileIdentifierMetadata, dirWrapperClassName, identifierModuleUrl, identifierName} from './compile_metadata';
-import {createCheckBindingField, isFirstViewCheck} from './compiler_util/binding_util';
+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';
-import {createCheckAnimationBindingStmts, createCheckRenderBindingStmt} from './compiler_util/render_util';
+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} from './private_import_core';
+import {Console, LifecycleHooks, isDefaultChangeDetectionStrategy} 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';
@ -32,8 +33,8 @@ const CHANGES_FIELD_NAME = '_changes';
 const CHANGED_FIELD_NAME = '_changed';
 const EVENT_HANDLER_FIELD_NAME = '_eventHandler';

-const CHANGE_VAR = o.variable('change');
 const CURR_VALUE_VAR = o.variable('currValue');
+const THROW_ON_CHANGE_VAR = o.variable('throwOnChange');
 const FORCE_UPDATE_VAR = o.variable('forceUpdate');
 const VIEW_VAR = o.variable('view');
 const COMPONENT_VIEW_VAR = o.variable('componentView');
@ -50,8 +51,12 @@ const RESET_CHANGES_STMT = o.THIS_EXPR.prop(CHANGES_FIELD_NAME).set(o.literalMap
 *
 * So far, only `@Input` and the lifecycle hooks have been implemented.
 */
-@CompilerInjectable()
+@Injectable()
 export class DirectiveWrapperCompiler {
+  static dirWrapperClassName(id: CompileIdentifierMetadata) {
+    return `Wrapper_${identifierName(id)}`;
+  }
+
  constructor(
      private compilerConfig: CompilerConfig, private _exprParser: Parser,
      private _schemaRegistry: ElementSchemaRegistry, private _console: Console) {}
@ -130,9 +135,8 @@ class DirectiveWrapperBuilder implements ClassBuilder {
      new o.ClassField(CONTEXT_FIELD_NAME, o.importType(this.dirMeta.type)),
      new o.ClassField(CHANGED_FIELD_NAME, o.BOOL_TYPE, [o.StmtModifier.Private]),
    ];
-    const ctorStmts: o.Statement[] = [
-      o.THIS_EXPR.prop(CHANGED_FIELD_NAME).set(o.literal(false)).toStmt(),
-    ];
+    const ctorStmts: o.Statement[] =
+        [o.THIS_EXPR.prop(CHANGED_FIELD_NAME).set(o.literal(false)).toStmt()];
    if (this.genChanges) {
      fields.push(new o.ClassField(
          CHANGES_FIELD_NAME, new o.MapType(o.DYNAMIC_TYPE), [o.StmtModifier.Private]));
@ -146,7 +150,7 @@ class DirectiveWrapperBuilder implements ClassBuilder {
            .toStmt());

    return createClassStmt({
-      name: dirWrapperClassName(this.dirMeta.type.reference),
+      name: DirectiveWrapperCompiler.dirWrapperClassName(this.dirMeta.type),
      ctorParams: dirDepParamNames.map((paramName) => new o.FnParam(paramName, o.DYNAMIC_TYPE)),
      builders: [{fields, ctorStmts, methods}, this]
    });
@ -181,14 +185,14 @@ function addNgDoCheckMethod(builder: DirectiveWrapperBuilder) {

  if (builder.ngOnInit) {
    lifecycleStmts.push(new o.IfStmt(
-        isFirstViewCheck(VIEW_VAR),
+        VIEW_VAR.prop('numberOfChecks').identical(new o.LiteralExpr(0)),
        [o.THIS_EXPR.prop(CONTEXT_FIELD_NAME).callMethod('ngOnInit', []).toStmt()]));
  }
  if (builder.ngDoCheck) {
    lifecycleStmts.push(o.THIS_EXPR.prop(CONTEXT_FIELD_NAME).callMethod('ngDoCheck', []).toStmt());
  }
  if (lifecycleStmts.length > 0) {
-    stmts.push(new o.IfStmt(o.not(VIEW_VAR.prop('throwOnChange')), lifecycleStmts));
+    stmts.push(new o.IfStmt(o.not(THROW_ON_CHANGE_VAR), lifecycleStmts));
  }
  stmts.push(new o.ReturnStatement(changedVar));

@ -198,6 +202,7 @@ function addNgDoCheckMethod(builder: DirectiveWrapperBuilder) {
        new o.FnParam(
            VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
        new o.FnParam(RENDER_EL_VAR.name, o.DYNAMIC_TYPE),
+        new o.FnParam(THROW_ON_CHANGE_VAR.name, o.BOOL_TYPE),
      ],
      stmts, o.BOOL_TYPE));
 }
@ -207,35 +212,24 @@ function addCheckInputMethod(input: string, builder: DirectiveWrapperBuilder) {
  const onChangeStatements: o.Statement[] = [
    o.THIS_EXPR.prop(CHANGED_FIELD_NAME).set(o.literal(true)).toStmt(),
    o.THIS_EXPR.prop(CONTEXT_FIELD_NAME).prop(input).set(CURR_VALUE_VAR).toStmt(),
-    field.expression.set(CURR_VALUE_VAR).toStmt()
  ];
-  let methodBody: o.Statement[];
  if (builder.genChanges) {
-    onChangeStatements.push(
-        o.THIS_EXPR.prop(CHANGES_FIELD_NAME).key(o.literal(input)).set(CHANGE_VAR).toStmt());
-    methodBody = [
-      CHANGE_VAR
-          .set(o.importExpr(createIdentifier(Identifiers.checkBindingChange)).callFn([
-            VIEW_VAR, field.expression, CURR_VALUE_VAR, FORCE_UPDATE_VAR
-          ]))
-          .toDeclStmt(),
-      new o.IfStmt(CHANGE_VAR, onChangeStatements)
-    ];
-  } else {
-    methodBody = [new o.IfStmt(
-        o.importExpr(createIdentifier(Identifiers.checkBinding)).callFn([
-          VIEW_VAR, field.expression, CURR_VALUE_VAR, FORCE_UPDATE_VAR
-        ]),
-        onChangeStatements)];
+    onChangeStatements.push(o.THIS_EXPR.prop(CHANGES_FIELD_NAME)
+                                .key(o.literal(input))
+                                .set(o.importExpr(createIdentifier(Identifiers.SimpleChange))
+                                         .instantiate([field.expression, CURR_VALUE_VAR]))
+                                .toStmt());
  }

+  const methodBody: o.Statement[] = createCheckBindingStmt(
+      {currValExpr: CURR_VALUE_VAR, forceUpdate: FORCE_UPDATE_VAR, stmts: []}, field.expression,
+      THROW_ON_CHANGE_VAR, onChangeStatements);
  builder.methods.push(new o.ClassMethod(
      `check_${input}`,
      [
-        new o.FnParam(
-            VIEW_VAR.name, o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
        new o.FnParam(CURR_VALUE_VAR.name, o.DYNAMIC_TYPE),
-        new o.FnParam(FORCE_UPDATE_VAR.name, o.BOOL_TYPE)
+        new o.FnParam(THROW_ON_CHANGE_VAR.name, o.BOOL_TYPE),
+        new o.FnParam(FORCE_UPDATE_VAR.name, o.BOOL_TYPE),
      ],
      methodBody));
 }
@ -251,6 +245,7 @@ function addCheckHostMethod(
        COMPONENT_VIEW_VAR.name,
        o.importType(createIdentifier(Identifiers.AppView), [o.DYNAMIC_TYPE])),
    new o.FnParam(RENDER_EL_VAR.name, o.DYNAMIC_TYPE),
+    new o.FnParam(THROW_ON_CHANGE_VAR.name, o.BOOL_TYPE),
  ];
  hostProps.forEach((hostProp, hostPropIdx) => {
    const field = createCheckBindingField(builder);
@ -265,18 +260,23 @@ function addCheckHostMethod(
      methodParams.push(new o.FnParam(
          securityContextExpr.name, o.importType(createIdentifier(Identifiers.SecurityContext))));
    }
+    let checkBindingStmts: o.Statement[];
    if (hostProp.isAnimation) {
-      const {checkUpdateStmts, checkDetachStmts} = createCheckAnimationBindingStmts(
+      const {updateStmts, detachStmts} = triggerAnimation(
          VIEW_VAR, COMPONENT_VIEW_VAR, hostProp, hostEvents,
          o.THIS_EXPR.prop(EVENT_HANDLER_FIELD_NAME)
              .or(o.importExpr(createIdentifier(Identifiers.noop))),
-          RENDER_EL_VAR, field.expression, evalResult);
-      builder.detachStmts.push(...checkDetachStmts);
-      stmts.push(...checkUpdateStmts);
+          RENDER_EL_VAR, evalResult.currValExpr, field.expression);
+      checkBindingStmts = updateStmts;
+      builder.detachStmts.push(...detachStmts);
    } else {
-      stmts.push(...createCheckRenderBindingStmt(
-          VIEW_VAR, RENDER_EL_VAR, hostProp, field.expression, evalResult, securityContextExpr));
+      checkBindingStmts = writeToRenderer(
+          VIEW_VAR, hostProp, RENDER_EL_VAR, evalResult.currValExpr,
+          builder.compilerConfig.logBindingUpdate, securityContextExpr);
    }
+
+    stmts.push(...createCheckBindingStmt(
+        evalResult, field.expression, THROW_ON_CHANGE_VAR, checkBindingStmts));
  });
  builder.methods.push(new o.ClassMethod('checkHost', methodParams, stmts));
 }
@ -386,19 +386,20 @@ export class DirectiveWrapperExpressions {
    return dirWrapper.prop(CONTEXT_FIELD_NAME);
  }

-  static ngDoCheck(dirWrapper: o.Expression, view: o.Expression, renderElement: o.Expression, ):
-      o.Expression {
-    return dirWrapper.callMethod('ngDoCheck', [view, renderElement]);
+  static ngDoCheck(
+      dirWrapper: o.Expression, view: o.Expression, renderElement: o.Expression,
+      throwOnChange: o.Expression): o.Expression {
+    return dirWrapper.callMethod('ngDoCheck', [view, renderElement, throwOnChange]);
  }
  static checkHost(
      hostProps: BoundElementPropertyAst[], dirWrapper: o.Expression, view: o.Expression,
-      componentView: o.Expression, renderElement: o.Expression,
+      componentView: o.Expression, renderElement: o.Expression, throwOnChange: o.Expression,
      runtimeSecurityContexts: o.Expression[]): o.Statement[] {
    if (hostProps.length) {
      return [dirWrapper
                  .callMethod(
-                      'checkHost',
-                      [view, componentView, renderElement].concat(runtimeSecurityContexts))
+                      'checkHost', [view, componentView, renderElement, throwOnChange].concat(
+                                       runtimeSecurityContexts))
                  .toStmt()];
    } else {
      return [];
--- a/modules/@angular/compiler/src/expression_parser/lexer.ts
+++ b/modules/@angular/compiler/src/expression_parser/lexer.ts
@ -6,9 +6,9 @@
 * found in the LICENSE file at https://angular.io/license
 */

+import {Injectable} from '@angular/core';
 import * as chars from '../chars';
 import {NumberWrapper, isPresent} from '../facade/lang';
-import {CompilerInjectable} from '../injectable';

 export enum TokenType {
  Character,
@ -22,7 +22,7 @@ export enum TokenType {

 const KEYWORDS = ['var', 'let', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this'];

-@CompilerInjectable()
+@Injectable()
 export class Lexer {
  tokenize(text: string): Token[] {
    const scanner = new _Scanner(text);
@ -120,7 +120,7 @@ function newErrorToken(index: number, message: string): Token {
  return new Token(index, TokenType.Error, 0, message);
 }

-export const EOF: Token = new Token(-1, TokenType.Character, 0, '');
+export var EOF: Token = new Token(-1, TokenType.Character, 0, '');

 class _Scanner {
  length: number;
--- a/modules/@angular/compiler/src/expression_parser/parser.ts
+++ b/modules/@angular/compiler/src/expression_parser/parser.ts
@ -6,9 +6,10 @@
 * found in the LICENSE file at https://angular.io/license
 */

+import {Injectable} from '@angular/core';
+
 import * as chars from '../chars';
 import {escapeRegExp, isBlank, isPresent} from '../facade/lang';
-import {CompilerInjectable} from '../injectable';
 import {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from '../ml_parser/interpolation_config';

 import {AST, ASTWithSource, AstVisitor, Binary, BindingPipe, Chain, Conditional, EmptyExpr, FunctionCall, ImplicitReceiver, Interpolation, KeyedRead, KeyedWrite, LiteralArray, LiteralMap, LiteralPrimitive, MethodCall, ParseSpan, ParserError, PrefixNot, PropertyRead, PropertyWrite, Quote, SafeMethodCall, SafePropertyRead, TemplateBinding} from './ast';
@ -30,7 +31,7 @@ function _createInterpolateRegExp(config: InterpolationConfig): RegExp {
  return new RegExp(pattern, 'g');
 }

-@CompilerInjectable()
+@Injectable()
 export class Parser {
  private errors: ParserError[] = [];

--- a/modules/@angular/compiler/src/i18n/digest.ts
+++ b/modules/@angular/compiler/src/i18n/digest.ts
@ -9,13 +9,13 @@
 import * as i18n from './i18n_ast';

 export function digest(message: i18n.Message): string {
-  return message.id || sha1(serializeNodes(message.nodes).join('') + `[${message.meaning}]`);
+  return sha1(serializeNodes(message.nodes).join('') + `[${message.meaning}]`);
 }

 export function decimalDigest(message: i18n.Message): string {
  const visitor = new _SerializerIgnoreIcuExpVisitor();
  const parts = message.nodes.map(a => a.visit(visitor, null));
-  return message.id || computeMsgId(parts.join(''), message.meaning);
+  return computeMsgId(parts.join(''), message.meaning);
 }

 /**
--- a/modules/@angular/compiler/src/i18n/extractor.ts
+++ b/modules/@angular/compiler/src/i18n/extractor.ts
@ -14,9 +14,7 @@ import {ViewEncapsulation} from '@angular/core';

 import {analyzeAndValidateNgModules, extractProgramSymbols} from '../aot/compiler';
 import {StaticAndDynamicReflectionCapabilities} from '../aot/static_reflection_capabilities';
-import {StaticReflector} from '../aot/static_reflector';
-import {StaticSymbolCache} from '../aot/static_symbol';
-import {StaticSymbolResolver, StaticSymbolResolverHost} from '../aot/static_symbol_resolver';
+import {StaticReflector, StaticReflectorHost} from '../aot/static_reflector';
 import {AotSummaryResolver, AotSummaryResolverHost} from '../aot/summary_resolver';
 import {CompileDirectiveMetadata} from '../compile_metadata';
 import {CompilerConfig} from '../config';
@ -28,17 +26,23 @@ import {InterpolationConfig} from '../ml_parser/interpolation_config';
 import {NgModuleResolver} from '../ng_module_resolver';
 import {ParseError} from '../parse_util';
 import {PipeResolver} from '../pipe_resolver';
+import {Console} from '../private_import_core';
 import {DomElementSchemaRegistry} from '../schema/dom_element_schema_registry';
 import {createOfflineCompileUrlResolver} from '../url_resolver';

 import {I18NHtmlParser} from './i18n_html_parser';
 import {MessageBundle} from './message_bundle';

+export interface ExtractorOptions {
+  includeFilePattern?: RegExp;
+  excludeFilePattern?: RegExp;
+}
+
 /**
 * The host of the Extractor disconnects the implementation from TypeScript / other language
 * services and from underlying file systems.
 */
-export interface ExtractorHost extends StaticSymbolResolverHost, AotSummaryResolverHost {
+export interface ExtractorHost extends StaticReflectorHost, AotSummaryResolverHost {
  /**
   * Loads a resource (e.g. html / css)
   */
@ -47,13 +51,14 @@ export interface ExtractorHost extends StaticSymbolResolverHost, AotSummaryResol

 export class Extractor {
  constructor(
-      public host: ExtractorHost, private staticSymbolResolver: StaticSymbolResolver,
-      private messageBundle: MessageBundle, private metadataResolver: CompileMetadataResolver) {}
+      private options: ExtractorOptions, public host: ExtractorHost,
+      private staticReflector: StaticReflector, private messageBundle: MessageBundle,
+      private metadataResolver: CompileMetadataResolver) {}

  extract(rootFiles: string[]): Promise<MessageBundle> {
-    const programSymbols = extractProgramSymbols(this.staticSymbolResolver, rootFiles, this.host);
+    const programSymbols = extractProgramSymbols(this.staticReflector, rootFiles, this.options);
    const {ngModuleByPipeOrDirective, files, ngModules} =
-        analyzeAndValidateNgModules(programSymbols, this.host, this.metadataResolver);
+        analyzeAndValidateNgModules(programSymbols, this.options, this.metadataResolver);
    return Promise
        .all(ngModules.map(
            ngModule => this.metadataResolver.loadNgModuleDirectiveAndPipeMetadata(
@ -86,14 +91,12 @@ export class Extractor {
        });
  }

-  static create(host: ExtractorHost): {extractor: Extractor, staticReflector: StaticReflector} {
+  static create(host: ExtractorHost, options: ExtractorOptions):
+      {extractor: Extractor, staticReflector: StaticReflector} {
    const htmlParser = new I18NHtmlParser(new HtmlParser());

    const urlResolver = createOfflineCompileUrlResolver();
-    const symbolCache = new StaticSymbolCache();
-    const summaryResolver = new AotSummaryResolver(host, symbolCache);
-    const staticSymbolResolver = new StaticSymbolResolver(host, symbolCache, summaryResolver);
-    const staticReflector = new StaticReflector(staticSymbolResolver);
+    const staticReflector = new StaticReflector(host);
    StaticAndDynamicReflectionCapabilities.install(staticReflector);

    const config = new CompilerConfig({
@ -108,13 +111,13 @@ export class Extractor {
    const elementSchemaRegistry = new DomElementSchemaRegistry();
    const resolver = new CompileMetadataResolver(
        new NgModuleResolver(staticReflector), new DirectiveResolver(staticReflector),
-        new PipeResolver(staticReflector), summaryResolver, elementSchemaRegistry, normalizer,
-        symbolCache, staticReflector);
+        new PipeResolver(staticReflector), new AotSummaryResolver(host, staticReflector, options),
+        elementSchemaRegistry, normalizer, staticReflector);

    // TODO(vicb): implicit tags & attributes
    const messageBundle = new MessageBundle(htmlParser, [], {});

-    const extractor = new Extractor(host, staticSymbolResolver, messageBundle, resolver);
+    const extractor = new Extractor(options, host, staticReflector, messageBundle, resolver);
    return {extractor, staticReflector};
  }
 }
--- a/modules/@angular/compiler/src/i18n/extractor_merger.ts
+++ b/modules/@angular/compiler/src/i18n/extractor_merger.ts
@ -18,8 +18,6 @@ import {TranslationBundle} from './translation_bundle';
 const _I18N_ATTR = 'i18n';
 const _I18N_ATTR_PREFIX = 'i18n-';
 const _I18N_COMMENT_PREFIX_REGEXP = /^i18n:?/;
-const MEANING_SEPARATOR = '|';
-const ID_SEPARATOR = '@@';

 /**
 * Extract translatable messages from an html AST
@ -79,7 +77,7 @@ class _Visitor implements html.Visitor {
  // _VisitorMode.Merge only
  private _translations: TranslationBundle;
  private _createI18nMessage:
-      (msg: html.Node[], meaning: string, description: string, id: string) => i18n.Message;
+      (msg: html.Node[], meaning: string, description: string) => i18n.Message;


  constructor(private _implicitTags: string[], private _implicitAttrs: {[k: string]: string[]}) {}
@ -332,15 +330,15 @@ class _Visitor implements html.Visitor {
  }

  // add a translatable message
-  private _addMessage(ast: html.Node[], msgMeta?: string): i18n.Message {
+  private _addMessage(ast: html.Node[], meaningAndDesc?: string): i18n.Message {
    if (ast.length == 0 ||
        ast.length == 1 && ast[0] instanceof html.Attribute && !(<html.Attribute>ast[0]).value) {
      // Do not create empty messages
      return;
    }

-    const {meaning, description, id} = _parseMessageMeta(msgMeta);
-    const message = this._createI18nMessage(ast, meaning, description, id);
+    const [meaning, description] = _splitMeaningAndDesc(meaningAndDesc);
+    const message = this._createI18nMessage(ast, meaning, description);
    this._messages.push(message);
    return message;
  }
@ -370,7 +368,7 @@ class _Visitor implements html.Visitor {
    attributes.forEach(attr => {
      if (attr.name.startsWith(_I18N_ATTR_PREFIX)) {
        i18nAttributeMeanings[attr.name.slice(_I18N_ATTR_PREFIX.length)] =
-            _parseMessageMeta(attr.value).meaning;
+            _splitMeaningAndDesc(attr.value)[0];
      }
    });

@ -384,7 +382,7 @@ class _Visitor implements html.Visitor {

      if (attr.value && attr.value != '' && i18nAttributeMeanings.hasOwnProperty(attr.name)) {
        const meaning = i18nAttributeMeanings[attr.name];
-        const message: i18n.Message = this._createI18nMessage([attr], meaning, '', '');
+        const message: i18n.Message = this._createI18nMessage([attr], meaning, '');
        const nodes = this._translations.get(message);
        if (nodes) {
          if (nodes[0] instanceof html.Text) {
@ -422,7 +420,7 @@ class _Visitor implements html.Visitor {
  }

  /**
-   * Marks the start of a section, see `_closeTranslatableSection`
+   * Marks the start of a section, see `_endSection`
   */
  private _openTranslatableSection(node: html.Node): void {
    if (this._isInTranslatableSection) {
@ -498,16 +496,8 @@ function _getI18nAttr(p: html.Element): html.Attribute {
  return p.attrs.find(attr => attr.name === _I18N_ATTR) || null;
 }

-function _parseMessageMeta(i18n: string): {meaning: string, description: string, id: string} {
-  if (!i18n) return {meaning: '', description: '', id: ''};
-
-  const idIndex = i18n.indexOf(ID_SEPARATOR);
-  const descIndex = i18n.indexOf(MEANING_SEPARATOR);
-  const [meaningAndDesc, id] =
-      (idIndex > -1) ? [i18n.slice(0, idIndex), i18n.slice(idIndex + 2)] : [i18n, ''];
-  const [meaning, description] = (descIndex > -1) ?
-      [meaningAndDesc.slice(0, descIndex), meaningAndDesc.slice(descIndex + 1)] :
-      ['', meaningAndDesc];
-
-  return {meaning, description, id};
+function _splitMeaningAndDesc(i18n: string): [string, string] {
+  if (!i18n) return ['', ''];
+  const pipeIndex = i18n.indexOf('|');
+  return pipeIndex == -1 ? ['', i18n] : [i18n.slice(0, pipeIndex), i18n.slice(pipeIndex + 1)];
 }
--- a/modules/@angular/compiler/src/i18n/i18n_ast.ts
+++ b/modules/@angular/compiler/src/i18n/i18n_ast.ts
@ -15,12 +15,11 @@ export class Message {
   * @param placeholderToMessage maps placeholder names to messages (used for nested ICU messages)
   * @param meaning
   * @param description
-   * @param id
   */
  constructor(
      public nodes: Node[], public placeholders: {[phName: string]: string},
      public placeholderToMessage: {[phName: string]: Message}, public meaning: string,
-      public description: string, public id: string) {}
+      public description: string) {}
 }

 export interface Node {
--- a/modules/@angular/compiler/src/i18n/i18n_parser.ts
+++ b/modules/@angular/compiler/src/i18n/i18n_parser.ts
@ -22,11 +22,11 @@ const _expParser = new ExpressionParser(new ExpressionLexer());
 * Returns a function converting html nodes to an i18n Message given an interpolationConfig
 */
 export function createI18nMessageFactory(interpolationConfig: InterpolationConfig): (
-    nodes: html.Node[], meaning: string, description: string, id: string) => i18n.Message {
+    nodes: html.Node[], meaning: string, description: string) => i18n.Message {
  const visitor = new _I18nVisitor(_expParser, interpolationConfig);

-  return (nodes: html.Node[], meaning: string, description: string, id: string) =>
-             visitor.toI18nMessage(nodes, meaning, description, id);
+  return (nodes: html.Node[], meaning: string, description: string) =>
+             visitor.toI18nMessage(nodes, meaning, description);
 }

 class _I18nVisitor implements html.Visitor {
@ -40,8 +40,7 @@ class _I18nVisitor implements html.Visitor {
      private _expressionParser: ExpressionParser,
      private _interpolationConfig: InterpolationConfig) {}

-  public toI18nMessage(nodes: html.Node[], meaning: string, description: string, id: string):
-      i18n.Message {
+  public toI18nMessage(nodes: html.Node[], meaning: string, description: string): i18n.Message {
    this._isIcu = nodes.length == 1 && nodes[0] instanceof html.Expansion;
    this._icuDepth = 0;
    this._placeholderRegistry = new PlaceholderRegistry();
@ -51,7 +50,7 @@ class _I18nVisitor implements html.Visitor {
    const i18nodes: i18n.Node[] = html.visitAll(this, nodes, {});

    return new i18n.Message(
-        i18nodes, this._placeholderToContent, this._placeholderToMessage, meaning, description, id);
+        i18nodes, this._placeholderToContent, this._placeholderToMessage, meaning, description);
  }

  visitElement(el: html.Element, context: any): i18n.Node {
@ -116,7 +115,7 @@ class _I18nVisitor implements html.Visitor {
    // TODO(vicb): add a html.Node -> i18n.Message cache to avoid having to re-create the msg
    const phName = this._placeholderRegistry.getPlaceholderName('ICU', icu.sourceSpan.toString());
    const visitor = new _I18nVisitor(this._expressionParser, this._interpolationConfig);
-    this._placeholderToMessage[phName] = visitor.toI18nMessage([icu], '', '', '');
+    this._placeholderToMessage[phName] = visitor.toI18nMessage([icu], '', '');
    return new i18n.IcuPlaceholder(i18nIcu, phName, icu.sourceSpan);
  }

--- a/modules/@angular/compiler/src/i18n/index.ts
+++ b/modules/@angular/compiler/src/i18n/index.ts
@ -6,7 +6,7 @@
 * found in the LICENSE file at https://angular.io/license
 */

-export {Extractor, ExtractorHost} from './extractor';
+export {Extractor, ExtractorHost, ExtractorOptions} from './extractor';
 export {I18NHtmlParser} from './i18n_html_parser';
 export {MessageBundle} from './message_bundle';
 export {Serializer} from './serializers/serializer';
--- a/modules/@angular/compiler/src/i18n/serializers/xmb.ts
+++ b/modules/@angular/compiler/src/i18n/serializers/xmb.ts
@ -39,7 +39,6 @@ const _DOCTYPE = `<!ELEMENT messagebundle (msg)*>

 export class Xmb implements Serializer {
  write(messages: i18n.Message[]): string {
-    const exampleVisitor = new ExampleVisitor();
    const visitor = new _Visitor();
    const visited: {[id: string]: boolean} = {};
    let rootNode = new xml.Tag(_MESSAGES_TAG);
@ -72,7 +71,7 @@ export class Xmb implements Serializer {
      new xml.CR(),
      new xml.Doctype(_MESSAGES_TAG, _DOCTYPE),
      new xml.CR(),
-      exampleVisitor.addDefaultExamples(rootNode),
+      rootNode,
      new xml.CR(),
    ]);
  }
@ -134,27 +133,4 @@ 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 {}
-}
+}
--- a/modules/@angular/compiler/src/identifiers.ts
+++ b/modules/@angular/compiler/src/identifiers.ts
@ -10,7 +10,7 @@ import {ANALYZE_FOR_ENTRY_COMPONENTS, AnimationTransitionEvent, ChangeDetectionS

 import {StaticSymbol} from './aot/static_symbol';
 import {CompileIdentifierMetadata, CompileTokenMetadata, identifierModuleUrl, identifierName} from './compile_metadata';
-import {AnimationGroupPlayer, AnimationKeyframe, AnimationSequencePlayer, AnimationStyles, AnimationTransition, AppView, ChangeDetectorStatus, CodegenComponentFactoryResolver, ComponentRef_, DebugAppView, DebugContext, NgModuleInjector, NoOpAnimationPlayer, StaticNodeDebugInfo, TemplateRef_, ValueUnwrapper, ViewContainer, ViewType, balanceAnimationKeyframes, clearStyles, collectAndResolveStyles, devModeEqual, prepareFinalAnimationStyles, reflector, registerModuleFactory, renderStyles, view_utils} from './private_import_core';
+import {AnimationGroupPlayer, AnimationKeyframe, AnimationSequencePlayer, AnimationStyles, AnimationTransition, AppView, ChangeDetectorStatus, CodegenComponentFactoryResolver, ComponentRef_, DebugAppView, DebugContext, NgModuleInjector, NoOpAnimationPlayer, StaticNodeDebugInfo, TemplateRef_, UNINITIALIZED, ValueUnwrapper, ViewContainer, ViewType, balanceAnimationKeyframes, clearStyles, collectAndResolveStyles, devModeEqual, prepareFinalAnimationStyles, reflector, registerModuleFactory, renderStyles, view_utils} from './private_import_core';

 const APP_VIEW_MODULE_URL = assetUrl('core', 'linker/view');
 const VIEW_UTILS_MODULE_URL = assetUrl('core', 'linker/view_utils');
@ -161,6 +161,8 @@ export class Identifiers {
  };
  static SimpleChange:
      IdentifierSpec = {name: 'SimpleChange', moduleUrl: CD_MODULE_URL, runtime: SimpleChange};
+  static UNINITIALIZED:
+      IdentifierSpec = {name: 'UNINITIALIZED', moduleUrl: CD_MODULE_URL, runtime: UNINITIALIZED};
  static ChangeDetectorStatus: IdentifierSpec = {
    name: 'ChangeDetectorStatus',
    moduleUrl: CD_MODULE_URL,
@ -171,36 +173,6 @@ export class Identifiers {
    moduleUrl: VIEW_UTILS_MODULE_URL,
    runtime: view_utils.checkBinding
  };
-  static checkBindingChange: IdentifierSpec = {
-    name: 'checkBindingChange',
-    moduleUrl: VIEW_UTILS_MODULE_URL,
-    runtime: view_utils.checkBindingChange
-  };
-  static checkRenderText: IdentifierSpec = {
-    name: 'checkRenderText',
-    moduleUrl: VIEW_UTILS_MODULE_URL,
-    runtime: view_utils.checkRenderText
-  };
-  static checkRenderProperty: IdentifierSpec = {
-    name: 'checkRenderProperty',
-    moduleUrl: VIEW_UTILS_MODULE_URL,
-    runtime: view_utils.checkRenderProperty
-  };
-  static checkRenderAttribute: IdentifierSpec = {
-    name: 'checkRenderAttribute',
-    moduleUrl: VIEW_UTILS_MODULE_URL,
-    runtime: view_utils.checkRenderAttribute
-  };
-  static checkRenderClass: IdentifierSpec = {
-    name: 'checkRenderClass',
-    moduleUrl: VIEW_UTILS_MODULE_URL,
-    runtime: view_utils.checkRenderClass
-  };
-  static checkRenderStyle: IdentifierSpec = {
-    name: 'checkRenderStyle',
-    moduleUrl: VIEW_UTILS_MODULE_URL,
-    runtime: view_utils.checkRenderStyle
-  };
  static devModeEqual:
      IdentifierSpec = {name: 'devModeEqual', moduleUrl: CD_MODULE_URL, runtime: devModeEqual};
  static inlineInterpolate: IdentifierSpec = {
--- a/modules/@angular/compiler/src/injectable.ts
+++ b/modules/@angular/compiler/src/injectable.ts
@ -1,16 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-/**
- * A replacement for @Injectable to be used in the compiler, so that
- * we don't try to evaluate the metadata in the compiler during AoT.
- * This decorator is enough to make the compiler work with the ReflectiveInjector though.
- */
-export function CompilerInjectable(): (data: any) => any {
-  return (x) => x;
-}
--- a/modules/@angular/compiler/src/jit/compiler.ts
+++ b/modules/@angular/compiler/src/jit/compiler.ts
@ -6,26 +6,24 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {Compiler, ComponentFactory, Injector, ModuleWithComponentFactories, NgModuleFactory, SchemaMetadata, Type} from '@angular/core';
+import {Compiler, ComponentFactory, Injectable, Injector, ModuleWithComponentFactories, NgModuleFactory, SchemaMetadata, Type} from '@angular/core';

 import {AnimationCompiler} from '../animation/animation_compiler';
 import {AnimationParser} from '../animation/animation_parser';
-import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompilePipeMetadata, ProviderMeta, ProxyClass, createHostComponentMeta, identifierName} from '../compile_metadata';
+import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompilePipeMetadata, ProviderMeta, createHostComponentMeta, identifierName} from '../compile_metadata';
 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';
 import {interpretStatements} from '../output/output_interpreter';
 import {jitStatements} from '../output/output_jit';
-import {view_utils} from '../private_import_core';
 import {CompiledStylesheet, StyleCompiler} from '../style_compiler';
 import {TemplateParser} from '../template_parser/template_parser';
 import {SyncAsyncResult} from '../util';
-import {ComponentFactoryDependency, ComponentViewDependency, DirectiveWrapperDependency, ViewCompiler} from '../view_compiler/view_compiler';
+import {ComponentFactoryDependency, DirectiveWrapperDependency, ViewClassDependency, ViewCompiler} from '../view_compiler/view_compiler';



@ -38,7 +36,7 @@ import {ComponentFactoryDependency, ComponentViewDependency, DirectiveWrapperDep
 * from a trusted source. Attacker-controlled data introduced by a template could expose your
 * application to XSS risks.  For more detail, see the [Security Guide](http://g.co/ng/security).
 */
-@CompilerInjectable()
+@Injectable()
 export class JitCompiler implements Compiler {
  private _compiledTemplateCache = new Map<Type<any>, CompiledTemplate>();
  private _compiledHostTemplateCache = new Map<Type<any>, CompiledTemplate>();
@ -131,6 +129,10 @@ export class JitCompiler implements Compiler {
      const extraProviders = [this._metadataResolver.getProviderMetadata(new ProviderMeta(
          Compiler, {useFactory: () => new ModuleBoundCompiler(this, moduleMeta.type.reference)}))];
      const compileResult = this._ngModuleCompiler.compile(moduleMeta, extraProviders);
+      compileResult.dependencies.forEach((dep) => {
+        dep.placeholder.reference =
+            this._assertComponentKnown(dep.comp.reference, true).proxyComponentFactory;
+      });
      if (!this._compilerConfig.useJit) {
        ngModuleFactory =
            interpretStatements(compileResult.statements, compileResult.ngModuleFactoryVar);
@ -165,7 +167,7 @@ export class JitCompiler implements Compiler {
            const template =
                this._createCompiledHostTemplate(dirMeta.type.reference, localModuleMeta);
            templates.add(template);
-            allComponentFactories.push(<ComponentFactory<any>>dirMeta.componentFactory);
+            allComponentFactories.push(template.proxyComponentFactory);
          }
        }
      });
@ -177,16 +179,15 @@ export class JitCompiler implements Compiler {
        const dirMeta = this._metadataResolver.getDirectiveMetadata(dirIdentifier.reference);
        if (dirMeta.isComponent) {
          dirMeta.entryComponents.forEach((entryComponentType) => {
-            const moduleMeta = moduleByDirective.get(entryComponentType.componentType);
+            const moduleMeta = moduleByDirective.get(entryComponentType.reference);
            templates.add(
-                this._createCompiledHostTemplate(entryComponentType.componentType, moduleMeta));
+                this._createCompiledHostTemplate(entryComponentType.reference, moduleMeta));
          });
        }
      });
      localModuleMeta.entryComponents.forEach((entryComponentType) => {
-        const moduleMeta = moduleByDirective.get(entryComponentType.componentType);
-        templates.add(
-            this._createCompiledHostTemplate(entryComponentType.componentType, moduleMeta));
+        const moduleMeta = moduleByDirective.get(entryComponentType.reference);
+        templates.add(this._createCompiledHostTemplate(entryComponentType.reference, moduleMeta));
      });
    });
    templates.forEach((template) => this._compileTemplate(template));
@ -220,12 +221,12 @@ export class JitCompiler implements Compiler {
      const compMeta = this._metadataResolver.getDirectiveMetadata(compType);
      assertComponent(compMeta);

-      const componentFactory = <ComponentFactory<any>>compMeta.componentFactory;
-      const hostClass = this._metadataResolver.getHostComponentType(compType);
-      const hostMeta = createHostComponentMeta(
-          hostClass, compMeta, <any>view_utils.getComponentFactoryViewClass(componentFactory));
-      compiledTemplate =
-          new CompiledTemplate(true, compMeta.type, hostMeta, ngModule, [compMeta.type]);
+      const HostClass = function HostClass() {};
+      (<any>HostClass).overriddenName = `${identifierName(compMeta.type)}_Host`;
+
+      const hostMeta = createHostComponentMeta(HostClass, compMeta);
+      compiledTemplate = new CompiledTemplate(
+          true, compMeta.selector, compMeta.type, hostMeta, ngModule, [compMeta.type]);
      this._compiledHostTemplateCache.set(compType, compiledTemplate);
    }
    return compiledTemplate;
@ -237,7 +238,8 @@ export class JitCompiler implements Compiler {
    if (!compiledTemplate) {
      assertComponent(compMeta);
      compiledTemplate = new CompiledTemplate(
-          false, compMeta.type, compMeta, ngModule, ngModule.transitiveModule.directives);
+          false, compMeta.selector, compMeta.type, compMeta, ngModule,
+          ngModule.transitiveModule.directives);
      this._compiledTemplateCache.set(compMeta.type.reference, compiledTemplate);
    }
    return compiledTemplate;
@ -274,7 +276,6 @@ export class JitCompiler implements Compiler {
          `/${identifierName(moduleMeta.type)}/${identifierName(dirMeta.type)}/wrapper.ngfactory.js`,
          statements, compileResult.dirWrapperClassVar);
    }
-    (<ProxyClass>dirMeta.wrapperType).setDelegate(directiveWrapperClass);
    this._compiledDirectiveWrapperCache.set(dirMeta.type.reference, directiveWrapperClass);
  }

@ -302,6 +303,21 @@ export class JitCompiler implements Compiler {
    const compileResult = this._viewCompiler.compileComponent(
        compMeta, parsedTemplate, ir.variable(stylesCompileResult.componentStylesheet.stylesVar),
        pipes, compiledAnimations);
+    compileResult.dependencies.forEach((dep) => {
+      let depTemplate: CompiledTemplate;
+      if (dep instanceof ViewClassDependency) {
+        const vfd = <ViewClassDependency>dep;
+        depTemplate = this._assertComponentKnown(vfd.comp.reference, false);
+        vfd.placeholder.reference = depTemplate.proxyViewClass;
+      } else if (dep instanceof ComponentFactoryDependency) {
+        const cfd = <ComponentFactoryDependency>dep;
+        depTemplate = this._assertComponentKnown(cfd.comp.reference, true);
+        cfd.placeholder.reference = depTemplate.proxyComponentFactory;
+      } else if (dep instanceof DirectiveWrapperDependency) {
+        const dwd = <DirectiveWrapperDependency>dep;
+        dwd.placeholder.reference = this._assertDirectiveWrapper(dwd.dir.reference);
+      }
+    });
    const statements = stylesCompileResult.componentStylesheet.statements
                           .concat(...compiledAnimations.map(ca => ca.statements))
                           .concat(compileResult.statements);
@ -341,18 +357,30 @@ export class JitCompiler implements Compiler {

 class CompiledTemplate {
  private _viewClass: Function = null;
+  proxyViewClass: Type<any>;
+  proxyComponentFactory: ComponentFactory<any>;
  isCompiled = false;

  constructor(
-      public isHost: boolean, public compType: CompileIdentifierMetadata,
+      public isHost: boolean, selector: string, public compType: CompileIdentifierMetadata,
      public compMeta: CompileDirectiveMetadata, public ngModule: CompileNgModuleMetadata,
      public directives: CompileIdentifierMetadata[]) {
    const self = this;
+    this.proxyViewClass = <any>function() {
+      if (!self._viewClass) {
+        throw new Error(
+            `Illegal state: CompiledTemplate for ${stringify(self.compType)} is not compiled yet!`);
+      }
+      return self._viewClass.apply(this, arguments);
+    };
+    this.proxyComponentFactory = isHost ?
+        new ComponentFactory<any>(selector, this.proxyViewClass, compType.reference) :
+        null;
  }

  compiled(viewClass: Function) {
    this._viewClass = viewClass;
-    (<ProxyClass>this.compMeta.componentViewType).setDelegate(viewClass);
+    this.proxyViewClass.prototype = viewClass.prototype;
    this.isCompiled = true;
  }
 }
--- a/modules/@angular/compiler/src/jit/compiler_factory.ts
+++ b/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, OpaqueToken, Optional, PLATFORM_INITIALIZER, PlatformRef, Provider, ReflectiveInjector, TRANSLATIONS, TRANSLATIONS_FORMAT, Type, ViewEncapsulation, createPlatformFactory, isDevMode, platformCore} from '@angular/core';
+import {COMPILER_OPTIONS, Compiler, CompilerFactory, CompilerOptions, Inject, Injectable, Optional, PLATFORM_INITIALIZER, PlatformRef, Provider, ReflectiveInjector, TRANSLATIONS, TRANSLATIONS_FORMAT, Type, ViewEncapsulation, createPlatformFactory, isDevMode, platformCore} from '@angular/core';

 import {AnimationParser} from '../animation/animation_parser';
 import {CompilerConfig} from '../config';
@ -16,7 +16,6 @@ import {DirectiveWrapperCompiler} from '../directive_wrapper_compiler';
 import {Lexer} from '../expression_parser/lexer';
 import {Parser} from '../expression_parser/parser';
 import * as i18n from '../i18n/index';
-import {CompilerInjectable} from '../injectable';
 import {CompileMetadataResolver} from '../metadata_resolver';
 import {HtmlParser} from '../ml_parser/html_parser';
 import {NgModuleCompiler} from '../ng_module_compiler';
@ -40,8 +39,6 @@ const _NO_RESOURCE_LOADER: ResourceLoader = {
          `No ResourceLoader implementation has been provided. Can't read the url "${url}"`);}
 };

-const baseHtmlParser = new OpaqueToken('HtmlParser');
-
 /**
 * A set of providers that provide `JitCompiler` and its dependencies to use for
 * template compilation.
@ -54,24 +51,17 @@ export const COMPILER_PROVIDERS: Array<any|Type<any>|{[k: string]: any}|any[]> =
  Console,
  Lexer,
  Parser,
-  {
-    provide: baseHtmlParser,
-    useClass: HtmlParser,
-  },
+  HtmlParser,
  {
    provide: i18n.I18NHtmlParser,
    useFactory: (parser: HtmlParser, translations: string, format: string) =>
                    new i18n.I18NHtmlParser(parser, translations, format),
    deps: [
-      baseHtmlParser,
+      HtmlParser,
      [new Optional(), new Inject(TRANSLATIONS)],
      [new Optional(), new Inject(TRANSLATIONS_FORMAT)],
    ]
  },
-  {
-    provide: HtmlParser,
-    useExisting: i18n.I18NHtmlParser,
-  },
  TemplateParser,
  DirectiveNormalizer,
  CompileMetadataResolver,
@ -93,7 +83,7 @@ export const COMPILER_PROVIDERS: Array<any|Type<any>|{[k: string]: any}|any[]> =
 ];


-@CompilerInjectable()
+@Injectable()
 export class JitCompilerFactory implements CompilerFactory {
  private _defaultOptions: CompilerOptions[];
  constructor(@Inject(COMPILER_OPTIONS) defaultOptions: CompilerOptions[]) {
--- a/modules/@angular/compiler/src/metadata_resolver.ts
+++ b/modules/@angular/compiler/src/metadata_resolver.ts
@ -6,17 +6,16 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {AnimationAnimateMetadata, AnimationEntryMetadata, AnimationGroupMetadata, AnimationKeyframesSequenceMetadata, AnimationMetadata, AnimationStateDeclarationMetadata, AnimationStateMetadata, AnimationStateTransitionMetadata, AnimationStyleMetadata, AnimationWithStepsMetadata, Attribute, ChangeDetectionStrategy, Component, ComponentFactory, Directive, Host, Inject, Injectable, ModuleWithProviders, OpaqueToken, Optional, Provider, Query, SchemaMetadata, Self, SkipSelf, Type, resolveForwardRef} from '@angular/core';
+import {AnimationAnimateMetadata, AnimationEntryMetadata, AnimationGroupMetadata, AnimationKeyframesSequenceMetadata, AnimationMetadata, AnimationStateDeclarationMetadata, AnimationStateMetadata, AnimationStateTransitionMetadata, AnimationStyleMetadata, AnimationWithStepsMetadata, Attribute, ChangeDetectionStrategy, Component, Directive, Host, Inject, Injectable, ModuleWithProviders, OpaqueToken, Optional, Provider, Query, SchemaMetadata, Self, SkipSelf, Type, resolveForwardRef} from '@angular/core';

-import {StaticSymbol, StaticSymbolCache} from './aot/static_symbol';
-import {ngfactoryFilePath} from './aot/util';
+import {StaticSymbol} from './aot/static_symbol';
 import {assertArrayOfStrings, assertInterpolationSymbols} from './assertions';
 import * as cpl from './compile_metadata';
 import {DirectiveNormalizer} from './directive_normalizer';
 import {DirectiveResolver} from './directive_resolver';
-import {stringify} from './facade/lang';
-import {Identifiers, resolveIdentifier} from './identifiers';
-import {CompilerInjectable} from './injectable';
+import {ListWrapper, StringMapWrapper} from './facade/collection';
+import {isBlank, isPresent, stringify} from './facade/lang';
+import {Identifiers, createIdentifierToken, resolveIdentifier} from './identifiers';
 import {hasLifecycleHook} from './lifecycle_reflector';
 import {NgModuleResolver} from './ng_module_resolver';
 import {PipeResolver} from './pipe_resolver';
@ -24,7 +23,7 @@ import {ComponentStillLoadingError, LIFECYCLE_HOOKS_VALUES, ReflectorReader, ref
 import {ElementSchemaRegistry} from './schema/element_schema_registry';
 import {SummaryResolver} from './summary_resolver';
 import {getUrlScheme} from './url_resolver';
-import {MODULE_SUFFIX, SyntaxError, ValueTransformer, visitValue} from './util';
+import {MODULE_SUFFIX, SyncAsyncResult, ValueTransformer, visitValue} from './util';

 export type ErrorCollector = (error: any, type?: any) => void;
 export const ERROR_COLLECTOR_TOKEN = new OpaqueToken('ErrorCollector');
@ -36,10 +35,8 @@ export const ERROR_COLLECTOR_TOKEN = new OpaqueToken('ErrorCollector');
 //   But we want to report errors even when the async work is
 //   not required to check that the user would have been able
 //   to wait correctly.
-@CompilerInjectable()
+@Injectable()
 export class CompileMetadataResolver {
-  private _nonNormalizedDirectiveCache =
-      new Map<Type<any>, {annotation: Directive, metadata: cpl.CompileDirectiveMetadata}>();
  private _directiveCache = new Map<Type<any>, cpl.CompileDirectiveMetadata>();
  private _summaryCache = new Map<Type<any>, cpl.CompileTypeSummary>();
  private _pipeCache = new Map<Type<any>, cpl.CompilePipeMetadata>();
@ -48,17 +45,15 @@ export class CompileMetadataResolver {

  constructor(
      private _ngModuleResolver: NgModuleResolver, private _directiveResolver: DirectiveResolver,
-      private _pipeResolver: PipeResolver, private _summaryResolver: SummaryResolver<any>,
+      private _pipeResolver: PipeResolver, private _summaryResolver: SummaryResolver,
      private _schemaRegistry: ElementSchemaRegistry,
      private _directiveNormalizer: DirectiveNormalizer,
-      @Optional() private _staticSymbolCache: StaticSymbolCache,
      private _reflector: ReflectorReader = reflector,
      @Optional() @Inject(ERROR_COLLECTOR_TOKEN) private _errorCollector?: ErrorCollector) {}

  clearCacheFor(type: Type<any>) {
    const dirMeta = this._directiveCache.get(type);
    this._directiveCache.delete(type);
-    this._nonNormalizedDirectiveCache.delete(type);
    this._summaryCache.delete(type);
    this._pipeCache.delete(type);
    this._ngModuleOfTypes.delete(type);
@ -69,9 +64,8 @@ export class CompileMetadataResolver {
    }
  }

-  clearCache(): void {
+  clearCache() {
    this._directiveCache.clear();
-    this._nonNormalizedDirectiveCache.clear();
    this._summaryCache.clear();
    this._pipeCache.clear();
    this._ngModuleCache.clear();
@ -79,66 +73,6 @@ export class CompileMetadataResolver {
    this._directiveNormalizer.clearCache();
  }

-  private _createProxyClass(baseType: any, name: string): cpl.ProxyClass {
-    let delegate: any = null;
-    const proxyClass: cpl.ProxyClass = <any>function() {
-      if (!delegate) {
-        throw new Error(
-            `Illegal state: Class ${name} for type ${stringify(baseType)} is not compiled yet!`);
-      }
-      return delegate.apply(this, arguments);
-    };
-    proxyClass.setDelegate = (d) => {
-      delegate = d;
-      (<any>proxyClass).prototype = d.prototype;
-    };
-    // Make stringify work correctly
-    (<any>proxyClass).overriddenName = name;
-    return proxyClass;
-  }
-
-  private getGeneratedClass(dirType: any, name: string): StaticSymbol|cpl.ProxyClass {
-    if (dirType instanceof StaticSymbol) {
-      return this._staticSymbolCache.get(ngfactoryFilePath(dirType.filePath), name);
-    } else {
-      return this._createProxyClass(dirType, name);
-    }
-  }
-
-  private getDirectiveWrapperClass(dirType: any): StaticSymbol|cpl.ProxyClass {
-    return this.getGeneratedClass(dirType, cpl.dirWrapperClassName(dirType));
-  }
-
-  private getComponentViewClass(dirType: any): StaticSymbol|cpl.ProxyClass {
-    return this.getGeneratedClass(dirType, cpl.viewClassName(dirType, 0));
-  }
-
-  getHostComponentViewClass(dirType: any): StaticSymbol|cpl.ProxyClass {
-    return this.getGeneratedClass(dirType, cpl.hostViewClassName(dirType));
-  }
-
-  getHostComponentType(dirType: any): StaticSymbol|Type<any> {
-    const name = `${cpl.identifierName({reference: dirType})}_Host`;
-    if (dirType instanceof StaticSymbol) {
-      return this._staticSymbolCache.get(dirType.filePath, name);
-    } else {
-      const HostClass = <any>function HostClass() {};
-      HostClass.overriddenName = name;
-
-      return HostClass;
-    }
-  }
-
-  private getComponentFactory(selector: string, dirType: any): StaticSymbol|ComponentFactory<any> {
-    if (dirType instanceof StaticSymbol) {
-      return this._staticSymbolCache.get(
-          ngfactoryFilePath(dirType.filePath), cpl.componentFactoryName(dirType));
-    } else {
-      const hostView = this.getHostComponentViewClass(dirType);
-      return new ComponentFactory(selector, <any>hostView, dirType);
-    }
-  }
-
  getAnimationEntryMetadata(entry: AnimationEntryMetadata): cpl.CompileAnimationEntryMetadata {
    const defs = entry.definitions.map(def => this._getAnimationStateMetadata(def));
    return new cpl.CompileAnimationEntryMetadata(entry.name, defs);
@ -194,13 +128,12 @@ export class CompileMetadataResolver {
  }

  private _loadSummary(type: any, kind: cpl.CompileSummaryKind): cpl.CompileTypeSummary {
-    let typeSummary = this._summaryCache.get(type);
-    if (!typeSummary) {
-      const summary = this._summaryResolver.resolveSummary(type);
-      typeSummary = summary ? summary.type : null;
-      this._summaryCache.set(type, typeSummary);
+    let summary = this._summaryCache.get(type);
+    if (!summary) {
+      summary = this._summaryResolver.resolveSummary(type);
+      this._summaryCache.set(type, summary);
    }
-    return typeSummary && typeSummary.summaryKind === kind ? typeSummary : null;
+    return summary && summary.summaryKind === kind ? summary : null;
  }

  private _loadDirectiveMetadata(directiveType: any, isSync: boolean): Promise<any> {
@ -227,9 +160,6 @@ export class CompileMetadataResolver {
        queries: metadata.queries,
        viewQueries: metadata.viewQueries,
        entryComponents: metadata.entryComponents,
-        wrapperType: metadata.wrapperType,
-        componentViewType: metadata.componentViewType,
-        componentFactory: metadata.componentFactory,
        template: templateMetadata
      });
      this._directiveCache.set(directiveType, normalizedDirMeta);
@ -269,14 +199,7 @@ export class CompileMetadataResolver {
  getNonNormalizedDirectiveMetadata(directiveType: any):
      {annotation: Directive, metadata: cpl.CompileDirectiveMetadata} {
    directiveType = resolveForwardRef(directiveType);
-    if (!directiveType) {
-      return null;
-    }
-    let cacheEntry = this._nonNormalizedDirectiveCache.get(directiveType);
-    if (cacheEntry) {
-      return cacheEntry;
-    }
-    const dirMeta = this._directiveResolver.resolve(directiveType, false);
+    const dirMeta = this._directiveResolver.resolve(directiveType);
    if (!dirMeta) {
      return null;
    }
@ -305,7 +228,7 @@ export class CompileMetadataResolver {

    let changeDetectionStrategy: ChangeDetectionStrategy = null;
    let viewProviders: cpl.CompileProviderMetadata[] = [];
-    let entryComponentMetadata: cpl.CompileEntryComponentMetadata[] = [];
+    let entryComponentMetadata: cpl.CompileIdentifierMetadata[] = [];
    let selector = dirMeta.selector;

    if (dirMeta instanceof Component) {
@ -314,11 +237,11 @@ export class CompileMetadataResolver {
      if (dirMeta.viewProviders) {
        viewProviders = this._getProvidersMetadata(
            dirMeta.viewProviders, entryComponentMetadata,
-            `viewProviders for "${stringifyType(directiveType)}"`, [], directiveType);
+            `viewProviders for "${stringify(directiveType)}"`, [], directiveType);
      }
      if (dirMeta.entryComponents) {
        entryComponentMetadata = flattenAndDedupeArray(dirMeta.entryComponents)
-                                     .map((type) => this._getEntryComponentMetadata(type))
+                                     .map((type) => this._getIdentifierMetadata(type))
                                     .concat(entryComponentMetadata);
      }
      if (!selector) {
@ -328,22 +251,21 @@ export class CompileMetadataResolver {
      // Directive
      if (!selector) {
        this._reportError(
-            new SyntaxError(
-                `Directive ${stringifyType(directiveType)} has no selector, please add it!`),
+            new Error(`Directive ${stringify(directiveType)} has no selector, please add it!`),
            directiveType);
        selector = 'error';
      }
    }

    let providers: cpl.CompileProviderMetadata[] = [];
-    if (dirMeta.providers != null) {
+    if (isPresent(dirMeta.providers)) {
      providers = this._getProvidersMetadata(
-          dirMeta.providers, entryComponentMetadata,
-          `providers for "${stringifyType(directiveType)}"`, [], directiveType);
+          dirMeta.providers, entryComponentMetadata, `providers for "${stringify(directiveType)}"`,
+          [], directiveType);
    }
    let queries: cpl.CompileQueryMetadata[] = [];
    let viewQueries: cpl.CompileQueryMetadata[] = [];
-    if (dirMeta.queries != null) {
+    if (isPresent(dirMeta.queries)) {
      queries = this._getQueriesMetadata(dirMeta.queries, false, directiveType);
      viewQueries = this._getQueriesMetadata(dirMeta.queries, true, directiveType);
    }
@ -362,17 +284,9 @@ export class CompileMetadataResolver {
      viewProviders: viewProviders,
      queries: queries,
      viewQueries: viewQueries,
-      entryComponents: entryComponentMetadata,
-      wrapperType: this.getDirectiveWrapperClass(directiveType),
-      componentViewType: nonNormalizedTemplateMetadata ? this.getComponentViewClass(directiveType) :
-                                                         undefined,
-      componentFactory: nonNormalizedTemplateMetadata ?
-          this.getComponentFactory(selector, directiveType) :
-          undefined
+      entryComponents: entryComponentMetadata
    });
-    cacheEntry = {metadata, annotation: dirMeta};
-    this._nonNormalizedDirectiveCache.set(directiveType, cacheEntry);
-    return cacheEntry;
+    return {metadata, annotation: dirMeta};
  }

  /**
@ -383,8 +297,8 @@ export class CompileMetadataResolver {
    const dirMeta = this._directiveCache.get(directiveType);
    if (!dirMeta) {
      this._reportError(
-          new SyntaxError(
-              `Illegal state: getDirectiveMetadata can only be called after loadNgModuleMetadata for a module that declares it. Directive ${stringifyType(directiveType)}.`),
+          new Error(
+              `Illegal state: getDirectiveMetadata can only be called after loadNgModuleMetadata for a module that declares it. Directive ${stringify(directiveType)}.`),
          directiveType);
    }
    return dirMeta;
@ -395,8 +309,8 @@ export class CompileMetadataResolver {
        <cpl.CompileDirectiveSummary>this._loadSummary(dirType, cpl.CompileSummaryKind.Directive);
    if (!dirSummary) {
      this._reportError(
-          new SyntaxError(
-              `Illegal state: Could not load the summary for directive ${stringifyType(dirType)}.`),
+          new Error(
+              `Illegal state: Could not load the summary for directive ${stringify(dirType)}.`),
          dirType);
    }
    return dirSummary;
@ -454,7 +368,7 @@ export class CompileMetadataResolver {
    const importedModules: cpl.CompileNgModuleSummary[] = [];
    const exportedModules: cpl.CompileNgModuleSummary[] = [];
    const providers: cpl.CompileProviderMetadata[] = [];
-    const entryComponents: cpl.CompileEntryComponentMetadata[] = [];
+    const entryComponents: cpl.CompileIdentifierMetadata[] = [];
    const bootstrapComponents: cpl.CompileIdentifierMetadata[] = [];
    const schemas: SchemaMetadata[] = [];

@ -469,8 +383,7 @@ export class CompileMetadataResolver {
          if (moduleWithProviders.providers) {
            providers.push(...this._getProvidersMetadata(
                moduleWithProviders.providers, entryComponents,
-                `provider for the NgModule '${stringifyType(importedModuleType)}'`, [],
-                importedType));
+                `provider for the NgModule '${stringify(importedModuleType)}'`, [], importedType));
          }
        }

@ -478,16 +391,16 @@ export class CompileMetadataResolver {
          const importedModuleSummary = this.getNgModuleSummary(importedModuleType);
          if (!importedModuleSummary) {
            this._reportError(
-                new SyntaxError(
-                    `Unexpected ${this._getTypeDescriptor(importedType)} '${stringifyType(importedType)}' imported by the module '${stringifyType(moduleType)}'`),
+                new Error(
+                    `Unexpected ${this._getTypeDescriptor(importedType)} '${stringify(importedType)}' imported by the module '${stringify(moduleType)}'`),
                moduleType);
            return;
          }
          importedModules.push(importedModuleSummary);
        } else {
          this._reportError(
-              new SyntaxError(
-                  `Unexpected value '${stringifyType(importedType)}' imported by the module '${stringifyType(moduleType)}'`),
+              new Error(
+                  `Unexpected value '${stringify(importedType)}' imported by the module '${stringify(moduleType)}'`),
              moduleType);
          return;
        }
@ -498,8 +411,8 @@ export class CompileMetadataResolver {
      flattenAndDedupeArray(meta.exports).forEach((exportedType) => {
        if (!isValidType(exportedType)) {
          this._reportError(
-              new SyntaxError(
-                  `Unexpected value '${stringifyType(exportedType)}' exported by the module '${stringifyType(moduleType)}'`),
+              new Error(
+                  `Unexpected value '${stringify(exportedType)}' exported by the module '${stringify(moduleType)}'`),
              moduleType);
          return;
        }
@ -519,8 +432,8 @@ export class CompileMetadataResolver {
      flattenAndDedupeArray(meta.declarations).forEach((declaredType) => {
        if (!isValidType(declaredType)) {
          this._reportError(
-              new SyntaxError(
-                  `Unexpected value '${stringifyType(declaredType)}' declared by the module '${stringifyType(moduleType)}'`),
+              new Error(
+                  `Unexpected value '${stringify(declaredType)}' declared by the module '${stringify(moduleType)}'`),
              moduleType);
          return;
        }
@ -536,8 +449,8 @@ export class CompileMetadataResolver {
          this._addTypeToModule(declaredType, moduleType);
        } else {
          this._reportError(
-              new SyntaxError(
-                  `Unexpected ${this._getTypeDescriptor(declaredType)} '${stringifyType(declaredType)}' declared by the module '${stringifyType(moduleType)}'`),
+              new Error(
+                  `Unexpected ${this._getTypeDescriptor(declaredType)} '${stringify(declaredType)}' declared by the module '${stringify(moduleType)}'`),
              moduleType);
          return;
        }
@ -555,8 +468,8 @@ export class CompileMetadataResolver {
        transitiveModule.addExportedPipe(exportedId);
      } else {
        this._reportError(
-            new SyntaxError(
-                `Can't export ${this._getTypeDescriptor(exportedId.reference)} ${stringifyType(exportedId.reference)} from ${stringifyType(moduleType)} as it was neither declared nor imported!`),
+            new Error(
+                `Can't export ${this._getTypeDescriptor(exportedId.reference)} ${stringify(exportedId.reference)} from ${stringify(moduleType)} as it was neither declared nor imported!`),
            moduleType);
      }
    });
@ -565,30 +478,29 @@ export class CompileMetadataResolver {
    // so that they overwrite any other provider we already added.
    if (meta.providers) {
      providers.push(...this._getProvidersMetadata(
-          meta.providers, entryComponents,
-          `provider for the NgModule '${stringifyType(moduleType)}'`, [], moduleType));
+          meta.providers, entryComponents, `provider for the NgModule '${stringify(moduleType)}'`,
+          [], moduleType));
    }

    if (meta.entryComponents) {
-      entryComponents.push(...flattenAndDedupeArray(meta.entryComponents)
-                               .map(type => this._getEntryComponentMetadata(type)));
+      entryComponents.push(
+          ...flattenAndDedupeArray(meta.entryComponents).map(type => this._getTypeMetadata(type)));
    }

    if (meta.bootstrap) {
      flattenAndDedupeArray(meta.bootstrap).forEach(type => {
        if (!isValidType(type)) {
          this._reportError(
-              new SyntaxError(
-                  `Unexpected value '${stringifyType(type)}' used in the bootstrap property of module '${stringifyType(moduleType)}'`),
+              new Error(
+                  `Unexpected value '${stringify(type)}' used in the bootstrap property of module '${stringify(moduleType)}'`),
              moduleType);
          return;
        }
-        bootstrapComponents.push(this._getIdentifierMetadata(type));
+        bootstrapComponents.push(this._getTypeMetadata(type));
      });
    }

-    entryComponents.push(
-        ...bootstrapComponents.map(type => this._getEntryComponentMetadata(type.reference)));
+    entryComponents.push(...bootstrapComponents);

    if (meta.schemas) {
      schemas.push(...flattenAndDedupeArray(meta.schemas));
@ -642,10 +554,10 @@ export class CompileMetadataResolver {
    const oldModule = this._ngModuleOfTypes.get(type);
    if (oldModule && oldModule !== moduleType) {
      this._reportError(
-          new SyntaxError(
-              `Type ${stringifyType(type)} is part of the declarations of 2 modules: ${stringifyType(oldModule)} and ${stringifyType(moduleType)}! ` +
-              `Please consider moving ${stringifyType(type)} to a higher module that imports ${stringifyType(oldModule)} and ${stringifyType(moduleType)}. ` +
-              `You can also create a new NgModule that exports and includes ${stringifyType(type)} then import that NgModule in ${stringifyType(oldModule)} and ${stringifyType(moduleType)}.`),
+          new Error(
+              `Type ${stringify(type)} is part of the declarations of 2 modules: ${stringify(oldModule)} and ${stringify(moduleType)}! ` +
+              `Please consider moving ${stringify(type)} to a higher module that imports ${stringify(oldModule)} and ${stringify(moduleType)}. ` +
+              `You can also create a new NgModule that exports and includes ${stringify(type)} then import that NgModule in ${stringify(oldModule)} and ${stringify(moduleType)}.`),
          moduleType);
    }
    this._ngModuleOfTypes.set(type, moduleType);
@ -694,26 +606,6 @@ export class CompileMetadataResolver {
    return {reference: type};
  }

-  isInjectable(type: any): boolean {
-    const annotations = this._reflector.annotations(type);
-    // Note: We need an exact check here as @Component / @Directive / ... inherit
-    // from @CompilerInjectable!
-    return annotations.some(ann => ann.constructor === Injectable);
-  }
-
-  getInjectableSummary(type: any): cpl.CompileTypeSummary {
-    return {summaryKind: cpl.CompileSummaryKind.Injectable, type: this._getTypeMetadata(type)};
-  }
-
-  private _getInjectableMetadata(type: Type<any>, dependencies: any[] = null):
-      cpl.CompileTypeMetadata {
-    const typeSummary = this._loadSummary(type, cpl.CompileSummaryKind.Injectable);
-    if (typeSummary) {
-      return typeSummary.type;
-    }
-    return this._getTypeMetadata(type, dependencies);
-  }
-
  private _getTypeMetadata(type: Type<any>, dependencies: any[] = null): cpl.CompileTypeMetadata {
    const identifier = this._getIdentifierMetadata(type);
    return {
@ -738,8 +630,8 @@ export class CompileMetadataResolver {
    const pipeMeta = this._pipeCache.get(pipeType);
    if (!pipeMeta) {
      this._reportError(
-          new SyntaxError(
-              `Illegal state: getPipeMetadata can only be called after loadNgModuleMetadata for a module that declares it. Pipe ${stringifyType(pipeType)}.`),
+          new Error(
+              `Illegal state: getPipeMetadata can only be called after loadNgModuleMetadata for a module that declares it. Pipe ${stringify(pipeType)}.`),
          pipeType);
    }
    return pipeMeta;
@ -750,8 +642,7 @@ export class CompileMetadataResolver {
        <cpl.CompilePipeSummary>this._loadSummary(pipeType, cpl.CompileSummaryKind.Pipe);
    if (!pipeSummary) {
      this._reportError(
-          new SyntaxError(
-              `Illegal state: Could not load the summary for pipe ${stringifyType(pipeType)}.`),
+          new Error(`Illegal state: Could not load the summary for pipe ${stringify(pipeType)}.`),
          pipeType);
    }
    return pipeSummary;
@ -806,14 +697,14 @@ export class CompileMetadataResolver {
            token = paramEntry.attributeName;
          } else if (paramEntry instanceof Inject) {
            token = paramEntry.token;
-          } else if (isValidType(paramEntry) && token == null) {
+          } else if (isValidType(paramEntry) && isBlank(token)) {
            token = paramEntry;
          }
        });
      } else {
        token = param;
      }
-      if (token == null) {
+      if (isBlank(token)) {
        hasUnknownDeps = true;
        return null;
      }
@ -831,10 +722,9 @@ export class CompileMetadataResolver {

    if (hasUnknownDeps) {
      const depsTokens =
-          dependenciesMetadata.map((dep) => dep ? stringifyType(dep.token) : '?').join(', ');
+          dependenciesMetadata.map((dep) => dep ? stringify(dep.token) : '?').join(', ');
      this._reportError(
-          new SyntaxError(
-              `Can't resolve all parameters for ${stringifyType(typeOrFunc)}: (${depsTokens}).`),
+          new Error(`Can't resolve all parameters for ${stringify(typeOrFunc)}: (${depsTokens}).`),
          typeOrFunc);
    }

@ -853,7 +743,7 @@ export class CompileMetadataResolver {
  }

  private _getProvidersMetadata(
-      providers: Provider[], targetEntryComponents: cpl.CompileEntryComponentMetadata[],
+      providers: Provider[], targetEntryComponents: cpl.CompileIdentifierMetadata[],
      debugInfo?: string, compileProviders: cpl.CompileProviderMetadata[] = [],
      type?: any): cpl.CompileProviderMetadata[] {
    providers.forEach((provider: any, providerIdx: number) => {
@ -862,22 +752,18 @@ export class CompileMetadataResolver {
      } else {
        provider = resolveForwardRef(provider);
        let providerMeta: cpl.ProviderMeta;
-        if (provider && typeof provider === 'object' && provider.hasOwnProperty('provide')) {
-          this._validateProvider(provider);
+        if (provider && typeof provider == 'object' && provider.hasOwnProperty('provide')) {
          providerMeta = new cpl.ProviderMeta(provider.provide, provider);
        } else if (isValidType(provider)) {
          providerMeta = new cpl.ProviderMeta(provider, {useClass: provider});
-        } else if (provider === void 0) {
-          this._reportError(new SyntaxError(
-              `Encountered undefined provider! Usually this means you have a circular dependencies (might be caused by using 'barrel' index.ts files.`));
        } else {
          const providersInfo =
              (<string[]>providers.reduce(
                   (soFar: string[], seenProvider: any, seenProviderIdx: number) => {
                     if (seenProviderIdx < providerIdx) {
-                       soFar.push(`${stringifyType(seenProvider)}`);
+                       soFar.push(`${stringify(seenProvider)}`);
                     } else if (seenProviderIdx == providerIdx) {
-                       soFar.push(`?${stringifyType(seenProvider)}?`);
+                       soFar.push(`?${stringify(seenProvider)}?`);
                     } else if (seenProviderIdx == providerIdx + 1) {
                       soFar.push('...');
                     }
@ -886,7 +772,7 @@ export class CompileMetadataResolver {
                   []))
                  .join(', ');
          this._reportError(
-              new SyntaxError(
+              new Error(
                  `Invalid ${debugInfo ? debugInfo : 'provider'} - only instances of Provider and Type are allowed, got: [${providersInfo}]`),
              type);
        }
@ -900,57 +786,32 @@ export class CompileMetadataResolver {
    return compileProviders;
  }

-  private _validateProvider(provider: any): void {
-    if (provider.hasOwnProperty('useClass') && provider.useClass == null) {
-      this._reportError(new SyntaxError(
-          `Invalid provider for ${stringifyType(provider.provide)}. useClass cannot be ${provider.useClass}.
-           Usually it happens when:
-           1. There's a circular dependency (might be caused by using index.ts (barrel) files).
-           2. Class was used before it was declared. Use forwardRef in this case.`));
-    }
-  }
-
  private _getEntryComponentsFromProvider(provider: cpl.ProviderMeta, type?: any):
-      cpl.CompileEntryComponentMetadata[] {
-    const components: cpl.CompileEntryComponentMetadata[] = [];
+      cpl.CompileIdentifierMetadata[] {
+    const components: cpl.CompileIdentifierMetadata[] = [];
    const collectedIdentifiers: cpl.CompileIdentifierMetadata[] = [];

    if (provider.useFactory || provider.useExisting || provider.useClass) {
      this._reportError(
-          new SyntaxError(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports useValue!`), type);
+          new Error(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports useValue!`), type);
      return [];
    }

    if (!provider.multi) {
      this._reportError(
-          new SyntaxError(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports 'multi = true'!`),
-          type);
+          new Error(`The ANALYZE_FOR_ENTRY_COMPONENTS token only supports 'multi = true'!`), type);
      return [];
    }

    extractIdentifiers(provider.useValue, collectedIdentifiers);
    collectedIdentifiers.forEach((identifier) => {
-      const entry = this._getEntryComponentMetadata(identifier.reference);
-      if (entry) {
-        components.push(entry);
+      if (this._directiveResolver.isDirective(identifier.reference)) {
+        components.push(identifier);
      }
    });
    return components;
  }

-  private _getEntryComponentMetadata(dirType: any): cpl.CompileEntryComponentMetadata {
-    const dirMeta = this.getNonNormalizedDirectiveMetadata(dirType);
-    if (dirMeta) {
-      return {componentType: dirType, componentFactory: dirMeta.metadata.componentFactory};
-    } else {
-      const dirSummary =
-          <cpl.CompileDirectiveSummary>this._loadSummary(dirType, cpl.CompileSummaryKind.Directive);
-      if (dirSummary) {
-        return {componentType: dirType, componentFactory: dirSummary.componentFactory};
-      }
-    }
-  }
-
  getProviderMetadata(provider: cpl.ProviderMeta): cpl.CompileProviderMetadata {
    let compileDeps: cpl.CompileDiDependencyMetadata[];
    let compileTypeMetadata: cpl.CompileTypeMetadata = null;
@ -958,7 +819,7 @@ export class CompileMetadataResolver {
    let token: cpl.CompileTokenMetadata = this._getTokenMetadata(provider.token);

    if (provider.useClass) {
-      compileTypeMetadata = this._getInjectableMetadata(provider.useClass, provider.dependencies);
+      compileTypeMetadata = this._getTypeMetadata(provider.useClass, provider.dependencies);
      compileDeps = compileTypeMetadata.diDeps;
      if (provider.token === provider.useClass) {
        // use the compileTypeMetadata as it contains information about lifecycleHooks...
@ -1006,8 +867,8 @@ export class CompileMetadataResolver {
    } else {
      if (!q.selector) {
        this._reportError(
-            new SyntaxError(
-                `Can't construct a query for the property "${propertyName}" of "${stringifyType(typeOrFunc)}" since the query selector wasn't defined.`),
+            new Error(
+                `Can't construct a query for the property "${propertyName}" of "${stringify(typeOrFunc)}" since the query selector wasn't defined.`),
            typeOrFunc);
      }
      selectors = [this._getTokenMetadata(q.selector)];
@ -1074,8 +935,8 @@ export function componentModuleUrl(
    const scheme = getUrlScheme(moduleId);
    return scheme ? moduleId : `package:${moduleId}${MODULE_SUFFIX}`;
  } else if (moduleId !== null && moduleId !== void 0) {
-    throw new SyntaxError(
-        `moduleId should be a string in "${stringifyType(type)}". See https://goo.gl/wIDDiL for more information.\n` +
+    throw new Error(
+        `moduleId should be a string in "${stringify(type)}". See https://goo.gl/wIDDiL for more information.\n` +
        `If you're using Webpack you should inline the template and the styles, see https://goo.gl/X2J8zc.`);
  }

@ -1091,11 +952,3 @@ class _CompileValueConverter extends ValueTransformer {
    targetIdentifiers.push({reference: value});
  }
 }
-
-function stringifyType(type: any): string {
-  if (type instanceof StaticSymbol) {
-    return `${type.name} in ${type.filePath}`;
-  } else {
-    return stringify(type);
-  }
-}
--- a/modules/@angular/compiler/src/ml_parser/html_parser.ts
+++ b/modules/@angular/compiler/src/ml_parser/html_parser.ts
@ -6,7 +6,7 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {CompilerInjectable} from '../injectable';
+import {Injectable} from '@angular/core';

 import {getHtmlTagDefinition} from './html_tags';
 import {DEFAULT_INTERPOLATION_CONFIG, InterpolationConfig} from './interpolation_config';
@ -14,7 +14,7 @@ import {ParseTreeResult, Parser} from './parser';

 export {ParseTreeResult, TreeError} from './parser';

-@CompilerInjectable()
+@Injectable()
 export class HtmlParser extends Parser {
  constructor() { super(getHtmlTagDefinition); }

--- a/modules/@angular/compiler/src/ml_parser/icu_ast_expander.ts
+++ b/modules/@angular/compiler/src/ml_parser/icu_ast_expander.ts
@ -30,9 +30,9 @@ const PLURAL_CASES: string[] = ['zero', 'one', 'two', 'few', 'many', 'other'];
 *
 * ```
 * <ng-container [ngPlural]="messages.length">
- *   <template ngPluralCase="=0">zero</template>
- *   <template ngPluralCase="=1">one</template>
- *   <template ngPluralCase="other">more than one</template>
+ *   <template ngPluralCase="=0">zero</ng-container>
+ *   <template ngPluralCase="=1">one</ng-container>
+ *   <template ngPluralCase="other">more than one</ng-container>
 * </ng-container>
 * ```
 */
--- a/modules/@angular/compiler/src/ml_parser/lexer.ts
+++ b/modules/@angular/compiler/src/ml_parser/lexer.ts
@ -133,7 +133,7 @@ class _Tokenizer {
          } else {
            this._consumeTagOpen(start);
          }
-        } else if (!(this._tokenizeIcu && this._tokenizeExpansionForm())) {
+        } else if (!this._tokenizeIcu || !this._tokenizeExpansionForm()) {
          this._consumeText();
        }
      } catch (e) {
@ -586,8 +586,8 @@ class _Tokenizer {
        parts.push(this._interpolationConfig.start);
        this._inInterpolation = true;
      } else if (
-          this._interpolationConfig && this._inInterpolation &&
-          this._attemptStr(this._interpolationConfig.end)) {
+          this._interpolationConfig && this._attemptStr(this._interpolationConfig.end) &&
+          this._inInterpolation) {
        parts.push(this._interpolationConfig.end);
        this._inInterpolation = false;
      } else {
--- a/modules/@angular/compiler/src/ng_module_compiler.ts
+++ b/modules/@angular/compiler/src/ng_module_compiler.ts
@ -6,11 +6,12 @@
 * found in the LICENSE file at https://angular.io/license
 */

+import {Injectable} from '@angular/core';
+
 import {CompileDiDependencyMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompileProviderMetadata, CompileTokenMetadata, identifierModuleUrl, identifierName, tokenName, tokenReference} from './compile_metadata';
 import {createDiTokenExpression} from './compiler_util/identifier_util';
 import {isPresent} from './facade/lang';
 import {Identifiers, createIdentifier, createIdentifierToken, resolveIdentifier} from './identifiers';
-import {CompilerInjectable} from './injectable';
 import {ClassBuilder, createClassStmt} from './output/class_builder';
 import * as o from './output/output_ast';
 import {convertValueToOutputAst} from './output/value_util';
@ -19,12 +20,9 @@ import {LifecycleHooks} from './private_import_core';
 import {NgModuleProviderAnalyzer} from './provider_analyzer';
 import {ProviderAst} from './template_parser/template_ast';

-/**
- * This is currently not read, but will probably be used in the future.
- * We keep it as we already pass it through all the rigth places...
- */
 export class ComponentFactoryDependency {
-  constructor(public compType: any) {}
+  constructor(
+      public comp: CompileIdentifierMetadata, public placeholder: CompileIdentifierMetadata) {}
 }

 export class NgModuleCompileResult {
@ -33,7 +31,7 @@ export class NgModuleCompileResult {
      public dependencies: ComponentFactoryDependency[]) {}
 }

-@CompilerInjectable()
+@Injectable()
 export class NgModuleCompiler {
  compile(ngModuleMeta: CompileNgModuleMetadata, extraProviders: CompileProviderMetadata[]):
      NgModuleCompileResult {
@ -49,12 +47,13 @@ export class NgModuleCompiler {
    const bootstrapComponentFactories: CompileIdentifierMetadata[] = [];
    const entryComponentFactories =
        ngModuleMeta.transitiveModule.entryComponents.map((entryComponent) => {
+          const id: CompileIdentifierMetadata = {reference: null};
          if (ngModuleMeta.bootstrapComponents.some(
-                  (id) => id.reference === entryComponent.componentType)) {
-            bootstrapComponentFactories.push({reference: entryComponent.componentFactory});
+                  (id) => id.reference === entryComponent.reference)) {
+            bootstrapComponentFactories.push(id);
          }
-          deps.push(new ComponentFactoryDependency(entryComponent.componentType));
-          return {reference: entryComponent.componentFactory};
+          deps.push(new ComponentFactoryDependency(entryComponent, id));
+          return id;
        });
    const builder = new _InjectorBuilder(
        ngModuleMeta, entryComponentFactories, bootstrapComponentFactories, sourceSpan);
--- a/modules/@angular/compiler/src/ng_module_resolver.ts
+++ b/modules/@angular/compiler/src/ng_module_resolver.ts
@ -6,11 +6,10 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {NgModule, Type} from '@angular/core';
+import {Injectable, NgModule, Type} from '@angular/core';

 import {ListWrapper} from './facade/collection';
 import {isPresent, stringify} from './facade/lang';
-import {CompilerInjectable} from './injectable';
 import {ReflectorReader, reflector} from './private_import_core';

 function _isNgModuleMetadata(obj: any): obj is NgModule {
@ -20,7 +19,7 @@ function _isNgModuleMetadata(obj: any): obj is NgModule {
 /**
 * Resolves types to {@link NgModule}.
 */
-@CompilerInjectable()
+@Injectable()
 export class NgModuleResolver {
  constructor(private _reflector: ReflectorReader = reflector) {}

--- a/modules/@angular/compiler/src/output/js_emitter.ts
+++ b/modules/@angular/compiler/src/output/js_emitter.ts
@ -7,8 +7,7 @@
 */


-import {StaticSymbol} from '../aot/static_symbol';
-import {CompileIdentifierMetadata} from '../compile_metadata';
+import {identifierModuleUrl, identifierName} from '../compile_metadata';
 import {isBlank, isPresent} from '../facade/lang';

 import {EmitterVisitorContext, OutputEmitter} from './abstract_emitter';
@ -17,17 +16,17 @@ import * as o from './output_ast';
 import {ImportResolver} from './path_util';

 export class JavaScriptEmitter implements OutputEmitter {
-  constructor(private _importResolver: ImportResolver) {}
-  emitStatements(genFilePath: string, stmts: o.Statement[], exportedVars: string[]): string {
-    const converter = new JsEmitterVisitor(genFilePath, this._importResolver);
+  constructor(private _importGenerator: ImportResolver) {}
+  emitStatements(moduleUrl: string, stmts: o.Statement[], exportedVars: string[]): string {
+    const converter = new JsEmitterVisitor(moduleUrl);
    const ctx = EmitterVisitorContext.createRoot(exportedVars);
    converter.visitAllStatements(stmts, ctx);
    const srcParts: string[] = [];
-    converter.importsWithPrefixes.forEach((prefix, importedFilePath) => {
+    converter.importsWithPrefixes.forEach((prefix, importedModuleUrl) => {
      // Note: can't write the real word for import as it screws up system.js auto detection...
      srcParts.push(
          `var ${prefix} = req` +
-          `uire('${this._importResolver.fileNameToModuleName(importedFilePath, genFilePath)}');`);
+          `uire('${this._importGenerator.fileNameToModuleName(importedModuleUrl, moduleUrl)}');`);
    });
    srcParts.push(ctx.toSource());
    return srcParts.join('\n');
@ -37,23 +36,20 @@ export class JavaScriptEmitter implements OutputEmitter {
 class JsEmitterVisitor extends AbstractJsEmitterVisitor {
  importsWithPrefixes = new Map<string, string>();

-  constructor(private _genFilePath: string, private _importResolver: ImportResolver) { super(); }
-
-  private _resolveStaticSymbol(value: CompileIdentifierMetadata): StaticSymbol {
-    const reference = value.reference;
-    if (!(reference instanceof StaticSymbol)) {
-      throw new Error(`Internal error: unknown identifier ${JSON.stringify(value)}`);
-    }
-    return this._importResolver.getImportAs(reference) || reference;
-  }
+  constructor(private _moduleUrl: string) { super(); }

  visitExternalExpr(ast: o.ExternalExpr, ctx: EmitterVisitorContext): any {
-    const {name, filePath} = this._resolveStaticSymbol(ast.value);
-    if (filePath != this._genFilePath) {
-      let prefix = this.importsWithPrefixes.get(filePath);
+    const name = identifierName(ast.value);
+    const moduleUrl = identifierModuleUrl(ast.value);
+    if (isBlank(name)) {
+      console.error('>>>', ast.value);
+      throw new Error(`Internal error: unknown identifier ${ast.value}`);
+    }
+    if (isPresent(moduleUrl) && moduleUrl != this._moduleUrl) {
+      let prefix = this.importsWithPrefixes.get(moduleUrl);
      if (isBlank(prefix)) {
        prefix = `import${this.importsWithPrefixes.size}`;
-        this.importsWithPrefixes.set(filePath, prefix);
+        this.importsWithPrefixes.set(moduleUrl, prefix);
      }
      ctx.print(`${prefix}.`);
    }
--- a/modules/@angular/compiler/src/output/output_ast.ts
+++ b/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 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 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 interface TypeVisitor {
  visitBuiltintType(type: BuiltinType, context: any): any;
@ -451,12 +451,12 @@ export interface ExpressionVisitor {
  visitLiteralMapExpr(ast: LiteralMapExpr, context: any): any;
 }

-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);
+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);

 //// Statements
 export enum StmtModifier {
@ -894,10 +894,8 @@ export function literalArr(values: Expression[], type: Type = null): LiteralArra
  return new LiteralArrayExpr(values, 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 literalMap(values: [string, Expression][], type: MapType = null): LiteralMapExpr {
+  return new LiteralMapExpr(values.map(entry => new LiteralMapEntry(entry[0], entry[1])), type);
 }

 export function not(expr: Expression): NotExpr {
--- a/modules/@angular/compiler/src/output/path_util.ts
+++ b/modules/@angular/compiler/src/output/path_util.ts
@ -6,8 +6,6 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {StaticSymbol} from '../aot/static_symbol';
-
 /**
 * Interface that defines how import statements should be generated.
 */
@ -16,12 +14,5 @@ export abstract class ImportResolver {
   * Converts a file path to a module name that can be used as an `import.
   * I.e. `path/to/importedFile.ts` should be imported by `path/to/containingFile.ts`.
   */
-  abstract fileNameToModuleName(importedFilePath: string, containingFilePath: string): string
-      /*|null*/;
-
-  /**
-   * Converts the given StaticSymbol into another StaticSymbol that should be used
-   * to generate the import from.
-   */
-  abstract getImportAs(symbol: StaticSymbol): StaticSymbol /*|null*/;
+  abstract fileNameToModuleName(importedFilePath: string, containingFilePath: string): string;
 }
--- a/modules/@angular/compiler/src/output/ts_emitter.ts
+++ b/modules/@angular/compiler/src/output/ts_emitter.ts
@ -7,22 +7,18 @@
 */


-import {StaticSymbol} from '../aot/static_symbol';
-import {CompileIdentifierMetadata} from '../compile_metadata';
+import {CompileIdentifierMetadata, identifierModuleUrl, identifierName} from '../compile_metadata';
 import {isBlank, isPresent} from '../facade/lang';

 import {AbstractEmitterVisitor, CATCH_ERROR_VAR, CATCH_STACK_VAR, EmitterVisitorContext, OutputEmitter} from './abstract_emitter';
 import * as o from './output_ast';
 import {ImportResolver} from './path_util';

-const _debugFilePath = '/debug/lib';
+const _debugModuleUrl = '/debug/lib';

 export function debugOutputAstAsTypeScript(ast: o.Statement | o.Expression | o.Type | any[]):
    string {
-  const converter = new _TsEmitterVisitor(_debugFilePath, {
-    fileNameToModuleName(filePath: string, containingFilePath: string) { return filePath; },
-    getImportAs(symbol: StaticSymbol) { return null; }
-  });
+  const converter = new _TsEmitterVisitor(_debugModuleUrl);
  const ctx = EmitterVisitorContext.createRoot([]);
  const asts: any[] = Array.isArray(ast) ? ast : [ast];

@ -41,23 +37,17 @@ export function debugOutputAstAsTypeScript(ast: o.Statement | o.Expression | o.T
 }

 export class TypeScriptEmitter implements OutputEmitter {
-  constructor(private _importResolver: ImportResolver) {}
-  emitStatements(genFilePath: string, stmts: o.Statement[], exportedVars: string[]): string {
-    const converter = new _TsEmitterVisitor(genFilePath, this._importResolver);
+  constructor(private _importGenerator: ImportResolver) {}
+  emitStatements(moduleUrl: string, stmts: o.Statement[], exportedVars: string[]): string {
+    const converter = new _TsEmitterVisitor(moduleUrl);
    const ctx = EmitterVisitorContext.createRoot(exportedVars);
    converter.visitAllStatements(stmts, ctx);
    const srcParts: string[] = [];
-    converter.reexports.forEach((reexports, exportedFilePath) => {
-      const reexportsCode =
-          reexports.map(reexport => `${reexport.name} as ${reexport.as}`).join(',');
-      srcParts.push(
-          `export {${reexportsCode}} from '${this._importResolver.fileNameToModuleName(exportedFilePath, genFilePath)}';`);
-    });
-    converter.importsWithPrefixes.forEach((prefix, importedFilePath) => {
+    converter.importsWithPrefixes.forEach((prefix, importedModuleUrl) => {
      // Note: can't write the real word for import as it screws up system.js auto detection...
      srcParts.push(
          `imp` +
-          `ort * as ${prefix} from '${this._importResolver.fileNameToModuleName(importedFilePath, genFilePath)}';`);
+          `ort * as ${prefix} from '${this._importGenerator.fileNameToModuleName(importedModuleUrl, moduleUrl)}';`);
    });
    srcParts.push(ctx.toSource());
    return srcParts.join('\n');
@ -65,12 +55,9 @@ export class TypeScriptEmitter implements OutputEmitter {
 }

 class _TsEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisitor {
-  constructor(private _genFilePath: string, private _importResolver: ImportResolver) {
-    super(false);
-  }
+  constructor(private _moduleUrl: string) { super(false); }

  importsWithPrefixes = new Map<string, string>();
-  reexports = new Map<string, {name: string, as: string}[]>();

  visitType(t: o.Type, ctx: EmitterVisitorContext, defaultType: string = 'any') {
    if (isPresent(t)) {
@ -111,19 +98,6 @@ class _TsEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisitor
  }

  visitDeclareVarStmt(stmt: o.DeclareVarStmt, ctx: EmitterVisitorContext): any {
-    if (ctx.isExportedVar(stmt.name) && stmt.value instanceof o.ExternalExpr && !stmt.type) {
-      // check for a reexport
-      const {name, filePath, members} = this._resolveStaticSymbol(stmt.value.value);
-      if (members.length === 0 && filePath !== this._genFilePath) {
-        let reexports = this.reexports.get(filePath);
-        if (!reexports) {
-          reexports = [];
-          this.reexports.set(filePath, reexports);
-        }
-        reexports.push({name, as: stmt.name});
-        return null;
-      }
-    }
    if (ctx.isExportedVar(stmt.name)) {
      ctx.print(`export `);
    }
@ -346,29 +320,25 @@ class _TsEmitterVisitor extends AbstractEmitterVisitor implements o.TypeVisitor
    }, params, ctx, ',');
  }

-  private _resolveStaticSymbol(value: CompileIdentifierMetadata): StaticSymbol {
-    const reference = value.reference;
-    if (!(reference instanceof StaticSymbol)) {
-      throw new Error(`Internal error: unknown identifier ${JSON.stringify(value)}`);
-    }
-    return this._importResolver.getImportAs(reference) || reference;
-  }
-
  private _visitIdentifier(
      value: CompileIdentifierMetadata, typeParams: o.Type[], ctx: EmitterVisitorContext): void {
-    const {name, filePath, members} = this._resolveStaticSymbol(value);
-    if (filePath != this._genFilePath) {
-      let prefix = this.importsWithPrefixes.get(filePath);
+    const name = identifierName(value);
+    const moduleUrl = identifierModuleUrl(value);
+    if (isBlank(name)) {
+      throw new Error(`Internal error: unknown identifier ${value}`);
+    }
+    if (isPresent(moduleUrl) && moduleUrl != this._moduleUrl) {
+      let prefix = this.importsWithPrefixes.get(moduleUrl);
      if (isBlank(prefix)) {
        prefix = `import${this.importsWithPrefixes.size}`;
-        this.importsWithPrefixes.set(filePath, prefix);
+        this.importsWithPrefixes.set(moduleUrl, prefix);
      }
      ctx.print(`${prefix}.`);
    }
-    if (members.length) {
-      ctx.print(name);
+    if (value.reference && value.reference.members) {
+      ctx.print(value.reference.name);
      ctx.print('.');
-      ctx.print(members.join('.'));
+      ctx.print(value.reference.members.join('.'));
    } else {
      ctx.print(name);
    }
--- a/modules/@angular/compiler/src/pipe_resolver.ts
+++ b/modules/@angular/compiler/src/pipe_resolver.ts
@ -6,11 +6,10 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {Pipe, Type, resolveForwardRef} from '@angular/core';
+import {Injectable, Pipe, Type, resolveForwardRef} from '@angular/core';

 import {ListWrapper} from './facade/collection';
 import {isPresent, stringify} from './facade/lang';
-import {CompilerInjectable} from './injectable';
 import {ReflectorReader, reflector} from './private_import_core';

 function _isPipeMetadata(type: any): boolean {
@ -24,7 +23,7 @@ function _isPipeMetadata(type: any): boolean {
 *
 * See {@link Compiler}
 */
-@CompilerInjectable()
+@Injectable()
 export class PipeResolver {
  constructor(private _reflector: ReflectorReader = reflector) {}

--- a/modules/@angular/compiler/src/private_import_core.ts
+++ b/modules/@angular/compiler/src/private_import_core.ts
@ -32,6 +32,7 @@ export const view_utils: typeof r.view_utils = r.view_utils;
 export const DebugContext: typeof r.DebugContext = r.DebugContext;
 export const StaticNodeDebugInfo: typeof r.StaticNodeDebugInfo = r.StaticNodeDebugInfo;
 export const devModeEqual: typeof r.devModeEqual = r.devModeEqual;
+export const UNINITIALIZED: typeof r.UNINITIALIZED = r.UNINITIALIZED;
 export const ValueUnwrapper: typeof r.ValueUnwrapper = r.ValueUnwrapper;
 export const TemplateRef_: typeof r.TemplateRef_ = r.TemplateRef_;
 export type RenderDebugInfo = typeof r._RenderDebugInfo;
--- a/modules/@angular/compiler/src/schema/dom_element_schema_registry.ts
+++ b/modules/@angular/compiler/src/schema/dom_element_schema_registry.ts
@ -6,8 +6,7 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {AUTO_STYLE, CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA, SchemaMetadata, SecurityContext} from '@angular/core';
-import {CompilerInjectable} from '../injectable';
+import {AUTO_STYLE, CUSTOM_ELEMENTS_SCHEMA, Injectable, NO_ERRORS_SCHEMA, SchemaMetadata, SecurityContext} from '@angular/core';

 import {dashCaseToCamelCase} from '../util';

@ -239,7 +238,7 @@ const _ATTR_TO_PROP: {[name: string]: string} = {
  'tabindex': 'tabIndex',
 };

-@CompilerInjectable()
+@Injectable()
 export class DomElementSchemaRegistry extends ElementSchemaRegistry {
  private _schema: {[element: string]: {[property: string]: string}} = {};

--- a/modules/@angular/compiler/src/selector.ts
+++ b/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');

 /**
--- a/modules/@angular/compiler/src/style_compiler.ts
+++ b/modules/@angular/compiler/src/style_compiler.ts
@ -6,10 +6,9 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {ViewEncapsulation} from '@angular/core';
+import {Injectable, ViewEncapsulation} from '@angular/core';

 import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileStylesheetMetadata, identifierModuleUrl, identifierName} from './compile_metadata';
-import {CompilerInjectable} from './injectable';
 import * as o from './output/output_ast';
 import {ShadowCss} from './shadow_css';
 import {UrlResolver} from './url_resolver';
@ -37,7 +36,7 @@ export class CompiledStylesheet {
      public meta: CompileStylesheetMetadata) {}
 }

-@CompilerInjectable()
+@Injectable()
 export class StyleCompiler {
  private _shadowCss: ShadowCss = new ShadowCss();

--- a/modules/@angular/compiler/src/style_url_resolver.ts
+++ b/modules/@angular/compiler/src/style_url_resolver.ts
@ -9,6 +9,8 @@
 // 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 {
@ -16,8 +18,8 @@ export class StyleWithImports {
 }

 export function isStyleUrlResolvable(url: string): boolean {
-  if (url == null || url.length === 0 || url[0] == '/') return false;
-  const schemeMatch = url.match(URL_WITH_SCHEMA_REGEXP);
+  if (isBlank(url) || url.length === 0 || url[0] == '/') return false;
+  const schemeMatch = url.match(_urlWithSchemaRe);
  return schemeMatch === null || schemeMatch[1] == 'package' || schemeMatch[1] == 'asset';
 }

@ -28,20 +30,17 @@ export function isStyleUrlResolvable(url: string): boolean {
 export function extractStyleUrls(
    resolver: UrlResolver, baseUrl: string, cssText: string): StyleWithImports {
  const foundUrls: string[] = [];
-
-  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 '';
-      });
+  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 '';
+  });
  return new StyleWithImports(modifiedCssText, foundUrls);
 }

-const CSS_IMPORT_REGEXP = /@import\s+(?:url\()?\s*(?:(?:['"]([^'"]*))|([^;\)\s]*))[^;]*;?/g;
-const CSS_COMMENT_REGEXP = /\/\*.+?\*\//g;
-const URL_WITH_SCHEMA_REGEXP = /^([^:/?#]+):/;
+const _cssImportRe = /@import\s+(?:url\()?\s*(?:(?:['"]([^'"]*))|([^;\)\s]*))[^;]*;?/g;
+const _urlWithSchemaRe = /^([^:/?#]+):/;
--- a/modules/@angular/compiler/src/summary_resolver.ts
+++ b/modules/@angular/compiler/src/summary_resolver.ts
@ -5,20 +5,10 @@
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
+import {Injectable} from '@angular/core';
 import {CompileTypeSummary} from './compile_metadata';
-import {CompilerInjectable} from './injectable';

-export interface Summary<T> {
-  symbol: T;
-  metadata: any;
-  type?: CompileTypeSummary;
-}
-
-@CompilerInjectable()
-export class SummaryResolver<T> {
-  isLibraryFile(fileName: string): boolean { return false; };
-  getLibraryFileName(fileName: string): string { return null; }
-  resolveSummary(reference: T): Summary<T> { return null; };
-  getSymbolsOf(filePath: string): T[] { return []; }
-  getImportAs(reference: T): T { return reference; }
+@Injectable()
+export class SummaryResolver {
+  resolveSummary(reference: any): CompileTypeSummary { return null; }
 }
--- a/modules/@angular/compiler/src/template_parser/template_parser.ts
+++ b/modules/@angular/compiler/src/template_parser/template_parser.ts
@ -6,13 +6,13 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {Inject, OpaqueToken, Optional, SchemaMetadata} from '@angular/core';
+import {Inject, Injectable, OpaqueToken, Optional, SchemaMetadata} from '@angular/core';
+
 import {CompileDirectiveMetadata, CompileDirectiveSummary, CompilePipeSummary, CompileTemplateSummary, CompileTokenMetadata, CompileTypeMetadata, identifierName} from '../compile_metadata';
 import {Parser} from '../expression_parser/parser';
 import {isPresent} from '../facade/lang';
 import {I18NHtmlParser} from '../i18n/i18n_html_parser';
 import {Identifiers, createIdentifierToken, identifierToken} from '../identifiers';
-import {CompilerInjectable} from '../injectable';
 import * as html from '../ml_parser/ast';
 import {ParseTreeResult} from '../ml_parser/html_parser';
 import {expandNodes} from '../ml_parser/icu_ast_expander';
@ -24,7 +24,7 @@ import {ProviderElementContext, ProviderViewContext} from '../provider_analyzer'
 import {ElementSchemaRegistry} from '../schema/element_schema_registry';
 import {CssSelector, SelectorMatcher} from '../selector';
 import {isStyleUrlResolvable} from '../style_url_resolver';
-import {SyntaxError} from '../util';
+
 import {BindingParser, BoundProperty} from './binding_parser';
 import {AttrAst, BoundDirectivePropertyAst, BoundElementPropertyAst, BoundEventAst, BoundTextAst, DirectiveAst, ElementAst, EmbeddedTemplateAst, NgContentAst, PropertyBindingType, ReferenceAst, TemplateAst, TemplateAstVisitor, TextAst, VariableAst, templateVisitAll} from './template_ast';
 import {PreparsedElementType, preparseElement} from './template_preparser';
@ -79,7 +79,7 @@ export class TemplateParseResult {
  constructor(public templateAst?: TemplateAst[], public errors?: ParseError[]) {}
 }

-@CompilerInjectable()
+@Injectable()
 export class TemplateParser {
  constructor(
      private _exprParser: Parser, private _schemaRegistry: ElementSchemaRegistry,
@ -99,7 +99,7 @@ export class TemplateParser {

    if (errors.length > 0) {
      const errorString = errors.join('\n');
-      throw new SyntaxError(`Template parse errors:\n${errorString}`);
+      throw new Error(`Template parse errors:\n${errorString}`);
    }

    return result.templateAst;
@ -149,7 +149,7 @@ export class TemplateParser {
      return new TemplateParseResult(result, errors);
    }

-    if (this.transforms) {
+    if (isPresent(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 (expr) {
+    if (isPresent(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, string][] = [];
+    const matchableAttrs: string[][] = [];
    const elementOrDirectiveProps: BoundProperty[] = [];
    const elementOrDirectiveRefs: ElementOrDirectiveRef[] = [];
    const elementVars: VariableAst[] = [];
    const events: BoundEventAst[] = [];

    const templateElementOrDirectiveProps: BoundProperty[] = [];
-    const templateMatchableAttrs: [string, string][] = [];
+    const templateMatchableAttrs: string[][] = [];
    const templateElementVars: VariableAst[] = [];

    let hasInlineTemplates = false;
@ -268,17 +268,14 @@ class TemplateParseVisitor implements html.Visitor {
          isTemplateElement, attr, matchableAttrs, elementOrDirectiveProps, events,
          elementOrDirectiveRefs, elementVars);

-      let templateBindingsSource: string|undefined;
-      let prefixToken: string|undefined;
-      let normalizedName = this._normalizeAttributeName(attr.name);
-
-      if (normalizedName == TEMPLATE_ATTR) {
+      let templateBindingsSource: string|undefined = undefined;
+      let prefixToken: string|undefined = undefined;
+      if (this._normalizeAttributeName(attr.name) == TEMPLATE_ATTR) {
        templateBindingsSource = attr.value;
-      } else if (normalizedName.startsWith(TEMPLATE_ATTR_PREFIX)) {
+      } else if (attr.name.startsWith(TEMPLATE_ATTR_PREFIX)) {
        templateBindingsSource = attr.value;
-        prefixToken = normalizedName.substring(TEMPLATE_ATTR_PREFIX.length);
+        prefixToken = attr.name.substring(TEMPLATE_ATTR_PREFIX.length);  // remove the star
      }
-
      const hasTemplateBinding = isPresent(templateBindingsSource);
      if (hasTemplateBinding) {
        if (hasInlineTemplates) {
@ -544,12 +541,10 @@ 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;
      }
@ -572,7 +567,6 @@ 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)) {
@ -587,7 +581,7 @@ class TemplateParseVisitor implements html.Visitor {
        }
        targetReferences.push(new ReferenceAst(elOrDirRef.name, refToken, elOrDirRef.sourceSpan));
      }
-    });
+    });  // fix syntax highlighting issue: `
    return directiveAsts;
  }

@ -748,7 +742,7 @@ class NonBindableVisitor implements html.Visitor {
      return null;
    }

-    const attrNameAndValues = ast.attrs.map((attr): [string, string] => [attr.name, attr.value]);
+    const attrNameAndValues = ast.attrs.map(attrAst => [attrAst.name, attrAst.value]);
    const selector = createElementCssSelector(ast.name, attrNameAndValues);
    const ngContentIndex = parent.findNgContentIndex(selector);
    const children = html.visitAll(this, ast.children, EMPTY_ELEMENT_CONTEXT);
@ -817,16 +811,16 @@ class ElementContext {
 }

 export function createElementCssSelector(
-    elementName: string, attributes: [string, string][]): CssSelector {
+    elementName: string, matchableAttrs: string[][]): CssSelector {
  const cssSelector = new CssSelector();
  const elNameNoNs = splitNsName(elementName)[1];

  cssSelector.setElement(elNameNoNs);

-  for (let i = 0; i < attributes.length; i++) {
-    const attrName = attributes[i][0];
+  for (let i = 0; i < matchableAttrs.length; i++) {
+    const attrName = matchableAttrs[i][0];
    const attrNameNoNs = splitNsName(attrName)[1];
-    const attrValue = attributes[i][1];
+    const attrValue = matchableAttrs[i][1];

    cssSelector.addAttribute(attrNameNoNs, attrValue);
    if (attrName.toLowerCase() == CLASS_ATTR) {
--- a/modules/@angular/compiler/src/url_resolver.ts
+++ b/modules/@angular/compiler/src/url_resolver.ts
@ -6,11 +6,9 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {Inject, PACKAGE_ROOT_URL} from '@angular/core';
+import {Inject, Injectable, PACKAGE_ROOT_URL} from '@angular/core';

 import {isBlank, isPresent} from './facade/lang';
-import {CompilerInjectable} from './injectable';
-

 /**
 * Create a {@link UrlResolver} with no package prefix.
@ -26,7 +24,7 @@ export function createOfflineCompileUrlResolver(): UrlResolver {
 /**
 * A default provider for {@link PACKAGE_ROOT_URL} that maps to '/'.
 */
-export const DEFAULT_PACKAGE_URL_PROVIDER = {
+export var DEFAULT_PACKAGE_URL_PROVIDER = {
  provide: PACKAGE_ROOT_URL,
  useValue: '/'
 };
@ -47,7 +45,7 @@ export const DEFAULT_PACKAGE_URL_PROVIDER = {
 * Attacker-controlled data introduced by a template could expose your
 * application to XSS risks. For more detail, see the [Security Guide](http://g.co/ng/security).
 */
-@CompilerInjectable()
+@Injectable()
 export class UrlResolver {
  constructor(@Inject(PACKAGE_ROOT_URL) private _packagePrefix: string = null) {}

--- a/modules/@angular/compiler/src/util.ts
+++ b/modules/@angular/compiler/src/util.ts
@ -6,8 +6,8 @@
 * found in the LICENSE file at https://angular.io/license
 */

-import {BaseError} from './facade/errors';
 import {isPrimitive, isStrictStringMap} from './facade/lang';
+
 export const MODULE_SUFFIX = '';

 const CAMEL_CASE_REGEXP = /([A-Z])/g;
@ -78,5 +78,3 @@ export class SyncAsyncResult<T> {
    }
  }
 }
-
-export class SyntaxError extends BaseError {}
--- a/modules/@angular/compiler/src/view_compiler/compile_element.ts
+++ b/modules/@angular/compiler/src/view_compiler/compile_element.ts
@ -97,11 +97,12 @@ export class CompileElement extends CompileNode {
  }

  private _createComponentFactoryResolver() {
-    const entryComponents = this.component.entryComponents.map((entryComponent) => {
-      this.view.targetDependencies.push(
-          new ComponentFactoryDependency(entryComponent.componentType));
-      return {reference: entryComponent.componentFactory};
-    });
+    const entryComponents =
+        this.component.entryComponents.map((entryComponent: CompileIdentifierMetadata) => {
+          const id: CompileIdentifierMetadata = {reference: null};
+          this.view.targetDependencies.push(new ComponentFactoryDependency(entryComponent, id));
+          return id;
+        });
    if (!entryComponents || entryComponents.length === 0) {
      return;
    }
@ -178,11 +179,11 @@ export class CompileElement extends CompileNode {
          const depsExpr =
              deps.map((dep) => this._getDependency(resolvedProvider.providerType, dep));
          if (isDirectiveWrapper) {
-            const dirMeta =
-                this._directives.find(dir => dir.type.reference === provider.useClass.reference);
-            this.view.targetDependencies.push(
-                new DirectiveWrapperDependency(dirMeta.type.reference));
-            return DirectiveWrapperExpressions.create({reference: dirMeta.wrapperType}, depsExpr);
+            const directiveWrapperIdentifier: CompileIdentifierMetadata = {reference: null};
+            this.view.targetDependencies.push(new DirectiveWrapperDependency(
+                provider.useClass, DirectiveWrapperCompiler.dirWrapperClassName(provider.useClass),
+                directiveWrapperIdentifier));
+            return DirectiveWrapperExpressions.create(directiveWrapperIdentifier, depsExpr);
          } else {
            return o.importExpr(provider.useClass)
                .instantiate(depsExpr, o.importType(provider.useClass));
@ -210,7 +211,12 @@ 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;
@ -220,6 +226,27 @@ 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);
+      }
    });
  }

@ -238,14 +265,12 @@ 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.generateStatements(
-                    this.view.createMethod, this.view.updateContentQueriesMethod)));
+                q =>
+                    q.afterChildren(this.view.createMethod, this.view.updateContentQueriesMethod)));
  }

  addContentNode(ngContentIndex: number, nodeExpr: CompileViewRootNode) {
@ -258,11 +283,12 @@ export class CompileElement extends CompileNode {
        null;
  }

-  getProviderTokens(): CompileTokenMetadata[] {
-    return Array.from(this._resolvedProviders.values()).map(provider => provider.token);
+  getProviderTokens(): o.Expression[] {
+    return Array.from(this._resolvedProviders.values())
+        .map((resolvedProvider) => createDiTokenExpression(resolvedProvider.token));
  }

-  getQueriesFor(token: CompileTokenMetadata): CompileQuery[] {
+  private _getQueriesFor(token: CompileTokenMetadata): CompileQuery[] {
    const result: CompileQuery[] = [];
    let currentEl: CompileElement = this;
    let distance = 0;
@ -400,3 +426,10 @@ 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;
+  }
+}
--- a/modules/@angular/compiler/src/view_compiler/compile_query.ts
+++ b/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);
  }

-  generateStatements(targetStaticMethod: CompileMethod, targetDynamicMethod: CompileMethod) {
+  afterChildren(targetStaticMethod: CompileMethod, targetDynamicMethod: CompileMethod) {
    const values = createQueryValues(this._values);
    const updateStmts = [this.queryList.callMethod('reset', [o.literalArr(values)]).toStmt()];
    if (isPresent(this.ownerDirectiveExpression)) {
--- a/modules/@angular/compiler/src/view_compiler/compile_view.ts
+++ b/modules/@angular/compiler/src/view_compiler/compile_view.ts
@ -7,8 +7,9 @@
 */

 import {AnimationEntryCompileResult} from '../animation/animation_compiler';
-import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompilePipeSummary, tokenName, viewClassName} from '../compile_metadata';
+import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompilePipeSummary, tokenName} from '../compile_metadata';
 import {EventHandlerVars, NameResolver} from '../compiler_util/expression_converter';
+import {createPureProxy} from '../compiler_util/identifier_util';
 import {CompilerConfig} from '../config';
 import {isPresent} from '../facade/lang';
 import {Identifiers, createIdentifier} from '../identifiers';
@ -19,8 +20,8 @@ import {CompileElement, CompileNode} from './compile_element';
 import {CompileMethod} from './compile_method';
 import {CompilePipe} from './compile_pipe';
 import {CompileQuery, addQueryToTokenMap, createQueryList} from './compile_query';
-import {ComponentFactoryDependency, ComponentViewDependency, DirectiveWrapperDependency} from './deps';
-import {getPropertyInView} from './util';
+import {ComponentFactoryDependency, DirectiveWrapperDependency, ViewClassDependency} from './deps';
+import {getPropertyInView, getViewClassName} from './util';

 export enum CompileViewRootNodeType {
  Node,
@ -86,7 +87,7 @@ export class CompileView implements NameResolver {
      public animations: AnimationEntryCompileResult[], public viewIndex: number,
      public declarationElement: CompileElement, public templateVariableBindings: string[][],
      public targetDependencies:
-          Array<ComponentViewDependency|ComponentFactoryDependency|DirectiveWrapperDependency>) {
+          Array<ViewClassDependency|ComponentFactoryDependency|DirectiveWrapperDependency>) {
    this.createMethod = new CompileMethod(this);
    this.animationBindingsMethod = new CompileMethod(this);
    this.injectorGetMethod = new CompileMethod(this);
@ -102,7 +103,7 @@ export class CompileView implements NameResolver {
    this.detachMethod = new CompileMethod(this);

    this.viewType = getViewType(component, viewIndex);
-    this.className = viewClassName(component.type.reference, viewIndex);
+    this.className = getViewClassName(component, viewIndex);
    this.classType = o.expressionType(o.variable(this.className));
    this.classExpr = o.variable(this.className);
    if (this.viewType === ViewType.COMPONENT || this.viewType === ViewType.HOST) {
@ -153,11 +154,11 @@ export class CompileView implements NameResolver {
    }
  }

-  finish() {
+  afterNodes() {
    Array.from(this.viewQueries.values())
        .forEach(
            queries => queries.forEach(
-                q => q.generateStatements(this.createMethod, this.updateViewQueriesMethod)));
+                q => q.afterChildren(this.createMethod, this.updateViewQueriesMethod)));
  }
 }

--- a/modules/@angular/compiler/src/view_compiler/constants.ts
+++ b/modules/@angular/compiler/src/view_compiler/constants.ts
@ -47,7 +47,6 @@ export class ViewConstructorVars {
 export class ViewProperties {
  static renderer = o.THIS_EXPR.prop('renderer');
  static viewUtils = o.THIS_EXPR.prop('viewUtils');
-  static throwOnChange = o.THIS_EXPR.prop('throwOnChange');
 }

 export class InjectMethodVars {
@ -55,3 +54,9 @@ export class InjectMethodVars {
  static requestNodeIndex = o.variable('requestNodeIndex');
  static notFoundResult = o.variable('notFoundResult');
 }
+
+export class DetectChangesVars {
+  static throwOnChange = o.variable(`throwOnChange`);
+  static changes = o.variable(`changes`);
+  static changed = o.variable(`changed`);
+}
--- a/modules/@angular/compiler/src/view_compiler/deps.ts
+++ b/modules/@angular/compiler/src/view_compiler/deps.ts
@ -8,26 +8,19 @@

 import {CompileIdentifierMetadata} from '../compile_metadata';

-/**
- * This is currently not read, but will probably be used in the future.
- * We keep it as we already pass it through all the rigth places...
- */
-export class ComponentViewDependency {
-  constructor(public compType: any) {}
+export class ViewClassDependency {
+  constructor(
+      public comp: CompileIdentifierMetadata, public name: string,
+      public placeholder: CompileIdentifierMetadata) {}
 }

-/**
- * This is currently not read, but will probably be used in the future.
- * We keep it as we already pass it through all the rigth places...
- */
 export class ComponentFactoryDependency {
-  constructor(public compType: any) {}
+  constructor(
+      public comp: CompileIdentifierMetadata, public placeholder: CompileIdentifierMetadata) {}
 }

-/**
- * This is currently not read, but will probably be used in the future.
- * We keep it as we already pass it through all the rigth places...
- */
 export class DirectiveWrapperDependency {
-  constructor(public dirType: any) {}
+  constructor(
+      public dir: CompileIdentifierMetadata, public name: string,
+      public placeholder: CompileIdentifierMetadata) {}
 }
--- a/modules/@angular/compiler/src/view_compiler/event_binder.ts
+++ b/modules/@angular/compiler/src/view_compiler/event_binder.ts
@ -133,4 +133,4 @@ type EventSummary = {
  name: string,
  target: string,
  phase: string
-};
+}
--- a/modules/@angular/compiler/src/view_compiler/lifecycle_binder.ts
+++ b/modules/@angular/compiler/src/view_compiler/lifecycle_binder.ts
@ -7,7 +7,6 @@
 */

 import {CompileDirectiveSummary, CompilePipeSummary} from '../compile_metadata';
-import {isFirstViewCheck} from '../compiler_util/binding_util';
 import {DirectiveWrapperExpressions} from '../directive_wrapper_compiler';
 import * as o from '../output/output_ast';
 import {LifecycleHooks} from '../private_import_core';
@ -15,6 +14,10 @@ import {DirectiveAst, ProviderAst, ProviderAstType} from '../template_parser/tem

 import {CompileElement} from './compile_element';
 import {CompileView} from './compile_view';
+import {DetectChangesVars} from './constants';
+
+const STATE_IS_NEVER_CHECKED = o.THIS_EXPR.prop('numberOfChecks').identical(new o.LiteralExpr(0));
+const NOT_THROW_ON_CHANGES = o.not(DetectChangesVars.throwOnChange);

 export function bindDirectiveAfterContentLifecycleCallbacks(
    directiveMeta: CompileDirectiveSummary, directiveInstance: o.Expression,
@ -26,8 +29,7 @@ export function bindDirectiveAfterContentLifecycleCallbacks(
      compileElement.nodeIndex, compileElement.sourceAst);
  if (lifecycleHooks.indexOf(LifecycleHooks.AfterContentInit) !== -1) {
    afterContentLifecycleCallbacksMethod.addStmt(new o.IfStmt(
-        isFirstViewCheck(o.THIS_EXPR),
-        [directiveInstance.callMethod('ngAfterContentInit', []).toStmt()]));
+        STATE_IS_NEVER_CHECKED, [directiveInstance.callMethod('ngAfterContentInit', []).toStmt()]));
  }
  if (lifecycleHooks.indexOf(LifecycleHooks.AfterContentChecked) !== -1) {
    afterContentLifecycleCallbacksMethod.addStmt(
@ -45,8 +47,7 @@ export function bindDirectiveAfterViewLifecycleCallbacks(
      compileElement.nodeIndex, compileElement.sourceAst);
  if (lifecycleHooks.indexOf(LifecycleHooks.AfterViewInit) !== -1) {
    afterViewLifecycleCallbacksMethod.addStmt(new o.IfStmt(
-        isFirstViewCheck(o.THIS_EXPR),
-        [directiveInstance.callMethod('ngAfterViewInit', []).toStmt()]));
+        STATE_IS_NEVER_CHECKED, [directiveInstance.callMethod('ngAfterViewInit', []).toStmt()]));
  }
  if (lifecycleHooks.indexOf(LifecycleHooks.AfterViewChecked) !== -1) {
    afterViewLifecycleCallbacksMethod.addStmt(
--- a/modules/@angular/compiler/src/view_compiler/property_binder.ts
+++ b/modules/@angular/compiler/src/view_compiler/property_binder.ts
@ -8,19 +8,19 @@

 import {SecurityContext} from '@angular/core';

-import {createCheckBindingField} from '../compiler_util/binding_util';
+import {createCheckBindingField, createCheckBindingStmt} from '../compiler_util/binding_util';
 import {ConvertPropertyBindingResult, convertPropertyBinding} from '../compiler_util/expression_converter';
 import {createEnumExpression} from '../compiler_util/identifier_util';
-import {createCheckAnimationBindingStmts, createCheckRenderBindingStmt} from '../compiler_util/render_util';
+import {triggerAnimation, writeToRenderer} from '../compiler_util/render_util';
 import {DirectiveWrapperExpressions} from '../directive_wrapper_compiler';
 import {Identifiers, createIdentifier} from '../identifiers';
 import * as o from '../output/output_ast';
 import {isDefaultChangeDetectionStrategy} from '../private_import_core';
 import {ElementSchemaRegistry} from '../schema/element_schema_registry';
 import {BoundElementPropertyAst, BoundEventAst, BoundTextAst, DirectiveAst, PropertyBindingType} from '../template_parser/template_ast';
-
 import {CompileElement, CompileNode} from './compile_element';
 import {CompileView} from './compile_view';
+import {DetectChangesVars} from './constants';
 import {getHandleEventMethodName} from './util';

 export function bindRenderText(
@ -33,15 +33,11 @@ export function bindRenderText(
  }

  view.detectChangesRenderPropertiesMethod.resetDebugInfo(compileNode.nodeIndex, boundText);
-  view.detectChangesRenderPropertiesMethod.addStmts(evalResult.stmts);
-  view.detectChangesRenderPropertiesMethod.addStmt(
-      o.importExpr(createIdentifier(Identifiers.checkRenderText))
-          .callFn([
-            o.THIS_EXPR, compileNode.renderNode, valueField.expression,
-            valueField.expression.set(evalResult.currValExpr),
-            evalResult.forceUpdate || o.literal(false)
-          ])
-          .toStmt());
+  view.detectChangesRenderPropertiesMethod.addStmts(createCheckBindingStmt(
+      evalResult, valueField.expression, DetectChangesVars.throwOnChange,
+      [o.THIS_EXPR.prop('renderer')
+           .callMethod('setText', [compileNode.renderNode, evalResult.currValExpr])
+           .toStmt()]));
 }

 export function bindRenderInputs(
@ -58,27 +54,31 @@ export function bindRenderInputs(
    if (!evalResult) {
      return;
    }
+    const checkBindingStmts: o.Statement[] = [];
    let compileMethod = view.detectChangesRenderPropertiesMethod;
    switch (boundProp.type) {
      case PropertyBindingType.Property:
      case PropertyBindingType.Attribute:
      case PropertyBindingType.Class:
      case PropertyBindingType.Style:
-        compileMethod.addStmts(createCheckRenderBindingStmt(
-            o.THIS_EXPR, renderNode, boundProp, bindingField.expression, evalResult));
+        checkBindingStmts.push(...writeToRenderer(
+            o.THIS_EXPR, boundProp, renderNode, evalResult.currValExpr,
+            view.genConfig.logBindingUpdate));
        break;
      case PropertyBindingType.Animation:
        compileMethod = view.animationBindingsMethod;
-        const {checkUpdateStmts, checkDetachStmts} = createCheckAnimationBindingStmts(
+        const {updateStmts, detachStmts} = triggerAnimation(
            o.THIS_EXPR, o.THIS_EXPR, boundProp, boundOutputs,
            (hasEvents ? o.THIS_EXPR.prop(getHandleEventMethodName(compileElement.nodeIndex)) :
                         o.importExpr(createIdentifier(Identifiers.noop)))
                .callMethod(o.BuiltinMethod.Bind, [o.THIS_EXPR]),
-            compileElement.renderNode, bindingField.expression, evalResult);
-        view.detachMethod.addStmts(checkDetachStmts);
-        compileMethod.addStmts(checkUpdateStmts);
+            compileElement.renderNode, evalResult.currValExpr, bindingField.expression);
+        checkBindingStmts.push(...updateStmts);
+        view.detachMethod.addStmts(detachStmts);
        break;
    }
+    compileMethod.addStmts(createCheckBindingStmt(
+        evalResult, bindingField.expression, DetectChangesVars.throwOnChange, checkBindingStmts));
  });
 }

@ -108,7 +108,7 @@ export function bindDirectiveHostProps(
      DirectiveWrapperExpressions.checkHost(
          directiveAst.hostProperties, directiveWrapperInstance, o.THIS_EXPR,
          compileElement.compViewExpr || o.THIS_EXPR, compileElement.renderNode,
-          runtimeSecurityCtxExprs));
+          DetectChangesVars.throwOnChange, runtimeSecurityCtxExprs));
 }

 export function bindDirectiveInputs(
@ -132,13 +132,17 @@ export function bindDirectiveInputs(
        directiveWrapperInstance
            .callMethod(
                `check_${input.directiveName}`,
-                [o.THIS_EXPR, evalResult.currValExpr, evalResult.forceUpdate || o.literal(false)])
+                [
+                  evalResult.currValExpr, DetectChangesVars.throwOnChange,
+                  evalResult.forceUpdate || o.literal(false)
+                ])
            .toStmt());
  });
  const isOnPushComp = directiveAst.directive.isComponent &&
      !isDefaultChangeDetectionStrategy(directiveAst.directive.changeDetection);
  const directiveDetectChangesExpr = DirectiveWrapperExpressions.ngDoCheck(
-      directiveWrapperInstance, o.THIS_EXPR, compileElement.renderNode);
+      directiveWrapperInstance, o.THIS_EXPR, compileElement.renderNode,
+      DetectChangesVars.throwOnChange);
  const directiveDetectChangesStmt = isOnPushComp ?
      new o.IfStmt(
          directiveDetectChangesExpr,
--- a/modules/@angular/compiler/src/view_compiler/query_binder.ts
+++ b/modules/@angular/compiler/src/view_compiler/query_binder.ts
@ -1,55 +0,0 @@
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-
-import {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;
-  }
-}
--- a/modules/@angular/compiler/src/view_compiler/util.ts
+++ b/modules/@angular/compiler/src/view_compiler/util.ts
@ -71,6 +71,12 @@ export function injectFromViewParentInjector(
  return viewExpr.callMethod('injectorGet', args);
 }

+export function getViewClassName(
+    component: CompileDirectiveSummary | CompileDirectiveMetadata,
+    embeddedTemplateIndex: number): string {
+  return `View_${identifierName(component.type)}${embeddedTemplateIndex}`;
+}
+
 export function getHandleEventMethodName(elementIndex: number): string {
  return `handleEvent_${elementIndex}`;
 }
--- a/modules/@angular/compiler/src/view_compiler/view_binder.ts
+++ b/modules/@angular/compiler/src/view_compiler/view_binder.ts
@ -15,7 +15,6 @@ 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 {
@ -44,7 +43,6 @@ 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) => {
@ -77,7 +75,6 @@ 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);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Victor Berchet	540b1197a6	fix(form): fix merge errors	2016-12-14 18:22:03 -08:00
Victor Berchet	d30cc8461b	docs(changelog): add changelog for 2.3.1	2016-12-14 18:14:34 -08:00
Victor Berchet	f27954e62c	build: bump angular to 2.3.1 & tsc-wrapped to 0.5.0	2016-12-14 18:11:35 -08:00
Victor Berchet	69b52eb2b3	fix(compiler): fix merge error in compiler_host	2016-12-14 18:08:54 -08:00
Chuck Jazdzewski	b9b557cdb0	fix(compiler): update to metadata version 3 (#13464 ) This change retracts support for metadata version 2. The collector used to produce version 2 metadata was incomplete and can cause the AOT compiler to fail to resolve symbols or produce other spurious errors. All libraries compiled and published with 2.3.0 ngc will need to be recompiled and updated with this change.	2016-12-14 18:08:48 -08:00
Victor Berchet	a72a002a8d	refactor: format & lint	2016-12-14 18:08:43 -08:00
Matias Niemelä	a0437f8c9d	chore(animations/aot): always export NoOpAnimationDriver (#13480 )	2016-12-14 18:08:36 -08:00
Victor Berchet	1c279b3264	fix(compiler): fix simplify a reference without a name closes #13470	2016-12-14 18:08:32 -08:00
Victor Berchet	cd03c77364	fix(tsc-wrapped): generate metadata for exports without module specifier fixes #13327	2016-12-14 18:08:29 -08:00
Victor Berchet	f6ef7d6e5a	fix(compiler): propagate exports when upgrading metadata to v2	2016-12-14 18:08:25 -08:00
Alex Rickabaugh	6aeaca3fb4	fix(compiler): resolver should merge host bindings and listeners (#13474 ) fixes #13327	2016-12-14 18:07:41 -08:00
Peter Bacon Darwin	af62050729	docs(upgrade): fix UpgradeAdapter examples closes #12675	2016-12-14 18:02:26 -08:00
Peter Bacon Darwin	cb69656b56	docs(upgrade/upgrade_adapter): fix up references to AngularJS and Angular 2	2016-12-14 18:02:14 -08:00
Eudes Petonnet-Vincent	2fc0560988	feat(upgrade): enable Angular 1 unit testing of upgrade module - New method `UpgradeAdapter.registerForNg1Tests(modules)` declares the Angular 1 upgrade module and provides it to the `angular.mock.module()` helper. This prevents the need to bootstrap the entire hybrid for every test. Closes #5462, #12675	2016-12-14 18:02:05 -08:00
Eudes Petonnet-Vincent	86c50983d7	fix(upgrade): fix downgrade content projection and injector inheritance - Full support for content projection in downgraded Angular 2 components. In particular, this enables multi-slot projection and other features on <ng-content>. - Correctly wire up hierarchical injectors for downgraded Angular 2 components: downgraded components inherit the injector of the first other downgraded Angular 2 component they find up the DOM tree. Closes #6629, #7727, #8729, #9643, #9649, #12675	2016-12-14 17:56:20 -08:00
Peter Bacon Darwin	21976446e0	refactor(upgrade/upgrade_adapter): use `Deferred` helper Making Angular 1's `$compile` asynchronous by chaining injector promises in linking functions can cause flickering views in applications.	2016-12-14 17:56:16 -08:00
Peter Bacon Darwin	998ce9ad7e	refactor(upgrade/util): remove unused `stringify()` method	2016-12-14 17:56:11 -08:00
Peter Bacon Darwin	111523677c	refactor(compiler/template_parser): export `createElementCssSelector` This is needed in `ngUpgrade`.	2016-12-14 17:56:06 -08:00
Peter Bacon Darwin	2d74a224d0	refactor(upgrade): add missing Angular 1 type info	2016-12-14 17:55:56 -08:00
Miško Hevery	4d6ac9d414	fix(core): detectChanges() doesn't work on detached instance Closes #13426 Closes #13472	2016-12-14 17:55:38 -08:00
Matias Niemelä	6557bc34f6	fix(animations): throw errors and normalize offset beyond the range of [0,1] Closes #13348 Closes #13440	2016-12-14 17:55:34 -08:00
Matias Niemelä	e2622add07	perf(animations): always run the animation queue outside of zones Related #12732 Closes #13440	2016-12-14 17:55:27 -08:00
Chuck Jazdzewski	ecfad467a1	fix(compiler): emit quoted object literal keys if the source is quoted feat(tsc-wrapped): recored when to quote a object literal key Collecting quoted literals is off by default as it introduces a breaking change in the .metadata.json file. A follow-up commit will address this. Fixes #13249 Closes #13356	2016-12-14 17:55:22 -08:00
Victor Berchet	5918133784	Revert "fix(compiler): xmb `<ph>` tags should not self close (#13413 )" This reverts commit `4b3d135193`. closes #13463	2016-12-14 17:55:18 -08:00
Victor Berchet	700bce9ec1	Revert "test(i18n): fix a typo in the reference xmb (#13441 )" This reverts commit `a8d237581d`.	2016-12-14 17:55:14 -08:00
Bradford C. Smith	a64a35a8c1	refactor(facade): don't expect super() to return a new Error object in BaseError (#12600 ) Related to #12575	2016-12-14 17:55:10 -08:00
gary-b	b3dcff0cc1	fix(forms): ensure select[multiple] retains selections If you bound an array to select[multiple] via ngModel and subsequently changed the options to select from, the UI would drop any selections made since by the user. This was due to SelectMultipleControlValueAccessor not keeping a reference to the new model arrays it generated when users interacted with the select control. Update code to keep the reference. Closes #12527 Closes #12654	2016-12-14 17:55:02 -08:00
Dzmitry Shylovich	124267c87a	fix(forms): introduce checkbox required validator Closes #11459 Closes #13364	2016-12-14 17:52:53 -08:00
gary-b	547bfa92ef	fix (forms): clear selected options when model is not an array (#12519 ) When an invalid model value (eg empty string) was preset ngModel on select[multiple] would throw an error, which is inconsistent with how it works on other user input elements. Setting the model value to null or undefined would also have no effect on what was already selected in the UI. Fix this by clearing selected options when model set to null, undefined or a type other than Array. Closes #11926	2016-12-14 17:52:02 -08:00
Pawel Kozlowski	d40bbf4d5c	fix(core): properly destroy embedded Views attatched to ApplicationRef (#13459 ) Fixes #13062	2016-12-14 17:51:56 -08:00
Victor Berchet	94b7031fe9	refactor: format & lint	2016-12-14 17:51:48 -08:00
Hans	df0bf1dd74	chore(internal API): introduce an internal API for ngtools. (#13415 )	2016-12-14 17:51:40 -08:00
Hans	c8a9b70890	fix(compiler): generated CSS files suffixed with ngstyle. (#13353 ) Mirrors factories which ends in `ngfactory`. Closes #13141.	2016-12-14 17:50:29 -08:00
Tobias Bosch	efa2d80df8	fix(compiler): make sure provider values with `name` property don’t break. Fixes #13394 Closes #13445	2016-12-14 17:50:22 -08:00
Victor Berchet	a58e5efd09	test(i18n): fix a typo in the reference xmb (#13441 )	2016-12-14 17:50:12 -08:00
Pawel Kozlowski	86cf0ef892	refactor: remove intl from facades (#13404 ) The existing intl.ts file is not a facade but rather a set of utils used by i18n-related pipes only. As such moving it back to common module so those utils are not used accidently from other places.	2016-12-14 17:50:02 -08:00
Marc Laval	5c568fab86	test(upgrade): fix failing test in browsers which do not support RAF closes #13399	2016-12-14 17:49:52 -08:00
Marc Laval	566104504c	ci(browser providers): update browsers in SL and BS (#13431 )	2016-12-14 17:49:37 -08:00
Chuck Jazdzewski	307d305b2d	fix(compiler): narrow the span reported for invalid pipes fixes #13326 closes #13411	2016-12-14 17:49:05 -08:00
Chuck Jazdzewski	0a7364feea	fix(language-service): correctly type undefined fixes #13412 closes #13414	2016-12-14 17:40:58 -08:00
Victor Berchet	4544b1d7a6	fix(compiler): xmb `<ph>` tags should not self close (#13413 )	2016-12-14 17:39:51 -08:00
Dzmitry Shylovich	9e0e6b59d1	docs(core): update OnDestroy description (#13369 ) Closes #11228	2016-12-14 17:39:45 -08:00
Chuck Jazdzewski	14dd2b367a	fix(language-service): treat string unions as strings (#13406 ) Fixes #13403	2016-12-14 17:39:36 -08:00
Marc Laval	91eb8914dd	build: update the package list of the symlinks scripts for Windows (#13408 )	2016-12-14 17:39:30 -08:00
Victor Berchet	77823d721f	refactor: format and lint code	2016-12-14 17:38:31 -08:00
Misko Hevery	2afe2d107f	docs(Location): updating Location docs and adding example closes #11500	2016-12-14 17:38:22 -08:00
Misko Hevery	17f40fb75f	chore: Add @types/systemjs	2016-12-14 17:37:43 -08:00
Jesús Rodríguez	98936fdf16	chore: convert hash_location_strategy example to a tested spec	2016-12-14 17:37:33 -08:00
Dzmitry Shylovich	7383e4a801	fix(forms): fix Validators.min/maxLength with FormArray (#13095 ) Fixes #13089	2016-12-14 17:37:18 -08:00
Dzmitry Shylovich	65c9b5b6aa	fix(http): create a copy of headers when merge options (#13365 ) Closes #11980	2016-12-14 17:36:48 -08:00
Dzmitry Shylovich	5fab8710cb	fix(dom_adapter): remove logError from logGroup (#12925 )	2016-12-14 17:35:12 -08:00
domusofsail	f106a18b96	fix(http): check response body text against undefined (#13017 )	2016-12-14 17:35:05 -08:00
Victor Berchet	8db184d349	fix(compiler): support dotted property binding fixes angular/flex-layout#34	2016-12-14 17:31:08 -08:00
Victor Berchet	c18eb298eb	test(Selector): add a test for dotted attribute names	2016-12-14 17:31:00 -08:00
Victor Berchet	3f4aa59cfa	refactor(Compiler): cleanup	2016-12-14 17:30:50 -08:00
Victor Berchet	79728b4c41	fix(compiler): fix PR 13322 (#13331 )	2016-12-14 17:30:40 -08:00
Victor Berchet	413167ab1b	style: clang-format the code	2016-12-14 17:26:52 -08:00
Misko Hevery	203cc7e1f1	fix: Better instructions on running examples and their tests	2016-12-14 17:23:11 -08:00
Misko Hevery	b0cd514709	fix: Better error when directive not listed in NgModule.declarations	2016-12-14 17:22:58 -08:00
Dzmitry Shylovich	392c9ac214	fix(selector): SelectorMatcher match elements with :not selector (#12977 )	2016-12-14 17:21:34 -08:00
Matias Niemelä	a26e054857	fix(animations): always cleanup players after they have finished internally (#13334 ) Closes #13333 Closes #13334	2016-12-14 17:21:23 -08:00
Victor Berchet	c0b001a6af	refactor(router): misc refactoring (#13330 )	2016-12-14 17:21:09 -08:00
Victor Berchet	c8c1f22f9c	refactor(router): simplify regexp closes #11373 closes #13329	2016-12-14 17:20:47 -08:00
Andy Howell	e4d5a5f003	fix(router): add support for query params with mulitple values closes #11373	2016-12-14 17:20:22 -08:00
Victor Berchet	03d9de33a1	Revert "fix(compiler): fix transpiled ES5 code (#13322 )" This reverts commit `4398056146`.	2016-12-14 17:20:14 -08:00
Chuck Jazdzewski	a8a80cf523	doc: update triage owners for language service and router (#13325 )	2016-12-14 17:19:50 -08:00
Victor Berchet	6c1d7908d5	fix(compiler): fix transpiled ES5 code (#13322 ) fixes #13301 The inner class would transpile to a nested function declaration which is not allowed in ES5. See http://eslint.org/docs/rules/no-inner-declarations	2016-12-14 17:18:12 -08:00
Victor Berchet	9aab6d24eb	build(tslint): enable no-inner-declarations (#13316 )	2016-12-14 17:18:02 -08:00
Jónatan Núñez	5ee8155e4e	fix(router): Use T type in Resolve interface (#13242 )	2016-12-14 17:17:45 -08:00
Rakhat Jabagin	21de0f239d	docs(changelog): fix a typo (#13298 )	2016-12-14 17:16:49 -08:00